Lots of improvements:

- Added a logger and using `github.com/fatih/color`
- Can now run a phase `Steps` in parallel by specifying `run_parallel: true` in the phase yaml
- Added quick start guide in README

Author: francoishill

README.md

@@ -1,4 +1,29 @@
 # yaml-script-runner
 Just a basic script runner to easily abort/continue on previous step failure
 
-# WIP: Working on first implementation
+## Quick Start
+
+### /path/to/my-setup.yaml:
+
+```
+variables:
+  COMMAND_VAR: where python && echo Hallo
+
+Phase 1: 
+  continue_on_failure: true
+  inherit_environment: true
+  run_parallel: true
+  AdditionalEnvironment:
+    - MyEnviron1=Value1
+  executor: ["sh", "-c"]
+  steps:
+    - where python
+    - $COMMAND_VAR && echo test123
+```
+
+### Install and run
+
+```
+go get -u github.com/golang-devops/yaml-script-runner
+yaml-script-runner "/path/to/my-setup.yaml"
+```

logger.go

@@ -0,0 +1,64 @@
+package main
+
+import (
+	"github.com/fatih/color"
+	"io"
+	"log"
+	"os"
+	"sync"
+)
+
+var logger = NewLogger(os.Stdout /*ioutil.Discard*/, os.Stdout, os.Stdout, os.Stderr)
+
+func NewLogger(traceHandle, infoHandle, warningHandle, errorHandle io.Writer) *Logger {
+	return &Logger{
+		colorTraceSprintfFunc:   color.New().SprintfFunc(),
+		colorInfoSprintfFunc:    color.New(color.FgHiGreen).SprintfFunc(),
+		colorWarningSprintfFunc: color.New(color.FgHiYellow).SprintfFunc(),
+		colorErrSprintfFunc:     color.New(color.FgRed).SprintfFunc(),
+
+		trace:   log.New(traceHandle, "[T] ", log.Ldate|log.Ltime|log.Lshortfile),
+		info:    log.New(infoHandle, "[I] ", log.Ldate|log.Ltime|log.Lshortfile),
+		warning: log.New(warningHandle, "[W] ", log.Ldate|log.Ltime|log.Lshortfile),
+		err:     log.New(errorHandle, "[E] ", log.Ldate|log.Ltime|log.Lshortfile),
+	}
+}
+
+type Logger struct {
+	sync.RWMutex
+
+	colorTraceSprintfFunc   func(format string, args ...interface{}) string
+	colorInfoSprintfFunc    func(format string, args ...interface{}) string
+	colorWarningSprintfFunc func(format string, args ...interface{}) string
+	colorErrSprintfFunc     func(format string, args ...interface{}) string
+
+	trace   *log.Logger
+	info    *log.Logger
+	warning *log.Logger
+	err     *log.Logger
+}
+
+func (l *Logger) Tracelnf(format string, args ...interface{}) {
+	l.trace.Println(l.colorTraceSprintfFunc(format+"\n", args...))
+}
+func (l *Logger) Infolnf(format string, args ...interface{}) {
+	l.info.Println(l.colorInfoSprintfFunc(format+"\n", args...))
+}
+func (l *Logger) Warninglnf(format string, args ...interface{}) {
+	l.warning.Println(l.colorWarningSprintfFunc(format+"\n", args...))
+}
+func (l *Logger) Errorlnf(format string, args ...interface{}) {
+	l.err.Println(l.colorErrSprintfFunc(format+"\n", args...))
+}
+func (l *Logger) Fatallnf(format string, args ...interface{}) {
+	l.err.Fatalln(l.colorErrSprintfFunc(format+"\n", args...))
+}
+
+func (l *Logger) PrintCommandOutput(commandName string, output string) {
+	l.Lock()
+	defer l.Unlock()
+
+	l.Infolnf("[BEGIN OUTPUT of %s]", commandName)
+	color.New(color.FgHiCyan).Println(string(output))
+	l.Infolnf("[END OUTPUT of %s]", commandName)
+}

main.go

@@ -2,39 +2,72 @@ package main
 
 import (
 	"fmt"
-	"log"
 	"os"
+	"os/exec"
+	"strings"
+	"sync"
 )
 
