terraform/command/show.go

185 lines
3.9 KiB
Go
Raw Normal View History

2014-07-13 04:47:31 +02:00
package command
import (
"flag"
"fmt"
"os"
"strings"
"github.com/hashicorp/terraform/backend"
"github.com/hashicorp/terraform/plans/planfile"
"github.com/hashicorp/terraform/states/statefile"
"github.com/hashicorp/terraform/tfdiags"
2017-01-19 05:50:45 +01:00
"github.com/hashicorp/terraform/command/format"
"github.com/hashicorp/terraform/plans"
"github.com/hashicorp/terraform/states"
2014-07-13 04:47:31 +02:00
)
// ShowCommand is a Command implementation that reads and outputs the
// contents of a Terraform plan or state file.
type ShowCommand struct {
Meta
2014-07-13 04:47:31 +02:00
}
func (c *ShowCommand) Run(args []string) int {
args, err := c.Meta.process(args, false)
if err != nil {
return 1
}
2014-07-13 04:47:31 +02:00
cmdFlags := flag.NewFlagSet("show", flag.ContinueOnError)
2014-07-13 04:47:31 +02:00
cmdFlags.Usage = func() { c.Ui.Error(c.Help()) }
if err := cmdFlags.Parse(args); err != nil {
return 1
}
args = cmdFlags.Args()
if len(args) > 1 {
2014-07-13 04:47:31 +02:00
c.Ui.Error(
"The show command expects at most one argument with the path\n" +
2014-07-13 04:47:31 +02:00
"to a Terraform state or plan file.\n")
cmdFlags.Usage()
return 1
}
var diags tfdiags.Diagnostics
// Load the backend
b, backendDiags := c.Backend(nil)
diags = diags.Append(backendDiags)
if backendDiags.HasErrors() {
c.showDiagnostics(diags)
return 1
}
// We require a local backend
local, ok := b.(backend.Local)
if !ok {
c.showDiagnostics(diags) // in case of any warnings in here
c.Ui.Error(ErrUnsupportedLocalOp)
return 1
}
// the show command expects the config dir to always be the cwd
cwd, err := os.Getwd()
if err != nil {
c.Ui.Error(fmt.Sprintf("Error getting cwd: %s", err))
return 1
}
// Build the operation
opReq := c.Operation(b)
opReq.ConfigDir = cwd
opReq.ConfigLoader, err = c.initConfigLoader()
if err != nil {
diags = diags.Append(err)
c.showDiagnostics(diags)
return 1
}
// Get the context
ctx, _, ctxDiags := local.Context(opReq)
diags = diags.Append(ctxDiags)
if ctxDiags.HasErrors() {
c.showDiagnostics(diags)
return 1
}
schemas := ctx.Schemas()
env := c.Workspace()
var planErr, stateErr error
var path string
var plan *plans.Plan
var state *states.State
if len(args) > 0 {
path = args[0]
pr, err := planfile.Open(path)
if err != nil {
f, err := os.Open(path)
if err != nil {
c.Ui.Error(fmt.Sprintf("Error loading file: %s", err))
return 1
}
defer f.Close()
2014-07-13 04:47:31 +02:00
var stateFile *statefile.File
stateFile, err = statefile.Read(f)
if err != nil {
stateErr = err
} else {
state = stateFile.State
}
} else {
plan, err = pr.ReadPlan()
if err != nil {
planErr = err
}
2014-07-13 04:47:31 +02:00
}
} else {
2017-01-19 05:50:45 +01:00
// Get the state
stateStore, err := b.StateMgr(env)
2017-01-19 05:50:45 +01:00
if err != nil {
c.Ui.Error(fmt.Sprintf("Failed to load state: %s", err))
return 1
}
if err := stateStore.RefreshState(); err != nil {
c.Ui.Error(fmt.Sprintf("Failed to load state: %s", err))
return 1
}
state = stateStore.State()
if state == nil {
c.Ui.Output("No state.")
return 0
2014-07-13 04:47:31 +02:00
}
}
2014-07-13 04:47:31 +02:00
if plan == nil && state == nil {
c.Ui.Error(fmt.Sprintf(
"Terraform couldn't read the given file as a state or plan file.\n"+
"The errors while attempting to read the file as each format are\n"+
"shown below.\n\n"+
"State read error: %s\n\nPlan read error: %s",
stateErr,
planErr))
return 1
}
if plan != nil {
dispPlan := format.NewPlan(plan.Changes)
command/format: improve consistency of plan results Previously the rendered plan output was constructed directly from the core plan and then annotated with counts derived from the count hook. At various places we applied little adjustments to deal with the fact that the user-facing diff model is not identical to the internal diff model, including the special handling of data source reads and destroys. Since this logic was just muddled into the rendering code, it behaved inconsistently with the tally of adds, updates and deletes. This change reworks the plan formatter so that it happens in two stages: - First, we produce a specialized Plan object that is tailored for use in the UI. This applies all the relevant logic to transform the physical model into the user model. - Second, we do a straightforward visual rendering of the display-oriented plan object. For the moment this is slightly overkill since there's only one rendering path, but it does give us the benefit of letting the counts be derived from the same data as the full detailed diff, ensuring that they'll stay consistent. Later we may choose to have other UIs for plans, such as a machine-readable output intended to drive a web UI. In that case, we'd want the web UI to consume a serialization of the _display-oriented_ plan so that it doesn't need to re-implement all of these UI special cases. This introduces to core a new diff action type for "refresh". Currently this is used _only_ in the UI layer, to represent data source reads. Later it would be good to use this type for the core diff as well, to improve consistency, but that is left for another day to keep this change focused on the UI.
2017-08-24 01:23:02 +02:00
c.Ui.Output(dispPlan.Format(c.Colorize()))
2014-07-13 04:47:31 +02:00
return 0
}
2017-01-19 05:50:45 +01:00
c.Ui.Output(format.State(&format.StateOpts{
State: state,
Color: c.Colorize(),
Schemas: schemas,
}))
2014-07-13 04:47:31 +02:00
return 0
}
func (c *ShowCommand) Help() string {
helpText := `
2014-10-11 21:57:47 +02:00
Usage: terraform show [options] [path]
2014-07-13 04:47:31 +02:00
Reads and outputs a Terraform state or plan file in a human-readable
2014-10-11 21:57:47 +02:00
form. If no path is specified, the current state will be shown.
2014-07-13 04:47:31 +02:00
Options:
-no-color If specified, output won't contain any color.
2014-07-13 04:47:31 +02:00
`
return strings.TrimSpace(helpText)
}
func (c *ShowCommand) Synopsis() string {
return "Inspect Terraform state or plan"
}