terraform/command/apply.go

389 lines
12 KiB
Go
Raw Normal View History

2014-05-24 21:27:58 +02:00
package command
import (
2014-06-19 01:42:13 +02:00
"fmt"
2014-05-24 21:27:58 +02:00
"strings"
"github.com/hashicorp/terraform/command/arguments"
"github.com/hashicorp/terraform/command/views"
"github.com/hashicorp/terraform/internal/backend"
remoteBackend "github.com/hashicorp/terraform/internal/backend/remote"
"github.com/hashicorp/terraform/internal/tfdiags"
"github.com/hashicorp/terraform/plans/planfile"
2014-05-24 21:27:58 +02:00
)
// ApplyCommand is a Command implementation that applies a Terraform
// configuration and actually builds or changes infrastructure.
type ApplyCommand struct {
Meta
2014-10-01 06:49:24 +02:00
// If true, then this apply command will become the "destroy"
// command. It is just like apply but only processes a destroy.
Destroy bool
2014-05-24 21:27:58 +02:00
}
2021-02-18 23:23:34 +01:00
func (c *ApplyCommand) Run(rawArgs []string) int {
var diags tfdiags.Diagnostics
2021-02-18 23:23:34 +01:00
// Parse and apply global view arguments
common, rawArgs := arguments.ParseView(rawArgs)
c.View.Configure(common)
// Propagate -no-color for the remote backend's legacy use of Ui. This
// should be removed when the remote backend is migrated to views.
c.Meta.color = !common.NoColor
c.Meta.Color = c.Meta.color
2021-02-18 23:23:34 +01:00
// Parse and validate flags
var args *arguments.Apply
switch {
case c.Destroy:
args, diags = arguments.ParseApplyDestroy(rawArgs)
default:
args, diags = arguments.ParseApply(rawArgs)
}
2021-02-18 23:23:34 +01:00
// Instantiate the view, even if there are flag errors, so that we render
// diagnostics according to the desired view
var view views.Apply
view = views.NewApply(args.ViewType, c.Destroy, c.View)
2021-02-18 23:23:34 +01:00
if diags.HasErrors() {
view.Diagnostics(diags)
view.HelpPrompt()
return 1
2014-10-01 06:49:24 +02:00
}
2021-02-18 23:23:34 +01:00
// Check for user-supplied plugin path
var err error
if c.pluginPath, err = c.loadPluginPath(); err != nil {
diags = diags.Append(err)
view.Diagnostics(diags)
2014-06-19 01:42:13 +02:00
return 1
}
2021-02-18 23:23:34 +01:00
// Attempt to load the plan file, if specified
planFile, diags := c.LoadPlanFile(args.PlanPath)
if diags.HasErrors() {
2021-02-18 23:23:34 +01:00
view.Diagnostics(diags)
return 1
}
// Check for invalid combination of plan file and variable overrides
if planFile != nil && !args.Vars.Empty() {
diags = diags.Append(tfdiags.Sourceless(
tfdiags.Error,
"Can't set variables when applying a saved plan",
"The -var and -var-file options cannot be used when applying a saved plan file, because a saved plan includes the variable values that were set when it was created.",
))
view.Diagnostics(diags)
return 1
}
2021-02-18 23:23:34 +01:00
// FIXME: the -input flag value is needed to initialize the backend and the
// operation, but there is no clear path to pass this value down, so we
// continue to mutate the Meta object state for now.
c.Meta.input = args.InputEnabled
// FIXME: the -parallelism flag is used to control the concurrency of
// Terraform operations. At the moment, this value is used both to
// initialize the backend via the ContextOpts field inside CLIOpts, and to
// set a largely unused field on the Operation request. Again, there is no
// clear path to pass this value down, so we continue to mutate the Meta
// object state for now.
c.Meta.parallelism = args.Operation.Parallelism
// Prepare the backend, passing the plan file if present, and the
// backend-specific arguments
be, beDiags := c.PrepareBackend(planFile, args.State)
diags = diags.Append(beDiags)
if diags.HasErrors() {
view.Diagnostics(diags)
return 1
}
2021-02-18 23:23:34 +01:00
// Build the operation request
opReq, opDiags := c.OperationRequest(be, view, planFile, args.Operation, args.AutoApprove)
2021-02-18 23:23:34 +01:00
diags = diags.Append(opDiags)
// Collect variable value and add them to the operation request
diags = diags.Append(c.GatherVariables(opReq, args.Vars))
// Before we delegate to the backend, we'll print any warning diagnostics
// we've accumulated here, since the backend will start fresh with its own
// diagnostics.
view.Diagnostics(diags)
if diags.HasErrors() {
return 1
}
diags = nil
// Run the operation
op, err := c.RunOperation(be, opReq)
2017-01-19 05:50:45 +01:00
if err != nil {
2021-02-18 23:23:34 +01:00
diags = diags.Append(err)
view.Diagnostics(diags)
2014-06-19 01:42:13 +02:00
return 1
}
2021-02-18 23:23:34 +01:00
if op.Result != backend.OperationSuccess {
return op.Result.ExitStatus()
}
// Render the resource count and outputs, unless we're using the remote
// backend locally, in which case these are rendered remotely
if rb, isRemoteBackend := be.(*remoteBackend.Remote); !isRemoteBackend || rb.IsLocalOperations() {
view.ResourceCount(args.State.StateOutPath)
if !c.Destroy && op.State != nil {
view.Outputs(op.State.RootModule().OutputValues)
}
2021-02-18 23:23:34 +01:00
}
view.Diagnostics(diags)
if diags.HasErrors() {
return 1
}
2021-02-18 23:23:34 +01:00
return 0
}
func (c *ApplyCommand) LoadPlanFile(path string) (*planfile.Reader, tfdiags.Diagnostics) {
var planFile *planfile.Reader
2021-02-18 23:23:34 +01:00
var diags tfdiags.Diagnostics
// Try to load plan if path is specified
if path != "" {
var err error
planFile, err = c.PlanFile(path)
if err != nil {
2021-02-18 23:23:34 +01:00
diags = diags.Append(tfdiags.Sourceless(
tfdiags.Error,
fmt.Sprintf("Failed to load %q as a plan file", path),
fmt.Sprintf("Error: %s", err),
))
return nil, diags
}
// If the path doesn't look like a plan, both planFile and err will be
// nil. In that case, the user is probably trying to use the positional
// argument to specify a configuration path. Point them at -chdir.
if planFile == nil {
2021-02-18 23:23:34 +01:00
diags = diags.Append(tfdiags.Sourceless(
tfdiags.Error,
fmt.Sprintf("Failed to load %q as a plan file", path),
"The specified path is a directory, not a plan file. You can use the global -chdir flag to use this directory as the configuration root.",
))
return nil, diags
}
// If we successfully loaded a plan but this is a destroy operation,
// explain that this is not supported.
if c.Destroy {
diags = diags.Append(tfdiags.Sourceless(
tfdiags.Error,
2021-02-18 23:23:34 +01:00
"Destroy can't be called with a plan file",
fmt.Sprintf("If this plan was created using plan -destroy, apply it using:\n terraform apply %q", path),
))
2021-02-18 23:23:34 +01:00
return nil, diags
}
}
2021-02-18 23:23:34 +01:00
return planFile, diags
}
func (c *ApplyCommand) PrepareBackend(planFile *planfile.Reader, args *arguments.State) (backend.Enhanced, tfdiags.Diagnostics) {
var diags tfdiags.Diagnostics
// FIXME: we need to apply the state arguments to the meta object here
// because they are later used when initializing the backend. Carving a
// path to pass these arguments to the functions that need them is
// difficult but would make their use easier to understand.
c.Meta.applyStateArguments(args)
// Load the backend
var be backend.Enhanced
var beDiags tfdiags.Diagnostics
if planFile == nil {
2021-02-18 23:23:34 +01:00
backendConfig, configDiags := c.loadBackendConfig(".")
diags = diags.Append(configDiags)
if configDiags.HasErrors() {
2021-02-18 23:23:34 +01:00
return nil, diags
2017-01-19 05:50:45 +01:00
}
be, beDiags = c.Backend(&BackendOpts{
Config: backendConfig,
})
} else {
plan, err := planFile.ReadPlan()
if err != nil {
diags = diags.Append(tfdiags.Sourceless(
tfdiags.Error,
"Failed to read plan from plan file",
fmt.Sprintf("Cannot read the plan from the given plan file: %s.", err),
))
2021-02-18 23:23:34 +01:00
return nil, diags
}
if plan.Backend.Config == nil {
// Should never happen; always indicates a bug in the creation of the plan file
diags = diags.Append(tfdiags.Sourceless(
tfdiags.Error,
"Failed to read plan from plan file",
2020-12-01 16:42:07 +01:00
"The given plan file does not have a valid backend configuration. This is a bug in the Terraform command that generated this plan file.",
))
2021-02-18 23:23:34 +01:00
return nil, diags
}
be, beDiags = c.BackendForPlan(plan.Backend)
}
2021-02-18 23:23:34 +01:00
diags = diags.Append(beDiags)
if beDiags.HasErrors() {
2021-02-18 23:23:34 +01:00
return nil, diags
2017-01-19 05:50:45 +01:00
}
2021-02-18 23:23:34 +01:00
return be, diags
}
func (c *ApplyCommand) OperationRequest(
be backend.Enhanced,
view views.Apply,
planFile *planfile.Reader,
args *arguments.Operation,
autoApprove bool,
2021-02-18 23:23:34 +01:00
) (*backend.Operation, tfdiags.Diagnostics) {
var diags tfdiags.Diagnostics
2017-01-19 05:50:45 +01:00
// Applying changes with dev overrides in effect could make it impossible
// to switch back to a release version if the schema isn't compatible,
// so we'll warn about it.
diags = diags.Append(c.providerDevOverrideRuntimeWarnings())
2017-01-19 05:50:45 +01:00
// Build the operation
opReq := c.Operation(be)
opReq.AutoApprove = autoApprove
2021-02-18 23:23:34 +01:00
opReq.ConfigDir = "."
opReq.PlanMode = args.PlanMode
2021-02-18 23:23:34 +01:00
opReq.Hooks = view.Hooks()
opReq.PlanFile = planFile
2021-02-18 23:23:34 +01:00
opReq.PlanRefresh = args.Refresh
opReq.Targets = args.Targets
opReq.ForceReplace = args.ForceReplace
2017-01-19 05:50:45 +01:00
opReq.Type = backend.OperationTypeApply
2021-02-18 23:23:34 +01:00
opReq.View = view.Operation()
var err error
opReq.ConfigLoader, err = c.initConfigLoader()
if err != nil {
2021-02-18 23:23:34 +01:00
diags = diags.Append(fmt.Errorf("Failed to initialize config loader: %s", err))
return nil, diags
}
2021-02-18 23:23:34 +01:00
return opReq, diags
}
2021-02-18 23:23:34 +01:00
func (c *ApplyCommand) GatherVariables(opReq *backend.Operation, args *arguments.Vars) tfdiags.Diagnostics {
var diags tfdiags.Diagnostics
// FIXME the arguments package currently trivially gathers variable related
// arguments in a heterogenous slice, in order to minimize the number of
// code paths gathering variables during the transition to this structure.
// Once all commands that gather variables have been converted to this
// structure, we could move the variable gathering code to the arguments
// package directly, removing this shim layer.
varArgs := args.All()
items := make([]rawFlag, len(varArgs))
for i := range varArgs {
items[i].Name = varArgs[i].Name
items[i].Value = varArgs[i].Value
2014-07-13 18:34:35 +02:00
}
2021-02-18 23:23:34 +01:00
c.Meta.variableArgs = rawFlags{items: &items}
opReq.Variables, diags = c.collectVariableValues()
2014-07-13 18:34:35 +02:00
2021-02-18 23:23:34 +01:00
return diags
2014-05-24 21:27:58 +02:00
}
func (c *ApplyCommand) Help() string {
2014-10-01 07:01:11 +02:00
if c.Destroy {
return c.helpDestroy()
}
return c.helpApply()
}
func (c *ApplyCommand) Synopsis() string {
if c.Destroy {
return "Destroy previously-created infrastructure"
2014-10-01 07:01:11 +02:00
}
return "Create or update infrastructure"
2014-10-01 07:01:11 +02:00
}
func (c *ApplyCommand) helpApply() string {
2014-05-24 21:27:58 +02:00
helpText := `
Usage: terraform [global options] apply [options] [PLAN]
2014-05-24 21:27:58 +02:00
Creates or updates infrastructure according to Terraform configuration
files in the current directory.
2014-09-30 00:57:35 +02:00
By default, Terraform will generate a new plan and present it for your
approval before taking any action. You can optionally provide a plan
file created by a previous call to "terraform plan", in which case
Terraform will take the actions described in that plan without any
confirmation prompt.
2014-05-24 21:27:58 +02:00
Options:
-auto-approve Skip interactive approval of plan before applying.
2014-07-28 00:09:04 +02:00
-backup=path Path to backup the existing state file before
modifying. Defaults to the "-state-out" path with
".backup" extension. Set to "-" to disable backup.
2014-07-28 00:09:04 +02:00
-compact-warnings If Terraform produces any warnings that are not
accompanied by errors, show them in a more compact
form that includes only the summary messages.
-lock=false Don't hold a state lock during the operation. This is
dangerous if others might concurrently run commands
against the same workspace.
-lock-timeout=0s Duration to retry a state lock.
-input=true Ask for input for variables if not directly set.
-no-color If specified, output won't contain any color.
-parallelism=n Limit the number of parallel resource operations.
Defaults to 10.
2015-05-06 17:58:42 +02:00
-state=path Path to read and save state (unless state-out
is specified). Defaults to "terraform.tfstate".
2014-06-19 06:36:44 +02:00
-state-out=path Path to write state to that is different than
"-state". This can be used to preserve the old
state.
2014-05-24 21:27:58 +02:00
If you don't provide a saved plan file then this command will also accept
all of the plan-customization options accepted by the terraform plan command.
For more information on those options, run:
terraform plan -help
2014-05-24 21:27:58 +02:00
`
return strings.TrimSpace(helpText)
}
2014-10-01 07:01:11 +02:00
func (c *ApplyCommand) helpDestroy() string {
helpText := `
Usage: terraform [global options] destroy [options]
2014-10-01 07:01:11 +02:00
Destroy Terraform-managed infrastructure.
This command is a convenience alias for:
terraform apply -destroy
2014-10-01 07:01:11 +02:00
This command also accepts many of the plan-customization options accepted by
the terraform plan command. For more information on those options, run:
terraform plan -help
2014-10-01 07:01:11 +02:00
`
return strings.TrimSpace(helpText)
}