Merge pull request #448 from jameswynn/kubernetes

Support for Kubernetes and Longhorn

src/components/services/item.jsx

@@ -4,8 +4,10 @@ import { useContext, useState } from "react";
 import Status from "./status";
 import Widget from "./widget";
 import Ping from "./ping";
+import KubernetesStatus from "./kubernetes-status";
 
 import Docker from "widgets/docker/component";
+import Kubernetes from "widgets/kubernetes/component";
 import { SettingsContext } from "utils/contexts/settings";
 import ResolvedIcon from "components/resolvedicon";
 
@@ -89,6 +91,16 @@ export default function Item({ service }) {
                   <span className="sr-only">View container stats</span>
                 </button>
               )}
+              {service.app && (
+                <button
+                  type="button"
+                  onClick={() => (statsOpen ? closeStats() : setStatsOpen(true))}
+                  className="flex-shrink-0 flex items-center justify-center cursor-pointer"
+                >
+                  <KubernetesStatus service={service} />
+                  <span className="sr-only">View container stats</span>
+                </button>
+              )}
           </div>
         </div>
 
@@ -102,6 +114,16 @@ export default function Item({ service }) {
             {statsOpen && <Docker service={{ widget: { container: service.container, server: service.server } }} />}
           </div>
         )}
+        {service.app && (
+          <div
+            className={classNames(
+              statsOpen && !statsClosing ? "max-h-[55px] opacity-100" : " max-h-[0] opacity-0",
+              "w-full overflow-hidden transition-all duration-300 ease-in-out"
+            )}
+          >
+            {statsOpen && <Kubernetes service={{ widget: { namespace: service.namespace, app: service.app, podSelector: service.podSelector } }} />}
+          </div>
+        )}
 
         {service.widget && <Widget service={service} />}
       </div>

src/components/services/kubernetes-status.jsx

