ASG Suspend

README.md

@@ -34,6 +34,7 @@ Edit [serverless.yml](serverless.yml) where you can adjust
 - `hammertime:canttouchthis`: Will prevent hammertime from starting or stopping this asset in all cases.
 - `hammertime:canttouchthisbetween`: Will prevent hammertime from starting or stopping the asset between a given time range specified in the value of the tag. The expected format for the value is `{datetime} and {datetime}` For example: A value of `2017-05-06 and 2017-06-06` prevents hammertime from affecting this asset between the mentioned dates. The datetimes should be a valid ISO-8601 string.
 - `hammertime:canttouchthisbefore`: Will prevent hammertime from affecting the asset before a specific datetime represented in the value field of the tag. The datetime should be a valid ISO-8601 string. For example: A value of `2017-05-06` will ensure the given asset is not touched before the given date.
+- `hammertime:asgsuspend`: (ASG only) Will suspend all processes on the tagged ASG and shutdown ec2 instances attached to ASG (this is instead of the default behaviour of setting desired instance count to 0, which terminates all ec2 instances).
 
 `start-hammertime` will query the tags left by `stop-hammertime` and return the instances and ASGs to their previous status.
 

package.json

@@ -20,8 +20,9 @@
   "author": "nib",
   "license": "MIT",
   "dependencies": {
+    "aws-sdk": "^2.7.19",
+    "handlebars": "^4.5.3",
     "@babel/register": "^7.6.2",
-    "aws-sdk": "^2.610.0",
     "luxon": "^1.11.4",
     "moment": "^2.22.1",
     "nyc": "^14.1.1",
@@ -39,14 +40,15 @@
     "babel-register": "^6.26.0",
     "chai": "^3.5.0",
     "codecov": "^3.6.5",
-    "eslint": "^4.18.2",
-    "eslint-config-airbnb": "^14.1.0",
+    "eslint": "^8.2.0",
+    "eslint-config-airbnb": "^19.0.4",
     "eslint-plugin-chai-expect": "^1.1.1",
     "eslint-plugin-chai-friendly": "^0.3.6",
     "eslint-plugin-import": "^2.2.0",
-    "eslint-plugin-jsx-a11y": "^3.0.2",
-    "eslint-plugin-mocha": "^4.9.0",
-    "eslint-plugin-react": "^6.9.0",
+    "eslint-plugin-jsx-a11y": "^6.7.1",
+    "eslint-plugin-mocha": "^10.1.0",
+    "eslint-plugin-react": "^7.32.2",
+    "istanbul": "^0.4.5",
     "mocha": "^6.2.1"
   }
 }

serverless.yml

@@ -1,7 +1,7 @@
 service: hammertime
 provider:
   name: aws
-  runtime: nodejs12.x
+  runtime: nodejs14.x
   memorySize: 128
   stage: '${env:SLICE}'
   region: '${env:AWS_REGION}'
@@ -24,6 +24,9 @@ provider:
         - 'autoscaling:DeleteTags'
         - 'autoscaling:DescribeAutoScalingGroups'
         - 'autoscaling:UpdateAutoScalingGroup'
+        - 'autoscaling:SuspendProcesses'
+        - 'autoscaling:ResumeProcesses'
+        - 'kms:CreateGrant'
         - 'ecs:ListClusters'
         - 'ecs:ListServices'
         - 'ecs:DescribeServices'
@@ -47,9 +50,9 @@ provider:
 functions:
   stop-hammertime:
     handler: hammertime.stop
-    timeout: 180
+    timeout: 900
     events: ${file(./dist/events.js):stop}
   start-hammertime:
     handler: hammertime.start
-    timeout: 180
+    timeout: 900
     events: ${file(./dist/events.js):start}

src/asgs/listASGsToResume.js

@@ -0,0 +1,32 @@
+const hasTag = require("../tags/hasTag");
+const listTargetASGs = require("./listTargetASGs");
+const canITouchThis = require("../tags/canITouchThis");
+const hasTagValue = require("../tags/hasTagValue");
+
+function resumeableASG(application) {
+  return function suspendableASGFilter(asg) {
+    if (application === "all") {
+      return (
+        hasTag(asg.Tags, "stop:hammertime") &&
+        hasTag(asg.Tags, "hammertime:asgsuspend") &&
+        canITouchThis(asg.Tags)
+      );
+    }
+    return (
+      hasTag(asg.Tags, "stop:hammertime") &&
+      hasTag(asg.Tags, "hammertime:asgsuspend") &&
+      canITouchThis(asg.Tags) &&
+      hasTag(asg.Tags, "Application") &&
+      hasTagValue(asg.Tags, "Application", application)
+    );
+  };
+}
+
+function listASGsToResume(currentOperatingTimezone, application) {
+  return listTargetASGs({
+    filter: resumeableASG(application),
+    currentOperatingTimezone,
+  });
+}
+
+module.exports = listASGsToResume;

