func (b *BashWriter) Variable(variable common.BuildVariable) {
if variable.File {
variableFile := b.Absolute(path.Join(b.TemporaryPath, variable.Key))
b.Line(fmt.Sprintf("mkdir -p %q", helpers.ToSlash(b.TemporaryPath)))
b.Line(fmt.Sprintf("echo -n %s > %q", helpers.ShellEscape(variable.Value), variableFile))
b.Line(fmt.Sprintf("export %s=%q", helpers.ShellEscape(variable.Key), variableFile))
} else {
b.Line(fmt.Sprintf("export %s=%s", helpers.ShellEscape(variable.Key), helpers.ShellEscape(variable.Value)))
}
}
func (s *Command) fullCommand() string {
var arguments []string
// TODO: This method is compatible only with Bjourne compatible shells
for _, part := range s.Command {
arguments = append(arguments, helpers.ShellEscape(part))
}
return strings.Join(arguments, " ")
}
func (b *BashWriter) Finish() string {
var buffer bytes.Buffer
w := bufio.NewWriter(&buffer)
io.WriteString(w, "set -eo pipefail\n")
io.WriteString(w, "set +o noclobber\n")
io.WriteString(w, ": | eval "+helpers.ShellEscape(b.String())+"\n")
w.Flush()
return buffer.String()
}
func (b *BashWriter) Command(command string, arguments ...string) {
list := []string{
helpers.ShellEscape(command),
}
for _, argument := range arguments {
list = append(list, strconv.Quote(argument))
}
b.Line(strings.Join(list, " "))
}
func (s *Client) Run(cmd Command) error {
if s.client == nil {
return errors.New("Not connected")
}
session, err := s.client.NewSession()
if err != nil {
return err
}
defer session.Close()
var envVariables bytes.Buffer
for _, keyValue := range cmd.Environment {
envVariables.WriteString("export " + helpers.ShellEscape(keyValue) + "\n")
}
session.Stdin = io.MultiReader(
&envVariables,
bytes.NewBufferString(cmd.Stdin),
)
session.Stdout = s.Stdout
session.Stderr = s.Stderr
err = session.Start(cmd.fullCommand())
if err != nil {
return err
}
waitCh := make(chan error)
go func() {
err := session.Wait()
if _, ok := err.(*ssh.ExitError); ok {
err = &ExitError{Inner: err}
}
waitCh <- err
}()
select {
case <-cmd.Abort:
session.Signal(ssh.SIGKILL)
session.Close()
return <-waitCh
case err := <-waitCh:
return err
}
}
func (b *BashWriter) Error(format string, arguments ...interface{}) {
coloredText := helpers.ANSI_BOLD_RED + fmt.Sprintf(format, arguments...) + helpers.ANSI_RESET
b.Line("echo " + helpers.ShellEscape(coloredText))
}