@ossy/deployment-tools 0.0.19 → 0.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/deployment-tools",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "description": "Collection of scripts and tools to aid deployment of containers and static files",
   "main": "dist/index.js",
   "type": "module",
@@ -12,6 +12,9 @@
   "license": "ISC",
   "bin": "dist/index.js",
   "dependencies": {
+    "@actions/core": "^1.10.0",
+    "@aws-sdk/client-sqs": "^3.186.0",
+    "@aws-sdk/client-sts": "^3.188.0",
     "arg": "^5.0.2",
     "express": "^4.18.1",
     "nanoid": "^4.0.0",

package/src/aws-credentials-client.js

@@ -0,0 +1,24 @@
+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: 5 * 60,
+        WebIdentityToken: webIdentityToken
+      })))
+      .then(responseData => ({
+        accessKeyId: responseData.Credentials.AccessKeyId,
+        secretAccessKey: responseData.Credentials.SecretAccessKey,
+        sessionToken: responseData.Credentials.SessionToken
+      }))
+
+  }
+
+}

package/src/caddy-client.js

@@ -49,7 +49,7 @@ export class CaddyClient {
           http: {
             servers: {
               [this.serverName]: {
-                listen: [':443'],
+                listen: [':80', ':443'],
                 routes: [
                   {
                     match: [Matchers.host(`*.${config.environmentName}.${config.domain}`)],

package/src/config.js

@@ -1,4 +1,9 @@
+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-commands.js → container-manager-client.js}

@@ -1,32 +1,36 @@
 import { resolve } from 'path'
 import { readFileSync } from 'fs'
-import fetch from 'node-fetch'
+import { AwsCredentialsClient } from './aws-credentials-client.js'
+import { DeploymentQueueClient } from './deployment-manager-client.js'
 
-export class ContainerManagerCommands {
+export class ContainerManagerClient {
 
+  //eslint-disable-next-line max-params
   static deploy(
+    username,
+    authentication,
     targetEnvironment = 'local-dev',
     pathToDeploymentPlatforms,
     pathToOssyFile
   ) {
-    const webApiCommands = new ContainerManagerCommands()
-    return webApiCommands.deploy(
+    const containerManagerClient = new ContainerManagerClient()
+    return containerManagerClient.deploy(
+      username,
+      authentication,
       targetEnvironment,
       pathToDeploymentPlatforms,
       pathToOssyFile
     )
   }
 
-  constructor() {
-
-  }
+  constructor() {}
 
   getDeployments(pathToOssyFile) {
     const ossyfile = JSON.parse(readFileSync(resolve(pathToOssyFile), 'utf8'))
     return Promise.resolve(ossyfile.deployments || [])
   }
 
-  async getDeploymentPlatforms(pathToDeploymentPlatforms) {
+  getDeploymentPlatforms(pathToDeploymentPlatforms) {
 
     const localDevPlatform = {
       name: 'dev',
@@ -36,9 +40,8 @@ export class ContainerManagerCommands {
 
     if (!pathToDeploymentPlatforms) return [localDevPlatform]
 
-    const imports = await import(resolve(pathToDeploymentPlatforms))
-    const deploymentPlatforms = Object.values(imports)
-    return deploymentPlatforms || [localDevPlatform]
+    const deploymentPlatforms = JSON.parse(readFileSync(resolve(pathToDeploymentPlatforms), 'utf8'))
+    return Promise.resolve(deploymentPlatforms || [localDevPlatform])
   }
 
   getDeploymentTargetURL(targetEnvironment, deploymentPlatform, deployment) {
@@ -65,7 +68,7 @@ export class ContainerManagerCommands {
   deploy(
     username,
     authentication,
-    targetEnvironment = 'dev',
+    targetEnvironment,
     pathToDeploymentPlatforms,
     pathToOssyFile
   ) {
@@ -99,17 +102,14 @@ export class ContainerManagerCommands {
             authentication: authentication
           }
 
-          console.log('body', body)
-
-          const ciUrl = targetEnvironment === 'prod'
-            ? `http://${platform.ciSubDomain}.${platform.domain}/deploy`
-            : `http://${platform.ciSubDomain}.${targetEnvironment}.${platform.domain}/deploy`
+          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))
 
-          fetch(ciUrl, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(body)
-          })
+            })
         })
       })
       .catch(error => console.log(error))

package/src/container-manager-server.js

@@ -1,6 +1,7 @@
 import express from 'express'
 import { CaddyClient } from './caddy-client.js'
 import { DockerClient } from './docker-client.js'
+import { DeploymentQueueClient } from './deployment-manager-client.js'
 import * as config from './config.js'
 
 export class ContainerManagerServer {
@@ -10,17 +11,18 @@ export class ContainerManagerServer {
   }
 
   constructor() {
+    this.server = express()
     this.dockerClient = DockerClient.new()
     this.caddyClient = CaddyClient.new()
-    this.server = express()
+    this.deploymentQueueClient = DeploymentQueueClient.new()
 
-    this.server.use(express.json())
+    this.applyDefaultCaddyConfig()
+    this.setupServerEndpoints()
+    this.pollForDeploymentRequests()
+  }
 
-    this.caddyClient.applyDefaultServerConfig()
-      .then(() => this.caddyClient.deploy({
-        domain: `${config.ciSubDomain}.${config.environmentName}.${config.domain}`,
-        targetPort: config.port
-      }))
+  setupServerEndpoints() {
+    this.server.use(express.json())
 
     this.server.get('/', (req, res) => {
       res.redirect('/status')
@@ -30,19 +32,34 @@ export class ContainerManagerServer {
       res.json('Server is live')
     })
 
-    this.server.post('/deploy', (req, res) => {
-      console.log('/deploy body', req.body)
-      this.deploy(req, res)
-    })
-
     this.server.listen(config.port, () => {
       console.log(`Web API is live on port ${config.port}`)
     })
   }
 
-  deploy(req, res) {
+  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)
+  }
 
-    console.log('req.body: ', req.body)
+  deploy(deploymentRequestMessage) {
 
     const {
       registry,
@@ -53,7 +70,7 @@ export class ContainerManagerServer {
       image,
       domain,
       env
-    } = req.body
+    } = deploymentRequestMessage
 
     this.dockerClient.deploy({
       image,
@@ -67,7 +84,6 @@ export class ContainerManagerServer {
 
     domain && this.caddyClient.deploy({ domain, targetPort: hostPort })
 
-    res.json('Recieved deployment request')
   }
 
 }

package/src/deployment-queue-client.js

@@ -0,0 +1,57 @@
+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 = 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 = ReceiveMessageCommand({ QueueUrl: this.queueUrl })
+
+    return this.sqs.send(command)
+      .catch(error => console.log('Error', error))
+  }
+
+  deleteMessage(receiptHandle) {
+    const command = DeleteMessageCommand({
+      QueueUrl: this.queueUrl,
+      ReceiptHandle:  receiptHandle
+    })
+
+    return this.sqs.send(command)
+      .then(() => console.log('success'))
+      .catch(error => console.log('Error', error))
+
+  }
+
+}

package/src/index.js

@@ -3,7 +3,7 @@ import { platform } from 'os'
 import { exec } from 'child_process'
 import arg from 'arg'
 import { ContainerManagerServer } from './container-manager-server.js'
-import { ContainerManagerCommands } from './container-manager-commands.js'
+import { ContainerManagerClient } from './container-manager-client.js'
 
 const [_, __, command, ...restArgs] = process.argv
 
@@ -40,7 +40,7 @@ const deployHandler = () => {
     '-u': '--username',
 
     '--authentication': String,
-    '--p': '--authentication',
+    '--a': '--authentication',
 
     '--target-env': String,
     '-t': '--target-env',
@@ -54,7 +54,7 @@ const deployHandler = () => {
 
   console.log('args', args)
 
-  ContainerManagerCommands.deploy(
+  ContainerManagerClient.deploy(
     args['--username'],
     args['--authentication'],
     args['--target-env'],