mirror of
https://github.com/Dokploy/dokploy
synced 2025-06-26 18:27:59 +00:00
9535276fe6
Improve environment variable parsing to handle values containing equals signs by extracting a dedicated parseEnvironmentKeyValuePair function and updating Railpack secret formatting.
572 lines
13 KiB
TypeScript
572 lines
13 KiB
TypeScript
import fs from "node:fs";
|
|
import path from "node:path";
|
|
import type { Readable } from "node:stream";
|
|
import { docker, paths } from "@dokploy/server/constants";
|
|
import type { Compose } from "@dokploy/server/services/compose";
|
|
import type { ContainerInfo, ResourceRequirements } from "dockerode";
|
|
import { parse } from "dotenv";
|
|
import type { ApplicationNested } from "../builders";
|
|
import type { MariadbNested } from "../databases/mariadb";
|
|
import type { MongoNested } from "../databases/mongo";
|
|
import type { MysqlNested } from "../databases/mysql";
|
|
import type { PostgresNested } from "../databases/postgres";
|
|
import type { RedisNested } from "../databases/redis";
|
|
import { execAsync, execAsyncRemote } from "../process/execAsync";
|
|
import { spawnAsync } from "../process/spawnAsync";
|
|
import { getRemoteDocker } from "../servers/remote-docker";
|
|
|
|
interface RegistryAuth {
|
|
username: string;
|
|
password: string;
|
|
registryUrl: string;
|
|
}
|
|
|
|
export const pullImage = async (
|
|
dockerImage: string,
|
|
onData?: (data: any) => void,
|
|
authConfig?: Partial<RegistryAuth>,
|
|
): Promise<void> => {
|
|
try {
|
|
if (!dockerImage) {
|
|
throw new Error("Docker image not found");
|
|
}
|
|
|
|
if (authConfig?.username && authConfig?.password) {
|
|
await spawnAsync(
|
|
"docker",
|
|
[
|
|
"login",
|
|
authConfig.registryUrl || "",
|
|
"-u",
|
|
authConfig.username,
|
|
"-p",
|
|
authConfig.password,
|
|
],
|
|
onData,
|
|
);
|
|
}
|
|
await spawnAsync("docker", ["pull", dockerImage], onData);
|
|
} catch (error) {
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
export const pullRemoteImage = async (
|
|
dockerImage: string,
|
|
serverId: string,
|
|
onData?: (data: any) => void,
|
|
authConfig?: Partial<RegistryAuth>,
|
|
): Promise<void> => {
|
|
try {
|
|
if (!dockerImage) {
|
|
throw new Error("Docker image not found");
|
|
}
|
|
|
|
const remoteDocker = await getRemoteDocker(serverId);
|
|
|
|
await new Promise((resolve, reject) => {
|
|
remoteDocker.pull(
|
|
dockerImage,
|
|
{ authconfig: authConfig },
|
|
(err, stream) => {
|
|
if (err) {
|
|
reject(err);
|
|
return;
|
|
}
|
|
|
|
remoteDocker.modem.followProgress(
|
|
stream as Readable,
|
|
(err: Error | null, res) => {
|
|
if (!err) {
|
|
resolve(res);
|
|
}
|
|
if (err) {
|
|
reject(err);
|
|
}
|
|
},
|
|
(event) => {
|
|
onData?.(event);
|
|
},
|
|
);
|
|
},
|
|
);
|
|
});
|
|
} catch (error) {
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
export const containerExists = async (containerName: string) => {
|
|
const container = docker.getContainer(containerName);
|
|
try {
|
|
await container.inspect();
|
|
return true;
|
|
} catch (_error) {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
export const stopService = async (appName: string) => {
|
|
try {
|
|
await execAsync(`docker service scale ${appName}=0 `);
|
|
} catch (error) {
|
|
console.error(error);
|
|
return error;
|
|
}
|
|
};
|
|
|
|
export const stopServiceRemote = async (serverId: string, appName: string) => {
|
|
try {
|
|
await execAsyncRemote(serverId, `docker service scale ${appName}=0 `);
|
|
} catch (error) {
|
|
console.error(error);
|
|
return error;
|
|
}
|
|
};
|
|
|
|
export const getContainerByName = (name: string): Promise<ContainerInfo> => {
|
|
const opts = {
|
|
limit: 1,
|
|
filters: {
|
|
name: [name],
|
|
},
|
|
};
|
|
return new Promise((resolve, reject) => {
|
|
docker.listContainers(opts, (err, containers) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else if (containers?.length === 0) {
|
|
reject(new Error(`No container found with name: ${name}`));
|
|
} else if (containers && containers?.length > 0 && containers[0]) {
|
|
resolve(containers[0]);
|
|
}
|
|
});
|
|
});
|
|
};
|
|
export const cleanUpUnusedImages = async (serverId?: string) => {
|
|
try {
|
|
const command = "docker image prune --force";
|
|
if (serverId) {
|
|
await execAsyncRemote(serverId, command);
|
|
} else {
|
|
await execAsync(command);
|
|
}
|
|
} catch (error) {
|
|
console.error(error);
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
export const cleanStoppedContainers = async (serverId?: string) => {
|
|
try {
|
|
const command = "docker container prune --force";
|
|
if (serverId) {
|
|
await execAsyncRemote(serverId, command);
|
|
} else {
|
|
await execAsync(command);
|
|
}
|
|
} catch (error) {
|
|
console.error(error);
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
export const cleanUpUnusedVolumes = async (serverId?: string) => {
|
|
try {
|
|
const command = "docker volume prune --force";
|
|
if (serverId) {
|
|
await execAsyncRemote(serverId, command);
|
|
} else {
|
|
await execAsync(command);
|
|
}
|
|
} catch (error) {
|
|
console.error(error);
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
export const cleanUpInactiveContainers = async () => {
|
|
try {
|
|
const containers = await docker.listContainers({ all: true });
|
|
const inactiveContainers = containers.filter(
|
|
(container) => container.State !== "running",
|
|
);
|
|
|
|
for (const container of inactiveContainers) {
|
|
await docker.getContainer(container.Id).remove({ force: true });
|
|
console.log(`Cleaning up inactive container: ${container.Id}`);
|
|
}
|
|
} catch (error) {
|
|
console.error("Error cleaning up inactive containers:", error);
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
export const cleanUpDockerBuilder = async (serverId?: string) => {
|
|
const command = "docker builder prune --all --force";
|
|
if (serverId) {
|
|
await execAsyncRemote(serverId, command);
|
|
} else {
|
|
await execAsync(command);
|
|
}
|
|
};
|
|
|
|
export const cleanUpSystemPrune = async (serverId?: string) => {
|
|
const command = "docker system prune --all --force --volumes";
|
|
if (serverId) {
|
|
await execAsyncRemote(serverId, command);
|
|
} else {
|
|
await execAsync(command);
|
|
}
|
|
};
|
|
|
|
export const startService = async (appName: string) => {
|
|
try {
|
|
await execAsync(`docker service scale ${appName}=1 `);
|
|
} catch (error) {
|
|
console.error(error);
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
export const startServiceRemote = async (serverId: string, appName: string) => {
|
|
try {
|
|
await execAsyncRemote(serverId, `docker service scale ${appName}=1 `);
|
|
} catch (error) {
|
|
console.error(error);
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
export const removeService = async (
|
|
appName: string,
|
|
serverId?: string | null,
|
|
_deleteVolumes = false,
|
|
) => {
|
|
try {
|
|
const command = `docker service rm ${appName}`;
|
|
|
|
if (serverId) {
|
|
await execAsyncRemote(serverId, command);
|
|
} else {
|
|
await execAsync(command);
|
|
}
|
|
} catch (error) {
|
|
return error;
|
|
}
|
|
};
|
|
|
|
export const prepareEnvironmentVariables = (
|
|
serviceEnv: string | null,
|
|
projectEnv?: string | null,
|
|
) => {
|
|
const projectVars = parse(projectEnv ?? "");
|
|
const serviceVars = parse(serviceEnv ?? "");
|
|
|
|
const resolvedVars = Object.entries(serviceVars).map(([key, value]) => {
|
|
let resolvedValue = value;
|
|
if (projectVars) {
|
|
resolvedValue = value.replace(/\$\{\{project\.(.*?)\}\}/g, (_, ref) => {
|
|
if (projectVars[ref] !== undefined) {
|
|
return projectVars[ref];
|
|
}
|
|
throw new Error(`Invalid project environment variable: project.${ref}`);
|
|
});
|
|
}
|
|
return `${key}=${resolvedValue}`;
|
|
});
|
|
|
|
return resolvedVars;
|
|
};
|
|
|
|
export const parseEnvironmentKeyValuePair = (
|
|
pair: string,
|
|
): [string, string] => {
|
|
const [key, ...valueParts] = pair.split("=");
|
|
if (!key || !valueParts.length) {
|
|
throw new Error(`Invalid environment variable pair: ${pair}`);
|
|
}
|
|
|
|
return [key, valueParts.join("")];
|
|
};
|
|
|
|
export const getEnviromentVariablesObject = (
|
|
input: string | null,
|
|
projectEnv?: string | null,
|
|
) => {
|
|
const envs = prepareEnvironmentVariables(input, projectEnv);
|
|
|
|
const jsonObject: Record<string, string> = {};
|
|
|
|
for (const pair of envs) {
|
|
const [key, value] = parseEnvironmentKeyValuePair(pair);
|
|
if (key && value) {
|
|
jsonObject[key] = value;
|
|
}
|
|
}
|
|
|
|
return jsonObject;
|
|
};
|
|
|
|
export const generateVolumeMounts = (mounts: ApplicationNested["mounts"]) => {
|
|
if (!mounts || mounts.length === 0) {
|
|
return [];
|
|
}
|
|
|
|
return mounts
|
|
.filter((mount) => mount.type === "volume")
|
|
.map((mount) => ({
|
|
Type: "volume" as const,
|
|
Source: mount.volumeName || "",
|
|
Target: mount.mountPath,
|
|
}));
|
|
};
|
|
|
|
type Resources = {
|
|
memoryLimit: string | null;
|
|
memoryReservation: string | null;
|
|
cpuLimit: string | null;
|
|
cpuReservation: string | null;
|
|
};
|
|
export const calculateResources = ({
|
|
memoryLimit,
|
|
memoryReservation,
|
|
cpuLimit,
|
|
cpuReservation,
|
|
}: Resources): ResourceRequirements => {
|
|
return {
|
|
Limits: {
|
|
MemoryBytes: memoryLimit ? Number.parseInt(memoryLimit) : undefined,
|
|
NanoCPUs: cpuLimit ? Number.parseInt(cpuLimit) : undefined,
|
|
},
|
|
Reservations: {
|
|
MemoryBytes: memoryReservation
|
|
? Number.parseInt(memoryReservation)
|
|
: undefined,
|
|
NanoCPUs: cpuReservation ? Number.parseInt(cpuReservation) : undefined,
|
|
},
|
|
};
|
|
};
|
|
|
|
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,
|
|
}
|
|
: {}),
|
|
...(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 [];
|
|
}
|
|
|
|
return mounts
|
|
.filter((mount) => mount.type === "bind")
|
|
.map((mount) => ({
|
|
Type: "bind" as const,
|
|
Source: mount.hostPath || "",
|
|
Target: mount.mountPath,
|
|
}));
|
|
};
|
|
|
|
export const generateFileMounts = (
|
|
appName: string,
|
|
service:
|
|
| ApplicationNested
|
|
| MongoNested
|
|
| MariadbNested
|
|
| MysqlNested
|
|
| PostgresNested
|
|
| RedisNested,
|
|
) => {
|
|
const { mounts } = service;
|
|
const { APPLICATIONS_PATH } = paths(!!service.serverId);
|
|
if (!mounts || mounts.length === 0) {
|
|
return [];
|
|
}
|
|
|
|
return mounts
|
|
.filter((mount) => mount.type === "file")
|
|
.map((mount) => {
|
|
const fileName = mount.filePath;
|
|
const absoluteBasePath = path.resolve(APPLICATIONS_PATH);
|
|
const directory = path.join(absoluteBasePath, appName, "files");
|
|
const sourcePath = path.join(directory, fileName || "");
|
|
return {
|
|
Type: "bind" as const,
|
|
Source: sourcePath,
|
|
Target: mount.mountPath,
|
|
};
|
|
});
|
|
};
|
|
|
|
export const createFile = async (
|
|
outputPath: string,
|
|
filePath: string,
|
|
content: string,
|
|
) => {
|
|
try {
|
|
const fullPath = path.join(outputPath, filePath);
|
|
if (fullPath.endsWith(path.sep) || filePath.endsWith("/")) {
|
|
fs.mkdirSync(fullPath, { recursive: true });
|
|
return;
|
|
}
|
|
|
|
const directory = path.dirname(fullPath);
|
|
fs.mkdirSync(directory, { recursive: true });
|
|
fs.writeFileSync(fullPath, content || "");
|
|
} catch (error) {
|
|
throw error;
|
|
}
|
|
};
|
|
export const encodeBase64 = (content: string) =>
|
|
Buffer.from(content, "utf-8").toString("base64");
|
|
|
|
export const getCreateFileCommand = (
|
|
outputPath: string,
|
|
filePath: string,
|
|
content: string,
|
|
) => {
|
|
const fullPath = path.join(outputPath, filePath);
|
|
if (fullPath.endsWith(path.sep) || filePath.endsWith("/")) {
|
|
return `mkdir -p ${fullPath};`;
|
|
}
|
|
|
|
const directory = path.dirname(fullPath);
|
|
const encodedContent = encodeBase64(content);
|
|
return `
|
|
mkdir -p ${directory};
|
|
echo "${encodedContent}" | base64 -d > "${fullPath}";
|
|
`;
|
|
};
|
|
|
|
export const getServiceContainer = async (
|
|
appName: string,
|
|
serverId?: string | null,
|
|
) => {
|
|
try {
|
|
const filter = {
|
|
status: ["running"],
|
|
label: [`com.docker.swarm.service.name=${appName}`],
|
|
};
|
|
const remoteDocker = await getRemoteDocker(serverId);
|
|
const containers = await remoteDocker.listContainers({
|
|
filters: JSON.stringify(filter),
|
|
});
|
|
|
|
if (containers.length === 0 || !containers[0]) {
|
|
return null;
|
|
}
|
|
|
|
const container = containers[0];
|
|
|
|
return container;
|
|
} catch (error) {
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
export const getComposeContainer = async (
|
|
compose: Compose,
|
|
serviceName: string,
|
|
) => {
|
|
try {
|
|
const { appName, composeType, serverId } = compose;
|
|
// 1. Determine the correct labels based on composeType
|
|
const labels: string[] = [];
|
|
if (composeType === "stack") {
|
|
// Labels for Docker Swarm stack services
|
|
labels.push(`com.docker.stack.namespace=${appName}`);
|
|
labels.push(`com.docker.swarm.service.name=${appName}_${serviceName}`);
|
|
} else {
|
|
// Labels for Docker Compose projects (default)
|
|
labels.push(`com.docker.compose.project=${appName}`);
|
|
labels.push(`com.docker.compose.service=${serviceName}`);
|
|
}
|
|
const filter = {
|
|
status: ["running"],
|
|
label: labels,
|
|
};
|
|
|
|
const remoteDocker = await getRemoteDocker(serverId);
|
|
const containers = await remoteDocker.listContainers({
|
|
filters: JSON.stringify(filter),
|
|
limit: 1,
|
|
});
|
|
|
|
if (containers.length === 0 || !containers[0]) {
|
|
return null;
|
|
}
|
|
|
|
const container = containers[0];
|
|
return container;
|
|
} catch (error) {
|
|
throw error;
|
|
}
|
|
};
|