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 }

api/libs/common.js

@@ -0,0 +1,94 @@
+const crypto = require('crypto')
+const shell = require('shelljs')
+const jsonwebtoken = require('jsonwebtoken')
+const { docker } = require('./docker')
+const User = require('../models/User')
+const algorithm = 'aes-256-cbc'
+const key = process.env.SECRETS_ENCRYPTION_KEY
+
+function delay (t) {
+  return new Promise(function (resolve) {
+    setTimeout(function () {
+      resolve('OK')
+    }, t)
+  })
+}
+
+async function verifyUserId (authorization) {
+  const token = authorization.split(' ')[1]
+  const verify = jsonwebtoken.verify(token, process.env.JWT_SIGN_KEY)
+  const found = await User.findOne({ uid: verify.jti })
+  if (found) {
+    return true
+  } else {
+    return false
+  }
+}
+function execShellAsync (cmd, opts = {}) {
+  try {
+    return new Promise(function (resolve, reject) {
+      shell.config.silent = true
+      shell.exec(cmd, opts, function (code, stdout, stderr) {
+        if (code !== 0) return reject(new Error(stderr))
+        return resolve(stdout)
+      })
+    })
+  } catch (error) {
+    return new Error('Oops')
+  }
+}
+function cleanupTmp (dir) {
+  if (dir !== '/') shell.rm('-fr', dir)
+}
+
+async function checkImageAvailable (name) {
+  let cacheAvailable = false
+  try {
+    await docker.engine.getImage(name).get()
+    cacheAvailable = true
+  } catch (e) {
+    // Cache image not found
+  }
+  return cacheAvailable
+}
+
+function encryptData (text) {
+  const iv = crypto.randomBytes(16)
+  const cipher = crypto.createCipheriv(algorithm, Buffer.from(key), iv)
+  let encrypted = cipher.update(text)
+  encrypted = Buffer.concat([encrypted, cipher.final()])
+  return { iv: iv.toString('hex'), encryptedData: encrypted.toString('hex') }
+}
+
+function decryptData (text) {
+  const iv = Buffer.from(text.iv, 'hex')
+  const encryptedText = Buffer.from(text.encryptedData, 'hex')
+  const decipher = crypto.createDecipheriv(algorithm, Buffer.from(key), iv)
+  let decrypted = decipher.update(encryptedText)
+  decrypted = Buffer.concat([decrypted, decipher.final()])
+  return decrypted.toString()
+}
+
+function createToken (payload) {
+  const { uuid } = payload
+  return jsonwebtoken.sign({}, process.env.JWT_SIGN_KEY, {
+    expiresIn: 15778800,
+    algorithm: 'HS256',
+    audience: 'coolify',
+    issuer: 'coolify',
+    jwtid: uuid,
+    subject: `User:${uuid}`,
+    notBefore: -1000
+  })
+}
+
+module.exports = {
+  delay,
+  createToken,
+  execShellAsync,
+  cleanupTmp,
+  checkImageAvailable,
+  encryptData,
+  decryptData,
+  verifyUserId
+}

api/libs/docker.js

@@ -0,0 +1,31 @@
+const Dockerode = require('dockerode')
+const { saveAppLog } = require('./logging')
+
+const docker = {
+  engine: new Dockerode({
+    socketPath: process.env.DOCKER_ENGINE
+  }),
+  network: process.env.DOCKER_NETWORK
+}
+async function streamEvents (stream, configuration) {
+  try {
+    await new Promise((resolve, reject) => {
+      docker.engine.modem.followProgress(stream, onFinished, onProgress)
+      function onFinished (err, res) {
+        if (err) reject(err)
+        resolve(res)
+      }
+      function onProgress (event) {
+        if (event.error) {
+          reject(event.error)
+          return
+        }
+        saveAppLog(event.stream, configuration)
+      }
+    })
+  } catch (error) {
+    throw { error, type: 'app' }
+  }
+}
+
+module.exports = { streamEvents, docker }

api/libs/logging.js

@@ -0,0 +1,55 @@
+const ApplicationLog = require('../models/Logs/Application')
+const ServerLog = require('../models/Logs/Server')
+const dayjs = require('dayjs')
+
+function generateTimestamp () {
+  return `${dayjs().format('YYYY-MM-DD HH:mm:ss.SSS')} `
+}
+
+async function saveAppLog (event, configuration, isError) {
+  try {
+    const deployId = configuration.general.deployId
+    const repoId = configuration.repository.id
+    const branch = configuration.repository.branch
+    if (isError) {
+      // console.log(event, config, isError)
+      let clearedEvent = null
+
+      if (event.error) clearedEvent = '[ERROR] ' + generateTimestamp() + event.error.replace(/(\r\n|\n|\r)/gm, '')
+      else if (event) clearedEvent = '[ERROR] ' + generateTimestamp() + event.replace(/(\r\n|\n|\r)/gm, '')
+
+      try {
+        await new ApplicationLog({ repoId, branch, deployId, event: clearedEvent }).save()
+      } catch (error) {
+        console.log(error)
+      }
+    } else {
+      if (event && event !== '\n') {
+        const clearedEvent = '[INFO] ' + generateTimestamp() + event.replace(/(\r\n|\n|\r)/gm, '')
+        try {
+          await new ApplicationLog({ repoId, branch, deployId, event: clearedEvent }).save()
+        } catch (error) {
+          console.log(error)
+        }
+      }
+    }
+  } catch (error) {
+    console.log(error)
+    return error
+  }
+}
+
+async function saveServerLog ({ event, configuration, type }) {
+  if (configuration) {
+    const deployId = configuration.general.deployId
+    const repoId = configuration.repository.id
+    const branch = configuration.repository.branch
+    await new ApplicationLog({ repoId, branch, deployId, event: `[SERVER ERROR 😖]: ${event}` }).save()
+  }
+  await new ServerLog({ event, type }).save()
+}
+
+module.exports = {
+  saveAppLog,
+  saveServerLog
+}