@ossy/deployment-tools 0.0.44 → 0.0.46

package/src/types.js

@@ -1,42 +1,9 @@
-// export interface PlatformTemplate {
-//   platformName: string;
-//   domain: string;
-//   supportedDeploymentTypes: SupportedDeploymentTypes[];
-//   supportedEnvironments: SupportedEnvironments[];
-//   awsRegion?: string;
-//   awsAccountId: string;
-//   awsKeyPairName?: string;
-//   awsRoleToAssume?: string;
-//   awsDeploymentSqsArn?: string;
-//   ciSubDomain?: string;
-//   ciInternalServerPort?: string | number;
-//   ciServerName?: string;
-//   ciDockerNetworkName?: string;
-// }
-//
 // export interface PlatformConfig extends Required<Omit<PlatformTemplate, 'awsRoleToAssume' | 'awsKeyPairName'>> {
 //   activeEnvironment: SupportedEnvironments;
 //   awsRoleToAssume?: string;
 //   awsKeyPairName?: string;
 // }
 
-export const SupportedRegions = {
-  North: 'eu-north-1'
-}
-
-export const SupportedEnvironments = {
-  LOCAL: 'local',
-  QA: 'qa',
-  TEST: 'test',
-  DEMO: 'demo',
-  PROD: 'prod'
-}
-
-export const SupportedDeploymentTypes = {
-  Container: 'CONTAINER'
-  // Static = 'STATIC'
-}
-
 // export interface DeploymentTemplate {
 //   type: SupportedDeploymentTypes;
 //   targetDeploymentPlatform: string;

package/src/aws-credentials-client.js

@@ -1,43 +0,0 @@
-import * as core from '@actions/core'
-import { STSClient, AssumeRoleWithWebIdentityCommand } from '@aws-sdk/client-sts'
-import { logInfo, logError } from './log.js'
-
-export 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
-      })
-  }
-
-}

package/src/cli-commands/index.js

@@ -1,23 +0,0 @@
-import { logError } from '../log.js'
-import { startHandler } from './start-handler.js'
-import { stopHandler } from './stop-handler.js'
-import { statusHandler } from './status-handler.js'
-import { deployHandler } from './deploy-handler.js'
-
-export 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)
-}

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

@@ -1,24 +0,0 @@
-import arg from 'arg'
-import { platform } from 'os'
-import { logInfo, logError } from '../log.js'
-import { PlatformClient } from '../platform-client.js'
-
-export 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'])
-}

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

@@ -1,7 +0,0 @@
-import { exec } from 'child_process'
-import { logInfo } from '../log.js'
-
-export const statusHandler = () => {
-  logInfo({ message: 'Running status command' })
-  exec('systemctl status deployment-tools.service')
-}

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

@@ -1,7 +0,0 @@
-import { exec } from 'child_process'
-import { logInfo } from '../log.js'
-
-export const stopHandler = () => {
-  logInfo({ message: 'Running stop command' })
-  exec('systemctl stop deployment-tools.service')
-}

package/src/platform-cli.js

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

package/src/platform-client.js

@@ -1,95 +0,0 @@
-import { resolve } from 'path'
-import { readFileSync } from 'fs'
-import { SupportedDeploymentTypes } from './types.js'
-import { PlatformTemplateService } from './platform-template.js'
-import { PlatformConfigService } from './platform-config.js'
-import { CaddyClient } from './caddy-client.js'
-import { DockerClient } from './docker-client.js'
-import { DeploymentQueueClient } from './deployment-queue-client.js'
-import { CiRestApi } from './ci-rest-api.js'
-import { logError } from './log.js'
-
-// journalctl -u service-name.service
-export 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] || {})
-    }
-  }
-
-}