Added a repeat functionality on the script step level.

Author: francoishill

README.md

@@ -8,6 +8,7 @@ Just a basic script runner to easily abort/continue on previous step failure
 ```
 variables:
   COMMAND_VAR: where python && echo Hallo
+  Machines: ["machine1", "machine2"]
 
 Phase 1: 
   continue_on_failure: true
@@ -19,6 +20,7 @@ Phase 1:
   steps:
     - where python
     - $COMMAND_VAR && echo test123
+    - 'repeat::Machines echo {{.}}'
 ```
 
 ### Install and run

main.go

@@ -8,14 +8,16 @@ import (
 	"sync"
 )
 
-func runCommand(wg *sync.WaitGroup, commandIndex int, phase nodeData, cmd *exec.Cmd) {
+func runCommand(wg *sync.WaitGroup, commandIndex int, phase *nodeData, cmd *exec.Cmd) {
 	if wg != nil {
 		defer wg.Done()
 	}
 
+	commandName := strings.TrimSpace(fmt.Sprintf(`(INDEX %d) "%s" %+v`, commandIndex, cmd.Path, cmd.Args))
+
 	out, err := cmd.CombinedOutput()
 	if err != nil {
-		errMsg := fmt.Sprintf("ERROR (continue=%t): %s. OUT: %s\n", phase.ContinueOnFailure, err.Error(), string(out))
+		errMsg := fmt.Sprintf("ERROR (continue=%t): %s. OUT: %s. COMMAND: %s\n", phase.ContinueOnFailure, err.Error(), string(out), commandName)
 		if !phase.ContinueOnFailure {
 			logger.Fatallnf(errMsg)
 		} else {
@@ -24,14 +26,13 @@ func runCommand(wg *sync.WaitGroup, commandIndex int, phase nodeData, cmd *exec.
 		}
 	}
 
-	commandName := strings.TrimSpace(fmt.Sprintf(`(INDEX %d) "%s" %+v`, commandIndex, cmd.Path, cmd.Args))
 	logger.PrintCommandOutput(commandName, string(out))
 }
 
-func runPhase(setup *setup, phaseName string, phase nodeData) {
+func runPhase(setup *setup, phaseName string, phase *nodeData) {
 	var wg sync.WaitGroup
 
-	cmds, err := phase.GetExecCommandsFromSteps(setup.Variables)
+	cmds, err := phase.GetExecCommandsFromSteps(setup.StringVariablesOnly(), setup.Variables)
 	if err != nil {
 		logger.Fatallnf(err.Error())
 	}

setup.go

@@ -7,11 +7,11 @@ import (
 	"strings"
 )
 
-type phasesMap map[string]nodeData
+type phasesMap map[string]*nodeData
 
 type setup struct {
 	Phases    phasesMap
-	Variables map[string]string
+	Variables map[string]interface{}
 }
 
 //TODO: Do we need a check the `ContinueOnFailure==true` when `RunParallel==true`. Because if continue is false we will probably exit while another command is still busy in parallel
@@ -26,33 +26,62 @@ func (s *setup) Validate() error {
 	return nil
 }
 
+func (s *setup) ExpandRepeatingSteps() error {
+	for _, node := range s.Phases {
+		err := node.ExpandRepeatingSteps(s.Variables)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (s *setup) StringVariablesOnly() map[string]string {
+	m := make(map[string]string)
+	for k, v := range s.Variables {
+		if str, ok := v.(string); ok {
+			m[k] = str
+		}
+	}
+	return m
+}
+
 func ParseYamlFile(filePath string) (*setup, error) {
 	yamlBytes, err := ioutil.ReadFile(filePath)
 	if err != nil {
 		return nil, err
 	}
 
-	tmpPhases := make(phasesMap)
+	tmpPhases := make(map[string]nodeData)
 	if err = yaml.Unmarshal(yamlBytes, &tmpPhases); err != nil {
 		return nil, err
 	}
 	deleteVariablesFromPhasesMap(tmpPhases)
 
 	tmpVariables := &struct {
-		Variables map[string]string
+		Variables map[string]interface{}
 	}{}
 	if err = yaml.Unmarshal(yamlBytes, tmpVariables); err != nil {
 		return nil, err
 	}
 
+	pointerPhasesMap := make(phasesMap)
+	for key, phase := range tmpPhases {
+		pointerPhasesMap[key] = &phase
+	}
+
 	s := &setup{
-		tmpPhases,
+		pointerPhasesMap,
 		tmpVariables.Variables,
 	}
 
 	if err = s.Validate(); err != nil {
 		return nil, err
 	}
 
+	if err = s.ExpandRepeatingSteps(); err != nil {
+		return nil, err
+	}
+
 	return s, nil
 }

setup_node_data.go

@@ -1,8 +1,10 @@
 package main
 
 import (
+	"fmt"
 	"os"
 	"os/exec"
+	"strings"
 )
 
 type nodeData struct {
@@ -14,11 +16,57 @@ type nodeData struct {
 	Steps                 []nodeDataStep
 }
 
-func (n *nodeData) GetExecCommandsFromSteps(variables map[string]string) ([]*exec.Cmd, error) {
+func (n *nodeData) ExpandRepeatingSteps(variables map[string]interface{}) error {
+	expandedSteps := []nodeDataStep{}
+
+	for _, step := range n.Steps {
+		repeatPrefix := "repeat::"
+		if strings.HasPrefix(string(step), repeatPrefix) {
+			varNameAndStepLine := strings.TrimPrefix(string(step), repeatPrefix)
+
+			indexFirstSpace := strings.Index(varNameAndStepLine, " ")
+			if indexFirstSpace == -1 {
+				return fmt.Errorf("Unable to find a space after the repeat prefix '%s' in step line '%s'", repeatPrefix, string(step))
+			}
+
+			varName := strings.TrimSpace(varNameAndStepLine[0:indexFirstSpace])
+			if varName == "" {
+				return fmt.Errorf("The variable name is blank in the repeat prefixed step line '%s'", string(step))
+			}
+
+			var varSlice []interface{}
+			if val, ok := variables[varName]; !ok {
+				return fmt.Errorf("The variable '%s' is not found in variables list %#v", varName, variables)
+			} else if varSlice, ok = val.([]interface{}); !ok {
+				return fmt.Errorf("The variable '%s' with value '%#v' cannot be type-casted to string slice", varName, val)
+			}
+
+			repeatingStep := strings.TrimSpace(varNameAndStepLine[indexFirstSpace:])
+			if repeatingStep == "" {
+				return fmt.Errorf("The remaining step line after the repeat prefix '%s' is empty or white space in step line '%s'", repeatPrefix, string(step))
+			}
+
+			for _, v := range varSlice {
+				expandedStep, err := execTemplateToString(repeatingStep, v)
+				if err != nil {
+					return err
+				}
+				expandedSteps = append(expandedSteps, nodeDataStep(strings.TrimSpace(expandedStep)))
+			}
+		} else {
+			expandedSteps = append(expandedSteps, step)
+		}
+	}
+	n.Steps = expandedSteps
+
+	return nil
+}
+
+func (n *nodeData) GetExecCommandsFromSteps(stringVariables map[string]string, allVariables map[string]interface{}) ([]*exec.Cmd, error) {
 	cmds := []*exec.Cmd{}
 
 	for _, step := range n.Steps {
-		splittedStep, err := step.SplitAndReplaceVariables(variables)
+		splittedStep, err := step.SplitAndReplaceVariables(stringVariables, allVariables)
 		if err != nil {
 			return nil, err
 		}

setup_node_data_step.go

@@ -6,17 +6,13 @@ import (
 
 type nodeDataStep string
 
-//TODO: Is the best practice to replace variables after splitting or before?
-func (n nodeDataStep) SplitAndReplaceVariables(variables map[string]string) ([]string, error) {
-	preReplacedVars := replaceVariables(string(n), variables)
-	splittedStep, err := parsecommand.Parse(preReplacedVars)
+func (n nodeDataStep) SplitAndReplaceVariables(stringVariables map[string]string, allVariables map[string]interface{}) ([]string, error) {
+	step := replaceVariables(string(n), stringVariables)
+
+	splittedStep, err := parsecommand.Parse(step)
 	if err != nil {
 		return nil, err
 	}
 
-	/*for i, _ := range splittedStep {
-		splittedStep[i] = replaceVariables(splittedStep[i], variables)
-	}*/
-
 	return splittedStep, nil
 }

util.go

@@ -1,8 +1,10 @@
 package main
 
 import (
+	"bytes"
 	"fmt"
 	"strings"
+	"text/template"
 )
 
 func splitEnvironKeyValue(pair string) (string, string, error) {
@@ -71,7 +73,7 @@ func appendEnvironment(environ []string, toAppend ...string) ([]string, error) {
 	return newSlice, nil
 }
 
-func deleteVariablesFromPhasesMap(m phasesMap) {
+func deleteVariablesFromPhasesMap(m map[string]nodeData) {
 	for key, _ := range m {
 		if strings.EqualFold(key, "variables") {
 			delete(m, key)
@@ -87,3 +89,18 @@ func replaceVariables(s string, variables map[string]string) string {
 	}
 	return returnStr
 }
+
+func execTemplateToString(templateString string, data interface{}) (string, error) {
+	t, err := template.New("").Parse(templateString)
+	if err != nil {
+		return "", err
+	}
+
+	var doc bytes.Buffer
+	err = t.Execute(&doc, data)
+	if err != nil {
+		return "", err
+	}
+
+	return doc.String(), nil
+}