terraform/command/graph.go

201 lines
5.2 KiB
Go

package command
import (
"fmt"
"strings"
"github.com/hashicorp/terraform/plans/planfile"
"github.com/hashicorp/terraform/tfdiags"
"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"
}