| import { createWriteStream } from "node:fs"; |
| import { join } from "node:path"; |
| import { paths } from "@dokploy/server/constants"; |
| import type { apiGitlabTestConnection } from "@dokploy/server/db/schema"; |
| import type { Compose } from "@dokploy/server/services/compose"; |
| import { |
| type Gitlab, |
| findGitlabById, |
| updateGitlab, |
| } from "@dokploy/server/services/gitlab"; |
| import type { InferResultType } from "@dokploy/server/types/with"; |
| import { TRPCError } from "@trpc/server"; |
| import { recreateDirectory } from "../filesystem/directory"; |
| import { execAsyncRemote } from "../process/execAsync"; |
| import { spawnAsync } from "../process/spawnAsync"; |
|
|
| export const refreshGitlabToken = async (gitlabProviderId: string) => { |
| const gitlabProvider = await findGitlabById(gitlabProviderId); |
| const currentTime = Math.floor(Date.now() / 1000); |
|
|
| const safetyMargin = 60; |
| if ( |
| gitlabProvider.expiresAt && |
| currentTime + safetyMargin < gitlabProvider.expiresAt |
| ) { |
| return; |
| } |
|
|
| const response = await fetch(`${gitlabProvider.gitlabUrl}/oauth/token`, { |
| method: "POST", |
| headers: { |
| "Content-Type": "application/x-www-form-urlencoded", |
| }, |
| body: new URLSearchParams({ |
| grant_type: "refresh_token", |
| refresh_token: gitlabProvider.refreshToken as string, |
| client_id: gitlabProvider.applicationId as string, |
| client_secret: gitlabProvider.secret as string, |
| }), |
| }); |
|
|
| if (!response.ok) { |
| throw new Error(`Failed to refresh token: ${response.statusText}`); |
| } |
|
|
| const data = await response.json(); |
|
|
| const expiresAt = Math.floor(Date.now() / 1000) + data.expires_in; |
|
|
| await updateGitlab(gitlabProviderId, { |
| accessToken: data.access_token, |
| refreshToken: data.refresh_token, |
| expiresAt, |
| }); |
| return data; |
| }; |
|
|
| export const haveGitlabRequirements = (gitlabProvider: Gitlab) => { |
| return !!(gitlabProvider?.accessToken && gitlabProvider?.refreshToken); |
| }; |
|
|
| const getErrorCloneRequirements = (entity: { |
| gitlabRepository?: string | null; |
| gitlabOwner?: string | null; |
| gitlabBranch?: string | null; |
| gitlabPathNamespace?: string | null; |
| }) => { |
| const reasons: string[] = []; |
| const { gitlabBranch, gitlabOwner, gitlabRepository, gitlabPathNamespace } = |
| entity; |
|
|
| if (!gitlabRepository) reasons.push("1. Repository not assigned."); |
| if (!gitlabOwner) reasons.push("2. Owner not specified."); |
| if (!gitlabBranch) reasons.push("3. Branch not defined."); |
| if (!gitlabPathNamespace) reasons.push("4. Path namespace not defined."); |
|
|
| return reasons; |
| }; |
|
|
| export type ApplicationWithGitlab = InferResultType< |
| "applications", |
| { gitlab: true } |
| >; |
|
|
| export type ComposeWithGitlab = InferResultType<"compose", { gitlab: true }>; |
|
|
| export const cloneGitlabRepository = async ( |
| entity: ApplicationWithGitlab | ComposeWithGitlab, |
| logPath: string, |
| isCompose = false, |
| ) => { |
| const writeStream = createWriteStream(logPath, { flags: "a" }); |
| const { |
| appName, |
| gitlabBranch, |
| gitlabId, |
| gitlab, |
| gitlabPathNamespace, |
| enableSubmodules, |
| } = entity; |
|
|
| if (!gitlabId) { |
| throw new TRPCError({ |
| code: "NOT_FOUND", |
| message: "Gitlab Provider not found", |
| }); |
| } |
|
|
| await refreshGitlabToken(gitlabId); |
|
|
| const requirements = getErrorCloneRequirements(entity); |
|
|
| |
| if (requirements.length > 0) { |
| writeStream.write( |
| `\nGitLab Repository configuration failed for application: ${appName}\n`, |
| ); |
| writeStream.write("Reasons:\n"); |
| writeStream.write(requirements.join("\n")); |
| writeStream.end(); |
| throw new TRPCError({ |
| code: "BAD_REQUEST", |
| message: "Error: GitLab repository information is incomplete.", |
| }); |
| } |
|
|
| const { COMPOSE_PATH, APPLICATIONS_PATH } = paths(); |
| const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH; |
| const outputPath = join(basePath, appName, "code"); |
| await recreateDirectory(outputPath); |
| const repoclone = `${gitlab?.gitlabUrl.replace(/^https?:\/\//, "")}/${gitlabPathNamespace}.git`; |
| const cloneUrl = `https://oauth2:${gitlab?.accessToken}@${repoclone}`; |
|
|
| try { |
| writeStream.write(`\nClonning Repo ${repoclone} to ${outputPath}: ✅\n`); |
| const cloneArgs = [ |
| "clone", |
| "--branch", |
| gitlabBranch!, |
| "--depth", |
| "1", |
| ...(enableSubmodules ? ["--recurse-submodules"] : []), |
| cloneUrl, |
| outputPath, |
| "--progress", |
| ]; |
|
|
| await spawnAsync("git", cloneArgs, (data) => { |
| if (writeStream.writable) { |
| writeStream.write(data); |
| } |
| }); |
| writeStream.write(`\nCloned ${repoclone}: ✅\n`); |
| } catch (error) { |
| writeStream.write(`ERROR Clonning: ${error}: ❌`); |
| throw error; |
| } finally { |
| writeStream.end(); |
| } |
| }; |
|
|
| export const getGitlabCloneCommand = async ( |
| entity: ApplicationWithGitlab | ComposeWithGitlab, |
| logPath: string, |
| isCompose = false, |
| ) => { |
| const { |
| appName, |
| gitlabPathNamespace, |
| gitlabBranch, |
| gitlabId, |
| serverId, |
| gitlab, |
| enableSubmodules, |
| } = entity; |
|
|
| if (!serverId) { |
| throw new TRPCError({ |
| code: "NOT_FOUND", |
| message: "Server not found", |
| }); |
| } |
|
|
| if (!gitlabId) { |
| const command = ` |
| echo "Error: ❌ Gitlab Provider not found" >> ${logPath}; |
| exit 1; |
| `; |
|
|
| await execAsyncRemote(serverId, command); |
| throw new TRPCError({ |
| code: "NOT_FOUND", |
| message: "Gitlab Provider not found", |
| }); |
| } |
|
|
| const requirements = getErrorCloneRequirements(entity); |
|
|
| |
| let logMessages = ""; |
| if (requirements.length > 0) { |
| logMessages += `\nGitLab Repository configuration failed for application: ${appName}\n`; |
| logMessages += "Reasons:\n"; |
| logMessages += requirements.join("\n"); |
| const escapedLogMessages = logMessages |
| .replace(/\\/g, "\\\\") |
| .replace(/"/g, '\\"') |
| .replace(/\n/g, "\\n"); |
|
|
| const bashCommand = ` |
| echo "${escapedLogMessages}" >> ${logPath}; |
| exit 1; # Exit with error code |
| `; |
|
|
| await execAsyncRemote(serverId, bashCommand); |
| return; |
| } |
|
|
| const { COMPOSE_PATH, APPLICATIONS_PATH } = paths(true); |
| await refreshGitlabToken(gitlabId); |
| const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH; |
| const outputPath = join(basePath, appName, "code"); |
| await recreateDirectory(outputPath); |
| const repoclone = `${gitlab?.gitlabUrl.replace(/^https?:\/\//, "")}/${gitlabPathNamespace}.git`; |
| const cloneUrl = `https://oauth2:${gitlab?.accessToken}@${repoclone}`; |
|
|
| const cloneCommand = ` |
| rm -rf ${outputPath}; |
| mkdir -p ${outputPath}; |
| if ! git clone --branch ${gitlabBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} --progress ${cloneUrl} ${outputPath} >> ${logPath} 2>&1; then |
| echo "❌ [ERROR] Fail to clone the repository ${repoclone}" >> ${logPath}; |
| exit 1; |
| fi |
| echo "Cloned ${repoclone} to ${outputPath}: ✅" >> ${logPath}; |
| `; |
|
|
| return cloneCommand; |
| }; |
|
|
| export const getGitlabRepositories = async (gitlabId?: string) => { |
| if (!gitlabId) { |
| return []; |
| } |
|
|
| await refreshGitlabToken(gitlabId); |
|
|
| const gitlabProvider = await findGitlabById(gitlabId); |
|
|
| const allProjects = await validateGitlabProvider(gitlabProvider); |
|
|
| const filteredRepos = allProjects.filter((repo: any) => { |
| const { full_path, kind } = repo.namespace; |
| const groupName = gitlabProvider.groupName?.toLowerCase(); |
|
|
| if (groupName) { |
| const isIncluded = groupName |
| .split(",") |
| .some((name) => |
| full_path.toLowerCase().startsWith(name.trim().toLowerCase()), |
| ); |
|
|
| return isIncluded && kind === "group"; |
| } |
| return kind === "user"; |
| }); |
| const mappedRepositories = filteredRepos.map((repo: any) => { |
| return { |
| id: repo.id, |
| name: repo.name, |
| url: repo.path_with_namespace, |
| owner: { |
| username: repo.namespace.path, |
| }, |
| }; |
| }); |
|
|
| return mappedRepositories as { |
| id: number; |
| name: string; |
| url: string; |
| owner: { |
| username: string; |
| }; |
| }[]; |
| }; |
|
|
| export const getGitlabBranches = async (input: { |
| id?: number; |
| gitlabId?: string; |
| owner: string; |
| repo: string; |
| }) => { |
| if (!input.gitlabId || !input.id || input.id === 0) { |
| return []; |
| } |
|
|
| const gitlabProvider = await findGitlabById(input.gitlabId); |
|
|
| const branchesResponse = await fetch( |
| `${gitlabProvider.gitlabUrl}/api/v4/projects/${input.id}/repository/branches`, |
| { |
| headers: { |
| Authorization: `Bearer ${gitlabProvider.accessToken}`, |
| }, |
| }, |
| ); |
|
|
| if (!branchesResponse.ok) { |
| throw new Error(`Failed to fetch branches: ${branchesResponse.statusText}`); |
| } |
|
|
| const branches = await branchesResponse.json(); |
|
|
| return branches as { |
| id: string; |
| name: string; |
| commit: { |
| id: string; |
| }; |
| }[]; |
| }; |
|
|
| export const cloneRawGitlabRepository = async (entity: Compose) => { |
| const { |
| appName, |
| gitlabBranch, |
| gitlabId, |
| gitlabPathNamespace, |
| enableSubmodules, |
| } = entity; |
|
|
| if (!gitlabId) { |
| throw new TRPCError({ |
| code: "NOT_FOUND", |
| message: "Gitlab Provider not found", |
| }); |
| } |
|
|
| const gitlabProvider = await findGitlabById(gitlabId); |
| const { COMPOSE_PATH } = paths(); |
| await refreshGitlabToken(gitlabId); |
| const basePath = COMPOSE_PATH; |
| const outputPath = join(basePath, appName, "code"); |
| await recreateDirectory(outputPath); |
| const gitlabUrl = gitlabProvider.gitlabUrl; |
| |
| const repoclone = `${gitlabUrl.replace(/^https?:\/\//, "")}/${gitlabPathNamespace}.git`; |
| const cloneUrl = `https://oauth2:${gitlabProvider?.accessToken}@${repoclone}`; |
|
|
| try { |
| const cloneArgs = [ |
| "clone", |
| "--branch", |
| gitlabBranch!, |
| "--depth", |
| "1", |
| ...(enableSubmodules ? ["--recurse-submodules"] : []), |
| cloneUrl, |
| outputPath, |
| "--progress", |
| ]; |
| await spawnAsync("git", cloneArgs); |
| } catch (error) { |
| throw error; |
| } |
| }; |
|
|
| export const cloneRawGitlabRepositoryRemote = async (compose: Compose) => { |
| const { |
| appName, |
| gitlabPathNamespace, |
| branch, |
| gitlabId, |
| serverId, |
| enableSubmodules, |
| } = compose; |
|
|
| if (!serverId) { |
| throw new TRPCError({ |
| code: "NOT_FOUND", |
| message: "Server not found", |
| }); |
| } |
| if (!gitlabId) { |
| throw new TRPCError({ |
| code: "NOT_FOUND", |
| message: "Gitlab Provider not found", |
| }); |
| } |
| const gitlabProvider = await findGitlabById(gitlabId); |
| const { COMPOSE_PATH } = paths(true); |
| await refreshGitlabToken(gitlabId); |
| const basePath = COMPOSE_PATH; |
| const outputPath = join(basePath, appName, "code"); |
| const repoclone = `${gitlabProvider.gitlabUrl.replace(/^https?:\/\//, "")}/${gitlabPathNamespace}.git`; |
| const cloneUrl = `https://oauth2:${gitlabProvider?.accessToken}@${repoclone}`; |
| try { |
| const command = ` |
| rm -rf ${outputPath}; |
| git clone --branch ${branch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} ${cloneUrl} ${outputPath} |
| `; |
| await execAsyncRemote(serverId, command); |
| } catch (error) { |
| throw error; |
| } |
| }; |
|
|
| export const testGitlabConnection = async ( |
| input: typeof apiGitlabTestConnection._type, |
| ) => { |
| const { gitlabId, groupName } = input; |
|
|
| if (!gitlabId) { |
| throw new Error("Gitlab provider not found"); |
| } |
|
|
| await refreshGitlabToken(gitlabId); |
|
|
| const gitlabProvider = await findGitlabById(gitlabId); |
|
|
| const repositories = await validateGitlabProvider(gitlabProvider); |
|
|
| const filteredRepos = repositories.filter((repo: any) => { |
| const { full_path, kind } = repo.namespace; |
|
|
| if (groupName) { |
| return groupName |
| .split(",") |
| .some((name) => |
| full_path.toLowerCase().startsWith(name.trim().toLowerCase()), |
| ); |
| } |
| return kind === "user"; |
| }); |
|
|
| return filteredRepos.length; |
| }; |
|
|
| export const validateGitlabProvider = async (gitlabProvider: Gitlab) => { |
| try { |
| const allProjects = []; |
| let page = 1; |
| const perPage = 100; |
|
|
| while (true) { |
| const response = await fetch( |
| `${gitlabProvider.gitlabUrl}/api/v4/projects?membership=true&owned=true&page=${page}&per_page=${perPage}`, |
| { |
| headers: { |
| Authorization: `Bearer ${gitlabProvider.accessToken}`, |
| }, |
| }, |
| ); |
|
|
| if (!response.ok) { |
| throw new TRPCError({ |
| code: "BAD_REQUEST", |
| message: `Failed to fetch repositories: ${response.statusText}`, |
| }); |
| } |
|
|
| const projects = await response.json(); |
|
|
| if (projects.length === 0) { |
| break; |
| } |
|
|
| allProjects.push(...projects); |
| page++; |
|
|
| const total = response.headers.get("x-total"); |
| if (total && allProjects.length >= Number.parseInt(total)) { |
| break; |
| } |
| } |
|
|
| return allProjects; |
| } catch (error) { |
| throw error; |
| } |
| }; |
|
|
