@ossy/deployment-tools 0.0.77 → 0.0.80

package/README.md

@@ -37,111 +37,6 @@ npx --yes @ossy/deployment-tools deploy \
   --ossyfile packages/${{ github.event.inputs.packageName }}/ossy.json \
 ```
 
-## Concepts
-
-**Workspace**
-
-A workspace is an umbrella for our services.
-It needs to be associated with at least one billable account.
-The workspace holds information like what tools and services are in use and should
-be billed, and what users have access to these tools and services.
-
-```
-id: string;
-name: string;
-participants: WorkspaceParticipant[];
-services: ServiceDefinition[];
-billingInformation
-
-```
-
-## Our domains
-
-ossy.se
-www.ossy.se
-test.ossy.se
-
-api.ossy.se
-api.test.ossy.se
-
-plexus.ossy.se
-plexus.test.ossy.se
-
-oskarssylwan.se
-www.oskarssylwan.se
-test.oskarssylwan.se
-
-
-## Overview of our infrastructure
-
-We use AWS to host our infrastructure and all of it is defined in JavaScript with the help of
-(AWS CDK)[https://aws.amazon.com/cdk/].
-
-**Static content**
-
-We use a s3 bucket for static content.
-This bucket is used to host websites, images, videos and other static content.
-On root level you'll find directories that represent one workspace each.
-
-/<workspacId>/<service>/
-/<workspacId>/websites/website-id
-
-The bucket have directories for each workspace that is the workspaceID.
-
-The bucket have directories for each workspace that contains a media directory and website directories
-
-- a place to host media files like images, videos, pdf documents etc.
-- a platform to host different docker images to
-- a mongodb database that can ensure data persistance without much effort from our our side
-- an email service
-- an easy way to host multiple single page applications
-
-Stacks
-
-- email service stack per env
-- media bucket stack per env
-- stack for dns records with the account that holds domain names
-
-### Adding a new AWS account
-We have a different account for each service and environment.
-To add a new account follow the steps below.
-
-- Create an email group in GoogleAdmin with **public post access**.
-  The email should follow the pattern <service-name>-<env>@ossy.se.
-  If it's an account for prod use <service-name>@ossy.se.
-  Don't forgett to add yourself and other relevant people to the group.
-- Log into our root organisation account and create a new aws account
-  with the same naming pattern and email as described above.
-- Log out of the organisation account then send a password reset request to the
-  newly created account using the new email.
-- Create a new user in the account with the same name as the account.
-  In the same process add the AdministratorAccess managed policy to the user.
-- Create an access key to the account and add it as a (named profile)[https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-profiles.html] on your computer
-- Create a keypair in the correct region and download it
-- Add the new environment to the platforms.json file in this repository
-  - don't forget to add the keypair
-- run the cdk ls command to make sure the new stack is picked up
-- run cdk bootstrap for the account and region. This will create necessary resources like roles used by aws cdk.
-- run deploy for all stacks
-- add the instanceIp, awsRoleToAssume, and staticBucket name to the platforms.json file
-
-
-<!-- Deploys AWS infrastructure
-```
-npx --yes @ossy/deployment-tools infrastructure deploy
-```
-
-Destroys AWS infrastructure
-```
-npx --yes @ossy/deployment-tools infrastructure destroy
-```
-
-Prints AWS infrastructure stacks
-```
-npx --yes @ossy/deployment-tools infrastructure ls
-``` -->
-
-
 The `cdk.json` file tells the CDK Toolkit how to execute your app.
 
 * `cdk deploy`      deploy this stack to your default AWS account/region

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/deployment-tools",
-  "version": "0.0.77",
+  "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",
@@ -18,16 +18,16 @@
     "@aws-sdk/client-sqs": "^3.245.0",
     "@aws-sdk/client-sts": "^3.245.0",
     "arg": "^5.0.2",
-    "aws-cdk-lib": "^2.59.0",
-    "constructs": "^10.1.211",
+    "aws-cdk": "^2.73.0",
+    "aws-cdk-lib": "^2.73.0",
+    "constructs": "^10.1.304",
     "express": "^4.18.1",
     "glob": "^9.3.2",
     "nanoid": "^3.3.4",
     "node-fetch": "^2.6.7"
   },
   "devDependencies": {
-    "aws-cdk": "^2.59.0",
     "jest": "^27.5.1",
-    "jsdoc": "^3.6.11"
+    "jsdoc": "^4.0.2"
   }
 }

package/src/deploy/cli.js

@@ -22,8 +22,8 @@ const deploy = options => {
     '--platforms-path': String,
     '-pp': '--platforms-path',
 
-    '--ossy-files': String,
-    '-o': '--ossy-files',
+    '--deployments-path': String,
+    '-dp': '--deployments-path',
 
 
   }, { argv: options })
@@ -34,14 +34,45 @@ const deploy = options => {
     targetDomain: parsedArgs['--domain'],
     targetPlatform: parsedArgs['--platform'],
     pathToPlatformTemplates: parsedArgs['--platforms-path'],
-    globPatternForOssyFiles: parsedArgs['--ossy-files']
+    pathToDeploymentTemplates: parsedArgs['--deployments-path']
+  })
+}
+
+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

@@ -17,11 +17,11 @@ class PlatformDeploymentService {
     targetDomain,
     targetPlatform,
     pathToPlatformTemplates,
-    globPatternForOssyFiles
+    pathToDeploymentTemplates
   }) {
 
     return Promise.all([
-      DeploymentTemplateService.readOssyFiles(globPatternForOssyFiles),
+      DeploymentTemplateService.readFromFiles(pathToDeploymentTemplates),
       PlatformTemplateService.readFromFile(pathToPlatformTemplates)
         .then(templates => templates.map(PlatformConfigService.from))
     ])
@@ -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

package/src/infrastructure/cli.js

@@ -9,7 +9,7 @@ const { PlatformConfigService } = require('../config')
 const { PlatformDeploymentService } = require('../deploy')
 
 Promise.all([
-  DeploymentTemplateService.readOssyFiles(process.env.OSSY_FILES),
+  DeploymentTemplateService.readFromFiles(process.env.DEPLOYMENTS),
   PlatformTemplateService
     .readFromFile(process.env.PLATFORMS)
     .then(templates => templates.map(PlatformConfigService.from))

package/src/template/deployment-template.js

@@ -25,16 +25,14 @@ class DeploymentTemplateService {
   /**
    *  Read and and group deployments by targetDeploymentPlatform
    *
-   * @param {string} blob - blob pattern for ossy.json files
+   * @param {string} blob - blob pattern for deployments.json files
    */
-   static readOssyFiles(blob) {
+   static readFromFiles(blob) {
      return glob(blob, { ignore: 'node_modules/**' })
        .then(filePaths => filePaths
            .map(path => readFileSync(path, 'utf-8'))
-           .map(json => JSON.parse(json))
-           .flatMap(ossyFileContent => ossyFileContent.deployments)
+           .flatMap(json => JSON.parse(json))
            .reduce((deploymentsMap, deployment) => {
-
              if (!!deploymentsMap[deployment.targetDeploymentPlatform]) {
                return {
                  ...deploymentsMap,

package/src/template/playground.js

@@ -0,0 +1,5 @@
+const { DeploymentTemplateService } = require('./deployment-template')
+
+DeploymentTemplateService.readFromFiles('../infrastructure/deployment*.json')
+  // .then(console.log)
+  // .catch(console.log)