@@ -0,0 +1,35 @@
+import useSWR from "swr";
+import { t } from "i18next";
+
+export default function KubernetesStatus({ service }) {
+  const podSelectorString = service.podSelector !== undefined ? `podSelector=${service.podSelector}` : "";
+  const { data, error } = useSWR(`/api/kubernetes/status/${service.namespace}/${service.app}?${podSelectorString}`);
+
+  if (error) {
+    <div className="w-auto px-1.5 py-0.5 text-center bg-theme-500/10 dark:bg-theme-900/50 rounded-b-[3px] overflow-hidden" title={data.status}>
+      <div className="text-[8px] font-bold text-rose-500/80 uppercase">{t("docker.error")}</div>
+    </div>
+  }
+
+  if (data && data.status === "running") {
+    return (
+      <div className="w-auto px-1.5 py-0.5 text-center bg-theme-500/10 dark:bg-theme-900/50 rounded-b-[3px] overflow-hidden" title={data.health ?? data.status}>
+        <div className="text-[8px] font-bold text-emerald-500/80 uppercase">{data.health ?? data.status}</div>
+      </div>
+    );
+  }
+
+  if (data && (data.status === "not found" || data.status === "down" || data.status === "partial")) {
+    return (
+      <div className="w-auto px-1.5 py-0.5 text-center bg-theme-500/10 dark:bg-theme-900/50 rounded-b-[3px] overflow-hidden" title={data.status}>
+        <div className="text-[8px] font-bold text-orange-400/50 dark:text-orange-400/80 uppercase">{data.status}</div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="w-auto px-1.5 py-0.5 text-center bg-theme-500/10 dark:bg-theme-900/50 rounded-b-[3px] overflow-hidden">
+      <div className="text-[8px] font-bold text-black/20 dark:text-white/40 uppercase">{t("docker.unknown")}</div>
+    </div>
+  );
+}

src/components/widgets/kubernetes/kubernetes.jsx

@@ -0,0 +1,74 @@
+import useSWR from "swr";
+import { BiError } from "react-icons/bi";
+import { useTranslation } from "next-i18next";
+
+import Node from "./node";
+
+export default function Widget({ options }) {
+  const { cluster, nodes } = options;
+  const { t, i18n } = useTranslation();
+
+  const defaultData = {
+    cpu: {
+      load: 0,
+      total: 0,
+      percent: 0
+    },
+    memory: {
+      used: 0,
+      total: 0,
+      free: 0,
+      precent: 0
+    }
+  };
+
+  const { data, error } = useSWR(
+    `/api/widgets/kubernetes?${new URLSearchParams({ lang: i18n.language }).toString()}`, {
+      refreshInterval: 1500
+    }
+  );
+
+  if (error || data?.error) {
+    return (
+      <div className="flex flex-col justify-center first:ml-0 ml-4">
+        <div className="flex flex-row items-center justify-end">
+          <div className="flex flex-row items-center">
+            <BiError className="w-8 h-8 text-theme-800 dark:text-theme-200" />
+            <div className="flex flex-col ml-3 text-left">
+              <span className="text-theme-800 dark:text-theme-200 text-sm">{t("widget.api_error")}</span>
+            </div>
+          </div>
+        </div>
+      </div>
+    );
+  }
+
+  if (!data) {
+    return (
+      <div className="flex flex-col max-w:full sm:basis-auto self-center grow-0 flex-wrap">
+        <div className="flex flex-row self-center flex-wrap justify-between">
+          {cluster.show &&
+            <Node type="cluster" key="cluster" options={options.cluster} data={defaultData} />
+          }
+          {nodes.show &&
+            <Node type="node" key="nodes" options={options.nodes} data={defaultData} />
+          }
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="flex flex-col max-w:full sm:basis-auto self-center grow-0 flex-wrap">
+      <div className="flex flex-row self-center flex-wrap justify-between">
+        {cluster.show &&
+          <Node key="cluster" type="cluster" options={options.cluster} data={data.cluster} />
+        }
+        {nodes.show && data.nodes &&
+          data.nodes.map((node) =>
+            <Node key={node.name} type="node" options={options.nodes} data={node} />)
+        }
+      </div>
+    </div>
+  );
+}

src/components/widgets/kubernetes/node.jsx

@@ -0,0 +1,60 @@
+import { FaMemory } from "react-icons/fa";
+import { FiAlertTriangle, FiCpu, FiServer } from "react-icons/fi";
+import { SiKubernetes } from "react-icons/si";
+import { useTranslation } from "next-i18next";
+
+import UsageBar from "./usage-bar";
+
+
+export default function Node({ type, options, data }) {
+  const { t } = useTranslation();
+
+
+  function icon() {
+    if (type === "cluster") {
+      return <SiKubernetes className="text-theme-800 dark:text-theme-200 w-5 h-5" />;
+    }
+    if (data.ready) {
+      return <FiServer className="text-theme-800 dark:text-theme-200 w-5 h-5" />;
+    }
+    return <FiAlertTriangle className="text-theme-800 dark:text-theme-200 w-5 h-5" />;
+  }
+
+  return (
+    <div className="flex flex-col max-w:full sm:basis-auto self-center grow-0 flex-wrap ml-4">
+      <div className="flex flex-row self-center flex-wrap justify-between">
+        <div className="flex-none flex flex-row items-center mr-3 py-1.5">
+          {icon()}
+          <div className="flex flex-col ml-3 text-left min-w-[85px]">
+            <div className="text-theme-800 dark:text-theme-200 text-xs flex flex-row justify-between">
+              <div className="pl-0.5">
+                {t("common.number", {
+                  value: data.cpu.percent,
+                  style: "unit",
+                  unit: "percent",
+                  maximumFractionDigits: 0
+                })}
+              </div>
+              <FiCpu className="text-theme-800 dark:text-theme-200 w-3 h-3" />
+            </div>
+            <UsageBar percent={data.cpu.percent} />
+            <div className="text-theme-800 dark:text-theme-200 text-xs flex flex-row justify-between">
+              <div className="pl-0.5">
+                {t("common.bytes", {
+                  value: data.memory.free,
+                  maximumFractionDigits: 0,
+                  binary: true
+                })}
+              </div>
+              <FaMemory className="text-theme-800 dark:text-theme-200 w-3 h-3" />
+            </div>
+            <UsageBar percent={data.memory.percent} />
+            {options.showLabel && (
+              <div className="pt-1 text-center text-theme-800 dark:text-theme-200 text-xs">{type === "cluster" ? options.label : data.name}</div>
+            )}
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}

src/components/widgets/kubernetes/usage-bar.jsx

@@ -0,0 +1,12 @@
+export default function UsageBar({ percent }) {
+  return (
+    <div className="mt-0.5 w-full bg-theme-800/30 rounded-full h-1 dark:bg-theme-200/20">
+      <div
+        className="bg-theme-800/70 h-1 rounded-full dark:bg-theme-200/50 transition-all duration-1000"
+        style={{
+          width: `${percent}%`,
+        }}
+      />
+    </div>
+  );
+}

src/components/widgets/longhorn/longhorn.jsx

@@ -0,0 +1,57 @@
+import useSWR from "swr";
+import { BiError } from "react-icons/bi";
+import { useTranslation } from "next-i18next";
+
+import Node from "./node";
+
+export default function Longhorn({ options }) {
+  const { expanded, total, labels, include, nodes } = options;
+  const { t } = useTranslation();
+  const { data, error } = useSWR(`/api/widgets/longhorn`, {
+    refreshInterval: 1500
+  });
+
+  if (error || data?.error) {
+    return (
+      <div className="flex flex-col max-w:full sm:basis-auto self-center grow-0 flex-wrap">
+        <BiError className="text-theme-800 dark:text-theme-200 w-5 h-5" />
+        <div className="flex flex-col ml-3 text-left">
+          <span className="text-theme-800 dark:text-theme-200 text-xs">{t("widget.api_error")}</span>
+        </div>
+      </div>
+    );
+  }
+
+  if (!data) {
+    return (
+      <div className="flex flex-col max-w:full sm:basis-auto self-center grow-0 flex-wrap">
+        <div className="flex flex-row self-center flex-wrap justify-between" />
+      </div>
+    );
+  }
+
+  return (
+    <div className="flex flex-col max-w:full sm:basis-auto self-center grow-0 flex-wrap">
+      <div className="flex flex-row self-center flex-wrap justify-between">
+        {data.nodes
+          .filter((node) => {
+            if (node.id === 'total' && total) {
+              return true;
+            }
+            if (!nodes) {
+              return false;
+            }
+            if (include && !include.includes(node.id)) {
+              return false;
+            }
+            return true;
+          })
+          .map((node) =>
+            <div key={node.id}>
+              <Node data={{ node }} expanded={expanded} labels={labels} />
+            </div>
+          )}
+      </div>
+    </div>
+  );
+}

src/components/widgets/longhorn/node.jsx

@@ -0,0 +1,32 @@
+import { FiHardDrive } from "react-icons/fi";
+import { useTranslation } from "next-i18next";
+
+import UsageBar from "../resources/usage-bar";
+
+export default function Node({ data, expanded, labels }) {
+  const { t } = useTranslation();
+
+  return (
+    <>
+      <div className="flex-none flex flex-row items-center mr-3 py-1.5">
+        <FiHardDrive className="text-theme-800 dark:text-theme-200 w-5 h-5" />
+        <div className="flex flex-col ml-3 text-left min-w-[85px]">
+        <span className="text-theme-800 dark:text-theme-200 text-xs flex flex-row justify-between">
+          <div className="pl-0.5">{t("common.bytes", { value: data.node.available })}</div>
+          <div className="pr-1">{t("resources.free")}</div>
+        </span>
+          {expanded && (
+            <span className="text-theme-800 dark:text-theme-200 text-xs flex flex-row justify-between">
+            <div className="pl-0.5">{t("common.bytes", { value: data.node.maximum })}</div>
+            <div className="pr-1">{t("resources.total")}</div>
+          </span>
+          )}
+          <UsageBar percent={Math.round(((data.node.maximum - data.node.available) / data.node.maximum) * 100)} />
+        </div>
+      </div>
+      {labels && (
+        <div className="ml-6 pt-1 text-center text-theme-800 dark:text-theme-200 text-xs">{data.node.id}</div>
+      )}
+    </>
+  );
+}

src/components/widgets/widget.jsx

@@ -13,6 +13,8 @@ const widgetMappings = {
   unifi_console: dynamic(() => import("components/widgets/unifi_console/unifi_console")),
   glances: dynamic(() => import("components/widgets/glances/glances")),
   openmeteo: dynamic(() => import("components/widgets/openmeteo/openmeteo")),
+  longhorn: dynamic(() => import("components/widgets/longhorn/longhorn")),
+  kubernetes: dynamic(() => import("components/widgets/kubernetes/kubernetes")),
 };
 
 export default function Widget({ widget }) {

src/pages/api/kubernetes/stats/[...service].js

@@ -0,0 +1,110 @@
+import { CoreV1Api, Metrics } from "@kubernetes/client-node";
+
+import getKubeConfig from "../../../../utils/config/kubernetes";
+import { parseCpu, parseMemory } from "../../../../utils/kubernetes/kubernetes-utils";
+import createLogger from "../../../../utils/logger";
+
+const logger = createLogger("kubernetesStatsService");
+
+export default async function handler(req, res) {
+  const APP_LABEL = "app.kubernetes.io/name";
+  const { service, podSelector } = req.query;
+
+  const [namespace, appName] = service;
+  if (!namespace && !appName) {
+    res.status(400).send({
+      error: "kubernetes query parameters are required"
+    });
+    return;
+  }
+  const labelSelector = podSelector !== undefined ? podSelector : `${APP_LABEL}=${appName}`;
+
+  try {
+    const kc = getKubeConfig();
+    if (!kc) {
+      res.status(500).send({
+        error: "No kubernetes configuration"
+      });
+      return;
+    }
+    const coreApi = kc.makeApiClient(CoreV1Api);
+    const metricsApi = new Metrics(kc);
+    const podsResponse = await coreApi.listNamespacedPod(namespace, null, null, null, null, labelSelector)
+      .then((response) => response.body)
+      .catch((err) => {
+        logger.error("Error getting pods: %d %s %s", err.statusCode, err.body, err.response);
+        return null;
+      });
+    if (!podsResponse) {
+      res.status(500).send({
+        error: "Error communicating with kubernetes"
+      });
+      return;
+    }
+    const pods = podsResponse.items;
+
+    if (pods.length === 0) {
+      res.status(404).send({
+        error: "not found"
+      });
+      return;
+    }
+
+    let cpuLimit = 0;
+    let memLimit = 0;
+    pods.forEach((pod) => {
+      pod.spec.containers.forEach((container) => {
+        if (container?.resources?.limits?.cpu) {
+          cpuLimit += parseCpu(container?.resources?.limits?.cpu);
+        }
+        if (container?.resources?.limits?.memory) {
+          memLimit += parseMemory(container?.resources?.limits?.memory);
+        }
+      });
+    });
+
+    const podStatsList = await Promise.all(pods.map(async (pod) => {
+      let depMem = 0;
+      let depCpu = 0;
+      const podMetrics = await metricsApi.getPodMetrics(namespace, pod.metadata.name)
+        .then((response) => response)
+        .catch((err) => {
+          // 404 generally means that the metrics have not been populated yet
+          if (err.statusCode !== 404) {
+            logger.error("Error getting pod metrics: %d %s %s", err.statusCode, err.body, err.response);
+          }
+          return null;
+        });
+      if (podMetrics) {
+        podMetrics.containers.forEach((container) => {
+          depMem += parseMemory(container.usage.memory);
+          depCpu += parseCpu(container.usage.cpu);
+        });
+      }
+      return {
+        mem: depMem,
+        cpu: depCpu
+      };
+    }));
+    const stats = {
+      mem: 0,
+      cpu: 0
+    }
+    podStatsList.forEach((podStat) => {
+      stats.mem += podStat.mem;
+      stats.cpu += podStat.cpu;
+    });
+    stats.cpuLimit = cpuLimit;
+    stats.memLimit = memLimit;
+    stats.cpuUsage = cpuLimit ? stats.cpu / cpuLimit : 0;
+    stats.memUsage = memLimit ? stats.mem / memLimit : 0;
+    res.status(200).json({
+      stats
+    });
+  } catch (e) {
+    logger.error(e);
+    res.status(500).send({
+      error: "unknown error"
+    });
+  }
+}

src/pages/api/kubernetes/status/[...service].js

@@ -0,0 +1,66 @@
+import { CoreV1Api } from "@kubernetes/client-node";
+
+import getKubeConfig from "../../../../utils/config/kubernetes";
+import createLogger from "../../../../utils/logger";
+
+const logger = createLogger("kubernetesStatusService");
+
+export default async function handler(req, res) {
+  const APP_LABEL =  "app.kubernetes.io/name";
+  const { service, podSelector } = req.query;
+
+  const [namespace, appName] = service;
+  if (!namespace && !appName) {
+    res.status(400).send({
+      error: "kubernetes query parameters are required",
+    });
+    return;
+  }
+  const labelSelector = podSelector !== undefined ? podSelector : `${APP_LABEL}=${appName}`;
+  try {
+    const kc = getKubeConfig();
+    if (!kc) {
+      res.status(500).send({
+        error: "No kubernetes configuration"
+      });
+      return;
+    }
+    const coreApi = kc.makeApiClient(CoreV1Api);
+    const podsResponse = await coreApi.listNamespacedPod(namespace, null, null, null, null, labelSelector)
+      .then((response) => response.body)
+      .catch((err) => {
+        logger.error("Error getting pods: %d %s %s", err.statusCode, err.body, err.response);
+        return null;
+      });
+    if (!podsResponse) {
+      res.status(500).send({
+        error: "Error communicating with kubernetes"
+      });
+      return;
+    }
+    const pods = podsResponse.items;
+
+    if (pods.length === 0) {
+      res.status(404).send({
+        error: "not found",
+      });
+      return;
+    }
+    const someReady = pods.find(pod => pod.status.phase === "Running");
+    const allReady = pods.every((pod) => pod.status.phase === "Running");
+    let status = "down";
+    if (allReady) {
+      status = "running";
+    } else if (someReady) {
+      status = "partial";
+    }
+    res.status(200).json({
+      status
+    });
+  } catch (e) {
+    logger.error(e);
+    res.status(500).send({
+      error: "unknown error",
+    });
+  }
+}

src/pages/api/widgets/kubernetes.js

@@ -0,0 +1,92 @@
+import { CoreV1Api, Metrics } from "@kubernetes/client-node";
+
+import getKubeConfig from "../../../utils/config/kubernetes";
+import { parseCpu, parseMemory } from "../../../utils/kubernetes/kubernetes-utils";
+import createLogger from "../../../utils/logger";
+
+const logger = createLogger("kubernetes-widget");
+
+export default async function handler(req, res) {
+  try {
+    const kc = getKubeConfig();
+    if (!kc) {
+      return res.status(500).send({
+        error: "No kubernetes configuration"
+      });
+    }
+    const coreApi = kc.makeApiClient(CoreV1Api);
+    const metricsApi = new Metrics(kc);
+
+    const nodes = await coreApi.listNode()
+      .then((response) => response.body)
+      .catch((error) => {
+        logger.error("Error getting ingresses: %d %s %s", error.statusCode, error.body, error.response);
+        return null;
+      });
+    if (!nodes) {
+      return res.status(500).send({
+        error: "unknown error"
+      });
+    }
+    let cpuTotal = 0;
+    let cpuUsage = 0;
+    let memTotal = 0;
+    let memUsage = 0;
+
+    const nodeMap = {};
+    nodes.items.forEach((node) => {
+      const cpu = Number.parseInt(node.status.capacity.cpu, 10);
+      const mem = parseMemory(node.status.capacity.memory);
+      const ready = node.status.conditions.filter(condition => condition.type === "Ready" && condition.status === "True").length > 0;
+      nodeMap[node.metadata.name] = {
+        name: node.metadata.name,
+        ready,
+        cpu: {
+          total: cpu
+        },
+        memory: {
+          total: mem
+        }
+      };
+      cpuTotal += cpu;
+      memTotal += mem;
+    });
+
+    const nodeMetrics = await metricsApi.getNodeMetrics();
+    nodeMetrics.items.forEach((nodeMetric) => {
+      const cpu = parseCpu(nodeMetric.usage.cpu);
+      const mem = parseMemory(nodeMetric.usage.memory);
+      cpuUsage += cpu;
+      memUsage += mem;
+      nodeMap[nodeMetric.metadata.name].cpu.load = cpu;
+      nodeMap[nodeMetric.metadata.name].cpu.percent = (cpu / nodeMap[nodeMetric.metadata.name].cpu.total) * 100;
+      nodeMap[nodeMetric.metadata.name].memory.used = mem;
+      nodeMap[nodeMetric.metadata.name].memory.free = nodeMap[nodeMetric.metadata.name].memory.total - mem;
+      nodeMap[nodeMetric.metadata.name].memory.percent = (mem / nodeMap[nodeMetric.metadata.name].memory.total) * 100;
+    });
+
+    const cluster = {
+      cpu: {
+        load: cpuUsage,
+        total: cpuTotal,
+        percent: (cpuUsage / cpuTotal) * 100
+      },
+      memory: {
+        used: memUsage,
+        total: memTotal,
+        free: (memTotal - memUsage),
+        percent: (memUsage / memTotal) * 100
+      }
+    };
+
+    return res.status(200).json({
+      cluster,
+      nodes: Object.entries(nodeMap).map(([name, node]) => ({ name, ...node }))
+    });
+  } catch (e) {
+    logger.error("exception %s", e);
+    return res.status(500).send({
+      error: "unknown error"
+    });
+  }
+}

src/pages/api/widgets/longhorn.js

@@ -0,0 +1,84 @@
+import { httpProxy } from "../../../utils/proxy/http";
+import createLogger from "../../../utils/logger";
+import { getSettings } from "../../../utils/config/config";
+
+const logger = createLogger("longhorn");
+
+function parseLonghornData(data) {
+  const json = JSON.parse(data);
+
+  if (!json) {
+    return null;
+  }
+
+  const nodes = json.data.map((node) => {
+    let available = 0;
+    let maximum = 0;
+    let reserved = 0;
+    let scheduled = 0;
+    if (node.disks) {
+      Object.keys(node.disks).forEach((diskKey) => {
+        const disk = node.disks[diskKey];
+        available += disk.storageAvailable;
+        maximum += disk.storageMaximum;
+        reserved += disk.storageReserved;
+        scheduled += disk.storageScheduled;
+      });
+    }
+    return {
+      id: node.id,
+      available,
+      maximum,
+      reserved,
+      scheduled,
+    };
+  });
+  const total = nodes.reduce((summary, node) => ({
+    available: summary.available + node.available,
+    maximum: summary.maximum + node.maximum,
+    reserved: summary.reserved + node.reserved,
+    scheduled: summary.scheduled + node.scheduled,
+  }));
+  total.id = "total";
+  nodes.push(total);
+  return nodes;
+}
+
+export default async function handler(req, res) {
+  const settings = getSettings();
+  const longhornSettings = settings?.providers?.longhorn;
+  const {url, username, password} = longhornSettings;
+
+  if (!url) {
+    const errorMessage = "Missing Longhorn URL";
+    logger.error(errorMessage);
+    return res.status(400).json({ error: errorMessage });
+  }
+
+  const apiUrl = `${url}/v1/nodes`;
+  const headers = {
+    "Accept-Encoding": "application/json"
+  };
+  if (username && password) {
+    headers.Authorization = `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`
+  }
+  const params = { method: "GET", headers };
+
+  const [status, contentType, data] = await httpProxy(apiUrl, params);
+
+  if (status === 401) {
+    logger.error("Authorization failure getting data from Longhorn API. Data: %s", data);
+  }
+
+  if (status !== 200) {
+    logger.error("HTTP %d getting data from Longhorn API. Data: %s", status, data);
+  }
+
+  if (contentType) res.setHeader("Content-Type", contentType);
+
+  const nodes = parseLonghornData(data);
+
+  return res.status(200).json({
+    nodes,
+  });
+}

src/skeleton/kubernetes.yaml

@@ -0,0 +1,2 @@
+---
+# sample kubernetes config

src/utils/config/api-response.js

@@ -5,7 +5,12 @@ import path from "path";
 import yaml from "js-yaml";
 
 import checkAndCopyConfig, { getSettings } from "utils/config/config";
-import { servicesFromConfig, servicesFromDocker, cleanServiceGroups } from "utils/config/service-helpers";
+import {
+  servicesFromConfig,
+  servicesFromDocker,
+  cleanServiceGroups,
+  servicesFromKubernetes
+} from "utils/config/service-helpers";
 import { cleanWidgetGroups, widgetsFromConfig } from "utils/config/widget-helpers";
 
 export async function bookmarksResponse() {
@@ -44,19 +49,28 @@ export async function widgetsResponse() {
 }
 
 export async function servicesResponse() {
-  let discoveredServices;
+  let discoveredDockerServices;
+  let discoveredKubernetesServices;
   let configuredServices;
   let initialSettings;
 
   try {
-    discoveredServices = cleanServiceGroups(await servicesFromDocker());
-    if (discoveredServices?.length === 0) {
+    discoveredDockerServices = cleanServiceGroups(await servicesFromDocker());
+    if (discoveredDockerServices?.length === 0) {
       console.debug("No containers were found with homepage labels.");
     }
   } catch (e) {
     console.error("Failed to discover services, please check docker.yaml for errors or remove example entries.");
     if (e) console.error(e.toString());
-    discoveredServices = [];
+    discoveredDockerServices = [];
+  }
+
+  try {
+    discoveredKubernetesServices = cleanServiceGroups(await servicesFromKubernetes());
+  } catch (e) {
+    console.error("Failed to discover services, please check kubernetes.yaml for errors or remove example entries.");
+    if (e) console.error(e.toString());
+    discoveredKubernetesServices = [];
   }
 
   try {
@@ -76,7 +90,11 @@ export async function servicesResponse() {
   }
 
   const mergedGroupsNames = [
-    ...new Set([discoveredServices.map((group) => group.name), configuredServices.map((group) => group.name)].flat()),
+    ...new Set([
+      discoveredDockerServices.map((group) => group.name),
+      discoveredKubernetesServices.map((group) => group.name),
+      configuredServices.map((group) => group.name),
+    ].flat()),
   ];
 
   const sortedGroups = [];
@@ -84,12 +102,17 @@ export async function servicesResponse() {
   const definedLayouts = initialSettings.layout ? Object.keys(initialSettings.layout) : null;
 
   mergedGroupsNames.forEach((groupName) => {
-    const discoveredGroup = discoveredServices.find((group) => group.name === groupName) || { services: [] };
+    const discoveredDockerGroup = discoveredDockerServices.find((group) => group.name === groupName) || { services: [] };
+    const discoveredKubernetesGroup = discoveredKubernetesServices.find((group) => group.name === groupName) || { services: [] };
     const configuredGroup = configuredServices.find((group) => group.name === groupName) || { services: [] };
 
     const mergedGroup = {
       name: groupName,
-      services: [...discoveredGroup.services, ...configuredGroup.services].filter((service) => service),
+      services: [
+        ...discoveredDockerGroup.services,
+        ...discoveredKubernetesGroup.services,
+        ...configuredGroup.services
+      ].filter((service) => service),
     };
 
     if (definedLayouts) {

src/utils/config/kubernetes.js

@@ -0,0 +1,30 @@
+import path from "path";
+import { readFileSync } from "fs";
+
+import yaml from "js-yaml";
+import { KubeConfig } from "@kubernetes/client-node";
+
+import checkAndCopyConfig from "utils/config/config";
+
+export default function getKubeConfig() {
+  checkAndCopyConfig("kubernetes.yaml");
+
+  const configFile = path.join(process.cwd(), "config", "kubernetes.yaml");
+  const configData = readFileSync(configFile, "utf8");
+  const config = yaml.load(configData);
+  const kc = new KubeConfig();
+
+  switch (config?.mode) {
+    case 'cluster':
+      kc.loadFromCluster();
+      break;
+    case 'default':
+      kc.loadFromDefault();
+      break;
+    case 'disabled':
+    default:
+      return null;
+  }
+
+  return kc;
+}

src/utils/config/service-helpers.js

@@ -4,9 +4,14 @@ import path from "path";
 import yaml from "js-yaml";
 import Docker from "dockerode";
 import * as shvl from "shvl";
+import { NetworkingV1Api } from "@kubernetes/client-node";
 
+import createLogger from "utils/logger";
 import checkAndCopyConfig from "utils/config/config";
 import getDockerArguments from "utils/config/docker";
+import getKubeConfig from "utils/config/kubernetes";
+
+const logger = createLogger("service-helpers");
 
 export async function servicesFromConfig() {
   checkAndCopyConfig("services.yaml");
@@ -108,6 +113,89 @@ export async function servicesFromDocker() {
   return mappedServiceGroups;
 }
 
+function getUrlFromIngress(ingress) {
+  const urlHost = ingress.spec.rules[0].host;
+  const urlPath = ingress.spec.rules[0].http.paths[0].path;
+  const urlSchema = ingress.spec.tls ? 'https' : 'http';
+  return `${urlSchema}://${urlHost}${urlPath}`;
+}
+
+export async function servicesFromKubernetes() {
+  const ANNOTATION_BASE = 'gethomepage.dev';
+  const ANNOTATION_WIDGET_BASE = `${ANNOTATION_BASE}/widget.`;
+  const ANNOTATION_POD_SELECTOR = `${ANNOTATION_BASE}/pod-selector`;
+
+  checkAndCopyConfig("kubernetes.yaml");
+
+  try {
+    const kc = getKubeConfig();
+    if (!kc) {
+      return [];
+    }
+    const networking = kc.makeApiClient(NetworkingV1Api);
+
+    const ingressList = await networking.listIngressForAllNamespaces(null, null, null, null)
+      .then((response) => response.body)
+      .catch((error) => {
+        logger.error("Error getting ingresses: %d %s %s", error.statusCode, error.body, error.response);
+        return null;
+      });
+    if (!ingressList) {
+      return [];
+    }
+    const services = ingressList.items
+      .filter((ingress) => ingress.metadata.annotations && ingress.metadata.annotations[`${ANNOTATION_BASE}/enabled`] === 'true')
+      .map((ingress) => {
+      const constructedService = {
+        app: ingress.metadata.name,
+        namespace: ingress.metadata.namespace,
+        href: ingress.metadata.annotations[`${ANNOTATION_BASE}/href`] || getUrlFromIngress(ingress),
+        name: ingress.metadata.annotations[`${ANNOTATION_BASE}/name`] || ingress.metadata.name,
+        group: ingress.metadata.annotations[`${ANNOTATION_BASE}/group`] || "Kubernetes",
+        icon: ingress.metadata.annotations[`${ANNOTATION_BASE}/icon`] || '',
+        description: ingress.metadata.annotations[`${ANNOTATION_BASE}/description`] || '',
+      };
+      if (ingress.metadata.annotations[ANNOTATION_POD_SELECTOR]) {
+        constructedService.podSelector = ingress.metadata.annotations[ANNOTATION_POD_SELECTOR];
+      }
+      Object.keys(ingress.metadata.annotations).forEach((annotation) => {
+        if (annotation.startsWith(ANNOTATION_WIDGET_BASE)) {
+          shvl.set(constructedService, annotation.replace(`${ANNOTATION_BASE}/`, ""), ingress.metadata.annotations[annotation]);
+        }
+      });
+
+      return constructedService;
+    });
+
+    const mappedServiceGroups = [];
+
+    services.forEach((serverService) => {
+      let serverGroup = mappedServiceGroups.find((searchedGroup) => searchedGroup.name === serverService.group);
+      if (!serverGroup) {
+        mappedServiceGroups.push({
+          name: serverService.group,
+          services: [],
+        });
+        serverGroup = mappedServiceGroups[mappedServiceGroups.length - 1];
+      }
+
+      const { name: serviceName, group: serverServiceGroup, ...pushedService } = serverService;
+      const result = {
+        name: serviceName,
+        ...pushedService,
+      };
+
+      serverGroup.services.push(result);
+    });
+
+    return mappedServiceGroups;
+
+  } catch (e) {
+    logger.error(e);
+    throw e;
+  }
+}
+
 export function cleanServiceGroups(groups) {
   return groups.map((serviceGroup) => ({
     name: serviceGroup.name,
@@ -123,7 +211,10 @@ export function cleanServiceGroups(groups) {
           container,
           currency, // coinmarketcap widget
           symbols,
-          defaultinterval
+          defaultinterval,
+          namespace, // kubernetes widget
+          app,
+          podSelector
         } = cleanedService.widget;
 
         cleanedService.widget = {
@@ -141,6 +232,11 @@ export function cleanServiceGroups(groups) {
           if (server) cleanedService.widget.server = server;
           if (container) cleanedService.widget.container = container;
         }
+        if (type === "kubernetes") {
+          if (namespace) cleanedService.widget.namespace = namespace;
+          if (app) cleanedService.widget.app = app;
+          if (podSelector) cleanedService.widget.podSelector = podSelector;
+        }
       }
 
       return cleanedService;
@@ -171,5 +267,15 @@ export default async function getServiceWidget(group, service) {
     }
   }
 
+  const kubernetesServices = await servicesFromKubernetes();
+  const kubernetesServiceGroup = kubernetesServices.find((g) => g.name === group);
+  if (kubernetesServiceGroup) {
+    const kubernetesServiceEntry = kubernetesServiceGroup.services.find((s) => s.name === service);
+    if (kubernetesServiceEntry) {
+      const { widget } = kubernetesServiceEntry;
+      return widget;
+    }
+  }
+
   return false;
-}
+}

src/utils/kubernetes/kubernetes-utils.js

@@ -0,0 +1,45 @@
+export function parseCpu(cpuStr) {
+  const unitLength = 1;
+  const base = Number.parseInt(cpuStr, 10);
+  const units = cpuStr.substring(cpuStr.length - unitLength);
+  if (Number.isNaN(Number(units))) {
+    switch (units) {
+      case 'n':
+        return base / 1000000000;
+      case 'u':
+        return base / 1000000;
+      case 'm':
+        return base / 1000;
+      default:
+        return base;
+    }
+  } else {
+    return Number.parseInt(cpuStr, 10);
+  }
+}
+
+export function parseMemory(memStr) {
+  const unitLength = (memStr.substring(memStr.length - 1) === 'i' ? 2 : 1);
+  const base = Number.parseInt(memStr, 10);
+  const units = memStr.substring(memStr.length - unitLength);
+  if (Number.isNaN(Number(units))) {
+    switch (units) {
+      case 'Ki':
+        return base * 1000;
+      case 'K':
+        return base * 1024;
+      case 'Mi':
+        return base * 1000000;
+      case 'M':
+        return base * 1024 * 1024;
+      case 'Gi':
+        return base * 1000000000;
+      case 'G':
+        return base * 1024 * 1024 * 1024;
+      default:
+        return base;
+    }
+  } else {
+    return Number.parseInt(memStr, 10);
+  }
+}

src/widgets/components.js

@@ -10,6 +10,7 @@ const components = {
   deluge: dynamic(() => import("./deluge/component")),
   downloadstation: dynamic(() => import("./downloadstation/component")),
   docker: dynamic(() => import("./docker/component")),
+  kubernetes: dynamic(() => import("./kubernetes/component")),
   emby: dynamic(() => import("./emby/component")),
   flood: dynamic(() => import("./flood/component")),
   gluetun: dynamic(() => import("./gluetun/component")),

src/widgets/kubernetes/component.jsx

@@ -0,0 +1,50 @@
+import useSWR from "swr";
+import { useTranslation } from "next-i18next";
+
+import Container from "components/services/widget/container";
+import Block from "components/services/widget/block";
+
+export default function Component({ service }) {
+  const { t } = useTranslation();
+
+  const { widget } = service;
+  const podSelectorString = widget.podSelector !== undefined ? `podSelector=${widget.podSelector}` : "";
+  const { data: statusData, error: statusError } = useSWR(
+    `/api/kubernetes/status/${widget.namespace}/${widget.app}?${podSelectorString}`);
+
+  const { data: statsData, error: statsError } = useSWR(
+    `/api/kubernetes/stats/${widget.namespace}/${widget.app}?${podSelectorString}`);
+
+  if (statsError || statusError) {
+    return <Container error={t("widget.api_error")} />;
+  }
+
+  if (statusData && statusData.status !== "running") {
+    return (
+      <Container>
+        <Block label={t("widget.status")} value={t("docker.offline")} />
+      </Container>
+    );
+  }
+
+  if (!statsData || !statusData) {
+    return (
+      <Container service={service}>
+        <Block label="docker.cpu" />
+        <Block label="docker.mem" />
+      </Container>
+    );
+  }
+
+  return (
+    <Container service={service}>
+      {statsData.stats.cpuLimit && (
+        <Block label="docker.cpu" value={t("common.percent", { value: statsData.stats.cpuUsage })} />
+      ) || (
+        <Block label="docker.cpu" value={t("common.number", { value: statsData.stats.cpu, maximumFractionDigits: 4 })}
+        />
+      )}
+      <Block label="docker.mem" value={t("common.bytes", { value: statsData.stats.mem })} />
+    </Container>
+  );
+}