terraform/command/graph.go

200 lines
4.6 KiB
Go
Raw Normal View History

2014-07-01 19:02:13 +02:00
package command
import (
"flag"
"fmt"
"strings"
2015-02-20 07:58:42 +01:00
"github.com/hashicorp/terraform/tfdiags"
2017-01-19 05:50:45 +01:00
"github.com/hashicorp/terraform/backend"
"github.com/hashicorp/terraform/config"
2017-01-19 05:50:45 +01:00
"github.com/hashicorp/terraform/config/module"
"github.com/hashicorp/terraform/dag"
2015-02-20 07:58:42 +01:00
"github.com/hashicorp/terraform/terraform"
2014-07-01 19:02:13 +02:00
)
// GraphCommand is a Command implementation that takes a Terraform
// configuration and outputs the dependency tree in graphical form.
type GraphCommand struct {
Meta
2014-07-01 19:02:13 +02:00
}
func (c *GraphCommand) Run(args []string) int {
2014-09-25 02:36:27 +02:00
var moduleDepth int
var verbose bool
var drawCycles bool
2016-12-04 00:00:34 +01:00
var graphTypeStr string
2014-09-25 02:36:27 +02:00
args, err := c.Meta.process(args, false)
if err != nil {
return 1
}
2014-07-01 19:02:13 +02:00
cmdFlags := flag.NewFlagSet("graph", flag.ContinueOnError)
c.addModuleDepthFlag(cmdFlags, &moduleDepth)
cmdFlags.BoolVar(&verbose, "verbose", false, "verbose")
cmdFlags.BoolVar(&drawCycles, "draw-cycles", false, "draw-cycles")
2016-12-04 00:00:34 +01:00
cmdFlags.StringVar(&graphTypeStr, "type", "", "type")
2014-07-01 19:02:13 +02:00
cmdFlags.Usage = func() { c.Ui.Error(c.Help()) }
if err := cmdFlags.Parse(args); err != nil {
return 1
}
2017-01-19 05:50:45 +01:00
configPath, err := ModulePath(cmdFlags.Args())
if err != nil {
c.Ui.Error(err.Error())
return 1
}
// Check if the path is a plan
plan, err := c.Plan(configPath)
if err != nil {
c.Ui.Error(err.Error())
2014-07-01 19:02:13 +02:00
return 1
2017-01-19 05:50:45 +01:00
}
if plan != nil {
// Reset for backend loading
configPath = ""
}
var diags tfdiags.Diagnostics
2017-01-19 05:50:45 +01:00
// Load the module
var mod *module.Tree
if plan == nil {
var modDiags tfdiags.Diagnostics
mod, modDiags = c.Module(configPath)
diags = diags.Append(modDiags)
if modDiags.HasErrors() {
c.showDiagnostics(diags)
2017-01-19 05:50:45 +01:00
return 1
2014-07-12 05:41:47 +02:00
}
2014-07-01 19:02:13 +02:00
}
var conf *config.Config
if mod != nil {
conf = mod.Config()
}
2017-01-19 05:50:45 +01:00
// Load the backend
b, err := c.Backend(&BackendOpts{
Config: conf,
Plan: plan,
})
2014-07-01 19:02:13 +02:00
if err != nil {
2017-01-19 05:50:45 +01:00
c.Ui.Error(fmt.Sprintf("Failed to load backend: %s", err))
return 1
}
// We require a local backend
local, ok := b.(backend.Local)
if !ok {
c.Ui.Error(ErrUnsupportedLocalOp)
return 1
}
// Building a graph may require config module to be present, even if it's
// empty.
if mod == nil && plan == nil {
mod = module.NewEmptyTree()
}
2017-01-19 05:50:45 +01:00
// Build the operation
opReq := c.Operation()
opReq.Module = mod
opReq.Plan = plan
// Get the context
ctx, _, err := local.Context(opReq)
if err != nil {
c.Ui.Error(err.Error())
2014-07-01 19:02:13 +02:00
return 1
}
2016-12-04 00:00:34 +01:00
// Determine the graph type
graphType := terraform.GraphTypePlan
2017-01-19 05:50:45 +01:00
if plan != nil {
2016-12-04 00:00:34 +01:00
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.
2016-12-04 00:00:34 +01:00
g, err := ctx.Graph(graphType, &terraform.ContextGraphOpts{
Verbose: verbose,
Validate: false,
})
2014-07-01 19:02:13 +02:00
if err != nil {
c.Ui.Error(fmt.Sprintf("Error creating graph: %s", err))
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)
2014-07-01 19:02:13 +02:00
return 0
}
func (c *GraphCommand) Help() string {
helpText := `
Usage: terraform graph [options] [DIR]
2014-07-01 19:02:13 +02:00
2016-12-04 00:00:34 +01:00
Outputs the visual execution graph of Terraform resources according to
configuration files in DIR (or the current directory if omitted).
2014-07-01 19:02:13 +02:00
2014-07-12 05:38:03 +02:00
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.
2016-12-04 00:00:34 +01:00
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.
2014-09-25 02:36:27 +02:00
2016-12-04 00:00:34 +01:00
Options:
2016-12-04 00:00:34 +01:00
-draw-cycles Highlight any cycles in the graph with colored edges.
This helps when diagnosing cycle errors.
2014-09-25 02:36:27 +02:00
2016-12-04 00:00:34 +01:00
-no-color If specified, output won't contain any color.
2015-06-22 14:14:01 +02:00
2016-12-04 00:00:34 +01:00
-type=plan Type of graph to output. Can be: plan, plan-destroy, apply,
2017-01-27 00:18:42 +01:00
validate, input, refresh.
2015-06-22 14:14:01 +02:00
2014-07-01 19:02:13 +02:00
`
return strings.TrimSpace(helpText)
}
func (c *GraphCommand) Synopsis() string {
2014-07-13 04:28:38 +02:00
return "Create a visual graph of Terraform resources"
2014-07-01 19:02:13 +02:00
}