Documentation

Overview

    Package addrs contains types that represent "addresses", which are references to specific objects within a Terraform configuration or state.

    All addresses have string representations based on HCL traversal syntax which should be used in the user-interface, and also in-memory representations that can be used internally.

    For object types that exist within Terraform modules a pair of types is used. The "local" part of the address is represented by a type, and then an absolute path to that object in the context of its module is represented by a type of the same name with an "Abs" prefix added, for "absolute".

    All types within this package should be treated as immutable, even if this is not enforced by the Go compiler. It is always an implementation error to modify an address object in-place after it is initially constructed.

    Index

    Constants

    View Source
    const BuiltInProviderHost = svchost.Hostname("terraform.io")

      BuiltInProviderHost is the pseudo-hostname used for the "built-in" provider namespace. Built-in provider addresses must also have their namespace set to BuiltInProviderNamespace in order to be considered as built-in.

      View Source
      const BuiltInProviderNamespace = "builtin"

        BuiltInProviderNamespace is the provider namespace used for "built-in" providers. Built-in provider addresses must also have their hostname set to BuiltInProviderHost in order to be considered as built-in.

        The this namespace is literally named "builtin", in the hope that users who see FQNs containing this will be able to infer the way in which they are special, even if they haven't encountered the concept formally yet.

        View Source
        const DefaultRegistryHost = svchost.Hostname("registry.terraform.io")

          DefaultRegistryHost is the hostname used for provider addresses that do not have an explicit hostname.

          View Source
          const LegacyProviderNamespace = "-"

            LegacyProviderNamespace is the special string used in the Namespace field of type Provider to mark a legacy provider address. This special namespace value would normally be invalid, and can be used only when the hostname is DefaultRegistryHost because that host owns the mapping from legacy name to FQN.

            View Source
            const Self selfT = 0

              Self is the address of the special object "self" that behaves as an alias for a containing object currently in scope.

              Variables

              This section is empty.

              Functions

              func InstanceKeyLess

              func InstanceKeyLess(i, j InstanceKey) bool

                InstanceKeyLess returns true if the first given instance key i should sort before the second key j, and false otherwise.

                func IsProviderPartNormalized

                func IsProviderPartNormalized(str string) (bool, error)

                  IsProviderPartNormalized compares a given string to the result of ParseProviderPart(string)

                  func MustParseProviderPart

                  func MustParseProviderPart(given string) string

                    MustParseProviderPart is a wrapper around ParseProviderPart that panics if it returns an error.

                    func ParseProviderPart

                    func ParseProviderPart(given string) (string, error)

                      ParseProviderPart processes an addrs.Provider namespace or type string provided by an end-user, producing a normalized version if possible or an error if the string contains invalid characters.

                      A provider part is processed in the same way as an individual label in a DNS domain name: it is transformed to lowercase per the usual DNS case mapping and normalization rules and may contain only letters, digits, and dashes. Additionally, dashes may not appear at the start or end of the string.

                      These restrictions are intended to allow these names to appear in fussy contexts such as directory/file names on case-insensitive filesystems, repository names on GitHub, etc. We're using the DNS rules in particular, rather than some similar rules defined locally, because the hostname part of an addrs.Provider is already a hostname and it's ideal to use exactly the same case folding and normalization rules for all of the parts.

                      In practice a provider type string conventionally does not contain dashes either. Such names are permitted, but providers with such type names will be hard to use because their resource type names will not be able to contain the provider type name and thus each resource will need an explicit provider address specified. (A real-world example of such a provider is the "google-beta" variant of the GCP provider, which has resource types that start with the "google_" prefix instead.)

                      It's valid to pass the result of this function as the argument to a subsequent call, in which case the result will be identical.

                      Types

                      type AbsInputVariableInstance

                      type AbsInputVariableInstance struct {
                      	Module   ModuleInstance
                      	Variable InputVariable
                      }

                        AbsInputVariableInstance is the address of an input variable within a particular module instance.

                        func (AbsInputVariableInstance) String

                        func (v AbsInputVariableInstance) String() string

                        type AbsLocalValue

                        type AbsLocalValue struct {
                        	Module     ModuleInstance
                        	LocalValue LocalValue
                        }

                          AbsLocalValue is the absolute address of a local value within a module instance.

                          func (AbsLocalValue) String

                          func (v AbsLocalValue) String() string

                          type AbsModuleCallOutput

                          type AbsModuleCallOutput struct {
                          	Call ModuleCallInstance
                          	Name string
                          	// contains filtered or unexported fields
                          }

                            AbsModuleCallOutput is the address of a particular named output produced by an instance of a module call.

                            func (AbsModuleCallOutput) AbsOutputValue

                            func (co AbsModuleCallOutput) AbsOutputValue(caller ModuleInstance) AbsOutputValue

                              AbsOutputValue returns the absolute output value address that corresponds to the receving module call output address, once resolved in the given calling module.

                              func (AbsModuleCallOutput) ModuleCallOutput

                              func (co AbsModuleCallOutput) ModuleCallOutput() ModuleCallOutput

                                ModuleCallOutput returns the referenceable ModuleCallOutput for this particular instance.

                                func (AbsModuleCallOutput) String

                                func (co AbsModuleCallOutput) String() string

                                type AbsOutputValue

                                type AbsOutputValue struct {
                                	Module      ModuleInstance
                                	OutputValue OutputValue
                                }

                                  AbsOutputValue is the absolute address of an output value within a module instance.

                                  This represents an output globally within the namespace of a particular configuration. It is related to but separate from ModuleCallOutput, which represents a module output from the perspective of its parent module.

                                  func (AbsOutputValue) Equal

                                  func (v AbsOutputValue) Equal(o AbsOutputValue) bool

                                  func (AbsOutputValue) ModuleCallOutput

                                  func (v AbsOutputValue) ModuleCallOutput() (ModuleInstance, AbsModuleCallOutput)

                                    ModuleCallOutput converts an AbsModuleOutput into a ModuleCallOutput, returning also the module instance that the ModuleCallOutput is relative to.

                                    The root module does not have a call, and so this method cannot be used with outputs in the root module, and will panic in that case.

                                    func (AbsOutputValue) String

                                    func (v AbsOutputValue) String() string

                                    type AbsProviderConfig

                                    type AbsProviderConfig struct {
                                    	Module   Module
                                    	Provider Provider
                                    	Alias    string
                                    }

                                      AbsProviderConfig is the absolute address of a provider configuration within a particular module instance.

                                      func ParseAbsProviderConfig

                                      func ParseAbsProviderConfig(traversal hcl.Traversal) (AbsProviderConfig, tfdiags.Diagnostics)

                                        ParseAbsProviderConfig parses the given traversal as an absolute provider address. The following are examples of traversals that can be successfully parsed as absolute provider configuration addresses:

                                        provider["registry.terraform.io/hashicorp/aws"]
                                        provider["registry.terraform.io/hashicorp/aws"].foo
                                        module.bar.provider["registry.terraform.io/hashicorp/aws"]
                                        module.bar.module.baz.provider["registry.terraform.io/hashicorp/aws"].foo
                                        

                                        This type of address is used, for example, to record the relationships between resources and provider configurations in the state structure. This type of address is not generally used in the UI, except in error messages that refer to provider configurations.

                                        func ParseAbsProviderConfigStr

                                        func ParseAbsProviderConfigStr(str string) (AbsProviderConfig, tfdiags.Diagnostics)

                                          ParseAbsProviderConfigStr is a helper wrapper around ParseAbsProviderConfig 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 ParseAbsProviderConfig.

                                          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 the returned address is invalid.

                                          func ParseLegacyAbsProviderConfig

                                          func ParseLegacyAbsProviderConfig(traversal hcl.Traversal) (AbsProviderConfig, tfdiags.Diagnostics)

                                            ParseLegacyAbsProviderConfig parses the given traversal as an absolute provider address. The following are examples of traversals that can be successfully parsed as legacy absolute provider configuration addresses:

                                            provider.aws
                                            provider.aws.foo
                                            module.bar.provider.aws
                                            module.bar.module.baz.provider.aws.foo
                                            

                                            This type of address is used in legacy state and may appear in state v4 if the provider config addresses have not been normalized to include provider FQN.

                                            func ParseLegacyAbsProviderConfigStr

                                            func ParseLegacyAbsProviderConfigStr(str string) (AbsProviderConfig, tfdiags.Diagnostics)

                                            func (AbsProviderConfig) Inherited

                                            func (pc AbsProviderConfig) Inherited() (AbsProviderConfig, bool)

                                              Inherited returns an address that the receiving configuration address might inherit from in a parent module. The second bool return value indicates if such inheritance is possible, and thus whether the returned address is valid.

                                              Inheritance is possible only for default (un-aliased) providers in modules other than the root module. Even if a valid address is returned, inheritence may not be performed for other reasons, such as if the calling module provided explicit provider configurations within the call for this module. The ProviderTransformer graph transform in the main terraform module has the authoritative logic for provider inheritance, and this method is here mainly just for its benefit.

                                              func (AbsProviderConfig) LegacyString

                                              func (pc AbsProviderConfig) LegacyString() string

                                                LegacyString() returns a legacy-style AbsProviderConfig string and should only be used for legacy state shimming.

                                                func (AbsProviderConfig) String

                                                func (pc AbsProviderConfig) String() string

                                                  String() returns a string representation of an AbsProviderConfig in the following format:

                                                  provider["example.com/namespace/name"]
                                                  provider["example.com/namespace/name"].alias
                                                  module.module-name.provider["example.com/namespace/name"]
                                                  module.module-name.provider["example.com/namespace/name"].alias
                                                  

                                                  type AbsResource

                                                  type AbsResource struct {
                                                  	Module   ModuleInstance
                                                  	Resource Resource
                                                  	// contains filtered or unexported fields
                                                  }

                                                    AbsResource is an absolute address for a resource under a given module path.

                                                    func ParseAbsResource

                                                    func ParseAbsResource(traversal hcl.Traversal) (AbsResource, tfdiags.Diagnostics)

                                                      ParseAbsResource attempts to interpret the given traversal as an absolute resource address, using the same syntax as expected by ParseTarget.

                                                      If no error diagnostics are returned, the returned target includes the address that was extracted and the source range it was extracted from.

                                                      If error diagnostics are returned then the AbsResource value is invalid and must not be used.

                                                      func ParseAbsResourceStr

                                                      func ParseAbsResourceStr(str string) (AbsResource, tfdiags.Diagnostics)

                                                        ParseAbsResourceStr is a helper wrapper around ParseAbsResource that takes a string and parses it with the HCL native syntax traversal parser before interpreting it.

                                                        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 the returned address may be incomplete.

                                                        Since this function has no context about the source of the given string, any returned diagnostics will not have meaningful source location information.

                                                        func (AbsResource) Config

                                                        func (r AbsResource) Config() ConfigResource

                                                          Config returns the unexpanded ConfigResource for this AbsResource.

                                                          func (AbsResource) Equal

                                                          func (r AbsResource) Equal(o AbsResource) bool

                                                          func (AbsResource) Instance

                                                            Instance produces the address for a specific instance of the receiver that is idenfied by the given key.

                                                            func (AbsResource) String

                                                            func (r AbsResource) String() string

                                                            func (AbsResource) TargetContains

                                                            func (r AbsResource) TargetContains(other Targetable) bool

                                                              TargetContains implements Targetable by returning true if the given other address is either equal to the receiver or is an instance of the receiver.

                                                              type AbsResourceInstance

                                                              type AbsResourceInstance struct {
                                                              	Module   ModuleInstance
                                                              	Resource ResourceInstance
                                                              	// contains filtered or unexported fields
                                                              }

                                                                AbsResourceInstance is an absolute address for a resource instance under a given module path.

                                                                func ParseAbsResourceInstance

                                                                func ParseAbsResourceInstance(traversal hcl.Traversal) (AbsResourceInstance, tfdiags.Diagnostics)

                                                                  ParseAbsResourceInstance attempts to interpret the given traversal as an absolute resource instance address, using the same syntax as expected by ParseTarget.

                                                                  If no error diagnostics are returned, the returned target includes the address that was extracted and the source range it was extracted from.

                                                                  If error diagnostics are returned then the AbsResource value is invalid and must not be used.

                                                                  func ParseAbsResourceInstanceStr

                                                                  func ParseAbsResourceInstanceStr(str string) (AbsResourceInstance, tfdiags.Diagnostics)

                                                                    ParseAbsResourceInstanceStr is a helper wrapper around ParseAbsResourceInstance that takes a string and parses it with the HCL native syntax traversal parser before interpreting it.

                                                                    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 the returned address may be incomplete.

                                                                    Since this function has no context about the source of the given string, any returned diagnostics will not have meaningful source location information.

                                                                    func (AbsResourceInstance) ContainingResource

                                                                    func (r AbsResourceInstance) ContainingResource() AbsResource

                                                                      ContainingResource returns the address of the resource that contains the receving resource instance. In other words, it discards the key portion of the address to produce an AbsResource value.

                                                                      func (AbsResourceInstance) Equal

                                                                      func (AbsResourceInstance) Less

                                                                        Less returns true if the receiver should sort before the given other value in a sorted list of addresses.

                                                                        func (AbsResourceInstance) String

                                                                        func (r AbsResourceInstance) String() string

                                                                        func (AbsResourceInstance) TargetContains

                                                                        func (r AbsResourceInstance) TargetContains(other Targetable) bool

                                                                          TargetContains implements Targetable by returning true if the given other address is equal to the receiver.

                                                                          type ConfigResource

                                                                          type ConfigResource struct {
                                                                          	Module   Module
                                                                          	Resource Resource
                                                                          	// contains filtered or unexported fields
                                                                          }

                                                                            ConfigResource is an address for a resource within a configuration.

                                                                            func (ConfigResource) Absolute

                                                                            func (r ConfigResource) Absolute(module ModuleInstance) AbsResource

                                                                              Absolute produces the address for the receiver within a specific module instance.

                                                                              func (ConfigResource) Equal

                                                                              func (r ConfigResource) Equal(o ConfigResource) bool

                                                                              func (ConfigResource) String

                                                                              func (r ConfigResource) String() string

                                                                              func (ConfigResource) TargetContains

                                                                              func (r ConfigResource) TargetContains(other Targetable) bool

                                                                                TargetContains implements Targetable by returning true if the given other address is either equal to the receiver or is an instance of the receiver.

                                                                                type CountAttr

                                                                                type CountAttr struct {
                                                                                	Name string
                                                                                	// contains filtered or unexported fields
                                                                                }

                                                                                  CountAttr is the address of an attribute of the "count" object in the interpolation scope, like "count.index".

                                                                                  func (CountAttr) String

                                                                                  func (ca CountAttr) String() string

                                                                                  type ForEachAttr

                                                                                  type ForEachAttr struct {
                                                                                  	Name string
                                                                                  	// contains filtered or unexported fields
                                                                                  }

                                                                                    ForEachAttr is the address of an attribute referencing the current "for_each" object in the interpolation scope, addressed using the "each" keyword, ex. "each.key" and "each.value"

                                                                                    func (ForEachAttr) String

                                                                                    func (f ForEachAttr) String() string

                                                                                    type InputVariable

                                                                                    type InputVariable struct {
                                                                                    	Name string
                                                                                    	// contains filtered or unexported fields
                                                                                    }

                                                                                      InputVariable is the address of an input variable.

                                                                                      func (InputVariable) Absolute

                                                                                        Absolute converts the receiver into an absolute address within the given module instance.

                                                                                        func (InputVariable) String

                                                                                        func (v InputVariable) String() string

                                                                                        type InstanceKey

                                                                                        type InstanceKey interface {
                                                                                        	String() string
                                                                                        
                                                                                        	// Value returns the cty.Value of the appropriate type for the InstanceKey
                                                                                        	// value.
                                                                                        	Value() cty.Value
                                                                                        	// contains filtered or unexported methods
                                                                                        }

                                                                                          InstanceKey represents the key of an instance within an object that contains multiple instances due to using "count" or "for_each" arguments in configuration.

                                                                                          IntKey and StringKey are the two implementations of this type. No other implementations are allowed. The single instance of an object that _isn't_ using "count" or "for_each" is represented by NoKey, which is a nil InstanceKey.

                                                                                          var NoKey InstanceKey

                                                                                            NoKey represents the absense of an InstanceKey, for the single instance of a configuration object that does not use "count" or "for_each" at all.

                                                                                            func ParseInstanceKey

                                                                                            func ParseInstanceKey(key cty.Value) (InstanceKey, error)

                                                                                              ParseInstanceKey returns the instance key corresponding to the given value, which must be known and non-null.

                                                                                              If an unknown or null value is provided then this function will panic. This function is intended to deal with the values that would naturally be found in a hcl.TraverseIndex, which (when parsed from source, at least) can never contain unknown or null values.

                                                                                              type InstanceKeyType

                                                                                              type InstanceKeyType rune

                                                                                                InstanceKeyType represents the different types of instance key that are supported. Usually it is sufficient to simply type-assert an InstanceKey value to either IntKey or StringKey, but this type and its values can be used to represent the types themselves, rather than specific values of those types.

                                                                                                const (
                                                                                                	NoKeyType     InstanceKeyType = 0
                                                                                                	IntKeyType    InstanceKeyType = 'I'
                                                                                                	StringKeyType InstanceKeyType = 'S'
                                                                                                )

                                                                                                type IntKey

                                                                                                type IntKey int

                                                                                                  IntKey is the InstanceKey representation representing integer indices, as used when the "count" argument is specified or if for_each is used with a sequence type.

                                                                                                  func (IntKey) String

                                                                                                  func (k IntKey) String() string

                                                                                                  func (IntKey) Value

                                                                                                  func (k IntKey) Value() cty.Value

                                                                                                  type LocalProviderConfig

                                                                                                  type LocalProviderConfig struct {
                                                                                                  	LocalName string
                                                                                                  
                                                                                                  	// If not empty, Alias identifies which non-default (aliased) provider
                                                                                                  	// configuration this address refers to.
                                                                                                  	Alias string
                                                                                                  }

                                                                                                    LocalProviderConfig is the address of a provider configuration from the perspective of references in a particular module.

                                                                                                    Finding the corresponding AbsProviderConfig will require looking up the LocalName in the providers table in the module's configuration; there is no syntax-only translation between these types.

                                                                                                    func NewDefaultLocalProviderConfig

                                                                                                    func NewDefaultLocalProviderConfig(LocalNameName string) LocalProviderConfig

                                                                                                      NewDefaultLocalProviderConfig returns the address of the default (un-aliased) configuration for the provider with the given local type name.

                                                                                                      func (LocalProviderConfig) String

                                                                                                      func (pc LocalProviderConfig) String() string

                                                                                                      func (LocalProviderConfig) StringCompact

                                                                                                      func (pc LocalProviderConfig) StringCompact() string

                                                                                                        StringCompact is an alternative to String that returns the form that can be parsed by ParseProviderConfigCompact, without the "provider." prefix.

                                                                                                        type LocalValue

                                                                                                        type LocalValue struct {
                                                                                                        	Name string
                                                                                                        	// contains filtered or unexported fields
                                                                                                        }

                                                                                                          LocalValue is the address of a local value.

                                                                                                          func (LocalValue) Absolute

                                                                                                          func (v LocalValue) Absolute(m ModuleInstance) AbsLocalValue

                                                                                                            Absolute converts the receiver into an absolute address within the given module instance.

                                                                                                            func (LocalValue) String

                                                                                                            func (v LocalValue) String() string

                                                                                                            type Module

                                                                                                            type Module []string

                                                                                                              Module is an address for a module call within configuration. This is the static counterpart of ModuleInstance, representing a traversal through the static module call tree in configuration and does not take into account the potentially-multiple instances of a module that might be created by "count" and "for_each" arguments within those calls.

                                                                                                              This type should be used only in very specialized cases when working with the static module call tree. Type ModuleInstance is appropriate in more cases.

                                                                                                              Although Module is a slice, it should be treated as immutable after creation.

                                                                                                              var RootModule Module

                                                                                                                RootModule is the module address representing the root of the static module call tree, which is also the zero value of Module.

                                                                                                                Note that this is not the root of the dynamic module tree, which is instead represented by RootModuleInstance.

                                                                                                                func (Module) Ancestors

                                                                                                                func (m Module) Ancestors() []Module

                                                                                                                  Ancestors returns a slice containing the receiver and all of its ancestor modules, all the way up to (and including) the root module. The result is ordered by depth, with the root module always first.

                                                                                                                  Since the result always includes the root module, a caller may choose to ignore it by slicing the result with [1:].

                                                                                                                  func (Module) Call

                                                                                                                  func (m Module) Call() (Module, ModuleCall)

                                                                                                                    Call returns the module call address that corresponds to the given module instance, along with the address of the module that contains it.

                                                                                                                    There is no call for the root module, so this method will panic if called on the root module address.

                                                                                                                    In practice, this just turns the last element of the receiver into a ModuleCall and then returns a slice of the receiever that excludes that last part. This is just a convenience for situations where a call address is required, such as when dealing with *Reference and Referencable values.

                                                                                                                    func (Module) Child

                                                                                                                    func (m Module) Child(name string) Module

                                                                                                                      Child returns the address of a child call in the receiver, identified by the given name.

                                                                                                                      func (Module) Equal

                                                                                                                      func (m Module) Equal(other Module) bool

                                                                                                                      func (Module) IsRoot

                                                                                                                      func (m Module) IsRoot() bool

                                                                                                                        IsRoot returns true if the receiver is the address of the root module, or false otherwise.

                                                                                                                        func (Module) Parent

                                                                                                                        func (m Module) Parent() Module

                                                                                                                          Parent returns the address of the parent module of the receiver, or the receiver itself if there is no parent (if it's the root module address).

                                                                                                                          func (Module) Resource

                                                                                                                          func (m Module) Resource(mode ResourceMode, typeName string, name string) ConfigResource

                                                                                                                            Resource returns the address of a particular resource within the module.

                                                                                                                            func (Module) String

                                                                                                                            func (m Module) String() string

                                                                                                                            func (Module) TargetContains

                                                                                                                            func (m Module) TargetContains(other Targetable) bool

                                                                                                                              TargetContains implements Targetable for Module by returning true if the given other address either matches the receiver, is a sub-module-instance of the receiver, or is a targetable absolute address within a module that is contained within the receiver.

                                                                                                                              func (Module) UnkeyedInstanceShim

                                                                                                                              func (m Module) UnkeyedInstanceShim() ModuleInstance

                                                                                                                                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.

                                                                                                                                type ModuleCall

                                                                                                                                type ModuleCall struct {
                                                                                                                                	Name string
                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                }

                                                                                                                                  ModuleCall is the address of a call from the current module to a child module.

                                                                                                                                  There is no "Abs" version of ModuleCall because an absolute module path is represented by ModuleInstance.

                                                                                                                                  func (ModuleCall) Instance

                                                                                                                                  func (c ModuleCall) Instance(key InstanceKey) ModuleCallInstance

                                                                                                                                    Instance returns the address of an instance of the receiver identified by the given key.

                                                                                                                                    func (ModuleCall) String

                                                                                                                                    func (c ModuleCall) String() string

                                                                                                                                    type ModuleCallInstance

                                                                                                                                    type ModuleCallInstance struct {
                                                                                                                                    	Call ModuleCall
                                                                                                                                    	Key  InstanceKey
                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                    }

                                                                                                                                      ModuleCallInstance is the address of one instance of a module created from a module call, which might create multiple instances using "count" or "for_each" arguments.

                                                                                                                                      func (ModuleCallInstance) ModuleInstance

                                                                                                                                      func (c ModuleCallInstance) ModuleInstance(caller ModuleInstance) ModuleInstance

                                                                                                                                        ModuleInstance returns the address of the module instance that corresponds to the receiving call instance when resolved in the given calling module. In other words, it returns the child module instance that the receving call instance creates.

                                                                                                                                        func (ModuleCallInstance) Output

                                                                                                                                          Output returns the absolute address of an output of the receiver identified by its name.

                                                                                                                                          func (ModuleCallInstance) String

                                                                                                                                          func (c ModuleCallInstance) String() string

                                                                                                                                          type ModuleCallOutput

                                                                                                                                          type ModuleCallOutput struct {
                                                                                                                                          	Call ModuleCall
                                                                                                                                          	Name string
                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                          }

                                                                                                                                            ModuleCallOutput is the address of a named output and its associated ModuleCall, which may expand into multiple module instances

                                                                                                                                            func (ModuleCallOutput) String

                                                                                                                                            func (m ModuleCallOutput) String() string

                                                                                                                                            type ModuleInstance

                                                                                                                                            type ModuleInstance []ModuleInstanceStep

                                                                                                                                              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.

                                                                                                                                              var RootModuleInstance ModuleInstance

                                                                                                                                                RootModuleInstance is the module instance address representing the root module, which is also the zero value of ModuleInstance.

                                                                                                                                                func ParseModuleInstance

                                                                                                                                                func ParseModuleInstance(traversal hcl.Traversal) (ModuleInstance, tfdiags.Diagnostics)

                                                                                                                                                func ParseModuleInstanceStr

                                                                                                                                                func ParseModuleInstanceStr(str string) (ModuleInstance, tfdiags.Diagnostics)

                                                                                                                                                  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 ParseModuleInstance.

                                                                                                                                                  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 (ModuleInstance) Ancestors

                                                                                                                                                  func (m ModuleInstance) Ancestors() []ModuleInstance

                                                                                                                                                    Ancestors returns a slice containing the receiver and all of its ancestor module instances, all the way up to (and including) the root module. The result is ordered by depth, with the root module always first.

                                                                                                                                                    Since the result always includes the root module, a caller may choose to ignore it by slicing the result with [1:].

                                                                                                                                                    func (ModuleInstance) Call

                                                                                                                                                      Call returns the module call address that corresponds to the given module instance, along with the address of the module instance that contains it.

                                                                                                                                                      There is no call for the root module, so this method will panic if called on the root module address.

                                                                                                                                                      A single module call can produce potentially many module instances, so the result discards any instance key that might be present on the last step of the instance. To retain this, use CallInstance instead.

                                                                                                                                                      In practice, this just turns the last element of the receiver into a ModuleCall and then returns a slice of the receiever that excludes that last part. This is just a convenience for situations where a call address is required, such as when dealing with *Reference and Referencable values.

                                                                                                                                                      func (ModuleInstance) CallInstance

                                                                                                                                                      func (m ModuleInstance) CallInstance() (ModuleInstance, ModuleCallInstance)

                                                                                                                                                        CallInstance returns the module call instance address that corresponds to the given module instance, along with the address of the module instance that contains it.

                                                                                                                                                        There is no call for the root module, so this method will panic if called on the root module address.

                                                                                                                                                        In practice, this just turns the last element of the receiver into a ModuleCallInstance and then returns a slice of the receiever that excludes that last part. This is just a convenience for situations where a call\ address is required, such as when dealing with *Reference and Referencable values.

                                                                                                                                                        func (ModuleInstance) Child

                                                                                                                                                        func (m ModuleInstance) Child(name string, key InstanceKey) ModuleInstance

                                                                                                                                                          Child returns the address of a child module instance of the receiver, identified by the given name and key.

                                                                                                                                                          func (ModuleInstance) Equal

                                                                                                                                                          func (m ModuleInstance) Equal(o ModuleInstance) bool

                                                                                                                                                            Equal returns true if the receiver and the given other value contains the exact same parts.

                                                                                                                                                            func (ModuleInstance) InputVariable

                                                                                                                                                            func (m ModuleInstance) InputVariable(name string) AbsInputVariableInstance

                                                                                                                                                              InputVariable returns the absolute address of the input variable of the given name inside the receiving module instance.

                                                                                                                                                              func (ModuleInstance) IsAncestor

                                                                                                                                                              func (m ModuleInstance) IsAncestor(o ModuleInstance) bool

                                                                                                                                                                IsAncestor returns true if the receiver is an ancestor of the given other value.

                                                                                                                                                                func (ModuleInstance) IsRoot

                                                                                                                                                                func (m ModuleInstance) IsRoot() bool

                                                                                                                                                                  IsRoot returns true if the receiver is the address of the root module instance, or false otherwise.

                                                                                                                                                                  func (ModuleInstance) Less

                                                                                                                                                                    Less returns true if the receiver should sort before the given other value in a sorted list of addresses.

                                                                                                                                                                    func (ModuleInstance) LocalValue

                                                                                                                                                                    func (m ModuleInstance) LocalValue(name string) AbsLocalValue

                                                                                                                                                                      LocalValue returns the absolute address of a local value of the given name within the receiving module instance.

                                                                                                                                                                      func (ModuleInstance) Module

                                                                                                                                                                      func (m ModuleInstance) Module() Module

                                                                                                                                                                        Module returns the address of the module that this instance is an instance of.

                                                                                                                                                                        func (ModuleInstance) OutputValue

                                                                                                                                                                        func (m ModuleInstance) OutputValue(name string) AbsOutputValue

                                                                                                                                                                          OutputValue returns the absolute address of an output value of the given name within the receiving module instance.

                                                                                                                                                                          func (ModuleInstance) Parent

                                                                                                                                                                          func (m ModuleInstance) Parent() ModuleInstance

                                                                                                                                                                            Parent returns the address of the parent module instance of the receiver, or the receiver itself if there is no parent (if it's the root module address).

                                                                                                                                                                            func (ModuleInstance) ProviderConfigAliased

                                                                                                                                                                            func (m ModuleInstance) ProviderConfigAliased(provider Provider, alias string) AbsProviderConfig

                                                                                                                                                                              ProviderConfigAliased returns the address of an aliased provider config of the given type and alias inside the recieving module instance.

                                                                                                                                                                              func (ModuleInstance) ProviderConfigDefault

                                                                                                                                                                              func (m ModuleInstance) ProviderConfigDefault(provider Provider) AbsProviderConfig

                                                                                                                                                                                ProviderConfigDefault returns the address of the default provider config of the given type inside the recieving module instance.

                                                                                                                                                                                func (ModuleInstance) Resource

                                                                                                                                                                                func (m ModuleInstance) Resource(mode ResourceMode, typeName string, name string) AbsResource

                                                                                                                                                                                  Resource returns the address of a particular resource within the receiver.

                                                                                                                                                                                  func (ModuleInstance) ResourceInstance

                                                                                                                                                                                  func (m ModuleInstance) ResourceInstance(mode ResourceMode, typeName string, name string, key InstanceKey) AbsResourceInstance

                                                                                                                                                                                    ResourceInstance returns the address of a particular resource instance within the receiver.

                                                                                                                                                                                    func (ModuleInstance) String

                                                                                                                                                                                    func (m ModuleInstance) String() string

                                                                                                                                                                                      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 (ModuleInstance) TargetContains

                                                                                                                                                                                      func (m ModuleInstance) TargetContains(other Targetable) bool

                                                                                                                                                                                        TargetContains implements Targetable by returning true if the given other address either matches the receiver, is a sub-module-instance of the receiver, or is a targetable absolute address within a module that is contained within the reciever.

                                                                                                                                                                                        type ModuleInstanceStep

                                                                                                                                                                                        type ModuleInstanceStep struct {
                                                                                                                                                                                        	Name        string
                                                                                                                                                                                        	InstanceKey InstanceKey
                                                                                                                                                                                        }

                                                                                                                                                                                          ModuleInstanceStep is a single traversal step through the dynamic module tree. It is used only as part of ModuleInstance.

                                                                                                                                                                                          func (ModuleInstanceStep) String

                                                                                                                                                                                          func (s ModuleInstanceStep) String() string

                                                                                                                                                                                          type OutputValue

                                                                                                                                                                                          type OutputValue struct {
                                                                                                                                                                                          	Name string
                                                                                                                                                                                          }

                                                                                                                                                                                            OutputValue is the address of an output value, in the context of the module that is defining it.

                                                                                                                                                                                            This is related to but separate from ModuleCallOutput, which represents a module output from the perspective of its parent module. Since output values cannot be represented from the module where they are defined, OutputValue is not Referenceable, while ModuleCallOutput is.

                                                                                                                                                                                            func (OutputValue) Absolute

                                                                                                                                                                                              Absolute converts the receiver into an absolute address within the given module instance.

                                                                                                                                                                                              func (OutputValue) String

                                                                                                                                                                                              func (v OutputValue) String() string

                                                                                                                                                                                              type PathAttr

                                                                                                                                                                                              type PathAttr struct {
                                                                                                                                                                                              	Name string
                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                              }

                                                                                                                                                                                                PathAttr is the address of an attribute of the "path" object in the interpolation scope, like "path.module".

                                                                                                                                                                                                func (PathAttr) String

                                                                                                                                                                                                func (pa PathAttr) String() string

                                                                                                                                                                                                type Provider

                                                                                                                                                                                                type Provider struct {
                                                                                                                                                                                                	Type      string
                                                                                                                                                                                                	Namespace string
                                                                                                                                                                                                	Hostname  svchost.Hostname
                                                                                                                                                                                                }

                                                                                                                                                                                                  Provider encapsulates a single provider type. In the future this will be extended to include additional fields including Namespace and SourceHost

                                                                                                                                                                                                  func ImpliedProviderForUnqualifiedType

                                                                                                                                                                                                  func ImpliedProviderForUnqualifiedType(typeName string) Provider

                                                                                                                                                                                                    ImpliedProviderForUnqualifiedType represents the rules for inferring what provider FQN a user intended when only a naked type name is available.

                                                                                                                                                                                                    For all except the type name "terraform" this returns a so-called "default" provider, which is under the registry.terraform.io/hashicorp/ namespace.

                                                                                                                                                                                                    As a special case, the string "terraform" maps to "terraform.io/builtin/terraform" because that is the more likely user intent than the now-unmaintained "registry.terraform.io/hashicorp/terraform" which remains only for compatibility with older Terraform versions.

                                                                                                                                                                                                    func MustParseProviderSourceString

                                                                                                                                                                                                    func MustParseProviderSourceString(str string) Provider

                                                                                                                                                                                                      MustParseProviderSourceString is a wrapper around ParseProviderSourceString that panics if it returns an error.

                                                                                                                                                                                                      func NewBuiltInProvider

                                                                                                                                                                                                      func NewBuiltInProvider(name string) Provider

                                                                                                                                                                                                        NewBuiltInProvider returns the address of a "built-in" provider. See the docs for Provider.IsBuiltIn for more information.

                                                                                                                                                                                                        func NewDefaultProvider

                                                                                                                                                                                                        func NewDefaultProvider(name string) Provider

                                                                                                                                                                                                          NewDefaultProvider returns the default address of a HashiCorp-maintained, Registry-hosted provider.

                                                                                                                                                                                                          func NewLegacyProvider

                                                                                                                                                                                                          func NewLegacyProvider(name string) Provider

                                                                                                                                                                                                            NewLegacyProvider returns a mock address for a provider. This will be removed when ProviderType is fully integrated.

                                                                                                                                                                                                            func NewProvider

                                                                                                                                                                                                            func NewProvider(hostname svchost.Hostname, namespace, typeName string) Provider

                                                                                                                                                                                                              NewProvider constructs a provider address from its parts, and normalizes the namespace and type parts to lowercase using unicode case folding rules so that resulting addrs.Provider values can be compared using standard Go equality rules (==).

                                                                                                                                                                                                              The hostname is given as a svchost.Hostname, which is required by the contract of that type to have already been normalized for equality testing.

                                                                                                                                                                                                              This function will panic if the given namespace or type name are not valid. When accepting namespace or type values from outside the program, use ParseProviderPart first to check that the given value is valid.

                                                                                                                                                                                                              func ParseProviderSourceString

                                                                                                                                                                                                              func ParseProviderSourceString(str string) (Provider, tfdiags.Diagnostics)

                                                                                                                                                                                                                ParseProviderSourceString parses the source attribute and returns a provider. This is intended primarily to parse the FQN-like strings returned by terraform-config-inspect.

                                                                                                                                                                                                                The following are valid source string formats:

                                                                                                                                                                                                                name
                                                                                                                                                                                                                namespace/name
                                                                                                                                                                                                                hostname/namespace/name
                                                                                                                                                                                                                

                                                                                                                                                                                                                func (Provider) Equals

                                                                                                                                                                                                                func (pt Provider) Equals(other Provider) bool

                                                                                                                                                                                                                  Equals returns true if the receiver and other provider have the same attributes.

                                                                                                                                                                                                                  func (Provider) ForDisplay

                                                                                                                                                                                                                  func (pt Provider) ForDisplay() string

                                                                                                                                                                                                                    ForDisplay returns a user-friendly FQN string, simplified for readability. If the provider is using the default hostname, the hostname is omitted.

                                                                                                                                                                                                                    func (Provider) IsBuiltIn

                                                                                                                                                                                                                    func (pt Provider) IsBuiltIn() bool

                                                                                                                                                                                                                      IsBuiltIn returns true if the receiver is the address of a "built-in" provider. That is, a provider under terraform.io/builtin/ which is included as part of the Terraform binary itself rather than one to be installed from elsewhere.

                                                                                                                                                                                                                      These are ignored by the provider installer because they are assumed to already be available without any further installation.

                                                                                                                                                                                                                      func (Provider) IsDefault

                                                                                                                                                                                                                      func (pt Provider) IsDefault() bool

                                                                                                                                                                                                                        IsDefault returns true if the provider is a default hashicorp provider

                                                                                                                                                                                                                        func (Provider) IsLegacy

                                                                                                                                                                                                                        func (pt Provider) IsLegacy() bool

                                                                                                                                                                                                                          IsLegacy returns true if the provider is a legacy-style provider

                                                                                                                                                                                                                          func (Provider) IsZero

                                                                                                                                                                                                                          func (pt Provider) IsZero() bool

                                                                                                                                                                                                                            IsZero returns true if the receiver is the zero value of addrs.Provider.

                                                                                                                                                                                                                            The zero value is not a valid addrs.Provider and calling other methods on such a value is likely to either panic or otherwise misbehave.

                                                                                                                                                                                                                            func (Provider) LegacyString

                                                                                                                                                                                                                            func (pt Provider) LegacyString() string

                                                                                                                                                                                                                              LegacyString returns the provider type, which is frequently used interchangeably with provider name. This function can and should be removed when provider type is fully integrated. As a safeguard for future refactoring, this function panics if the Provider is not a legacy provider.

                                                                                                                                                                                                                              func (Provider) LessThan

                                                                                                                                                                                                                              func (pt Provider) LessThan(other Provider) bool

                                                                                                                                                                                                                                LessThan returns true if the receiver should sort before the other given address in an ordered list of provider addresses.

                                                                                                                                                                                                                                This ordering is an arbitrary one just to allow deterministic results from functions that would otherwise have no natural ordering. It's subject to change in future.

                                                                                                                                                                                                                                func (Provider) String

                                                                                                                                                                                                                                func (pt Provider) String() string

                                                                                                                                                                                                                                  String returns an FQN string, indended for use in machine-readable output.

                                                                                                                                                                                                                                  type ProviderConfig

                                                                                                                                                                                                                                  type ProviderConfig interface {
                                                                                                                                                                                                                                  	// contains filtered or unexported methods
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                    ProviderConfig is an interface type whose dynamic type can be either LocalProviderConfig or AbsProviderConfig, in order to represent situations where a value might either be module-local or absolute but the decision cannot be made until runtime.

                                                                                                                                                                                                                                    Where possible, use either LocalProviderConfig or AbsProviderConfig directly instead, to make intent more clear. ProviderConfig can be used only in situations where the recipient of the value has some out-of-band way to determine a "current module" to use if the value turns out to be a LocalProviderConfig.

                                                                                                                                                                                                                                    Recipients of non-nil ProviderConfig values that actually need AbsProviderConfig values should call ResolveAbsProviderAddr on the *configs.Config value representing the root module configuration, which handles the translation from local to fully-qualified using mapping tables defined in the configuration.

                                                                                                                                                                                                                                    Recipients of a ProviderConfig value can assume it can contain only a LocalProviderConfig value, an AbsProviderConfigValue, or nil to represent the absense of a provider config in situations where that is meaningful.

                                                                                                                                                                                                                                    type Reference

                                                                                                                                                                                                                                    type Reference struct {
                                                                                                                                                                                                                                    	Subject     Referenceable
                                                                                                                                                                                                                                    	SourceRange tfdiags.SourceRange
                                                                                                                                                                                                                                    	Remaining   hcl.Traversal
                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                      Reference describes a reference to an address with source location information.

                                                                                                                                                                                                                                      func ParseRef

                                                                                                                                                                                                                                      func ParseRef(traversal hcl.Traversal) (*Reference, tfdiags.Diagnostics)

                                                                                                                                                                                                                                        ParseRef attempts to extract a referencable address from the prefix of the given traversal, which must be an absolute traversal or this function will panic.

                                                                                                                                                                                                                                        If no error diagnostics are returned, the returned reference includes the address that was extracted, the source range it was extracted from, and any remaining relative traversal that was not consumed as part of the reference.

                                                                                                                                                                                                                                        If error diagnostics are returned then the Reference value is invalid and must not be used.

                                                                                                                                                                                                                                        func ParseRefStr

                                                                                                                                                                                                                                        func ParseRefStr(str string) (*Reference, tfdiags.Diagnostics)

                                                                                                                                                                                                                                          ParseRefStr is a helper wrapper around ParseRef 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 ParseRef.

                                                                                                                                                                                                                                          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 the returned reference may be nil or incomplete.

                                                                                                                                                                                                                                          type Referenceable

                                                                                                                                                                                                                                          type Referenceable interface {
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// String produces a string representation of the address that could be
                                                                                                                                                                                                                                          	// parsed as a HCL traversal and passed to ParseRef to produce an identical
                                                                                                                                                                                                                                          	// result.
                                                                                                                                                                                                                                          	String() string
                                                                                                                                                                                                                                          	// contains filtered or unexported methods
                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                            Referenceable is an interface implemented by all address types that can appear as references in configuration language expressions.

                                                                                                                                                                                                                                            type Resource

                                                                                                                                                                                                                                            type Resource struct {
                                                                                                                                                                                                                                            	Mode ResourceMode
                                                                                                                                                                                                                                            	Type string
                                                                                                                                                                                                                                            	Name string
                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                              Resource is an address for a resource block within configuration, which contains potentially-multiple resource instances if that configuration block uses "count" or "for_each".

                                                                                                                                                                                                                                              func (Resource) Absolute

                                                                                                                                                                                                                                              func (r Resource) Absolute(module ModuleInstance) AbsResource

                                                                                                                                                                                                                                                Absolute returns an AbsResource from the receiver and the given module instance address.

                                                                                                                                                                                                                                                func (Resource) Equal

                                                                                                                                                                                                                                                func (r Resource) Equal(o Resource) bool

                                                                                                                                                                                                                                                func (Resource) ImpliedProvider

                                                                                                                                                                                                                                                func (r Resource) ImpliedProvider() string

                                                                                                                                                                                                                                                  ImpliedProvider returns the implied provider type name, for e.g. the "aws" in "aws_instance"

                                                                                                                                                                                                                                                  func (Resource) InModule

                                                                                                                                                                                                                                                  func (r Resource) InModule(module Module) ConfigResource

                                                                                                                                                                                                                                                    InModule returns a ConfigResource from the receiver and the given module address.

                                                                                                                                                                                                                                                    func (Resource) Instance

                                                                                                                                                                                                                                                    func (r Resource) Instance(key InstanceKey) ResourceInstance

                                                                                                                                                                                                                                                      Instance produces the address for a specific instance of the receiver that is idenfied by the given key.

                                                                                                                                                                                                                                                      func (Resource) Phase

                                                                                                                                                                                                                                                        Phase returns a special "phase address" for the receving instance. See the documentation of ResourceInstancePhase for the limited situations where this is intended to be used.

                                                                                                                                                                                                                                                        func (Resource) String

                                                                                                                                                                                                                                                        func (r Resource) String() string

                                                                                                                                                                                                                                                        type ResourceInstance

                                                                                                                                                                                                                                                        type ResourceInstance struct {
                                                                                                                                                                                                                                                        	Resource Resource
                                                                                                                                                                                                                                                        	Key      InstanceKey
                                                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                          ResourceInstance is an address for a specific instance of a resource. When a resource is defined in configuration with "count" or "for_each" it produces zero or more instances, which can be addressed using this type.

                                                                                                                                                                                                                                                          func (ResourceInstance) Absolute

                                                                                                                                                                                                                                                            Absolute returns an AbsResourceInstance from the receiver and the given module instance address.

                                                                                                                                                                                                                                                            func (ResourceInstance) ContainingResource

                                                                                                                                                                                                                                                            func (r ResourceInstance) ContainingResource() Resource

                                                                                                                                                                                                                                                            func (ResourceInstance) Equal

                                                                                                                                                                                                                                                            func (ResourceInstance) Phase

                                                                                                                                                                                                                                                              Phase returns a special "phase address" for the receving instance. See the documentation of ResourceInstancePhase for the limited situations where this is intended to be used.

                                                                                                                                                                                                                                                              func (ResourceInstance) String

                                                                                                                                                                                                                                                              func (r ResourceInstance) String() string

                                                                                                                                                                                                                                                              type ResourceInstancePhase

                                                                                                                                                                                                                                                              type ResourceInstancePhase struct {
                                                                                                                                                                                                                                                              	ResourceInstance ResourceInstance
                                                                                                                                                                                                                                                              	Phase            ResourceInstancePhaseType
                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                ResourceInstancePhase is a special kind of reference used only internally during graph building to represent resource instances that are in a non-primary state.

                                                                                                                                                                                                                                                                Graph nodes can declare themselves referenceable via an instance phase or can declare that they reference an instance phase in order to accomodate secondary graph nodes dealing with, for example, destroy actions.

                                                                                                                                                                                                                                                                This special reference type cannot be accessed directly by end-users, and should never be shown in the UI.

                                                                                                                                                                                                                                                                func (ResourceInstancePhase) ContainingResource

                                                                                                                                                                                                                                                                func (rp ResourceInstancePhase) ContainingResource() ResourcePhase

                                                                                                                                                                                                                                                                  ContainingResource returns an address for the same phase of the resource that this instance belongs to.

                                                                                                                                                                                                                                                                  func (ResourceInstancePhase) String

                                                                                                                                                                                                                                                                  func (rp ResourceInstancePhase) String() string

                                                                                                                                                                                                                                                                  type ResourceInstancePhaseType

                                                                                                                                                                                                                                                                  type ResourceInstancePhaseType string

                                                                                                                                                                                                                                                                    ResourceInstancePhaseType is an enumeration used with ResourceInstancePhase.

                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                    	// ResourceInstancePhaseDestroy represents the "destroy" phase of a
                                                                                                                                                                                                                                                                    	// resource instance.
                                                                                                                                                                                                                                                                    	ResourceInstancePhaseDestroy ResourceInstancePhaseType = "destroy"
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// ResourceInstancePhaseDestroyCBD is similar to ResourceInstancePhaseDestroy
                                                                                                                                                                                                                                                                    	// but is used for resources that have "create_before_destroy" set, thus
                                                                                                                                                                                                                                                                    	// requiring a different dependency ordering.
                                                                                                                                                                                                                                                                    	ResourceInstancePhaseDestroyCBD ResourceInstancePhaseType = "destroy-cbd"
                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                    func (ResourceInstancePhaseType) String

                                                                                                                                                                                                                                                                    func (rpt ResourceInstancePhaseType) String() string

                                                                                                                                                                                                                                                                    type ResourceMode

                                                                                                                                                                                                                                                                    type ResourceMode rune

                                                                                                                                                                                                                                                                      ResourceMode defines which lifecycle applies to a given resource. Each resource lifecycle has a slightly different address format.

                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                      	// InvalidResourceMode is the zero value of ResourceMode and is not
                                                                                                                                                                                                                                                                      	// a valid resource mode.
                                                                                                                                                                                                                                                                      	InvalidResourceMode ResourceMode = 0
                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                      	// ManagedResourceMode indicates a managed resource, as defined by
                                                                                                                                                                                                                                                                      	// "resource" blocks in configuration.
                                                                                                                                                                                                                                                                      	ManagedResourceMode ResourceMode = 'M'
                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                      	// DataResourceMode indicates a data resource, as defined by
                                                                                                                                                                                                                                                                      	// "data" blocks in configuration.
                                                                                                                                                                                                                                                                      	DataResourceMode ResourceMode = 'D'
                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                      func (ResourceMode) String

                                                                                                                                                                                                                                                                      func (i ResourceMode) String() string

                                                                                                                                                                                                                                                                      type ResourcePhase

                                                                                                                                                                                                                                                                      type ResourcePhase struct {
                                                                                                                                                                                                                                                                      	Resource Resource
                                                                                                                                                                                                                                                                      	Phase    ResourceInstancePhaseType
                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                        ResourcePhase is a special kind of reference used only internally during graph building to represent resources that are in a non-primary state.

                                                                                                                                                                                                                                                                        Graph nodes can declare themselves referenceable via a resource phase or can declare that they reference a resource phase in order to accomodate secondary graph nodes dealing with, for example, destroy actions.

                                                                                                                                                                                                                                                                        Since resources (as opposed to instances) aren't actually phased, this address type is used only as an approximation during initial construction of the resource-oriented plan graph, under the assumption that resource instances with ResourceInstancePhase addresses will be created in dynamic subgraphs during the graph walk.

                                                                                                                                                                                                                                                                        This special reference type cannot be accessed directly by end-users, and should never be shown in the UI.

                                                                                                                                                                                                                                                                        func (ResourcePhase) String

                                                                                                                                                                                                                                                                        func (rp ResourcePhase) String() string

                                                                                                                                                                                                                                                                        type StringKey

                                                                                                                                                                                                                                                                        type StringKey string

                                                                                                                                                                                                                                                                          StringKey is the InstanceKey representation representing string indices, as used when the "for_each" argument is specified with a map or object type.

                                                                                                                                                                                                                                                                          func (StringKey) String

                                                                                                                                                                                                                                                                          func (k StringKey) String() string

                                                                                                                                                                                                                                                                          func (StringKey) Value

                                                                                                                                                                                                                                                                          func (k StringKey) Value() cty.Value

                                                                                                                                                                                                                                                                          type Target

                                                                                                                                                                                                                                                                          type Target struct {
                                                                                                                                                                                                                                                                          	Subject     Targetable
                                                                                                                                                                                                                                                                          	SourceRange tfdiags.SourceRange
                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                            Target describes a targeted address with source location information.

                                                                                                                                                                                                                                                                            func ParseTarget

                                                                                                                                                                                                                                                                            func ParseTarget(traversal hcl.Traversal) (*Target, tfdiags.Diagnostics)

                                                                                                                                                                                                                                                                              ParseTarget attempts to interpret the given traversal as a targetable address. The given traversal must be absolute, or this function will panic.

                                                                                                                                                                                                                                                                              If no error diagnostics are returned, the returned target includes the address that was extracted and the source range it was extracted from.

                                                                                                                                                                                                                                                                              If error diagnostics are returned then the Target value is invalid and must not be used.

                                                                                                                                                                                                                                                                              func ParseTargetStr

                                                                                                                                                                                                                                                                              func ParseTargetStr(str string) (*Target, tfdiags.Diagnostics)

                                                                                                                                                                                                                                                                                ParseTargetStr is a helper wrapper around ParseTarget 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 target 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 ParseTarget.

                                                                                                                                                                                                                                                                                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 the returned target may be nil or incomplete.

                                                                                                                                                                                                                                                                                type Targetable

                                                                                                                                                                                                                                                                                type Targetable interface {
                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                	// TargetContains returns true if the receiver is considered to contain
                                                                                                                                                                                                                                                                                	// the given other address. Containment, for the purpose of targeting,
                                                                                                                                                                                                                                                                                	// means that if a container address is targeted then all of the
                                                                                                                                                                                                                                                                                	// addresses within it are also implicitly targeted.
                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                	// A targetable address always contains at least itself.
                                                                                                                                                                                                                                                                                	TargetContains(other Targetable) bool
                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                	// String produces a string representation of the address that could be
                                                                                                                                                                                                                                                                                	// parsed as a HCL traversal and passed to ParseTarget to produce an
                                                                                                                                                                                                                                                                                	// identical result.
                                                                                                                                                                                                                                                                                	String() string
                                                                                                                                                                                                                                                                                	// contains filtered or unexported methods
                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                  Targetable is an interface implemented by all address types that can be used as "targets" for selecting sub-graphs of a graph.

                                                                                                                                                                                                                                                                                  type TerraformAttr

                                                                                                                                                                                                                                                                                  type TerraformAttr struct {
                                                                                                                                                                                                                                                                                  	Name string
                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                    TerraformAttr is the address of an attribute of the "terraform" object in the interpolation scope, like "terraform.workspace".

                                                                                                                                                                                                                                                                                    func (TerraformAttr) String

                                                                                                                                                                                                                                                                                    func (ta TerraformAttr) String() string