mirror of
https://github.com/opentofu/opentofu.git
synced 2025-02-20 11:48:24 -06:00
ff2936bb3f
If the shell spawns a subprocess which doesn't close the output file descriptors, the exec.Cmd will block on Wait() (see golang.org/issue/18874). Use an os.Pipe to provide the command with a real file descriptor so the exec package doesn't need to do the copy manually. This in turn may block our own reading goroutine, but we can select on that and leave it for cleanup later.
117 lines
2.7 KiB
Go
117 lines
2.7 KiB
Go
package localexec
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"os/exec"
|
|
"runtime"
|
|
|
|
"github.com/armon/circbuf"
|
|
"github.com/hashicorp/terraform/helper/schema"
|
|
"github.com/hashicorp/terraform/terraform"
|
|
"github.com/mitchellh/go-linereader"
|
|
)
|
|
|
|
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,
|
|
},
|
|
},
|
|
|
|
ApplyFunc: applyFn,
|
|
}
|
|
}
|
|
|
|
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")
|
|
}
|
|
|
|
// Execute the command using a shell
|
|
var shell, flag string
|
|
if runtime.GOOS == "windows" {
|
|
shell = "cmd"
|
|
flag = "/C"
|
|
} else {
|
|
shell = "/bin/sh"
|
|
flag = "-c"
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
|
|
// Setup the command
|
|
cmd := exec.CommandContext(ctx, shell, flag, command)
|
|
cmd.Stderr = pw
|
|
cmd.Stdout = pw
|
|
|
|
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: %s %s \"%s\"",
|
|
shell, flag, command))
|
|
|
|
// 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 {
|
|
return fmt.Errorf("Error running command '%s': %v. Output: %s",
|
|
command, err, output.Bytes())
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|