@ossy/deployment-tools 0.0.79 → 0.0.80

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/deployment-tools",
-  "version": "0.0.79",
+  "version": "0.0.80",
   "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/deploy/cli.js

@@ -38,10 +38,41 @@ const deploy = options => {
   })
 }
 
+const deployAll = options => {
+  logInfo({ message: '[CLI] Running deploy-all command' })
+
+  const parsedArgs = arg({
+    '--username': String,
+    '-u': '--username',
+
+    '--authentication': String,
+    '--a': '--authentication',
+
+    '--platform': String,
+    '-p': '--platform',
+
+    '--platforms-path': String,
+    '-pp': '--platforms-path',
+
+    '--deployments-path': String,
+    '-dp': '--deployments-path',
+
+
+  }, { argv: options })
+
+  PlatformDeploymentService.deployAll({
+    username: parsedArgs['--username'],
+    authentication: parsedArgs['--authentication'],
+    targetPlatform: parsedArgs['--platform'],
+    pathToPlatformTemplates: parsedArgs['--platforms-path'],
+    pathToDeploymentTemplates: parsedArgs['--deployments-path']
+  })
+}
+
 module.exports = {
   handler: ([command, ...options]) => {
     !!command
-      ? { deploy }[command](options)
+      ? { deploy, 'deploy-all': deployAll }[command](options)
       : logError({ message: 'No command provided' })
   }
 }

package/src/deploy/platform-deployment.js

@@ -63,6 +63,60 @@ class PlatformDeploymentService {
       .catch(error => logError({ message: '[PlatformDeploymentService] Could not send deployment request', error }))
   }
 
+  static deployAll({
+    username,
+    authentication,
+    targetDomain,
+    targetPlatform,
+    pathToPlatformTemplates,
+    pathToDeploymentTemplates
+  }) {
+
+    return Promise.all([
+      DeploymentTemplateService.readFromFiles(pathToDeploymentTemplates),
+      PlatformTemplateService.readFromFile(pathToPlatformTemplates)
+        .then(templates => templates.map(PlatformConfigService.from))
+    ])
+      .then(([deploymentTemplates, platformConfigs]) => {
+
+        const platformConfig = platformConfigs.find(({ platformName }) => platformName === targetPlatform)
+        const deploymentTemplatesForTargetPlatform = deploymentTemplates[targetPlatform] || []
+
+        if (!platformConfig) {
+          logError({ message: `[PlatformDeploymentService] Could not find a platform named ${targetPlatform}` })
+          return Promise.reject()
+        }
+
+        if (deploymentTemplatesForTargetPlatform.length === 0) {
+          logError({ message: `[PlatformDeploymentService] Could not find a deployment template for ${targetDomain} in ${targetPlatform}` })
+          return Promise.reject()
+        }
+
+        process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'
+
+        return deploymentTemplatesForTargetPlatform.map(deploymentTemplate => {
+          if (deploymentTemplate.type === SupportedDeploymentTypes.Container) {
+
+            const caddyConfig = CaddyConfigService.createConfig(platformConfig, deploymentTemplatesForTargetPlatform)
+
+            const deploymentRequest = {
+              ...deploymentTemplate,
+              username: username,
+              authentication: authentication,
+              caddyConfig
+            }
+
+            return DeploymentQueueService.sendDeploymentRequest(platformConfig, deploymentRequest)
+          }
+
+          logError({ message: `[PlatformDeploymentService] Unsupported deployment type of ${deploymentTemplate.type}` })
+          return Promise.reject()
+        })
+
+      })
+      .catch(error => logError({ message: '[PlatformDeploymentService] Could not send deployment request', error }))
+  }
+
 }
 
 module.exports = {

package/src/docker/docker-service.js

@@ -33,7 +33,8 @@ class DockerService {
   }
 
   static removeImage(deploymentRequest) {
-    const name = deploymentRequest.image.replaceAll('/', '_')
+    const { registry, image } = deploymentRequest
+    const name = !!registry ? `${registry}/${image}` : image
     logInfo({ message: `[DockerService] Removing image ${name}` })
     return exec(`docker image rm -f ${name}`)
       .catch(() => {}) // no worries if container isn't there