Add support or command as string and array

eg.

exec:
  - type: local
    command: date +%s
  - type: local
    command:
      - date
      - +%s

Fix also shell escaping

Author: mblaschke

sync/config.go

@@ -7,7 +7,6 @@ import (
 
 var waitGroup sync.WaitGroup
 
-
 type Filter struct {
 	Exclude []string
 	excludeRegexp []*regexp.Regexp
@@ -62,7 +61,7 @@ type Database struct {
 
 type Execution struct {
 	Type string
-	Command string
+	Command YamlStringArray
 	Workdir string
 	When string
 }

sync/connection.go

@@ -7,12 +7,18 @@ import (
 )
 
 func (connection *Connection) CommandBuilder(command string, args ...string) []interface{} {
+	//args = shell.QuoteValues(args...)
+
+	return connection.RawCommandBuilder(command, args...)
+}
+
+func (connection *Connection) RawCommandBuilder(command string, args ...string) []interface{} {
 	var ret []interface{}
 
 	if connection.WorkDir != "" {
 		shellArgs := []string{command}
 		shellArgs = append(shellArgs, args...)
-		return connection.ShellCommandBuilder(shellArgs...)
+		return connection.RawShellCommandBuilder(shellArgs...)
 	}
 
 	switch connection.GetType() {
@@ -32,6 +38,11 @@ func (connection *Connection) CommandBuilder(command string, args ...string) []i
 }
 
 func (connection *Connection) ShellCommandBuilder(args ...string) []interface{} {
+	args = shell.QuoteValues(args...)
+	return connection.RawShellCommandBuilder(args...)
+}
+
+func (connection *Connection) RawShellCommandBuilder(args ...string) []interface{} {
 	var ret []interface{}
 
 	inlineArgs := []string{}
@@ -40,12 +51,14 @@ func (connection *Connection) ShellCommandBuilder(args ...string) []interface{}
 		inlineArgs = append(inlineArgs, val)
 	}
 
-	inlineCommand := shell.Quote(strings.Join(inlineArgs, " "))
+	inlineCommand := strings.Join(inlineArgs, " ")
 
 	if connection.WorkDir != "" {
 		inlineCommand = fmt.Sprintf("cd %s ; %s", shell.Quote(connection.WorkDir), inlineCommand)
 	}
 
+	inlineCommand = shell.Quote(inlineCommand)
+
 	switch connection.GetType() {
 	case "local":
 		ret = connection.LocalCommandBuilder("/bin/sh", "-c", inlineCommand)

sync/connection_ssh.go

@@ -2,19 +2,23 @@ package sync
 
 import (
 	"fmt"
+	"strings"
+	"github.com/webdevops/go-shell"
 )
 
 func (connection *Connection) SshCommandBuilder(command string, args ...string) []interface{} {
+	remoteCmdParts := []string{command}
+	for _, val := range args {
+		remoteCmdParts = append(remoteCmdParts, val)
+	}
+	remoteCmd := shell.Quote(strings.Join(remoteCmdParts, " "))
+
 	sshArgs := []string{
 		"-oBatchMode=yes",
 		"-oPasswordAuthentication=no",
 		connection.SshConnectionHostnameString(),
 		"--",
-		command,
-	}
-
-	for _, val := range args {
-		sshArgs = append(sshArgs, val)
+		remoteCmd,
 	}
 
 	return ShellCommandInterfaceBuilder("ssh", sshArgs...)

sync/database_remote.go

@@ -1,8 +1,8 @@
 package sync
 
 import (
-	"github.com/webdevops/go-shell"
 	"strings"
+	"github.com/webdevops/go-shell"
 )
 
 func (database *Database) remoteMysqldumpCmdBuilder(additionalArgs []string, useFilter bool) []interface{} {
@@ -43,10 +43,10 @@ func (database *Database) remoteMysqldumpCmdBuilder(additionalArgs []string, use
 	}
 
 	cmd := []string{"mysqldump"}
-	cmd = append(cmd, args...)
-	cmd = append(cmd, "|", "gzip --stdout")
+	cmd = append(cmd, shell.QuoteValues(args...)...)
+	cmd = append(cmd, "|", "gzip", "--stdout")
 
-	return database.remoteConnection.ShellCommandBuilder(cmd...)
+	return database.remoteConnection.RawShellCommandBuilder(cmd...)
 }
 
 func (database *Database) remoteMysqlCmdBuilder(args ...string) []interface{} {
@@ -99,11 +99,7 @@ func (database *Database) remoteMysqlCmdBuilderUncompress(args ...string) []inte
 		args = append(args, database.Schema)
 	}
 
-	for key, val := range args {
-		args[key] = shell.Quote(val)
-	}
-
-	cmd := []string{"gunzip", "--stdout", "|", "mysql", strings.Join(args, " ")}
+	cmd := []string{"gunzip", "--stdout", "|", "mysql", strings.Join(shell.QuoteValues(args...), " ")}
 
-	return database.remoteConnection.ShellCommandBuilder(strings.Join(cmd, " "))
+	return database.remoteConnection.RawShellCommandBuilder(cmd...)
 }

sync/execution.go

@@ -15,13 +15,16 @@ func (execution *Execution) String(server *Server) string {
 	if execution.Workdir != "" {
 		parts = append(parts, fmt.Sprintf("Workdir:%s", execution.Workdir))
 	}
-	parts = append(parts, fmt.Sprintf("Command:%s", execution.Command))
+	parts = append(parts, fmt.Sprintf("Command:%s", execution.Command.ToString(" ")))
 
 	return fmt.Sprintf("Exec[%s]", strings.Join(parts[:]," "))
 }
 
 func (execution *Execution) Execute(server *Server) {
-	shell.Cmd(execution.commandBuilder(server)...)
+	cmd := execution.commandBuilder(server)
+	run := shell.Cmd(cmd...).Run()
+
+	Logger.Verbose(run.Stdout.String())
 }
 
 func (execution *Execution) commandBuilder(server *Server) []interface{} {
@@ -38,7 +41,13 @@ func (execution *Execution) commandBuilder(server *Server) []interface{} {
 		connection.WorkDir = execution.Workdir
 	}
 
-	return connection.CommandBuilder(execution.Command)
+	if len(execution.Command.Multi) >= 1 {
+		// multi element command (use safer quoting)
+		return connection.ShellCommandBuilder(execution.Command.Multi...)
+	} else {
+		// single string command (use as is)
+		return connection.RawShellCommandBuilder(execution.Command.Single)
+	}
 }
 
 func (execution *Execution) GetType() string {

sync/helper.go

@@ -19,7 +19,7 @@ func ShellCommandInterfaceBuilder(command string, args ...string) []interface{}
 	}
 
 	for _, val := range args {
-		cmd = append(cmd, shell.Quote(val))
+		cmd = append(cmd, val)
 	}
 
 	shellCmd := make([]interface{}, len(cmd))
@@ -99,6 +99,8 @@ func ShellErrorHandler(recover interface{}) {
 			printMessage("Stdout", process.Stdout.String())
 			printMessage("Stderr", process.Stderr.String())
 			printMessage("Exit code", fmt.Sprintf("%d", p))
+
+			os.Exit(2)
 		}
 	}
 }

sync/server_deploy.go

@@ -2,8 +2,8 @@ package sync
 
 func (server *Server) Deploy() {
 	defer func() {
-		//recover := recover()
-		//ShellErrorHandler(recover)
+		recover := recover()
+		ShellErrorHandler(recover)
 	}()
 
 	server.RunExec("startup")

sync/yaml.go

@@ -0,0 +1,46 @@
+package sync
+
+import "strings"
+
+type YamlStringArray struct {
+	Multi  []string
+	Single  string
+}
+
+func (ysa *YamlStringArray) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var multi []string
+	err := unmarshal(&multi)
+	if err != nil {
+		var single string
+		err := unmarshal(&single)
+		if err != nil {
+			return err
+		}
+		ysa.Single = single
+	} else {
+		ysa.Multi = multi
+	}
+	return nil
+}
+
+func (ysa *YamlStringArray) String() string {
+	return ysa.ToString(";")
+}
+
+func (ysa *YamlStringArray) ToString(sep string) string {
+	if len(ysa.Multi) >= 1 {
+		return strings.Join(ysa.Multi, sep)
+	} else {
+		return ysa.Single
+	}
+}
+
+func (ysa *YamlStringArray) Array() []string {
+	if len(ysa.Multi) >= 1 {
+		return ysa.Multi
+	} else if ysa.Single != "" {
+		return []string{ysa.Single}
+	} else {
+		return []string{}
+	}
+}