cloudmason 0.0.1

package/.github/workflows/main.yml

@@ -0,0 +1,27 @@
+name: Node.js Package
+
+on:
+  pull_request:
+    types:
+      - closed
+    branches:
+      - 'release/**'
+
+jobs:
+  if_merged:
+    if: github.event.pull_request.merged == true
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+          registry-url: https://registry.npmjs.org/
+      - run: npm run build
+        env: 
+          branch: ${{ github.base_ref }}
+          build: ${{ github.run_number }}
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/README.md

@@ -0,0 +1,25 @@
+# Introduction 
+TODO: Give a short introduction of your project. Let this section explain the objectives or the motivation behind this project. 
+
+## Sub Introduction
+
+### Sub2 Introduction
+
+
+# Getting Started
+TODO: Guide users through getting your code up and running on their own system. In this section you can talk about:
+1.	Installation process
+2.	Software dependencies
+3.	Latest releases
+4.	API references
+
+# Build and Test
+TODO: Describe and show how to build your code and run the tests. 
+
+# Contribute
+TODO: Explain how other users and developers can contribute to make your code better. 
+
+If you want to learn more about creating good readme files then refer the following [guidelines](https://docs.microsoft.com/en-us/azure/devops/repos/git/create-a-readme?view=azure-devops). You can also seek inspiration from the below readme files:
+- [ASP.NET Core](https://github.com/aspnet/Home)
+- [Visual Studio Code](https://github.com/Microsoft/vscode)
+- [Chakra Core](https://github.com/Microsoft/ChakraCore)

package/build.js

@@ -0,0 +1,21 @@
+const fs = require('fs');
+
+const pckg = JSON.parse(fs.readFileSync('./package.json'));
+
+const branch = process.env.branch;
+const build = process.env.build;
+
+console.log(`Branch: ${branch}`);
+console.log(`Build: ${build}`);
+
+const branchParts = branch.split('/');
+const lastPart = branchParts[branchParts.length - 1];
+const majorVersion = lastPart.replaceAll(/[^0-9\.]/g, '');
+
+const version = `${majorVersion}.${build}`;
+
+pckg.version = version;
+
+console.log(`Version: ${version}`);
+
+fs.writeFileSync('./package.json', JSON.stringify(pckg));

package/commands/delete.js

@@ -0,0 +1,29 @@
+const CF = require('./helpers/cf');
+const Params = require('./helpers/params');
+
+
+exports.delete_instance = async function(args){
+    // Get App
+    const app = await Params.getApp(args.app);
+    if (!app){
+        console.log('Err: No app named ' + args.app);
+        throw new Error('Err: No app named ' + args.app)
+    }
+    //  Get Instance
+    const targetInstance = app.instances.find(ins=>{ return ins.name.toLowerCase() == args.i.toLowerCase() });
+    if (!targetInstance){ console.log(`No instance of ${args.app} named ${args.i}`); throw new Error('Invalid Instance')}
+    
+    //  Delete Stack
+    const stackName = (`${args.app}-${args.i}`).toLowerCase();
+    console.log(`Deleting ${args.app} instance ${args.i} in ${targetInstance.region}`)
+    const delOK = await CF.delete(stackName, targetInstance.region);
+    if (delOK){
+        console.log('Delete Successful')
+    } else {
+        return;
+    }
+
+    //  Update Params
+    await Params.deleteInstance(args.app,args.i);
+    return true;
+}

package/commands/delete_app.js

@@ -0,0 +1,28 @@
+const { S3Client,PutObjectCommand } = require("@aws-sdk/client-s3");
+const fs = require('fs');
+const path = require('path')
+const Params = require('./helpers/params');
+const S3 = require('./helpers/s3');
+
+
+exports.main = async function(args){
+    // Check for existing app
+    const existingApp = await Params.getApp(args.name);
+    if (!existingApp){
+        console.log('Err: App does not exist ' + args.name);
+        throw new Error('App does not exist')
+    }
+
+
+    // Upload Stack
+    console.log(`Uploading ${args.type} to ${process.env.orgBucket}`)
+    const stackKey = `apps/${args.name.toLowerCase()}/default_stack.yaml`
+    await S3.uploadInfraText(stackKey,stackText);
+
+    // Update app config
+    console.log('Adding app params');
+    const nodev = args.node || '';
+    const pyv = args.py || '';
+    await Params.addApp(args.name,args.type,stackKey,nodev,pyv);
+    console.log(`Added ${args.name} with ${args.type} stack`)
+}

package/commands/helpers/cf.js

@@ -0,0 +1,118 @@
+const { CloudFormationClient, CreateStackCommand,UpdateStackCommand, DeleteStackCommand, ValidateTemplateCommand,DescribeStacksCommand } = require('@aws-sdk/client-cloudformation');
+
+const fs = require('fs');
+const path = require('path')
+
+
+exports.deployOrgStack = async function(stackName,stackType,region,params,tag){
+    // Read Stack
+    const stackPath = path.resolve(__dirname,'stacks',`${stackType.toLowerCase()}.yaml`);
+    if (!fs.existsSync(stackPath)){
+        console.log('Invalid stack type:' + stackType);
+        throw { message: 'Invalid stack type', at: 'deployStack'}
+    }
+    const stackYML = fs.readFileSync(stackPath,'utf-8');
+    console.log
+    // Build Params
+    const cfParams = Object.keys(params).map(k=>{ return { ParameterKey: k, ParameterValue: params[k] } })
+    const cfTags = Object.keys(tag).map(k=>{ return { Key: k, Value: tag[k] } })
+    // Deploy Stack
+    const client = new CloudFormationClient({ region });
+    const input = {
+        StackName: stackName,
+        TemplateBody: stackYML,
+        Capabilities: [
+            "CAPABILITY_IAM" || "CAPABILITY_NAMED_IAM" || "CAPABILITY_AUTO_EXPAND",
+        ],
+        Parameters: cfParams,
+        Tags: cfTags
+    };
+    try{
+        const result = await client.send(new CreateStackCommand(input));
+        return result.StackId;
+    } catch (e){
+        if (/AlreadyExistsException/.test(e)){
+            console.log('Stack exists ' + stackName);
+            return false;
+        } else {
+            throw new Error(e.message)
+        }
+    }
+}
+
+exports.deployS3Stack = async function(stackName,s3Url,params,tag,region){
+    // Build Params
+    const cfParams = Object.keys(params).map(k=>{ return { ParameterKey: k, ParameterValue: params[k] } })
+    const cfTags = Object.keys(tag).map(k=>{ return { Key: k, Value: tag[k] } })
+    // Deploy Stack
+    const client = new CloudFormationClient({ region });
+    const input = {
+        StackName: stackName,
+        TemplateURL: s3Url,
+        Capabilities: [
+            "CAPABILITY_IAM" || "CAPABILITY_NAMED_IAM" || "CAPABILITY_AUTO_EXPAND",
+        ],
+        Parameters: cfParams,
+        Tags: cfTags
+    };
+
+    const result = await client.send(new CreateStackCommand(input));
+    return result.StackId;
+}
+
+exports.updateStack = async function(stackName,s3Url,params,region){
+    const client = new CloudFormationClient({ region });
+    const cfParams = Object.keys(params).map(k=>{ return { ParameterKey: k, ParameterValue: params[k] } })
+    console.log(s3Url)
+    const cmd = {
+        StackName: stackName,
+        TemplateURL: s3Url,
+        Parameters: cfParams,
+        Capabilities: ["CAPABILITY_IAM", "CAPABILITY_NAMED_IAM"]
+    };
+    const command = new UpdateStackCommand(cmd);
+    const response = await client.send(command);
+    return true;
+}
+
+exports.validateStack = async function(stack){
+    const client = new CloudFormationClient({ region: process.env.orgRegion });
+
+    const command = new ValidateTemplateCommand({
+        TemplateBody: stack,
+    });
+
+    try{
+        const data = await client.send(command);
+        return { ok: true, data: data }
+    } catch (e){
+        return {ok: false, data: e}
+    }
+}
+
+exports.stackExists = async function(stackName,region){
+    const client = new CloudFormationClient({ region });
+    const command = new DescribeStacksCommand({ StackName: stackName });
+    try {
+        
+        const response = await client.send(command);
+        return true;
+    } catch (error) {
+        if (error.name === 'ValidationError') {
+            return false;
+        }
+        throw error;
+    }
+}
+
+exports.delete = async function(stackName,region){
+    const client = new CloudFormationClient({ region });
+    try {
+        const command = new DeleteStackCommand({ StackName: stackName });
+        const response = await client.send(command);
+        return true;
+    } catch (error) {
+        console.error("Error deleting the stack:", error);
+        return false;
+    }
+}

package/commands/helpers/ec2.js

@@ -0,0 +1,40 @@
+const { EC2Client, RunInstancesCommand,CreateImageCommand,TerminateInstancesCommand,DescribeInstanceStatusCommand,DeregisterImageCommand,DescribeImagesCommand,CopyImageCommand } = require("@aws-sdk/client-ec2");
+
+exports.findAMI = async function(image_name,region){
+    const client = new EC2Client({ region });
+    const input = { // DescribeImagesRequest
+        Filters: [ // FilterList
+            { // Filter
+            Name: "name",
+            Values: [ // ValueStringList
+                image_name,
+            ],
+            },
+        ],
+        IncludeDeprecated: true,
+        DryRun: false,
+        MaxResults: 6
+    };
+    const command = new DescribeImagesCommand(input);
+    const response = await client.send(command);
+    const images = response.Images;
+    if (!images[0]){ 
+        console.log('No existing image with name:' + image_name)
+        return false; 
+    };
+    return images[0].ImageId;
+}
+
+exports.copyAMI = async function(image_name,src_ami,src_region,dest_region){
+    
+    const destinationEc2Client = new EC2Client({ region: dest_region });
+
+    const copyImageCommand = new CopyImageCommand({
+        SourceRegion: src_region,
+        SourceImageId: src_ami,
+        Name: image_name,
+    });
+    
+    const { ImageId } = await destinationEc2Client.send(copyImageCommand);
+    return ImageId;
+}

package/commands/helpers/params.js

@@ -0,0 +1,178 @@
+const { SSMClient, GetParameterCommand,PutParameterCommand,GetParametersByPathCommand } = require("@aws-sdk/client-ssm");
+
+// ORG PARAMS
+exports.getOrgConfig = async function(){
+    if (!process.env.orgRegion){ throw new Error('Region not set') }
+    const ssmClient = new SSMClient({ region: process.env.orgRegion }); // Set your preferred region
+    const pathPrefix = "/infra/";
+    const parameters = [];
+    let nextToken;
+
+    do {
+        const response = await ssmClient.send(new GetParametersByPathCommand({
+            Path: pathPrefix,
+            NextToken: nextToken
+        }));
+
+        if (response.Parameters) {
+            parameters.push(...response.Parameters);
+        }
+
+        nextToken = response.NextToken;
+
+    } while (nextToken);
+    const params = {}
+    parameters.forEach(p=>{ 
+        const k = p.Name.split('/')[p.Name.split('/').length-1]
+        params[k] = p.Value 
+    })
+    return params;
+}
+
+// APP PARAMS
+exports.listApps = async function(){
+    if (!process.env.orgRegion){ throw new Error('Region not set') }
+
+    const ssmClient = new SSMClient({ region: process.env.orgRegion }); // Set your preferred region
+    const pathPrefix = "/infra/apps/";
+    const parameters = [];
+    let nextToken;
+
+    do {
+        const response = await ssmClient.send(new GetParametersByPathCommand({
+            Path: pathPrefix,
+            NextToken: nextToken
+        }));
+
+        if (response.Parameters) {
+            parameters.push(...response.Parameters);
+        }
+
+        nextToken = response.NextToken;
+
+    } while (nextToken);
+    const params = parameters.map(p=>{ return JSON.parse(p.Value) })
+    return params;
+}
+
+exports.getApp = async function(appName){
+    if (!process.env.orgRegion){ throw new Error('Region not set') }
+    const app = await readParam(
+        `/infra/apps/${appName.toLowerCase()}`,
+        process.env.orgRegion
+    )
+    return app ? JSON.parse(app) : null;
+}
+
+exports.addApp = async function(appName,appType,stackKey,nodeV,pyV){
+    const appData = {
+        name: appName,
+        stack: appType,
+        nodeV: nodeV,
+        pyV: pyV,
+        stackKey: stackKey,
+        versions: {
+            // build,ami,updated
+        },
+        instances: []
+    }
+    const paramPath = `/infra/apps/${appName.toLowerCase()}`;
+    await writeParam(paramPath,JSON.stringify(appData),process.env.orgRegion);
+}
+
+// VERSION PARAMS
+exports.updateAppV = async function(appName,version,vParams){
+    if (!process.env.orgRegion){ throw new Error('Region not set') }
+    if (!vParams.baseAMI_Name || !vParams.baseAMI_Id || !vParams.updated){ throw new Error('Missing version param' + vParams)}
+    const appKey = `/infra/apps/${appName.toLowerCase()}`
+    const appStr = await readParam(appKey,process.env.orgRegion);
+    const app = JSON.parse(appStr);
+
+    app.versions[version] = vParams;
+    await writeParam(appKey,JSON.stringify(app),process.env.orgRegion);
+}
+
+// INSTANCE PARAMS
+exports.addInstance = async function(appName,instanceName,params){
+    if (!process.env.orgRegion){ throw new Error('Region not set') }
+    const appKey = `/infra/apps/${appName.toLowerCase()}`
+    const appStr = await readParam(appKey,process.env.orgRegion);
+    const app = JSON.parse(appStr);
+
+    const ei = app.instances.find(ins=>{ return ins.name.toLowerCase() == instanceName.toLowerCase()});
+    if (ei){
+        throw new Error('Instance exists')
+    }
+    app.instances.push(params);
+    await writeParam(appKey,JSON.stringify(app),process.env.orgRegion)
+}
+
+exports.editInstance = async function(appName,instanceName,version,cfParams){
+    if (!process.env.orgRegion){ throw new Error('Region not set') }
+    const appKey = `/infra/apps/${appName.toLowerCase()}`
+    const appStr = await readParam(appKey,process.env.orgRegion);
+    const app = JSON.parse(appStr);
+
+    const ei = app.instances.find(ins=>{ return ins.name.toLowerCase() == instanceName.toLowerCase()});
+    if (!ei){ throw new Error('Instance not found') }
+    ei.version = version;
+    ei.cfParams = cfParams;
+    await writeParam(appKey,JSON.stringify(app),process.env.orgRegion)
+}
+
+exports.deleteInstance = async function(appName,instanceName){
+    if (!process.env.orgRegion){ throw new Error('Region not set') }
+    const appKey = `/infra/apps/${appName.toLowerCase()}`
+    const appStr = await readParam(appKey,process.env.orgRegion);
+    const app = JSON.parse(appStr);
+
+    const ei = app.instances.find(ins=>{ return ins.name.toLowerCase() == instanceName.toLowerCase()});
+    if (!ei){ throw new Error('Instance not found') }
+    app.instances = app.instances.filter(ins=>{ return ins.name.toLowerCase() !== instanceName.toLowerCase()});
+    await writeParam(appKey,JSON.stringify(app),process.env.orgRegion)
+}
+
+
+
+
+
+//////////////////////
+async function writeParam(name,value,region){
+    const ssmClient = new SSMClient({ region }); // specify the appropriate AWS region
+    if (value.length > 1000){
+        console.log('WARNING: Long parameter ' + value.length)
+    }
+    // Creating the command object with the parameter details
+    const command = new PutParameterCommand({
+        Name: name,
+        Value: value,
+        Type: 'String', // Specify the parameter type: 'String', 'StringList', or 'SecureString'
+        Overwrite: true, // Specify whether to overwrite an existing parameter
+    });
+
+    const response = await ssmClient.send(command);
+    return true; 
+}
+
+async function readParam(name,region){
+    const ssmClient = new SSMClient({ region });
+
+    // Create a command object with the parameter name
+    const command = new GetParameterCommand({
+        Name: name,
+        WithDecryption: true
+    });
+    
+    try {
+        // Send the command to SSM and wait for the result
+        const response = await ssmClient.send(command);
+        return response.Parameter.Value;
+    } catch (error) {
+        // Handle any errors
+        if (/ParameterNotFound/.test(error)){
+            return null;
+        } else {
+            throw error;
+        }
+    }
+}

package/commands/helpers/s3.js

@@ -0,0 +1,68 @@
+const { S3Client,PutObjectCommand,CopyObjectCommand,HeadObjectCommand } = require("@aws-sdk/client-s3");
+const fs = require('fs');
+
+
+exports.uploadInfraFile = async function(fileKey,localPath){
+    const s3Path = fileKey;
+    if (!fs.existsSync(localPath)){
+        throw new Error('File does not exist:' + localPath)
+    }
+    const fileStream = fs.createReadStream(localPath);
+    // Upload Stack
+    const client = new S3Client({region: process.env.orgRegion});
+    const input = {
+        Body: fileStream,
+        Bucket: process.env.orgBucket,
+        Key: s3Path.toLowerCase()
+    };
+    const poCommand = new PutObjectCommand(input);
+    const poResponse = await client.send(poCommand);
+    return poResponse;
+}
+
+exports.uploadInfraText = async function(fileKey,fileText){
+    // Upload Stack
+    const client = new S3Client({region: process.env.orgRegion});
+    const input = {
+        Body: fileText,
+        Bucket: process.env.orgBucket,
+        Key: fileKey.toLowerCase()
+    };
+    const poCommand = new PutObjectCommand(input);
+    const poResponse = await client.send(poCommand);
+    return poResponse;
+}
+
+exports.infraFileExists = async function(fileKey){
+    const client = new S3Client({region: process.env.orgRegion});
+    
+    const input = {
+        Bucket: process.env.orgBucket,
+        Key: fileKey.toLowerCase()
+    };
+
+    const command = new HeadObjectCommand(input)
+    try{
+        const response = await client.send(command);
+        return true;
+    } catch (e){
+        if (/NotFound/.test(e)){
+            return false;
+        } else {
+            console.log('Uncaught Error:',e)
+            throw e;
+        }
+    }
+}
+
+
+exports.copyInfraFile = async function(srcKey,destKey){
+    const client = new S3Client({ region: process.env.orgRegion });
+    const params = {
+        Bucket: process.env.orgBucket,
+        CopySource: `${process.env.orgBucket}/${srcKey}`,
+        Key: destKey.toLowerCase(),
+    };
+    await client.send(new CopyObjectCommand(params));
+    return true;
+}