@ossy/deployment-tools 1.17.3 → 1.17.5

package/jsdoc.config.js

@@ -1,15 +0,0 @@
-
-module.exports = {
-  recurseDepth: 10,
-  source: {
-    include: ['src'],
-    includePattern: '\.js',
-    exclude: ['node_modules']
-  },
-  opts: {
-    // template: './template',
-    destination: './jsdoc',
-    recurse: true
-    // tutorials: './tutorials'
-  }
-}

package/src/deploy/cli.js

@@ -1,60 +0,0 @@
-#!/usr/bin/env node
-const arg = require('arg')
-const { PlatformDeploymentService } = require('./platform-deployment')
-const { logInfo, logError } = require('../log')
-
-const deploy = options => {
-  logInfo({ message: '[CLI] Running deploy command' })
-
-  const parsedArgs = arg({
-    '--domain': String,
-    '-d': '--domain',
-
-    '--platform': String,
-    '-p': '--platform',
-
-    '--platforms-path': String,
-    '-pp': '--platforms-path',
-
-    '--deployments-path': String,
-    '-dp': '--deployments-path',
-
-  }, { argv: options })
-
-  PlatformDeploymentService.deploy({
-    targetDomain: parsedArgs['--domain'],
-    targetPlatform: parsedArgs['--platform'],
-    pathToPlatformTemplates: parsedArgs['--platforms-path'],
-    pathToDeploymentTemplates: parsedArgs['--deployments-path']
-  })
-}
-
-const deployAll = options => {
-  logInfo({ message: '[CLI] Running deploy-all command' })
-
-  const parsedArgs = arg({
-    '--platform': String,
-    '-p': '--platform',
-
-    '--platforms-path': String,
-    '-pp': '--platforms-path',
-
-    '--deployments-path': String,
-    '-dp': '--deployments-path',
-
-  }, { argv: options })
-
-  PlatformDeploymentService.deployAll({
-    targetPlatform: parsedArgs['--platform'],
-    pathToPlatformTemplates: parsedArgs['--platforms-path'],
-    pathToDeploymentTemplates: parsedArgs['--deployments-path']
-  })
-}
-
-module.exports = {
-  handler: ([command, ...options]) => {
-    !!command
-      ? { deploy, 'deploy-all': deployAll }[command](options)
-      : logError({ message: 'No command provided' })
-  }
-}

package/src/deploy/index.js

@@ -1 +0,0 @@
-module.exports = require('./platform-deployment.js')

package/src/deploy/platform-deployment.js

