feat(aws-codedeploy): add instance tag filter support for server Deployment Groups

packages/@aws-cdk/aws-codedeploy/README.md

@@ -32,6 +32,27 @@ const deploymentGroup = new codedeploy.ServerDeploymentGroup(this, 'CodeDeployDe
     // adds User Data that installs the CodeDeploy agent on your auto-scaling groups hosts
     // default: true
     installAgent: true,
+    // adds EC2 instances matching tags
+    ec2InstanceTags: new codedeploy.InstanceTagSet(
+        {
+            // any instance with tags satisfying
+            // key1=v1 or key1=v2 or key2 (any value) or value v3 (any key)
+            // will match this group
+            'key1': ['v1', 'v2'],
+            'key2': [],
+            '': ['v3'],
+        },
+    ),
+    // adds on-premise instances matching tags
+    onPremiseInstanceTags: new codedeploy.InstanceTagSet(
+        // only instances with tags (key1=v1 or key1=v2) AND key2=v3 will match this set
+        {
+            'key1': ['v1', 'v2'],
+        },
+        {
+            'key2': ['v3'],
+        },
+    ),
 });
 ```
 

packages/@aws-cdk/aws-codedeploy/lib/deployment-group.ts

@@ -99,6 +99,41 @@ class ImportedServerDeploymentGroupRef extends ServerDeploymentGroupRef {
   }
 }
 
+/**
+ * Represents a group of instance tags.
+ * An instance will match a group if it has a tag matching
+ * any of the group's tags by key and any of the provided values -
+ * in other words, tag groups follow 'or' semantics.
+ * If the value for a given key is an empty array,
+ * an instance will match when it has a tag with the given key,
+ * regardless of the value.
+ * If the key is an empty string, any tag,
+ * regardless of its key, with any of the given values, will match.
+ */
+export type InstanceTagGroup = {[key: string]: string[]};
+
+/**
+ * Represents a set of instance tag groups.
+ * An instance will match a set if it matches all of the groups in the set -
+ * in other words, sets follow 'and' semantics.
+ * You can have a maximum of 3 tag groups inside a set.
+ */
+export class InstanceTagSet {
+  private readonly _instanceTagGroups: InstanceTagGroup[];
+
+  constructor(...instanceTagGroups: InstanceTagGroup[]) {
+    if (instanceTagGroups.length > 3) {
+      throw new Error('An instance tag set can have a maximum of 3 instance tag groups, ' +
+        `but ${instanceTagGroups.length} were provided`);
+    }
+    this._instanceTagGroups = instanceTagGroups;
+  }
+
+  public get instanceTagGroups(): InstanceTagGroup[] {
+    return this._instanceTagGroups.slice();
+  }
+}
+
 /**
  * Construction properties for {@link ServerDeploymentGroup}.
  */
@@ -153,6 +188,20 @@ export interface ServerDeploymentGroupProps {
    * @default the Deployment Group will not have a load balancer defined
    */
   loadBalancer?: codedeploylb.ILoadBalancer;
+
+  /*
+   * All EC2 instances matching the given set of tags when a deployment occurs will be added to this Deployment Group.
+   *
+   * @default no additional EC2 instances will be added to the Deployment Group
+   */
+  ec2InstanceTags?: InstanceTagSet;
+
+  /**
+   * All on-premise instances matching the given set of tags when a deployment occurs will be added to this Deployment Group.
+   *
+   * @default no additional on-premise instances will be added to the Deployment Group
+   */
+  onPremiseInstanceTags?: InstanceTagSet;
 }
 
 /**
@@ -204,6 +253,8 @@ export class ServerDeploymentGroup extends ServerDeploymentGroupRef {
         : {
           deploymentOption: 'WITH_TRAFFIC_CONTROL',
         },
+      ec2TagSet: this.ec2TagSet(props.ec2InstanceTags),
+      onPremisesTagSet: this.onPremiseTagSet(props.onPremiseInstanceTags),
     });
 
     this.deploymentGroupName = resource.deploymentGroupName;
@@ -284,6 +335,75 @@ export class ServerDeploymentGroup extends ServerDeploymentGroupRef {
         };
     }
   }
+
+  private ec2TagSet(tagSet?: InstanceTagSet):
+      cloudformation.DeploymentGroupResource.EC2TagSetProperty | undefined {
+    if (!tagSet || tagSet.instanceTagGroups.length === 0) {
+      return undefined;
+    }
+
+    return {
+      ec2TagSetList: tagSet.instanceTagGroups.map(tagGroup => {
+        return {
+          ec2TagGroup: this.tagGroup2TagsArray(tagGroup) as
+            cloudformation.DeploymentGroupResource.EC2TagFilterProperty[],
+        };
+      }),
+    };
+  }
+
+  private onPremiseTagSet(tagSet?: InstanceTagSet):
+      cloudformation.DeploymentGroupResource.OnPremisesTagSetProperty | undefined {
+    if (!tagSet || tagSet.instanceTagGroups.length === 0) {
+      return undefined;
+    }
+
+    return {
+      onPremisesTagSetList: tagSet.instanceTagGroups.map(tagGroup => {
+        return {
+          onPremisesTagGroup: this.tagGroup2TagsArray(tagGroup) as
+            cloudformation.DeploymentGroupResource.TagFilterProperty[],
+        };
+      }),
+    };
+  }
+
+  private tagGroup2TagsArray(tagGroup: InstanceTagGroup): any[] {
+    const tagsInGroup = [];
+    for (const tagKey in tagGroup) {
+      if (tagGroup.hasOwnProperty(tagKey)) {
+        const tagValues = tagGroup[tagKey];
+        if (tagKey.length > 0) {
+          if (tagValues.length > 0) {
+            for (const tagValue of tagValues) {
+              tagsInGroup.push({
+                key: tagKey,
+                value: tagValue,
+                type: 'KEY_AND_VALUE',
+              });
+            }
+          } else {
+            tagsInGroup.push({
+              key: tagKey,
+              type: 'KEY_ONLY',
+            });
+          }
+        } else {
+          if (tagValues.length > 0) {
+            for (const tagValue of tagValues) {
+              tagsInGroup.push({
+                value: tagValue,
+                type: 'VALUE_ONLY',
+              });
+            }
+          } else {
+            throw new Error('Cannot specify both an empty key and no values for an instance tag filter');
+          }
+        }
+      }
+    }
+    return tagsInGroup;
+  }
 }
 
 function deploymentGroupName2Arn(applicationName: string, deploymentGroupName: string): string {

packages/@aws-cdk/aws-codedeploy/test/test.deployment-group.ts

@@ -157,5 +157,112 @@ export = {
 
       test.done();
     },
+
+    'can be created with a single EC2 instance tag set with a single or no value'(test: Test) {
+      const stack = new cdk.Stack();
+
+      new codedeploy.ServerDeploymentGroup(stack, 'DeploymentGroup', {
+        ec2InstanceTags: new codedeploy.InstanceTagSet(
+          {
+            'some-key': ['some-value'],
+            'other-key': [],
+          },
+        ),
+      });
+
+      expect(stack).to(haveResource('AWS::CodeDeploy::DeploymentGroup', {
+        "Ec2TagSet": {
+          "Ec2TagSetList": [
+            {
+              "Ec2TagGroup": [
+                {
+                  "Key": "some-key",
+                  "Value": "some-value",
+                  "Type": "KEY_AND_VALUE",
+                },
+                {
+                  "Key": "other-key",
+                  "Type": "KEY_ONLY",
+                },
+              ],
+            },
+          ],
+        },
+      }));
+
+      test.done();
+    },
+
+    'can be created with two on-premise instance tag sets with multiple values or without a key'(test: Test) {
+      const stack = new cdk.Stack();
+
+      new codedeploy.ServerDeploymentGroup(stack, 'DeploymentGroup', {
+        onPremiseInstanceTags: new codedeploy.InstanceTagSet(
+          {
+            'some-key': ['some-value', 'another-value'],
+          },
+          {
+            '': ['keyless-value'],
+          },
+        ),
+      });
+
+      expect(stack).to(haveResource('AWS::CodeDeploy::DeploymentGroup', {
+        "OnPremisesTagSet": {
+          "OnPremisesTagSetList": [
+            {
+              "OnPremisesTagGroup": [
+                {
+                  "Key": "some-key",
+                  "Value": "some-value",
+                  "Type": "KEY_AND_VALUE",
+                },
+                {
+                  "Key": "some-key",
+                  "Value": "another-value",
+                  "Type": "KEY_AND_VALUE",
+                },
+              ],
+            },
+            {
+              "OnPremisesTagGroup": [
+                {
+                  "Value": "keyless-value",
+                  "Type": "VALUE_ONLY",
+                },
+              ],
+            },
+          ],
+        },
+      }));
+
+      test.done();
+    },
+
+    'cannot be created with an instance tag set containing a keyless, valueless filter'(test: Test) {
+      const stack = new cdk.Stack();
+
+      test.throws(() => {
+        new codedeploy.ServerDeploymentGroup(stack, 'DeploymentGroup', {
+          onPremiseInstanceTags: new codedeploy.InstanceTagSet({
+            '': [],
+          }),
+        });
+      });
+
+      test.done();
+    },
+
+    'cannot be created with an instance tag set containing 4 instance tag groups'(test: Test) {
+      const stack = new cdk.Stack();
+
+      test.throws(() => {
+        new codedeploy.ServerDeploymentGroup(stack, 'DeploymentGroup', {
+          onPremiseInstanceTags: new codedeploy.InstanceTagSet({}, {}, {}, {}),
+        });
+      }, /3/);
+
+      test.done();
+    },
   },
 };