f555e7a9f2
* I had to contextualise Communicator.Start and RemoteCmd.StartWithUi NOTE: Communicator.Start starts a RemoteCmd but RemoteCmd.StartWithUi will run the cmd and wait for a return, so I renamed StartWithUi to RunWithUi so that the intent is clearer. Ideally in the future RunWithUi will be named back to StartWithUi and the exit status or wait funcs of the command will allow to wait for a return. If you do so please read carrefully https://golang.org/pkg/os/exec/#Cmd.Stdout to avoid a deadlock * cmd.ExitStatus to cmd.ExitStatus() is now blocking to avoid race conditions * also had to simplify StartWithUi
90 lines
2.1 KiB
Go
90 lines
2.1 KiB
Go
package hyperone
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"log"
|
|
"strings"
|
|
|
|
"github.com/hashicorp/packer/helper/multistep"
|
|
"github.com/hashicorp/packer/packer"
|
|
"github.com/hashicorp/packer/template/interpolate"
|
|
openapi "github.com/hyperonecom/h1-client-go"
|
|
)
|
|
|
|
func formatOpenAPIError(err error) string {
|
|
openAPIError, ok := err.(openapi.GenericOpenAPIError)
|
|
if !ok {
|
|
return err.Error()
|
|
}
|
|
|
|
return fmt.Sprintf("%s (body: %s)", openAPIError.Error(), openAPIError.Body())
|
|
}
|
|
|
|
func runCommands(commands []string, ictx interpolate.Context, state multistep.StateBag) error {
|
|
ctx := context.TODO()
|
|
ui := state.Get("ui").(packer.Ui)
|
|
wrappedCommand := state.Get("wrappedCommand").(CommandWrapper)
|
|
comm := state.Get("communicator").(packer.Communicator)
|
|
|
|
for _, rawCmd := range commands {
|
|
intCmd, err := interpolate.Render(rawCmd, &ictx)
|
|
if err != nil {
|
|
return fmt.Errorf("error interpolating: %s", err)
|
|
}
|
|
|
|
command, err := wrappedCommand(intCmd)
|
|
if err != nil {
|
|
return fmt.Errorf("error wrapping command: %s", err)
|
|
}
|
|
|
|
remoteCmd := &packer.RemoteCmd{
|
|
Command: command,
|
|
}
|
|
|
|
ui.Say(fmt.Sprintf("Executing command: %s", command))
|
|
|
|
err = remoteCmd.RunWithUi(ctx, comm, ui)
|
|
if err != nil {
|
|
return fmt.Errorf("error running remote cmd: %s", err)
|
|
}
|
|
|
|
if remoteCmd.ExitStatus() != 0 {
|
|
return fmt.Errorf(
|
|
"received non-zero exit code %d from command: %s",
|
|
remoteCmd.ExitStatus(),
|
|
command)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func captureOutput(command string, state multistep.StateBag) (string, error) {
|
|
ctx := context.TODO()
|
|
comm := state.Get("communicator").(packer.Communicator)
|
|
|
|
var stdout bytes.Buffer
|
|
remoteCmd := &packer.RemoteCmd{
|
|
Command: command,
|
|
Stdout: &stdout,
|
|
}
|
|
|
|
log.Println(fmt.Sprintf("Executing command: %s", command))
|
|
|
|
err := comm.Start(ctx, remoteCmd)
|
|
if err != nil {
|
|
return "", fmt.Errorf("error running remote cmd: %s", err)
|
|
}
|
|
|
|
remoteCmd.Wait()
|
|
if remoteCmd.ExitStatus() != 0 {
|
|
return "", fmt.Errorf(
|
|
"received non-zero exit code %d from command: %s",
|
|
remoteCmd.ExitStatus(),
|
|
command)
|
|
}
|
|
|
|
return strings.TrimSpace(stdout.String()), nil
|
|
}
|