@@ -1,122 +0,0 @@
-const { PlatformTemplateService, DeploymentTemplateService } = require('../template')
-const { PlatformConfigService, SupportedDeploymentTypes } = require('../config')
-const { DeploymentQueueService } = require('../deployment-queue')
-const { DockerService } = require('../docker/docker-service')
-const { logError } = require('../log')
-
-function assertEcrContainer(deploymentTemplate) {
-  const r = deploymentTemplate.registry
-  if (!r || !DockerService.isEcrRegistry(r)) {
-    logError({
-      message:
-        `[PlatformDeploymentService] ${deploymentTemplate.domain}: container deployments only support Amazon ECR. ` +
-        'Set `registry` in deployments JSON to your ECR hostname (e.g. 123456789012.dkr.ecr.eu-north-1.amazonaws.com).'
-    })
-    return false
-  }
-  return true
-}
-
-/**
-  * @class
-*/
-class PlatformDeploymentService {
-
-  static deploy({
-    targetDomain,
-    targetPlatform,
-    pathToPlatformTemplates,
-    pathToDeploymentTemplates
-  }) {
-
-    return Promise.all([
-      DeploymentTemplateService.readFromFiles(pathToDeploymentTemplates),
-      PlatformTemplateService.readFromFile(pathToPlatformTemplates)
-        .then(templates => templates.map(PlatformConfigService.from))
-    ])
-      .then(([deploymentTemplates, platformConfigs]) => {
-
-        const platformConfig = platformConfigs.find(({ platformName }) => platformName === targetPlatform)
-        const deploymentTemplatesForTargetPlatform = deploymentTemplates[targetPlatform] || [] //todo remove deploymentTargetPlatform
-        const deploymentTemplate = deploymentTemplatesForTargetPlatform.find(({ domain }) => domain === targetDomain)
-
-        if (!platformConfig) {
-          logError({ message: `[PlatformDeploymentService] Could not find a platform named ${targetPlatform}` })
-          return Promise.reject()
-        }
-
-        if (!deploymentTemplate) {
-          logError({ message: `[PlatformDeploymentService] Could not find a deployment template for ${targetDomain} in ${targetPlatform}` })
-          return Promise.reject()
-        }
-
-        process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'
-
-        if (deploymentTemplate.type === SupportedDeploymentTypes.Container) {
-          if (!assertEcrContainer(deploymentTemplate)) {
-            return Promise.reject()
-          }
-
-          const deploymentRequest = { ...deploymentTemplate }
-
-          return DeploymentQueueService.sendDeploymentRequest(platformConfig, deploymentRequest)
-        }
-
-        logError({ message: `[PlatformDeploymentService] Unsupported deployment type of ${deploymentTemplate.type}` })
-        return Promise.reject()
-      })
-      .catch(error => logError({ message: '[PlatformDeploymentService] Could not send deployment request', error }))
-  }
-
-  static deployAll({
-    targetPlatform,
-    pathToPlatformTemplates,
-    pathToDeploymentTemplates
-  }) {
-
-    return Promise.all([
-      DeploymentTemplateService.readFromFiles(pathToDeploymentTemplates),
-      PlatformTemplateService.readFromFile(pathToPlatformTemplates)
-        .then(templates => templates.map(PlatformConfigService.from))
-    ])
-      .then(([deploymentTemplates, platformConfigs]) => {
-
-        const platformConfig = platformConfigs.find(({ platformName }) => platformName === targetPlatform)
-        const deploymentTemplatesForTargetPlatform = deploymentTemplates[targetPlatform] || []
-
-        if (!platformConfig) {
-          logError({ message: `[PlatformDeploymentService] Could not find a platform named ${targetPlatform}` })
-          return Promise.reject()
-        }
-
-        if (deploymentTemplatesForTargetPlatform.length === 0) {
-          logError({ message: `[PlatformDeploymentService] Could not find any deployment templates for platform ${targetPlatform}` })
-          return Promise.reject()
-        }
-
-        process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'
-
-        return deploymentTemplatesForTargetPlatform.map(deploymentTemplate => {
-          if (deploymentTemplate.type === SupportedDeploymentTypes.Container) {
-            if (!assertEcrContainer(deploymentTemplate)) {
-              return Promise.reject()
-            }
-
-            const deploymentRequest = { ...deploymentTemplate }
-
-            return DeploymentQueueService.sendDeploymentRequest(platformConfig, deploymentRequest)
-          }
-
-          logError({ message: `[PlatformDeploymentService] Unsupported deployment type of ${deploymentTemplate.type}` })
-          return Promise.reject()
-        })
-
-      })
-      .catch(error => logError({ message: '[PlatformDeploymentService] Could not send deployment request', error }))
-  }
-
-}
-
-module.exports = {
-  PlatformDeploymentService
-}

package/src/deployment-queue/deployment-queue.js

