141 lines
2.9 KiB
Go
141 lines
2.9 KiB
Go
package command
|
|
|
|
import (
|
|
"flag"
|
|
"fmt"
|
|
"os"
|
|
"strings"
|
|
|
|
"github.com/hashicorp/terraform/terraform"
|
|
"github.com/mitchellh/cli"
|
|
)
|
|
|
|
// ApplyCommand is a Command implementation that applies a Terraform
|
|
// configuration and actually builds or changes infrastructure.
|
|
type ApplyCommand struct {
|
|
ShutdownCh <-chan struct{}
|
|
ContextOpts *terraform.ContextOpts
|
|
Ui cli.Ui
|
|
}
|
|
|
|
func (c *ApplyCommand) Run(args []string) int {
|
|
var init bool
|
|
var stateOutPath string
|
|
|
|
cmdFlags := flag.NewFlagSet("apply", flag.ContinueOnError)
|
|
cmdFlags.BoolVar(&init, "init", false, "init")
|
|
cmdFlags.StringVar(&stateOutPath, "out", "", "path")
|
|
cmdFlags.Usage = func() { c.Ui.Error(c.Help()) }
|
|
if err := cmdFlags.Parse(args); err != nil {
|
|
return 1
|
|
}
|
|
|
|
args = cmdFlags.Args()
|
|
if len(args) != 2 {
|
|
c.Ui.Error("The apply command expects two arguments.\n")
|
|
cmdFlags.Usage()
|
|
return 1
|
|
}
|
|
|
|
statePath := args[0]
|
|
configPath := args[1]
|
|
|
|
if stateOutPath == "" {
|
|
stateOutPath = statePath
|
|
}
|
|
|
|
planStatePath := statePath
|
|
if init {
|
|
planStatePath = ""
|
|
}
|
|
|
|
// Initialize Terraform right away
|
|
c.ContextOpts.Hooks = append(c.ContextOpts.Hooks, &UiHook{Ui: c.Ui})
|
|
ctx, err := ContextArg(configPath, planStatePath, c.ContextOpts)
|
|
if err != nil {
|
|
c.Ui.Error(err.Error())
|
|
return 1
|
|
}
|
|
if !validateContext(ctx, c.Ui) {
|
|
return 1
|
|
}
|
|
|
|
errCh := make(chan error)
|
|
stateCh := make(chan *terraform.State)
|
|
go func() {
|
|
state, err := ctx.Apply()
|
|
if err != nil {
|
|
errCh <- err
|
|
return
|
|
}
|
|
|
|
stateCh <- state
|
|
}()
|
|
|
|
err = nil
|
|
var state *terraform.State
|
|
select {
|
|
case <-c.ShutdownCh:
|
|
c.Ui.Output("Interrupt received. Gracefully shutting down...")
|
|
|
|
// Stop execution
|
|
ctx.Stop()
|
|
|
|
// Still get the result, since there is still one
|
|
select {
|
|
case <-c.ShutdownCh:
|
|
c.Ui.Error(
|
|
"Two interrupts received. Exiting immediately. Note that data\n" +
|
|
"loss may have occurred.")
|
|
return 1
|
|
case state = <-stateCh:
|
|
case err = <-errCh:
|
|
}
|
|
case state = <-stateCh:
|
|
case err = <-errCh:
|
|
}
|
|
|
|
if err != nil {
|
|
c.Ui.Error(fmt.Sprintf("Error applying plan: %s", err))
|
|
return 1
|
|
}
|
|
|
|
// Write state out to the file
|
|
f, err := os.Create(stateOutPath)
|
|
if err == nil {
|
|
err = terraform.WriteState(state, f)
|
|
f.Close()
|
|
}
|
|
if err != nil {
|
|
c.Ui.Error(fmt.Sprintf("Failed to save state: %s", err))
|
|
return 1
|
|
}
|
|
|
|
c.Ui.Output(strings.TrimSpace(state.String()))
|
|
|
|
return 0
|
|
}
|
|
|
|
func (c *ApplyCommand) Help() string {
|
|
helpText := `
|
|
Usage: terraform apply [options] STATE PATH
|
|
|
|
Builds or changes infrastructure according to the Terraform configuration
|
|
file.
|
|
|
|
Options:
|
|
|
|
-init If specified, it is okay to build brand new
|
|
infrastructure (with no state file specified).
|
|
|
|
-out=file.tfstate Path to save the new state. If not specified, the
|
|
state path argument will be used.
|
|
|
|
`
|
|
return strings.TrimSpace(helpText)
|
|
}
|
|
|
|
func (c *ApplyCommand) Synopsis() string {
|
|
return "Builds or changes infrastructure"
|
|
}
|