+func runCommand(wg *sync.WaitGroup, commandIndex int, phase nodeData, cmd *exec.Cmd) {
+	if wg != nil {
+		defer wg.Done()
+	}
+
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		errMsg := fmt.Sprintf("ERROR (continue=%t): %s. OUT: %s\n", phase.ContinueOnFailure, err.Error(), string(out))
+		if !phase.ContinueOnFailure {
+			logger.Fatallnf(errMsg)
+		} else {
+			logger.Errorlnf(errMsg)
+			return
+		}
+	}
+
+	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) {
+	var wg sync.WaitGroup
+
+	cmds, err := phase.GetExecCommandsFromSteps(setup.Variables)
+	if err != nil {
+		logger.Fatallnf(err.Error())
+	}
+
+	if phase.RunParallel {
+		wg.Add(len(cmds))
+	}
+
+	logger.Infolnf("Running step %s", phaseName)
+	for ind, c := range cmds {
+		var wgToUse *sync.WaitGroup = nil
+		if phase.RunParallel {
+			wgToUse = &wg
+		}
+
+		go runCommand(wgToUse, ind, phase, c)
+	}
+
+	if phase.RunParallel {
+		wg.Wait()
+	}
+}
+
 func main() {
 	if len(os.Args) < 2 {
-		log.Fatal("The first command-line argument must be the YAML file path.")
+		logger.Fatallnf("The first command-line argument must be the YAML file path.")
 	}
 
 	yamlFilePath := os.Args[1]
 
 	setup, err := ParseYamlFile(yamlFilePath)
 	if err != nil {
-		log.Fatal(err)
+		logger.Fatallnf(err.Error())
 	}
 
-	cmds, err := setup.GetExecCommandsFromSteps()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	for _, c := range cmds {
-		out, err := c.CombinedOutput()
-		if err != nil {
-			errMsg := fmt.Sprintf("ERROR (continue=%t): %s. OUT: %s\n", setup.ContinueIfStepFailed, err.Error(), string(out))
-			if !setup.ContinueIfStepFailed {
-				log.Fatalln(errMsg)
-			} else {
-				log.Println(errMsg)
-				continue
-			}
-		}
-
-		fmt.Println(string(out))
+	for name, phase := range setup.Phases {
+		runPhase(setup, name, phase)
 	}
 }

setup.go

@@ -1,40 +1,29 @@
 package main
 
 import (
+	"fmt"
 	"github.com/ghodss/yaml"
-	"github.com/golang-devops/parsecommand"
 	"io/ioutil"
-	"os/exec"
+	"strings"
 )
 
+type phasesMap map[string]nodeData
+
 type setup struct {
-	ContinueIfStepFailed bool `json:"continue_if_step_failed"`
-	Executor             []string
-	Steps                []string
+	Phases    phasesMap
+	Variables map[string]string
 }
 
-func (s *setup) GetExecCommandsFromSteps() ([]*exec.Cmd, error) {
-	cmds := []*exec.Cmd{}
-
-	for _, step := range s.Steps {
-		splittedStep, err := parsecommand.Parse(step)
-		if err != nil {
-			return nil, err
-		}
-
-		allArgs := s.Executor
-		allArgs = append(allArgs, splittedStep...)
-
-		exe := allArgs[0]
-		args := []string{}
-		if len(allArgs) > 1 {
-			args = allArgs[1:]
+//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
+func (s *setup) Validate() error {
+	for _, node := range s.Phases {
+		for _, e := range node.AdditionalEnvironment {
+			if !strings.Contains(e, "=") {
+				return fmt.Errorf("Environment string must be in format key=value. Invalid string: '%s'", e)
+			}
 		}
-
-		cmds = append(cmds, exec.Command(exe, args...))
 	}
-
-	return cmds, nil
+	return nil
 }
 
 func ParseYamlFile(filePath string) (*setup, error) {
@@ -43,9 +32,25 @@ func ParseYamlFile(filePath string) (*setup, error) {
 		return nil, err
 	}
 
-	s := &setup{}
-	err = yaml.Unmarshal(yamlBytes, s)
-	if err != nil {
+	tmpPhases := make(phasesMap)
+	if err = yaml.Unmarshal(yamlBytes, &tmpPhases); err != nil {
+		return nil, err
+	}
+	deleteVariablesFromPhasesMap(tmpPhases)
+
+	tmpVariables := &struct {
+		Variables map[string]string
+	}{}
+	if err = yaml.Unmarshal(yamlBytes, tmpVariables); err != nil {
+		return nil, err
+	}
+
+	s := &setup{
+		tmpPhases,
+		tmpVariables.Variables,
+	}
+
+	if err = s.Validate(); err != nil {
 		return nil, err
 	}
 

setup_node_data.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"os"
+	"os/exec"
+)
+
+type nodeData struct {
+	ContinueOnFailure     bool `json:"continue_on_failure"`
+	InheritEnvironment    bool `json:"inherit_environment"`
+	AdditionalEnvironment []string
+	RunParallel           bool `json:"run_parallel"`
+	Executor              []string
+	Steps                 []nodeDataStep
+}
+
+func (n *nodeData) GetExecCommandsFromSteps(variables map[string]string) ([]*exec.Cmd, error) {
+	cmds := []*exec.Cmd{}
+
+	for _, step := range n.Steps {
+		splittedStep, err := step.SplitAndReplaceVariables(variables)
+		if err != nil {
+			return nil, err
+		}
+
+		allArgs := n.Executor
+		allArgs = append(allArgs, splittedStep...)
+
+		exe := allArgs[0]
+		args := []string{}
+		if len(allArgs) > 1 {
+			args = allArgs[1:]
+		}
+
+		c := exec.Command(exe, args...)
+
+		if n.InheritEnvironment {
+			c.Env, err = appendEnvironment(c.Env, os.Environ()...)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		for _, e := range n.AdditionalEnvironment {
+			c.Env, err = appendEnvironment(c.Env, e)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		cmds = append(cmds, c)
+	}
+
+	return cmds, nil
+}

setup_node_data_step.go

@@ -0,0 +1,22 @@
+package main
+
+import (
+	"github.com/golang-devops/parsecommand"
+)
+
+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)
+	if err != nil {
+		return nil, err
+	}
+
+	/*for i, _ := range splittedStep {
+		splittedStep[i] = replaceVariables(splittedStep[i], variables)
+	}*/
+
+	return splittedStep, nil
+}