v0.1.0 (#112)

* feat: add schema for registry and routes

* feat: add docker registry upload

* feat: add show cluster

* refactor: set the registry url in image in case we have a registry asociated

* feat: add update registry and fix the docker url markup

* chore: remove --advertise-ip on swarm script

* refactor: remove listen address of swarm initialize

* feat: add table to show nodes and add dropdown to add manager & workers

* refactor: improve interface for cluster

* refactor: improve UI

* feat: add experimental swarm settings

* refactor: remove comments

* refactor: prettify json of each setting

* refactor: add interface tooltip

* refactor: delete static form self registry

* refactor: allow to se a empty registry

* fix: remove text area warnings

* feat: add network swarm json

* refactor: update ui

* revert: go back to swarm init config

* refactor: remove initialization on server, only on setup script

* Update LICENSE.MD

* feat: appearance theme support system config

* refactor: remove logs

* fix(README-ru): hyperlink-ed docs url

* feat: (#107) webhook listener filter docker events based on image tag.

Fixes #107

* refactor: simplify comparison docker tags

* refactor: remove return in res status

* refactor: prevent to updates download automatically

* feat: support code editor (#105)

* feat: support code editor

* Update codeblock

* refactor: remove unused class

---------

Co-authored-by: Mauricio Siu <47042324+Siumauricio@users.noreply.github.com>

* fix: select the right image from sourcetype (#109)

* chore: bump minor version

---------

Co-authored-by: hehehai <riverhohai@gmail.com>
Co-authored-by: Bayram Tagiev <bayram.tagiev.a@gmail.com>
Co-authored-by: Paulo Santana <30875229+hikinine@users.noreply.github.com>

server/utils/builders/index.ts

@@ -5,6 +5,7 @@ import type { CreateServiceOptions } from "dockerode";
 import {
 	calculateResources,
 	generateBindMounts,
+	generateConfigContainer,
 	generateFileMounts,
 	generateVolumeMounts,
 	prepareEnvironmentVariables,
@@ -13,6 +14,7 @@ import { buildCustomDocker } from "./docker-file";
 import { buildHeroku } from "./heroku";
 import { buildNixpacks } from "./nixpacks";
 import { buildPaketo } from "./paketo";
+import { uploadImage } from "../cluster/upload";
 
 // NIXPACKS codeDirectory = where is the path of the code directory
 // HEROKU codeDirectory = where is the path of the code directory
@@ -20,7 +22,7 @@ import { buildPaketo } from "./paketo";
 // DOCKERFILE codeDirectory = where is the exact path of the (Dockerfile)
 export type ApplicationNested = InferResultType<
 	"applications",
-	{ mounts: true; security: true; redirects: true; ports: true }
+	{ mounts: true; security: true; redirects: true; ports: true; registry: true }
 >;
 export const buildApplication = async (
 	application: ApplicationNested,
@@ -42,6 +44,10 @@ export const buildApplication = async (
 		} else if (buildType === "dockerfile") {
 			await buildCustomDocker(application, writeStream);
 		}
+
+		if (application.registryId) {
+			await uploadImage(application, writeStream);
+		}
 		await mechanizeDockerContainer(application);
 		writeStream.write("Docker Deployed: ✅");
 	} catch (error) {
@@ -59,8 +65,6 @@ export const mechanizeDockerContainer = async (
 		appName,
 		env,
 		mounts,
-		sourceType,
-		dockerImage,
 		cpuLimit,
 		memoryLimit,
 		memoryReservation,
@@ -75,16 +79,34 @@ export const mechanizeDockerContainer = async (
 		cpuLimit,
 		cpuReservation,
 	});
+
 	const volumesMount = generateVolumeMounts(mounts);
+
+	const {
+		HealthCheck,
+		RestartPolicy,
+		Placement,
+		Labels,
+		Mode,
+		RollbackConfig,
+		UpdateConfig,
+		Networks,
+	} = generateConfigContainer(application);
+
 	const bindsMount = generateBindMounts(mounts);
 	const filesMount = generateFileMounts(appName, mounts);
 	const envVariables = prepareEnvironmentVariables(env);
 
+	const image = getImageName(application);
+	const authConfig = getAuthConfig(application);
+
 	const settings: CreateServiceOptions = {
+		authconfig: authConfig,
 		Name: appName,
 		TaskTemplate: {
 			ContainerSpec: {
-				Image: sourceType === "docker" ? dockerImage! : `${appName}:latest`,
+				HealthCheck,
+				Image: image,
 				Env: envVariables,
 				Mounts: [...volumesMount, ...bindsMount, ...filesMount],
 				...(command
@@ -93,20 +115,17 @@ export const mechanizeDockerContainer = async (
 							Args: ["-c", command],
 						}
 					: {}),
+				Labels,
 			},
-			Networks: [{ Target: "dokploy-network" }],
-			RestartPolicy: {
-				Condition: "on-failure",
-			},
+			Networks,
+			RestartPolicy,
+			Placement,
 			Resources: {
 				...resources,
 			},
 		},
-		Mode: {
-			Replicated: {
-				Replicas: 1,
-			},
-		},
+		Mode,
+		RollbackConfig,
 		EndpointSpec: {
 			Ports: ports.map((port) => ({
 				Protocol: port.protocol,
@@ -114,10 +133,7 @@ export const mechanizeDockerContainer = async (
 				PublishedPort: port.publishedPort,
 			})),
 		},
-		UpdateConfig: {
-			Parallelism: 1,
-			Order: "start-first",
-		},
+		UpdateConfig,
 	};
 
 	try {
@@ -132,7 +148,43 @@ export const mechanizeDockerContainer = async (
 			},
 		});
 	} catch (error) {
+		console.log(error);
 		await docker.createService(settings);
 	}
-	// await cleanUpUnusedImages();
+};
+
+const getImageName = (application: ApplicationNested) => {
+	const { appName, sourceType, dockerImage, registry } = application;
+
+	if (sourceType === "docker") {
+		return dockerImage || "ERROR-NO-IMAGE-PROVIDED";
+	}
+
+	const registryUrl = registry?.registryUrl || "";
+	const imagePrefix = registry?.imagePrefix ? `${registry.imagePrefix}/` : "";
+	return registry
+		? `${registryUrl}/${imagePrefix}${appName}`
+		: `${appName}:latest`;
+};
+
+const getAuthConfig = (application: ApplicationNested) => {
+	const { registry, username, password, sourceType } = application;
+
+	if (sourceType === "docker") {
+		if (username && password) {
+			return {
+				password,
+				username,
+				serveraddress: "https://index.docker.io/v1/",
+			};
+		}
+	} else if (registry) {
+		return {
+			password: registry.password,
+			username: registry.username,
+			serveraddress: registry.registryUrl,
+		};
+	}
+
+	return undefined;
 };

server/utils/cluster/upload.ts

@@ -0,0 +1,65 @@
+import type { ApplicationNested } from "../builders";
+import { spawnAsync } from "../process/spawnAsync";
+import type { WriteStream } from "node:fs";
+
+export const uploadImage = async (
+	application: ApplicationNested,
+	writeStream: WriteStream,
+) => {
+	const registry = application.registry;
+
+	if (!registry) {
+		throw new Error("Registry not found");
+	}
+
+	const { registryUrl, imagePrefix, registryType } = registry;
+	const { appName } = application;
+	const imageName = `${appName}:latest`;
+
+	const finalURL =
+		registryType === "selfHosted"
+			? process.env.NODE_ENV === "development"
+				? "localhost:5000"
+				: registryUrl
+			: registryUrl;
+
+	const registryTag = imagePrefix
+		? `${finalURL}/${imagePrefix}/${imageName}`
+		: `${finalURL}/${imageName}`;
+
+	try {
+		console.log(finalURL, registryTag);
+		writeStream.write(
+			`📦 [Enabled Registry] Uploading image to ${registry.registryType} | ${registryTag} | ${finalURL}\n`,
+		);
+
+		await spawnAsync(
+			"docker",
+			["login", finalURL, "-u", registry.username, "-p", registry.password],
+			(data) => {
+				if (writeStream.writable) {
+					writeStream.write(data);
+				}
+			},
+		);
+
+		await spawnAsync("docker", ["tag", imageName, registryTag], (data) => {
+			if (writeStream.writable) {
+				writeStream.write(data);
+			}
+		});
+
+		await spawnAsync("docker", ["push", registryTag], (data) => {
+			if (writeStream.writable) {
+				writeStream.write(data);
+			}
+		});
+	} catch (error) {
+		console.log(error);
+		throw error;
+	}
+};
+// docker:
+// endpoint: "unix:///var/run/docker.sock"
+// exposedByDefault: false
+// swarmMode: true

server/utils/docker/utils.ts

@@ -122,10 +122,10 @@ export const cleanUpInactiveContainers = async () => {
 
 		for (const container of inactiveContainers) {
 			await docker.getContainer(container.Id).remove({ force: true });
-			console.log(`Contenedor eliminado: ${container.Id}`);
+			console.log(`Cleaning up inactive container: ${container.Id}`);
 		}
 	} catch (error) {
-		console.error("Error al limpiar contenedores inactivos:", error);
+		console.error("Error cleaning up inactive containers:", error);
 		throw error;
 	}
 };
@@ -199,6 +199,83 @@ export const calculateResources = ({
 	};
 };
 
+export const generateConfigContainer = (application: ApplicationNested) => {
+	const {
+		healthCheckSwarm,
+		restartPolicySwarm,
+		placementSwarm,
+		updateConfigSwarm,
+		rollbackConfigSwarm,
+		modeSwarm,
+		labelsSwarm,
+		replicas,
+		mounts,
+		networkSwarm,
+	} = application;
+
+	const haveMounts = mounts.length > 0;
+
+	return {
+		...(healthCheckSwarm && {
+			HealthCheck: healthCheckSwarm,
+		}),
+		...(restartPolicySwarm
+			? {
+					RestartPolicy: restartPolicySwarm,
+				}
+			: {
+					// if no restartPolicySwarm provided use default
+					RestartPolicy: {
+						Condition: "on-failure",
+					},
+				}),
+		...(placementSwarm
+			? {
+					Placement: placementSwarm,
+				}
+			: {
+					// if app have mounts keep manager as constraint
+					Placement: {
+						Constraints: haveMounts ? ["node.role==manager"] : [],
+					},
+				}),
+		...(labelsSwarm && {
+			Labels: labelsSwarm,
+		}),
+		...(modeSwarm
+			? {
+					Mode: modeSwarm,
+				}
+			: {
+					// use replicas value if no modeSwarm provided
+					Mode: {
+						Replicated: {
+							Replicas: replicas,
+						},
+					},
+				}),
+		...(rollbackConfigSwarm && {
+			RollbackConfig: rollbackConfigSwarm,
+		}),
+		...(updateConfigSwarm
+			? { UpdateConfig: updateConfigSwarm }
+			: {
+					// default config if no updateConfigSwarm provided
+					UpdateConfig: {
+						Parallelism: 1,
+						Order: "start-first",
+					},
+				}),
+		...(networkSwarm
+			? {
+					Networks: networkSwarm,
+				}
+			: {
+					Networks: [{ Target: "dokploy-network" }],
+				}),
+	};
+};
+
 export const generateBindMounts = (mounts: ApplicationNested["mounts"]) => {
 	if (!mounts || mounts.length === 0) {
 		return [];

server/utils/traefik/domain.ts

@@ -47,10 +47,7 @@ export const removeDomain = async (appName: string, uniqueKey: number) => {
 	}
 };
 
-export const createRouterConfig = async (
-	app: ApplicationNested,
-	domain: Domain,
-) => {
+const createRouterConfig = async (app: ApplicationNested, domain: Domain) => {
 	const { appName, redirects, security } = app;
 	const { certificateType } = domain;
 

server/utils/traefik/registry.ts

@@ -0,0 +1,71 @@
+import type { FileConfig, HttpRouter } from "./file-types";
+import type { Registry } from "@/server/api/services/registry";
+import { removeDirectoryIfExistsContent } from "../filesystem/directory";
+import { REGISTRY_PATH } from "@/server/constants";
+import { dump, load } from "js-yaml";
+import { join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+
+export const manageRegistry = async (registry: Registry) => {
+	if (!existsSync(REGISTRY_PATH)) {
+		mkdirSync(REGISTRY_PATH, { recursive: true });
+	}
+
+	const appName = "dokploy-registry";
+	const config: FileConfig = loadOrCreateConfig();
+
+	const serviceName = `${appName}-service`;
+	const routerName = `${appName}-router`;
+
+	config.http = config.http || { routers: {}, services: {} };
+	config.http.routers = config.http.routers || {};
+	config.http.services = config.http.services || {};
+
+	config.http.routers[routerName] = await createRegistryRouterConfig(registry);
+
+	config.http.services[serviceName] = {
+		loadBalancer: {
+			servers: [{ url: `http://${appName}:5000` }],
+			passHostHeader: true,
+		},
+	};
+
+	const yamlConfig = dump(config);
+	const configFile = join(REGISTRY_PATH, "registry.yml");
+	writeFileSync(configFile, yamlConfig);
+};
+
+export const removeSelfHostedRegistry = async () => {
+	await removeDirectoryIfExistsContent(REGISTRY_PATH);
+};
+
+const createRegistryRouterConfig = async (registry: Registry) => {
+	const { registryUrl } = registry;
+	const routerConfig: HttpRouter = {
+		rule: `Host(\`${registryUrl}\`)`,
+		service: "dokploy-registry-service",
+		entryPoints: [
+			"web",
+			...(process.env.NODE_ENV === "production" ? ["websecure"] : []),
+		],
+		...(process.env.NODE_ENV === "production"
+			? {
+					tls: { certResolver: "letsencrypt" },
+				}
+			: {}),
+	};
+
+	return routerConfig;
+};
+
+const loadOrCreateConfig = (): FileConfig => {
+	const configPath = join(REGISTRY_PATH, "registry.yml");
+	if (existsSync(configPath)) {
+		const yamlStr = readFileSync(configPath, "utf8");
+		const parsedConfig = (load(yamlStr) as FileConfig) || {
+			http: { routers: {}, services: {} },
+		};
+		return parsedConfig;
+	}
+	return { http: { routers: {}, services: {} } };
+};