mirror of
https://github.com/opentofu/opentofu.git
synced 2025-01-19 13:12:58 -06:00
4bc1696fd1
The graph walking mechanism is specified as requiring a graph with a single root, which in practice means there's exactly one node in the graph which doesn't have any dependencies. However, we previously weren't verifying that invariant is true for subgraphs returned from DynamicExpand. It was working anyway, but it's not ideal to be relying on a behavior that isn't guaranteed by our underlying infrastructure. We also previously had the RootTransformer being a bit clever and trying to avoid adding a new node if there is already only a single graph with no dependencies. That special case isn't particularly valuable since there's no harm in turning a one-node graph into a two-node graph with an explicit separate root node, and doing that allows us to assume that the root node is always present and is always exactly terraform.rootNode. Many existing DynamicExpand implementations were not producing valid graphs and were previously getting away with it. All of them now produce properly-rooted graphs that should pass validation, and we will guarantee that with an explicit check of the DynamicExpand return value before we try to walk that subgraph. For good measure we also verify that the root node is exactly terraform.rootNode, even though that isn't strictly required by our graph walker, just to help us catch potential future bugs where a DynamicExpand implementation neglects to add our singleton root node.
83 lines
2.4 KiB
Go
83 lines
2.4 KiB
Go
package terraform
|
|
|
|
import (
|
|
"github.com/hashicorp/terraform/internal/dag"
|
|
)
|
|
|
|
const rootNodeName = "root"
|
|
|
|
// RootTransformer is a GraphTransformer that adds a root to the graph.
|
|
type RootTransformer struct{}
|
|
|
|
func (t *RootTransformer) Transform(g *Graph) error {
|
|
addRootNodeToGraph(g)
|
|
return nil
|
|
}
|
|
|
|
// addRootNodeToGraph modifies the given graph in-place so that it has a root
|
|
// node if it didn't already have one and so that any other node which doesn't
|
|
// already depend on something will depend on that root node.
|
|
//
|
|
// After this function returns, the graph will have only one node that doesn't
|
|
// depend on any other nodes.
|
|
func addRootNodeToGraph(g *Graph) {
|
|
// We always add the root node. This is a singleton so if it's already
|
|
// in the graph this will do nothing and just retain the existing root node.
|
|
//
|
|
// Note that rootNode is intentionally added by value and not by pointer
|
|
// so that all root nodes will be equal to one another and therefore
|
|
// coalesce when two valid graphs get merged together into a single graph.
|
|
g.Add(rootNode)
|
|
|
|
// Everything that doesn't already depend on at least one other node will
|
|
// depend on the root node, except the root node itself.
|
|
for _, v := range g.Vertices() {
|
|
if v == dag.Vertex(rootNode) {
|
|
continue
|
|
}
|
|
|
|
if g.UpEdges(v).Len() == 0 {
|
|
g.Connect(dag.BasicEdge(rootNode, v))
|
|
}
|
|
}
|
|
}
|
|
|
|
type graphNodeRoot struct{}
|
|
|
|
// rootNode is the singleton value representing all root graph nodes.
|
|
//
|
|
// The root node for all graphs should be this value directly, and in particular
|
|
// _not_ a pointer to this value. Using the value directly here means that
|
|
// multiple root nodes will always coalesce together when subsuming one graph
|
|
// into another.
|
|
var rootNode graphNodeRoot
|
|
|
|
func (n graphNodeRoot) Name() string {
|
|
return rootNodeName
|
|
}
|
|
|
|
// CloseRootModuleTransformer is a GraphTransformer that adds a root to the graph.
|
|
type CloseRootModuleTransformer struct{}
|
|
|
|
func (t *CloseRootModuleTransformer) Transform(g *Graph) error {
|
|
// close the root module
|
|
closeRoot := &nodeCloseModule{}
|
|
g.Add(closeRoot)
|
|
|
|
// since this is closing the root module, make it depend on everything in
|
|
// the root module.
|
|
for _, v := range g.Vertices() {
|
|
if v == closeRoot {
|
|
continue
|
|
}
|
|
|
|
// since this is closing the root module, and must be last, we can
|
|
// connect to anything that doesn't have any up edges.
|
|
if g.UpEdges(v).Len() == 0 {
|
|
g.Connect(dag.BasicEdge(closeRoot, v))
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|