Merge branch 'feat/add-gitea-repo' of https://github.com/jrparks/dokploy into feat/add-gitea-repo

packages/server/src/lib/auth.ts

@@ -2,12 +2,16 @@ import type { IncomingMessage } from "node:http";
 import * as bcrypt from "bcrypt";
 import { betterAuth } from "better-auth";
 import { drizzleAdapter } from "better-auth/adapters/drizzle";
+import { APIError } from "better-auth/api";
 import { apiKey, organization, twoFactor } from "better-auth/plugins";
 import { and, desc, eq } from "drizzle-orm";
 import { IS_CLOUD } from "../constants";
 import { db } from "../db";
 import * as schema from "../db/schema";
+import { getUserByToken } from "../services/admin";
+import { updateUser } from "../services/user";
 import { sendEmail } from "../verification/send-verification-email";
+import { getPublicIpWithFallback } from "../wss/utils";
 
 const { handler, api } = betterAuth({
 	database: drizzleAdapter(db, {
@@ -88,11 +92,40 @@ const { handler, api } = betterAuth({
 	databaseHooks: {
 		user: {
 			create: {
+				before: async (_user, context) => {
+					if (!IS_CLOUD) {
+						const xDokployToken =
+							context?.request?.headers?.get("x-dokploy-token");
+						if (xDokployToken) {
+							const user = await getUserByToken(xDokployToken);
+							if (!user) {
+								throw new APIError("BAD_REQUEST", {
+									message: "User not found",
+								});
+							}
+						} else {
+							const isAdminPresent = await db.query.member.findFirst({
+								where: eq(schema.member.role, "owner"),
+							});
+							if (isAdminPresent) {
+								throw new APIError("BAD_REQUEST", {
+									message: "Admin is already created",
+								});
+							}
+						}
+					}
+				},
 				after: async (user) => {
 					const isAdminPresent = await db.query.member.findFirst({
 						where: eq(schema.member.role, "owner"),
 					});
 
+					if (!IS_CLOUD) {
+						await updateUser(user.id, {
+							serverIp: await getPublicIpWithFallback(),
+						});
+					}
+
 					if (IS_CLOUD || !isAdminPresent) {
 						await db.transaction(async (tx) => {
 							const organization = await tx

packages/server/src/setup/server-setup.ts

@@ -361,7 +361,7 @@ const installUtilities = () => `
 	alpine)
 		sed -i '/^#.*\/community/s/^#//' /etc/apk/repositories
 		apk update >/dev/null
-		apk add curl wget git jq openssl >/dev/null
+		apk add curl wget git jq openssl sudo unzip tar >/dev/null
 		;;
 	ubuntu | debian | raspbian)
 		DEBIAN_FRONTEND=noninteractive apt-get update -y >/dev/null

packages/server/src/setup/traefik-setup.ts

@@ -101,11 +101,11 @@ export const initializeTraefik = async ({
 					console.log("Waiting for service cleanup...");
 					await new Promise((resolve) => setTimeout(resolve, 5000));
 					attempts++;
-				} catch (e) {
+				} catch (_e) {
 					break;
 				}
 			}
-		} catch (err) {
+		} catch (_err) {
 			console.log("No existing service to remove");
 		}
 
@@ -120,7 +120,7 @@ export const initializeTraefik = async ({
 
 			await container.remove({ force: true });
 			await new Promise((resolve) => setTimeout(resolve, 5000));
-		} catch (error) {
+		} catch (_err) {
 			console.log("No existing container to remove");
 		}
 

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

@@ -0,0 +1,4 @@
+export { restorePostgresBackup } from "./postgres";
+export { restoreMySqlBackup } from "./mysql";
+export { restoreMariadbBackup } from "./mariadb";
+export { restoreMongoBackup } from "./mongo";

packages/server/src/utils/restore/mariadb.ts

@@ -0,0 +1,56 @@
+import type { Destination } from "@dokploy/server/services/destination";
+import type { Mariadb } from "@dokploy/server/services/mariadb";
+import { getS3Credentials } from "../backups/utils";
+import {
+	getRemoteServiceContainer,
+	getServiceContainer,
+} from "../docker/utils";
+import { execAsync, execAsyncRemote } from "../process/execAsync";
+
+export const restoreMariadbBackup = async (
+	mariadb: Mariadb,
+	destination: Destination,
+	database: string,
+	backupFile: string,
+	emit: (log: string) => void,
+) => {
+	try {
+		const { appName, databasePassword, databaseUser, serverId } = mariadb;
+
+		const rcloneFlags = getS3Credentials(destination);
+		const bucketPath = `:s3:${destination.bucket}`;
+		const backupPath = `${bucketPath}/${backupFile}`;
+
+		const { Id: containerName } = serverId
+			? await getRemoteServiceContainer(serverId, appName)
+			: await getServiceContainer(appName);
+
+		const restoreCommand = `
+    rclone cat ${rcloneFlags.join(" ")} "${backupPath}" | gunzip | docker exec -i ${containerName} mariadb -u ${databaseUser} -p${databasePassword} ${database}
+  `;
+
+		emit("Starting restore...");
+
+		emit(`Executing command: ${restoreCommand}`);
+
+		if (serverId) {
+			await execAsyncRemote(serverId, restoreCommand);
+		} else {
+			await execAsync(restoreCommand);
+		}
+
+		emit("Restore completed successfully!");
+	} catch (error) {
+		console.error(error);
+		emit(
+			`Error: ${
+				error instanceof Error
+					? error.message
+					: "Error restoring mariadb backup"
+			}`,
+		);
+		throw new Error(
+			error instanceof Error ? error.message : "Error restoring mariadb backup",
+		);
+	}
+};

packages/server/src/utils/restore/mongo.ts

@@ -0,0 +1,64 @@
+import type { Destination } from "@dokploy/server/services/destination";
+import type { Mongo } from "@dokploy/server/services/mongo";
+import { getS3Credentials } from "../backups/utils";
+import {
+	getRemoteServiceContainer,
+	getServiceContainer,
+} from "../docker/utils";
+import { execAsync, execAsyncRemote } from "../process/execAsync";
+
+export const restoreMongoBackup = async (
+	mongo: Mongo,
+	destination: Destination,
+	database: string,
+	backupFile: string,
+	emit: (log: string) => void,
+) => {
+	try {
+		const { appName, databasePassword, databaseUser, serverId } = mongo;
+
+		const rcloneFlags = getS3Credentials(destination);
+		const bucketPath = `:s3:${destination.bucket}`;
+		const backupPath = `${bucketPath}/${backupFile}`;
+
+		const { Id: containerName } = serverId
+			? await getRemoteServiceContainer(serverId, appName)
+			: await getServiceContainer(appName);
+
+		// For MongoDB, we need to first download the backup file since mongorestore expects a directory
+		const tempDir = "/tmp/dokploy-restore";
+		const fileName = backupFile.split("/").pop() || "backup.dump.gz";
+		const decompressedName = fileName.replace(".gz", "");
+
+		const downloadCommand = `\
+rm -rf ${tempDir} && \
+mkdir -p ${tempDir} && \
+rclone copy ${rcloneFlags.join(" ")} "${backupPath}" ${tempDir} && \
+cd ${tempDir} && \
+gunzip -f "${fileName}" && \
+docker exec -i ${containerName} mongorestore --username ${databaseUser} --password ${databasePassword} --authenticationDatabase admin --db ${database} --archive < "${decompressedName}" && \
+rm -rf ${tempDir}`;
+
+		emit("Starting restore...");
+
+		emit(`Executing command: ${downloadCommand}`);
+
+		if (serverId) {
+			await execAsyncRemote(serverId, downloadCommand);
+		} else {
+			await execAsync(downloadCommand);
+		}
+
+		emit("Restore completed successfully!");
+	} catch (error) {
+		console.error(error);
+		emit(
+			`Error: ${
+				error instanceof Error ? error.message : "Error restoring mongo backup"
+			}`,
+		);
+		throw new Error(
+			error instanceof Error ? error.message : "Error restoring mongo backup",
+		);
+	}
+};

packages/server/src/utils/restore/mysql.ts

@@ -0,0 +1,54 @@
+import type { Destination } from "@dokploy/server/services/destination";
+import type { MySql } from "@dokploy/server/services/mysql";
+import { getS3Credentials } from "../backups/utils";
+import {
+	getRemoteServiceContainer,
+	getServiceContainer,
+} from "../docker/utils";
+import { execAsync, execAsyncRemote } from "../process/execAsync";
+
+export const restoreMySqlBackup = async (
+	mysql: MySql,
+	destination: Destination,
+	database: string,
+	backupFile: string,
+	emit: (log: string) => void,
+) => {
+	try {
+		const { appName, databaseRootPassword, serverId } = mysql;
+
+		const rcloneFlags = getS3Credentials(destination);
+		const bucketPath = `:s3:${destination.bucket}`;
+		const backupPath = `${bucketPath}/${backupFile}`;
+
+		const { Id: containerName } = serverId
+			? await getRemoteServiceContainer(serverId, appName)
+			: await getServiceContainer(appName);
+
+		const restoreCommand = `
+    rclone cat ${rcloneFlags.join(" ")} "${backupPath}" | gunzip | docker exec -i ${containerName} mysql -u root -p${databaseRootPassword} ${database}
+  `;
+
+		emit("Starting restore...");
+
+		emit(`Executing command: ${restoreCommand}`);
+
+		if (serverId) {
+			await execAsyncRemote(serverId, restoreCommand);
+		} else {
+			await execAsync(restoreCommand);
+		}
+
+		emit("Restore completed successfully!");
+	} catch (error) {
+		console.error(error);
+		emit(
+			`Error: ${
+				error instanceof Error ? error.message : "Error restoring mysql backup"
+			}`,
+		);
+		throw new Error(
+			error instanceof Error ? error.message : "Error restoring mysql backup",
+		);
+	}
+};

packages/server/src/utils/restore/postgres.ts

@@ -0,0 +1,60 @@
+import type { Destination } from "@dokploy/server/services/destination";
+import type { Postgres } from "@dokploy/server/services/postgres";
+import { getS3Credentials } from "../backups/utils";
+import {
+	getRemoteServiceContainer,
+	getServiceContainer,
+} from "../docker/utils";
+import { execAsync, execAsyncRemote } from "../process/execAsync";
+
+export const restorePostgresBackup = async (
+	postgres: Postgres,
+	destination: Destination,
+	database: string,
+	backupFile: string,
+	emit: (log: string) => void,
+) => {
+	try {
+		const { appName, databaseUser, serverId } = postgres;
+
+		const rcloneFlags = getS3Credentials(destination);
+		const bucketPath = `:s3:${destination.bucket}`;
+
+		const backupPath = `${bucketPath}/${backupFile}`;
+
+		const { Id: containerName } = serverId
+			? await getRemoteServiceContainer(serverId, appName)
+			: await getServiceContainer(appName);
+
+		emit("Starting restore...");
+		emit(`Backup path: ${backupPath}`);
+
+		const command = `\
+rclone cat ${rcloneFlags.join(" ")} "${backupPath}" | gunzip | docker exec -i ${containerName} pg_restore -U ${databaseUser} -d ${database} --clean --if-exists`;
+
+		emit(`Executing command: ${command}`);
+
+		if (serverId) {
+			const { stdout, stderr } = await execAsyncRemote(serverId, command);
+			emit(stdout);
+			emit(stderr);
+		} else {
+			const { stdout, stderr } = await execAsync(command);
+			console.log("stdout", stdout);
+			console.log("stderr", stderr);
+			emit(stdout);
+			emit(stderr);
+		}
+
+		emit("Restore completed successfully!");
+	} catch (error) {
+		emit(
+			`Error: ${
+				error instanceof Error
+					? error.message
+					: "Error restoring postgres backup"
+			}`,
+		);
+		throw error;
+	}
+};