@ossy/deployment-tools 0.0.45 → 0.0.46

package/src/aws-credentials-client.js

@@ -1,47 +0,0 @@
-const core = require('@actions/core')
-const { STSClient, AssumeRoleWithWebIdentityCommand } = require('@aws-sdk/client-sts')
-const { logInfo, logError } = require('./log')
-
-class AwsCredentialsClient {
-
-  static resolveAwsCredentials(platformConfig) {
-    // If awsRoleToAssume is present, then we assume we run in a github workflow
-    // If awsRoleToAssume is not present, then we assume they are resolved localy by aws-sdk
-    if (!platformConfig.awsRoleToAssume) {
-      logInfo({ message: '[AwsCredentialsClient] No aws role to assume was found, leaving auth logic to @aws-sdk package' })
-      return Promise.resolve(undefined)
-    }
-
-    const stsClient = new STSClient({ region: platformConfig.awsRegion })
-
-    logInfo({ message: '[AwsCredentialsClient] Fetching GitHub ID token' })
-    return core.getIDToken('sts.amazonaws.com')
-      .then(webIdentityToken => {
-        logInfo({ message: `[AwsCredentialsClient] Attempting to resolve aws credentials by assuming the role: ${platformConfig.awsRoleToAssume}` })
-        return stsClient.send(new AssumeRoleWithWebIdentityCommand({
-          RoleArn: `arn:aws:iam::${platformConfig.awsAccountId}:role/${platformConfig.awsRoleToAssume}`,
-          RoleSessionName: 'GitHubActions',
-          DurationSeconds: 15 * 60,
-          WebIdentityToken: webIdentityToken
-        }))
-      })
-      .then(responseData => ({
-        // Don't ask
-        AccessKeyId: responseData.Credentials.AccessKeyId,
-        SessionToken: responseData.Credentials.SessionToken,
-        SecretAccessKey: responseData.Credentials.SecretAccessKey,
-        accessKeyId: responseData.Credentials.AccessKeyId,
-        sessionToken: responseData.Credentials.SessionToken,
-        secretAccessKey: responseData.Credentials.SecretAccessKey
-      }))
-      .catch(error => {
-        logError({ message: '[AwsCredentialsClient] Could not resolve temporary credentials', error })
-        return undefined
-      })
-  }
-
-}
-
-module.exports = {
-  AwsCredentialsClient
-}

package/src/cli-commands/index.js

@@ -1,27 +0,0 @@
-const { logError } = require('../log')
-const { startHandler } = require('./start-handler')
-const { stopHandler } = require('./stop-handler')
-const { statusHandler } = require('./status-handler')
-const { deployHandler } = require('./deploy-handler')
-
-const runCliCommand = ({ name, args }) => {
-
-  if (!name) return logError({ message: 'No command provided' })
-
-  const commandHandler = {
-    start: startHandler,
-    stop: stopHandler,
-    status: statusHandler,
-    deploy: deployHandler
-  }[name]
-
-  if (!commandHandler) {
-    return logError({ message: 'Command not implemented, did you spell it correctly?' })
-  }
-
-  commandHandler(args)
-}
-
-module.exports = {
-  runCliCommand
-}

package/src/cli-commands/start-handler.js

@@ -1,28 +0,0 @@
-const arg = require('arg')
-const { platform } = require('os')
-const { logInfo, logError } = require('../log')
-const { PlatformClient } = require('../platform-client')
-
-const startHandler = cliArgs => {
-  logInfo({ message: 'Running start command' })
-
-  const Platforms = {
-    windows: 'win32',
-    mac: 'darwin'
-  }
-
-  if ([Platforms.windows].includes(platform())) {
-    return logError({ message: 'Deployment tools do not support this os' })
-  }
-
-  const parsedArgs = arg({
-    '--platforms': String,
-    '-p': '--platforms'
-  }, { argv: cliArgs })
-
-  PlatformClient.start(parsedArgs['--platforms'])
-}
-
-module.exports = {
-  startHandler
-}

package/src/cli-commands/status-handler.js

@@ -1,11 +0,0 @@
-const { exec } = require('child_process')
-const { logInfo } = require('../log')
-
-const statusHandler = () => {
-  logInfo({ message: 'Running status command' })
-  exec('systemctl status deployment-tools.service')
-}
-
-module.exports = {
-  statusHandler
-}

package/src/cli-commands/stop-handler.js

