@ossy/deployment-tools 0.0.29 → 0.0.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/deployment-tools",
-  "version": "0.0.29",
+  "version": "0.0.31",
   "description": "Collection of scripts and tools to aid deployment of containers and static files",
   "main": "dist/index.js",
   "type": "module",
@@ -16,6 +16,7 @@
     "@actions/core": "^1.10.0",
     "@aws-sdk/client-sqs": "^3.186.0",
     "@aws-sdk/client-sts": "^3.188.0",
+    "@aws-sdk/types": "^3.193.0",
     "arg": "^5.0.2",
     "express": "^4.18.1",
     "nanoid": "^4.0.0",

package/src/aws-credentials-client.ts

@@ -1,24 +1,25 @@
 import * as core from '@actions/core'
-import { STSClient, AssumeRoleWithWebIdentityCommand, Credentials } from '@aws-sdk/client-sts'
+import { STSClient, AssumeRoleWithWebIdentityCommand } from '@aws-sdk/client-sts'
 import { DeploymentPlatform } from 'types'
-import { log } from 'log'
+import { logDebug, logInfo, logError } from 'log'
+import { Credentials } from '@aws-sdk/types'
 
 export class AwsCredentialsClient {
 
-  static resolveAwsCredentials({ awsAccountId, awsRegion, awsRoleToAssume }: DeploymentPlatform) {
+  static resolveAwsCredentials({ awsAccountId, awsRegion, awsRoleToAssume }: DeploymentPlatform): Promise<Credentials | undefined> {
     // 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 (!awsRoleToAssume) {
-      log({ type: 'info', message: `[AwsCredentialsClient] No aws role to assume was found, leaving auth logic to @aws-sdk package` })
+      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: awsRegion })
 
-    log({ type: 'info', message: '[AwsCredentialsClient] Fetching GitHub ID token' })
+    logInfo({ message: '[AwsCredentialsClient] Fetching GitHub ID token' })
     return core.getIDToken('sts.amazonaws.com')
       .then(webIdentityToken => {
-        log({ type: 'info', message: `[AwsCredentialsClient] Attempting to resolve aws credentials by assuming the role: ${awsRoleToAssume}` })
+        logInfo({ message: `[AwsCredentialsClient] Attempting to resolve aws credentials by assuming the role: ${awsRoleToAssume}` })
         return stsClient.send(new AssumeRoleWithWebIdentityCommand({
           RoleArn: `arn:aws:iam::${awsAccountId}:role/${awsRoleToAssume}`,
           RoleSessionName: 'GitHubActions',
@@ -26,13 +27,18 @@ export class AwsCredentialsClient {
           WebIdentityToken: webIdentityToken
         }))
       })
-      .then(responseData => ({
-        AccessKeyId: responseData.Credentials.AccessKeyId,
-        SessionToken: responseData.Credentials.SessionToken,
-        SecretAccessKey: responseData.Credentials.SecretAccessKey,
-      }))
+      // .then(responseData => ({
+      //   AccessKeyId: responseData.Credentials.AccessKeyId,
+      //   SessionToken: responseData.Credentials.SessionToken,
+      //   SecretAccessKey: responseData.Credentials.SecretAccessKey,
+      // }))
+      .then(responseData => responseData.Credentials)
+      .then(data => {
+        logDebug({ message: '[AwsCredentialsClient] AssumeRoleWithWebIdentityCommand responseData.Credentials', data })
+        return data
+      })
       .catch(error => {
-        log({ type: 'error', message: '[AwsCredentialsClient] Could not resolve temporary credentials', error })
+        logError({ message: '[AwsCredentialsClient] Could not resolve temporary credentials', error })
         return undefined
       })
   }

package/src/caddy-client.ts

@@ -1,5 +1,5 @@
 import fetch from 'node-fetch'
-import { log } from './log'
+import { logInfo, logError } from './log'
 import { DeploymentPlatform, ContainerDeploymentRequest } from 'types'
 
 export const Matchers = {
@@ -24,10 +24,7 @@ export class CaddyClient {
 
     const url = `${deploymentRequest.subdomain}.${deploymentPlatform.activeEnvironment}.${deploymentPlatform.domain}`
 
-    log({
-      type: 'info',
-      message: `[CaddyClient] Updating caddy config to route ${url} to localhost:${deploymentRequest.hostPort}`
-    })
+    logInfo({ message: `[CaddyClient] Updating caddy config to route ${url} to localhost:${deploymentRequest.hostPort}` })
 
     return fetch(`http://localhost:2019/config/apps/http/servers/${deploymentPlatform.ciServerName}/routes/0/handle`, {
       method: 'POST',
@@ -39,11 +36,11 @@ export class CaddyClient {
         }
       ]))
     })
