initial production release 🎉

api/libs/applications/build/container.js

@@ -0,0 +1,34 @@
+const packs = require('../../../packs')
+const { saveAppLog } = require('../../logging')
+const Deployment = require('../../../models/Deployment')
+
+module.exports = async function (configuration) {
+  const { id, organization, name, branch } = configuration.repository
+  const { domain } = configuration.publish
+  const deployId = configuration.general.deployId
+
+  const execute = packs[configuration.build.pack]
+  if (execute) {
+    try {
+      await Deployment.findOneAndUpdate(
+        { repoId: id, branch, deployId, organization, name, domain },
+        { repoId: id, branch, deployId, organization, name, domain, progress: 'inprogress' })
+      await saveAppLog('### Building application.', configuration)
+
+      await execute(configuration)
+
+      await saveAppLog('### Building done.', configuration)
+    } catch (error) {
+      await Deployment.findOneAndUpdate(
+        { repoId: id, branch, deployId, organization, name, domain },
+        { repoId: id, branch, deployId, organization, name, domain, progress: 'failed' })
+      if (error.stack) throw { error: error.stack, type: 'server' }
+      throw { error, type: 'app' }
+    }
+  } else {
+    await Deployment.findOneAndUpdate(
+      { repoId: id, branch, deployId, organization, name, domain },
+      { repoId: id, branch, deployId, organization, name, domain, progress: 'failed' })
+    throw { error: 'No buildpack found.', type: 'app' }
+  }
+}

api/libs/applications/cleanup/index.js

@@ -0,0 +1,41 @@
+const { docker } = require('../../docker')
+const { execShellAsync, delay } = require('../../common')
+const Deployment = require('../../../models/Deployment')
+
+async function purgeOldThings () {
+  try {
+    await docker.engine.pruneImages()
+    await docker.engine.pruneContainers()
+  } catch (error) {
+    throw { error, type: 'server' }
+  }
+}
+
+async function cleanup (configuration) {
+  const { id } = configuration.repository
+  const deployId = configuration.general.deployId
+  try {
+    // Cleanup stucked deployments.
+    const deployments = await Deployment.find({ repoId: id, deployId: { $ne: deployId }, progress: { $in: ['queued', 'inprogress'] } })
+    for (const deployment of deployments) {
+      await Deployment.findByIdAndUpdate(deployment._id, { $set: { progress: 'failed' } })
+    }
+  } catch (error) {
+    throw { error, type: 'server' }
+  }
+}
+
+async function deleteSameDeployments (configuration) {
+  try {
+    await (await docker.engine.listServices()).filter(r => r.Spec.Labels.managedBy === 'coolify' && r.Spec.Labels.type === 'application').map(async s => {
+      const running = JSON.parse(s.Spec.Labels.configuration)
+      if (running.repository.id === configuration.repository.id && running.repository.branch === configuration.repository.branch) {
+        await execShellAsync(`docker stack rm ${s.Spec.Labels['com.docker.stack.namespace']}`)
+      }
+    })
+  } catch (error) {
+    throw { error, type: 'server' }
+  }
+}
+
+module.exports = { cleanup, deleteSameDeployments, purgeOldThings }

api/libs/applications/configuration.js