@@ -1,11 +0,0 @@
-const { exec } = require('child_process')
-const { logInfo } = require('../log')
-
-const stopHandler = () => {
-  logInfo({ message: 'Running stop command' })
-  exec('systemctl stop deployment-tools.service')
-}
-
-module.exports = {
-  stopHandler
-}

package/src/platform-cli.js

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-const { runCliCommand } = require('./cli-commands/index')
-
-//eslint-disable-next-line no-unused-vars
-const [_, __, command, ...restArgs] = process.argv
-
-runCliCommand({ name: command, args: restArgs })

package/src/platform-client.js

@@ -1,99 +0,0 @@
-const { resolve } = require('path')
-const { readFileSync } = require('fs')
-const { SupportedDeploymentTypes } = require('./types')
-const { PlatformTemplateService } = require('./platform-template')
-const { PlatformConfigService } = require('./platform-config')
-const { CaddyClient } = require('./caddy-client')
-const { DockerClient } = require('./docker-client')
-const { DeploymentQueueClient } = require('./deployment-queue-client')
-const { CiRestApi } = require('./ci-rest-api')
-const { logError } = require('./log')
-
-// journalctl -u service-name.service
-class PlatformClient {
-
-  static start(platformTemplatesFilePath) {
-    PlatformTemplateService.readFromFile(platformTemplatesFilePath).then(([firstPlatformTemplateFound]) => {
-      const platformConfig = PlatformConfigService.from(firstPlatformTemplateFound)
-
-      CiRestApi.start(platformConfig)
-      CaddyClient.applyDefaultServerConfig(platformConfig)
-
-      DeploymentQueueClient.pollForDeploymentRequests(
-        platformConfig,
-        deploymentRequest => {
-          DockerClient.deploy(platformConfig, deploymentRequest)
-          CaddyClient.deploy(platformConfig, deploymentRequest)
-          return Promise.resolve()
-        }
-      )
-
-    })
-      .catch(error => logError({ message: '[PlatformClient] Could not start the deployment platform', error }))
-  }
-
-  //eslint-disable-next-line max-params
-  static deploy({
-    username,
-    authentication,
-    targetEnvironment,
-    pathToPlatformTemplates,
-    pathToOssyFile
-  }) {
-
-    const platformConfigRequest = PlatformTemplateService.readFromFile(pathToPlatformTemplates)
-      .then(templates => templates.map(x => ({ ...x, activeEnvironment: targetEnvironment })))
-      .then(templates => templates.map(x => PlatformConfigService.from(x)))
-
-    const deploymentTemplatesRequest = PlatformClient.getDeploymentTemplates(pathToOssyFile)
-
-    return Promise.all([platformConfigRequest, deploymentTemplatesRequest])
-      .then(([platformConfigs, deploymentTemplates]) => {
-        deploymentTemplates.map(deploymentTemplate => {
-
-          const platformConfig = platformConfigs.find(config => config.platformName === deploymentTemplate.targetDeploymentPlatform)
-
-          if (!platformConfig) {
-            logError({ message: `[PlatformClient] Could not find a deployment platform with the name ${deploymentTemplate.targetDeploymentPlatform}` })
-            return Promise.reject()
-          }
-
-          process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'
-
-          if (deploymentTemplate.type !== SupportedDeploymentTypes.Container) {
-            logError({ message: `[PlatformClient] Unsupported deployment type of ${deploymentTemplate.type}` })
-            return Promise.reject()
-          }
-
-          const deploymentRequest = {
-            ...deploymentTemplate,
-            env: PlatformClient.getEnvironmentVariables(targetEnvironment, deploymentTemplate),
-            username: username,
-            authentication: authentication
-          }
-
-          return DeploymentQueueClient.sendDeploymentRequest(platformConfig, deploymentRequest)
-
-        })
-      })
-      .catch(error => logError({ message: '[PlatformClient] Could not send deployment request', error }))
-  }
-
-  static getDeploymentTemplates(pathToOssyFile) {
-    const ossyfile = JSON.parse(readFileSync(resolve(pathToOssyFile), 'utf8'))
-    return Promise.resolve(ossyfile.deployments || [])
-  }
-
-  static getEnvironmentVariables(targetEnvironment, deploymentRequest) {
-    const envs = deploymentRequest.env || {}
-    return {
-      ...(envs.shared || {}),
-      ...(envs[targetEnvironment] || {})
-    }
-  }
-
-}
-
-module.exports = {
-  PlatformClient
-}