terraform/command/apply.go

412 lines
13 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"
2017-01-19 05:50:45 +01:00
"github.com/hashicorp/terraform/backend"
remoteBackend "github.com/hashicorp/terraform/backend/remote"
"github.com/hashicorp/terraform/command/arguments"
"github.com/hashicorp/terraform/command/views"
"github.com/hashicorp/terraform/plans/planfile"
terraform: ugly huge change to weave in new HCL2-oriented types Due to how deeply the configuration types go into Terraform Core, there isn't a great way to switch out to HCL2 gradually. As a consequence, this huge commit gets us from the old state to a _compilable_ new state, but does not yet attempt to fix any tests and has a number of known missing parts and bugs. We will continue to iterate on this in forthcoming commits, heading back towards passing tests and making Terraform fully-functional again. The three main goals here are: - Use the configuration models from the "configs" package instead of the older models in the "config" package, which is now deprecated and preserved only to help us write our migration tool. - Do expression inspection and evaluation using the functionality of the new "lang" package, instead of the Interpolator type and related functionality in the main "terraform" package. - Represent addresses of various objects using types in the addrs package, rather than hand-constructed strings. This is not critical to support the above, but was a big help during the implementation of these other points since it made it much more explicit what kind of address is expected in each context. Since our new packages are built to accommodate some future planned features that are not yet implemented (e.g. the "for_each" argument on resources, "count"/"for_each" on modules), and since there's still a fair amount of functionality still using old-style APIs, there is a moderate amount of shimming here to connect new assumptions with old, hopefully in a way that makes it easier to find and eliminate these shims later. I apologize in advance to the person who inevitably just found this huge commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
"github.com/hashicorp/terraform/tfdiags"
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 {
// 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
args, diags := arguments.ParseApply(rawArgs)
// 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.RunningInAutomation, c.View)
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 _, isRemoteBackend := be.(*remoteBackend.Remote); !isRemoteBackend || c.RunningInAutomation {
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.Destroy = c.Destroy
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
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.
2017-02-06 16:07:32 +01:00
-lock=true Lock the state file when locking is supported.
-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
2014-07-27 02:50:13 +02:00
-refresh=true Update state prior to checking for differences. This
has no effect if a plan file is given to apply.
-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
-target=resource Resource to target. Operation will be limited to this
resource and its dependencies. This flag can be used
multiple times.
2014-07-18 20:37:27 +02:00
-var 'foo=bar' Set a variable in the Terraform configuration. This
flag can be set multiple times.
-var-file=foo Set variables in the Terraform configuration from
2017-06-22 03:22:07 +02:00
a file. If "terraform.tfvars" or any ".auto.tfvars"
files are present, they will be automatically loaded.
2014-07-18 20:37:27 +02:00
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.
Options:
-auto-approve Skip interactive approval before destroying.
2017-02-06 16:07:32 +01:00
-lock=true Lock the state file when locking is supported.
-lock-timeout=0s Duration to retry a state lock.
2014-10-01 07:01:11 +02:00
-no-color If specified, output won't contain any color.
-parallelism=n Limit the number of concurrent operations.
Defaults to 10.
2014-10-01 07:01:11 +02:00
-refresh=true Update state prior to checking for differences. This
has no effect if a plan file is given to apply.
-target=resource Resource to target. Operation will be limited to this
resource and its dependencies. This flag can be used
multiple times.
2014-10-01 07:01:11 +02:00
-var 'foo=bar' Set a variable in the Terraform configuration. This
flag can be set multiple times.
-var-file=foo Set variables in the Terraform configuration from
2017-06-22 03:22:07 +02:00
a file. If "terraform.tfvars" or any ".auto.tfvars"
files are present, they will be automatically loaded.
2014-10-01 07:01:11 +02:00
command: Reorganize docs of the local backend's legacy CLI options We have these funny extra options that date back to before Terraform even had remote state, which we've preserved along the way by most recently incorporating them as special-case overrides for the local backend. The documentation we had for these has grown less accurate over time as the details have shifted, and was in many cases missing the requisite caveats that they are only for the local backend and that backend configuration is the modern, preferred way to deal with the use-cases they were intended for. We always have a bit of a tension with this sort of legacy option because we want to keep them documented just enough to be useful to someone who finds an existing script/etc using them and wants to know what they do, but not to take up so much space that they might distract users from finding the modern alternative they should consider instead. As a compromise in that vein here I've created a new section about these options under the local backend documentation, which then gives us the space to go into some detail about the various behaviors and interactions and also to discuss their history and our recommended alternatives. I then simplified all of the other mentions of these in command documentation to just link to or refer to the local backend documentation. My hope then is that folks who need to know what these do can still find the docs, but that information can be kept out of the direct path of new users so they can focus on learning about remote backends instead. This is certainly not the most ideal thing ever, but it seemed like the best compromise between the competing priorities I described above.
2021-03-25 00:17:03 +01:00
-state, state-out, and -backup are legacy options supported for the local
backend only. For more information, see the local backend's documentation.
2014-10-01 07:01:11 +02:00
`
return strings.TrimSpace(helpText)
}