@@ -0,0 +1,62 @@
+const { uniqueNamesGenerator, adjectives, colors, animals } = require('unique-names-generator')
+const cuid = require('cuid')
+const { execShellAsync } = require('../common')
+const crypto = require('crypto')
+
+function getUniq () {
+  return uniqueNamesGenerator({ dictionaries: [adjectives, animals, colors], length: 2 })
+}
+
+function setDefaultConfiguration (configuration) {
+  try {
+    const nickname = getUniq()
+    const deployId = cuid()
+
+    const shaBase = JSON.stringify({ repository: configuration.repository })
+    const sha256 = crypto.createHash('sha256').update(shaBase).digest('hex')
+
+    configuration.build.container.name = sha256.slice(0, 15)
+
+    configuration.general.nickname = nickname
+    configuration.general.deployId = deployId
+    configuration.general.workdir = `/tmp/${deployId}`
+
+    if (!configuration.publish.path) configuration.publish.path = '/'
+    if (!configuration.publish.port) configuration.publish.port = configuration.build.pack === 'static' ? 80 : 3000
+
+    if (configuration.build.pack === 'static') {
+      if (!configuration.build.command.installation) configuration.build.command.installation = 'yarn install'
+      if (!configuration.build.directory) configuration.build.directory = '/'
+    }
+
+    if (configuration.build.pack === 'nodejs') {
+      if (!configuration.build.command.installation) configuration.build.command.installation = 'yarn install'
+      if (!configuration.build.directory) configuration.build.directory = '/'
+    }
+
+    return configuration
+  } catch (error) {
+    throw { error, type: 'server' }
+  }
+}
+
+async function updateServiceLabels (configuration, services) {
+  // In case of any failure during deployment, still update the current configuration.
+  const found = services.find(s => {
+    const config = JSON.parse(s.Spec.Labels.configuration)
+    if (config.repository.id === configuration.repository.id && config.repository.branch === configuration.repository.branch) {
+      return config
+    }
+    return null
+  })
+  if (found) {
+    const { ID } = found
+    try {
+      const Labels = { ...JSON.parse(found.Spec.Labels.configuration), ...configuration }
+      execShellAsync(`docker service update --label-add configuration='${JSON.stringify(Labels)}' --label-add com.docker.stack.image='${configuration.build.container.name}:${configuration.build.container.tag}' ${ID}`)
+    } catch (error) {
+      console.log(error)
+    }
+  }
+}
+module.exports = { setDefaultConfiguration, updateServiceLabels }

api/libs/applications/deploy/copyFiles.js

@@ -0,0 +1,53 @@
+const fs = require('fs').promises
+module.exports = async function (configuration) {
+  try {
+    // TODO: Do it better.
+    await fs.writeFile(`${configuration.general.workdir}/.dockerignore`, 'node_modules')
+    await fs.writeFile(
+      `${configuration.general.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;
+                }  
+        
+            }
+        
+        }
+        `
+    )
+  } catch (error) {
+    throw { error, type: 'server' }
+  }
+}

api/libs/applications/deploy/deploy.js

@@ -0,0 +1,97 @@
+const yaml = require('js-yaml')
+const { execShellAsync } = require('../../common')
+const { docker } = require('../../docker')
+const { saveAppLog } = require('../../logging')
+const { deleteSameDeployments } = require('../cleanup')
+const fs = require('fs').promises
+
+module.exports = async function (configuration, configChanged, imageChanged) {
+  try {
+    const generateEnvs = {}
+    for (const secret of configuration.publish.secrets) {
+      generateEnvs[secret.name] = secret.value
+    }
+    const containerName = configuration.build.container.name
+    const stack = {
+      version: '3.8',
+      services: {
+        [containerName]: {
+          image: `${configuration.build.container.name}:${configuration.build.container.tag}`,
+          networks: [`${docker.network}`],
+          environment: generateEnvs,
+          deploy: {
+            replicas: 1,
+            restart_policy: {
+              condition: 'on-failure',
+              delay: '5s',
+              max_attempts: 1,
+              window: '120s'
+            },
+            update_config: {
+              parallelism: 1,
+              delay: '10s',
+              order: 'start-first'
+            },
+            rollback_config: {
+              parallelism: 1,
+              delay: '10s',
+              order: 'start-first'
+            },
+            labels: [
+              'managedBy=coolify',
+              'type=application',
+              'configuration=' + JSON.stringify(configuration),
+              'traefik.enable=true',
+              'traefik.http.services.' +
+              configuration.build.container.name +
+              `.loadbalancer.server.port=${configuration.publish.port}`,
+              'traefik.http.routers.' +
+              configuration.build.container.name +
+              '.entrypoints=websecure',
+              'traefik.http.routers.' +
+              configuration.build.container.name +
+              '.rule=Host(`' +
+              configuration.publish.domain +
+              '`) && PathPrefix(`' +
+              configuration.publish.path +
+              '`)',
+              'traefik.http.routers.' +
+              configuration.build.container.name +
+              '.tls.certresolver=letsencrypt',
+              'traefik.http.routers.' +
+              configuration.build.container.name +
+              '.middlewares=global-compress'
+            ]
+          }
+        }
+      },
+      networks: {
+        [`${docker.network}`]: {
+          external: true
+        }
+      }
+    }
+    await saveAppLog('### Publishing.', configuration)
+    await fs.writeFile(`${configuration.general.workdir}/stack.yml`, yaml.dump(stack))
+    if (configChanged) {
+      // console.log('configuration changed')
+      await execShellAsync(
+        `cat ${configuration.general.workdir}/stack.yml | docker stack deploy --prune -c - ${containerName}`
+      )
+    } else if (imageChanged) {
+      // console.log('image changed')
+      await execShellAsync(`docker service update --image ${configuration.build.container.name}:${configuration.build.container.tag} ${configuration.build.container.name}_${configuration.build.container.name}`)
+    } else {
+      // console.log('new deployment or force deployment')
+      await deleteSameDeployments(configuration)
+      await execShellAsync(
+        `cat ${configuration.general.workdir}/stack.yml | docker stack deploy --prune -c - ${containerName}`
+      )
+    }
+
+    await saveAppLog('### Published done!', configuration)
+  } catch (error) {
+    await saveAppLog(`Error occured during deployment: ${error.message}`, configuration)
+    throw { error, type: 'server' }
+  }
+}