-    .catch(error => log({ type: 'error', message: `[CaddyClient] Could not update caddy config to include ${url}`, error }))
+    .catch(error => logError({  message: `[CaddyClient] Could not update caddy config to include ${url}`, error }))
   }
 
   static applyDefaultServerConfig(deploymentPlatform: DeploymentPlatform) {
-    log({ type: 'info', message: '[CaddyClient] Applying default caddy config' })
+    logInfo({  message: '[CaddyClient] Applying default caddy config' })
     return fetch('http://localhost:2019/load', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
@@ -105,7 +102,7 @@ export class CaddyClient {
         }
       })
     })
-      .catch(error => log({ type: 'error', message: '[CaddyClient] Could not apply default caddy config', error }))
+      .catch(error => logError({  message: '[CaddyClient] Could not apply default caddy config', error }))
   }
 
 }

package/src/ci-rest-api.ts

@@ -1,6 +1,6 @@
 import express from 'express'
 import { DeploymentPlatform } from 'types'
-import { log } from './log'
+import { logInfo } from './log'
 
 export class CiRestApi {
 
@@ -18,7 +18,7 @@ export class CiRestApi {
     })
 
     server.listen(deploymentPlatform.ciInternalServerPort, () => {
-      log({ type: 'info', message: `[ContainerManagerServer] API is live on port ${deploymentPlatform.ciInternalServerPort}`})
+      logInfo({ message: `[ContainerManagerServer] API is live on port ${deploymentPlatform.ciInternalServerPort}`})
     })
   }
 

package/src/cli-commands/deploy-handler.ts

@@ -1,9 +1,9 @@
 import arg from 'arg'
