terraform/builtin/provisioners/local-exec/resource_provisioner.go

159 lines
3.9 KiB
Go
Raw Normal View History

2014-07-09 22:34:08 +02:00
package localexec
import (
"context"
2014-07-09 22:34:08 +02:00
"fmt"
"io"
"os"
2014-07-09 22:34:08 +02:00
"os/exec"
"runtime"
"github.com/armon/circbuf"
"github.com/hashicorp/terraform/helper/schema"
2014-07-09 22:34:08 +02:00
"github.com/hashicorp/terraform/terraform"
"github.com/mitchellh/go-linereader"
2014-07-09 22:34:08 +02:00
)
const (
// maxBufSize limits how much output we collect from a local
// invocation. This is to prevent TF memory usage from growing
// to an enormous amount due to a faulty process.
maxBufSize = 8 * 1024
)
func Provisioner() terraform.ResourceProvisioner {
return &schema.Provisioner{
Schema: map[string]*schema.Schema{
"command": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
"interpreter": &schema.Schema{
Type: schema.TypeList,
Elem: &schema.Schema{Type: schema.TypeString},
Optional: true,
},
"working_dir": &schema.Schema{
Type: schema.TypeString,
Optional: true,
},
"environment": &schema.Schema{
Type: schema.TypeMap,
Optional: true,
},
},
2014-07-09 22:34:08 +02:00
ApplyFunc: applyFn,
2014-07-09 22:34:08 +02:00
}
}
func applyFn(ctx context.Context) error {
data := ctx.Value(schema.ProvConfigDataKey).(*schema.ResourceData)
o := ctx.Value(schema.ProvOutputKey).(terraform.UIOutput)
command := data.Get("command").(string)
if command == "" {
return fmt.Errorf("local-exec provisioner command must be a non-empty string")
2014-07-09 22:34:08 +02:00
}
// Execute the command with env
environment := data.Get("environment").(map[string]interface{})
var env []string
for k := range environment {
entry := fmt.Sprintf("%s=%s", k, environment[k].(string))
env = append(env, entry)
}
2014-07-09 22:34:08 +02:00
// Execute the command using a shell
interpreter := data.Get("interpreter").([]interface{})
var cmdargs []string
if len(interpreter) > 0 {
for _, i := range interpreter {
if arg, ok := i.(string); ok {
cmdargs = append(cmdargs, arg)
}
}
2014-07-09 22:34:08 +02:00
} else {
if runtime.GOOS == "windows" {
cmdargs = []string{"cmd", "/C"}
} else {
cmdargs = []string{"/bin/sh", "-c"}
}
2014-07-09 22:34:08 +02:00
}
cmdargs = append(cmdargs, command)
2014-07-09 22:34:08 +02:00
workingdir := data.Get("working_dir").(string)
// Setup the reader that will read the output from the command.
// We use an os.Pipe so that the *os.File can be passed directly to the
// process, and not rely on goroutines copying the data which may block.
// See golang.org/issue/18874
pr, pw, err := os.Pipe()
if err != nil {
return fmt.Errorf("failed to initialize pipe for output: %s", err)
}
var cmdEnv []string
cmdEnv = os.Environ()
cmdEnv = append(cmdEnv, env...)
2014-07-09 22:34:08 +02:00
// Setup the command
cmd := exec.CommandContext(ctx, cmdargs[0], cmdargs[1:]...)
cmd.Stderr = pw
cmd.Stdout = pw
// Dir specifies the working directory of the command.
// If Dir is the empty string (this is default), runs the command
// in the calling process's current directory.
cmd.Dir = workingdir
// Env specifies the environment of the command.
// By default will use the calling process's environment
cmd.Env = cmdEnv
2014-07-09 22:34:08 +02:00
output, _ := circbuf.NewBuffer(maxBufSize)
// Write everything we read from the pipe to the output buffer too
tee := io.TeeReader(pr, output)
// copy the teed output to the UI output
copyDoneCh := make(chan struct{})
go copyOutput(o, tee, copyDoneCh)
// Output what we're about to run
o.Output(fmt.Sprintf("Executing: %q", cmdargs))
2014-07-09 22:34:08 +02:00
// Start the command
err = cmd.Start()
if err == nil {
err = cmd.Wait()
}
// Close the write-end of the pipe so that the goroutine mirroring output
// ends properly.
pw.Close()
// Cancelling the command may block the pipe reader if the file descriptor
// was passed to a child process which hasn't closed it. In this case the
// copyOutput goroutine will just hang out until exit.
select {
case <-copyDoneCh:
case <-ctx.Done():
}
if err != nil {
2014-07-22 19:38:39 +02:00
return fmt.Errorf("Error running command '%s': %v. Output: %s",
2014-07-09 22:34:08 +02:00
command, err, output.Bytes())
}
2014-07-22 19:38:39 +02:00
return nil
2014-07-09 22:34:08 +02:00
}
func copyOutput(o terraform.UIOutput, r io.Reader, doneCh chan<- struct{}) {
defer close(doneCh)
lr := linereader.New(r)
for line := range lr.Ch {
o.Output(line)
}
}