api/libs/applications/github/cloneRepository.js

@@ -0,0 +1,44 @@
+const jwt = require('jsonwebtoken')
+const axios = require('axios')
+const { execShellAsync, cleanupTmp } = require('../../common')
+
+module.exports = async function (configuration) {
+  const { workdir } = configuration.general
+  const { organization, name, branch } = configuration.repository
+  const github = configuration.github
+
+  const githubPrivateKey = process.env.GITHUB_APP_PRIVATE_KEY.replace(/\\n/g, '\n').replace(/"/g, '')
+
+  const payload = {
+    iat: Math.round(new Date().getTime() / 1000),
+    exp: Math.round(new Date().getTime() / 1000 + 60),
+    iss: parseInt(github.app.id)
+  }
+
+  try {
+    const jwtToken = jwt.sign(payload, githubPrivateKey, {
+      algorithm: 'RS256'
+    })
+    const accessToken = await axios({
+      method: 'POST',
+      url: `https://api.github.com/app/installations/${github.installation.id}/access_tokens`,
+      data: {},
+      headers: {
+        Authorization: 'Bearer ' + jwtToken,
+        Accept: 'application/vnd.github.machine-man-preview+json'
+      }
+    })
+    await execShellAsync(
+      `mkdir -p ${workdir} && git clone -q -b ${branch} https://x-access-token:${accessToken.data.token}@github.com/${organization}/${name}.git ${workdir}/`
+    )
+    configuration.build.container.tag = (
+      await execShellAsync(`cd ${configuration.general.workdir}/ && git rev-parse HEAD`)
+    )
+      .replace('\n', '')
+      .slice(0, 7)
+  } catch (error) {
+    cleanupTmp(workdir)
+    if (error.stack) console.log(error.stack)
+    throw { error, type: 'server' }
+  }
+}

api/libs/applications/index.js

@@ -0,0 +1,44 @@
+const dayjs = require('dayjs')
+
+const { saveServerLog } = require('../logging')
+const { cleanupTmp } = require('../common')
+
+const { saveAppLog } = require('../logging')
+const copyFiles = require('./deploy/copyFiles')
+const buildContainer = require('./build/container')
+const deploy = require('./deploy/deploy')
+const Deployment = require('../../models/Deployment')
+const { cleanup, purgeOldThings } = require('./cleanup')
+const { updateServiceLabels } = require('./configuration')
+
+async function queueAndBuild (configuration, services, configChanged, imageChanged) {
+  const { id, organization, name, branch } = configuration.repository
+  const { domain } = configuration.publish
+  const { deployId, nickname, workdir } = configuration.general
+  try {
+    await new Deployment({
+      repoId: id, branch, deployId, domain, organization, name, nickname
+    }).save()
+    await saveAppLog(`${dayjs().format('YYYY-MM-DD HH:mm:ss.SSS')} Queued.`, configuration)
+    await copyFiles(configuration)
+    await buildContainer(configuration)
+    await deploy(configuration, configChanged, imageChanged)
+    await Deployment.findOneAndUpdate(
+      { repoId: id, branch, deployId, organization, name, domain },
+      { repoId: id, branch, deployId, organization, name, domain, progress: 'done' })
+    await updateServiceLabels(configuration, services)
+    cleanupTmp(workdir)
+    await purgeOldThings()
+  } catch (error) {
+    await cleanup(configuration)
+    cleanupTmp(workdir)
+    const { type } = error.error
+    if (type === 'app') {
+      await saveAppLog(error.error, configuration, true)
+    } else {
+      await saveServerLog({ event: error.error, configuration })
+    }
+  }
+}
+
+module.exports = { queueAndBuild }