201 lines
5.2 KiB
Go
201 lines
5.2 KiB
Go
package command
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
|
|
"github.com/hashicorp/terraform/internal/tfdiags"
|
|
"github.com/hashicorp/terraform/plans/planfile"
|
|
|
|
"github.com/hashicorp/terraform/internal/backend"
|
|
"github.com/hashicorp/terraform/internal/dag"
|
|
"github.com/hashicorp/terraform/terraform"
|
|
)
|
|
|
|
// GraphCommand is a Command implementation that takes a Terraform
|
|
// configuration and outputs the dependency tree in graphical form.
|
|
type GraphCommand struct {
|
|
Meta
|
|
}
|
|
|
|
func (c *GraphCommand) Run(args []string) int {
|
|
var drawCycles bool
|
|
var graphTypeStr string
|
|
var moduleDepth int
|
|
var verbose bool
|
|
var planPath string
|
|
|
|
args = c.Meta.process(args)
|
|
cmdFlags := c.Meta.defaultFlagSet("graph")
|
|
cmdFlags.BoolVar(&drawCycles, "draw-cycles", false, "draw-cycles")
|
|
cmdFlags.StringVar(&graphTypeStr, "type", "", "type")
|
|
cmdFlags.IntVar(&moduleDepth, "module-depth", -1, "module-depth")
|
|
cmdFlags.BoolVar(&verbose, "verbose", false, "verbose")
|
|
cmdFlags.StringVar(&planPath, "plan", "", "plan")
|
|
cmdFlags.Usage = func() { c.Ui.Error(c.Help()) }
|
|
if err := cmdFlags.Parse(args); err != nil {
|
|
c.Ui.Error(fmt.Sprintf("Error parsing command-line flags: %s\n", err.Error()))
|
|
return 1
|
|
}
|
|
|
|
configPath, err := ModulePath(cmdFlags.Args())
|
|
if err != nil {
|
|
c.Ui.Error(err.Error())
|
|
return 1
|
|
}
|
|
|
|
// Check for user-supplied plugin path
|
|
if c.pluginPath, err = c.loadPluginPath(); err != nil {
|
|
c.Ui.Error(fmt.Sprintf("Error loading plugin path: %s", err))
|
|
return 1
|
|
}
|
|
|
|
// Try to load plan if path is specified
|
|
var planFile *planfile.Reader
|
|
if planPath != "" {
|
|
planFile, err = c.PlanFile(planPath)
|
|
if err != nil {
|
|
c.Ui.Error(err.Error())
|
|
return 1
|
|
}
|
|
}
|
|
|
|
var diags tfdiags.Diagnostics
|
|
|
|
backendConfig, backendDiags := c.loadBackendConfig(configPath)
|
|
diags = diags.Append(backendDiags)
|
|
if diags.HasErrors() {
|
|
c.showDiagnostics(diags)
|
|
return 1
|
|
}
|
|
|
|
// Load the backend
|
|
b, backendDiags := c.Backend(&BackendOpts{
|
|
Config: backendConfig,
|
|
})
|
|
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
|
|
}
|
|
|
|
// This is a read-only command
|
|
c.ignoreRemoteBackendVersionConflict(b)
|
|
|
|
// Build the operation
|
|
opReq := c.Operation(b)
|
|
opReq.ConfigDir = configPath
|
|
opReq.ConfigLoader, err = c.initConfigLoader()
|
|
opReq.PlanFile = planFile
|
|
opReq.AllowUnsetVariables = true
|
|
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
|
|
}
|
|
|
|
// Determine the graph type
|
|
graphType := terraform.GraphTypePlan
|
|
if planFile != nil {
|
|
graphType = terraform.GraphTypeApply
|
|
}
|
|
|
|
if graphTypeStr != "" {
|
|
v, ok := terraform.GraphTypeMap[graphTypeStr]
|
|
if !ok {
|
|
c.Ui.Error(fmt.Sprintf("Invalid graph type requested: %s", graphTypeStr))
|
|
return 1
|
|
}
|
|
|
|
graphType = v
|
|
}
|
|
|
|
// Skip validation during graph generation - we want to see the graph even if
|
|
// it is invalid for some reason.
|
|
g, graphDiags := ctx.Graph(graphType, &terraform.ContextGraphOpts{
|
|
Verbose: verbose,
|
|
Validate: false,
|
|
})
|
|
diags = diags.Append(graphDiags)
|
|
if graphDiags.HasErrors() {
|
|
c.showDiagnostics(diags)
|
|
return 1
|
|
}
|
|
|
|
graphStr, err := terraform.GraphDot(g, &dag.DotOpts{
|
|
DrawCycles: drawCycles,
|
|
MaxDepth: moduleDepth,
|
|
Verbose: verbose,
|
|
})
|
|
if err != nil {
|
|
c.Ui.Error(fmt.Sprintf("Error converting graph: %s", err))
|
|
return 1
|
|
}
|
|
|
|
if diags.HasErrors() {
|
|
// For this command we only show diagnostics if there are errors,
|
|
// because printing out naked warnings could upset a naive program
|
|
// consuming our dot output.
|
|
c.showDiagnostics(diags)
|
|
return 1
|
|
}
|
|
|
|
c.Ui.Output(graphStr)
|
|
|
|
return 0
|
|
}
|
|
|
|
func (c *GraphCommand) Help() string {
|
|
helpText := `
|
|
Usage: terraform [global options] graph [options]
|
|
|
|
Outputs the visual execution graph of Terraform resources according to
|
|
either the current configuration or an execution plan.
|
|
|
|
The graph is outputted in DOT format. The typical program that can
|
|
read this format is GraphViz, but many web services are also available
|
|
to read this format.
|
|
|
|
The -type flag can be used to control the type of graph shown. Terraform
|
|
creates different graphs for different operations. See the options below
|
|
for the list of types supported. The default type is "plan" if a
|
|
configuration is given, and "apply" if a plan file is passed as an
|
|
argument.
|
|
|
|
Options:
|
|
|
|
-plan=tfplan Render graph using the specified plan file instead of the
|
|
configuration in the current directory.
|
|
|
|
-draw-cycles Highlight any cycles in the graph with colored edges.
|
|
This helps when diagnosing cycle errors.
|
|
|
|
-type=plan Type of graph to output. Can be: plan, plan-destroy, apply,
|
|
validate, input, refresh.
|
|
|
|
-module-depth=n (deprecated) In prior versions of Terraform, specified the
|
|
depth of modules to show in the output.
|
|
`
|
|
return strings.TrimSpace(helpText)
|
|
}
|
|
|
|
func (c *GraphCommand) Synopsis() string {
|
|
return "Generate a Graphviz graph of the steps in an operation"
|
|
}
|