@@ -1,81 +0,0 @@
-const {
-  SQSClient,
-  SendMessageCommand,
-  DeleteMessageCommand,
-  ReceiveMessageCommand
-} = require('@aws-sdk/client-sqs')
-const { AwsCredentialsService } = require('../aws-credentials')
-const { logInfo, logError, logDebug } = require('../log')
-
-/**
-  * @class
-*/
-class DeploymentQueueService {
-
-  static sendDeploymentRequest(platformConfig, deploymentRequest) {
-    logInfo({ message: '[DeploymentQueueService] Starting deployment sequence' })
-    return DeploymentQueueService.createAwsSqsClient(platformConfig)
-      .then(sqsClient => {
-
-        const sendMessageParams = {
-          QueueUrl: platformConfig.awsDeploymentSqsArn,
-          MessageBody: JSON.stringify(deploymentRequest)
-        }
-
-        logDebug({ message: '[DeploymentQueueService] SendMessageCommand params', data: sendMessageParams })
-        const command = new SendMessageCommand(sendMessageParams)
-
-        return sqsClient.send(command)
-          .then(() => logInfo({ message: '[DeploymentQueueService] Deployment request sent' }))
-          .catch(error => logError({ message: '[DeploymentQueueService] Could not send deployment request', error }))
-      })
-
-  }
-
-  static pollForDeploymentRequests(platformConfig, handleDeploymentRequest) {
-    logInfo({ message: '[DeploymentQueueService] Starting polling for deployment requests' })
-    DeploymentQueueService.createAwsSqsClient(platformConfig).then(sqsClient => {
-      const FIVE_MINUTES = 300000
-
-      setInterval(() => {
-
-        const receiveMessageCommand = new ReceiveMessageCommand({ QueueUrl: platformConfig.awsDeploymentSqsArn })
-
-        sqsClient.send(receiveMessageCommand)
-          .then(data => data && data.Messages && data.Messages.map(message => {
-
-            logInfo({ message: '[DeploymentQueueService] Received deployment request' })
-
-            handleDeploymentRequest(JSON.parse(message.Body))
-              .then(() => {
-
-                const deleteMessageCommand = new DeleteMessageCommand({
-                  QueueUrl: platformConfig.awsDeploymentSqsArn,
-                  ReceiptHandle: message.ReceiptHandle
-                })
-
-                sqsClient.send(deleteMessageCommand)
-                  .then(() => logInfo({ message: '[DeploymentQueueService] Removing deployment request from queue' }))
-                  .catch(error => logError({ message: '[DeploymentQueueService] Could not delete message from queue', error }))
-              })
-
-          }))
-          .catch(error => logError({ message: '[DeploymentQueueService] Could not handle incoming deployment request', error }))
-      }, FIVE_MINUTES)
-
-    })
-  }
-
-  static createAwsSqsClient(platformConfig) {
-    return AwsCredentialsService.resolveAwsCredentials(platformConfig)
-      .then(awsCredentials => new SQSClient({
-        region: platformConfig.awsRegion,
-        credentials: awsCredentials
-      }))
-  }
-
-}
-
-module.exports = {
-  DeploymentQueueService
-}

package/src/deployment-queue/index.js

@@ -1 +0,0 @@
-module.exports = require('./deployment-queue')

package/src/docker/docker-service.js

