mirror of
https://github.com/opentofu/opentofu.git
synced 2024-12-26 00:41:27 -06:00
171 lines
4.0 KiB
Go
171 lines
4.0 KiB
Go
package command
|
|
|
|
import (
|
|
"flag"
|
|
"fmt"
|
|
"strings"
|
|
|
|
"github.com/hashicorp/terraform/backend"
|
|
"github.com/hashicorp/terraform/config/module"
|
|
"github.com/hashicorp/terraform/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 moduleDepth int
|
|
var verbose bool
|
|
var drawCycles bool
|
|
var graphTypeStr string
|
|
|
|
args = c.Meta.process(args, false)
|
|
|
|
cmdFlags := flag.NewFlagSet("graph", flag.ContinueOnError)
|
|
c.addModuleDepthFlag(cmdFlags, &moduleDepth)
|
|
cmdFlags.BoolVar(&verbose, "verbose", false, "verbose")
|
|
cmdFlags.BoolVar(&drawCycles, "draw-cycles", false, "draw-cycles")
|
|
cmdFlags.StringVar(&graphTypeStr, "type", "", "type")
|
|
cmdFlags.Usage = func() { c.Ui.Error(c.Help()) }
|
|
if err := cmdFlags.Parse(args); err != nil {
|
|
return 1
|
|
}
|
|
|
|
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())
|
|
return 1
|
|
}
|
|
if plan != nil {
|
|
// Reset for backend loading
|
|
configPath = ""
|
|
}
|
|
|
|
// Load the module
|
|
var mod *module.Tree
|
|
if plan == nil {
|
|
mod, err = c.Module(configPath)
|
|
if err != nil {
|
|
c.Ui.Error(fmt.Sprintf("Failed to load root config module: %s", err))
|
|
return 1
|
|
}
|
|
}
|
|
|
|
// Load the backend
|
|
b, err := c.Backend(&BackendOpts{
|
|
ConfigPath: configPath,
|
|
Plan: plan,
|
|
})
|
|
if err != nil {
|
|
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
|
|
}
|
|
|
|
// 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())
|
|
return 1
|
|
}
|
|
|
|
// Determine the graph type
|
|
graphType := terraform.GraphTypePlan
|
|
if plan != 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, err := ctx.Graph(graphType, &terraform.ContextGraphOpts{
|
|
Verbose: verbose,
|
|
Validate: false,
|
|
})
|
|
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
|
|
}
|
|
|
|
c.Ui.Output(graphStr)
|
|
|
|
return 0
|
|
}
|
|
|
|
func (c *GraphCommand) Help() string {
|
|
helpText := `
|
|
Usage: terraform graph [options] [DIR]
|
|
|
|
Outputs the visual execution graph of Terraform resources according to
|
|
configuration files in DIR (or the current directory if omitted).
|
|
|
|
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:
|
|
|
|
-draw-cycles Highlight any cycles in the graph with colored edges.
|
|
This helps when diagnosing cycle errors.
|
|
|
|
-no-color If specified, output won't contain any color.
|
|
|
|
-type=plan Type of graph to output. Can be: plan, plan-destroy, apply,
|
|
validate, input, refresh.
|
|
|
|
|
|
`
|
|
return strings.TrimSpace(helpText)
|
|
}
|
|
|
|
func (c *GraphCommand) Synopsis() string {
|
|
return "Create a visual graph of Terraform resources"
|
|
}
|