2016-09-16 03:30:11 +02:00
|
|
|
package terraform
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
2016-11-07 22:55:35 +01:00
|
|
|
"log"
|
2019-10-30 20:59:34 +01:00
|
|
|
"sort"
|
2016-09-16 03:30:11 +02:00
|
|
|
|
2019-09-10 00:58:44 +02:00
|
|
|
"github.com/hashicorp/hcl/v2"
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
"github.com/hashicorp/terraform/addrs"
|
2019-10-17 22:05:27 +02:00
|
|
|
"github.com/hashicorp/terraform/configs"
|
2019-08-07 23:50:59 +02:00
|
|
|
"github.com/hashicorp/terraform/configs/configschema"
|
2016-09-16 03:30:11 +02:00
|
|
|
"github.com/hashicorp/terraform/dag"
|
2019-08-07 23:50:59 +02:00
|
|
|
"github.com/hashicorp/terraform/lang"
|
2019-10-17 22:05:27 +02:00
|
|
|
"github.com/hashicorp/terraform/states"
|
2016-09-16 03:30:11 +02:00
|
|
|
)
|
|
|
|
|
|
|
|
// GraphNodeReferenceable must be implemented by any node that represents
|
|
|
|
// a Terraform thing that can be referenced (resource, module, etc.).
|
2016-11-13 00:38:28 +01:00
|
|
|
//
|
|
|
|
// Even if the thing has no name, this should return an empty list. By
|
|
|
|
// implementing this and returning a non-nil result, you say that this CAN
|
|
|
|
// be referenced and other methods of referencing may still be possible (such
|
|
|
|
// as by path!)
|
2016-09-16 03:30:11 +02:00
|
|
|
type GraphNodeReferenceable interface {
|
2020-03-05 03:00:16 +01:00
|
|
|
GraphNodeModulePath
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
|
|
|
|
// ReferenceableAddrs returns a list of addresses through which this can be
|
|
|
|
// referenced.
|
|
|
|
ReferenceableAddrs() []addrs.Referenceable
|
2016-09-16 03:30:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// GraphNodeReferencer must be implemented by nodes that reference other
|
|
|
|
// Terraform items and therefore depend on them.
|
|
|
|
type GraphNodeReferencer interface {
|
2020-03-05 03:00:16 +01:00
|
|
|
GraphNodeModulePath
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
|
|
|
|
// References returns a list of references made by this node, which
|
|
|
|
// include both a referenced address and source location information for
|
|
|
|
// the reference.
|
|
|
|
References() []*addrs.Reference
|
2016-09-16 03:30:11 +02:00
|
|
|
}
|
|
|
|
|
2019-10-17 22:05:27 +02:00
|
|
|
type GraphNodeAttachDependencies interface {
|
|
|
|
GraphNodeResource
|
|
|
|
AttachDependencies([]addrs.AbsResource)
|
|
|
|
}
|
|
|
|
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
// GraphNodeReferenceOutside is an interface that can optionally be implemented.
|
|
|
|
// A node that implements it can specify that its own referenceable addresses
|
|
|
|
// and/or the addresses it references are in a different module than the
|
|
|
|
// node itself.
|
|
|
|
//
|
|
|
|
// Any referenceable addresses returned by ReferenceableAddrs are interpreted
|
|
|
|
// relative to the returned selfPath.
|
2016-09-16 22:56:10 +02:00
|
|
|
//
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
// Any references returned by References are interpreted relative to the
|
|
|
|
// returned referencePath.
|
2016-09-16 22:56:10 +02:00
|
|
|
//
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
// It is valid but not required for either of these paths to match what is
|
|
|
|
// returned by method Path, though if both match the main Path then there
|
|
|
|
// is no reason to implement this method.
|
|
|
|
//
|
|
|
|
// The primary use-case for this is the nodes representing module input
|
|
|
|
// variables, since their expressions are resolved in terms of their calling
|
|
|
|
// module, but they are still referenced from their own module.
|
|
|
|
type GraphNodeReferenceOutside interface {
|
|
|
|
// ReferenceOutside returns a path in which any references from this node
|
|
|
|
// are resolved.
|
2020-02-24 23:42:32 +01:00
|
|
|
ReferenceOutside() (selfPath, referencePath addrs.Module)
|
2016-09-16 22:56:10 +02:00
|
|
|
}
|
|
|
|
|
2016-09-16 03:30:11 +02:00
|
|
|
// ReferenceTransformer is a GraphTransformer that connects all the
|
|
|
|
// nodes that reference each other in order to form the proper ordering.
|
|
|
|
type ReferenceTransformer struct{}
|
|
|
|
|
|
|
|
func (t *ReferenceTransformer) Transform(g *Graph) error {
|
2016-09-16 08:20:35 +02:00
|
|
|
// Build a reference map so we can efficiently look up the references
|
|
|
|
vs := g.Vertices()
|
|
|
|
m := NewReferenceMap(vs)
|
|
|
|
|
|
|
|
// Find the things that reference things and connect them
|
|
|
|
for _, v := range vs {
|
2019-12-03 19:13:50 +01:00
|
|
|
if _, ok := v.(GraphNodeDestroyer); ok {
|
|
|
|
// destroy nodes references are not connected, since they can only
|
|
|
|
// use their own state.
|
|
|
|
continue
|
|
|
|
}
|
2020-02-24 23:42:32 +01:00
|
|
|
parents := m.References(v)
|
2016-11-07 22:55:35 +01:00
|
|
|
parentsDbg := make([]string, len(parents))
|
|
|
|
for i, v := range parents {
|
|
|
|
parentsDbg[i] = dag.VertexName(v)
|
|
|
|
}
|
|
|
|
log.Printf(
|
|
|
|
"[DEBUG] ReferenceTransformer: %q references: %v",
|
|
|
|
dag.VertexName(v), parentsDbg)
|
|
|
|
|
2016-09-16 08:20:35 +02:00
|
|
|
for _, parent := range parents {
|
|
|
|
g.Connect(dag.BasicEdge(v, parent))
|
2016-09-16 03:30:11 +02:00
|
|
|
}
|
2019-10-17 22:05:27 +02:00
|
|
|
|
|
|
|
if len(parents) > 0 {
|
|
|
|
continue
|
|
|
|
}
|
2016-09-16 08:20:35 +02:00
|
|
|
}
|
2016-09-16 03:30:11 +02:00
|
|
|
|
2016-09-16 08:20:35 +02:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-10-17 22:05:27 +02:00
|
|
|
// AttachDependenciesTransformer records all resource dependencies for each
|
|
|
|
// instance, and attaches the addresses to the node itself. Managed resource
|
|
|
|
// will record these in the state for proper ordering of destroy operations.
|
|
|
|
type AttachDependenciesTransformer struct {
|
|
|
|
Config *configs.Config
|
|
|
|
State *states.State
|
|
|
|
Schemas *Schemas
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t AttachDependenciesTransformer) Transform(g *Graph) error {
|
|
|
|
for _, v := range g.Vertices() {
|
|
|
|
attacher, ok := v.(GraphNodeAttachDependencies)
|
|
|
|
if !ok {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
selfAddr := attacher.ResourceAddr()
|
|
|
|
|
|
|
|
// Data sources don't need to track destroy dependencies
|
|
|
|
if selfAddr.Resource.Mode == addrs.DataResourceMode {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
ans, err := g.Ancestors(v)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// dedupe addrs when there's multiple instances involved, or
|
|
|
|
// multiple paths in the un-reduced graph
|
|
|
|
depMap := map[string]addrs.AbsResource{}
|
2020-01-07 23:49:34 +01:00
|
|
|
for _, d := range ans {
|
2019-10-17 22:05:27 +02:00
|
|
|
var addr addrs.AbsResource
|
|
|
|
|
|
|
|
switch d := d.(type) {
|
|
|
|
case GraphNodeResourceInstance:
|
|
|
|
instAddr := d.ResourceInstanceAddr()
|
|
|
|
addr = instAddr.Resource.Resource.Absolute(instAddr.Module)
|
|
|
|
case GraphNodeResource:
|
|
|
|
addr = d.ResourceAddr()
|
|
|
|
default:
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
// Data sources don't need to track destroy dependencies
|
|
|
|
if addr.Resource.Mode == addrs.DataResourceMode {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
if addr.Equal(selfAddr) {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
depMap[addr.String()] = addr
|
|
|
|
}
|
|
|
|
|
|
|
|
deps := make([]addrs.AbsResource, 0, len(depMap))
|
|
|
|
for _, d := range depMap {
|
|
|
|
deps = append(deps, d)
|
|
|
|
}
|
2019-10-30 20:59:34 +01:00
|
|
|
sort.Slice(deps, func(i, j int) bool {
|
|
|
|
return deps[i].String() < deps[j].String()
|
|
|
|
})
|
2019-10-17 22:05:27 +02:00
|
|
|
|
|
|
|
log.Printf("[TRACE] AttachDependenciesTransformer: %s depends on %s", attacher.ResourceAddr(), deps)
|
|
|
|
attacher.AttachDependencies(deps)
|
|
|
|
}
|
2019-10-30 20:59:34 +01:00
|
|
|
|
2019-10-17 22:05:27 +02:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-12-18 20:37:28 +01:00
|
|
|
// PruneUnusedValuesTransformer is a GraphTransformer that removes local,
|
|
|
|
// variable, and output values which are not referenced in the graph. If these
|
|
|
|
// values reference a resource that is no longer in the state the interpolation
|
|
|
|
// could fail.
|
|
|
|
type PruneUnusedValuesTransformer struct {
|
|
|
|
Destroy bool
|
|
|
|
}
|
2018-01-30 16:24:15 +01:00
|
|
|
|
|
|
|
func (t *PruneUnusedValuesTransformer) Transform(g *Graph) error {
|
2019-12-18 20:37:28 +01:00
|
|
|
// Pruning a value can effect previously checked edges, so loop until there
|
|
|
|
// are no more changes.
|
2018-04-03 19:19:04 +02:00
|
|
|
for removed := 0; ; removed = 0 {
|
|
|
|
for _, v := range g.Vertices() {
|
2019-12-18 20:37:28 +01:00
|
|
|
switch v := v.(type) {
|
|
|
|
case *NodeApplyableOutput:
|
|
|
|
// If we're not certain this is a full destroy, we need to keep any
|
|
|
|
// root module outputs
|
|
|
|
if v.Addr.Module.IsRoot() && !t.Destroy {
|
|
|
|
continue
|
|
|
|
}
|
2020-02-24 23:42:32 +01:00
|
|
|
case *NodePlannableOutput:
|
|
|
|
// Have similar guardrails for plannable outputs as applyable above
|
|
|
|
if v.Module.IsRoot() && !t.Destroy {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
case *NodeLocal, *NodeApplyableModuleVariable, *NodePlannableModuleVariable:
|
2018-04-03 19:19:04 +02:00
|
|
|
// OK
|
|
|
|
default:
|
2019-12-18 20:37:28 +01:00
|
|
|
// We're only concerned with variables, locals and outputs
|
2018-04-03 19:19:04 +02:00
|
|
|
continue
|
|
|
|
}
|
2018-01-30 16:24:15 +01:00
|
|
|
|
2018-04-03 19:19:04 +02:00
|
|
|
dependants := g.UpEdges(v)
|
|
|
|
|
|
|
|
switch dependants.Len() {
|
|
|
|
case 0:
|
|
|
|
// nothing at all depends on this
|
2019-12-18 20:37:28 +01:00
|
|
|
log.Printf("[TRACE] PruneUnusedValuesTransformer: removing unused value %s", dag.VertexName(v))
|
2018-04-03 19:19:04 +02:00
|
|
|
g.Remove(v)
|
|
|
|
removed++
|
|
|
|
case 1:
|
|
|
|
// because an output's destroy node always depends on the output,
|
|
|
|
// we need to check for the case of a single destroy node.
|
|
|
|
d := dependants.List()[0]
|
|
|
|
if _, ok := d.(*NodeDestroyableOutput); ok {
|
2019-12-18 20:37:28 +01:00
|
|
|
log.Printf("[TRACE] PruneUnusedValuesTransformer: removing unused value %s", dag.VertexName(v))
|
2018-04-03 19:19:04 +02:00
|
|
|
g.Remove(v)
|
|
|
|
removed++
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if removed == 0 {
|
|
|
|
break
|
2018-01-30 16:24:15 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-09-16 08:20:35 +02:00
|
|
|
// ReferenceMap is a structure that can be used to efficiently check
|
|
|
|
// for references on a graph.
|
|
|
|
type ReferenceMap struct {
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
// vertices is a map from internal reference keys (as produced by the
|
|
|
|
// mapKey method) to one or more vertices that are identified by each key.
|
|
|
|
//
|
|
|
|
// A particular reference key might actually identify multiple vertices,
|
|
|
|
// e.g. in situations where one object is contained inside another.
|
|
|
|
vertices map[string][]dag.Vertex
|
2016-09-16 08:20:35 +02:00
|
|
|
}
|
|
|
|
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
// References returns the set of vertices that the given vertex refers to,
|
|
|
|
// and any referenced addresses that do not have corresponding vertices.
|
2020-02-24 23:42:32 +01:00
|
|
|
func (m *ReferenceMap) References(v dag.Vertex) []dag.Vertex {
|
2016-09-16 08:20:35 +02:00
|
|
|
rn, ok := v.(GraphNodeReferencer)
|
|
|
|
if !ok {
|
2020-02-24 23:42:32 +01:00
|
|
|
return nil
|
2016-09-16 08:20:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
var matches []dag.Vertex
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
|
|
|
|
for _, ref := range rn.References() {
|
2018-05-25 15:07:07 +02:00
|
|
|
subject := ref.Subject
|
|
|
|
|
2018-05-30 01:27:30 +02:00
|
|
|
key := m.referenceMapKey(v, subject)
|
|
|
|
if _, exists := m.vertices[key]; !exists {
|
|
|
|
// If what we were looking for was a ResourceInstance then we
|
|
|
|
// might be in a resource-oriented graph rather than an
|
|
|
|
// instance-oriented graph, and so we'll see if we have the
|
|
|
|
// resource itself instead.
|
2018-05-30 21:01:05 +02:00
|
|
|
switch ri := subject.(type) {
|
|
|
|
case addrs.ResourceInstance:
|
|
|
|
subject = ri.ContainingResource()
|
|
|
|
case addrs.ResourceInstancePhase:
|
|
|
|
subject = ri.ContainingResource()
|
2018-05-30 01:27:30 +02:00
|
|
|
}
|
2018-05-30 21:01:05 +02:00
|
|
|
key = m.referenceMapKey(v, subject)
|
2018-05-25 15:07:07 +02:00
|
|
|
}
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
vertices := m.vertices[key]
|
|
|
|
for _, rv := range vertices {
|
|
|
|
// don't include self-references
|
|
|
|
if rv == v {
|
2016-11-08 18:35:57 +01:00
|
|
|
continue
|
|
|
|
}
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
matches = append(matches, rv)
|
2016-09-19 06:31:03 +02:00
|
|
|
}
|
2016-11-05 02:58:03 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return matches
|
|
|
|
}
|
|
|
|
|
2020-03-05 03:54:47 +01:00
|
|
|
func (m *ReferenceMap) mapKey(path addrs.Module, addr addrs.Referenceable) string {
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
return fmt.Sprintf("%s|%s", path.String(), addr.String())
|
|
|
|
}
|
|
|
|
|
|
|
|
// vertexReferenceablePath returns the path in which the given vertex can be
|
|
|
|
// referenced. This is the path that its results from ReferenceableAddrs
|
|
|
|
// are considered to be relative to.
|
|
|
|
//
|
2020-03-07 04:31:16 +01:00
|
|
|
// Only GraphNodeModulePath implementations can be referenced, so this method will
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
// panic if the given vertex does not implement that interface.
|
2020-03-05 03:54:47 +01:00
|
|
|
func vertexReferenceablePath(v dag.Vertex) addrs.Module {
|
2020-03-05 03:00:16 +01:00
|
|
|
sp, ok := v.(GraphNodeModulePath)
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
if !ok {
|
|
|
|
// Only nodes with paths can participate in a reference map.
|
2020-03-05 03:00:16 +01:00
|
|
|
panic(fmt.Errorf("vertexMapKey on vertex type %T which doesn't implement GraphNodeModulePath", sp))
|
2016-09-16 22:56:10 +02:00
|
|
|
}
|
|
|
|
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
if outside, ok := v.(GraphNodeReferenceOutside); ok {
|
|
|
|
// Vertex is referenced from a different module than where it was
|
|
|
|
// declared.
|
|
|
|
path, _ := outside.ReferenceOutside()
|
2020-03-05 03:54:47 +01:00
|
|
|
return path
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Vertex is referenced from the same module as where it was declared.
|
2020-03-05 03:54:47 +01:00
|
|
|
return sp.ModulePath()
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
}
|
|
|
|
|
2018-05-26 03:39:33 +02:00
|
|
|
// vertexReferencePath returns the path in which references _from_ the given
|
|
|
|
// vertex must be interpreted.
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
//
|
2020-03-07 04:31:16 +01:00
|
|
|
// Only GraphNodeModulePath implementations can have references, so this method
|
2018-05-26 03:39:33 +02:00
|
|
|
// will panic if the given vertex does not implement that interface.
|
2020-03-05 03:54:47 +01:00
|
|
|
func vertexReferencePath(v dag.Vertex) addrs.Module {
|
2020-03-05 03:00:16 +01:00
|
|
|
sp, ok := v.(GraphNodeModulePath)
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
if !ok {
|
|
|
|
// Only nodes with paths can participate in a reference map.
|
2020-03-05 03:00:16 +01:00
|
|
|
panic(fmt.Errorf("vertexReferencePath on vertex type %T which doesn't implement GraphNodeModulePath", v))
|
2016-09-16 22:56:10 +02:00
|
|
|
}
|
|
|
|
|
2020-03-05 03:00:16 +01:00
|
|
|
if outside, ok := v.(GraphNodeReferenceOutside); ok {
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
// Vertex makes references to objects in a different module than where
|
|
|
|
// it was declared.
|
2020-02-24 23:42:32 +01:00
|
|
|
_, path := outside.ReferenceOutside()
|
2020-03-05 03:54:47 +01:00
|
|
|
return path
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
}
|
|
|
|
|
2018-05-26 03:39:33 +02:00
|
|
|
// Vertex makes references to objects in the same module as where it
|
|
|
|
// was declared.
|
2020-03-05 03:54:47 +01:00
|
|
|
return sp.ModulePath()
|
2018-05-26 03:39:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// referenceMapKey produces keys for the "edges" map. "referrer" is the vertex
|
|
|
|
// that the reference is from, and "addr" is the address of the object being
|
|
|
|
// referenced.
|
|
|
|
//
|
|
|
|
// The result is an opaque string that includes both the address of the given
|
|
|
|
// object and the address of the module instance that object belongs to.
|
|
|
|
//
|
2020-03-07 04:31:16 +01:00
|
|
|
// Only GraphNodeModulePath implementations can be referrers, so this method will
|
2018-05-26 03:39:33 +02:00
|
|
|
// panic if the given vertex does not implement that interface.
|
|
|
|
func (m *ReferenceMap) referenceMapKey(referrer dag.Vertex, addr addrs.Referenceable) string {
|
|
|
|
path := vertexReferencePath(referrer)
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
return m.mapKey(path, addr)
|
2016-09-16 22:56:10 +02:00
|
|
|
}
|
|
|
|
|
2016-09-16 08:20:35 +02:00
|
|
|
// NewReferenceMap is used to create a new reference map for the
|
|
|
|
// given set of vertices.
|
|
|
|
func NewReferenceMap(vs []dag.Vertex) *ReferenceMap {
|
2016-09-16 22:56:10 +02:00
|
|
|
var m ReferenceMap
|
|
|
|
|
2016-09-16 08:20:35 +02:00
|
|
|
// Build the lookup table
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
vertices := make(map[string][]dag.Vertex)
|
2016-09-16 08:20:35 +02:00
|
|
|
for _, v := range vs {
|
|
|
|
// We're only looking for referenceable nodes
|
|
|
|
rn, ok := v.(GraphNodeReferenceable)
|
2016-09-16 03:30:11 +02:00
|
|
|
if !ok {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2020-03-05 03:00:16 +01:00
|
|
|
path := vertexReferenceablePath(v)
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
|
2016-09-16 08:20:35 +02:00
|
|
|
// Go through and cache them
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
for _, addr := range rn.ReferenceableAddrs() {
|
|
|
|
key := m.mapKey(path, addr)
|
|
|
|
vertices[key] = append(vertices[key], v)
|
2016-09-16 03:30:11 +02:00
|
|
|
}
|
2016-11-12 03:54:37 +01:00
|
|
|
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
// Any node can be referenced by the address of the module it belongs
|
|
|
|
// to or any of that module's ancestors.
|
|
|
|
for _, addr := range path.Ancestors()[1:] {
|
|
|
|
// Can be referenced either as the specific call instance (with
|
|
|
|
// an instance key) or as the bare module call itself (the "module"
|
|
|
|
// block in the parent module that created the instance).
|
|
|
|
callPath, call := addr.Call()
|
|
|
|
callKey := m.mapKey(callPath, call)
|
|
|
|
vertices[callKey] = append(vertices[callKey], v)
|
2016-11-12 03:54:37 +01:00
|
|
|
}
|
2016-09-16 03:30:11 +02:00
|
|
|
}
|
|
|
|
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
m.vertices = vertices
|
2016-09-16 22:56:10 +02:00
|
|
|
return &m
|
2016-09-16 03:30:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// ReferencesFromConfig returns the references that a configuration has
|
|
|
|
// based on the interpolated variables in a configuration.
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
func ReferencesFromConfig(body hcl.Body, schema *configschema.Block) []*addrs.Reference {
|
|
|
|
if body == nil {
|
|
|
|
return nil
|
2016-09-16 03:30:11 +02:00
|
|
|
}
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
refs, _ := lang.ReferencesInBlock(body, schema)
|
|
|
|
return refs
|
2016-09-16 03:30:11 +02:00
|
|
|
}
|
|
|
|
|
2018-05-30 22:16:39 +02:00
|
|
|
// appendResourceDestroyReferences identifies resource and resource instance
|
|
|
|
// references in the given slice and appends to it the "destroy-phase"
|
|
|
|
// equivalents of those references, returning the result.
|
|
|
|
//
|
|
|
|
// This can be used in the References implementation for a node which must also
|
|
|
|
// depend on the destruction of anything it references.
|
|
|
|
func appendResourceDestroyReferences(refs []*addrs.Reference) []*addrs.Reference {
|
|
|
|
given := refs
|
|
|
|
for _, ref := range given {
|
|
|
|
switch tr := ref.Subject.(type) {
|
|
|
|
case addrs.Resource:
|
|
|
|
newRef := *ref // shallow copy
|
|
|
|
newRef.Subject = tr.Phase(addrs.ResourceInstancePhaseDestroy)
|
|
|
|
refs = append(refs, &newRef)
|
|
|
|
case addrs.ResourceInstance:
|
|
|
|
newRef := *ref // shallow copy
|
|
|
|
newRef.Subject = tr.Phase(addrs.ResourceInstancePhaseDestroy)
|
|
|
|
refs = append(refs, &newRef)
|
|
|
|
}
|
2020-02-24 23:42:32 +01:00
|
|
|
// FIXME: Using this method in module expansion references,
|
|
|
|
// May want to refactor this method beyond resources
|
2018-05-30 22:16:39 +02:00
|
|
|
}
|
|
|
|
return refs
|
|
|
|
}
|
|
|
|
|
terraform: ugly huge change to weave in new HCL2-oriented types
Due to how deeply the configuration types go into Terraform Core, there
isn't a great way to switch out to HCL2 gradually. As a consequence, this
huge commit gets us from the old state to a _compilable_ new state, but
does not yet attempt to fix any tests and has a number of known missing
parts and bugs. We will continue to iterate on this in forthcoming
commits, heading back towards passing tests and making Terraform
fully-functional again.
The three main goals here are:
- Use the configuration models from the "configs" package instead of the
older models in the "config" package, which is now deprecated and
preserved only to help us write our migration tool.
- Do expression inspection and evaluation using the functionality of the
new "lang" package, instead of the Interpolator type and related
functionality in the main "terraform" package.
- Represent addresses of various objects using types in the addrs package,
rather than hand-constructed strings. This is not critical to support
the above, but was a big help during the implementation of these other
points since it made it much more explicit what kind of address is
expected in each context.
Since our new packages are built to accommodate some future planned
features that are not yet implemented (e.g. the "for_each" argument on
resources, "count"/"for_each" on modules), and since there's still a fair
amount of functionality still using old-style APIs, there is a moderate
amount of shimming here to connect new assumptions with old, hopefully in
a way that makes it easier to find and eliminate these shims later.
I apologize in advance to the person who inevitably just found this huge
commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
|
|
|
func modulePrefixStr(p addrs.ModuleInstance) string {
|
|
|
|
return p.String()
|
2017-01-27 05:05:42 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
func modulePrefixList(result []string, prefix string) []string {
|
|
|
|
if prefix != "" {
|
|
|
|
for i, v := range result {
|
|
|
|
result[i] = fmt.Sprintf("%s.%s", prefix, v)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result
|
|
|
|
}
|