@@ -1,136 +0,0 @@
-const { exec: execBash } = require('child_process')
-const { logInfo, logError, logDebug, logErrorAndReject } = require('../log')
-
-const exec = command => new Promise((resolve, reject) => {
-  execBash(command, (error, stdout, stderr) => {
-    logInfo({ message: `[DockerService] ${stderr}` })
-
-    if (error) return reject({ error, stderr })
-    resolve(stdout, stderr)
-  })
-})
-
-/**
-  * @class
-*/
-class DockerService {
-
-  static isEcrRegistry(registry) {
-    return (
-      typeof registry === 'string' &&
-      registry.includes('.dkr.ecr.') &&
-      registry.includes('amazonaws.com')
-    )
-  }
-
-  /**
-   * Log in to ECR using the host credentials (EC2 instance profile, env keys, etc.).
-   * Requires AWS CLI v2 on the worker (`aws ecr get-login-password`).
-   */
-  static ecrLoginViaAwsCli(registry) {
-    const m =
-      typeof registry === 'string' &&
-      registry.match(/\.dkr\.ecr\.([a-z0-9-]+)\.amazonaws\.com/)
-    const region = (m && m[1]) || process.env.AWS_DEFAULT_REGION || 'eu-north-1'
-    logInfo({ message: `[DockerService] ECR login via IAM for ${registry} (region ${region})` })
-    return exec(
-      `bash -c 'aws ecr get-login-password --region ${region} | docker login --username AWS --password-stdin ${registry}'`
-    ).catch(logErrorAndReject(`[DockerService] Could not IAM-login to ECR ${registry}`))
-  }
-
-  static startDefaultContainers(platformConfig) {
-    logInfo({ message: '[DockerService] Starting default containers' })
-    return exec(`docker run -d --name=mongodb --network=${platformConfig.ciDockerNetworkName} --network-alias=mongodb --rm mongo`)
-      .catch(() => {
-        logError({ message: '[DockerService] Faild to start default containers' })
-      })
-  }
-
-  static createDockerNetworkForContainerManagerServer(platformConfig) {
-    logInfo({ message: '[DockerService] Creating docker network for comunication between containers' })
-    return exec(`docker network create ${platformConfig.ciDockerNetworkName}`)
-      .catch(() => {
-        /* if it fails it's probably because the network already exists*/
-        logError({ message: '[DockerService] Faild to start default containers' })
-      })
-  }
-
-  static stopContainer(deploymentRequest) {
-    logInfo({ message: `[DockerService] Stopping container for ${deploymentRequest.domain}` })
-    return exec(`docker stop c-${deploymentRequest.domain}`)
-      .catch(() => {
-        logError({ message: `[DockerService] Faild to stop container for ${deploymentRequest.domain}` })
-      }) // no worries if container isn't there
-  }
-
-  static removeImage(deploymentRequest) {
-    const { registry, image } = deploymentRequest
-    const name = !!registry ? `${registry}/${image}` : image
-    logInfo({ message: `[DockerService] Removing image ${name}` })
-    return exec(`docker image rm -f ${name}`)
-      .catch(() => {
-        logError({ message: `[DockerService] Faild to remove image for ${deploymentRequest.domain}` })
-      }) // no worries if container isn't there
-      .then(() => exec(`docker rm -f c-${name}`))
-  }
-
-  static pullImage({ image, registry }) {
-    const imageUrl = !!registry ? `${registry}/${image}` : image
-    logInfo({ message: `[DockerService] Pulling image for ${image}:latest` })
-    return exec(`docker image pull ${imageUrl}:latest`)
-      .catch(logErrorAndReject(`[DockerService] Could pull image ${image}:latest`))
-  }
-
-  static startContainer(platformConfig, { image, containerPort, registry, env, domain }) {
-    const imageUrl = !!registry ? `${registry}/${image}` : image
-    const envsAsString = Object.entries(env || {}).reduce((envs, [name, value]) => `${envs} --env ${name}="${value}"`, '')
-    
-    return DockerService.getUnusedPort()
-      .then(hostPort => {
-        logInfo({ message: `[DockerService] Starting container for ${domain} with port mapping ${hostPort}:${containerPort} and source ${imageUrl}` })
-        return exec(`docker run -d -p ${hostPort}:${containerPort} --name=c-${domain} --network=${platformConfig.ciDockerNetworkName} --network-alias=c-${domain} --rm ${envsAsString} ${imageUrl}`)
-          .then(() => ({ hostPort }))
-          .catch(logErrorAndReject(`[DockerService] Could not start container ${image}`))
-      })
-      
-  }
-
-  static resolveCredentials({ registry }) {
-    if (!DockerService.isEcrRegistry(registry)) {
-      return Promise.reject(
-        new Error(
-          `[DockerService] Only Amazon ECR is supported; registry was: ${registry ?? '(missing)'}`
-        )
-      )
-    }
-    return DockerService.ecrLoginViaAwsCli(registry)
-  }
-
-  static deploy(platformConfig, deploymentRequest) {
-    logInfo({ message: '[DockerService] Starting docker deployment sequence' })
-    logDebug({ message: '[DockerService] deploymentRequest', data: deploymentRequest })
-
-    return DockerService.resolveCredentials(deploymentRequest)
-      .then(() => DockerService.stopContainer(deploymentRequest))
-      .then(() => DockerService.removeImage(deploymentRequest))
-      .then(() => DockerService.pullImage(deploymentRequest))
-      .then(() => DockerService.startContainer(platformConfig, deploymentRequest))
-      .catch(logErrorAndReject('[DockerService] Deployment failed'))
-  }
-
-  static getUnusedPort() {
-    // get-port is written in es6, so we need to import it like this
-    return import('get-port')
-      .then(module => {
-        const getPort = module.default;
-        const portNumbers = module.portNumbers;
-    
-        return getPort({ port: portNumbers(3000, 3200) })
-      });
-  }
-
-}
-
-module.exports = {
-  DockerService
-}

package/src/docker/docker-service.playground.js

@@ -1,15 +0,0 @@
-const { DockerService } = require('./docker-service')
-
-
-const deploymentTemplate =   {
-    "domain": "api.qa.ossy.se",
-    "image": "ossy-se/api",
-    "targetDeploymentPlatform": "ossybot",
-    "type": "CONTAINER",
-    "hostPort": "3001",
-    "containerPort": "3000",
-  }
-
-DockerService.pullImage(
-  deploymentTemplate
-)

