further restructuring

src/utils/config/api-response.js

@@ -4,8 +4,8 @@ import path from "path";
 
 import yaml from "js-yaml";
 
-import checkAndCopyConfig from "utils/config";
-import { servicesFromConfig, servicesFromDocker, cleanServiceGroups } from "utils/service-helpers";
+import checkAndCopyConfig from "utils/config/config";
+import { servicesFromConfig, servicesFromDocker, cleanServiceGroups } from "utils/config/service-helpers";
 
 export async function bookmarksResponse() {
   checkAndCopyConfig("bookmarks.yaml");

src/utils/config/config.js

@@ -0,0 +1,36 @@
+/* eslint-disable no-console */
+import { join } from "path";
+import { existsSync, copyFile, readFileSync } from "fs";
+
+import yaml from "js-yaml";
+
+export default function checkAndCopyConfig(config) {
+  const configYaml = join(process.cwd(), "config", config);
+  if (!existsSync(configYaml)) {
+    const configSkeleton = join(process.cwd(), "src", "skeleton", config);
+    copyFile(configSkeleton, configYaml, (err) => {
+      if (err) {
+        console.error("error copying config", err);
+        throw err;
+      }
+      console.info("%s was copied to the config folder", config);
+    });
+
+    return true;
+  }
+
+  try {
+    yaml.load(readFileSync(configYaml, "utf8"));
+    return true;
+  } catch (e) {
+    return { ...e, config };
+  }
+}
+
+export function getSettings() {
+  checkAndCopyConfig("settings.yaml");
+
+  const settingsYaml = join(process.cwd(), "config", "settings.yaml");
+  const fileContents = readFileSync(settingsYaml, "utf8");
+  return yaml.load(fileContents);
+}

src/utils/config/docker.js

@@ -0,0 +1,35 @@
+import path from "path";
+import { readFileSync } from "fs";
+
+import yaml from "js-yaml";
+
+import checkAndCopyConfig from "utils/config/config";
+
+export default function getDockerArguments(server) {
+  checkAndCopyConfig("docker.yaml");
+
+  const configFile = path.join(process.cwd(), "config", "docker.yaml");
+  const configData = readFileSync(configFile, "utf8");
+  const servers = yaml.load(configData);
+
+  if (!server) {
+    if (process.platform !== "win32" && process.platform !== "darwin") {
+      return { socketPath: "/var/run/docker.sock" };
+    }
+
+    return { host: "127.0.0.1" };
+  }
+
+  if (servers[server]) {
+    if (servers[server].socket) {
+      return { socketPath: servers[server].socket };
+    }
+
+    if (servers[server].host) {
+      return { host: servers[server].host, port: servers[server].port || null };
+    }
+
+    return servers[server];
+  }
+  return null;
+}

src/utils/config/service-helpers.js

@@ -0,0 +1,166 @@
+import { promises as fs } from "fs";
+import path from "path";
+
+import yaml from "js-yaml";
+import Docker from "dockerode";
+import * as shvl from "shvl";
+
+import checkAndCopyConfig from "utils/config/config";
+import getDockerArguments from "utils/config/docker";
+
+export async function servicesFromConfig() {
+  checkAndCopyConfig("services.yaml");
+
+  const servicesYaml = path.join(process.cwd(), "config", "services.yaml");
+  const fileContents = await fs.readFile(servicesYaml, "utf8");
+  const services = yaml.load(fileContents);
+
+  if (!services) {
+    return [];
+  }
+
+  // map easy to write YAML objects into easy to consume JS arrays
+  const servicesArray = services.map((servicesGroup) => ({
+    name: Object.keys(servicesGroup)[0],
+    services: servicesGroup[Object.keys(servicesGroup)[0]].map((entries) => ({
+      name: Object.keys(entries)[0],
+      ...entries[Object.keys(entries)[0]],
+    })),
+  }));
+
+  return servicesArray;
+}
+
+export async function servicesFromDocker() {
+  checkAndCopyConfig("docker.yaml");
+
+  const dockerYaml = path.join(process.cwd(), "config", "docker.yaml");
+  const dockerFileContents = await fs.readFile(dockerYaml, "utf8");
+  const servers = yaml.load(dockerFileContents);
+
+  if (!servers) {
+    return [];
+  }
+
+  const serviceServers = await Promise.all(
+    Object.keys(servers).map(async (serverName) => {
+      const docker = new Docker(getDockerArguments(serverName));
+      const containers = await docker.listContainers({
+        all: true,
+      });
+
+      // bad docker connections can result in a <Buffer ...> object?
+      // in any case, this ensures the result is the expected array
+      if (!Array.isArray(containers)) {
+        return [];
+      }
+
+      const discovered = containers.map((container) => {
+        let constructedService = null;
+
+        Object.keys(container.Labels).forEach((label) => {
+          if (label.startsWith("homepage")) {
+            if (!constructedService) {
+              constructedService = {
+                container: container.Names[0].replace(/^\//, ""),
+                server: serverName,
+              };
+            }
+            shvl.set(constructedService, label.replace("homepage.", ""), container.Labels[label]);
+          }
+        });
+
+        return constructedService;
+      });
+
+      return { server: serverName, services: discovered.filter((filteredService) => filteredService) };
+    })
+  );
+
+  const mappedServiceGroups = [];
+
+  serviceServers.forEach((server) => {
+    server.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;
+}
+
+export function cleanServiceGroups(groups) {
+  return groups.map((serviceGroup) => ({
+    name: serviceGroup.name,
+    services: serviceGroup.services.map((service) => {
+      const cleanedService = { ...service };
+
+      if (cleanedService.widget) {
+        // whitelisted set of keys to pass to the frontend
+        const {
+          type, // all widgets
+          server, // docker widget
+          container,
+          currency, // coinmarketcap widget
+          symbols,
+        } = cleanedService.widget;
+
+        cleanedService.widget = {
+          type,
+          service_name: service.name,
+          service_group: serviceGroup.name,
+        };
+
+        if (currency) cleanedService.widget.currency = currency;
+        if (symbols) cleanedService.widget.symbols = symbols;
+
+        if (type === "docker") {
+          if (server) cleanedService.widget.server = server;
+          if (container) cleanedService.widget.container = container;
+        }
+      }
+
+      return cleanedService;
+    }),
+  }));
+}
+
+export default async function getServiceWidget(group, service) {
+  const configuredServices = await servicesFromConfig();
+
+  const serviceGroup = configuredServices.find((g) => g.name === group);
+  if (serviceGroup) {
+    const serviceEntry = serviceGroup.services.find((s) => s.name === service);
+    if (serviceEntry) {
+      const { widget } = serviceEntry;
+      return widget;
+    }
+  }
+
+  const discoveredServices = await servicesFromDocker();
+
+  const dockerServiceGroup = discoveredServices.find((g) => g.name === group);
+  if (dockerServiceGroup) {
+    const dockerServiceEntry = dockerServiceGroup.services.find((s) => s.name === service);
+    if (dockerServiceEntry) {
+      const { widget } = dockerServiceEntry;
+      return widget;
+    }
+  }
+
+  return false;
+}