@ossy/deployment-tools 0.0.1

package/dist/licenses.txt

@@ -0,0 +1,23 @@
+node-fetch
+MIT
+The MIT License (MIT)
+
+Copyright (c) 2016 - 2020 Node Fetch Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@ossy/deployment-tools",
+  "version": "0.0.1",
+  "description": "Collection of scripts and tools to aid deployment of containers and static files",
+  "main": "dist/index.js",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "npx --yes @vercel/ncc build src/index.js --out dist --license licenses.txt"
+  },
+  "author": "Ossy",
+  "license": "ISC",
+  "bin": "dist/index.js",
+  "dependencies": {
+    "arg": "^5.0.2",
+    "express": "^4.18.1",
+    "nanoid": "^4.0.0",
+    "node-fetch": "^3.2.6"
+  }
+}

package/src/Caddyfile

@@ -0,0 +1,22 @@
+localhost {
+  reverse_proxy /api/* {
+    to localhost:3001
+  }
+
+  reverse_proxy * {
+    to localhost:3000
+  }
+
+}
+
+cms.localhost {
+  reverse_proxy * {
+    to localhost:3005
+  }
+}
+
+admin.localhost {
+  reverse_proxy * {
+    to localhost:3000
+  }
+}

package/src/caddy-client.js

@@ -0,0 +1,118 @@
+import fetch from 'node-fetch'
+
+const Matchers = {
+  host: host => ({ host: [host] }),
+  path: path => ({ path: [path] })
+}
+
+const Handlers = {
+  reverseProxy: upstreamPort => ({
+    handler: 'reverse_proxy',
+    upstreams: [{ dial: `localhost:${upstreamPort}` }]
+  }),
+  subroute: routes => ( {
+    handler: 'subroute',
+    routes
+  })
+}
+
+const createRouteConfig = ({ domain, path, upstreamPort }) => ({
+  match: [Matchers.host(domain)],
+  handle: [
+    {
+      handler: 'subroute',
+      routes: [
+        { handle: [Handlers.reverseProxy(upstreamPort)]}
+      ]
+    }
+  ],
+  terminal: true
+})
+
+const multipleDomansAndSubroutes = () => ({
+  apps: {
+    http: {
+      servers: {
+        'ci-client': {
+          listen: [
+            ':443'
+          ],
+          routes: [
+            {
+              match: [Matchers.host('admin.localhost')],
+              handle: [
+                Handlers.subroute([{ handle: [Handlers.reverseProxy(3000)] }])
+              ],
+              terminal: true
+            },
+            {
+              match: [Matchers.host('cms.localhost')],
+              handle: [
+                Handlers.subroute([{ handle: [Handlers.reverseProxy(3005)] }])
+              ],
+              terminal: true
+            },
+            {
+              match: [Matchers.host('localhost')],
+              handle: [
+                Handlers.subroute([
+                  {
+                    handle: [Handlers.reverseProxy(3001)],
+                    match: [Matchers.path('/api/*')]
+                  },
+                  { handle: [Handlers.reverseProxy(3000)] }
+                ])
+              ],
+              terminal: true
+            }
+          ]
+        }
+      }
+    }
+  }
+})
+
+//   curl localhost:2019/id/msg
+
+class CaddyClient {
+
+  constructor(serverName = 'ci-client') {
+    this.serverName = serverName
+  }
+
+  deploy({ domain, targetPort }) {
+    return fetch(`http://localhost:2019/config/apps/http/servers/${this.serverName}/routes`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        match: [Matchers.host(domain)],
+        handle: [
+          Handlers.subroute([{ handle: [Handlers.reverseProxy(targetPort)] }])
+        ],
+        terminal: true
+      })
+    })
+  }
+
+  applyDefaultServerConfig() {
+    return fetch('http://localhost:2019/load', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        apps: {
+          http: {
+            servers: {
+              [this.serverName]: {
+                listen: [':443'],
+                routes: []
+              }
+            }
+          }
+        }
+      })
+    })
+  }
+
+}
+
+export const createCaddyClient = serverName => new CaddyClient(serverName)

package/src/config.js

@@ -0,0 +1,3 @@
+export const domain = process.env.DEPLOYMENT_TOOLS_DOMAIN || 'localhost'
+export const subdomain = process.env.DEPLOYMENT_TOOLS_SUBDOMAIN || 'local-dev.ci'
+export const port = process.env.DEPLOYMENT_TOOLS_PORT || 3000

package/src/container-manager-commands.js

@@ -0,0 +1,114 @@
+import { resolve } from 'path'
+import { readFileSync } from 'fs'
+import fetch from 'node-fetch'
+
+const username = 'oskarssylwan'
+const authentication = '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'
+
+export class ContainerManagerCommands {
+
+  static deploy(
+    targetEnvironment = 'local-dev',
+    pathToDeploymentPlatforms,
+    pathToOssyFile
+  ) {
+    const webApiCommands = new ContainerManagerCommands()
+    return webApiCommands.deploy(
+      targetEnvironment,
+      pathToDeploymentPlatforms,
+      pathToOssyFile
+    )
+  }
+
+  constructor() {
+
+  }
+
+  getDeployments(pathToOssyFile) {
+    const ossyfile = JSON.parse(readFileSync(resolve(pathToOssyFile), 'utf8'))
+    return Promise.resolve(ossyfile.deployments || [])
+  }
+
+  async getDeploymentPlatforms(pathToDeploymentPlatforms) {
+
+    const localDevPlatform = {
+      name: 'local-dev',
+      domain: 'localhost',
+      supportedDeploymentTypes: ['CONTAINER']
+    }
+
+    if (!pathToDeploymentPlatforms) return [localDevPlatform]
+
+    const imports = await import(resolve(pathToDeploymentPlatforms))
+    const deploymentPlatforms = Object.values(imports)
+    return deploymentPlatforms || [localDevPlatform]
+  }
+
+  getDeploymentTargetURL(targetEnvironment, deploymentPlatform, deployment) {
+    let domain = targetEnvironment !== 'prod'
+      ? `${targetEnvironment}.`
+      : ''
+
+    domain = deployment.subdomain
+      ? `${domain}${deployment.subdomain}.${deploymentPlatform.domain}`
+      : `${domain}${deploymentPlatform.domain}`
+
+    return domain
+  }
+
+  getEnvironmentVariables(targetEnvironment, deployment) {
+    const envs = deployment.env || {}
+    return {
+      ...(envs.shared || {}),
+      ...(envs[targetEnvironment] || {})
+    }
+  }
+
+  deploy(
+    targetEnvironment = 'local-dev',
+    pathToDeploymentPlatforms,
+    pathToOssyFile
+  ) {
+    console.log('pathToDeploymentPlatforms', pathToDeploymentPlatforms)
+    console.log('pathToOssyFile', pathToOssyFile)
+    console.log('pathToOssyFile resolved', resolve(pathToOssyFile))
+    return Promise.all([
+      this.getDeploymentPlatforms(pathToDeploymentPlatforms),
+      this.getDeployments(pathToOssyFile)
+    ])
+      .then(([platforms, deployments]) => {
+        deployments.map(deployment => {
+          const platform = platforms.find(platform => platform.name === deployment.targetDeploymentPlatform)
+
+          if (!platform) {
+            return Promise.reject(
+              `Could not find a deployment platform with the name ${deployment.targetDeploymentPlatform}`
+            )
+          }
+
+          process.env.NODE_TLS_REJECT_UNAUTHORIZED = 0
+
+          const body = {
+            image: deployment.image,
+            hostPort: deployment.hostPort,
+            containerPort: deployment.containerPort,
+            domain: this.getDeploymentTargetURL(targetEnvironment, platform, deployment),
+            env: this.getEnvironmentVariables(targetEnvironment, deployment),
+            registry: deployment.registry,
+            username: username,
+            authentication: authentication
+          }
+
+          console.log('body', body)
+
+          fetch(`http://${targetEnvironment}.ci.${platform.domain}/deploy`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body)
+          })
+        })
+      })
+      .catch(error => console.log(error))
+  }
+
+}

package/src/container-manager-server.js

@@ -0,0 +1,73 @@
+import express from 'express'
+import { createCaddyClient } from './caddy-client.js'
+import { createDockerClient } from './docker-client.js'
+import * as config from './config.js'
+
+export class ContainerManagerServer {
+
+  static start() {
+    return new ContainerManagerServer()
+  }
+
+  constructor() {
+    this.dockerClient = createDockerClient()
+    this.caddyClient = createCaddyClient()
+    this.server = express()
+
+    this.server.use(express.json())
+
+    this.caddyClient.applyDefaultServerConfig()
+      .then(() => this.caddyClient.deploy({
+        domain: `${config.subdomain}.${config.domain}`,
+        targetPort: config.port
+      }))
+
+    this.server.get('/', (req, res) => {
+      res.redirect('/status')
+    })
+
+    this.server.get('/status', (req, res) => {
+      res.json('Server is live')
+    })
+
+    this.server.post('/deploy', (req, res) => {
+      console.log('/deploy body', req.body)
+      this.deploy(req, res)
+    })
+
+    this.server.listen(config.port, () => {
+      console.log(`Web API is live on port ${config.port}`)
+    })
+  }
+
+  deploy(req, res) {
+
+    console.log('req.body: ', req.body)
+
+    const {
+      registry,
+      username,
+      authentication,
+      containerPort,
+      hostPort,
+      image,
+      domain,
+      env
+    } = req.body
+
+    this.dockerClient.deploy({
+      image,
+      registry,
+      username,
+      authentication,
+      containerPort,
+      hostPort,
+      env
+    })
+
+    domain && this.caddyClient.deploy({ domain, targetPort: hostPort })
+
+    res.json('Recieved deployment request')
+  }
+
+}

package/src/docker-client.js

@@ -0,0 +1,78 @@
+import { exec } from 'child_process'
+import fs from 'fs'
+import { nanoid } from 'nanoid'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+class DockerClient {
+
+  constructor() {
+    this.networkName = 'deployment-tools'
+    exec(`docker network create ${this.networkName}`)
+  }
+
+  stopContainer({ image }) {
+    const name = image.replaceAll('/', '_')
+    return `sudo docker stop ${name} ||`
+  }
+
+  startContainer({ image, containerPort, hostPort, registry, env }) {
+    const name = image.replaceAll('/', '_')
+    const imageUrl = !!registry ? `${registry}/${image}` : image
+    const envsAsString = Object.entries(env || {}).reduce((envs, [name, value]) => `${envs} --env ${name}=${value}`, '')
+    return `sudo docker run -d -p ${hostPort}:${containerPort} --name=${name} --network=${this.networkName} --network-alias=${name} --rm ${envsAsString} ${imageUrl}`
+  }
+
+  resolveCredentials({ registry, username, authentication }) {
+    return (username || authentication)
+      ? `sudo docker login ${registry} -u ${username} -p ${authentication}`
+      : 'echo No credentials provided, assuming image is publicly hosted'
+  }
+
+  deploy({
+    image,
+    registry,
+    username,
+    authentication,
+    containerPort,
+    hostPort,
+    env
+  }) {
+    return new Promise(resolve => {
+      const dockerCommandScript = `'#!/bin/bash'
+${this.stopContainer({ image })}
+${this.resolveCredentials({ registry, username, authentication })}
+${this.startContainer({ image, containerPort, hostPort, registry, env })}`
+
+      const deploymentId = nanoid()
+
+      const FilePaths = {
+        DeploymentScript: `${__dirname}/${deploymentId}.sh`
+      }
+
+      fs.writeFileSync(FilePaths.DeploymentScript, dockerCommandScript)
+      const command = exec(`bash ${FilePaths.DeploymentScript}`)
+
+      command.stdout.on('data', (data) => {
+        console.log(`[DockerClient]: ${data}`)
+      })
+
+      command.stderr.on('data', (data) => {
+        console.error(`[DockerClient]: ${data}`)
+      })
+
+      command.on('close', (code) => {
+        console.log(`[DockerClient] command exited with code ${code}`)
+        fs.unlinkSync(FilePaths.DeploymentScript)
+        resolve()
+      })
+    })
+
+  }
+
+}
+
+export const createDockerClient = () => new DockerClient()

package/src/index.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+import { platform } from 'os'
+import { writeFileSync } from 'fs'
+import { exec } from 'child_process'
+import arg from 'arg'
+import { ContainerManagerServer } from './container-manager-server.js'
+import { ContainerManagerCommands } from './container-manager-commands.js'
+
+const [_, __, command, ...restArgs] = process.argv
+
+const startHandler = () => {
+  console.log('Running start command')
+
+  const Platforms = {
+    windows: 'win32',
+    mac: 'darwin'
+  }
+
+  if ([Platforms.windows].includes(platform())) {
+    return console.error('Deployment tools do not support this os')
+  }
+
+  writeFileSync('/etc/systemd/system/deployment-tools.service', `
+[Unit]
+Description=D
+After=network.target
+
+[Service]
+Environment=DEPLOYMENT_TOOLS_PORT=3000
+User=root
+WorkingDirectory=/%h/deployment-tools
+ExecStart=/usr/bin/node /%h/deployment-tools/index.js start-container-manager
+Restart=on-failure
+
+[Install]
+WantedBy=multi-user.target
+`)
+
+  exec('systemctl daemon-reload')
+  exec('systemctl start deployment-tools.service')
+
+}
+
+const startContainerManagerHandler = () => {
+  console.log('Running start-container-manager command')
+  ContainerManagerServer.start()
+}
+
+const stopHandler = () => {
+  console.log('Running stop command')
+  exec('systemctl stop deployment-tools.service')
+}
+
+const statusHandler = () => {
+  console.log('Running status command')
+  exec('systemctl status deployment-tools.service')
+}
+
+const deployHandler = () => {
+  console.log('Running deploy command')
+
+  const args = arg({
+    '--target-env': String,
+    '-t': '--target-env',
+
+    '--ossyfile': String,
+    '-o': '--ossyfile',
+
+    '--platforms': String,
+    '-p': '--platforms'
+  }, { argv: restArgs })
+
+  console.log('args', args)
+
+  ContainerManagerCommands.deploy(
+    args['--target-env'],
+    args['--platforms'],
+    args['--ossyfile']
+  )
+}
+
+const Commands = {
+  start: startHandler,
+  stop: stopHandler,
+  status: statusHandler,
+  deploy: deployHandler,
+  // internal commands
+  'start-container-manager': startContainerManagerHandler
+}
+
+const commandHandler = Commands[command]
+
+if (!commandHandler) {
+  console.log('Command not implemented, did you spell it correctly?')
+}
+
+commandHandler()