Merge branch 'canary' into feature/add-custom-webhook-notification-provider

packages/server/src/utils/access-log/handler.ts

@@ -1,5 +1,5 @@
 import { paths } from "@dokploy/server/constants";
-import { findAdmin } from "@dokploy/server/services/admin";
+import { findOwner } from "@dokploy/server/services/admin";
 import { updateUser } from "@dokploy/server/services/user";
 import { scheduledJobs, scheduleJob } from "node-schedule";
 import { execAsync } from "../process/execAsync";
@@ -29,9 +29,9 @@ export const startLogCleanup = async (
 			}
 		});
 
-		const admin = await findAdmin();
-		if (admin) {
-			await updateUser(admin.user.id, {
+		const owner = await findOwner();
+		if (owner) {
+			await updateUser(owner.user.id, {
 				logCleanupCron: cronExpression,
 			});
 		}
@@ -51,9 +51,9 @@ export const stopLogCleanup = async (): Promise<boolean> => {
 		}
 
 		// Update database
-		const admin = await findAdmin();
-		if (admin) {
-			await updateUser(admin.user.id, {
+		const owner = await findOwner();
+		if (owner) {
+			await updateUser(owner.user.id, {
 				logCleanupCron: null,
 			});
 		}
@@ -69,8 +69,8 @@ export const getLogCleanupStatus = async (): Promise<{
 	enabled: boolean;
 	cronExpression: string | null;
 }> => {
-	const admin = await findAdmin();
-	const cronExpression = admin?.user.logCleanupCron ?? null;
+	const owner = await findOwner();
+	const cronExpression = owner?.user.logCleanupCron ?? null;
 	return {
 		enabled: cronExpression !== null,
 		cronExpression,

packages/server/src/utils/backups/index.ts

@@ -6,11 +6,7 @@ import { eq } from "drizzle-orm";
 import { scheduleJob } from "node-schedule";
 import { db } from "../../db/index";
 import { startLogCleanup } from "../access-log/handler";
-import {
-	cleanUpDockerBuilder,
-	cleanUpSystemPrune,
-	cleanUpUnusedImages,
-} from "../docker/utils";
+import { cleanupAll } from "../docker/utils";
 import { sendDockerCleanupNotifications } from "../notifications/docker-cleanup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
 import { getS3Credentials, scheduleBackup } from "./utils";
@@ -34,9 +30,9 @@ export const initCronJobs = async () => {
 			console.log(
 				`Docker Cleanup ${new Date().toLocaleString()}]  Running docker cleanup`,
 			);
-			await cleanUpUnusedImages();
-			await cleanUpDockerBuilder();
-			await cleanUpSystemPrune();
+
+			await cleanupAll();
+
 			await sendDockerCleanupNotifications(admin.user.id);
 		});
 	}
@@ -50,9 +46,9 @@ export const initCronJobs = async () => {
 				console.log(
 					`SERVER-BACKUP[${new Date().toLocaleString()}] Running Cleanup ${name}`,
 				);
-				await cleanUpUnusedImages(serverId);
-				await cleanUpDockerBuilder(serverId);
-				await cleanUpSystemPrune(serverId);
+
+				await cleanupAll(serverId);
+
 				await sendDockerCleanupNotifications(
 					admin.user.id,
 					`Docker cleanup for Server ${name} (${serverId})`,

packages/server/src/utils/backups/utils.ts

@@ -62,16 +62,16 @@ 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-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}`);
+		rcloneFlags.unshift(`--s3-provider="${provider}"`);
 	}
 
 	return rcloneFlags;

packages/server/src/utils/builders/docker-file.ts

@@ -8,7 +8,6 @@ import {
 	getDockerContextPath,
 } from "../filesystem/directory";
 import type { ApplicationNested } from ".";
-import { createEnvFileCommand } from "./utils";
 
 export const getDockerCommand = (application: ApplicationNested) => {
 	const {
@@ -68,21 +67,7 @@ export const getDockerCommand = (application: ApplicationNested) => {
 			commandArgs.push("--secret", `type=env,id=${key}`);
 		}
 
-		/*
-			Do not generate an environment file when publishDirectory is specified,
-			as it could be publicly exposed.
-		*/
-		let command = "";
-		if (!publishDirectory) {
-			command += createEnvFileCommand(
-				dockerFilePath,
-				env,
-				application.environment.project.env,
-				application.environment.env,
-			);
-		}
-
-		command += `
+		const command = `
 echo "Building ${appName}" ;
 cd ${dockerContextPath} || { 
   echo "❌ The path ${dockerContextPath} does not exist" ;

packages/server/src/utils/builders/index.ts

@@ -1,6 +1,6 @@
 import type { InferResultType } from "@dokploy/server/types/with";
 import type { CreateServiceOptions } from "dockerode";
-import { uploadImageRemoteCommand } from "../cluster/upload";
+import { getRegistryTag, uploadImageRemoteCommand } from "../cluster/upload";
 import {
 	calculateResources,
 	generateBindMounts,
@@ -30,39 +30,45 @@ export type ApplicationNested = InferResultType<
 		ports: true;
 		registry: true;
 		buildRegistry: true;
+		rollbackRegistry: true;
+		deployments: true;
 		environment: { with: { project: true } };
 	}
 >;
 
-export const getBuildCommand = (application: ApplicationNested) => {
+export const getBuildCommand = async (application: ApplicationNested) => {
 	let command = "";
-	const { buildType } = application;
 
-	if (application.sourceType === "docker") {
-		return "";
+	if (application.sourceType !== "docker") {
+		const { buildType } = application;
+		switch (buildType) {
+			case "nixpacks":
+				command = getNixpacksCommand(application);
+				break;
+			case "heroku_buildpacks":
+				command = getHerokuCommand(application);
+				break;
+			case "paketo_buildpacks":
+				command = getPaketoCommand(application);
+				break;
+			case "static":
+				command = getStaticCommand(application);
+				break;
+			case "dockerfile":
+				command = getDockerCommand(application);
+				break;
+			case "railpack":
+				command = getRailpackCommand(application);
+				break;
+		}
 	}
-	switch (buildType) {
-		case "nixpacks":
-			command = getNixpacksCommand(application);
-			break;
-		case "heroku_buildpacks":
-			command = getHerokuCommand(application);
-			break;
-		case "paketo_buildpacks":
-			command = getPaketoCommand(application);
-			break;
-		case "static":
-			command = getStaticCommand(application);
-			break;
-		case "dockerfile":
-			command = getDockerCommand(application);
-			break;
-		case "railpack":
-			command = getRailpackCommand(application);
-			break;
-	}
-	if (application.registry || application.buildRegistry) {
-		command += uploadImageRemoteCommand(application);
+
+	if (
+		application.registry ||
+		application.buildRegistry ||
+		application.rollbackRegistry
+	) {
+		command += await uploadImageRemoteCommand(application);
 	}
 
 	return command;
@@ -188,17 +194,11 @@ const getImageName = (application: ApplicationNested) => {
 	}
 
 	if (registry) {
-		const { registryUrl, imagePrefix, username } = registry;
-		const registryTag = imagePrefix
-			? `${registryUrl ? `${registryUrl}/` : ""}${imagePrefix}/${imageName}`
-			: `${registryUrl ? `${registryUrl}/` : ""}${username}/${imageName}`;
+		const registryTag = getRegistryTag(registry, imageName);
 		return registryTag;
 	}
 	if (buildRegistry) {
-		const { registryUrl, imagePrefix, username } = buildRegistry;
-		const registryTag = imagePrefix
-			? `${registryUrl ? `${registryUrl}/` : ""}${imagePrefix}/${imageName}`
-			: `${registryUrl ? `${registryUrl}/` : ""}${username}/${imageName}`;
+		const registryTag = getRegistryTag(buildRegistry, imageName);
 		return registryTag;
 	}
 

packages/server/src/utils/cluster/upload.ts

@@ -1,16 +1,24 @@
+import { findAllDeploymentsByApplicationId } from "@dokploy/server/services/deployment";
 import type { Registry } from "@dokploy/server/services/registry";
+import { createRollback } from "@dokploy/server/services/rollbacks";
 import type { ApplicationNested } from "../builders";
 
-export const uploadImageRemoteCommand = (application: ApplicationNested) => {
+export const uploadImageRemoteCommand = async (
+	application: ApplicationNested,
+) => {
 	const registry = application.registry;
 	const buildRegistry = application.buildRegistry;
+	const rollbackRegistry = application.rollbackRegistry;
 
-	if (!registry && !buildRegistry) {
+	if (!registry && !buildRegistry && !rollbackRegistry) {
 		throw new Error("No registry found");
 	}
 
 	const { appName } = application;
-	const imageName = `${appName}:latest`;
+	const imageName =
+		application.sourceType === "docker"
+			? application.dockerImage || ""
+			: `${appName}:latest`;
 
 	const commands: string[] = [];
 	if (registry) {
@@ -35,16 +43,38 @@ export const uploadImageRemoteCommand = (application: ApplicationNested) => {
 			);
 		}
 	}
+
+	if (rollbackRegistry && application.rollbackActive) {
+		const deployment = await findAllDeploymentsByApplicationId(
+			application.applicationId,
+		);
+		if (!deployment || !deployment[0]) {
+			throw new Error("Deployment not found");
+		}
+		const deploymentId = deployment[0].deploymentId;
+		const rollback = await createRollback({
+			appName: appName,
+			deploymentId: deploymentId,
+		});
+
+		const rollbackRegistryTag = getRegistryTag(
+			rollbackRegistry,
+			rollback?.image || "",
+		);
+		if (rollbackRegistryTag) {
+			commands.push(`echo "🔄 [Enabled Rollback Registry]"`);
+			commands.push(
+				getRegistryCommands(rollbackRegistry, imageName, rollbackRegistryTag),
+			);
+		}
+	}
 	try {
 		return commands.join("\n");
 	} catch (error) {
 		throw error;
 	}
 };
-const getRegistryTag = (registry: Registry | null, imageName: string) => {
-	if (!registry) {
-		return null;
-	}
+export const getRegistryTag = (registry: Registry, imageName: string) => {
 	const { registryUrl, imagePrefix, username } = registry;
 	return imagePrefix
 		? `${registryUrl ? `${registryUrl}/` : ""}${imagePrefix}/${imageName}`

packages/server/src/utils/docker/utils.ts

@@ -144,81 +144,116 @@ export const getContainerByName = (name: string): Promise<ContainerInfo> => {
 		});
 	});
 };
-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) => {
+/**
+ * Docker commands passed through this method are held during Docker's build or pull process.
+ *
+ * https://github.com/Dokploy/dokploy/pull/3064
+ * https://github.com/fir4tozden
+ */
+export const dockerSafeExec = (exec: string) => `CHECK_INTERVAL=10
+
+echo "Preparing for execution..."
+
+while true; do
+    PROCESSES=$(ps aux | grep -E "docker build|docker pull" | grep -v grep)
+
+    if [ -z "$PROCESSES" ]; then
+        echo "Docker is idle. Starting execution..."
+        break
+    else
+        echo "Docker is busy. Will check again in $CHECK_INTERVAL seconds..."
+        sleep $CHECK_INTERVAL
+    fi
+done
+
+${exec}
+
+echo "Execution completed."`;
+
+export const cleanupContainers = async (serverId?: string) => {
 	try {
 		const command = "docker container prune --force";
+
 		if (serverId) {
-			await execAsyncRemote(serverId, command);
+			await execAsyncRemote(serverId, dockerSafeExec(command));
 		} else {
-			await execAsync(command);
+			await execAsync(dockerSafeExec(command));
 		}
 	} catch (error) {
 		console.error(error);
+
 		throw error;
 	}
 };
 
-export const cleanUpUnusedVolumes = async (serverId?: string) => {
+export const cleanupImages = async (serverId?: string) => {
 	try {
-		const command = "docker volume prune --force";
+		const command = "docker image prune --all --force";
+
 		if (serverId) {
-			await execAsyncRemote(serverId, command);
+			await execAsyncRemote(serverId, dockerSafeExec(command));
+		} else await execAsync(dockerSafeExec(command));
+	} catch (error) {
+		console.error(error);
+
+		throw error;
+	}
+};
+
+export const cleanupVolumes = async (serverId?: string) => {
+	try {
+		const command = "docker volume prune --all --force";
+
+		if (serverId) {
+			await execAsyncRemote(serverId, dockerSafeExec(command));
 		} else {
-			await execAsync(command);
+			await execAsync(dockerSafeExec(command));
 		}
 	} catch (error) {
 		console.error(error);
+
 		throw error;
 	}
 };
 
-export const cleanUpInactiveContainers = async () => {
+export const cleanupBuilders = async (serverId?: string) => {
 	try {
-		const containers = await docker.listContainers({ all: true });
-		const inactiveContainers = containers.filter(
-			(container) => container.State !== "running",
-		);
+		const command = "docker builder prune --all --force";
 
-		for (const container of inactiveContainers) {
-			await docker.getContainer(container.Id).remove({ force: true });
-			console.log(`Cleaning up inactive container: ${container.Id}`);
+		if (serverId) {
+			await execAsyncRemote(serverId, dockerSafeExec(command));
+		} else {
+			await execAsync(dockerSafeExec(command));
 		}
 	} catch (error) {
-		console.error("Error cleaning up inactive containers:", error);
+		console.error(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 cleanupSystem = async (serverId?: string) => {
+	try {
+		const command = "docker system prune --all --force";
+
+		if (serverId) {
+			await execAsyncRemote(serverId, dockerSafeExec(command));
+		} else {
+			await execAsync(dockerSafeExec(command));
+		}
+	} catch (error) {
+		console.error(error);
+
+		throw error;
 	}
 };
 
-export const cleanUpSystemPrune = async (serverId?: string) => {
-	const command = "docker system prune --force --volumes";
-	if (serverId) {
-		await execAsyncRemote(serverId, command);
-	} else {
-		await execAsync(command);
-	}
+export const cleanupAll = async (serverId?: string) => {
+	await cleanupContainers(serverId);
+	await cleanupImages(serverId);
+	await cleanupBuilders(serverId);
+	await cleanupSystem(serverId);
 };
 
 export const startService = async (appName: string) => {

packages/server/src/utils/notifications/volume-backup.ts

@@ -0,0 +1,274 @@
+import { db } from "@dokploy/server/db";
+import { notifications } from "@dokploy/server/db/schema";
+import { VolumeBackupEmail } from "@dokploy/server/emails/emails/volume-backup";
+import { renderAsync } from "@react-email/components";
+import { format } from "date-fns";
+import { and, eq } from "drizzle-orm";
+import {
+	sendDiscordNotification,
+	sendEmailNotification,
+	sendGotifyNotification,
+	sendNtfyNotification,
+	sendSlackNotification,
+	sendTelegramNotification,
+} from "./utils";
+
+export const sendVolumeBackupNotifications = async ({
+	projectName,
+	applicationName,
+	volumeName,
+	serviceType,
+	type,
+	errorMessage,
+	organizationId,
+	backupSize,
+}: {
+	projectName: string;
+	applicationName: string;
+	volumeName: string;
+	serviceType:
+		| "application"
+		| "postgres"
+		| "mysql"
+		| "mongodb"
+		| "mariadb"
+		| "redis"
+		| "compose";
+	type: "error" | "success";
+	organizationId: string;
+	errorMessage?: string;
+	backupSize?: string;
+}) => {
+	const date = new Date();
+	const unixDate = ~~(Number(date) / 1000);
+	const notificationList = await db.query.notifications.findMany({
+		where: and(
+			eq(notifications.volumeBackup, true),
+			eq(notifications.organizationId, organizationId),
+		),
+		with: {
+			email: true,
+			discord: true,
+			telegram: true,
+			slack: true,
+			gotify: true,
+			ntfy: true,
+		},
+	});
+
+	for (const notification of notificationList) {
+		const { email, discord, telegram, slack, gotify, ntfy } = notification;
+
+		if (email) {
+			const subject = `Volume Backup ${type === "success" ? "Successful" : "Failed"} - ${applicationName}`;
+			const htmlContent = await renderAsync(
+				VolumeBackupEmail({
+					projectName,
+					applicationName,
+					volumeName,
+					serviceType,
+					type,
+					errorMessage,
+					backupSize,
+					date: date.toISOString(),
+				}),
+			);
+			await sendEmailNotification(email, subject, htmlContent);
+		}
+
+		if (discord) {
+			const decorate = (decoration: string, text: string) =>
+				`${discord.decoration ? decoration : ""} ${text}`.trim();
+
+			await sendDiscordNotification(discord, {
+				title:
+					type === "success"
+						? decorate(">", "`✅` Volume Backup Successful")
+						: decorate(">", "`❌` Volume Backup Failed"),
+				color: type === "success" ? 0x57f287 : 0xed4245,
+				fields: [
+					{
+						name: decorate("`🛠️`", "Project"),
+						value: projectName,
+						inline: true,
+					},
+					{
+						name: decorate("`⚙️`", "Application"),
+						value: applicationName,
+						inline: true,
+					},
+					{
+						name: decorate("`💾`", "Volume Name"),
+						value: volumeName,
+						inline: true,
+					},
+					{
+						name: decorate("`🔧`", "Service Type"),
+						value: serviceType,
+						inline: true,
+					},
+					...(backupSize
+						? [
+								{
+									name: decorate("`📊`", "Backup Size"),
+									value: backupSize,
+									inline: true,
+								},
+							]
+						: []),
+					{
+						name: decorate("`📅`", "Date"),
+						value: `<t:${unixDate}:D>`,
+						inline: true,
+					},
+					{
+						name: decorate("`⌚`", "Time"),
+						value: `<t:${unixDate}:t>`,
+						inline: true,
+					},
+					{
+						name: decorate("`❓`", "Type"),
+						value: type
+							.replace("error", "Failed")
+							.replace("success", "Successful"),
+						inline: true,
+					},
+					...(type === "error" && errorMessage
+						? [
+								{
+									name: decorate("`⚠️`", "Error Message"),
+									value: `\`\`\`${errorMessage}\`\`\``,
+								},
+							]
+						: []),
+				],
+				timestamp: date.toISOString(),
+				footer: {
+					text: "Dokploy Volume Backup Notification",
+				},
+			});
+		}
+
+		if (gotify) {
+			const decorate = (decoration: string, text: string) =>
+				`${gotify.decoration ? decoration : ""} ${text}\n`;
+
+			await sendGotifyNotification(
+				gotify,
+				decorate(
+					type === "success" ? "✅" : "❌",
+					`Volume Backup ${type === "success" ? "Successful" : "Failed"}`,
+				),
+				`${decorate("🛠️", `Project: ${projectName}`)}` +
+					`${decorate("⚙️", `Application: ${applicationName}`)}` +
+					`${decorate("💾", `Volume Name: ${volumeName}`)}` +
+					`${decorate("🔧", `Service Type: ${serviceType}`)}` +
+					`${backupSize ? decorate("📊", `Backup Size: ${backupSize}`) : ""}` +
+					`${decorate("🕒", `Date: ${date.toLocaleString()}`)}` +
+					`${type === "error" && errorMessage ? decorate("❌", `Error:\n${errorMessage}`) : ""}`,
+			);
+		}
+
+		if (ntfy) {
+			await sendNtfyNotification(
+				ntfy,
+				`Volume Backup ${type === "success" ? "Successful" : "Failed"}`,
+				`${type === "success" ? "white_check_mark" : "x"}`,
+				"",
+				`🛠️Project: ${projectName}\n` +
+					`⚙️Application: ${applicationName}\n` +
+					`💾Volume Name: ${volumeName}\n` +
+					`🔧Service Type: ${serviceType}\n` +
+					`${backupSize ? `📊Backup Size: ${backupSize}\n` : ""}` +
+					`🕒Date: ${date.toLocaleString()}\n` +
+					`${type === "error" && errorMessage ? `❌Error:\n${errorMessage}` : ""}`,
+			);
+		}
+
+		if (telegram) {
+			const isError = type === "error" && errorMessage;
+
+			const statusEmoji = type === "success" ? "✅" : "❌";
+			const typeStatus = type === "success" ? "Successful" : "Failed";
+			const errorMsg = isError
+				? `\n\n<b>Error:</b>\n<pre>${errorMessage}</pre>`
+				: "";
+			const sizeInfo = backupSize ? `\n<b>Backup Size:</b> ${backupSize}` : "";
+
+			const messageText = `<b>${statusEmoji} Volume Backup ${typeStatus}</b>\n\n<b>Project:</b> ${projectName}\n<b>Application:</b> ${applicationName}\n<b>Volume Name:</b> ${volumeName}\n<b>Service Type:</b> ${serviceType}${sizeInfo}\n<b>Date:</b> ${format(date, "PP")}\n<b>Time:</b> ${format(date, "pp")}${isError ? errorMsg : ""}`;
+
+			await sendTelegramNotification(telegram, messageText);
+		}
+
+		if (slack) {
+			const { channel } = slack;
+			await sendSlackNotification(slack, {
+				channel: channel,
+				attachments: [
+					{
+						color: type === "success" ? "#00FF00" : "#FF0000",
+						pretext:
+							type === "success"
+								? ":white_check_mark: *Volume Backup Successful*"
+								: ":x: *Volume Backup Failed*",
+						fields: [
+							...(type === "error" && errorMessage
+								? [
+										{
+											title: "Error Message",
+											value: errorMessage,
+											short: false,
+										},
+									]
+								: []),
+							{
+								title: "Project",
+								value: projectName,
+								short: true,
+							},
+							{
+								title: "Application",
+								value: applicationName,
+								short: true,
+							},
+							{
+								title: "Volume Name",
+								value: volumeName,
+								short: true,
+							},
+							{
+								title: "Service Type",
+								value: serviceType,
+								short: true,
+							},
+							...(backupSize
+								? [
+										{
+											title: "Backup Size",
+											value: backupSize,
+											short: true,
+										},
+									]
+								: []),
+							{
+								title: "Time",
+								value: date.toLocaleString(),
+								short: true,
+							},
+							{
+								title: "Type",
+								value: type,
+								short: true,
+							},
+							{
+								title: "Status",
+								value: type === "success" ? "Successful" : "Failed",
+								short: true,
+							},
+						],
+					},
+				],
+			});
+		}
+	}
+};

