@ossy/deployment-tools 0.0.54 → 0.0.56

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/deployment-tools",
-  "version": "0.0.54",
+  "version": "0.0.56",
   "description": "Collection of scripts and tools to aid deployment of containers and static files to Amazon Web Services through GitHub Actions",
   "source": "./src/index.js",
   "main": "./src/index.js",

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

@@ -35,14 +35,14 @@ class DeploymentQueueService {
   static pollForDeploymentRequests(platformConfig, handleDeploymentRequest) {
     logInfo({ message: '[DeploymentQueueService] Starting polling for deployment requests' })
     DeploymentQueueService.createAwsSqsClient(platformConfig).then(sqsClient => {
-      const FIVE_MINUTES = 3000
+      const FIVE_MINUTES = 300000
 
       setInterval(() => {
 
         const receiveMessageCommand = new ReceiveMessageCommand({ QueueUrl: platformConfig.awsDeploymentSqsArn })
 
         sqsClient.send(receiveMessageCommand)
-          .then(data => data.Messages.map(message => {
+          .then(data => data && data.Messages && data.Messages.map(message => {
 
             logInfo({ message: '[DeploymentQueueService] Received deployment request' })
 
@@ -60,7 +60,7 @@ class DeploymentQueueService {
               })
 
           }))
-          .catch(error => logError({ message: '[ContainerManagerServer] Could not handle incoming deployment request', error }))
+          .catch(error => logError({ message: '[DeploymentQueueService] Could not handle incoming deployment request', error }))
       }, FIVE_MINUTES)
 
     })

package/src/docker/docker-service.js

@@ -1,29 +1,13 @@
-const { exec } = require('child_process')
-const Docker = require('dockerode')
+const { exec: execBash } = require('child_process')
+const { logInfo, logDebug, logErrorAndReject } = require('../log')
 
-const { logInfo } = require('../log')
-
-// const exec = command => new Promise((resolve, reject) => {
-//   execBash('command', (error, stdout, stderr) => {
-//
-//     if (error) {
-//       console.error(`exec error: ${error}`)
-//       return
-//     }
-//
-//     console.log(`stdout: ${stdout}`)
-//     console.error(`stderr: ${stderr}`)
-//
-//     command.stdout.on('data', data => {
-//       logInfo({ message: `[DockerService]: ${data}` })
-//     })
-//
-//     command.stderr.on('data', (data) => {
-//       logError({ message: `[DockerService]: ${data}` })
-//     })
-//
-//   })
-// })
+const exec = command => new Promise((resolve, reject) => {
+  execBash(command, (error, stdout, stderr) => {
+    if (error) return reject(error)
+    if (stderr) return reject(stderr)
+    resolve(stdout)
+  })
+})
 
 /**
   * @class
@@ -32,13 +16,14 @@ class DockerService {
 
   static createDockerNetworkForContainerManagerServer(platformConfig) {
     logInfo({ message: '[DockerService] Creating docker network for comunication between containers' })
-    exec(`sudo docker network create ${platformConfig.ciDockerNetworkName}`)
+    return exec(`docker network create ${platformConfig.ciDockerNetworkName}`)
   }
 
   static stopContainer(deploymentRequest) {
     const name = deploymentRequest.image.replaceAll('/', '_')
     logInfo({ message: `[DockerService] Running docker stop for image with the name of ${name}` })
-    exec(`sudo docker stop ${name}`)
+    return exec(`docker stop ${name}`)
+      .catch(() => {}) // no worries if container isn't there
   }
 
   static startContainer(platformConfig, { image, containerPort, hostPort, registry, env }) {
@@ -46,42 +31,30 @@ class DockerService {
     const imageUrl = !!registry ? `${registry}/${image}` : image
     const envsAsString = Object.entries(env || {}).reduce((envs, [name, value]) => `${envs} --env ${name}=${value}`, '')
     logInfo({ message: `[DockerService] Running docker start for image with the name of ${name} with port mapping ${hostPort}:${containerPort} and source ${imageUrl}` })
-    exec(`sudo docker run -d -p ${hostPort}:${containerPort} --name=${name} --network=${platformConfig.ciDockerNetworkName} --network-alias=${name} --rm ${envsAsString} ${imageUrl}`)
+    return exec(`docker run -d -p ${hostPort}:${containerPort} --name=${name} --network=${platformConfig.ciDockerNetworkName} --network-alias=${name} --rm ${envsAsString} ${imageUrl}`)
+      .cath(logErrorAndReject(`[DockerService] Could not start container ${image}`))
   }
 
-  static pullImage({ registry, username, authentication, image }) {
-    let authconfig
+  static resolveCredentials({ registry, username, authentication }) {
     const shouldAuthenticate = username || authentication
 
-    if (shouldAuthenticate) {
-      authconfig = {
-        username: username,
-        password: authentication,
-        // auth: '',
-        // email: 'your@email.email',
-        serveraddress: registry
-      }
-    }
-
     shouldAuthenticate
-      ? logInfo({ message: '[DockerService] Docker credentials provided, trying to pull from private repository' })
+      ? logInfo({ message: '[DockerService] Docker credentials provided, logging in to private repository' })
       : logInfo({ message: '[DockerService] No docker credentials provided, assuming image is publicly hosted' })
 
-    const docker = new Docker()
-
-    return docker.pull(image, { authconfig })
-    // .then()
-    // .catch()
-
-    // logInfo({ message: `[DockerService] Resolving docker credentials for ${registry}` })
-    // exec(`sudo docker login ${registry} -u ${username} -p ${authentication}`)
+    return !shouldAuthenticate
+      ? Promise.resolve()
+      : exec(`docker login ${registry} -u ${username} -p ${authentication}`)
+        .cath(logErrorAndReject(`[DockerService] Could not authenticate with ${registry}`))
   }
 
   static deploy(platformConfig, deploymentRequest) {
     logInfo({ message: '[DockerService] Starting docker deployment sequence' })
-    DockerService.stopContainer(deploymentRequest)
-    DockerService.pullImage(deploymentRequest)
-    DockerService.startContainer(platformConfig, deploymentRequest)
+    logDebug({ message: '[DockerService] deploymentRequest', data: deploymentRequest })
+
+    return DockerService.resolveCredentials(deploymentRequest)
+      .then(() => DockerService.stop(deploymentRequest))
+      .then(() => DockerService.startContainer(platformConfig, deploymentRequest))
   }
 
 }

package/src/infrastructure/container-server/container-server.js

@@ -111,6 +111,9 @@ class ContainerServer extends Construct {
     const userData = UserData.forLinux()
 
     userData.addCommands(
+      'sudo groupadd docker',
+      'sudo usermod -aG docker ubuntu',
+      'newgrp docker',
       'sudo apt update -y',
       ...getInstallNodeJs(),
       ...getInstallNpm(),

package/src/infrastructure/container-server/deployment-tools.service.js

@@ -5,8 +5,8 @@ After=network.target caddy-route53.service
 
 [Service]
 EnvironmentFile=/etc/environment
-User=caddy
-Group=caddy
+User=ubuntu
+Group=docker
 AmbientCapabilities=CAP_NET_BIND_SERVICE
 CapabilityBoundingSet=CAP_NET_BIND_SERVICE
 ExecStart=/usr/bin/npx --yes @ossy/deployment-tools server start --platforms /home/ubuntu/platform-config.json

package/src/log.js

@@ -26,15 +26,21 @@ const logError = logInput => {
 }
 
 const logDebug = logInput => {
-  const isDebugOn = process.env.DEBUG || false
+  const isDebugOn = process.env.DEBUG || true
   if (!isDebugOn) return
   const messagePrefix = prefixTo(TypeOfMessage.Debug, logInput.message)
   log(`${messagePrefix}${logInput.message}`)
   logInput.data && log('\n[Debug data]:', logInput.data, '\n')
 }
 
+const logErrorAndReject = message => error => {
+  logError({ message, error })
+  return Promise.reject(error)
+}
+
 module.exports = {
   logInfo,
   logError,
+  logErrorAndReject,
   logDebug
 }

package/src/server/platform-server.js

@@ -7,7 +7,7 @@ const { PlatformConfigService } = require('../config')
 const { DeploymentQueueService } = require('../deployment-queue')
 const { logError } = require('../log')
 
-// journalctl -u service-name.service
+// journalctl -u deployment-tools.service
 /**
   * @class
 */
@@ -24,7 +24,7 @@ class PlatformServerService {
         platformConfig,
         deploymentRequest => {
           DockerService.deploy(platformConfig, deploymentRequest)
-          CaddyService.addDeployment(platformConfig, deploymentRequest)
+            .then(() => CaddyService.addDeployment(platformConfig, deploymentRequest))
           return Promise.resolve()
         }
       )