Adding support for Terraform Destroy. Adding ConfirmApply customization

src/ConditionalApplyPlugin.groovy

@@ -1,18 +1,22 @@
 import static TerraformEnvironmentStage.CONFIRM
 import static TerraformEnvironmentStage.APPLY
+import static TerraformDestroyStage.DESTROY
 
 public class ConditionalApplyPlugin implements TerraformEnvironmentStagePlugin {
 
     private String branch
 
     ConditionalApplyPlugin() {
-        branch = 'master'
+        branch = 'destroy_test' // TODO: CHANGE THIS BACK TO MASTER!
     }
 
     @Override
     public void apply(TerraformEnvironmentStage stage) {
         stage.decorateAround(CONFIRM, onlyOnExpectedBranch())
         stage.decorateAround(APPLY, onlyOnExpectedBranch())
+        if (stage instanceof TerraformDestroyStage){
+            stage.decorateAround(DESTROY, onlyOnExpectedBranch())
+        }
     }
 
     public Closure onlyOnExpectedBranch() {

src/ConfirmApplyPlugin.groovy

@@ -3,6 +3,7 @@ import static TerraformEnvironmentStage.CONFIRM
 class ConfirmApplyPlugin implements TerraformEnvironmentStagePlugin {
 
     public static enabled = true
+    public static command_name
 
     ConfirmApplyPlugin() {
     }
@@ -13,19 +14,24 @@ class ConfirmApplyPlugin implements TerraformEnvironmentStagePlugin {
 
     @Override
     public void apply(TerraformEnvironmentStage stage) {
+        command_name = "apply"
+        if (stage instanceof TerraformDestroyStage){
+            command_name = "destroy"
+        }
+
         if (enabled) {
-            stage.decorate(CONFIRM, addConfirmation())
+            stage.decorate(CONFIRM, addConfirmation(command_name))
         }
     }
 
-    public static Closure addConfirmation() {
+    public static Closure addConfirmation(String command) {
         return { closure ->
             // ask for human input
             try {
                 timeout(time: 15, unit: 'MINUTES') {
                     input(
-                        message: 'Are you absolutely sure the plan above is correct, and should be IMMEDIATELY DEPLOYED via "terraform apply"?',
-                        ok: 'Run terraform APPLY now',
+                        message: "Are you absolutely sure the plan above is correct, and should be IMMEDIATELY DEPLOYED via \"terraform ${command}\"?",
+                        ok: "Run terraform ${command.toUpperCase()} now",
                         submitterParameter: 'approver'
                     )
                 }

src/TargetPlugin.groovy

@@ -1,11 +1,12 @@
 import static TerraformEnvironmentStage.ALL
 
-class TargetPlugin implements TerraformPlanCommandPlugin, TerraformApplyCommandPlugin, TerraformEnvironmentStagePlugin {
+class TargetPlugin implements TerraformPlanCommandPlugin, TerraformApplyCommandPlugin, TerraformDestroyCommandPlugin, TerraformEnvironmentStagePlugin {
     public static void init() {
         TargetPlugin plugin = new TargetPlugin()
 
         TerraformPlanCommand.addPlugin(plugin)
         TerraformApplyCommand.addPlugin(plugin)
+        TerraformDestroyCommand.addPlugin(plugin)
         TerraformEnvironmentStage.addPlugin(plugin)
     }
 
@@ -27,6 +28,15 @@ class TargetPlugin implements TerraformPlanCommandPlugin, TerraformApplyCommandP
                .each { item -> command.withArgument("-target ${item}") }
     }
 
+    @Override
+    public void apply(TerraformDestroyCommand command) {
+        def targets = Jenkinsfile.instance.getEnv().RESOURCE_TARGETS ?: ''
+        targets.split(',')
+               .collect { item -> item.trim() }
+               .findAll { item -> item != '' }
+               .each { item -> command.withArgument("-target ${item}") }
+    }
+
     @Override
     public void apply(TerraformEnvironmentStage stage) {
         stage.decorate(ALL, addBuildParams())

src/TerraformDestroyCommand.groovy

@@ -0,0 +1,88 @@
+class TerraformDestroyCommand {
+    private boolean input = false
+    private String terraformBinary = "terraform"
+    private String command = "destroy"
+    String environment
+    private prefixes = []
+    private suffixes = []
+    private args = []
+    private static plugins = []
+    private appliedPlugins = []
+    private String directory
+
+    public TerraformDestroyCommand(String environment) {
+        this.environment = environment
+    }
+
+    public TerraformDestroyCommand withInput(boolean input) {
+        this.input = input
+        return this
+    }
+
+    public TerraformDestroyCommand withArgument(String arg) {
+        this.args << arg
+        return this
+    }
+
+    public TerraformDestroyCommand withPrefix(String prefix) {
+        prefixes << prefix
+        return this
+    }
+
+    public TerraformDestroyCommand withSuffix(String suffix) {
+        suffixes << suffix
+        return this
+    }
+
+    public TerraformDestroyCommand withDirectory(String directory) {
+        this.directory = directory
+        return this
+    }
+
+    public String toString() {
+        applyPluginsOnce()
+
+        def pieces = []
+        pieces += prefixes
+        pieces << terraformBinary
+        pieces << command
+        if (!input) {
+            pieces << "-input=false"
+        }
+        pieces += args
+        if (directory) {
+            pieces << directory
+        }
+
+        pieces += suffixes
+
+        return pieces.join(' ')
+    }
+
+    private applyPluginsOnce() {
+        def remainingPlugins = plugins - appliedPlugins
+
+        for (TerraformDestroyCommandPlugin plugin in remainingPlugins) {
+            plugin.apply(this)
+            appliedPlugins << plugin
+        }
+    }
+
+    public static void addPlugin(TerraformDestroyCommandPlugin plugin) {
+        plugins << plugin
+    }
+
+    public static TerraformDestroyCommand instanceFor(String environment) {
+        return new TerraformDestroyCommand(environment)
+            .withInput(false)
+            .withArgument("-auto-approve")
+    }
+
+    public static getPlugins() {
+        return plugins
+    }
+
+    public static resetPlugins() {
+        this.plugins = []
+    }
+}

src/TerraformDestroyCommandPlugin.groovy

@@ -0,0 +1,3 @@
+interface TerraformDestroyCommandPlugin {
+    public void apply(TerraformDestroyCommand command)
+}

src/TerraformDestroyStage.groovy

@@ -0,0 +1,52 @@
+class TerraformDestroyStage extends TerraformEnvironmentStage {
+    private TerraformDestroyCommand destroyCommand
+    public static final String DESTROY = 'destroy'
+
+    TerraformDestroyStage(String environment) {
+        super(environment)
+    }
+
+    @Override
+    private Closure pipelineConfiguration() {
+        initCommand = TerraformInitCommand.instanceFor(environment)
+        planCommand = TerraformPlanCommand.instanceFor(environment)
+        planCommand = planCommand.withArgument("-destroy")
+        destroyCommand = TerraformDestroyCommand.instanceFor(environment)
+
+        applyPlugins()
+
+        def String environment = this.environment
+        return { ->
+            node(jenkinsfile.getNodeName()) {
+                deleteDir()
+                checkout(scm)
+
+                decorations.apply(ALL) {
+                    stage("${PLAN}-${DESTROY}-${environment}") {
+                        decorations.apply(PLAN) {
+                            sh initCommand.toString()
+                            sh planCommand.toString()
+                        }
+                    }
+
+                    decorations.apply("Around-${CONFIRM}") {
+                        stage("${CONFIRM}-${DESTROY}-${environment}") {
+                            decorations.apply(CONFIRM) {
+                                echo "Approved"
+                            }
+                        }
+                    }
+
+                    decorations.apply("Around-${DESTROY}") {
+                        stage("${DESTROY}-${environment}") {
+                            decorations.apply(DESTROY) {
+                                sh destroyCommand.toString()
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+}

src/TerraformEnvironmentStage.groovy

@@ -1,14 +1,14 @@
 class TerraformEnvironmentStage implements Stage {
-    private Jenkinsfile jenkinsfile
-    private String environment
-    private StageDecorations decorations
-    private TerraformInitCommand initCommand
-    private TerraformPlanCommand planCommand
-    private TerraformApplyCommand applyCommand
-    private localPlugins
+    protected Jenkinsfile jenkinsfile
+    protected String environment
+    protected StageDecorations decorations
+    protected TerraformInitCommand initCommand
+    protected TerraformPlanCommand planCommand
+    protected TerraformApplyCommand applyCommand
+    protected localPlugins
 
-    private static final DEFAULT_PLUGINS = [ new ConditionalApplyPlugin(), new ConfirmApplyPlugin(), new DefaultEnvironmentPlugin() ]
-    private static globalPlugins = DEFAULT_PLUGINS.clone()
+    protected static final DEFAULT_PLUGINS = [ new ConditionalApplyPlugin(), new ConfirmApplyPlugin(), new DefaultEnvironmentPlugin() ]
+    protected static globalPlugins = DEFAULT_PLUGINS.clone()
 
     public static final String ALL = 'all'
     public static final String PLAN = 'plan'
@@ -126,7 +126,7 @@ class TerraformEnvironmentStage implements Stage {
         return reconcileLocalAndGlobalPlugins()
     }
 
-    private reconcileLocalAndGlobalPlugins(TerraformEnvironmentStagePlugin newPlugin = null) {
+    protected reconcileLocalAndGlobalPlugins(TerraformEnvironmentStagePlugin newPlugin = null) {
         if (localPlugins == null) {
             if (newPlugin == null) {
                 // No local plugins were added - only global plugins take effect