| import { docker } from "@dokploy/server/constants"; |
| import { db } from "@dokploy/server/db"; |
| import { |
| type apiCreateApplication, |
| applications, |
| buildAppName, |
| } from "@dokploy/server/db/schema"; |
| import { getAdvancedStats } from "@dokploy/server/monitoring/utils"; |
| import { |
| buildApplication, |
| getBuildCommand, |
| mechanizeDockerContainer, |
| } from "@dokploy/server/utils/builders"; |
| import { sendBuildErrorNotifications } from "@dokploy/server/utils/notifications/build-error"; |
| import { sendBuildSuccessNotifications } from "@dokploy/server/utils/notifications/build-success"; |
| import { execAsyncRemote } from "@dokploy/server/utils/process/execAsync"; |
| import { |
| cloneBitbucketRepository, |
| getBitbucketCloneCommand, |
| } from "@dokploy/server/utils/providers/bitbucket"; |
| import { |
| buildDocker, |
| buildRemoteDocker, |
| } from "@dokploy/server/utils/providers/docker"; |
| 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 { createTraefikConfig } from "@dokploy/server/utils/traefik/application"; |
| import { TRPCError } from "@trpc/server"; |
| import { eq } from "drizzle-orm"; |
| import { encodeBase64 } from "../utils/docker/utils"; |
| import { getDokployUrl } from "./admin"; |
| import { |
| createDeployment, |
| createDeploymentPreview, |
| updateDeploymentStatus, |
| } from "./deployment"; |
| import { type Domain, getDomainHost } from "./domain"; |
| import { |
| createPreviewDeploymentComment, |
| getIssueComment, |
| issueCommentExists, |
| updateIssueComment, |
| } from "./github"; |
| import { |
| findPreviewDeploymentById, |
| updatePreviewDeployment, |
| } from "./preview-deployment"; |
| import { validUniqueServerAppName } from "./project"; |
| export type Application = typeof applications.$inferSelect; |
|
|
| export const createApplication = async ( |
| input: typeof apiCreateApplication._type, |
| ) => { |
| const appName = buildAppName("app", input.appName); |
|
|
| const valid = await validUniqueServerAppName(appName); |
| if (!valid) { |
| throw new TRPCError({ |
| code: "CONFLICT", |
| message: "Application with this 'AppName' already exists", |
| }); |
| } |
|
|
| return await db.transaction(async (tx) => { |
| const newApplication = await tx |
| .insert(applications) |
| .values({ |
| ...input, |
| appName, |
| }) |
| .returning() |
| .then((value) => value[0]); |
|
|
| if (!newApplication) { |
| throw new TRPCError({ |
| code: "BAD_REQUEST", |
| message: "Error creating the application", |
| }); |
| } |
|
|
| if (process.env.NODE_ENV === "development") { |
| createTraefikConfig(newApplication.appName); |
| } |
|
|
| return newApplication; |
| }); |
| }; |
|
|
| export const findApplicationById = async (applicationId: string) => { |
| const application = await db.query.applications.findFirst({ |
| where: eq(applications.applicationId, applicationId), |
| with: { |
| project: true, |
| domains: true, |
| deployments: true, |
| mounts: true, |
| redirects: true, |
| security: true, |
| ports: true, |
| registry: true, |
| gitlab: true, |
| github: true, |
| bitbucket: true, |
| gitea: true, |
| server: true, |
| previewDeployments: true, |
| }, |
| }); |
| if (!application) { |
| throw new TRPCError({ |
| code: "NOT_FOUND", |
| message: "Application not found", |
| }); |
| } |
| return application; |
| }; |
|
|
| export const findApplicationByName = async (appName: string) => { |
| const application = await db.query.applications.findFirst({ |
| where: eq(applications.appName, appName), |
| }); |
|
|
| return application; |
| }; |
|
|
| export const updateApplication = async ( |
| applicationId: string, |
| applicationData: Partial<Application>, |
| ) => { |
| const { appName, ...rest } = applicationData; |
| const application = await db |
| .update(applications) |
| .set({ |
| ...rest, |
| }) |
| .where(eq(applications.applicationId, applicationId)) |
| .returning(); |
|
|
| return application[0]; |
| }; |
|
|
| export const updateApplicationStatus = async ( |
| applicationId: string, |
| applicationStatus: Application["applicationStatus"], |
| ) => { |
| const application = await db |
| .update(applications) |
| .set({ |
| applicationStatus: applicationStatus, |
| }) |
| .where(eq(applications.applicationId, applicationId)) |
| .returning(); |
|
|
| return application; |
| }; |
|
|
| export const deployApplication = async ({ |
| applicationId, |
| titleLog = "Manual deployment", |
| descriptionLog = "", |
| }: { |
| applicationId: string; |
| titleLog: string; |
| descriptionLog: string; |
| }) => { |
| const application = await findApplicationById(applicationId); |
|
|
| const buildLink = `${await getDokployUrl()}/dashboard/project/${application.projectId}/services/application/${application.applicationId}?tab=deployments`; |
| const deployment = await createDeployment({ |
| applicationId: applicationId, |
| title: titleLog, |
| description: descriptionLog, |
| }); |
|
|
| try { |
| if (application.sourceType === "github") { |
| await cloneGithubRepository({ |
| ...application, |
| logPath: deployment.logPath, |
| }); |
| await buildApplication(application, deployment.logPath); |
| } else if (application.sourceType === "gitlab") { |
| await cloneGitlabRepository(application, deployment.logPath); |
| await buildApplication(application, deployment.logPath); |
| } else if (application.sourceType === "gitea") { |
| await cloneGiteaRepository(application, deployment.logPath); |
| await buildApplication(application, deployment.logPath); |
| } else if (application.sourceType === "bitbucket") { |
| await cloneBitbucketRepository(application, deployment.logPath); |
| await buildApplication(application, deployment.logPath); |
| } else if (application.sourceType === "docker") { |
| await buildDocker(application, deployment.logPath); |
| } else if (application.sourceType === "git") { |
| await cloneGitRepository(application, deployment.logPath); |
| await buildApplication(application, deployment.logPath); |
| } else if (application.sourceType === "drop") { |
| await buildApplication(application, deployment.logPath); |
| } |
|
|
| await updateDeploymentStatus(deployment.deploymentId, "done"); |
| await updateApplicationStatus(applicationId, "done"); |
|
|
| await sendBuildSuccessNotifications({ |
| projectName: application.project.name, |
| applicationName: application.name, |
| applicationType: "application", |
| buildLink, |
| organizationId: application.project.organizationId, |
| domains: application.domains, |
| }); |
| } catch (error) { |
| await updateDeploymentStatus(deployment.deploymentId, "error"); |
| await updateApplicationStatus(applicationId, "error"); |
| await sendBuildErrorNotifications({ |
| projectName: application.project.name, |
| applicationName: application.name, |
| applicationType: "application", |
| |
| errorMessage: error?.message || "Error building", |
| buildLink, |
| organizationId: application.project.organizationId, |
| }); |
|
|
| throw error; |
| } |
|
|
| return true; |
| }; |
|
|
| export const rebuildApplication = async ({ |
| applicationId, |
| titleLog = "Rebuild deployment", |
| descriptionLog = "", |
| }: { |
| applicationId: string; |
| titleLog: string; |
| descriptionLog: string; |
| }) => { |
| const application = await findApplicationById(applicationId); |
|
|
| const deployment = await createDeployment({ |
| applicationId: applicationId, |
| title: titleLog, |
| description: descriptionLog, |
| }); |
|
|
| try { |
| if (application.sourceType === "github") { |
| await buildApplication(application, deployment.logPath); |
| } else if (application.sourceType === "gitlab") { |
| await buildApplication(application, deployment.logPath); |
| } else if (application.sourceType === "bitbucket") { |
| await buildApplication(application, deployment.logPath); |
| } else if (application.sourceType === "docker") { |
| await buildDocker(application, deployment.logPath); |
| } else if (application.sourceType === "git") { |
| await buildApplication(application, deployment.logPath); |
| } else if (application.sourceType === "drop") { |
| await buildApplication(application, deployment.logPath); |
| } |
| await updateDeploymentStatus(deployment.deploymentId, "done"); |
| await updateApplicationStatus(applicationId, "done"); |
| } catch (error) { |
| await updateDeploymentStatus(deployment.deploymentId, "error"); |
| await updateApplicationStatus(applicationId, "error"); |
| throw error; |
| } |
|
|
| return true; |
| }; |
|
|
| export const deployRemoteApplication = async ({ |
| applicationId, |
| titleLog = "Manual deployment", |
| descriptionLog = "", |
| }: { |
| applicationId: string; |
| titleLog: string; |
| descriptionLog: string; |
| }) => { |
| const application = await findApplicationById(applicationId); |
|
|
| const buildLink = `${await getDokployUrl()}/dashboard/project/${application.projectId}/services/application/${application.applicationId}?tab=deployments`; |
| const deployment = await createDeployment({ |
| applicationId: applicationId, |
| title: titleLog, |
| description: descriptionLog, |
| }); |
|
|
| try { |
| if (application.serverId) { |
| let command = "set -e;"; |
| if (application.sourceType === "github") { |
| command += await getGithubCloneCommand({ |
| ...application, |
| serverId: application.serverId, |
| logPath: deployment.logPath, |
| }); |
| } else if (application.sourceType === "gitlab") { |
| command += await getGitlabCloneCommand(application, deployment.logPath); |
| } else if (application.sourceType === "bitbucket") { |
| command += await getBitbucketCloneCommand( |
| application, |
| deployment.logPath, |
| ); |
| } else if (application.sourceType === "gitea") { |
| command += await getGiteaCloneCommand(application, deployment.logPath); |
| } else if (application.sourceType === "git") { |
| command += await getCustomGitCloneCommand( |
| application, |
| deployment.logPath, |
| ); |
| } else if (application.sourceType === "docker") { |
| command += await buildRemoteDocker(application, deployment.logPath); |
| } |
|
|
| if (application.sourceType !== "docker") { |
| command += getBuildCommand(application, deployment.logPath); |
| } |
| await execAsyncRemote(application.serverId, command); |
| await mechanizeDockerContainer(application); |
| } |
|
|
| await updateDeploymentStatus(deployment.deploymentId, "done"); |
| await updateApplicationStatus(applicationId, "done"); |
|
|
| await sendBuildSuccessNotifications({ |
| projectName: application.project.name, |
| applicationName: application.name, |
| applicationType: "application", |
| buildLink, |
| organizationId: application.project.organizationId, |
| domains: application.domains, |
| }); |
| } catch (error) { |
| |
| const encodedContent = encodeBase64(error?.message); |
|
|
| await execAsyncRemote( |
| application.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 updateApplicationStatus(applicationId, "error"); |
| await sendBuildErrorNotifications({ |
| projectName: application.project.name, |
| applicationName: application.name, |
| applicationType: "application", |
| |
| errorMessage: error?.message || "Error building", |
| buildLink, |
| organizationId: application.project.organizationId, |
| }); |
|
|
| throw error; |
| } |
|
|
| return true; |
| }; |
|
|
| export const deployPreviewApplication = async ({ |
| applicationId, |
| titleLog = "Preview Deployment", |
| descriptionLog = "", |
| previewDeploymentId, |
| }: { |
| applicationId: string; |
| titleLog: string; |
| descriptionLog: string; |
| previewDeploymentId: string; |
| }) => { |
| const application = await findApplicationById(applicationId); |
|
|
| const deployment = await createDeploymentPreview({ |
| title: titleLog, |
| description: descriptionLog, |
| previewDeploymentId: previewDeploymentId, |
| }); |
|
|
| const previewDeployment = |
| await findPreviewDeploymentById(previewDeploymentId); |
|
|
| await updatePreviewDeployment(previewDeploymentId, { |
| createdAt: new Date().toISOString(), |
| }); |
|
|
| const previewDomain = getDomainHost(previewDeployment?.domain as Domain); |
| const issueParams = { |
| owner: application?.owner || "", |
| repository: application?.repository || "", |
| issue_number: previewDeployment.pullRequestNumber, |
| comment_id: Number.parseInt(previewDeployment.pullRequestCommentId), |
| githubId: application?.githubId || "", |
| }; |
| try { |
| const commentExists = await issueCommentExists({ |
| ...issueParams, |
| }); |
| if (!commentExists) { |
| const result = await createPreviewDeploymentComment({ |
| ...issueParams, |
| previewDomain, |
| appName: previewDeployment.appName, |
| githubId: application?.githubId || "", |
| previewDeploymentId, |
| }); |
|
|
| if (!result) { |
| throw new TRPCError({ |
| code: "NOT_FOUND", |
| message: "Pull request comment not found", |
| }); |
| } |
|
|
| issueParams.comment_id = Number.parseInt(result?.pullRequestCommentId); |
| } |
| const buildingComment = getIssueComment( |
| application.name, |
| "running", |
| previewDomain, |
| ); |
| await updateIssueComment({ |
| ...issueParams, |
| body: `### Dokploy Preview Deployment\n\n${buildingComment}`, |
| }); |
| application.appName = previewDeployment.appName; |
| application.env = `${application.previewEnv}\nDOKPLOY_DEPLOY_URL=${previewDeployment?.domain?.host}`; |
| application.buildArgs = application.previewBuildArgs; |
|
|
| if (application.sourceType === "github") { |
| await cloneGithubRepository({ |
| ...application, |
| appName: previewDeployment.appName, |
| branch: previewDeployment.branch, |
| logPath: deployment.logPath, |
| }); |
| await buildApplication(application, deployment.logPath); |
| } |
| const successComment = getIssueComment( |
| application.name, |
| "success", |
| previewDomain, |
| ); |
| await updateIssueComment({ |
| ...issueParams, |
| body: `### Dokploy Preview Deployment\n\n${successComment}`, |
| }); |
| await updateDeploymentStatus(deployment.deploymentId, "done"); |
| await updatePreviewDeployment(previewDeploymentId, { |
| previewStatus: "done", |
| }); |
| } catch (error) { |
| const comment = getIssueComment(application.name, "error", previewDomain); |
| await updateIssueComment({ |
| ...issueParams, |
| body: `### Dokploy Preview Deployment\n\n${comment}`, |
| }); |
| await updateDeploymentStatus(deployment.deploymentId, "error"); |
| await updatePreviewDeployment(previewDeploymentId, { |
| previewStatus: "error", |
| }); |
| throw error; |
| } |
|
|
| return true; |
| }; |
|
|
| export const deployRemotePreviewApplication = async ({ |
| applicationId, |
| titleLog = "Preview Deployment", |
| descriptionLog = "", |
| previewDeploymentId, |
| }: { |
| applicationId: string; |
| titleLog: string; |
| descriptionLog: string; |
| previewDeploymentId: string; |
| }) => { |
| const application = await findApplicationById(applicationId); |
|
|
| const deployment = await createDeploymentPreview({ |
| title: titleLog, |
| description: descriptionLog, |
| previewDeploymentId: previewDeploymentId, |
| }); |
|
|
| const previewDeployment = |
| await findPreviewDeploymentById(previewDeploymentId); |
|
|
| await updatePreviewDeployment(previewDeploymentId, { |
| createdAt: new Date().toISOString(), |
| }); |
|
|
| const previewDomain = getDomainHost(previewDeployment?.domain as Domain); |
| const issueParams = { |
| owner: application?.owner || "", |
| repository: application?.repository || "", |
| issue_number: previewDeployment.pullRequestNumber, |
| comment_id: Number.parseInt(previewDeployment.pullRequestCommentId), |
| githubId: application?.githubId || "", |
| }; |
| try { |
| const commentExists = await issueCommentExists({ |
| ...issueParams, |
| }); |
| if (!commentExists) { |
| const result = await createPreviewDeploymentComment({ |
| ...issueParams, |
| previewDomain, |
| appName: previewDeployment.appName, |
| githubId: application?.githubId || "", |
| previewDeploymentId, |
| }); |
|
|
| if (!result) { |
| throw new TRPCError({ |
| code: "NOT_FOUND", |
| message: "Pull request comment not found", |
| }); |
| } |
|
|
| issueParams.comment_id = Number.parseInt(result?.pullRequestCommentId); |
| } |
| const buildingComment = getIssueComment( |
| application.name, |
| "running", |
| previewDomain, |
| ); |
| await updateIssueComment({ |
| ...issueParams, |
| body: `### Dokploy Preview Deployment\n\n${buildingComment}`, |
| }); |
| application.appName = previewDeployment.appName; |
| application.env = `${application.previewEnv}\nDOKPLOY_DEPLOY_URL=${previewDeployment?.domain?.host}`; |
| application.buildArgs = application.previewBuildArgs; |
|
|
| if (application.serverId) { |
| let command = "set -e;"; |
| if (application.sourceType === "github") { |
| command += await getGithubCloneCommand({ |
| ...application, |
| appName: previewDeployment.appName, |
| branch: previewDeployment.branch, |
| serverId: application.serverId, |
| logPath: deployment.logPath, |
| }); |
| } |
|
|
| command += getBuildCommand(application, deployment.logPath); |
| await execAsyncRemote(application.serverId, command); |
| await mechanizeDockerContainer(application); |
| } |
|
|
| const successComment = getIssueComment( |
| application.name, |
| "success", |
| previewDomain, |
| ); |
| await updateIssueComment({ |
| ...issueParams, |
| body: `### Dokploy Preview Deployment\n\n${successComment}`, |
| }); |
| await updateDeploymentStatus(deployment.deploymentId, "done"); |
| await updatePreviewDeployment(previewDeploymentId, { |
| previewStatus: "done", |
| }); |
| } catch (error) { |
| const comment = getIssueComment(application.name, "error", previewDomain); |
| await updateIssueComment({ |
| ...issueParams, |
| body: `### Dokploy Preview Deployment\n\n${comment}`, |
| }); |
| await updateDeploymentStatus(deployment.deploymentId, "error"); |
| await updatePreviewDeployment(previewDeploymentId, { |
| previewStatus: "error", |
| }); |
| throw error; |
| } |
|
|
| return true; |
| }; |
|
|
| export const rebuildRemoteApplication = async ({ |
| applicationId, |
| titleLog = "Rebuild deployment", |
| descriptionLog = "", |
| }: { |
| applicationId: string; |
| titleLog: string; |
| descriptionLog: string; |
| }) => { |
| const application = await findApplicationById(applicationId); |
|
|
| const deployment = await createDeployment({ |
| applicationId: applicationId, |
| title: titleLog, |
| description: descriptionLog, |
| }); |
|
|
| try { |
| if (application.serverId) { |
| if (application.sourceType !== "docker") { |
| let command = "set -e;"; |
| command += getBuildCommand(application, deployment.logPath); |
| await execAsyncRemote(application.serverId, command); |
| } |
| await mechanizeDockerContainer(application); |
| } |
| await updateDeploymentStatus(deployment.deploymentId, "done"); |
| await updateApplicationStatus(applicationId, "done"); |
| } catch (error) { |
| |
| const encodedContent = encodeBase64(error?.message); |
|
|
| await execAsyncRemote( |
| application.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 updateApplicationStatus(applicationId, "error"); |
| throw error; |
| } |
|
|
| return true; |
| }; |
|
|
| export const getApplicationStats = async (appName: string) => { |
| const filter = { |
| status: ["running"], |
| label: [`com.docker.swarm.service.name=${appName}`], |
| }; |
|
|
| const containers = await docker.listContainers({ |
| filters: JSON.stringify(filter), |
| }); |
|
|
| const container = containers[0]; |
| if (!container || container?.State !== "running") { |
| return null; |
| } |
|
|
| const data = await getAdvancedStats(appName); |
|
|
| return data; |
| }; |
|
|
