Introduce before and after steps for a task. (#56)

* Introduce before and after steps for a task. A task is now able to have several steps which are executed before and after its own execution. The config syntax for this is the same as for the task itself: 'command', 'script' and 'exec' are supported. A task and all of the preceeding steps will still be executed even when the before steps are failing. Running a task now returns a list of errors which are logged according to their occurrence for easier troubleshooting. Co-authored-by: Jens Petersohn <me@jen.pet>
tj · Jun 20, 2022 · a1ab412 · a1ab412
1 parent fe26677
commit a1ab412
Show file tree

Hide file tree

Showing 7 changed files with 214 additions and 50 deletions.
diff --git a/Readme.md b/Readme.md
@@ -300,6 +300,30 @@ $ robo aws-stage ...
 
 Note that you cannot use shell featurs in the environment key.
 
+### Setup / Cleanup
+Some tasks or even your entire robo configuration may require steps upfront for setup or afterwards for a cleanup. The keywords `before` and `after` can be embedded into a task or into the overall robo configuration. It has the same executable syntax as a task: `script`, `exec` and `command`.
+Defining it on a task level causes the steps to be executed before (respectively after) the task. Global before or after steps are invoked for _every_ task in the configuration.
+All steps get interpolated the same way tasks and variables are interpolated.
+
+```yaml
+before:
+  - command: echo "global before {{ .foo }}"
+after:
+  - script: /global/after-script.sh
+
+foo:
+  before:
+    - command: echo "local before {{ .foo }}"
+    - exec: git pull -r
+  after:
+    - command: echo "local after"
+    - exec: git reset --hard HEAD
+  exec: git status
+
+variables:
+  foo: bar
+```
+
 ### Templates
 
  Task `list` and `help` output may be re-configured, for example if you

diff --git a/cli/cli.go b/cli/cli.go
@@ -9,6 +9,7 @@ import (
 
 	"github.com/fatih/color"
 	"github.com/tj/robo/config"
+	"github.com/tj/robo/task"
 )
 
 // Template helpers.
@@ -104,16 +105,32 @@ func Help(c *config.Config, name string) {
 
 // Run the task.
 func Run(c *config.Config, name string, args []string) {
-	task, ok := c.Tasks[name]
+	t, ok := c.Tasks[name]
 	if !ok {
 		Fatalf("undefined task %q", name)
 	}
+	lookupPath := filepath.Dir(c.File)
+	t.LookupPath = lookupPath
+
+	var errs []error
+	if err := task.RunOptionals("before", "GLOBAL", c.Before, args, lookupPath, nil); err != nil {
+		errs = append(errs, err)
+	}
 
-	task.LookupPath = filepath.Dir(c.File)
+	if runErrs := t.Run(args); len(runErrs) > 0 {
+		errs = append(errs, runErrs...)
+	}
 
-	err := task.Run(args)
-	if err != nil {
-		Fatalf("error: %s", err)
+	if err := task.RunOptionals("after", "GLOBAL", c.After, args, lookupPath, nil); err != nil {
+		errs = append(errs, err)
+	}
+
+	if len(errs) > 0 {
+		var msg string
+		for _, err := range errs {
+			msg += fmt.Sprintf("    - %+v\n", err)
+		}
+		Fatalf("error(s): \n%s", msg)
 	}
 }
 

diff --git a/config/config.go b/config/config.go
@@ -2,22 +2,25 @@ package config
 
 import (
 	"fmt"
-	"github.com/tj/robo/interpolation"
-	"gopkg.in/yaml.v2"
 	"io/ioutil"
 	"os/user"
 	"path"
 
+	"github.com/tj/robo/interpolation"
+	"gopkg.in/yaml.v2"
+
 	"github.com/tj/robo/task"
 )
 
 // Config represents the main YAML configuration
 // loaded for Robo tasks.
 type Config struct {
-	File         string
-	Tasks        map[string]*task.Task `yaml:",inline"`
-	Variables    map[string]interface{}
-	Templates    struct {
+	Before    []*task.Runnable
+	After     []*task.Runnable
+	File      string
+	Tasks     map[string]*task.Task `yaml:",inline"`
+	Variables map[string]interface{}
+	Templates struct {
 		List      string
 		Help      string
 		Variables string
@@ -37,6 +40,16 @@ func (c *Config) Eval() error {
 	if err != nil {
 		return fmt.Errorf("failed interpolating tasks. Error: %v", err)
 	}
+
+	err = interpolation.Optionals("before", c.Before, c.Variables)
+	if err != nil {
+		return fmt.Errorf("failed interpolating before optionals. Error: %v", err)
+	}
+
+	err = interpolation.Optionals("after", c.After, c.Variables)
+	if err != nil {
+		return fmt.Errorf("failed interpolating after optionals. Error: %v", err)
+	}
 	return nil
 }
 
@@ -102,4 +115,4 @@ func NewString(s string) (*Config, error) {
 	}
 
 	return c, nil
-}
+}
diff --git a/config/config_test.go b/config/config_test.go
@@ -10,9 +10,19 @@ import (
 )
 
 var s = `
+before:
+- command: echo "global before"
+
+after:
+- command: echo "global after"
+
 foo:
   summary: Command foo.
+  before:
+  - command: echo "before"
   command: echo "foo"
+  after:
+  - command: echo "after"
 
 bar:
   summary: Command bar.
@@ -50,9 +60,13 @@ func TestNewString(t *testing.T) {
 	assert.Equal(t, `ssh bastion-stage -t robo`, c.Tasks["stage"].Command)
 	assert.Equal(t, `ssh bastion-prod -t robo`, c.Tasks["prod"].Command)
 
+	assert.Equal(t, `echo "global before"`, c.Before[0].Command)
+	assert.Equal(t, `echo "global after"`, c.After[0].Command)
 	assert.Equal(t, `foo`, c.Tasks["foo"].Name)
 	assert.Equal(t, `Command foo.`, c.Tasks["foo"].Summary)
 	assert.Equal(t, `echo "foo"`, c.Tasks["foo"].Command)
+	assert.Equal(t, `echo "before"`, c.Tasks["foo"].Before[0].Command)
+	assert.Equal(t, `echo "after"`, c.Tasks["foo"].After[0].Command)
 
 	assert.Equal(t, `Command bar.`, c.Tasks["bar"].Summary)
 	assert.Equal(t, `echo "bar"`, c.Tasks["bar"].Command)
@@ -82,4 +96,4 @@ func TestNew(t *testing.T) {
 	c, err := config.New(file)
 	assert.Equal(t, nil, err)
 	assert.Equal(t, file, c.File)
-}
+}
diff --git a/interpolation/interpolation.go b/interpolation/interpolation.go
@@ -4,19 +4,20 @@ package interpolation
 import (
 	"bytes"
 	"fmt"
-	"github.com/tj/robo/task"
-	"gopkg.in/yaml.v2"
 	"os"
 	"os/exec"
 	"regexp"
 	"strings"
 	"text/template"
+
+	"github.com/tj/robo/task"
+	"gopkg.in/yaml.v2"
 )
 
 var commandPattern = regexp.MustCompile("\\$\\((.+)\\)")
 
 // Vars interpolates a given map of interfaces (strings or submaps) with itself
-// returning it mit populated template values.
+// returning it with populated template values.
 func Vars(vars *map[string]interface{}) error {
 	b, err := yaml.Marshal(*vars)
 	if err != nil {
@@ -71,11 +72,12 @@ func captureCommandOutput(args string) (string, error) {
 	cmd.Stdout = &b
 	cmd.Stderr = os.Stderr
 	err := cmd.Run()
-	return strings.TrimSuffix(string(b.Bytes()), "\n"), err
+	return strings.TrimSuffix(b.String(), "\n"), err
 }
 
 // Tasks interpolates a given task with a set of data replacing placeholders
-// in the command, summary, script, exec and envs property.
+// in the command, summary, script, exec and envs properties. If applicable the optionals 'before' and 'after' are also
+// interpolated.
 func Tasks(tasks map[string]*task.Task, data map[string]interface{}) error {
 	for _, task := range tasks {
 		// interpolate the tasks main fields
@@ -91,13 +93,39 @@ func Tasks(tasks map[string]*task.Task, data map[string]interface{}) error {
 			return err
 		}
 
-		// interpolate a tasks environment data
+		// interpolate a task's environment data
 		for i, item := range task.Env {
 			if err := interpolate("env-var", data, &item); err != nil {
 				return err
 			}
 			task.Env[i] = item
 		}
+
+		// interpolate a task's before and after steps
+		if err := Optionals("before", task.Before, data); err != nil {
+			return err
+		}
+		if err := Optionals("after", task.After, data); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Optionals interpolates a list of runnables (i.e. optional steps for a task or the overall robo configuration).
+func Optionals(id string, rs []*task.Runnable, data map[string]interface{}) error {
+	for i, step := range rs {
+		err := interpolate(
+			id,
+			data,
+			&step.Command,
+			&step.Exec,
+			&step.Script,
+		)
+		if err != nil {
+			return err
+		}
+		rs[i] = step
 	}
 	return nil
 }
@@ -119,4 +147,4 @@ func interpolate(name string, data interface{}, temps ...*string) error {
 		*temp = string(b.Bytes())
 	}
 	return nil
-}
+}
diff --git a/interpolation/interpolation_test.go b/interpolation/interpolation_test.go
@@ -1,9 +1,10 @@
 package interpolation
 
 import (
+	"testing"
+
 	"github.com/bmizerany/assert"
 	"github.com/tj/robo/task"
-	"testing"
 )
 
 func TestVars_whenValueReferencesOtherKey_shouldReplaceAccordingly(t *testing.T) {
@@ -21,10 +22,9 @@ func TestVars_whenValueReferencesOtherKey_shouldReplaceAccordingly(t *testing.T)
 func TestVars_whenValueIsCommand_shouldReplaceWithCommandResult(t *testing.T) {
 	vars := map[string]interface{}{
 		"foo": "$(echo Hello)",
-		"bar":
-			map[string]interface{}{
-				"sub": "$(echo World!)",
-			},
+		"bar": map[string]interface{}{
+			"sub": "$(echo World!)",
+		},
 	}
 
 	err := Vars(&vars)
@@ -36,20 +36,36 @@ func TestVars_whenValueIsCommand_shouldReplaceWithCommandResult(t *testing.T) {
 
 func TestTasks(t *testing.T) {
 	tk := task.Task{
-		Summary:    "This task handles {{ .foo }} World!",
-		Command:    "echo {{ .foo }} World!",
-		Script:     "/path/to/{{ .foo }}.sh",
-		Exec:       "{{ .foo }} World!",
-		Env:        []string{"bar={{ .foo }} World!"},
+		Summary: "This task handles {{ .foo }} World!",
+		Before: []*task.Runnable{
+			{Command: "{{ .foo }}"},
+			{Script: "{{ .foo }}"},
+			{Exec: "{{ .foo }}"},
+		},
+		After: []*task.Runnable{
+			{Command: "{{ .bar }}"},
+			{Script: "{{ .bar }}"},
+			{Exec: "{{ .bar }}"},
+		},
+		Command: "echo {{ .foo }} World!",
+		Script:  "/path/to/{{ .foo }}.sh",
+		Exec:    "{{ .foo }} World!",
+		Env:     []string{"bar={{ .foo }} World!"},
 	}
 
-	vars := map[string]interface{}{"foo": "Hello"}
+	vars := map[string]interface{}{"foo": "Hello", "bar": "Bye"}
 
 	err := Tasks(map[string]*task.Task{"tk": &tk}, vars)
 	assert.Equal(t, nil, err)
 	assert.Equal(t, "This task handles Hello World!", tk.Summary)
 	assert.Equal(t, "echo Hello World!", tk.Command)
 	assert.Equal(t, "/path/to/Hello.sh", tk.Script)
 	assert.Equal(t, "Hello World!", tk.Exec)
+	assert.Equal(t, "Hello", tk.Before[0].Command)
+	assert.Equal(t, "Hello", tk.Before[1].Script)
+	assert.Equal(t, "Hello", tk.Before[2].Exec)
+	assert.Equal(t, "Bye", tk.After[0].Command)
+	assert.Equal(t, "Bye", tk.After[1].Script)
+	assert.Equal(t, "Bye", tk.After[2].Exec)
 	assert.Equal(t, "bar=Hello World!", tk.Env[0])
 }