ExecuteChangeSet handles empty change sets (#438)

ExecuteChangeSet can now optionally handle empty change sets in two ways:
* Skip execution of the change set, so the ExecuteChangeSet step does not fail
* All of the above, plus deletion of the empty change set

Co-authored-by: Matthew Pfluger <matthew.pfluger@kcc.com>

Author: pflugs30

.changes/next-release/Feature-ccc4596d-a59c-4d5a-9ff5-2907f1bea3dd.json

@@ -0,0 +1,4 @@
+{
+	"type": "Feature",
+	"description": "Skips execution of and then deletes an empty change set"
+}

src/lib/cloudformationutils.ts

@@ -148,3 +148,23 @@ export async function testChangeSetExists(
 
     return false
 }
+
+// If there were no changes, a validation error is thrown which we want to suppress
+// (issue #28) instead of erroring out and failing the build. The only way to determine
+// this is to inspect the message in conjunction with the status code, and over time
+// there has been some variance in service behavior based on how we attempted to make the
+// change. So now detect either of the errors, and for either if the message indicates
+// a no-op.
+export function isNoWorkToDoValidationError(errCodeOrStatus?: string, errMessage?: string): boolean {
+    const knownNoOpErrorMessages = [
+        /^No updates are to be performed./,
+        /^The submitted information didn't contain changes./
+    ]
+
+    errCodeOrStatus = errCodeOrStatus || ''
+    const message = errMessage || ''
+    return (
+        (errCodeOrStatus.search(/ValidationError/) !== -1 || errCodeOrStatus.search(/FAILED/) !== -1) &&
+        knownNoOpErrorMessages.some(element => message.search(element) !== -1)
+    )
+}

src/tasks/CloudFormationCreateOrUpdateStack/TaskOperations.ts

@@ -4,10 +4,12 @@
  */
 
 import CloudFormation = require('aws-sdk/clients/cloudformation')
+import { AWSError } from 'aws-sdk/lib/error'
 import S3 = require('aws-sdk/clients/s3')
 import * as tl from 'azure-pipelines-task-lib/task'
 import {
     captureStackOutputs,
+    isNoWorkToDoValidationError,
     setWaiterParams,
     testChangeSetExists,
     testStackExists,
@@ -222,15 +224,20 @@ export class TaskOperations {
         }
 
         try {
-            const response: CloudFormation.UpdateStackOutput = await this.cloudFormationClient
-                .updateStack(request)
-                .promise()
+            await this.cloudFormationClient.updateStack(request).promise()
             await waitForStackUpdate(this.cloudFormationClient, request.StackName)
         } catch (err) {
-            if (!this.isNoWorkToDoValidationError(err.code, err.message)) {
-                console.error(tl.loc('StackUpdateRequestFailed', (err as Error).message), err)
-                throw err
+            const e = <AWSError>err
+            if (isNoWorkToDoValidationError(e.code, e.message)) {
+                if (this.taskParameters.warnWhenNoWorkNeeded) {
+                    tl.warning(tl.loc('NoWorkToDo'))
+                }
+
+                return
             }
+
+            console.error(tl.loc('StackUpdateRequestFailed', e.message), err)
+            throw err
         }
     }
 
@@ -523,40 +530,6 @@ export class TaskOperations {
         return templateParameters
     }
 
-    // If there were no changes, a validation error is thrown which we want to suppress
-    // (issue #28) instead of erroring out and failing the build. The only way to determine
-    // this is to inspect the message in conjunction with the status code, and over time
-    // there has been some variance in service behavior based on how we attempted to make the
-    // change. So now detect either of the errors, and for either if the message indicates
-    // a no-op.
-    private isNoWorkToDoValidationError(errCodeOrStatus: string, errMessage: string): boolean {
-        let noWorkToDo = false
-        const knownNoOpErrorMessages = [
-            /^No updates are to be performed./,
-            /^The submitted information didn't contain changes./
-        ]
-
-        try {
-            if (errCodeOrStatus.search(/ValidationError/) !== -1 || errCodeOrStatus.search(/FAILED/) !== -1) {
-                knownNoOpErrorMessages.forEach(element => {
-                    if (errMessage.search(element) !== -1) {
-                        noWorkToDo = true
-                    }
-                })
-            }
-            if (noWorkToDo) {
-                if (this.taskParameters.warnWhenNoWorkNeeded) {
-                    tl.warning(tl.loc('NoWorkToDo'))
-                }
-
-                return true
-            }
-            // tslint:disable-next-line:no-empty
-        } catch (err) {}
-
-        return false
-    }
-
     private async waitForChangeSetCreation(changeSetName: string, stackName: string): Promise<boolean> {
         console.log(tl.loc('WaitingForChangeSetValidation', changeSetName, stackName))
         try {
@@ -572,11 +545,11 @@ export class TaskOperations {
             const response = await this.cloudFormationClient
                 .describeChangeSet({ ChangeSetName: changeSetName, StackName: stackName })
                 .promise()
-            if (
-                response.Status &&
-                response.StatusReason &&
-                this.isNoWorkToDoValidationError(response.Status, response.StatusReason)
-            ) {
+            if (isNoWorkToDoValidationError(response.Status, response.StatusReason)) {
+                if (this.taskParameters.warnWhenNoWorkNeeded) {
+                    tl.warning(tl.loc('NoWorkToDo'))
+                }
+
                 return false
             } else {
                 throw new Error(tl.loc('ChangeSetValidationFailed', stackName, changeSetName, (err as Error).message))

src/tasks/CloudFormationExecuteChangeSet/TaskOperations.ts

@@ -7,6 +7,7 @@ import CloudFormation = require('aws-sdk/clients/cloudformation')
 import * as tl from 'azure-pipelines-task-lib/task'
 import {
     captureStackOutputs,
+    isNoWorkToDoValidationError,
     testStackHasResources,
     waitForStackCreation,
     waitForStackUpdate
@@ -20,29 +21,50 @@ export class TaskOperations {
     ) {}
 
     public async execute(): Promise<void> {
-        const stackId = await this.verifyResourcesExist(
+        const changeSet = await this.verifyResourcesExist(
             this.taskParameters.changeSetName,
             this.taskParameters.stackName
         )
         let waitForUpdate = false
+        const stackId = changeSet.StackId || ''
         if (stackId) {
             waitForUpdate = await testStackHasResources(this.cloudFormationClient, this.taskParameters.stackName)
         }
 
-        console.log(tl.loc('ExecutingChangeSet', this.taskParameters.changeSetName, this.taskParameters.stackName))
-
         try {
-            await this.cloudFormationClient
-                .executeChangeSet({
-                    ChangeSetName: this.taskParameters.changeSetName,
-                    StackName: this.taskParameters.stackName
-                })
-                .promise()
+            if (
+                this.taskParameters.noFailOnEmptyChangeSet &&
+                isNoWorkToDoValidationError(changeSet.Status, changeSet.StatusReason)
+            ) {
+                console.log(tl.loc('ExecutionSkipped', this.taskParameters.changeSetName))
+
+                if (this.taskParameters.deleteEmptyChangeSet) {
+                    const request: CloudFormation.DeleteChangeSetInput = {
+                        ChangeSetName: this.taskParameters.changeSetName
+                    }
+                    if (this.taskParameters.stackName) {
+                        request.StackName = this.taskParameters.stackName
+                    }
 
-            if (waitForUpdate) {
-                await waitForStackUpdate(this.cloudFormationClient, this.taskParameters.stackName)
+                    await this.cloudFormationClient.deleteChangeSet(request).promise()
+                    console.log(tl.loc('DeletingChangeSet', this.taskParameters.changeSetName))
+                }
             } else {
-                await waitForStackCreation(this.cloudFormationClient, this.taskParameters.stackName)
+                console.log(
+                    tl.loc('ExecutingChangeSet', this.taskParameters.changeSetName, this.taskParameters.stackName)
+                )
+                await this.cloudFormationClient
+                    .executeChangeSet({
+                        ChangeSetName: this.taskParameters.changeSetName,
+                        StackName: this.taskParameters.stackName
+                    })
+                    .promise()
+
+                if (waitForUpdate) {
+                    await waitForStackUpdate(this.cloudFormationClient, this.taskParameters.stackName)
+                } else {
+                    await waitForStackCreation(this.cloudFormationClient, this.taskParameters.stackName)
+                }
             }
 
             if (this.taskParameters.outputVariable) {
@@ -66,7 +88,10 @@ export class TaskOperations {
         }
     }
 
-    private async verifyResourcesExist(changeSetName: string, stackName: string): Promise<string> {
+    private async verifyResourcesExist(
+        changeSetName: string,
+        stackName: string
+    ): Promise<CloudFormation.DescribeChangeSetOutput> {
         try {
             const request: CloudFormation.DescribeChangeSetInput = {
                 ChangeSetName: changeSetName
@@ -75,13 +100,7 @@ export class TaskOperations {
                 request.StackName = stackName
             }
 
-            const response = await this.cloudFormationClient.describeChangeSet(request).promise()
-
-            if (!response.StackId) {
-                return ''
-            }
-
-            return response.StackId
+            return await this.cloudFormationClient.describeChangeSet(request).promise()
         } catch (err) {
             throw new Error(tl.loc('ChangeSetDoesNotExist', changeSetName))
         }

src/tasks/CloudFormationExecuteChangeSet/TaskParameters.ts

@@ -15,6 +15,8 @@ export interface TaskParameters {
     awsConnectionParameters: AWSConnectionParameters
     changeSetName: string
     stackName: string
+    noFailOnEmptyChangeSet: boolean
+    deleteEmptyChangeSet: boolean
     outputVariable: string
     captureStackOutputs: string
     captureAsSecuredVars: boolean
@@ -25,6 +27,8 @@ export function buildTaskParameters(): TaskParameters {
         awsConnectionParameters: buildConnectionParameters(),
         changeSetName: getInputRequired('changeSetName'),
         stackName: getInputRequired('stackName'),
+        noFailOnEmptyChangeSet: getBoolInput('noFailOnEmptyChangeSet', false),
+        deleteEmptyChangeSet: getBoolInput('deleteEmptyChangeSet', false),
         outputVariable: getInputOrEmpty('outputVariable'),
         captureStackOutputs: getInputOrEmpty('captureStackOutputs'),
         captureAsSecuredVars: getBoolInput('captureAsSecuredVars', false)

src/tasks/CloudFormationExecuteChangeSet/task.json

@@ -60,6 +60,23 @@
             "required": false,
             "helpMarkDown": "The stack name or Amazon Resource Name (ARN) of the stack associated with the change set. This value is required if you specified the name of a change set to execute. If the ARN of the change set was specified this field is optional.\n\nThe name must be unique in the region in which you are creating the stack. A stack name can contain only alphanumeric characters (case-sensitive) and hyphens. It must start with an alphabetic character and cannot be longer than 128 characters."
         },
+        {
+            "name": "noFailOnEmptyChangeSet",
+            "type": "boolean",
+            "label": "Do Not Fail On Empty Change Set",
+            "defaultValue": "false",
+            "required": false,
+            "helpMarkDown": "Causes the task to identify an empty change set and skip its execution without throwing an error."
+        },
+        {
+            "name": "deleteEmptyChangeSet",
+            "type": "boolean",
+            "label": "Delete Empty Change Set",
+            "defaultValue": "false",
+            "required": false,
+            "visibleRule": "noFailOnEmptyChangeSet = true",
+            "helpMarkDown": "Automatically delete change set if empty."
+        },
         {
             "name": "outputVariable",
             "type": "string",
@@ -120,6 +137,8 @@
     },
     "messages": {
         "ExecutingChangeSet": "Executing change set %s, associated with stack %s",
+        "DeletingChangeSet": "Deleting change set %s since it has no pending changes",
+        "ExecutionSkipped": "Skipping execution of change set %s since it has no pending changes",
         "ExecuteChangeSetFailed": "Request to execute change set failed with message: %s",
         "WaitingForStackUpdate": "Waiting for stack %s to reach update complete status",
         "WaitingForStackCreation": "Waiting for stack %s to reach create complete status",

tests/taskTests/cloudFormationExecuteChangeSet/cloudFormationExecuteChangeSet-test.ts

@@ -15,6 +15,8 @@ const defaultTaskParameters: TaskParameters = {
     awsConnectionParameters: emptyConnectionParameters,
     changeSetName: '',
     stackName: '',
+    noFailOnEmptyChangeSet: false,
+    deleteEmptyChangeSet: false,
     outputVariable: '',
     captureStackOutputs: '',
     captureAsSecuredVars: false
@@ -32,6 +34,17 @@ const changeSetFound = {
     }
 }
 
+const changeSetFoundWithNoChanges = {
+    promise: () => {
+        return {
+            StackId: 'yes',
+            Status: 'FAILED',
+            StatusReason:
+                "The submitted information didn't contain changes. Submit different information to create a change set."
+        }
+    }
+}
+
 const cloudFormationHasResourcesSucceeds = {
     promise: function() {
         return {
@@ -84,6 +97,75 @@ describe('Cloud Formation Execute Change Set', () => {
         expect(cloudFormation.describeStackResources).toBeCalledTimes(1)
     })
 
+    test('Resource exists works, change set has no changes, fails on execute', async () => {
+        expect.assertions(2)
+
+        const cloudFormation = new CloudFormation() as any
+        cloudFormation.describeChangeSet = jest.fn(() => changeSetFoundWithNoChanges)
+        cloudFormation.describeStackResources = jest.fn()
+        cloudFormation.executeChangeSet = jest.fn(() => ({
+            promise: () => {
+                throw new Error('no')
+            }
+        }))
+        const taskOperations = new TaskOperations(cloudFormation, defaultTaskParameters)
+        await taskOperations.execute().catch(err => {
+            expect(err).toStrictEqual(new Error('no'))
+        })
+
+        expect(cloudFormation.executeChangeSet).toBeCalledTimes(1)
+    })
+
+    test('Resource exists works, change set has no changes, skips execute, ignores stack output', async () => {
+        expect.assertions(4)
+
+        const cloudFormation = new CloudFormation() as any
+        cloudFormation.describeChangeSet = jest.fn(() => changeSetFoundWithNoChanges)
+        cloudFormation.describeStackResources = jest.fn()
+        cloudFormation.executeChangeSet = jest.fn()
+        cloudFormation.deleteChangeSet = jest.fn()
+
+        const taskParameters = { ...defaultTaskParameters }
+        taskParameters.captureStackOutputs = ignoreStackOutputs
+        taskParameters.noFailOnEmptyChangeSet = true
+        taskParameters.captureStackOutputs = ignoreStackOutputs
+
+        const taskOperations = new TaskOperations(cloudFormation, taskParameters)
+        await taskOperations.execute()
+
+        expect(cloudFormation.describeChangeSet).toBeCalledTimes(1)
+        expect(cloudFormation.describeStackResources).toBeCalledTimes(1)
+        expect(cloudFormation.executeChangeSet).toBeCalledTimes(0)
+        expect(cloudFormation.deleteChangeSet).toBeCalledTimes(0)
+    })
+
+    test('Resource exists works, change set has no changes, deletes empty change set, ignores stack output', async () => {
+        expect.assertions(4)
+
+        const cloudFormation = new CloudFormation() as any
+        cloudFormation.describeChangeSet = jest.fn(() => changeSetFoundWithNoChanges)
+        cloudFormation.describeStackResources = jest.fn()
+        cloudFormation.executeChangeSet = jest.fn()
+
+        const deleteSucceeded = {
+            promise: () => undefined
+        }
+        cloudFormation.deleteChangeSet = jest.fn(() => deleteSucceeded)
+
+        const taskParameters = { ...defaultTaskParameters }
+        taskParameters.noFailOnEmptyChangeSet = true
+        taskParameters.deleteEmptyChangeSet = true
+        taskParameters.captureStackOutputs = ignoreStackOutputs
+
+        const taskOperations = new TaskOperations(cloudFormation, taskParameters)
+        await taskOperations.execute()
+
+        expect(cloudFormation.describeChangeSet).toBeCalledTimes(1)
+        expect(cloudFormation.describeStackResources).toBeCalledTimes(1)
+        expect(cloudFormation.executeChangeSet).toBeCalledTimes(0)
+        expect(cloudFormation.deleteChangeSet).toBeCalledTimes(1)
+    })
+
     test('Execute change set fails, fails task', async () => {
         expect.assertions(1)
         const cloudFormation = new CloudFormation() as any