-import { log } from '../log'
+import { logInfo } from '../log'
 import { DeploymentPlatformClient } from 'deployment-platform-client'
 
 export const deployHandler = cliArgs => {
-  log({ type: 'info', message: 'Running deploy command' })
+  logInfo({  message: 'Running deploy command' })
 
   const parsedArgs = arg({
     '--username': String,

package/src/cli-commands/index.ts

@@ -1,4 +1,4 @@
-import { log } from '../log'
+import { logError } from '../log'
 import { startHandler } from './start-handler'
 import { stopHandler } from './stop-handler'
 import { statusHandler } from './status-handler'
@@ -6,7 +6,7 @@ import { deployHandler } from './deploy-handler'
 
 export const runCliCommand = ({ name, args }) => {
 
-  if (!name) return log({ type: 'error', message: 'No command provided' })
+  if (!name) return logError({ message: 'No command provided' })
 
   const commandHandler = {
     start: startHandler,
@@ -16,7 +16,7 @@ export const runCliCommand = ({ name, args }) => {
   }[name]
 
   if (!commandHandler) {
-    return log({ type: 'error', message: 'Command not implemented, did you spell it correctly?' })
+    return logError({ message: 'Command not implemented, did you spell it correctly?' })
   }
 
   commandHandler(args)

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

@@ -1,10 +1,10 @@
 import arg from 'arg'
 import { platform } from 'os'
-import { log } from '../log'
+import { logInfo, logError } from '../log'
 import { DeploymentPlatformClient } from 'deployment-platform-client'
 
 export const startHandler = cliArgs => {
-  log({ type: 'info', message: 'Running start command' })
+  logInfo({  message: 'Running start command' })
 
   const Platforms = {
     windows: 'win32',
@@ -12,7 +12,7 @@ export const startHandler = cliArgs => {
   }
 
   if ([Platforms.windows].includes(platform())) {
-    return log({ type: 'error', message: 'Deployment tools do not support this os' })
+    return logError({  message: 'Deployment tools do not support this os' })
   }
 
   const parsedArgs = arg({

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

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

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

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

package/src/deployment-platform-client.ts

@@ -6,13 +6,14 @@ import {
   ContainerDeploymentRequest,
   DeploymentTemplate,
   ContainerDeploymentTemplate,
-  SupportedDeploymentTypes
+  SupportedDeploymentTypes,
+  SupportedRegions
 } from 'types'
 import { CaddyClient } from './caddy-client'
 import { DockerClient } from './docker-client'
 import { DeploymentQueueClient } from './deployment-queue-client'
 import { CiRestApi } from './ci-rest-api'
-import { log } from 'log'
+import { logInfo, logError } from 'log'
 
 export class DeploymentPlatformClient {
 
@@ -20,7 +21,7 @@ export class DeploymentPlatformClient {
     DeploymentPlatformClient.getDeploymentPlatforms(pathToDeploymentPlatforms).then(([firstPlatformFound]) => {
 
       if (!firstPlatformFound) {
-        log({ type: 'error', message: '[DeploymentPlatformClient] Could not find a deployment platform' })
+        logError({  message: '[DeploymentPlatformClient] Could not find a deployment platform' })
         return Promise.reject()
       }
 
@@ -37,7 +38,7 @@ export class DeploymentPlatformClient {
       )
 
     })
-    .catch(error => log({ type: 'error', message: '[DeploymentPlatformClient] Could not start the deployment platform', error }))
+    .catch(error => logError({  message: '[DeploymentPlatformClient] Could not start the deployment platform', error }))
   }
 
   //eslint-disable-next-line max-params
@@ -55,22 +56,19 @@ export class DeploymentPlatformClient {
       .then(([platforms, deploymentTemplates]) => {
         deploymentTemplates.map(deploymentTemplate => {
 
-          log({
-            type: 'info',
-            message: `[DeploymentPlatformClient]: Found deployment platforms [${platforms.map(x => x.platformName).join(', ')}]`
-          })
+          logInfo({ message: `[DeploymentPlatformClient]: Found deployment platforms [${platforms.map(x => x.platformName).join(', ')}]` })
 
           const deploymentPlatform = platforms.find(platform => platform.platformName === deploymentTemplate.targetDeploymentPlatform)
 
           if (!deploymentPlatform) {
-            log({ type: 'error', message: `[DeploymentPlatformClient] Could not find a deployment platform with the name ${deploymentTemplate.targetDeploymentPlatform}` })
+            logError({  message: `[DeploymentPlatformClient] 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) {
-            log({ type: 'error', message: `[DeploymentPlatformClient] Unsupported deployment type of ${deploymentTemplate.type}` })
+            logError({  message: `[DeploymentPlatformClient] Unsupported deployment type of ${deploymentTemplate.type}` })
             return Promise.reject()
           }
 
@@ -85,7 +83,7 @@ export class DeploymentPlatformClient {
 
         })
       })
-      .catch(error => log({ type: 'error', message: '[DeploymentPlatformClient] Could not send deployment request', error }))
+      .catch(error => logError({  message: '[DeploymentPlatformClient] Could not send deployment request', error }))
   }
 
   static getDeploymentTemplates(pathToOssyFile: string): Promise<DeploymentTemplate[]> {
@@ -125,7 +123,8 @@ export class DeploymentPlatformClient {
       ciInternalServerPort: 3000,
       ciServerName: 'ci-client',
       ciDockerNetworkName: 'deployment-tools',
-      // awsRoleToAssume: 'github-ci-role',
+      awsRegion: SupportedRegions.North,
+      // awsRoleToAssume: 'github-ci-role', //todo: find a way to have this a a default value and still keep the same logic when resolving aws credentials
       ...deploymentPlatform
     }
   }

package/src/deployment-queue-client.ts

@@ -6,12 +6,12 @@ import {
 } from '@aws-sdk/client-sqs'
 import { DeploymentPlatform, ContainerDeploymentRequest } from 'types'
 import { AwsCredentialsClient } from 'aws-credentials-client'
-import { log } from 'log'
+import { logInfo, logError } from 'log'
 
 export class DeploymentQueueClient {
 
   static sendDeploymentRequest(deploymentPlatform: DeploymentPlatform, deploymentRequest: ContainerDeploymentRequest) {
-    log({ type: 'info', message: '[DeploymentQueueClient] Sending deployment request...' })
+    logInfo({  message: '[DeploymentQueueClient] Starting deployment sequence' })
     return DeploymentQueueClient.createAwsSqsClient(deploymentPlatform)
       .then(sqsClient => {
 
@@ -21,19 +21,14 @@ export class DeploymentQueueClient {
         })
 
         return sqsClient.send(command)
-          .then(() => log({ type: 'info', message: '[DeploymentQueueClient] Deployment request sent' }))
-          .catch(error => log({
-            type: 'error',
-            message: '[DeploymentQueueClient] Could not send deployment request',
-            error
-          }))
-
+          .then(() => logInfo({  message: '[DeploymentQueueClient] Deployment request sent' }))
+          .catch(error => logError({ message: '[DeploymentQueueClient] Could not send deployment request', error }))
       })
 
   }
 
   static pollForDeploymentRequests(deploymentPlatform: DeploymentPlatform, handleDeploymentRequest: (deploymentRequest: ContainerDeploymentRequest) => Promise<void>) {
-    log({ type: 'info', message: '[DeploymentQueueClient] Starting polling for deployment requests' })
+    logInfo({  message: '[DeploymentQueueClient] Starting polling for deployment requests' })
     DeploymentQueueClient.createAwsSqsClient(deploymentPlatform).then(sqsClient => {
       const FIVE_MINUTES = 3000
 
@@ -44,7 +39,7 @@ export class DeploymentQueueClient {
         sqsClient.send(receiveMessageCommand)
           .then(data => data.Messages.map(message => {
 
-            log({ type: 'info', message: '[DeploymentQueueClient] Received deployment request' })
+            logInfo({  message: '[DeploymentQueueClient] Received deployment request' })
 
             handleDeploymentRequest(JSON.parse(message.Body))
               .then(() => {
@@ -55,12 +50,12 @@ export class DeploymentQueueClient {
                 })
 
                 sqsClient.send(deleteMessageCommand)
-                  .then(() => log({ type: 'info', message: '[DeploymentQueueClient] Removing deployment request from queue' }))
-                  .catch(error => log({ type: 'error', message: '[DeploymentQueueClient] Could not delete message from queue', error }))
+                  .then(() => logInfo({  message: '[DeploymentQueueClient] Removing deployment request from queue' }))
+                  .catch(error => logError({  message: '[DeploymentQueueClient] Could not delete message from queue', error }))
               })
 
           }))
-          .catch(error => log({ type: 'error', message: '[ContainerManagerServer] Could not handle incoming deployment request', error }))
+          .catch(error => logError({  message: '[ContainerManagerServer] Could not handle incoming deployment request', error }))
       }, FIVE_MINUTES)
 
       })

package/src/docker-client.ts

@@ -3,7 +3,7 @@ import fs from 'fs'
 import { nanoid } from 'nanoid'
 import path from 'path'
 import { fileURLToPath } from 'url'
-import { log } from './log'
+import { logInfo, logError } from './log'
 import { DeploymentPlatform, ContainerDeploymentRequest } from 'types'
 
 const __filename = fileURLToPath(import.meta.url)
@@ -12,13 +12,13 @@ const __dirname = path.dirname(__filename)
 export class DockerClient {
 
   static createDockerNetworkForContainerManagerServer(deploymentPlatform: DeploymentPlatform) {
-    log({ type: 'info', message: '[DockerClient] Creating docker network for comunication between containers' })
+    logInfo({  message: '[DockerClient] Creating docker network for comunication between containers' })
     exec(`sudo docker network create ${deploymentPlatform.ciDockerNetworkName}`)
   }
 
   static stopContainer(deploymentRequest: ContainerDeploymentRequest) {
     const name = deploymentRequest.image.replaceAll('/', '_')
-    log({ type: 'info', message: `Running docker stop for image with the name of ${name}` })
+    logInfo({  message: `Running docker stop for image with the name of ${name}` })
     return `sudo docker stop ${name} ||`
   }
 
@@ -26,7 +26,7 @@ export class DockerClient {
     const name = image.replaceAll('/', '_')
     const imageUrl = !!registry ? `${registry}/${image}` : image
     const envsAsString = Object.entries(env || {}).reduce((envs, [name, value]) => `${envs} --env ${name}=${value}`, '')
-    log({ type: 'info', message: `Running docker start for image with the name of ${name} with port mapping ${hostPort}:${containerPort} and source ${imageUrl}` })
+    logInfo({  message: `Running docker start for image with the name of ${name} with port mapping ${hostPort}:${containerPort} and source ${imageUrl}` })
     return `sudo docker run -d -p ${hostPort}:${containerPort} --name=${name} --network=${deploymentPlatform.ciDockerNetworkName} --network-alias=${name} --rm ${envsAsString} ${imageUrl}`
   }
 
@@ -34,17 +34,17 @@ export class DockerClient {
     const shouldAuthenticate = username || authentication
 
     if (!shouldAuthenticate) {
-      log({ type: 'info', message: 'No docker credentials provided, assuming image is publicly hosted' })
+      logInfo({  message: 'No docker credentials provided, assuming image is publicly hosted' })
       return ''
     }
 
-    log({ type: 'info', message: `Resolving docker credentials for ${registry}` })
+    logInfo({  message: `Resolving docker credentials for ${registry}` })
     return `sudo docker login ${registry} -u ${username} -p ${authentication}`
   }
 
   static deploy(deploymentPlatform: DeploymentPlatform, deploymentRequest: ContainerDeploymentRequest): Promise<void> {
     return new Promise(resolve => {
-      log({ type: 'info', message: 'Starting docker deployment sequence' })
+      logInfo({  message: 'Starting docker deployment sequence' })
 
       const dockerCommandScript = `'#!/bin/bash'
 ${DockerClient.stopContainer(deploymentRequest)}
@@ -61,15 +61,15 @@ ${DockerClient.startContainer(deploymentPlatform, deploymentRequest)}`
       const command = exec(`bash ${FilePaths.DeploymentScript}`)
 
       command.stdout.on('data', data => {
-        log({ type: 'info', message: `[DockerClient]: ${data}` })
+        logInfo({  message: `[DockerClient]: ${data}` })
       })
 
       command.stderr.on('data', (data) => {
-        log({ type: 'error', message: `[DockerClient]: ${data}` })
+        logError({  message: `[DockerClient]: ${data}` })
       })
 
       command.on('close', code => {
-        log({ type: 'info', message: `[DockerClient] command exited with code ${code}` })
+        logInfo({  message: `[DockerClient] command exited with code ${code}` })
         fs.unlinkSync(FilePaths.DeploymentScript)
         resolve()
       })

package/src/log/index.ts

@@ -1,11 +1,39 @@
 interface LogInput {
-  type: 'info' | 'error';
+  type: TypeOfMessage;
   message: string;
-  error?: any;
+  data?: any;
+  dataPrefix: string;
 }
 
-export const log = ({ type, message, error }: LogInput = { type: 'info', message: '' }) => {
-  const messagePrefix = `[${type.toUpperCase()}]${message.startsWith('[') ? '' : ': '}`
-  console.log(`${messagePrefix}${message}`)
-  error && console.log('[Reason]:', error)
+enum TypeOfMessage {
+  Info = 'INFO',
+  Error = 'ERROR',
+  Debug = 'DEBUG'
+}
+
+const log = (...params) => {
+  console.log(...params)
+}
+
+function prefixTo(prefix: string, message: string) {
+  `[${prefix}]${message.startsWith('[') ? '' : ': '}`
+}
+
+export const logInfo = logInput => {
+  const messagePrefix = prefixTo(TypeOfMessage.Info, logInput.message)
+  log(`${messagePrefix}${logInput.message}`)
+}
+
+export const logError = logInput => {
+  const messagePrefix = prefixTo(TypeOfMessage.Error, logInput.message)
+  log(`${messagePrefix}${logInput.message}`)
+  logInput.error && log('\n[Reason]:', logInput.error, '\n')
+}
+
+export const logDebug = logInput => {
+  const isDebugOn = process.env.DEBUG || false
+  if (!isDebugOn) return
+  const messagePrefix = prefixTo(TypeOfMessage.Debug, logInput.message)
+  log(`${messagePrefix}${logInput.message}`)
+  logInput.data && log('\n[Debug data]:', logInput.data, '\n')
 }

package/src/types/index.ts

@@ -3,7 +3,7 @@ export interface DeploymentPlatformTemplate {
   domain: string;
   supportedDeploymentTypes: SupportedDeploymentTypes[];
   supportedEnvironments: SupportedEnvironments[];
-  awsRegion: string;
+  awsRegion?: string;
   awsAccountId: string;
   awsKeyPairName?: string;
   awsRoleToAssume?: string;