package/src/docker/index.js

@@ -1 +0,0 @@
-module.exports = require('./docker-service')

package/src/infrastructure/ecr-stack.js

@@ -1,53 +0,0 @@
-const { Stack, RemovalPolicy } = require('aws-cdk-lib')
-const { Repository, TagStatus } = require('aws-cdk-lib/aws-ecr')
-const { SupportedDeploymentTypes } = require('../config')
-
-/**
- * EcrStackProps
- * @typedef {Object} EcrStackProps
- * @property {PlatformConfig} config - platform config
- * @property {DeploymentTemplate[]} deployments - deployment templates
- */
-
-/**
- * Creates one ECR repository per unique container image name.
- * @class
- */
-class EcrStack extends Stack {
-
-  /**
-   * @param {object} scope
-   * @param {string} id
-   * @param {EcrStackProps} props
-   */
-  constructor(scope, id, props) {
-    super(scope, id, props)
-
-    const deployments = props.deployments || []
-    const repositoryNames = [...new Set(
-      deployments
-        .filter(deployment => deployment.type === SupportedDeploymentTypes.Container)
-        .map(deployment => deployment.image)
-        .filter(Boolean)
-    )]
-
-    repositoryNames.forEach(repositoryName => {
-      new Repository(this, `${repositoryName.replace(/[^A-Za-z0-9]/g, '-')}-repository`, {
-        repositoryName,
-        removalPolicy: RemovalPolicy.RETAIN,
-        imageScanOnPush: true,
-        lifecycleRules: [
-          {
-            description: 'Keep latest 5 tagged images',
-            maxImageCount: 5,
-            tagStatus: TagStatus.TAGGED
-          }
-        ]
-      })
-    })
-  }
-}
-
-module.exports = {
-  EcrStack
-}

package/src/server/cli.js

@@ -1,34 +0,0 @@
-const arg = require('arg')
-const { exec } = require('child_process')
-const { PlatformServerService } = require('./platform-server')
-
-const { logInfo, logError } = require('../log')
-
-const start = options => {
-  logInfo({ message: 'Running start command' })
-
-  const parsedArgs = arg({
-    '--platforms': String,
-    '-p': '--platforms'
-  }, { argv: options })
-
-  PlatformServerService.start(parsedArgs['--platforms'])
-}
-
-const status = () => {
-  logInfo({ message: 'Running status command' })
-  exec('systemctl status deployment-tools.service')
-}
-
-const stop = () => {
-  logInfo({ message: 'Running stop command' })
-  exec('systemctl stop deployment-tools.service')
-}
-
-module.exports = {
-  handler: ([command, ...options]) => {
-    !!command
-      ? { start, status, stop }[command](options)
-      : logError({ message: 'No command provided' })
-  }
-}

package/src/server/platform-server.js

@@ -1,42 +0,0 @@
-const { CaddyService } = require('../caddy')
-const { DockerService } = require('../docker')
-const { PlatformTemplateService } = require('../template')
-const { PlatformConfigService } = require('../config')
-const { DeploymentQueueService } = require('../deployment-queue')
-const { logError } = require('../log')
-
-/**
-  * @class
-*/
-class PlatformServerService {
-
-  static start(platformTemplatesFilePath) {
-    PlatformTemplateService
-      .readFromFile(platformTemplatesFilePath)
-      .then(([firstPlatformTemplateFound]) => {
-        const platformConfig = PlatformConfigService.from(firstPlatformTemplateFound)
-
-        DockerService.createDockerNetworkForContainerManagerServer(platformConfig)
-          .then(() => DockerService.startDefaultContainers(platformConfig))
-
-        CaddyService.loadServerConfig()
-
-        DeploymentQueueService.pollForDeploymentRequests(
-          platformConfig,
-          deploymentRequest => {
-            DockerService.deploy(platformConfig, deploymentRequest)
-              .then(({ hostPort }) => CaddyService.apply({ ...deploymentRequest, hostPort }))
-
-            return Promise.resolve()
-          }
-        )
-
-    })
-      .catch(error => logError({ message: '[PlatformServerService] Could not start the platform server', error }))
-  }
-
-}
-
-module.exports = {
-  PlatformServerService
-}