@ossy/deployment-tools 0.0.24 → 0.0.26

package/src/aws-credentials-client.js

@@ -1,24 +0,0 @@
-import * as core from '@actions/core'
-import { STSClient, AssumeRoleWithWebIdentityCommand } from '@aws-sdk/client-sts'
-
-export class AwsCredentialsClient {
-
-  static getTemporaryCredentials(awsAccountId, region, roleToAssume = 'github-ci-role') {
-    const stsClient = new STSClient({ region })
-
-    return core.getIDToken('sts.amazonaws.com')
-      .then(webIdentityToken => stsClient.send(new AssumeRoleWithWebIdentityCommand({
-        RoleArn: `arn:aws:iam::${awsAccountId}:role/${roleToAssume}`,
-        RoleSessionName: 'GitHubActions',
-        DurationSeconds: 15 * 60,
-        WebIdentityToken: webIdentityToken
-      })))
-      .then(responseData => ({
-        accessKeyId: responseData.Credentials.AccessKeyId,
-        secretAccessKey: responseData.Credentials.SecretAccessKey,
-        sessionToken: responseData.Credentials.SessionToken
-      }))
-
-  }
-
-}

package/src/config.js

@@ -1,9 +0,0 @@
-export const platformName = process.env.DEPLOYMENT_TOOLS_PLATFORM_NAME
-export const domain = process.env.DEPLOYMENT_TOOLS_DOMAIN || 'localhost'
-export const environmentName = process.env.DEPLOYMENT_TOOLS_ENVIRONMENT_NAME || 'dev'
-export const ciSubDomain = process.env.DEPLOYMENT_TOOLS_CI_SUB_DOMAIN || 'ci'
-export const port = process.env.DEPLOYMENT_TOOLS_PORT || 3000
-export const awsAccountId = process.env.AWS_ACCOUNT_ID
-export const awsRegion = process.env.AWS_REGION
-
-export const deploymentQueueUrl = `https://sqs.${awsRegion}.amazonaws.com/${awsAccountId}/${platformName}-${environmentName}`

package/src/container-manager-client.js

@@ -1,118 +0,0 @@
-import { resolve } from 'path'
-import { readFileSync } from 'fs'
-import { AwsCredentialsClient } from './aws-credentials-client.js'
-import { DeploymentQueueClient } from './deployment-queue-client.js'
-
-export class ContainerManagerClient {
-
-  //eslint-disable-next-line max-params
-  static deploy(
-    username,
-    authentication,
-    targetEnvironment = 'local-dev',
-    pathToDeploymentPlatforms,
-    pathToOssyFile
-  ) {
-    const containerManagerClient = new ContainerManagerClient()
-    return containerManagerClient.deploy(
-      username,
-      authentication,
-      targetEnvironment,
-      pathToDeploymentPlatforms,
-      pathToOssyFile
-    )
-  }
-
-  constructor() {}
-
-  getDeployments(pathToOssyFile) {
-    const ossyfile = JSON.parse(readFileSync(resolve(pathToOssyFile), 'utf8'))
-    return Promise.resolve(ossyfile.deployments || [])
-  }
-
-  getDeploymentPlatforms(pathToDeploymentPlatforms) {
-
-    const localDevPlatform = {
-      name: 'dev',
-      domain: 'localhost',
-      supportedDeploymentTypes: ['CONTAINER']
-    }
-
-    if (!pathToDeploymentPlatforms) return [localDevPlatform]
-
-    const deploymentPlatforms = JSON.parse(readFileSync(resolve(pathToDeploymentPlatforms), 'utf8'))
-    return Promise.resolve(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] || {})
-    }
-  }
-
-  //eslint-disable-next-line max-params
-  deploy(
-    username,
-    authentication,
-    targetEnvironment,
-    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
-          }
-
-          return AwsCredentialsClient.getTemporaryCredentials(platform.awsAccountId, platform.awsRegion)
-            .then(credentials => {
-              const deploymentQueueClient = DeploymentQueueClient.new({ credentials })
-              return deploymentQueueClient.sendMessage(body)
-                .then(() => console.log('[ContainerManagerCommands] Deployment request has been sent'))
-                .catch(error => console.log('[ContainerManagerCommands] Could not send deployment request', error))
-
-            })
-        })
-      })
-      .catch(error => console.log(error))
-  }
-
-}

package/src/container-manager-server.js

