240 lines
7.3 KiB
Go
240 lines
7.3 KiB
Go
package addrs
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
|
|
"github.com/hashicorp/hcl/v2"
|
|
"github.com/hashicorp/hcl/v2/hclsyntax"
|
|
"github.com/zclconf/go-cty/cty"
|
|
"github.com/zclconf/go-cty/cty/gocty"
|
|
|
|
"github.com/hashicorp/terraform-plugin-sdk/v2/internal/tfdiags"
|
|
)
|
|
|
|
// ModuleInstance is an address for a particular module instance within the
|
|
// dynamic module tree. This is an extension of the static traversals
|
|
// represented by type Module that deals with the possibility of a single
|
|
// module call producing multiple instances via the "count" and "for_each"
|
|
// arguments.
|
|
//
|
|
// Although ModuleInstance is a slice, it should be treated as immutable after
|
|
// creation.
|
|
type ModuleInstance []ModuleInstanceStep
|
|
|
|
func parseModuleInstance(traversal hcl.Traversal) (ModuleInstance, tfdiags.Diagnostics) {
|
|
mi, remain, diags := parseModuleInstancePrefix(traversal)
|
|
if len(remain) != 0 {
|
|
if len(remain) == len(traversal) {
|
|
diags = append(diags, tfdiags.Diag(
|
|
tfdiags.Error,
|
|
"Invalid module instance address",
|
|
"A module instance address must begin with \"module.\".",
|
|
))
|
|
} else {
|
|
diags = append(diags, tfdiags.Diag(
|
|
tfdiags.Error,
|
|
"Invalid module instance address",
|
|
"The module instance address is followed by additional invalid content.",
|
|
))
|
|
}
|
|
}
|
|
return mi, diags
|
|
}
|
|
|
|
// ParseModuleInstanceStr is a helper wrapper around ParseModuleInstance
|
|
// that takes a string and parses it with the HCL native syntax traversal parser
|
|
// before interpreting it.
|
|
//
|
|
// This should be used only in specialized situations since it will cause the
|
|
// created references to not have any meaningful source location information.
|
|
// If a reference string is coming from a source that should be identified in
|
|
// error messages then the caller should instead parse it directly using a
|
|
// suitable function from the HCL API and pass the traversal itself to
|
|
// ParseProviderConfigCompact.
|
|
//
|
|
// Error diagnostics are returned if either the parsing fails or the analysis
|
|
// of the traversal fails. There is no way for the caller to distinguish the
|
|
// two kinds of diagnostics programmatically. If error diagnostics are returned
|
|
// then the returned address is invalid.
|
|
func ParseModuleInstanceStr(str string) (ModuleInstance, tfdiags.Diagnostics) {
|
|
var diags tfdiags.Diagnostics
|
|
|
|
traversal, parseDiags := hclsyntax.ParseTraversalAbs([]byte(str), "", hcl.Pos{Line: 1, Column: 1})
|
|
for _, err := range parseDiags.Errs() {
|
|
// ignore warnings, they don't matter in this case
|
|
diags = append(diags, tfdiags.FromError(err))
|
|
}
|
|
if parseDiags.HasErrors() {
|
|
return nil, diags
|
|
}
|
|
|
|
addr, addrDiags := parseModuleInstance(traversal)
|
|
diags = append(diags, addrDiags...)
|
|
return addr, diags
|
|
}
|
|
|
|
func parseModuleInstancePrefix(traversal hcl.Traversal) (ModuleInstance, hcl.Traversal, tfdiags.Diagnostics) {
|
|
remain := traversal
|
|
var mi ModuleInstance
|
|
var diags tfdiags.Diagnostics
|
|
|
|
for len(remain) > 0 {
|
|
var next string
|
|
switch tt := remain[0].(type) {
|
|
case hcl.TraverseRoot:
|
|
next = tt.Name
|
|
case hcl.TraverseAttr:
|
|
next = tt.Name
|
|
default:
|
|
diags = append(diags, tfdiags.Diag(
|
|
tfdiags.Error,
|
|
"Invalid address operator",
|
|
"Module address prefix must be followed by dot and then a name.",
|
|
))
|
|
}
|
|
|
|
if next != "module" {
|
|
break
|
|
}
|
|
|
|
remain = remain[1:]
|
|
// If we have the prefix "module" then we should be followed by an
|
|
// module call name, as an attribute, and then optionally an index step
|
|
// giving the instance key.
|
|
if len(remain) == 0 {
|
|
diags = append(diags, tfdiags.Diag(
|
|
tfdiags.Error,
|
|
"Invalid address operator",
|
|
"Prefix \"module.\" must be followed by a module name.",
|
|
))
|
|
break
|
|
}
|
|
|
|
var moduleName string
|
|
switch tt := remain[0].(type) {
|
|
case hcl.TraverseAttr:
|
|
moduleName = tt.Name
|
|
default:
|
|
diags = append(diags, tfdiags.Diag(
|
|
tfdiags.Error,
|
|
"Invalid address operator",
|
|
"Prefix \"module.\" must be followed by a module name.",
|
|
))
|
|
}
|
|
remain = remain[1:]
|
|
step := ModuleInstanceStep{
|
|
Name: moduleName,
|
|
}
|
|
|
|
if len(remain) > 0 {
|
|
if idx, ok := remain[0].(hcl.TraverseIndex); ok {
|
|
remain = remain[1:]
|
|
|
|
switch idx.Key.Type() {
|
|
case cty.String:
|
|
step.InstanceKey = stringKey(idx.Key.AsString())
|
|
case cty.Number:
|
|
var idxInt int
|
|
err := gocty.FromCtyValue(idx.Key, &idxInt)
|
|
if err == nil {
|
|
step.InstanceKey = intKey(idxInt)
|
|
} else {
|
|
diags = append(diags, tfdiags.Diag(
|
|
tfdiags.Error,
|
|
"Invalid address operator",
|
|
fmt.Sprintf("Invalid module index: %s.", err),
|
|
))
|
|
}
|
|
default:
|
|
// Should never happen, because no other types are allowed in traversal indices.
|
|
diags = append(diags, tfdiags.Diag(
|
|
tfdiags.Error,
|
|
"Invalid address operator",
|
|
"Invalid module key: must be either a string or an integer.",
|
|
))
|
|
}
|
|
}
|
|
}
|
|
|
|
mi = append(mi, step)
|
|
}
|
|
|
|
var retRemain hcl.Traversal
|
|
if len(remain) > 0 {
|
|
retRemain = make(hcl.Traversal, len(remain))
|
|
copy(retRemain, remain)
|
|
// The first element here might be either a TraverseRoot or a
|
|
// TraverseAttr, depending on whether we had a module address on the
|
|
// front. To make life easier for callers, we'll normalize to always
|
|
// start with a TraverseRoot.
|
|
if tt, ok := retRemain[0].(hcl.TraverseAttr); ok {
|
|
retRemain[0] = hcl.TraverseRoot{
|
|
Name: tt.Name,
|
|
SrcRange: tt.SrcRange,
|
|
}
|
|
}
|
|
}
|
|
|
|
return mi, retRemain, diags
|
|
}
|
|
|
|
// UnkeyedInstanceShim is a shim method for converting a Module address to the
|
|
// equivalent ModuleInstance address that assumes that no modules have
|
|
// keyed instances.
|
|
//
|
|
// This is a temporary allowance for the fact that Terraform does not presently
|
|
// support "count" and "for_each" on modules, and thus graph building code that
|
|
// derives graph nodes from configuration must just assume unkeyed modules
|
|
// in order to construct the graph. At a later time when "count" and "for_each"
|
|
// support is added for modules, all callers of this method will need to be
|
|
// reworked to allow for keyed module instances.
|
|
func (m Module) UnkeyedInstanceShim() ModuleInstance {
|
|
path := make(ModuleInstance, len(m))
|
|
for i, name := range m {
|
|
path[i] = ModuleInstanceStep{Name: name}
|
|
}
|
|
return path
|
|
}
|
|
|
|
// ModuleInstanceStep is a single traversal step through the dynamic module
|
|
// tree. It is used only as part of ModuleInstance.
|
|
type ModuleInstanceStep struct {
|
|
Name string
|
|
InstanceKey instanceKey
|
|
}
|
|
|
|
// RootModuleInstance is the module instance address representing the root
|
|
// module, which is also the zero value of ModuleInstance.
|
|
var RootModuleInstance ModuleInstance
|
|
|
|
// Child returns the address of a child module instance of the receiver,
|
|
// identified by the given name and key.
|
|
func (m ModuleInstance) Child(name string, key instanceKey) ModuleInstance {
|
|
ret := make(ModuleInstance, 0, len(m)+1)
|
|
ret = append(ret, m...)
|
|
return append(ret, ModuleInstanceStep{
|
|
Name: name,
|
|
InstanceKey: key,
|
|
})
|
|
}
|
|
|
|
// String returns a string representation of the receiver, in the format used
|
|
// within e.g. user-provided resource addresses.
|
|
//
|
|
// The address of the root module has the empty string as its representation.
|
|
func (m ModuleInstance) String() string {
|
|
var buf bytes.Buffer
|
|
sep := ""
|
|
for _, step := range m {
|
|
buf.WriteString(sep)
|
|
buf.WriteString("module.")
|
|
buf.WriteString(step.Name)
|
|
if step.InstanceKey != NoKey {
|
|
buf.WriteString(step.InstanceKey.String())
|
|
}
|
|
sep = "."
|
|
}
|
|
return buf.String()
|
|
}
|