feat: add docker container table (#520)

* WIP On docker integration

* WIP on adding docker support

* WIP on adding docker support

* chore: Add cacheTime parameter to createCacheChannel function

* bugfix: Add node-loader npm dependency for webpack configuration

* revert changes

* chore: Add node-loader npm dependency for webpack configuration

* feat: Add Docker container list to DockerPage

* chore: apply pr suggestions

* fix: fix printing issue using a Date objext

* chore: Update npm dependencies

* feat: Create DockerTable component for displaying Docker container list

* feat: Refactor DockerPage to use DockerTable component

* feat: Refactor DockerPage to use DockerTable component

* feat: Add useTimeAgo hook for displaying relative timestamps

* feat: Add hooks module to common package

* refactor: Update DockerTable component

Include container actions and state badges

* feat: add information about instance for docker containers

* feat: Add OverflowBadge component for displaying overflowed data

* feat: Refactor DockerSingleton to use host and instance properties

This commit refactors the DockerSingleton class in the `docker.ts` file to use the `host` and `instance` properties instead of the previous `key` and `remoteApi` properties. This change improves clarity and consistency in the codebase.

* feat: Add OverflowBadge component for displaying overflowed data

* feat: Improve DockerTable component with Avatar and Name column

This commit enhances the DockerTable component in the `DockerTable.tsx` file by adding an Avatar and Name column. The Avatar column displays an icon based on the Docker container's image, while the Name column shows the container's name. This improvement provides better visual representation and identification of the containers in the table.

* feat: Enhance DockerTable component with Avatar and Name columns

* refactor: improve docker table and icon resolution

* chore: address pull request feedback

* fix: format issues

* chore: add missing translations

* refactor: remove black background

---------

Co-authored-by: Meier Lukas <meierschlumpf@gmail.com>

packages/api/src/root.ts

@@ -1,5 +1,6 @@
 import { appRouter as innerAppRouter } from "./router/app";
 import { boardRouter } from "./router/board";
+import { dockerRouter } from "./router/docker/docker-router";
 import { groupRouter } from "./router/group";
 import { homeRouter } from "./router/home";
 import { iconsRouter } from "./router/icons";
@@ -24,6 +25,7 @@ export const appRouter = createTRPCRouter({
   log: logRouter,
   icon: iconsRouter,
   home: homeRouter,
+  docker: dockerRouter,
   serverSettings: serverSettingsRouter,
 });
 

packages/api/src/router/docker/docker-router.ts

@@ -0,0 +1,84 @@
+import type Docker from "dockerode";
+
+import { db, like, or } from "@homarr/db";
+import { icons } from "@homarr/db/schema/sqlite";
+import type { DockerContainerState } from "@homarr/definitions";
+import { createCacheChannel } from "@homarr/redis";
+
+import { createTRPCRouter, publicProcedure } from "../../trpc";
+import { DockerSingleton } from "./docker-singleton";
+
+const dockerCache = createCacheChannel<{
+  containers: (Docker.ContainerInfo & { instance: string; iconUrl: string | null })[];
+}>("docker-containers", 5 * 60 * 1000);
+
+export const dockerRouter = createTRPCRouter({
+  getContainers: publicProcedure.query(async () => {
+    const { timestamp, data } = await dockerCache.consumeAsync(async () => {
+      const dockerInstances = DockerSingleton.getInstance();
+      const containers = await Promise.all(
+        // Return all the containers of all the instances into only one item
+        dockerInstances.map(({ instance, host: key }) =>
+          instance.listContainers({ all: true }).then((containers) =>
+            containers.map((container) => ({
+              ...container,
+              instance: key,
+            })),
+          ),
+        ),
+      ).then((containers) => containers.flat());
+
+      const extractImage = (container: Docker.ContainerInfo) =>
+        container.Image.split("/").at(-1)?.split(":").at(0) ?? "";
+      const likeQueries = containers.map((container) => like(icons.name, `%${extractImage(container)}%`));
+      const dbIcons =
+        likeQueries.length >= 1
+          ? await db.query.icons.findMany({
+              where: or(...likeQueries),
+            })
+          : [];
+
+      return {
+        containers: containers.map((container) => ({
+          ...container,
+          iconUrl:
+            dbIcons.find((icon) => {
+              const extractedImage = extractImage(container);
+              if (!extractedImage) return false;
+              return icon.name.toLowerCase().includes(extractedImage.toLowerCase());
+            })?.url ?? null,
+        })),
+      };
+    });
+
+    return {
+      containers: sanitizeContainers(data.containers),
+      timestamp,
+    };
+  }),
+});
+
+interface DockerContainer {
+  name: string;
+  id: string;
+  state: DockerContainerState;
+  image: string;
+  ports: Docker.Port[];
+  iconUrl: string | null;
+}
+
+function sanitizeContainers(
+  containers: (Docker.ContainerInfo & { instance: string; iconUrl: string | null })[],
+): DockerContainer[] {
+  return containers.map((container) => {
+    return {
+      name: container.Names[0]?.split("/")[1] || "Unknown",
+      id: container.Id,
+      instance: container.instance,
+      state: container.State as DockerContainerState,
+      image: container.Image,
+      ports: container.Ports,
+      iconUrl: container.iconUrl,
+    };
+  });
+}

packages/api/src/router/docker/docker-singleton.ts

@@ -0,0 +1,50 @@
+import Docker from "dockerode";
+
+interface DockerInstance {
+  host: string;
+  instance: Docker;
+}
+
+export class DockerSingleton {
+  private static instances: DockerInstance[];
+
+  private createInstances() {
+    const instances: DockerInstance[] = [];
+    const hostVariable = process.env.DOCKER_HOST;
+    const portVariable = process.env.DOCKER_PORT;
+    if (hostVariable === undefined || portVariable === undefined) {
+      instances.push({ host: "socket", instance: new Docker() });
+      return instances;
+    }
+    const hosts = hostVariable.split(",");
+    const ports = portVariable.split(",");
+
+    if (hosts.length !== ports.length) {
+      throw new Error("The number of hosts and ports must match");
+    }
+
+    hosts.forEach((host, i) => {
+      instances.push({
+        host: `${host}:${ports[i]}`,
+        instance: new Docker({
+          host,
+          port: parseInt(ports[i] || "", 10),
+        }),
+      });
+      return instances;
+    });
+    return instances;
+  }
+
+  public static findInstance(key: string): DockerInstance | undefined {
+    return this.instances.find((instance) => instance.host === key);
+  }
+
+  public static getInstance(): DockerInstance[] {
+    if (!DockerSingleton.instances) {
+      DockerSingleton.instances = new DockerSingleton().createInstances();
+    }
+
+    return this.instances;
+  }
+}