@@ -1,89 +0,0 @@
-import express from 'express'
-import { CaddyClient } from './caddy-client.js'
-import { DockerClient } from './docker-client.js'
-import { DeploymentQueueClient } from './deployment-queue-client.js'
-import * as config from './config.js'
-
-export class ContainerManagerServer {
-
-  static start() {
-    return new ContainerManagerServer()
-  }
-
-  constructor() {
-    this.server = express()
-    this.dockerClient = DockerClient.new()
-    this.caddyClient = CaddyClient.new()
-    this.deploymentQueueClient = DeploymentQueueClient.new()
-
-    this.applyDefaultCaddyConfig()
-    this.setupServerEndpoints()
-    this.pollForDeploymentRequests()
-  }
-
-  setupServerEndpoints() {
-    this.server.use(express.json())
-
-    this.server.get('/', (req, res) => {
-      res.redirect('/status')
-    })
-
-    this.server.get('/status', (req, res) => {
-      res.json('Server is live')
-    })
-
-    this.server.listen(config.port, () => {
-      console.log(`Web API is live on port ${config.port}`)
-    })
-  }
-
-  applyDefaultCaddyConfig() {
-    this.caddyClient.applyDefaultServerConfig()
-      .then(() => this.caddyClient.deploy({
-        domain: `${config.ciSubDomain}.${config.environmentName}.${config.domain}`,
-        targetPort: config.port
-      }))
-  }
-
-  pollForDeploymentRequests() {
-    const FIVE_MINUTES = 3000
-
-    const handleIcomingMessages = () => this.deploymentQueueClient.receiveMessages()
-      .then(data => data.Messages.map(message => {
-        console.log('[ContainerManagerServer] handleIcomingMessages')
-        this.deploy(message)
-        this.deploymentQueueClient.deleteMessage(message.ReceiptHandle)
-      }))
-      .catch(error => console.log('[ContainerManagerServer] handleIcomingMessages error', error))
-
-    setInterval(handleIcomingMessages, FIVE_MINUTES)
-  }
-
-  deploy(deploymentRequestMessage) {
-
-    const {
-      registry,
-      username,
-      authentication,
-      containerPort,
-      hostPort,
-      image,
-      domain,
-      env
-    } = deploymentRequestMessage
-
-    this.dockerClient.deploy({
-      image,
-      registry,
-      username,
-      authentication,
-      containerPort,
-      hostPort,
-      env
-    })
-
-    domain && this.caddyClient.deploy({ domain, targetPort: hostPort })
-
-  }
-
-}

package/src/deployment-queue-client.js

@@ -1,57 +0,0 @@
-import {
-  SQSClient,
-  SendMessageCommand,
-  DeleteMessageCommand,
-  ReceiveMessageCommand
-} from '@aws-sdk/client-sqs'
-import * as config from './config.js'
-
-export class DeploymentQueueClient {
-
-  static new({ queueUrl, region, credentials } = {}) {
-
-    const deploymentQueueClientDefaultConfig = {
-      queueUrl: queueUrl || config.deploymentQueueUrl,
-      region: region || config.awsRegion,
-      credentials
-    }
-
-    return new DeploymentQueueClient(deploymentQueueClientDefaultConfig)
-  }
-
-  constructor({ queueUrl, region, credentials }) {
-    this.queueUrl = queueUrl
-    this.sqs = new SQSClient({ region, credentials })
-  }
-
-  sendMessage(messageBody) {
-    const command = new SendMessageCommand({
-      QueueUrl: this.queueUrl,
-      MessageBody: JSON.stringify(messageBody)
-    })
-
-    return this.sqs.send(command)
-      .then(() => console.log('Success'))
-      .catch(err => console.log(err))
-  }
-
-  receiveMessages() {
-    const command = new ReceiveMessageCommand({ QueueUrl: this.queueUrl })
-
-    return this.sqs.send(command)
-      .catch(error => console.log('Error', error))
-  }
-
-  deleteMessage(receiptHandle) {
-    const command = new DeleteMessageCommand({
-      QueueUrl: this.queueUrl,
-      ReceiptHandle:  receiptHandle
-    })
-
-    return this.sqs.send(command)
-      .then(() => console.log('success'))
-      .catch(error => console.log('Error', error))
-
-  }
-
-}

package/src/docker-client.js

@@ -1,80 +0,0 @@
-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)
-
-export class DockerClient {
-
-  static new() {
-    return new DockerClient()
-  }
-
-  constructor() {
-    this.networkName = 'deployment-tools'
-    exec(`sudo 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()
-      })
-    })
-
-  }
-
-}

package/src/index.js

@@ -1,79 +0,0 @@
-#!/usr/bin/env node
-import { platform } from 'os'
-import { exec } from 'child_process'
-import arg from 'arg'
-import { ContainerManagerServer } from './container-manager-server.js'
-import { ContainerManagerClient } from './container-manager-client.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')
-  }
-
-  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({
-    '--username': String,
-    '-u': '--username',
-
-    '--authentication': String,
-    '--a': '--authentication',
-
-    '--target-env': String,
-    '-t': '--target-env',
-
-    '--ossyfile': String,
-    '-o': '--ossyfile',
-
-    '--platforms': String,
-    '-p': '--platforms'
-  }, { argv: restArgs })
-
-  console.log('args', args)
-
-  ContainerManagerClient.deploy(
-    args['--username'],
-    args['--authentication'],
-    args['--target-env'],
-    args['--platforms'],
-    args['--ossyfile']
-  )
-}
-
-const Commands = {
-  start: startHandler,
-  stop: stopHandler,
-  status: statusHandler,
-  deploy: deployHandler
-}
-
-const commandHandler = Commands[command]
-
-if (!commandHandler) {
-  console.log('Command not implemented, did you spell it correctly?')
-}
-
-commandHandler()