feat: Add Targeted Execution to the Pre/Post Workflow Hooks (#3708)

* Add Workflow hook target filter * Fix post workflow hook example * Update WokrflowHook in global_cfg * Fix linting --------- Co-authored-by: PePe Amengual <[email protected]>
runatlantis · Oct 6, 2023 · 64f7d2e · 64f7d2e
1 parent 271b51e
commit 64f7d2e
Show file tree

Hide file tree

Showing 8 changed files with 321 additions and 22 deletions.
diff --git a/runatlantis.io/docs/post-workflow-hooks.md b/runatlantis.io/docs/post-workflow-hooks.md
@@ -13,6 +13,27 @@ back to the PR as a comment.
 Post workflow hooks can only be specified in the Server-Side Repo Config under
 the `repos` key.
 
+## Atlantis Command Targetting
+
+By default, the workflow hook will run when any command is processed by Atlantis.
+This can be modified by specifying the `commands` key in the workflow hook containing a comma delimited list
+of Atlantis commands that the hook should be run for. Detail of the Atlantis commands
+can be found in [Using Atlantis](using-atlantis.md).
+
+### Example
+
+```yaml
+repos:
+    - id: /.*/
+      post_workflow_hooks:
+        - run: ./plan-hook.sh
+          description: Plan Hook
+          commands: plan
+        - run: ./plan-apply-hook.sh
+          description: Plan & Apply Hook
+          commands: plan, apply
+```
+
 ## Use Cases
 
 ### Cost estimation reporting

diff --git a/runatlantis.io/docs/pre-workflow-hooks.md b/runatlantis.io/docs/pre-workflow-hooks.md
@@ -23,6 +23,27 @@ behavior can be changed by setting the [fail-on-pre-workflow-hook-error](server-
 flag in the Atlantis server configuration.
 ::: 
 
+## Atlantis Command Targetting
+
+By default, the workflow hook will run when any command is processed by Atlantis.
+This can be modified by specifying the `commands` key in the workflow hook containing a comma delimited list
+of Atlantis commands that the hook should be run for. Detail of the Atlantis commands
+can be found in [Using Atlantis](using-atlantis.md).
+
+### Example
+
+```yaml
+repos:
+    - id: /.*/
+      pre_workflow_hooks:
+        - run: ./plan-hook.sh
+          description: Plan Hook
+          commands: plan
+        - run: ./plan-apply-hook.sh
+          description: Plan & Apply Hook
+          commands: plan, apply
+```
+
 ## Use Cases
 
 ### Dynamic Repo Config Generation

diff --git a/server/core/config/raw/workflow_step.go b/server/core/config/raw/workflow_step.go
@@ -78,6 +78,7 @@ func (s WorkflowHook) ToValid() *valid.WorkflowHook {
 			StepDescription: s.StringVal["description"],
 			Shell:           s.StringVal["shell"],
 			ShellArgs:       s.StringVal["shellArgs"],
+			Commands:        s.StringVal["commands"],
 		}
 	}
 

diff --git a/server/core/config/valid/global_cfg.go b/server/core/config/valid/global_cfg.go
@@ -111,6 +111,7 @@ type WorkflowHook struct {
 	StepDescription string
 	Shell           string
 	ShellArgs       string
+	Commands        string
 }
 
 // DefaultApplyStage is the Atlantis default apply stage.

diff --git a/server/events/post_workflow_hooks_command_runner.go b/server/events/post_workflow_hooks_command_runner.go
@@ -2,6 +2,7 @@ package events
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/google/uuid"
 	"github.com/runatlantis/atlantis/server/core/config/valid"
@@ -108,6 +109,15 @@ func (w *DefaultPostWorkflowHooksCommandRunner) runHooks(
 			hookDescription = fmt.Sprintf("Post workflow hook #%d", i)
 		}
 
+		ctx.Log.Debug("Processing post workflow hook '%s', Command '%s', Target commands [%s]",
+			hookDescription, ctx.CommandName, hook.Commands)
+		if hook.Commands != "" && !strings.Contains(hook.Commands, ctx.CommandName) {
+			ctx.Log.Debug("Skipping post workflow hook '%s' as command '%s' is not in Commands [%s]",
+				hookDescription, ctx.CommandName, hook.Commands)
+			continue
+		}
+
+		ctx.Log.Debug("Running post workflow hook: '%s'", hookDescription)
 		ctx.HookID = uuid.NewString()
 		shell := hook.Shell
 		if shell == "" {

diff --git a/server/events/post_workflow_hooks_command_runner_test.go b/server/events/post_workflow_hooks_command_runner_test.go
@@ -84,6 +84,18 @@ func TestRunPostHooks_Clone(t *testing.T) {
 		ShellArgs:  "-ce",
 	}
 
+	testHookWithPlanCommand := valid.WorkflowHook{
+		StepName:   "test4",
+		RunCommand: "echo test4",
+		Commands:   "plan",
+	}
+
+	testHookWithPlanApplyCommands := valid.WorkflowHook{
+		StepName:   "test5",
+		RunCommand: "echo test5",
+		Commands:   "plan, apply",
+	}
+
 	repoDir := "path/to/repo"
 	result := "some result"
 	runtimeDesc := ""
@@ -99,10 +111,14 @@ func TestRunPostHooks_Clone(t *testing.T) {
 		CommandName: "plan",
 	}
 
-	cmd := &events.CommentCommand{
+	planCmd := &events.CommentCommand{
 		Name: command.Plan,
 	}
 
+	applyCmd := &events.CommentCommand{
+		Name: command.Apply,
+	}
+
 	t.Run("success hooks in cfg", func(t *testing.T) {
 		postWorkflowHooksSetup(t)
 
@@ -129,7 +145,7 @@ func TestRunPostHooks_Clone(t *testing.T) {
 		When(whPostWorkflowHookRunner.Run(Any[models.WorkflowHookCommandContext](), Eq(testHook.RunCommand), Any[string](),
 			Any[string](), Eq(repoDir))).ThenReturn(result, runtimeDesc, nil)
 
-		err := postWh.RunPostHooks(ctx, cmd)
+		err := postWh.RunPostHooks(ctx, planCmd)
 
 		Ok(t, err)
 		whPostWorkflowHookRunner.VerifyWasCalledOnce().Run(Any[models.WorkflowHookCommandContext](),
@@ -157,7 +173,7 @@ func TestRunPostHooks_Clone(t *testing.T) {
 
 		postWh.GlobalCfg = globalCfg
 
-		err := postWh.RunPostHooks(ctx, cmd)
+		err := postWh.RunPostHooks(ctx, planCmd)
 
 		Ok(t, err)
 
@@ -184,7 +200,7 @@ func TestRunPostHooks_Clone(t *testing.T) {
 
 		When(postWhWorkingDirLocker.TryLock(testdata.GithubRepo.FullName, newPull.Num, events.DefaultWorkspace, events.DefaultRepoRelDir)).ThenReturn(func() {}, errors.New("some error"))
 
-		err := postWh.RunPostHooks(ctx, cmd)
+		err := postWh.RunPostHooks(ctx, planCmd)
 
 		Assert(t, err != nil, "error not nil")
 		postWhWorkingDir.VerifyWasCalled(Never()).Clone(testdata.GithubRepo, newPull, events.DefaultWorkspace)
@@ -216,7 +232,7 @@ func TestRunPostHooks_Clone(t *testing.T) {
 		When(postWhWorkingDirLocker.TryLock(testdata.GithubRepo.FullName, newPull.Num, events.DefaultWorkspace, events.DefaultRepoRelDir)).ThenReturn(unlockFn, nil)
 		When(postWhWorkingDir.Clone(testdata.GithubRepo, newPull, events.DefaultWorkspace)).ThenReturn(repoDir, false, errors.New("some error"))
 
-		err := postWh.RunPostHooks(ctx, cmd)
+		err := postWh.RunPostHooks(ctx, planCmd)
 
 		Assert(t, err != nil, "error not nil")
 
@@ -251,7 +267,7 @@ func TestRunPostHooks_Clone(t *testing.T) {
 		When(whPostWorkflowHookRunner.Run(Any[models.WorkflowHookCommandContext](), Eq(testHook.RunCommand),
 			Any[string](), Any[string](), Eq(repoDir))).ThenReturn(result, runtimeDesc, errors.New("some error"))
 
-		err := postWh.RunPostHooks(ctx, cmd)
+		err := postWh.RunPostHooks(ctx, planCmd)
 
 		Assert(t, err != nil, "error not nil")
 		Assert(t, *unlockCalled == true, "unlock function called")
@@ -276,7 +292,7 @@ func TestRunPostHooks_Clone(t *testing.T) {
 			},
 		}
 
-		cmd := &events.CommentCommand{
+		planCmd := &events.CommentCommand{
 			Name:  command.Plan,
 			Flags: []string{"comment", "args"},
 		}
@@ -291,7 +307,7 @@ func TestRunPostHooks_Clone(t *testing.T) {
 		When(whPostWorkflowHookRunner.Run(Any[models.WorkflowHookCommandContext](), Eq(testHook.RunCommand),
 			Any[string](), Any[string](), Eq(repoDir))).ThenReturn(result, runtimeDesc, nil)
 
-		err := postWh.RunPostHooks(ctx, cmd)
+		err := postWh.RunPostHooks(ctx, planCmd)
 
 		Ok(t, err)
 		whPostWorkflowHookRunner.VerifyWasCalledOnce().Run(Any[models.WorkflowHookCommandContext](),
@@ -325,7 +341,7 @@ func TestRunPostHooks_Clone(t *testing.T) {
 		When(whPostWorkflowHookRunner.Run(Any[models.WorkflowHookCommandContext](), Eq(testHookWithShell.RunCommand),
 			Any[string](), Any[string](), Eq(repoDir))).ThenReturn(result, runtimeDesc, nil)
 
-		err := postWh.RunPostHooks(ctx, cmd)
+		err := postWh.RunPostHooks(ctx, planCmd)
 
 		Ok(t, err)
 		whPostWorkflowHookRunner.VerifyWasCalledOnce().Run(Any[models.WorkflowHookCommandContext](),
@@ -359,7 +375,7 @@ func TestRunPostHooks_Clone(t *testing.T) {
 		When(whPostWorkflowHookRunner.Run(Any[models.WorkflowHookCommandContext](), Eq(testHook.RunCommand),
 			Any[string](), Any[string](), Eq(repoDir))).ThenReturn(result, runtimeDesc, nil)
 
-		err := postWh.RunPostHooks(ctx, cmd)
+		err := postWh.RunPostHooks(ctx, planCmd)
 
 		Ok(t, err)
 		whPostWorkflowHookRunner.VerifyWasCalledOnce().Run(Any[models.WorkflowHookCommandContext](),
@@ -393,12 +409,113 @@ func TestRunPostHooks_Clone(t *testing.T) {
 		When(whPostWorkflowHookRunner.Run(Any[models.WorkflowHookCommandContext](),
 			Eq(testHookWithShellandShellArgs.RunCommand), Any[string](), Any[string](), Eq(repoDir))).ThenReturn(result, runtimeDesc, nil)
 
-		err := postWh.RunPostHooks(ctx, cmd)
+		err := postWh.RunPostHooks(ctx, planCmd)
 
 		Ok(t, err)
 		whPostWorkflowHookRunner.VerifyWasCalledOnce().Run(Any[models.WorkflowHookCommandContext](),
 			Eq(testHookWithShellandShellArgs.RunCommand), Eq(testHookWithShellandShellArgs.Shell), Eq(testHookWithShellandShellArgs.ShellArgs), Eq(repoDir))
 		Assert(t, *unlockCalled == true, "unlock function called")
 	})
 
+	t.Run("Commands 'plan' set on webhook and plan command", func(t *testing.T) {
+		preWorkflowHooksSetup(t)
+
+		var unlockCalled = newBool(false)
+		unlockFn := func() {
+			unlockCalled = newBool(true)
+		}
+
+		globalCfg := valid.GlobalCfg{
+			Repos: []valid.Repo{
+				{
+					ID: testdata.GithubRepo.ID(),
+					PreWorkflowHooks: []*valid.WorkflowHook{
+						&testHookWithPlanCommand,
+					},
+				},
+			},
+		}
+
+		preWh.GlobalCfg = globalCfg
+
+		When(preWhWorkingDirLocker.TryLock(testdata.GithubRepo.FullName, newPull.Num, events.DefaultWorkspace, events.DefaultRepoRelDir)).ThenReturn(unlockFn, nil)
+		When(preWhWorkingDir.Clone(testdata.GithubRepo, newPull, events.DefaultWorkspace)).ThenReturn(repoDir, false, nil)
+		When(whPreWorkflowHookRunner.Run(Any[models.WorkflowHookCommandContext](),
+			Eq(testHookWithPlanCommand.RunCommand), Any[string](), Any[string](), Eq(repoDir))).ThenReturn(result, runtimeDesc, nil)
+
+		err := preWh.RunPreHooks(ctx, planCmd)
+
+		Ok(t, err)
+		whPreWorkflowHookRunner.VerifyWasCalledOnce().Run(Any[models.WorkflowHookCommandContext](),
+			Eq(testHookWithPlanCommand.RunCommand), Any[string](), Any[string](), Eq(repoDir))
+		Assert(t, *unlockCalled == true, "unlock function called")
+	})
+
+	t.Run("Commands 'plan' set on webhook and non-plan command", func(t *testing.T) {
+		preWorkflowHooksSetup(t)
+
+		var unlockCalled = newBool(false)
+		unlockFn := func() {
+			unlockCalled = newBool(true)
+		}
+
+		globalCfg := valid.GlobalCfg{
+			Repos: []valid.Repo{
+				{
+					ID: testdata.GithubRepo.ID(),
+					PreWorkflowHooks: []*valid.WorkflowHook{
+						&testHookWithPlanCommand,
+					},
+				},
+			},
+		}
+
+		preWh.GlobalCfg = globalCfg
+
+		When(preWhWorkingDirLocker.TryLock(testdata.GithubRepo.FullName, newPull.Num, events.DefaultWorkspace, events.DefaultRepoRelDir)).ThenReturn(unlockFn, nil)
+		When(preWhWorkingDir.Clone(testdata.GithubRepo, newPull, events.DefaultWorkspace)).ThenReturn(repoDir, false, nil)
+		When(whPreWorkflowHookRunner.Run(Any[models.WorkflowHookCommandContext](),
+			Eq(testHookWithPlanCommand.RunCommand), Any[string](), Any[string](), Eq(repoDir))).ThenReturn(result, runtimeDesc, nil)
+
+		err := preWh.RunPreHooks(ctx, applyCmd)
+
+		Ok(t, err)
+		whPreWorkflowHookRunner.VerifyWasCalled(Never()).Run(Any[models.WorkflowHookCommandContext](),
+			Eq(testHookWithPlanCommand.RunCommand), Any[string](), Any[string](), Eq(repoDir))
+		Assert(t, *unlockCalled == true, "unlock function called")
+	})
+
+	t.Run("Commands 'plan, apply' set on webhook and plan command", func(t *testing.T) {
+		preWorkflowHooksSetup(t)
+
+		var unlockCalled = newBool(false)
+		unlockFn := func() {
+			unlockCalled = newBool(true)
+		}
+
+		globalCfg := valid.GlobalCfg{
+			Repos: []valid.Repo{
+				{
+					ID: testdata.GithubRepo.ID(),
+					PreWorkflowHooks: []*valid.WorkflowHook{
+						&testHookWithPlanApplyCommands,
+					},
+				},
+			},
+		}
+
+		preWh.GlobalCfg = globalCfg
+
+		When(preWhWorkingDirLocker.TryLock(testdata.GithubRepo.FullName, newPull.Num, events.DefaultWorkspace, events.DefaultRepoRelDir)).ThenReturn(unlockFn, nil)
+		When(preWhWorkingDir.Clone(testdata.GithubRepo, newPull, events.DefaultWorkspace)).ThenReturn(repoDir, false, nil)
+		When(whPreWorkflowHookRunner.Run(Any[models.WorkflowHookCommandContext](),
+			Eq(testHookWithPlanApplyCommands.RunCommand), Any[string](), Any[string](), Eq(repoDir))).ThenReturn(result, runtimeDesc, nil)
+
+		err := preWh.RunPreHooks(ctx, planCmd)
+
+		Ok(t, err)
+		whPreWorkflowHookRunner.VerifyWasCalledOnce().Run(Any[models.WorkflowHookCommandContext](),
+			Eq(testHookWithPlanApplyCommands.RunCommand), Any[string](), Any[string](), Eq(repoDir))
+		Assert(t, *unlockCalled == true, "unlock function called")
+	})
 }
diff --git a/server/events/pre_workflow_hooks_command_runner.go b/server/events/pre_workflow_hooks_command_runner.go
@@ -2,6 +2,7 @@ package events
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/google/uuid"
 	"github.com/runatlantis/atlantis/server/core/config/valid"
@@ -105,6 +106,15 @@ func (w *DefaultPreWorkflowHooksCommandRunner) runHooks(
 			hookDescription = fmt.Sprintf("Pre workflow hook #%d", i)
 		}
 
+		ctx.Log.Debug("Processing pre workflow hook '%s', Command '%s', Target commands [%s]",
+			hookDescription, ctx.CommandName, hook.Commands)
+		if hook.Commands != "" && !strings.Contains(hook.Commands, ctx.CommandName) {
+			ctx.Log.Debug("Skipping pre workflow hook '%s' as command '%s' is not in Commands [%s]",
+				hookDescription, ctx.CommandName, hook.Commands)
+			continue
+		}
+
+		ctx.Log.Debug("Running pre workflow hook: '%s'", hookDescription)
 		ctx.HookID = uuid.NewString()
 		shell := hook.Shell
 		if shell == "" {