6 "github.com/hashicorp/terraform/config/module"
7 "github.com/hashicorp/terraform/dag"
10 // GraphNodeDestroyer must be implemented by nodes that destroy resources.
11 type GraphNodeDestroyer interface {
14 // ResourceAddr is the address of the resource that is being
15 // destroyed by this node. If this returns nil, then this node
16 // is not destroying anything.
17 DestroyAddr() *ResourceAddress
20 // GraphNodeCreator must be implemented by nodes that create OR update resources.
21 type GraphNodeCreator interface {
22 // ResourceAddr is the address of the resource being created or updated
23 CreateAddr() *ResourceAddress
26 // DestroyEdgeTransformer is a GraphTransformer that creates the proper
27 // references for destroy resources. Destroy resources are more complex
28 // in that they must be depend on the destruction of resources that
29 // in turn depend on the CREATION of the node being destroy.
31 // That is complicated. Visually:
33 // B_d -> A_d -> A -> B
35 // Notice that A destroy depends on B destroy, while B create depends on
36 // A create. They're inverted. This must be done for example because often
37 // dependent resources will block parent resources from deleting. Concrete
38 // example: VPC with subnets, the VPC can't be deleted while there are
40 type DestroyEdgeTransformer struct {
41 // These are needed to properly build the graph of dependencies
42 // to determine what a destroy node depends on. Any of these can be nil.
47 func (t *DestroyEdgeTransformer) Transform(g *Graph) error {
48 log.Printf("[TRACE] DestroyEdgeTransformer: Beginning destroy edge transformation...")
50 // Build a map of what is being destroyed (by address string) to
51 // the list of destroyers. In general there will only be one destroyer
52 // but to make it more robust we support multiple.
53 destroyers := make(map[string][]GraphNodeDestroyer)
54 for _, v := range g.Vertices() {
55 dn, ok := v.(GraphNodeDestroyer)
60 addr := dn.DestroyAddr()
67 "[TRACE] DestroyEdgeTransformer: %s destroying %q",
68 dag.VertexName(dn), key)
69 destroyers[key] = append(destroyers[key], dn)
72 // If we aren't destroying anything, there will be no edges to make
73 // so just exit early and avoid future work.
74 if len(destroyers) == 0 {
78 // Go through and connect creators to destroyers. Going along with
79 // our example, this makes: A_d => A
80 for _, v := range g.Vertices() {
81 cn, ok := v.(GraphNodeCreator)
86 addr := cn.CreateAddr()
97 for _, d := range ds {
98 // For illustrating our example
103 "[TRACE] DestroyEdgeTransformer: connecting creator/destroyer: %s, %s",
104 dag.VertexName(a), dag.VertexName(a_d))
106 g.Connect(&DestroyEdge{S: a, T: a_d})
110 // This is strange but is the easiest way to get the dependencies
111 // of a node that is being destroyed. We use another graph to make sure
112 // the resource is in the graph and ask for references. We have to do this
113 // because the node that is being destroyed may NOT be in the graph.
115 // Example: resource A is force new, then destroy A AND create A are
116 // in the graph. BUT if resource A is just pure destroy, then only
117 // destroy A is in the graph, and create A is not.
118 providerFn := func(a *NodeAbstractProvider) dag.Vertex {
119 return &NodeApplyableProvider{NodeAbstractProvider: a}
121 steps := []GraphTransformer{
122 // Add the local values
123 &LocalTransformer{Module: t.Module},
125 // Add outputs and metadata
126 &OutputTransformer{Module: t.Module},
127 &AttachResourceConfigTransformer{Module: t.Module},
128 &AttachStateTransformer{State: t.State},
130 TransformProviders(nil, providerFn, t.Module),
132 // Add all the variables. We can depend on resources through
133 // variables due to module parameters, and we need to properly
135 &RootVariableTransformer{Module: t.Module},
136 &ModuleVariableTransformer{Module: t.Module},
138 &ReferenceTransformer{},
141 // Go through all the nodes being destroyed and create a graph.
142 // The resulting graph is only of things being CREATED. For example,
143 // following our example, the resulting graph would be:
145 // A, B (with no edges)
148 var tempDestroyed []dag.Vertex
149 for d, _ := range destroyers {
150 // d is what is being destroyed. We parse the resource address
151 // which it came from it is a panic if this fails.
152 addr, err := ParseResourceAddress(d)
157 // This part is a little bit weird but is the best way to
158 // find the dependencies we need to: build a graph and use the
159 // attach config and state transformers then ask for references.
160 abstract := &NodeAbstractResource{Addr: addr}
162 tempDestroyed = append(tempDestroyed, abstract)
164 // We also add the destroy version here since the destroy can
165 // depend on things that the creation doesn't (destroy provisioners).
166 destroy := &NodeDestroyResource{NodeAbstractResource: abstract}
168 tempDestroyed = append(tempDestroyed, destroy)
171 // Run the graph transforms so we have the information we need to
173 for _, s := range steps {
174 if err := s.Transform(&tempG); err != nil {
179 log.Printf("[TRACE] DestroyEdgeTransformer: reference graph: %s", tempG.String())
181 // Go through all the nodes in the graph and determine what they
183 for _, v := range tempDestroyed {
184 // Find all ancestors of this to determine the edges we'll depend on
185 vs, err := tempG.Ancestors(v)
190 refs := make([]dag.Vertex, 0, vs.Len())
191 for _, raw := range vs.List() {
192 refs = append(refs, raw.(dag.Vertex))
195 refNames := make([]string, len(refs))
196 for i, ref := range refs {
197 refNames[i] = dag.VertexName(ref)
200 "[TRACE] DestroyEdgeTransformer: creation node %q references %s",
201 dag.VertexName(v), refNames)
203 // If we have no references, then we won't need to do anything
208 // Get the destroy node for this. In the example of our struct,
209 // we are currently at B and we're looking for B_d.
210 rn, ok := v.(GraphNodeResource)
215 addr := rn.ResourceAddr()
220 dns := destroyers[addr.String()]
222 // We have dependencies, check if any are being destroyed
223 // to build the list of things that we must depend on!
225 // In the example of the struct, if we have:
227 // B_d => A_d => A => B
229 // Then at this point in the algorithm we started with B_d,
230 // we built B (to get dependencies), and we found A. We're now looking
231 // to see if A_d exists.
232 var depDestroyers []dag.Vertex
233 for _, v := range refs {
234 rn, ok := v.(GraphNodeResource)
239 addr := rn.ResourceAddr()
245 if ds, ok := destroyers[key]; ok {
246 for _, d := range ds {
247 depDestroyers = append(depDestroyers, d.(dag.Vertex))
249 "[TRACE] DestroyEdgeTransformer: destruction of %q depends on %s",
250 key, dag.VertexName(d))
255 // Go through and make the connections. Use the variable
256 // names "a_d" and "b_d" to reference our example.
257 for _, a_d := range dns {
258 for _, b_d := range depDestroyers {
260 g.Connect(dag.BasicEdge(b_d, a_d))