| import { logger } from "@dokploy/server/lib/logger"; |
| import type { BackupSchedule } from "@dokploy/server/services/backup"; |
| import type { Destination } from "@dokploy/server/services/destination"; |
| import { scheduleJob, scheduledJobs } from "node-schedule"; |
| import { keepLatestNBackups } from "."; |
| import { runComposeBackup } from "./compose"; |
| import { runMariadbBackup } from "./mariadb"; |
| import { runMongoBackup } from "./mongo"; |
| import { runMySqlBackup } from "./mysql"; |
| import { runPostgresBackup } from "./postgres"; |
| import { runWebServerBackup } from "./web-server"; |
|
|
| export const scheduleBackup = (backup: BackupSchedule) => { |
| const { |
| schedule, |
| backupId, |
| databaseType, |
| postgres, |
| mysql, |
| mongo, |
| mariadb, |
| compose, |
| } = backup; |
| scheduleJob(backupId, schedule, async () => { |
| if (backup.backupType === "database") { |
| if (databaseType === "postgres" && postgres) { |
| await runPostgresBackup(postgres, backup); |
| await keepLatestNBackups(backup, postgres.serverId); |
| } else if (databaseType === "mysql" && mysql) { |
| await runMySqlBackup(mysql, backup); |
| await keepLatestNBackups(backup, mysql.serverId); |
| } else if (databaseType === "mongo" && mongo) { |
| await runMongoBackup(mongo, backup); |
| await keepLatestNBackups(backup, mongo.serverId); |
| } else if (databaseType === "mariadb" && mariadb) { |
| await runMariadbBackup(mariadb, backup); |
| await keepLatestNBackups(backup, mariadb.serverId); |
| } else if (databaseType === "web-server") { |
| await runWebServerBackup(backup); |
| await keepLatestNBackups(backup); |
| } |
| } else if (backup.backupType === "compose" && compose) { |
| await runComposeBackup(compose, backup); |
| await keepLatestNBackups(backup, compose.serverId); |
| } |
| }); |
| }; |
|
|
| export const removeScheduleBackup = (backupId: string) => { |
| const currentJob = scheduledJobs[backupId]; |
| currentJob?.cancel(); |
| }; |
|
|
| export const normalizeS3Path = (prefix: string) => { |
| |
| const normalizedPrefix = prefix.trim().replace(/^\/+|\/+$/g, ""); |
| |
| return normalizedPrefix ? `${normalizedPrefix}/` : ""; |
| }; |
|
|
| export const getS3Credentials = (destination: Destination) => { |
| const { accessKey, secretAccessKey, region, endpoint, provider } = |
| destination; |
| const rcloneFlags = [ |
| `--s3-access-key-id=${accessKey}`, |
| `--s3-secret-access-key=${secretAccessKey}`, |
| `--s3-region=${region}`, |
| `--s3-endpoint=${endpoint}`, |
| "--s3-no-check-bucket", |
| "--s3-force-path-style", |
| ]; |
|
|
| if (provider) { |
| rcloneFlags.unshift(`--s3-provider=${provider}`); |
| } |
|
|
| return rcloneFlags; |
| }; |
|
|
| export const getPostgresBackupCommand = ( |
| database: string, |
| databaseUser: string, |
| ) => { |
| return `docker exec -i $CONTAINER_ID bash -c "set -o pipefail; pg_dump -Fc --no-acl --no-owner -h localhost -U ${databaseUser} --no-password '${database}' | gzip"`; |
| }; |
|
|
| export const getMariadbBackupCommand = ( |
| database: string, |
| databaseUser: string, |
| databasePassword: string, |
| ) => { |
| return `docker exec -i $CONTAINER_ID bash -c "set -o pipefail; mariadb-dump --user='${databaseUser}' --password='${databasePassword}' --databases ${database} | gzip"`; |
| }; |
|
|
| export const getMysqlBackupCommand = ( |
| database: string, |
| databasePassword: string, |
| ) => { |
| return `docker exec -i $CONTAINER_ID bash -c "set -o pipefail; mysqldump --default-character-set=utf8mb4 -u 'root' --password='${databasePassword}' --single-transaction --no-tablespaces --quick '${database}' | gzip"`; |
| }; |
|
|
| export const getMongoBackupCommand = ( |
| database: string, |
| databaseUser: string, |
| databasePassword: string, |
| ) => { |
| return `docker exec -i $CONTAINER_ID bash -c "set -o pipefail; mongodump -d '${database}' -u '${databaseUser}' -p '${databasePassword}' --archive --authenticationDatabase admin --gzip"`; |
| }; |
|
|
| export const getServiceContainerCommand = (appName: string) => { |
| return `docker ps -q --filter "status=running" --filter "label=com.docker.swarm.service.name=${appName}" | head -n 1`; |
| }; |
|
|
| export const getComposeContainerCommand = ( |
| appName: string, |
| serviceName: string, |
| composeType: "stack" | "docker-compose" | undefined, |
| ) => { |
| if (composeType === "stack") { |
| return `docker ps -q --filter "status=running" --filter "label=com.docker.stack.namespace=${appName}" --filter "label=com.docker.swarm.service.name=${appName}_${serviceName}" | head -n 1`; |
| } |
| return `docker ps -q --filter "status=running" --filter "label=com.docker.compose.project=${appName}" --filter "label=com.docker.compose.service=${serviceName}" | head -n 1`; |
| }; |
|
|
| const getContainerSearchCommand = (backup: BackupSchedule) => { |
| const { backupType, postgres, mysql, mariadb, mongo, compose, serviceName } = |
| backup; |
|
|
| if (backupType === "database") { |
| const appName = |
| postgres?.appName || mysql?.appName || mariadb?.appName || mongo?.appName; |
| return getServiceContainerCommand(appName || ""); |
| } |
| if (backupType === "compose") { |
| const { appName, composeType } = compose || {}; |
| return getComposeContainerCommand( |
| appName || "", |
| serviceName || "", |
| composeType, |
| ); |
| } |
| }; |
|
|
| export const generateBackupCommand = (backup: BackupSchedule) => { |
| const { backupType, databaseType } = backup; |
| switch (databaseType) { |
| case "postgres": { |
| const postgres = backup.postgres; |
| if (backupType === "database" && postgres) { |
| return getPostgresBackupCommand(backup.database, postgres.databaseUser); |
| } |
| if (backupType === "compose" && backup.metadata?.postgres) { |
| return getPostgresBackupCommand( |
| backup.database, |
| backup.metadata.postgres.databaseUser, |
| ); |
| } |
| break; |
| } |
| case "mysql": { |
| const mysql = backup.mysql; |
| if (backupType === "database" && mysql) { |
| return getMysqlBackupCommand( |
| backup.database, |
| mysql.databaseRootPassword, |
| ); |
| } |
| if (backupType === "compose" && backup.metadata?.mysql) { |
| return getMysqlBackupCommand( |
| backup.database, |
| backup.metadata?.mysql?.databaseRootPassword || "", |
| ); |
| } |
| break; |
| } |
| case "mariadb": { |
| const mariadb = backup.mariadb; |
| if (backupType === "database" && mariadb) { |
| return getMariadbBackupCommand( |
| backup.database, |
| mariadb.databaseUser, |
| mariadb.databasePassword, |
| ); |
| } |
| if (backupType === "compose" && backup.metadata?.mariadb) { |
| return getMariadbBackupCommand( |
| backup.database, |
| backup.metadata.mariadb.databaseUser, |
| backup.metadata.mariadb.databasePassword, |
| ); |
| } |
| break; |
| } |
| case "mongo": { |
| const mongo = backup.mongo; |
| if (backupType === "database" && mongo) { |
| return getMongoBackupCommand( |
| backup.database, |
| mongo.databaseUser, |
| mongo.databasePassword, |
| ); |
| } |
| if (backupType === "compose" && backup.metadata?.mongo) { |
| return getMongoBackupCommand( |
| backup.database, |
| backup.metadata.mongo.databaseUser, |
| backup.metadata.mongo.databasePassword, |
| ); |
| } |
| break; |
| } |
| default: |
| throw new Error(`Database type not supported: ${databaseType}`); |
| } |
|
|
| return null; |
| }; |
|
|
| export const getBackupCommand = ( |
| backup: BackupSchedule, |
| rcloneCommand: string, |
| logPath: string, |
| ) => { |
| const containerSearch = getContainerSearchCommand(backup); |
| const backupCommand = generateBackupCommand(backup); |
|
|
| logger.info( |
| { |
| containerSearch, |
| backupCommand, |
| rcloneCommand, |
| logPath, |
| }, |
| `Executing backup command: ${backup.databaseType} ${backup.backupType}`, |
| ); |
|
|
| return ` |
| set -eo pipefail; |
| echo "[$(date)] Starting backup process..." >> ${logPath}; |
| echo "[$(date)] Executing backup command..." >> ${logPath}; |
| CONTAINER_ID=$(${containerSearch}) |
| |
| if [ -z "$CONTAINER_ID" ]; then |
| echo "[$(date)] ❌ Error: Container not found" >> ${logPath}; |
| exit 1; |
| fi |
| |
| echo "[$(date)] Container Up: $CONTAINER_ID" >> ${logPath}; |
| |
| # Run the backup command and capture the exit status |
| BACKUP_OUTPUT=$(${backupCommand} 2>&1 >/dev/null) || { |
| echo "[$(date)] ❌ Error: Backup failed" >> ${logPath}; |
| echo "Error: $BACKUP_OUTPUT" >> ${logPath}; |
| exit 1; |
| } |
| |
| echo "[$(date)] ✅ backup completed successfully" >> ${logPath}; |
| echo "[$(date)] Starting upload to S3..." >> ${logPath}; |
| |
| # Run the upload command and capture the exit status |
| UPLOAD_OUTPUT=$(${backupCommand} | ${rcloneCommand} 2>&1 >/dev/null) || { |
| echo "[$(date)] ❌ Error: Upload to S3 failed" >> ${logPath}; |
| echo "Error: $UPLOAD_OUTPUT" >> ${logPath}; |
| exit 1; |
| } |
| |
| echo "[$(date)] ✅ Upload to S3 completed successfully" >> ${logPath}; |
| echo "Backup done ✅" >> ${logPath}; |
| `; |
| }; |
|
|
