cloudmason 0.0.1 → 1.0.1

package/commands/helpers/cf.js

@@ -1,118 +1,182 @@
-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;
-    }
+const { CloudFormationClient,ListStackResourcesCommand, CreateStackCommand,UpdateStackCommand, DeleteStackCommand, ValidateTemplateCommand,DescribeStacksCommand } = require('@aws-sdk/client-cloudformation');
+
+const fs = require('fs');
+const path = require('path')
+
+
+exports.deployOrgStack = async function(region,params){
+    // Read Stack
+    const stackPath = path.resolve(__dirname,'stacks',`infra.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');
+
+    // Build Params
+    const cfParams = Object.keys(params).map(k=>{ return { ParameterKey: k, ParameterValue: params[k] } })
+    
+    // Deploy Stack
+    const client = new CloudFormationClient({ region });
+    const input = {
+        StackName: `CoreInfra`,
+        TemplateBody: stackYML,
+        Capabilities: [
+            "CAPABILITY_IAM" || "CAPABILITY_NAMED_IAM" || "CAPABILITY_AUTO_EXPAND",
+        ],
+        Parameters: cfParams,
+        Tags: [{ Key: 'purpose', Value: 'infra' }]
+    };
+    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,
+        OnFailure: 'DELETE',
+        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] } })
+    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 response.StackId;
+}
+
+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.stackStatus = async function(stackName, region) {
+    const client = new CloudFormationClient({ region }); // Replace with your region
+    try {
+        const command = new DescribeStacksCommand({ StackName: stackName });
+        const response = await client.send(command);
+
+        if (response.Stacks && response.Stacks.length > 0) {
+            const stack = response.Stacks[0];
+            const status = stack.StackStatus;
+            
+            // Check if status indicates failure
+            if (status.includes("FAIL") || status === "DELETE_FAILED") {
+                return {
+                    status: status,
+                    ok: false,
+                    failureReason: stack.StackStatusReason
+                };
+            } else if (status.includes("CREATE_IN_PROGRESS")){
+                return {
+                    status: status,
+                    ok: null
+                };
+            } else {
+                return {
+                    status: status,
+                    ok: true
+                };
+            }
+        } else {
+            throw new Error("No stack found with the specified name.");
+        }
+    } catch (error) {
+        console.error("Error fetching CloudFormation stack status:", error);
+        throw error;
+    }
+}
+
+exports.getStackResource = async function(resourceType,stackName,region){
+    const res = {
+        's3': "AWS::S3::Bucket",
+        'asg': "AWS::AutoScaling::AutoScalingGroup",
+        'ec2': "AWS::EC2::Instance"
+    }[resourceType];
+    const client = new CloudFormationClient({ region }); // specify your region
+
+    try {
+        const command = new ListStackResourcesCommand({ StackName: stackName });
+        const response = await client.send(command);
+
+        // Filter the results to find the Auto Scaling group
+        const asgResource = response.StackResourceSummaries.find(resource => resource.ResourceType === res);
+        
+        if (asgResource) {
+            return asgResource.PhysicalResourceId;
+        } else {
+            throw new Error("Auto Scaling Group not found in the specified stack.");
+        }
+    } catch (error) {
+        console.error("Error fetching Auto Scaling Group ID:", error);
+        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/common.js

@@ -0,0 +1,82 @@
+const Params = require('./params');
+const EC2 = require('./ec2');
+
+
+exports.prune_amis = async function(appName,version,region,removeLatest){
+    // Removal Func
+    const removeUnused = async function(aN,v,r){
+        const app = await Params.getApp(appName);
+        const latestBuildAMI = app.versions[version].baseAMI_Name;
+        
+        // All AMIs
+        const AMIs = await EC2.listAMIs(`${appName}-v${version}`,region);
+        // console.log(`Found ${AMIs.length} AMIs in ${region}`)
+
+        // Used AMIs
+        const regionInstances = app.instances.filter(i=>{ return i.region === region });
+        const usedAMIs = regionInstances.map(i=>{ return i.amiName });
+        // console.log(`Found ${usedAMIs.length} used AMIs in ${region}`)
+
+
+        // Remove Unused AMI from Target Region
+        let unusedAMIs = AMIs.filter(ami=>{ return !usedAMIs.includes(ami.Name) });
+        if (removeLatest !== true){
+            console.log('Retaining latest build ', latestBuildAMI, 'in ', region)
+            unusedAMIs = unusedAMIs.filter(ami=>{ return ami.Name !== latestBuildAMI })
+        } else {
+            console.log('Removing latest build ', latestBuildAMI, 'in ', region)
+        }
+        // console.log(`Found ${unusedAMIs.length} unused AMIs in ${region}`);
+
+        for (const ami of unusedAMIs){
+            console.log(`Deregistering ${ami.Name} in ${region}`)
+            await EC2.deleteAMI(ami.ImageId,region);
+        }
+    }
+    // Remove from target region
+    await removeUnused(appName,version,region);
+    // Remove from org region
+    await removeUnused(appName,version,process.env.orgRegion);
+}
+
+exports.remove_app_amis = async function(appName,region){
+    // All AMIs
+    const AMIs = await EC2.listAMIs(`${appName}-v`,region);
+    for (const ami of AMIs){
+        console.log(`Deregistering ${ami.Name} in ${region}`)
+        await EC2.deleteAMI(ami.ImageId,region);
+    }
+}
+
+exports.sleep = async function(s){
+    s = s*1000;
+    return new Promise(function (resolve, reject) {
+        setTimeout(function () { resolve(true);
+        }, s);
+    });
+}
+
+exports.formatDate = function(utcMillis){
+    let date;
+    if (typeof(utcMillis) === 'string'){
+        date = new Date(utcMillis);
+    } else {
+        date = new Date(utcMillis);
+    }
+
+    // Extracting individual components in local time
+    const month = date.getMonth() + 1; // getMonth returns month from 0-11
+    const day = date.getDate();
+    const year = date.getFullYear().toString().substr(-2); // Get last two digits of the year
+    const hours = date.getHours();
+    const minutes = date.getMinutes();
+
+    // Formatting each component to ensure two digits
+    const formattedMonth = month.toString().padStart(2, '0');
+    const formattedDay = day.toString().padStart(2, '0');
+    const formattedHours = hours.toString().padStart(2, '0');
+    const formattedMinutes = minutes.toString().padStart(2, '0');
+
+    // Constructing the final string
+    return `${formattedMonth}-${formattedDay}-${year} ${formattedHours}:${formattedMinutes}`;
+}

package/commands/helpers/ec2.js

@@ -1,40 +1,154 @@
-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;
-}
+const { EC2Client, GetConsoleOutputCommand, RunInstancesCommand,CreateImageCommand,TerminateInstancesCommand,DescribeInstanceStatusCommand,DeregisterImageCommand,DescribeImagesCommand,CopyImageCommand } = require("@aws-sdk/client-ec2");
+const { AutoScalingClient, DescribeAutoScalingGroupsCommand } = require("@aws-sdk/client-auto-scaling");
+
+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.awsLinuxAMI = function(region){
+    const ami = {
+        "us-east-1": "ami-0759f51a90924c166",
+        "us-east-2": "ami-048e636f368eb3006",
+        "us-west-1": "ami-0a07b0077b66673f1",
+        "us-west-2": "ami-0c00eacddaea828c6",
+        "ap-east-1": "",
+        "ap-south-1": "",
+        "ap-northeast-2": "",
+        "ap-southeast-1": "",
+        "ap-southeast-2": "",
+        "ap-northeast-1": "",
+        "ca-central-1": "ami-02d34aedb8fa9c346",
+        "eu-central-1": "",
+        "eu-west-1": "",
+        "eu-west-2": "",
+        "eu-west-3": "",
+        "eu-north-1": "",
+        "me-south-1": "",
+        "sa-east-1": "ami-0f4e579ad17e32ab7"
+    }[region];
+    if (!ami){ throw 'No AMI found for region ' + region };
+    return ami;
+}
+
+exports.listAMIs = async function(image_name,region){
+    const client = new EC2Client({ region });
+    image_name = image_name + '*';
+    const input = { // DescribeImagesRequest
+        Filters: [ // FilterList
+            { // Filter
+                Name: "name",
+                Values: [ // ValueStringList
+                    image_name,
+                ],
+            }
+        ],
+        Owners: [ // OwnerStringList
+            "self",
+        ],
+        IncludeDeprecated: false,
+        IncludeDisabled: false,
+        DryRun: false,
+        MaxResults: 6
+    };
+    const command = new DescribeImagesCommand(input);
+    const response = await client.send(command);
+    if (response.Images){
+        return response.Images.map(i=>{ return { ImageId: i.ImageId, Name: i.Name } });
+    } else {
+        return [];
+    }
+}
+
+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;
+}
+
+exports.deleteAMI = async function(image_id,region){
+    const client = new EC2Client({ region });
+    const input = {
+        ImageId: image_id,
+        DryRun: false
+    };
+    const command = new DeregisterImageCommand(input);
+    const response = await client.send(command);
+    return response;
+}
+
+exports.checkAMIStatus = async function(image_id,region){
+    const client = new EC2Client({ region }); // Replace 'your-region' with your AWS region
+
+    const command = new DescribeImagesCommand({
+        ImageIds: [image_id]
+    });
+
+    const response = await client.send(command);
+    if (response.Images && response.Images.length > 0 && response.Images[0].State.toLowerCase() === 'available') {
+        return true;
+    } else {
+        return false;
+    }
+
+}
+
+exports.getConsoleOutput = async function(autoScalingGroupName,region,latest=true){
+    const autoScalingClient = new AutoScalingClient({ region }); // specify your region
+    const ec2Client = new EC2Client({ region });
+
+    try {
+        // Get instance IDs from Auto Scaling group
+        const describeGroupsCommand = new DescribeAutoScalingGroupsCommand({
+            AutoScalingGroupNames: [autoScalingGroupName]
+        });
+        const groupResponse = await autoScalingClient.send(describeGroupsCommand);
+        const instances = groupResponse.AutoScalingGroups[0].Instances;
+        const instanceIds = instances.map(instance => instance.InstanceId);
+
+        // Get console output for each instance
+        const consoleOutput = [];
+        
+        for (let i=0;i<instanceIds.length;i++){
+            const consoleOutputCommand = new GetConsoleOutputCommand({ InstanceId: instanceIds[i],Latest: latest });
+            const outputResponse = await ec2Client.send(consoleOutputCommand);
+            const output = outputResponse.Output ? Buffer.from(outputResponse.Output, "base64").toString("ascii") : '';
+            consoleOutput.push({
+                instanceId: instanceIds[i],
+                output: output
+            });
+        }
+        return consoleOutput;
+    } catch (error) {
+        console.error("Error fetching EC2 console outputs:", error);
+        throw error;
+    }
+}