src/asgs/listASGsToStart.js

@@ -1,13 +1,32 @@
 const hasTag = require("../tags/hasTag");
 const listTargetASGs = require("./listTargetASGs");
 const canITouchThis = require("../tags/canITouchThis");
+const hasTagValue = require("../tags/hasTagValue");
 
-function startableASG(asg) {
-  return hasTag(asg.Tags, "stop:hammertime") && canITouchThis(asg.Tags);
+function startableASG(application) {
+  return function startableASGFilter(asg) {
+    if (application === "all") {
+      return (
+        hasTag(asg.Tags, "stop:hammertime") &&
+        !hasTag(asg.Tags, "hammertime:asgsuspend") &&
+        canITouchThis(asg.Tags)
+      );
+    }
+    return (
+      hasTag(asg.Tags, "stop:hammertime") &&
+      !hasTag(asg.Tags, "hammertime:asgsuspend") &&
+      canITouchThis(asg.Tags) &&
+      hasTag(asg.Tags, "Application") &&
+      hasTagValue(asg.Tags, "Application", application)
+    );
+  };
 }
 
-function listASGsToStart(currentOperatingTimezone) {
-  return listTargetASGs({ filter: startableASG, currentOperatingTimezone });
+function listASGsToStart(currentOperatingTimezone, application) {
+  return listTargetASGs({
+    filter: startableASG(application),
+    currentOperatingTimezone,
+  });
 }
 
 module.exports = listASGsToStart;

src/asgs/listASGsToStop.js

@@ -1,13 +1,32 @@
 const hasTag = require("../tags/hasTag");
 const listTargetASGs = require("./listTargetASGs");
 const canITouchThis = require("../tags/canITouchThis");
+const hasTagValue = require("../tags/hasTagValue");
 
-function stoppableASG(asg) {
-  return !hasTag(asg.Tags, "stop:hammertime") && canITouchThis(asg.Tags);
+function stoppableASG(application) {
+  return function stoppableASGFilter(asg) {
+    if (application === "all") {
+      return (
+        !hasTag(asg.Tags, "stop:hammertime") &&
+        !hasTag(asg.Tags, "hammertime:asgsuspend") &&
+        canITouchThis(asg.Tags)
+      );
+    }
+    return (
+      !hasTag(asg.Tags, "stop:hammertime") &&
+      !hasTag(asg.Tags, "hammertime:asgsuspend") &&
+      canITouchThis(asg.Tags) &&
+      hasTag(asg.Tags, "Application") &&
+      hasTagValue(asg.Tags, "Application", application)
+    );
+  };
 }
 
-function listASGsToStop(currentOperatingTimezone) {
-  return listTargetASGs({ filter: stoppableASG, currentOperatingTimezone });
+function listASGsToStop(currentOperatingTimezone, application) {
+  return listTargetASGs({
+    filter: stoppableASG(application),
+    currentOperatingTimezone,
+  });
 }
 
 module.exports = listASGsToStop;

src/asgs/listASGsToSuspend.js

@@ -0,0 +1,32 @@
+const hasTag = require("../tags/hasTag");
+const hasTagValue = require("../tags/hasTagValue");
+const listTargetASGs = require("./listTargetASGs");
+const canITouchThis = require("../tags/canITouchThis");
+
+function suspendableASG(application) {
+  return function suspendableASGFilter(asg) {
+    if (application === "all") {
+      return (
+        !hasTag(asg.Tags, "stop:hammertime") &&
+        hasTag(asg.Tags, "hammertime:asgsuspend") &&
+        canITouchThis(asg.Tags)
+      );
+    }
+    return (
+      !hasTag(asg.Tags, "stop:hammertime") &&
+      hasTag(asg.Tags, "hammertime:asgsuspend") &&
+      canITouchThis(asg.Tags) &&
+      hasTag(asg.Tags, "Application") &&
+      hasTagValue(asg.Tags, "Application", application)
+    );
+  };
+}
+
+function listASGsToSuspend(currentOperatingTimezone, application) {
+  return listTargetASGs({
+    filter: suspendableASG(application),
+    currentOperatingTimezone,
+  });
+}
+
+module.exports = listASGsToSuspend;

src/asgs/listTargetASGs.js

@@ -1,5 +1,5 @@
-const AWS = require('aws-sdk');
-const isInOperatingTimezone = require('../operatingTimezone/isInOperatingTimezone');
+const AWS = require("aws-sdk");
+const isInOperatingTimezone = require("../operatingTimezone/isInOperatingTimezone");
 
 function getAllASGs() {
   const autoscaling = new AWS.AutoScaling();
@@ -10,22 +10,26 @@ function getAllASGs() {
 
     if (data.NextToken) {
       params.NextToken = data.NextToken;
-      return autoscaling.describeAutoScalingGroups(params)
+      return autoscaling
+        .describeAutoScalingGroups(params)
         .promise()
-        .then(res => followASGPages(combinedAsgs, res));
+        .then((res) => followASGPages(combinedAsgs, res));
     }
 
     return Promise.resolve(combinedAsgs);
   }
 
-  return autoscaling.describeAutoScalingGroups(params)
+  return autoscaling
+    .describeAutoScalingGroups(params)
     .promise()
-    .then(data => followASGPages([], data));
+    .then((data) => followASGPages([], data));
 }
 
 function isASGInCurrentOperatingTimezone(currentOperatingTimezone) {
-  const isInCurrentOperatingTimezone = isInOperatingTimezone(currentOperatingTimezone);
-  return asg => {
+  const isInCurrentOperatingTimezone = isInOperatingTimezone(
+    currentOperatingTimezone
+  );
+  return (asg) => {
     return isInCurrentOperatingTimezone(asg.Tags);
   };
 }
@@ -35,3 +39,4 @@ module.exports = function listTargetASGs({ filter, currentOperatingTimezone }) {
           .then(allASGs => allASGs.filter(filter)
                                   .filter(isASGInCurrentOperatingTimezone(currentOperatingTimezone)));
 };
+

src/asgs/resumeASGs.js

@@ -0,0 +1,20 @@
+const AWS = require('aws-sdk');
+const retryWhenThrottled = require('../utils/retryWhenThrottled');
+
+function resumeASGProcesses(asg) {
+  const autoscaling = new AWS.AutoScaling();
+  const params = {
+    AutoScalingGroupName: asg.AutoScalingGroupName,
+    ScalingProcesses: []
+  };
+
+  return retryWhenThrottled(() => autoscaling.resumeProcesses(params))
+    .then(() => asg);
+}
+
+function resumeASGs(asgs) {
+  const updatedASGs = asgs.map(asg => resumeASGProcesses(asg));
+  return Promise.all(updatedASGs);
+}
+
+module.exports = resumeASGs;

src/asgs/suspendASGs.js

@@ -0,0 +1,17 @@
+const AWS = require('aws-sdk');
+const retryWhenThrottled = require('../utils/retryWhenThrottled');
+
+function suspendASGProcesses(asg) {
+  const autoscaling = new AWS.AutoScaling();
+  const params = { AutoScalingGroupName: asg.AutoScalingGroupName };
+
+  return retryWhenThrottled(() => autoscaling.suspendProcesses(params))
+    .then(() => asg);
+}
+
+function suspendASGs(asgs) {
+  const updatedASGs = asgs.map(asg => suspendASGProcesses(asg));
+  return Promise.all(updatedASGs);
+}
+
+module.exports = suspendASGs;

src/asgs/tagSuspendedASGs.js

@@ -0,0 +1,22 @@
+const AWS = require('aws-sdk');
+const retryWhenThrottled = require('../utils/retryWhenThrottled');
+const createTag = require('../utils/createTag');
+
+function tagASG(asg) {
+  const autoscaling = new AWS.AutoScaling();
+  const params = {
+    Tags: [
+      createTag('stop:hammertime', asg.AutoScalingGroupName, 'auto-scaling-group', new Date().toISOString()),
+    ],
+  };
+
+  return retryWhenThrottled(() => autoscaling.createOrUpdateTags(params))
+    .then(() => asg);
+}
+
+function tagSuspendedASGs(asgs) {
+  const taggedASGs = asgs.map(asg => tagASG(asg));
+  return Promise.all(taggedASGs);
+}
+
+module.exports = tagSuspendedASGs;

src/asgs/untagASGs.js

@@ -20,4 +20,4 @@ function untagASGs(asgs) {
   return Promise.all(untaggedASGs);
 }
 
-module.exports = untagASGs;
+module.exports = untagASGs;

src/asgs/untagResumedASGs.js

@@ -0,0 +1,29 @@
+const AWS = require("aws-sdk");
+const retryWhenThrottled = require("../utils/retryWhenThrottled");
+// const createTag = require('../utils/createTag');
+const deleteTagParams = require("../utils/deleteTagParams");
+
+function untagASG(asg) {
+  const autoscaling = new AWS.AutoScaling();
+  const params = {
+    Tags: [
+      deleteTagParams(
+        "stop:hammertime",
+        asg.AutoScalingGroupName,
+        "auto-scaling-group"
+      ),
+    ],
+  };
+  return retryWhenThrottled(() => autoscaling.deleteTags(params)).then(
+    () => asg
+  );
+}
+
+function untagResumedASGs(asgs) {
+  const untaggedASGs = asgs.map((asg) => untagASG(asg));
+  return Promise.all(untaggedASGs).catch((error) => {
+    console.log("untagResumedASGs - Broken Promise here:", error);
+  });
+}
+
+module.exports = untagResumedASGs;