Deploy MVP

src/core/deployment.ts

@@ -3,51 +3,111 @@
 import Docker from "dockerode";
 import { Application, Deployment } from "@/lib/types";
 import { CPUusage } from "@/lib/server/calc";
+import path from "path";
+import fs from "fs";
 
 const docker = new Docker();
 
+function sanitizeString(str: string): string {
+  if (!str) return "";
+  return (
+    str[0].replace(/[^a-zA-Z0-9]/g, "-") +
+    str.slice(1).replace(/[^a-zA-Z0-9_.-]/g, "-")
+  );
+}
+
 export async function getDeployments(
   apps: Application[]
 ): Promise<(null | Deployment)[]> {
-  const containers = await docker.listContainers({ all: true });
-
   return await Promise.all(
     apps
       .map((app) => app.deployments)
       .flat()
-      .map(async (imageId) => {
-        const containerInfo = containers.find(
-          (container) => container.ImageID === imageId
-        );
-
-        if (!containerInfo) return null;
-
-        const container = docker.getContainer(containerInfo.Id);
+      .map(async (deployId) => {
+        const container = docker.getContainer(deployId);
+        const containerInfo = await container.inspect();
 
         let cpu = 0;
         let memory = 0;
         let ports: Set<[number, number]> = new Set();
 
-        if (containerInfo.State === "running") {
+        if (containerInfo.State.Running) {
           const stats = await container.stats({ stream: false });
           memory += (stats.memory_stats.usage / stats.memory_stats.limit) * 100;
           cpu += CPUusage(stats);
         }
 
-        containerInfo.Ports?.forEach((p) => {
-          if (p.PublicPort && p.PrivatePort) {
-            ports.add([p.PublicPort, p.PrivatePort]);
+        for (const [key, mappings] of Object.entries(
+          containerInfo.NetworkSettings.Ports
+        )) {
+          const privatePort = parseInt(key.split("/")[0], 10);
+          if (mappings) {
+            for (const mapping of mappings) {
+              const publicPort = parseInt(mapping.HostPort, 10);
+              ports.add([publicPort, privatePort]);
+            }
           }
-        });
+        }
 
         return {
-          image: containerInfo.ImageID,
+          image: containerInfo.Image,
           container: containerInfo.Id,
           cpu,
           memory,
-          status: containerInfo.State === "running" ? "running" : "stopped",
+          status: containerInfo.State.Running ? "running" : "stopped",
           ports: [...ports],
         };
       })
   );
 }
+
+export async function deployApp(
+  name: string,
+  appId: string
+): Promise<string | undefined> {
+  const appPath = path.join("data", "apps", appId, "repo");
+  const imageTag = `dockship/${appId}:latest`;
+
+  try {
+    // Check if app exists
+    fs.accessSync(appPath);
+  } catch {
+    console.error("Repo does not exist:", appPath);
+    return undefined;
+  }
+
+  try {
+    const stream = await docker.buildImage(
+      {
+        context: appPath,
+        src: ["Dockerfile", "."],
+      },
+      { t: imageTag }
+    );
+
+    await new Promise<void>((resolve, reject) => {
+      docker.modem.followProgress(stream, (err: Error | null) =>
+        err ? reject(err) : resolve()
+      );
+    });
+
+    const container = await docker.createContainer({
+      Image: imageTag,
+      name: sanitizeString(name),
+      Tty: true,
+      HostConfig: {
+        RestartPolicy: { Name: "unless-stopped" },
+        PortBindings: {
+          "3000/tcp": [{ HostPort: "3800" }],
+        },
+      },
+    });
+
+    await container.start();
+
+    return container.id;
+  } catch (err) {
+    console.error("Failed to deploy app:", err);
+    return undefined;
+  }
+}