V2 (#111)

Just v2

src/lib/buildPacks/common.ts

@@ -0,0 +1,191 @@
+import { base64Encode } from '$lib/crypto';
+import { getDomain, saveBuildLog, version } from '$lib/common';
+import * as db from '$lib/database';
+import { scanningTemplates } from '$lib/components/templates';
+import { promises as fs } from 'fs';
+import { staticDeployments } from '$lib/components/common';
+
+export function makeLabelForStandaloneApplication({
+	applicationId,
+	fqdn,
+	name,
+	type,
+	pullmergeRequestId = null,
+	buildPack,
+	repository,
+	branch,
+	projectId,
+	port,
+	commit,
+	installCommand,
+	buildCommand,
+	startCommand,
+	baseDirectory,
+	publishDirectory
+}) {
+	if (pullmergeRequestId) {
+		const protocol = fqdn.startsWith('https://') ? 'https' : 'http';
+		const domain = getDomain(fqdn);
+		fqdn = `${protocol}://${pullmergeRequestId}.${domain}`;
+	}
+	return [
+		'--label coolify.managed=true',
+		`--label coolify.version=${version}`,
+		`--label coolify.type=standalone-application`,
+		`--label coolify.configuration=${base64Encode(
+			JSON.stringify({
+				applicationId,
+				fqdn,
+				name,
+				type,
+				pullmergeRequestId,
+				buildPack,
+				repository,
+				branch,
+				projectId,
+				port,
+				commit,
+				installCommand,
+				buildCommand,
+				startCommand,
+				baseDirectory,
+				publishDirectory
+			})
+		)}`
+	];
+}
+export async function makeLabelForStandaloneDatabase({ id, image, volume }) {
+	const database = await db.prisma.database.findFirst({ where: { id } });
+	delete database.destinationDockerId;
+	delete database.createdAt;
+	delete database.updatedAt;
+	return [
+		'coolify.managed=true',
+		`coolify.version=${version}`,
+		`coolify.type=standalone-database`,
+		`coolify.configuration=${base64Encode(
+			JSON.stringify({
+				version,
+				image,
+				volume,
+				...database
+			})
+		)}`
+	];
+}
+
+export async function makeLabelForPlausibleAnalytics({ id, images, volume }) {
+	const service = await db.prisma.service.findFirst({
+		where: { id },
+		include: { plausibleAnalytics: true }
+	});
+	delete service.destinationDockerId;
+	delete service.createdAt;
+	delete service.updatedAt;
+	return [
+		'coolify.managed=true',
+		`coolify.version=${version}`,
+		`coolify.type=service-plausibleanalytics`,
+		`coolify.configuration=${base64Encode(
+			JSON.stringify({
+				version,
+				images,
+				volume,
+				...service
+			})
+		)}`
+	];
+}
+
+export const setDefaultConfiguration = async (data) => {
+	let { buildPack, port, installCommand, startCommand, buildCommand, publishDirectory } = data;
+	const template = scanningTemplates[buildPack];
+	if (!port) {
+		port = template?.port || 3000;
+
+		if (buildPack === 'static') port = 80;
+		else if (buildPack === 'node') port = 3000;
+		else if (buildPack === 'php') port = 80;
+	}
+	if (!installCommand) installCommand = template?.installCommand || 'yarn install';
+	if (!startCommand) startCommand = template?.startCommand || 'yarn start';
+	if (!buildCommand) buildCommand = template?.buildCommand || null;
+	if (!publishDirectory) publishDirectory = template?.publishDirectory || null;
+
+	return {
+		buildPack,
+		port,
+		installCommand,
+		startCommand,
+		buildCommand,
+		publishDirectory
+	};
+};
+
+export async function copyBaseConfigurationFiles(buildPack, workdir, buildId, applicationId) {
+	try {
+		// TODO: Write full .dockerignore for all deployments!!
+		if (buildPack === 'php') {
+			await fs.writeFile(
+				`${workdir}/.htaccess`,
+				`
+        RewriteEngine On
+        RewriteBase /
+        RewriteCond %{REQUEST_FILENAME} !-d
+        RewriteCond %{REQUEST_FILENAME} !-f
+        RewriteRule ^(.+)$ index.php [QSA,L]
+        `
+			);
+			saveBuildLog({ line: 'Copied default configuration file for PHP.', buildId, applicationId });
+		} else if (staticDeployments.includes(buildPack)) {
+			await fs.writeFile(
+				`${workdir}/nginx.conf`,
+				`user  nginx;
+            worker_processes  auto;
+            
+            error_log  /var/log/nginx/error.log warn;
+            pid        /var/run/nginx.pid;
+            
+            events {
+                worker_connections  1024;
+            }
+            
+            http {
+                include       /etc/nginx/mime.types;
+            
+                access_log      off;
+                sendfile        on;
+                #tcp_nopush     on;
+                keepalive_timeout  65;
+    
+                server {
+                    listen       80;
+                    server_name  localhost;
+                    
+                    location / {
+                        root   /usr/share/nginx/html;
+                        index  index.html;
+                        try_files $uri $uri/index.html $uri/ /index.html =404;
+                    }
+            
+                    error_page  404              /50x.html;
+            
+                    # redirect server error pages to the static page /50x.html
+                    #
+                    error_page   500 502 503 504  /50x.html;
+                    location = /50x.html {
+                        root   /usr/share/nginx/html;
+                    }  
+            
+                }
+            
+            }
+            `
+			);
+			saveBuildLog({ line: 'Copied default configuration file.', buildId, applicationId });
+		}
+	} catch (error) {
+		console.log(error);
+		throw new Error(error);
+	}
+}

src/lib/buildPacks/docker.ts

@@ -0,0 +1,36 @@
+import { buildImage } from '$lib/docker';
+import { promises as fs } from 'fs';
+
+export default async function ({
+	applicationId,
+	debug,
+	tag,
+	workdir,
+	docker,
+	buildId,
+	baseDirectory,
+	secrets
+}) {
+	try {
+		let file = `${workdir}/Dockerfile`;
+		if (baseDirectory) {
+			file = `${workdir}/${baseDirectory}/Dockerfile`;
+		}
+
+		const Dockerfile: Array<string> = (await fs.readFile(`${file}`, 'utf8'))
+			.toString()
+			.trim()
+			.split('\n');
+		if (secrets.length > 0) {
+			secrets.forEach((secret) => {
+				if (secret.isBuildSecret) {
+					Dockerfile.push(`ARG ${secret.name} ${secret.value}`);
+				}
+			});
+		}
+		await fs.writeFile(`${file}`, Dockerfile.join('\n'));
+		await buildImage({ applicationId, tag, workdir, docker, buildId, debug });
+	} catch (error) {
+		throw error;
+	}
+}

src/lib/buildPacks/gatsby.ts

@@ -0,0 +1,27 @@
+import { buildCacheImageWithNode, buildImage } from '$lib/docker';
+import { promises as fs } from 'fs';
+
+const createDockerfile = async (data, imageforBuild): Promise<void> => {
+	const { applicationId, tag, workdir, publishDirectory } = data;
+	const Dockerfile: Array<string> = [];
+
+	Dockerfile.push(`FROM ${imageforBuild}`);
+	Dockerfile.push('WORKDIR /usr/share/nginx/html');
+	Dockerfile.push(`COPY --from=${applicationId}:${tag}-cache /usr/src/app/${publishDirectory} ./`);
+	Dockerfile.push(`EXPOSE 80`);
+	Dockerfile.push('CMD ["nginx", "-g", "daemon off;"]');
+	await fs.writeFile(`${workdir}/Dockerfile`, Dockerfile.join('\n'));
+};
+
+export default async function (data) {
+	try {
+		const image = 'nginx:stable-alpine';
+		const imageForBuild = 'node:lts';
+
+		await buildCacheImageWithNode(data, imageForBuild);
+		await createDockerfile(data, image);
+		await buildImage(data);
+	} catch (error) {
+		throw error;
+	}
+}

src/lib/buildPacks/index.ts

@@ -0,0 +1,27 @@
+import node from './node';
+import staticApp from './static';
+import docker from './docker';
+import gatsby from './gatsby';
+import svelte from './svelte';
+import react from './react';
+import nestjs from './nestjs';
+import nextjs from './nextjs';
+import nuxtjs from './nuxtjs';
+import vuejs from './vuejs';
+import php from './php';
+import rust from './rust';
+
+export {
+	node,
+	staticApp as static,
+	docker,
+	gatsby,
+	svelte,
+	react,
+	nestjs,
+	nextjs,
+	nuxtjs,
+	vuejs,
+	php,
+	rust
+};

src/lib/buildPacks/nestjs.ts

@@ -0,0 +1,29 @@
+import { buildCacheImageWithNode, buildImage } from '$lib/docker';
+import { promises as fs } from 'fs';
+
+const createDockerfile = async (data, image): Promise<void> => {
+	const { applicationId, tag, port, startCommand, workdir, baseDirectory } = data;
+	const Dockerfile: Array<string> = [];
+
+	Dockerfile.push(`FROM ${image}`);
+	Dockerfile.push('WORKDIR /usr/src/app');
+	Dockerfile.push(
+		`COPY --from=${applicationId}:${tag}-cache /usr/src/app/${baseDirectory || ''} ./`
+	);
+	Dockerfile.push(`EXPOSE ${port}`);
+	Dockerfile.push(`CMD ${startCommand}`);
+	await fs.writeFile(`${workdir}/Dockerfile`, Dockerfile.join('\n'));
+};
+
+export default async function (data) {
+	try {
+		const image = 'node:lts';
+		const imageForBuild = 'node:lts';
+
+		await buildCacheImageWithNode(data, imageForBuild);
+		await createDockerfile(data, image);
+		await buildImage(data);
+	} catch (error) {
+		throw error;
+	}
+}

src/lib/buildPacks/nextjs.ts

@@ -0,0 +1,45 @@
+import { buildImage } from '$lib/docker';
+import { promises as fs } from 'fs';
+
+const createDockerfile = async (data, image): Promise<void> => {
+	const { workdir, port, installCommand, buildCommand, startCommand, baseDirectory, secrets } =
+		data;
+	const Dockerfile: Array<string> = [];
+
+	Dockerfile.push(`FROM ${image}`);
+	Dockerfile.push('WORKDIR /usr/src/app');
+	if (secrets.length > 0) {
+		secrets.forEach((secret) => {
+			if (secret.isBuildSecret) {
+				Dockerfile.push(`ARG ${secret.name} ${secret.value}`);
+			}
+		});
+	}
+	Dockerfile.push(`COPY ./${baseDirectory || ''}package*.json ./`);
+	try {
+		await fs.stat(`${workdir}/yarn.lock`);
+		Dockerfile.push(`COPY ./${baseDirectory || ''}yarn.lock ./`);
+	} catch (error) {}
+	try {
+		await fs.stat(`${workdir}/pnpm-lock.yaml`);
+		Dockerfile.push(`COPY ./${baseDirectory || ''}pnpm-lock.yaml ./`);
+	} catch (error) {}
+	Dockerfile.push(`RUN ${installCommand}`);
+	Dockerfile.push(`COPY ./${baseDirectory || ''} ./`);
+	if (buildCommand) {
+		Dockerfile.push(`RUN ${buildCommand}`);
+	}
+	Dockerfile.push(`EXPOSE ${port}`);
+	Dockerfile.push(`CMD ${startCommand}`);
+	await fs.writeFile(`${workdir}/Dockerfile`, Dockerfile.join('\n'));
+};
+
+export default async function (data) {
+	try {
+		const image = 'node:lts';
+		await createDockerfile(data, image);
+		await buildImage(data);
+	} catch (error) {
+		throw error;
+	}
+}

src/lib/buildPacks/node.ts

@@ -0,0 +1,45 @@
+import { buildImage } from '$lib/docker';
+import { promises as fs } from 'fs';
+
+const createDockerfile = async (data, image): Promise<void> => {
+	const { workdir, port, installCommand, buildCommand, startCommand, baseDirectory, secrets } =
+		data;
+	const Dockerfile: Array<string> = [];
+
+	Dockerfile.push(`FROM ${image}`);
+	Dockerfile.push('WORKDIR /usr/src/app');
+	if (secrets.length > 0) {
+		secrets.forEach((secret) => {
+			if (secret.isBuildSecret) {
+				Dockerfile.push(`ARG ${secret.name} ${secret.value}`);
+			}
+		});
+	}
+	Dockerfile.push(`COPY ./${baseDirectory || ''}package*.json ./`);
+	try {
+		await fs.stat(`${workdir}/yarn.lock`);
+		Dockerfile.push(`COPY ./${baseDirectory || ''}yarn.lock ./`);
+	} catch (error) {}
+	try {
+		await fs.stat(`${workdir}/pnpm-lock.yaml`);
+		Dockerfile.push(`COPY ./${baseDirectory || ''}pnpm-lock.yaml ./`);
+	} catch (error) {}
+	Dockerfile.push(`RUN ${installCommand}`);
+	Dockerfile.push(`COPY ./${baseDirectory || ''} ./`);
+	if (buildCommand) {
+		Dockerfile.push(`RUN ${buildCommand}`);
+	}
+	Dockerfile.push(`EXPOSE ${port}`);
+	Dockerfile.push(`CMD ${startCommand}`);
+	await fs.writeFile(`${workdir}/Dockerfile`, Dockerfile.join('\n'));
+};
+
+export default async function (data) {
+	try {
+		const image = 'node:lts';
+		await createDockerfile(data, image);
+		await buildImage(data);
+	} catch (error) {
+		throw error;
+	}
+}

src/lib/buildPacks/nuxtjs.ts

@@ -0,0 +1,45 @@
+import { buildImage } from '$lib/docker';
+import { promises as fs } from 'fs';
+
+const createDockerfile = async (data, image): Promise<void> => {
+	const { workdir, port, installCommand, buildCommand, startCommand, baseDirectory, secrets } =
+		data;
+	const Dockerfile: Array<string> = [];
+
+	Dockerfile.push(`FROM ${image}`);
+	Dockerfile.push('WORKDIR /usr/src/app');
+	if (secrets.length > 0) {
+		secrets.forEach((secret) => {
+			if (secret.isBuildSecret) {
+				Dockerfile.push(`ARG ${secret.name} ${secret.value}`);
+			}
+		});
+	}
+	Dockerfile.push(`COPY ./${baseDirectory || ''}package*.json ./`);
+	try {
+		await fs.stat(`${workdir}/yarn.lock`);
+		Dockerfile.push(`COPY ./${baseDirectory || ''}yarn.lock ./`);
+	} catch (error) {}
+	try {
+		await fs.stat(`${workdir}/pnpm-lock.yaml`);
+		Dockerfile.push(`COPY ./${baseDirectory || ''}pnpm-lock.yaml ./`);
+	} catch (error) {}
+	Dockerfile.push(`RUN ${installCommand}`);
+	Dockerfile.push(`COPY ./${baseDirectory || ''} ./`);
+	if (buildCommand) {
+		Dockerfile.push(`RUN ${buildCommand}`);
+	}
+	Dockerfile.push(`EXPOSE ${port}`);
+	Dockerfile.push(`CMD ${startCommand}`);
+	await fs.writeFile(`${workdir}/Dockerfile`, Dockerfile.join('\n'));
+};
+
+export default async function (data) {
+	try {
+		const image = 'node:lts';
+		await createDockerfile(data, image);
+		await buildImage(data);
+	} catch (error) {
+		throw error;
+	}
+}

src/lib/buildPacks/php.ts

@@ -0,0 +1,25 @@
+import { buildImage } from '$lib/docker';
+import { promises as fs } from 'fs';
+
+const createDockerfile = async (data, image): Promise<void> => {
+	const { workdir, baseDirectory } = data;
+	const Dockerfile: Array<string> = [];
+
+	Dockerfile.push(`FROM ${image}`);
+	Dockerfile.push('RUN a2enmod rewrite');
+	Dockerfile.push('WORKDIR /var/www/html');
+	Dockerfile.push(`COPY ./${baseDirectory || ''} /var/www/html`);
+	Dockerfile.push(`EXPOSE 80`);
+	Dockerfile.push('CMD ["apache2-foreground"]');
+	await fs.writeFile(`${workdir}/Dockerfile`, Dockerfile.join('\n'));
+};
+
+export default async function (data) {
+	try {
+		const image = 'php:apache';
+		await createDockerfile(data, image);
+		await buildImage(data);
+	} catch (error) {
+		throw error;
+	}
+}

src/lib/buildPacks/react.ts

@@ -0,0 +1,26 @@
+import { buildCacheImageWithNode, buildImage } from '$lib/docker';
+import { promises as fs } from 'fs';
+
+const createDockerfile = async (data, image): Promise<void> => {
+	const { applicationId, tag, workdir, publishDirectory } = data;
+	const Dockerfile: Array<string> = [];
+
+	Dockerfile.push(`FROM ${image}`);
+	Dockerfile.push('WORKDIR /usr/share/nginx/html');
+	Dockerfile.push(`COPY --from=${applicationId}:${tag}-cache /usr/src/app/${publishDirectory} ./`);
+	Dockerfile.push(`EXPOSE 80`);
+	Dockerfile.push('CMD ["nginx", "-g", "daemon off;"]');
+	await fs.writeFile(`${workdir}/Dockerfile`, Dockerfile.join('\n'));
+};
+
+export default async function (data) {
+	try {
+		const image = 'nginx:stable-alpine';
+		const imageForBuild = 'node:lts';
+		await buildCacheImageWithNode(data, imageForBuild);
+		await createDockerfile(data, image);
+		await buildImage(data);
+	} catch (error) {
+		throw error;
+	}
+}

src/lib/buildPacks/rust.ts

@@ -0,0 +1,43 @@
+import { asyncExecShell } from '$lib/common';
+import { buildCacheImageWithCargo, buildImage } from '$lib/docker';
+import { promises as fs } from 'fs';
+import TOML from '@iarna/toml';
+
+const createDockerfile = async (data, image, name): Promise<void> => {
+	const { workdir, port, applicationId, tag } = data;
+	const Dockerfile: Array<string> = [];
+	Dockerfile.push(`FROM ${image}`);
+	Dockerfile.push('WORKDIR /usr/src/app');
+	Dockerfile.push(`COPY --from=${applicationId}:${tag}-cache /usr/src/app/target target`);
+	Dockerfile.push(`COPY --from=${applicationId}:${tag}-cache /usr/local/cargo /usr/local/cargo`);
+	Dockerfile.push(`COPY . .`);
+	Dockerfile.push(`RUN cargo build --release --bin ${name}`);
+	Dockerfile.push('FROM debian:buster-slim');
+	Dockerfile.push('WORKDIR /usr/src/app');
+	Dockerfile.push(
+		`RUN apt-get update -y && apt-get install -y --no-install-recommends openssl libcurl4 ca-certificates && apt-get autoremove -y && apt-get clean -y && rm -rf /var/lib/apt/lists/*`
+	);
+	Dockerfile.push(`RUN update-ca-certificates`);
+	Dockerfile.push(
+		`COPY --from=${applicationId}:${tag}-cache /usr/src/app/target/release/${name} ${name}`
+	);
+	Dockerfile.push(`EXPOSE ${port}`);
+	Dockerfile.push(`CMD ["/usr/src/app/${name}"]`);
+	await fs.writeFile(`${workdir}/Dockerfile`, Dockerfile.join('\n'));
+};
+
+export default async function (data) {
+	try {
+		const { workdir } = data;
+		const image = 'rust:latest';
+		const imageForBuild = 'rust:latest';
+		const { stdout: cargoToml } = await asyncExecShell(`cat ${workdir}/Cargo.toml`);
+		const parsedToml: any = TOML.parse(cargoToml);
+		const name = parsedToml.package.name;
+		await buildCacheImageWithCargo(data, imageForBuild);
+		await createDockerfile(data, image, name);
+		await buildImage(data);
+	} catch (error) {
+		throw error;
+	}
+}

src/lib/buildPacks/static.ts

@@ -0,0 +1,40 @@
+import { buildCacheImageWithNode, buildImage } from '$lib/docker';
+import { promises as fs } from 'fs';
+
+const createDockerfile = async (data, image): Promise<void> => {
+	const { applicationId, tag, workdir, buildCommand, baseDirectory, publishDirectory, secrets } =
+		data;
+	const Dockerfile: Array<string> = [];
+
+	Dockerfile.push(`FROM ${image}`);
+	Dockerfile.push('WORKDIR /usr/share/nginx/html');
+	if (secrets.length > 0) {
+		secrets.forEach((secret) => {
+			if (secret.isBuildSecret) {
+				Dockerfile.push(`ARG ${secret.name} ${secret.value}`);
+			}
+		});
+	}
+	if (buildCommand) {
+		Dockerfile.push(
+			`COPY --from=${applicationId}:${tag}-cache /usr/src/app/${publishDirectory} ./`
+		);
+	} else {
+		Dockerfile.push(`COPY ./${baseDirectory || ''} ./`);
+	}
+	Dockerfile.push(`EXPOSE 80`);
+	Dockerfile.push('CMD ["nginx", "-g", "daemon off;"]');
+	await fs.writeFile(`${workdir}/Dockerfile`, Dockerfile.join('\n'));
+};
+
+export default async function (data) {
+	try {
+		const image = 'nginx:stable-alpine';
+		const imageForBuild = 'node:lts';
+		if (data.buildCommand) await buildCacheImageWithNode(data, imageForBuild);
+		await createDockerfile(data, image);
+		await buildImage(data);
+	} catch (error) {
+		throw error;
+	}
+}

src/lib/buildPacks/svelte.ts

@@ -0,0 +1,27 @@
+import { buildCacheImageWithNode, buildImage } from '$lib/docker';
+import { promises as fs } from 'fs';
+
+const createDockerfile = async (data, image): Promise<void> => {
+	const { applicationId, tag, workdir, publishDirectory } = data;
+	const Dockerfile: Array<string> = [];
+
+	Dockerfile.push(`FROM ${image}`);
+	Dockerfile.push('WORKDIR /usr/share/nginx/html');
+	Dockerfile.push(`COPY --from=${applicationId}:${tag}-cache /usr/src/app/${publishDirectory} ./`);
+	Dockerfile.push(`EXPOSE 80`);
+	Dockerfile.push('CMD ["nginx", "-g", "daemon off;"]');
+	await fs.writeFile(`${workdir}/Dockerfile`, Dockerfile.join('\n'));
+};
+
+export default async function (data) {
+	try {
+		const image = 'nginx:stable-alpine';
+		const imageForBuild = 'node:lts';
+
+		await buildCacheImageWithNode(data, imageForBuild);
+		await createDockerfile(data, image);
+		await buildImage(data);
+	} catch (error) {
+		throw error;
+	}
+}

src/lib/buildPacks/vuejs.ts

@@ -0,0 +1,26 @@
+import { buildCacheImageWithNode, buildImage } from '$lib/docker';
+import { promises as fs } from 'fs';
+
+const createDockerfile = async (data, image): Promise<void> => {
+	const { applicationId, tag, workdir, publishDirectory } = data;
+	const Dockerfile: Array<string> = [];
+
+	Dockerfile.push(`FROM ${image}`);
+	Dockerfile.push('WORKDIR /usr/share/nginx/html');
+	Dockerfile.push(`COPY --from=${applicationId}:${tag}-cache /usr/src/app/${publishDirectory} ./`);
+	Dockerfile.push(`EXPOSE 80`);
+	Dockerfile.push('CMD ["nginx", "-g", "daemon off;"]');
+	await fs.writeFile(`${workdir}/Dockerfile`, Dockerfile.join('\n'));
+};
+
+export default async function (data) {
+	try {
+		const image = 'nginx:stable-alpine';
+		const imageForBuild = 'node:lts';
+		await buildCacheImageWithNode(data, imageForBuild);
+		await createDockerfile(data, image);
+		await buildImage(data);
+	} catch (error) {
+		throw error;
+	}
+}