|
|
import { join } from "node:path"; |
|
|
import { paths } from "@dokploy/server/constants"; |
|
|
import { db } from "@dokploy/server/db"; |
|
|
import { type apiCreateCompose, compose } from "@dokploy/server/db/schema"; |
|
|
import { buildAppName, cleanAppName } from "@dokploy/server/db/schema"; |
|
|
import { |
|
|
buildCompose, |
|
|
getBuildComposeCommand, |
|
|
} from "@dokploy/server/utils/builders/compose"; |
|
|
import { randomizeSpecificationFile } from "@dokploy/server/utils/docker/compose"; |
|
|
import { |
|
|
cloneCompose, |
|
|
cloneComposeRemote, |
|
|
loadDockerCompose, |
|
|
loadDockerComposeRemote, |
|
|
} from "@dokploy/server/utils/docker/domain"; |
|
|
import type { ComposeSpecification } from "@dokploy/server/utils/docker/types"; |
|
|
import { sendBuildErrorNotifications } from "@dokploy/server/utils/notifications/build-error"; |
|
|
import { sendBuildSuccessNotifications } from "@dokploy/server/utils/notifications/build-success"; |
|
|
import { |
|
|
execAsync, |
|
|
execAsyncRemote, |
|
|
} from "@dokploy/server/utils/process/execAsync"; |
|
|
import { |
|
|
cloneBitbucketRepository, |
|
|
getBitbucketCloneCommand, |
|
|
} from "@dokploy/server/utils/providers/bitbucket"; |
|
|
import { |
|
|
cloneGitRepository, |
|
|
getCustomGitCloneCommand, |
|
|
} from "@dokploy/server/utils/providers/git"; |
|
|
import { |
|
|
cloneGiteaRepository, |
|
|
getGiteaCloneCommand, |
|
|
} from "@dokploy/server/utils/providers/gitea"; |
|
|
import { |
|
|
cloneGithubRepository, |
|
|
getGithubCloneCommand, |
|
|
} from "@dokploy/server/utils/providers/github"; |
|
|
import { |
|
|
cloneGitlabRepository, |
|
|
getGitlabCloneCommand, |
|
|
} from "@dokploy/server/utils/providers/gitlab"; |
|
|
import { |
|
|
createComposeFile, |
|
|
getCreateComposeFileCommand, |
|
|
} from "@dokploy/server/utils/providers/raw"; |
|
|
import { TRPCError } from "@trpc/server"; |
|
|
import { eq } from "drizzle-orm"; |
|
|
import { encodeBase64 } from "../utils/docker/utils"; |
|
|
import { getDokployUrl } from "./admin"; |
|
|
import { createDeploymentCompose, updateDeploymentStatus } from "./deployment"; |
|
|
import { validUniqueServerAppName } from "./project"; |
|
|
|
|
|
export type Compose = typeof compose.$inferSelect; |
|
|
|
|
|
export const createCompose = async (input: typeof apiCreateCompose._type) => { |
|
|
const appName = buildAppName("compose", input.appName); |
|
|
|
|
|
const valid = await validUniqueServerAppName(appName); |
|
|
if (!valid) { |
|
|
throw new TRPCError({ |
|
|
code: "CONFLICT", |
|
|
message: "Service with this 'AppName' already exists", |
|
|
}); |
|
|
} |
|
|
|
|
|
const newDestination = await db |
|
|
.insert(compose) |
|
|
.values({ |
|
|
...input, |
|
|
composeFile: input.composeFile || "", |
|
|
appName, |
|
|
}) |
|
|
.returning() |
|
|
.then((value) => value[0]); |
|
|
|
|
|
if (!newDestination) { |
|
|
throw new TRPCError({ |
|
|
code: "BAD_REQUEST", |
|
|
message: "Error input: Inserting compose", |
|
|
}); |
|
|
} |
|
|
|
|
|
return newDestination; |
|
|
}; |
|
|
|
|
|
export const createComposeByTemplate = async ( |
|
|
input: typeof compose.$inferInsert, |
|
|
) => { |
|
|
const appName = cleanAppName(input.appName); |
|
|
if (appName) { |
|
|
const valid = await validUniqueServerAppName(appName); |
|
|
|
|
|
if (!valid) { |
|
|
throw new TRPCError({ |
|
|
code: "CONFLICT", |
|
|
message: "Service with this 'AppName' already exists", |
|
|
}); |
|
|
} |
|
|
} |
|
|
const newDestination = await db |
|
|
.insert(compose) |
|
|
.values({ |
|
|
...input, |
|
|
appName, |
|
|
}) |
|
|
.returning() |
|
|
.then((value) => value[0]); |
|
|
|
|
|
if (!newDestination) { |
|
|
throw new TRPCError({ |
|
|
code: "BAD_REQUEST", |
|
|
message: "Error input: Inserting compose", |
|
|
}); |
|
|
} |
|
|
|
|
|
return newDestination; |
|
|
}; |
|
|
|
|
|
export const findComposeById = async (composeId: string) => { |
|
|
const result = await db.query.compose.findFirst({ |
|
|
where: eq(compose.composeId, composeId), |
|
|
with: { |
|
|
project: true, |
|
|
deployments: true, |
|
|
mounts: true, |
|
|
domains: true, |
|
|
github: true, |
|
|
gitlab: true, |
|
|
bitbucket: true, |
|
|
gitea: true, |
|
|
server: true, |
|
|
backups: { |
|
|
with: { |
|
|
destination: true, |
|
|
deployments: true, |
|
|
}, |
|
|
}, |
|
|
}, |
|
|
}); |
|
|
if (!result) { |
|
|
throw new TRPCError({ |
|
|
code: "NOT_FOUND", |
|
|
message: "Compose not found", |
|
|
}); |
|
|
} |
|
|
return result; |
|
|
}; |
|
|
|
|
|
export const loadServices = async ( |
|
|
composeId: string, |
|
|
type: "fetch" | "cache" = "fetch", |
|
|
) => { |
|
|
const compose = await findComposeById(composeId); |
|
|
|
|
|
if (type === "fetch") { |
|
|
if (compose.serverId) { |
|
|
await cloneComposeRemote(compose); |
|
|
} else { |
|
|
await cloneCompose(compose); |
|
|
} |
|
|
} |
|
|
|
|
|
let composeData: ComposeSpecification | null; |
|
|
|
|
|
if (compose.serverId) { |
|
|
composeData = await loadDockerComposeRemote(compose); |
|
|
} else { |
|
|
composeData = await loadDockerCompose(compose); |
|
|
} |
|
|
|
|
|
if (compose.randomize && composeData) { |
|
|
const randomizedCompose = randomizeSpecificationFile( |
|
|
composeData, |
|
|
compose.suffix, |
|
|
); |
|
|
composeData = randomizedCompose; |
|
|
} |
|
|
|
|
|
if (!composeData?.services) { |
|
|
throw new TRPCError({ |
|
|
code: "NOT_FOUND", |
|
|
message: "Services not found", |
|
|
}); |
|
|
} |
|
|
|
|
|
const services = Object.keys(composeData.services); |
|
|
|
|
|
return [...services]; |
|
|
}; |
|
|
|
|
|
export const updateCompose = async ( |
|
|
composeId: string, |
|
|
composeData: Partial<Compose>, |
|
|
) => { |
|
|
const { appName, ...rest } = composeData; |
|
|
const composeResult = await db |
|
|
.update(compose) |
|
|
.set({ |
|
|
...rest, |
|
|
}) |
|
|
.where(eq(compose.composeId, composeId)) |
|
|
.returning(); |
|
|
|
|
|
return composeResult[0]; |
|
|
}; |
|
|
|
|
|
export const deployCompose = async ({ |
|
|
composeId, |
|
|
titleLog = "Manual deployment", |
|
|
descriptionLog = "", |
|
|
}: { |
|
|
composeId: string; |
|
|
titleLog: string; |
|
|
descriptionLog: string; |
|
|
}) => { |
|
|
const compose = await findComposeById(composeId); |
|
|
|
|
|
const buildLink = `${await getDokployUrl()}/dashboard/project/${ |
|
|
compose.projectId |
|
|
}/services/compose/${compose.composeId}?tab=deployments`; |
|
|
const deployment = await createDeploymentCompose({ |
|
|
composeId: composeId, |
|
|
title: titleLog, |
|
|
description: descriptionLog, |
|
|
}); |
|
|
|
|
|
try { |
|
|
if (compose.sourceType === "github") { |
|
|
await cloneGithubRepository({ |
|
|
...compose, |
|
|
logPath: deployment.logPath, |
|
|
type: "compose", |
|
|
}); |
|
|
} else if (compose.sourceType === "gitlab") { |
|
|
await cloneGitlabRepository(compose, deployment.logPath, true); |
|
|
} else if (compose.sourceType === "bitbucket") { |
|
|
await cloneBitbucketRepository(compose, deployment.logPath, true); |
|
|
} else if (compose.sourceType === "git") { |
|
|
await cloneGitRepository(compose, deployment.logPath, true); |
|
|
} else if (compose.sourceType === "gitea") { |
|
|
await cloneGiteaRepository(compose, deployment.logPath, true); |
|
|
} else if (compose.sourceType === "raw") { |
|
|
await createComposeFile(compose, deployment.logPath); |
|
|
} |
|
|
await buildCompose(compose, deployment.logPath); |
|
|
await updateDeploymentStatus(deployment.deploymentId, "done"); |
|
|
await updateCompose(composeId, { |
|
|
composeStatus: "done", |
|
|
}); |
|
|
|
|
|
await sendBuildSuccessNotifications({ |
|
|
projectName: compose.project.name, |
|
|
applicationName: compose.name, |
|
|
applicationType: "compose", |
|
|
buildLink, |
|
|
organizationId: compose.project.organizationId, |
|
|
domains: compose.domains, |
|
|
}); |
|
|
} catch (error) { |
|
|
await updateDeploymentStatus(deployment.deploymentId, "error"); |
|
|
await updateCompose(composeId, { |
|
|
composeStatus: "error", |
|
|
}); |
|
|
await sendBuildErrorNotifications({ |
|
|
projectName: compose.project.name, |
|
|
applicationName: compose.name, |
|
|
applicationType: "compose", |
|
|
|
|
|
errorMessage: error?.message || "Error building", |
|
|
buildLink, |
|
|
organizationId: compose.project.organizationId, |
|
|
}); |
|
|
throw error; |
|
|
} |
|
|
}; |
|
|
|
|
|
export const rebuildCompose = async ({ |
|
|
composeId, |
|
|
titleLog = "Rebuild deployment", |
|
|
descriptionLog = "", |
|
|
}: { |
|
|
composeId: string; |
|
|
titleLog: string; |
|
|
descriptionLog: string; |
|
|
}) => { |
|
|
const compose = await findComposeById(composeId); |
|
|
|
|
|
const deployment = await createDeploymentCompose({ |
|
|
composeId: composeId, |
|
|
title: titleLog, |
|
|
description: descriptionLog, |
|
|
}); |
|
|
|
|
|
try { |
|
|
if (compose.sourceType === "raw") { |
|
|
await createComposeFile(compose, deployment.logPath); |
|
|
} |
|
|
await buildCompose(compose, deployment.logPath); |
|
|
|
|
|
await updateDeploymentStatus(deployment.deploymentId, "done"); |
|
|
await updateCompose(composeId, { |
|
|
composeStatus: "done", |
|
|
}); |
|
|
} catch (error) { |
|
|
await updateDeploymentStatus(deployment.deploymentId, "error"); |
|
|
await updateCompose(composeId, { |
|
|
composeStatus: "error", |
|
|
}); |
|
|
throw error; |
|
|
} |
|
|
|
|
|
return true; |
|
|
}; |
|
|
|
|
|
export const deployRemoteCompose = async ({ |
|
|
composeId, |
|
|
titleLog = "Manual deployment", |
|
|
descriptionLog = "", |
|
|
}: { |
|
|
composeId: string; |
|
|
titleLog: string; |
|
|
descriptionLog: string; |
|
|
}) => { |
|
|
const compose = await findComposeById(composeId); |
|
|
|
|
|
const buildLink = `${await getDokployUrl()}/dashboard/project/${ |
|
|
compose.projectId |
|
|
}/services/compose/${compose.composeId}?tab=deployments`; |
|
|
const deployment = await createDeploymentCompose({ |
|
|
composeId: composeId, |
|
|
title: titleLog, |
|
|
description: descriptionLog, |
|
|
}); |
|
|
try { |
|
|
if (compose.serverId) { |
|
|
let command = "set -e;"; |
|
|
|
|
|
if (compose.sourceType === "github") { |
|
|
command += await getGithubCloneCommand({ |
|
|
...compose, |
|
|
logPath: deployment.logPath, |
|
|
type: "compose", |
|
|
serverId: compose.serverId, |
|
|
}); |
|
|
} else if (compose.sourceType === "gitlab") { |
|
|
command += await getGitlabCloneCommand( |
|
|
compose, |
|
|
deployment.logPath, |
|
|
true, |
|
|
); |
|
|
} else if (compose.sourceType === "bitbucket") { |
|
|
command += await getBitbucketCloneCommand( |
|
|
compose, |
|
|
deployment.logPath, |
|
|
true, |
|
|
); |
|
|
} else if (compose.sourceType === "git") { |
|
|
command += await getCustomGitCloneCommand( |
|
|
compose, |
|
|
deployment.logPath, |
|
|
true, |
|
|
); |
|
|
console.log(command); |
|
|
} else if (compose.sourceType === "raw") { |
|
|
command += getCreateComposeFileCommand(compose, deployment.logPath); |
|
|
} else if (compose.sourceType === "gitea") { |
|
|
command += await getGiteaCloneCommand( |
|
|
compose, |
|
|
deployment.logPath, |
|
|
true, |
|
|
); |
|
|
} |
|
|
|
|
|
await execAsyncRemote(compose.serverId, command); |
|
|
await getBuildComposeCommand(compose, deployment.logPath); |
|
|
} |
|
|
|
|
|
await updateDeploymentStatus(deployment.deploymentId, "done"); |
|
|
await updateCompose(composeId, { |
|
|
composeStatus: "done", |
|
|
}); |
|
|
|
|
|
await sendBuildSuccessNotifications({ |
|
|
projectName: compose.project.name, |
|
|
applicationName: compose.name, |
|
|
applicationType: "compose", |
|
|
buildLink, |
|
|
organizationId: compose.project.organizationId, |
|
|
domains: compose.domains, |
|
|
}); |
|
|
} catch (error) { |
|
|
|
|
|
const encodedContent = encodeBase64(error?.message); |
|
|
|
|
|
await execAsyncRemote( |
|
|
compose.serverId, |
|
|
` |
|
|
echo "\n\n===================================EXTRA LOGS============================================" >> ${deployment.logPath}; |
|
|
echo "Error occurred ❌, check the logs for details." >> ${deployment.logPath}; |
|
|
echo "${encodedContent}" | base64 -d >> "${deployment.logPath}";`, |
|
|
); |
|
|
await updateDeploymentStatus(deployment.deploymentId, "error"); |
|
|
await updateCompose(composeId, { |
|
|
composeStatus: "error", |
|
|
}); |
|
|
await sendBuildErrorNotifications({ |
|
|
projectName: compose.project.name, |
|
|
applicationName: compose.name, |
|
|
applicationType: "compose", |
|
|
|
|
|
errorMessage: error?.message || "Error building", |
|
|
buildLink, |
|
|
organizationId: compose.project.organizationId, |
|
|
}); |
|
|
throw error; |
|
|
} |
|
|
}; |
|
|
|
|
|
export const rebuildRemoteCompose = async ({ |
|
|
composeId, |
|
|
titleLog = "Rebuild deployment", |
|
|
descriptionLog = "", |
|
|
}: { |
|
|
composeId: string; |
|
|
titleLog: string; |
|
|
descriptionLog: string; |
|
|
}) => { |
|
|
const compose = await findComposeById(composeId); |
|
|
|
|
|
const deployment = await createDeploymentCompose({ |
|
|
composeId: composeId, |
|
|
title: titleLog, |
|
|
description: descriptionLog, |
|
|
}); |
|
|
|
|
|
try { |
|
|
if (compose.sourceType === "raw") { |
|
|
const command = getCreateComposeFileCommand(compose, deployment.logPath); |
|
|
await execAsyncRemote(compose.serverId, command); |
|
|
} |
|
|
if (compose.serverId) { |
|
|
await getBuildComposeCommand(compose, deployment.logPath); |
|
|
} |
|
|
|
|
|
await updateDeploymentStatus(deployment.deploymentId, "done"); |
|
|
await updateCompose(composeId, { |
|
|
composeStatus: "done", |
|
|
}); |
|
|
} catch (error) { |
|
|
|
|
|
const encodedContent = encodeBase64(error?.message); |
|
|
|
|
|
await execAsyncRemote( |
|
|
compose.serverId, |
|
|
` |
|
|
echo "\n\n===================================EXTRA LOGS============================================" >> ${deployment.logPath}; |
|
|
echo "Error occurred ❌, check the logs for details." >> ${deployment.logPath}; |
|
|
echo "${encodedContent}" | base64 -d >> "${deployment.logPath}";`, |
|
|
); |
|
|
await updateDeploymentStatus(deployment.deploymentId, "error"); |
|
|
await updateCompose(composeId, { |
|
|
composeStatus: "error", |
|
|
}); |
|
|
throw error; |
|
|
} |
|
|
|
|
|
return true; |
|
|
}; |
|
|
|
|
|
export const removeCompose = async ( |
|
|
compose: Compose, |
|
|
deleteVolumes: boolean, |
|
|
) => { |
|
|
try { |
|
|
const { COMPOSE_PATH } = paths(!!compose.serverId); |
|
|
const projectPath = join(COMPOSE_PATH, compose.appName); |
|
|
|
|
|
if (compose.composeType === "stack") { |
|
|
const command = ` |
|
|
docker network disconnect ${compose.appName} dokploy-traefik; |
|
|
cd ${projectPath} && docker stack rm ${compose.appName} && rm -rf ${projectPath}`; |
|
|
|
|
|
if (compose.serverId) { |
|
|
await execAsyncRemote(compose.serverId, command); |
|
|
} else { |
|
|
await execAsync(command); |
|
|
} |
|
|
await execAsync(command, { |
|
|
cwd: projectPath, |
|
|
}); |
|
|
} else { |
|
|
const command = ` |
|
|
docker network disconnect ${compose.appName} dokploy-traefik; |
|
|
cd ${projectPath} && docker compose -p ${compose.appName} down ${ |
|
|
deleteVolumes ? "--volumes" : "" |
|
|
} && rm -rf ${projectPath}`; |
|
|
|
|
|
if (compose.serverId) { |
|
|
await execAsyncRemote(compose.serverId, command); |
|
|
} else { |
|
|
await execAsync(command, { |
|
|
cwd: projectPath, |
|
|
}); |
|
|
} |
|
|
} |
|
|
} catch (error) { |
|
|
throw error; |
|
|
} |
|
|
|
|
|
return true; |
|
|
}; |
|
|
|
|
|
export const startCompose = async (composeId: string) => { |
|
|
const compose = await findComposeById(composeId); |
|
|
try { |
|
|
const { COMPOSE_PATH } = paths(!!compose.serverId); |
|
|
if (compose.composeType === "docker-compose") { |
|
|
if (compose.serverId) { |
|
|
await execAsyncRemote( |
|
|
compose.serverId, |
|
|
`cd ${join( |
|
|
COMPOSE_PATH, |
|
|
compose.appName, |
|
|
"code", |
|
|
)} && docker compose -p ${compose.appName} up -d`, |
|
|
); |
|
|
} else { |
|
|
await execAsync(`docker compose -p ${compose.appName} up -d`, { |
|
|
cwd: join(COMPOSE_PATH, compose.appName, "code"), |
|
|
}); |
|
|
} |
|
|
} |
|
|
|
|
|
await updateCompose(composeId, { |
|
|
composeStatus: "done", |
|
|
}); |
|
|
} catch (error) { |
|
|
await updateCompose(composeId, { |
|
|
composeStatus: "idle", |
|
|
}); |
|
|
throw error; |
|
|
} |
|
|
|
|
|
return true; |
|
|
}; |
|
|
|
|
|
export const stopCompose = async (composeId: string) => { |
|
|
const compose = await findComposeById(composeId); |
|
|
try { |
|
|
const { COMPOSE_PATH } = paths(!!compose.serverId); |
|
|
if (compose.composeType === "docker-compose") { |
|
|
if (compose.serverId) { |
|
|
await execAsyncRemote( |
|
|
compose.serverId, |
|
|
`cd ${join(COMPOSE_PATH, compose.appName)} && docker compose -p ${ |
|
|
compose.appName |
|
|
} stop`, |
|
|
); |
|
|
} else { |
|
|
await execAsync(`docker compose -p ${compose.appName} stop`, { |
|
|
cwd: join(COMPOSE_PATH, compose.appName), |
|
|
}); |
|
|
} |
|
|
} |
|
|
|
|
|
if (compose.composeType === "stack") { |
|
|
if (compose.serverId) { |
|
|
await execAsyncRemote( |
|
|
compose.serverId, |
|
|
`docker stack rm ${compose.appName}`, |
|
|
); |
|
|
} else { |
|
|
await execAsync(`docker stack rm ${compose.appName}`); |
|
|
} |
|
|
} |
|
|
|
|
|
await updateCompose(composeId, { |
|
|
composeStatus: "idle", |
|
|
}); |
|
|
} catch (error) { |
|
|
await updateCompose(composeId, { |
|
|
composeStatus: "error", |
|
|
}); |
|
|
throw error; |
|
|
} |
|
|
|
|
|
return true; |
|
|
}; |
|
|
|