packages/server/src/utils/volume-backups/utils.ts

@@ -11,8 +11,54 @@ import {
 } from "@dokploy/server/utils/process/execAsync";
 import { scheduledJobs, scheduleJob } from "node-schedule";
 import { getS3Credentials, normalizeS3Path } from "../backups/utils";
+import { sendVolumeBackupNotifications } from "../notifications/volume-backup";
 import { backupVolume } from "./backup";
 
+// Helper functions to extract project info from volume backup
+const getProjectName = (
+	volumeBackup: Awaited<ReturnType<typeof findVolumeBackupById>>,
+): string => {
+	const services = [
+		volumeBackup.application,
+		volumeBackup.compose,
+		volumeBackup.postgres,
+		volumeBackup.mysql,
+		volumeBackup.mariadb,
+		volumeBackup.mongo,
+		volumeBackup.redis,
+	];
+
+	for (const service of services) {
+		if (service?.environment?.project?.name) {
+			return service.environment.project.name;
+		}
+	}
+
+	return "Unknown Project";
+};
+
+const getOrganizationId = (
+	volumeBackup: Awaited<ReturnType<typeof findVolumeBackupById>>,
+): string => {
+	const services = [
+		volumeBackup.application,
+		volumeBackup.compose,
+		volumeBackup.postgres,
+		volumeBackup.mysql,
+		volumeBackup.mariadb,
+		volumeBackup.mongo,
+		volumeBackup.redis,
+	];
+
+	for (const service of services) {
+		if (service?.environment?.project?.organizationId) {
+			return service.environment.project.organizationId;
+		}
+	}
+
+	return "";
+};
+
 export const scheduleVolumeBackup = async (volumeBackupId: string) => {
 	const volumeBackup = await findVolumeBackupById(volumeBackupId);
 	scheduleJob(volumeBackupId, volumeBackup.cronExpression, async () => {
@@ -61,7 +107,8 @@ export const runVolumeBackup = async (volumeBackupId: string) => {
 		title: "Volume Backup",
 		description: "Volume Backup",
 	});
-
+	const projectName = getProjectName(volumeBackup);
+	const organizationId = getOrganizationId(volumeBackup);
 	try {
 		const command = await backupVolume(volumeBackup);
 
@@ -77,6 +124,21 @@ export const runVolumeBackup = async (volumeBackupId: string) => {
 		}
 
 		await updateDeploymentStatus(deployment.deploymentId, "done");
+
+		// Map service type to match notification function expectations
+		const mappedServiceType =
+			volumeBackup.serviceType === "mongo"
+				? "mongodb"
+				: volumeBackup.serviceType;
+
+		await sendVolumeBackupNotifications({
+			projectName,
+			applicationName: volumeBackup.name,
+			volumeName: volumeBackup.volumeName,
+			serviceType: mappedServiceType,
+			type: "success",
+			organizationId,
+		});
 	} catch (error) {
 		const { VOLUME_BACKUPS_PATH } = paths(!!serverId);
 		const volumeBackupPath = path.join(
@@ -92,6 +154,20 @@ export const runVolumeBackup = async (volumeBackupId: string) => {
 		}
 		await updateDeploymentStatus(deployment.deploymentId, "error");
 
-		console.error(error);
+		// Send error notification
+		const mappedServiceType =
+			volumeBackup.serviceType === "mongo"
+				? "mongodb"
+				: volumeBackup.serviceType;
+
+		await sendVolumeBackupNotifications({
+			projectName,
+			applicationName: volumeBackup.name,
+			volumeName: volumeBackup.volumeName,
+			serviceType: mappedServiceType,
+			type: "error",
+			organizationId,
+			errorMessage: error instanceof Error ? error.message : String(error),
+		});
 	}
 };