104 lines
3.5 KiB
TypeScript
104 lines
3.5 KiB
TypeScript
import { ErrorHandler, generateDatabaseConfiguration, prisma } from '$lib/database';
|
|
import {
|
|
checkContainer,
|
|
startCoolifyProxy,
|
|
startHttpProxy,
|
|
startTcpProxy,
|
|
startTraefikHTTPProxy,
|
|
startTraefikProxy,
|
|
startTraefikTCPProxy,
|
|
stopCoolifyProxy,
|
|
stopTcpHttpProxy,
|
|
stopTraefikProxy
|
|
} from '$lib/haproxy';
|
|
|
|
export default async function (): Promise<void | {
|
|
status: number;
|
|
body: { message: string; error: string };
|
|
}> {
|
|
try {
|
|
// Coolify Proxy
|
|
const engine = '/var/run/docker.sock';
|
|
const settings = await prisma.setting.findFirst();
|
|
const localDocker = await prisma.destinationDocker.findFirst({
|
|
where: { engine, network: 'coolify' }
|
|
});
|
|
if (localDocker && localDocker.isCoolifyProxyUsed) {
|
|
if (settings.isTraefikUsed) {
|
|
const found = await checkContainer(engine, 'coolify-haproxy');
|
|
if (found) await stopCoolifyProxy(engine);
|
|
await startTraefikProxy(engine);
|
|
} else {
|
|
const found = await checkContainer(engine, 'coolify-proxy');
|
|
if (found) await stopTraefikProxy(engine);
|
|
await startCoolifyProxy(engine);
|
|
}
|
|
}
|
|
|
|
// TCP Proxies
|
|
const databasesWithPublicPort = await prisma.database.findMany({
|
|
where: { publicPort: { not: null } },
|
|
include: { settings: true, destinationDocker: true }
|
|
});
|
|
for (const database of databasesWithPublicPort) {
|
|
const { destinationDockerId, destinationDocker, publicPort, id } = database;
|
|
if (destinationDockerId) {
|
|
if (destinationDocker.isCoolifyProxyUsed) {
|
|
const { privatePort } = generateDatabaseConfiguration(database);
|
|
if (settings.isTraefikUsed) {
|
|
await stopTcpHttpProxy(id, destinationDocker, publicPort, `haproxy-for-${publicPort}`);
|
|
await startTraefikTCPProxy(destinationDocker, id, publicPort, privatePort);
|
|
} else {
|
|
await stopTcpHttpProxy(id, destinationDocker, publicPort, `${id}-${publicPort}`);
|
|
await startTcpProxy(destinationDocker, id, publicPort, privatePort);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const wordpressWithFtp = await prisma.wordpress.findMany({
|
|
where: { ftpPublicPort: { not: null } },
|
|
include: { service: { include: { destinationDocker: true } } }
|
|
});
|
|
for (const ftp of wordpressWithFtp) {
|
|
const { service, ftpPublicPort } = ftp;
|
|
const { destinationDockerId, destinationDocker, id } = service;
|
|
if (destinationDockerId) {
|
|
if (destinationDocker.isCoolifyProxyUsed) {
|
|
if (settings.isTraefikUsed) {
|
|
await stopTcpHttpProxy(
|
|
id,
|
|
destinationDocker,
|
|
ftpPublicPort,
|
|
`haproxy-for-${ftpPublicPort}`
|
|
);
|
|
await startTraefikTCPProxy(destinationDocker, id, ftpPublicPort, 22, 'wordpressftp');
|
|
} else {
|
|
await stopTcpHttpProxy(id, destinationDocker, ftpPublicPort, `${id}-${ftpPublicPort}`);
|
|
await startTcpProxy(destinationDocker, `${id}-ftp`, ftpPublicPort, 22);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// HTTP Proxies
|
|
if (!settings.isTraefikUsed) {
|
|
const minioInstances = await prisma.minio.findMany({
|
|
where: { publicPort: { not: null } },
|
|
include: { service: { include: { destinationDocker: true } } }
|
|
});
|
|
for (const minio of minioInstances) {
|
|
const { service, publicPort } = minio;
|
|
const { destinationDockerId, destinationDocker, id } = service;
|
|
if (destinationDockerId) {
|
|
if (destinationDocker.isCoolifyProxyUsed) {
|
|
await stopTcpHttpProxy(id, destinationDocker, publicPort, `${id}-${publicPort}`);
|
|
await startHttpProxy(destinationDocker, id, publicPort, 9000);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} catch (error) {
|
|
return ErrorHandler(error.response?.body || error);
|
|
}
|
|
}
|