terraform

type AddOutputOrphanTransformer ¶ added in v0.5.0

type AddOutputOrphanTransformer struct {
	State *State
}

AddOutputOrphanTransformer is a transformer that adds output orphans to the graph. Output orphans are outputs that are no longer in the configuration and therefore need to be removed from the state.

NOTE: This is the _old_ way to add output orphans that is used with legacy graph builders. The new way is OrphanOutputTransformer.

func (t *AddOutputOrphanTransformer) Transform(g *Graph) error

type ApplyGraphBuilder ¶ added in v0.7.8

type ApplyGraphBuilder struct {
	// Module is the root module for the graph to build.
	Module *module.Tree

	// Diff is the diff to apply.
	Diff *Diff

	// State is the current state
	State *State

	// Providers is the list of providers supported.
	Providers []string

	// Provisioners is the list of provisioners supported.
	Provisioners []string

	// Targets are resources to target. This is only required to make sure
	// unnecessary outputs aren't included in the apply graph. The plan
	// builder successfully handles targeting resources. In the future,
	// outputs should go into the diff so that this is unnecessary.
	Targets []string

	// DisableReduce, if true, will not reduce the graph. Great for testing.
	DisableReduce bool

	// Destroy, if true, represents a pure destroy operation
	Destroy bool

	// Validate will do structural validation of the graph.
	Validate bool
}

ApplyGraphBuilder implements GraphBuilder and is responsible for building a graph for applying a Terraform diff.

Because the graph is built from the diff (vs. the config or state), this helps ensure that the apply-time graph doesn't modify any resources that aren't explicitly in the diff. There are other scenarios where the diff can be deviated, so this is just one layer of protection.

func (b *ApplyGraphBuilder) Build(path []string) (*Graph, error)

func (b *ApplyGraphBuilder) Steps() []GraphTransformer

type AttachProviderConfigTransformer ¶ added in v0.7.8

type AttachProviderConfigTransformer struct {
	Module *module.Tree // Module is the root module for the config
}

AttachProviderConfigTransformer goes through the graph and attaches provider configuration structures to nodes that implement the interfaces above.

The attached configuration structures are directly from the configuration. If they're going to be modified, a copy should be made.

func (t *AttachProviderConfigTransformer) Transform(g *Graph) error

type AttachResourceConfigTransformer ¶ added in v0.7.8

type AttachResourceConfigTransformer struct {
	Module *module.Tree // Module is the root module for the config
}

AttachResourceConfigTransformer goes through the graph and attaches resource configuration structures to nodes that implement the interfaces above.

The attached configuration structures are directly from the configuration. If they're going to be modified, a copy should be made.

func (t *AttachResourceConfigTransformer) Transform(g *Graph) error

type AttachStateTransformer ¶ added in v0.7.8

type AttachStateTransformer struct {
	State *State // State is the root state
}

AttachStateTransformer goes through the graph and attaches state to nodes that implement the interfaces above.

func (t *AttachStateTransformer) Transform(g *Graph) error

type BasicGraphBuilder ¶ added in v0.4.0

type BasicGraphBuilder struct {
	Steps    []GraphTransformer
	Validate bool
	// Optional name to add to the graph debug log
	Name string
}

BasicGraphBuilder is a GraphBuilder that builds a graph out of a series of transforms and (optionally) validates the graph is a valid structure.

func (b *BasicGraphBuilder) Build(path []string) (*Graph, error)

type BuiltinEvalContext ¶ added in v0.4.0

type BuiltinEvalContext struct {
	// PathValue is the Path that this context is operating within.
	PathValue []string

	// Interpolater setting below affect the interpolation of variables.
	//
	// The InterpolaterVars are the exact value for ${var.foo} values.
	// The map is shared between all contexts and is a mapping of
	// PATH to KEY to VALUE. Because it is shared by all contexts as well
	// as the Interpolater itself, it is protected by InterpolaterVarLock
	// which must be locked during any access to the map.
	Interpolater        *Interpolater
	InterpolaterVars    map[string]map[string]interface{}
	InterpolaterVarLock *sync.Mutex

	Components          contextComponentFactory
	Hooks               []Hook
	InputValue          UIInput
	ProviderCache       map[string]ResourceProvider
	ProviderConfigCache map[string]*ResourceConfig
	ProviderInputConfig map[string]map[string]interface{}
	ProviderLock        *sync.Mutex
	ProvisionerCache    map[string]ResourceProvisioner
	ProvisionerLock     *sync.Mutex
	DiffValue           *Diff
	DiffLock            *sync.RWMutex
	StateValue          *State
	StateLock           *sync.RWMutex
	// contains filtered or unexported fields
}

BuiltinEvalContext is an EvalContext implementation that is used by Terraform by default.

func (ctx *BuiltinEvalContext) CloseProvider(n string) error

func (ctx *BuiltinEvalContext) CloseProvisioner(n string) error

func (ctx *BuiltinEvalContext) ConfigureProvider(
	n string, cfg *ResourceConfig) error

func (ctx *BuiltinEvalContext) Diff() (*Diff, *sync.RWMutex)

func (ctx *BuiltinEvalContext) Hook(fn func(Hook) (HookAction, error)) error

func (ctx *BuiltinEvalContext) InitProvider(n string) (ResourceProvider, error)

func (ctx *BuiltinEvalContext) InitProvisioner(
	n string) (ResourceProvisioner, error)

func (ctx *BuiltinEvalContext) Input() UIInput

func (ctx *BuiltinEvalContext) Interpolate(
	cfg *config.RawConfig, r *Resource) (*ResourceConfig, error)

func (ctx *BuiltinEvalContext) ParentProviderConfig(n string) *ResourceConfig

func (ctx *BuiltinEvalContext) Path() []string

func (ctx *BuiltinEvalContext) Provider(n string) ResourceProvider

func (ctx *BuiltinEvalContext) ProviderInput(n string) map[string]interface{}

func (ctx *BuiltinEvalContext) Provisioner(n string) ResourceProvisioner

func (ctx *BuiltinEvalContext) SetProviderConfig(
	n string, cfg *ResourceConfig) error

func (ctx *BuiltinEvalContext) SetProviderInput(n string, c map[string]interface{})

func (ctx *BuiltinEvalContext) SetVariables(n string, vs map[string]interface{})

func (ctx *BuiltinEvalContext) State() (*State, *sync.RWMutex)

type BuiltinGraphBuilder ¶ added in v0.4.0

type BuiltinGraphBuilder struct {
	// Root is the root module of the graph to build.
	Root *module.Tree

	// Diff is the diff. The proper module diffs will be looked up.
	Diff *Diff

	// State is the global state. The proper module states will be looked
	// up by graph path.
	State *State

	// Providers is the list of providers supported.
	Providers []string

	// Provisioners is the list of provisioners supported.
	Provisioners []string

	// Targets is the user-specified list of resources to target.
	Targets []string

	// Destroy is set to true when we're in a `terraform destroy` or a
	// `terraform plan -destroy`
	Destroy bool

	// Determines whether the GraphBuilder should perform graph validation before
	// returning the Graph. Generally you want this to be done, except when you'd
	// like to inspect a problematic graph.
	Validate bool

	// Verbose is set to true when the graph should be built "worst case",
	// skipping any prune steps. This is used for early cycle detection during
	// Validate and for manual inspection via `terraform graph -verbose`.
	Verbose bool
}

BuiltinGraphBuilder is responsible for building the complete graph that Terraform uses for execution. It is an opinionated builder that defines the step order required to build a complete graph as is used and expected by Terraform.

If you require a custom graph, you'll have to build it up manually on your own by building a new GraphBuilder implementation.

func (b *BuiltinGraphBuilder) Build(path []string) (*Graph, error)

func (b *BuiltinGraphBuilder) Steps(path []string) []GraphTransformer

type CBDEdgeTransformer ¶ added in v0.7.8

type CBDEdgeTransformer struct {
	// Module and State are only needed to look up dependencies in
	// any way possible. Either can be nil if not availabile.
	Module *module.Tree
	State  *State
}

CBDEdgeTransformer modifies the edges of CBD nodes that went through the DestroyEdgeTransformer to have the right dependencies. There are two real tasks here:

1. With CBD, the destroy edge is inverted: the destroy depends on the creation.

2. A_d must depend on resources that depend on A. This is to enable the destroy to only happen once nodes that depend on A successfully update to A. Example: adding a web server updates the load balancer before deleting the old web server.

func (t *CBDEdgeTransformer) Transform(g *Graph) error

type CallbackUIOutput ¶ added in v0.3.0

type CallbackUIOutput struct {
	OutputFn func(string)
}

func (o *CallbackUIOutput) Output(v string)

type CloseProviderTransformer ¶ added in v0.6.0

type CloseProviderTransformer struct{}

CloseProviderTransformer is a GraphTransformer that adds nodes to the graph that will close open provider connections that aren't needed anymore. A provider connection is not needed anymore once all depended resources in the graph are evaluated.

func (t *CloseProviderTransformer) Transform(g *Graph) error

type CloseProvisionerTransformer ¶ added in v0.6.0

type CloseProvisionerTransformer struct{}

CloseProvisionerTransformer is a GraphTransformer that adds nodes to the graph that will close open provisioner connections that aren't needed anymore. A provisioner connection is not needed anymore once all depended resources in the graph are evaluated.

func (t *CloseProvisionerTransformer) Transform(g *Graph) error

type ConcreteProviderNodeFunc ¶ added in v0.8.0

type ConcreteProviderNodeFunc func(*NodeAbstractProvider) dag.Vertex

ConcreteProviderNodeFunc is a callback type used to convert an abstract provider to a concrete one of some type.

type ConcreteResourceNodeFunc ¶ added in v0.7.8

type ConcreteResourceNodeFunc func(*NodeAbstractResource) dag.Vertex

ConcreteResourceNodeFunc is a callback type used to convert an abstract resource to a concrete one of some type.

type ConfigTransformer ¶ added in v0.4.0

type ConfigTransformer struct {
	Concrete ConcreteResourceNodeFunc

	Module *module.Tree
}

ConfigTransformer is a GraphTransformer that adds all the resources from the configuration to the graph.

The module used to configure this transformer must be the root module.

Only resources are added to the graph. Variables, outputs, and providers must be added via other transforms.

Unlike ConfigTransformerOld, this transformer creates a graph with all resources including module resources, rather than creating module nodes that are then "flattened".

func (t *ConfigTransformer) Transform(g *Graph) error

type ConfigTransformerOld ¶ added in v0.7.10

type ConfigTransformerOld struct {
	Module *module.Tree
}

ConfigTransformerOld is a GraphTransformer that adds the configuration to the graph. The module used to configure this transformer must be the root module. We'll look up the child module by the Path in the Graph.

func (t *ConfigTransformerOld) Transform(g *Graph) error

type Context ¶

type Context struct {
	// contains filtered or unexported fields
}

Context represents all the context that Terraform needs in order to perform operations on infrastructure. This structure is built using NewContext. See the documentation for that.

Extra functions on Context can be found in context_*.go files.

func NewContext(opts *ContextOpts) (*Context, error)

func (c *Context) Apply() (*State, error)

func (c *Context) Graph(typ GraphType, opts *ContextGraphOpts) (*Graph, error)

func (c *Context) Import(opts *ImportOpts) (*State, error)

func (c *Context) Input(mode InputMode) error

func (c *Context) Interpolater() *Interpolater

func (c *Context) Module() *module.Tree

func (c *Context) Plan() (*Plan, error)

func (c *Context) Refresh() (*State, error)

func (c *Context) SetVariable(k string, v interface{})

func (c *Context) ShadowError() error

func (c *Context) Stop()

func (c *Context) Validate() ([]string, []error)

func (c *Context) Variables() map[string]interface{}

type ContextGraphOpts ¶ added in v0.5.0

type ContextGraphOpts struct {
	// If true, validates the graph structure (checks for cycles).
	Validate bool

	// Legacy graphs only: won't prune the graph
	Verbose bool
}

type ContextGraphWalker ¶ added in v0.4.0

type ContextGraphWalker struct {
	NullGraphWalker

	// Configurable values
	Context   *Context
	Operation walkOperation

	// Outputs, do not set these. Do not read these while the graph
	// is being walked.
	ValidationWarnings []string
	ValidationErrors   []error
	// contains filtered or unexported fields
}

ContextGraphWalker is the GraphWalker implementation used with the Context struct to walk and evaluate the graph.

func (w *ContextGraphWalker) EnterEvalTree(v dag.Vertex, n EvalNode) EvalNode

func (w *ContextGraphWalker) EnterPath(path []string) EvalContext

func (w *ContextGraphWalker) ExitEvalTree(
	v dag.Vertex, output interface{}, err error) error

type ContextOpts ¶

type ContextOpts struct {
	Destroy            bool
	Diff               *Diff
	Hooks              []Hook
	Module             *module.Tree
	Parallelism        int
	State              *State
	StateFutureAllowed bool
	Providers          map[string]ResourceProviderFactory
	Provisioners       map[string]ResourceProvisionerFactory
	Shadow             bool
	Targets            []string
	Variables          map[string]interface{}

	UIInput UIInput
}

ContextOpts are the user-configurable options to create a context with NewContext.

type CountBoundaryTransformer ¶ added in v0.7.8

type CountBoundaryTransformer struct{}

CountBoundaryTransformer adds a node that depends on everything else so that it runs last in order to clean up the state for nodes that are on the "count boundary": "foo.0" when only one exists becomes "foo"

func (t *CountBoundaryTransformer) Transform(g *Graph) error

type CreateBeforeDestroyTransformer ¶ added in v0.4.0

type CreateBeforeDestroyTransformer struct{}

CreateBeforeDestroyTransformer is a GraphTransformer that modifies the destroys of some nodes so that the creation happens before the destroy.

func (t *CreateBeforeDestroyTransformer) Transform(g *Graph) error

type DataSource ¶ added in v0.7.0

type DataSource struct {
	Name string
}

DataSource is a data source that a resource provider implements.

type DebugHook ¶ added in v0.7.9

type DebugHook struct{}

DebugHook implements all methods of the terraform.Hook interface, and writes the arguments to a file in the archive. When a suitable format for the argument isn't available, the argument is encoded using json.Marshal. If the debug handler is nil, all DebugHook methods are noop, so no time is spent in marshaling the data structures.

func (*DebugHook) PostApply(ii *InstanceInfo, is *InstanceState, err error) (HookAction, error)

func (*DebugHook) PostDiff(ii *InstanceInfo, id *InstanceDiff) (HookAction, error)

func (*DebugHook) PostImportState(ii *InstanceInfo, iss []*InstanceState) (HookAction, error)

func (*DebugHook) PostProvision(ii *InstanceInfo, s string) (HookAction, error)

func (*DebugHook) PostProvisionResource(ii *InstanceInfo, is *InstanceState) (HookAction, error)

func (*DebugHook) PostRefresh(ii *InstanceInfo, is *InstanceState) (HookAction, error)

func (*DebugHook) PostStateUpdate(*State) (HookAction, error)

func (*DebugHook) PreApply(ii *InstanceInfo, is *InstanceState, id *InstanceDiff) (HookAction, error)

func (*DebugHook) PreDiff(ii *InstanceInfo, is *InstanceState) (HookAction, error)

func (*DebugHook) PreImportState(ii *InstanceInfo, s string) (HookAction, error)

func (*DebugHook) PreProvision(ii *InstanceInfo, s string) (HookAction, error)

func (*DebugHook) PreProvisionResource(ii *InstanceInfo, is *InstanceState) (HookAction, error)

func (*DebugHook) PreRefresh(ii *InstanceInfo, is *InstanceState) (HookAction, error)

func (*DebugHook) ProvisionOutput(ii *InstanceInfo, s1 string, s2 string)

type DeposedTransformer ¶ added in v0.4.0

type DeposedTransformer struct {
	// State is the global state. We'll automatically find the correct
	// ModuleState based on the Graph.Path that is being transformed.
	State *State

	// View, if non-empty, is the ModuleState.View used around the state
	// to find deposed resources.
	View string
}

DeposedTransformer is a GraphTransformer that adds deposed resources to the graph.

func (t *DeposedTransformer) Transform(g *Graph) error

type DestroyEdge ¶ added in v0.7.8

type DestroyEdge struct {
	S, T dag.Vertex
}

DestroyEdge is an edge that represents a standard "destroy" relationship: Target depends on Source because Source is destroying.

func (e *DestroyEdge) Hashcode() interface{}

func (e *DestroyEdge) Source() dag.Vertex

func (e *DestroyEdge) Target() dag.Vertex

type DestroyEdgeTransformer ¶ added in v0.7.8

type DestroyEdgeTransformer struct {
	// These are needed to properly build the graph of dependencies
	// to determine what a destroy node depends on. Any of these can be nil.
	Module *module.Tree
	State  *State
}

DestroyEdgeTransformer is a GraphTransformer that creates the proper references for destroy resources. Destroy resources are more complex in that they must be depend on the destruction of resources that in turn depend on the CREATION of the node being destroy.

That is complicated. Visually:

B_d -> A_d -> A -> B

Notice that A destroy depends on B destroy, while B create depends on A create. They're inverted. This must be done for example because often dependent resources will block parent resources from deleting. Concrete example: VPC with subnets, the VPC can't be deleted while there are still subnets.

func (t *DestroyEdgeTransformer) Transform(g *Graph) error

type DestroyPlanGraphBuilder ¶ added in v0.7.8

type DestroyPlanGraphBuilder struct {
	// Module is the root module for the graph to build.
	Module *module.Tree

	// State is the current state
	State *State

	// Targets are resources to target
	Targets []string

	// Validate will do structural validation of the graph.
	Validate bool
}

DestroyPlanGraphBuilder implements GraphBuilder and is responsible for planning a pure-destroy.

Planning a pure destroy operation is simple because we can ignore most ordering configuration and simply reverse the state.

func (b *DestroyPlanGraphBuilder) Build(path []string) (*Graph, error)

func (b *DestroyPlanGraphBuilder) Steps() []GraphTransformer

type DestroyTransformer ¶ added in v0.4.0

type DestroyTransformer struct {
	FullDestroy bool
}

DestroyTransformer is a GraphTransformer that creates the destruction nodes for things that _might_ be destroyed.

func (t *DestroyTransformer) Transform(g *Graph) error

type Diff ¶

type Diff struct {
	// Modules contains all the modules that have a diff
	Modules []*ModuleDiff
}

Diff trackes the changes that are necessary to apply a configuration to an existing infrastructure.

func (d *Diff) AddModule(path []string) *ModuleDiff

func (d *Diff) DeepCopy() *Diff

func (d *Diff) Empty() bool

func (d *Diff) Equal(d2 *Diff) bool

func (d *Diff) ModuleByPath(path []string) *ModuleDiff

func (d *Diff) Prune()

func (d *Diff) RootModule() *ModuleDiff

func (d *Diff) String() string

type DiffAttrType ¶

type DiffAttrType byte

DiffAttrType is an enum type that says whether a resource attribute diff is an input attribute (comes from the configuration) or an output attribute (comes as a result of applying the configuration). An example input would be "ami" for AWS and an example output would be "private_ip".

const (
	DiffAttrUnknown DiffAttrType = iota
	DiffAttrInput
	DiffAttrOutput
)

type DiffChangeType ¶ added in v0.3.0

type DiffChangeType byte

DiffChangeType is an enum with the kind of changes a diff has planned.

const (
	DiffInvalid DiffChangeType = iota
	DiffNone
	DiffCreate
	DiffUpdate
	DiffDestroy
	DiffDestroyCreate
)

type DiffTransformer ¶ added in v0.7.8

type DiffTransformer struct {
	Concrete ConcreteResourceNodeFunc

	Diff   *Diff
	Module *module.Tree
	State  *State
}

DiffTransformer is a GraphTransformer that adds the elements of the diff to the graph.

This transform is used for example by the ApplyGraphBuilder to ensure that only resources that are being modified are represented in the graph.

Module and State is still required for the DiffTransformer for annotations since the Diff doesn't contain all the information required to build the complete graph (such as create-before-destroy information). The graph is built based on the diff first, though, ensuring that only resources that are being modified are present in the graph.

func (t *DiffTransformer) Transform(g *Graph) error

type DisableProviderTransformer ¶ added in v0.4.1

type DisableProviderTransformer struct{}

DisableProviderTransformer "disables" any providers that are not actually used by anything. This avoids the provider being initialized and configured. This both saves resources but also avoids errors since configuration may imply initialization which may require auth.

func (t *DisableProviderTransformer) Transform(g *Graph) error

type DisableProviderTransformerOld ¶ added in v0.7.8

type DisableProviderTransformerOld struct{}

DisableProviderTransformer "disables" any providers that are only depended on by modules.

NOTE: "old" = used by old graph builders, will be removed one day

func (t *DisableProviderTransformerOld) Transform(g *Graph) error

type EphemeralState ¶ added in v0.3.0

type EphemeralState struct {
	// ConnInfo is used for the providers to export information which is
	// used to connect to the resource for provisioning. For example,
	// this could contain SSH or WinRM credentials.
	ConnInfo map[string]string `json:"-"`

	// Type is used to specify the resource type for this instance. This is only
	// required for import operations (as documented). If the documentation
	// doesn't state that you need to set this, then don't worry about
	// setting it.
	Type string `json:"-"`
}

EphemeralState is used for transient state that is only kept in-memory

func (e *EphemeralState) DeepCopy() *EphemeralState

type EvalApply ¶ added in v0.4.0

type EvalApply struct {
	Info      *InstanceInfo
	State     **InstanceState
	Diff      **InstanceDiff
	Provider  *ResourceProvider
	Output    **InstanceState
	CreateNew *bool
	Error     *error
}

EvalApply is an EvalNode implementation that writes the diff to the full diff.

func (n *EvalApply) Eval(ctx EvalContext) (interface{}, error)

type EvalApplyPost ¶ added in v0.4.0

type EvalApplyPost struct {
	Info  *InstanceInfo
	State **InstanceState
	Error *error
}

EvalApplyPost is an EvalNode implementation that does the post-Apply work

func (n *EvalApplyPost) Eval(ctx EvalContext) (interface{}, error)

type EvalApplyProvisioners ¶ added in v0.4.0

type EvalApplyProvisioners struct {
	Info           *InstanceInfo
	State          **InstanceState
	Resource       *config.Resource
	InterpResource *Resource
	CreateNew      *bool
	Error          *error
}

EvalApplyProvisioners is an EvalNode implementation that executes the provisioners for a resource.

TODO(mitchellh): This should probably be split up into a more fine-grained ApplyProvisioner (single) that is looped over.

func (n *EvalApplyProvisioners) Eval(ctx EvalContext) (interface{}, error)

type EvalBuildProviderConfig ¶ added in v0.4.0

type EvalBuildProviderConfig struct {
	Provider string
	Config   **ResourceConfig
	Output   **ResourceConfig
}

EvalBuildProviderConfig outputs a *ResourceConfig that is properly merged with parents and inputs on top of what is configured in the file.

func (n *EvalBuildProviderConfig) Eval(ctx EvalContext) (interface{}, error)

type EvalCheckPreventDestroy ¶ added in v0.5.0

type EvalCheckPreventDestroy struct {
	Resource   *config.Resource
	ResourceId string
	Diff       **InstanceDiff
}

EvalPreventDestroy is an EvalNode implementation that returns an error if a resource has PreventDestroy configured and the diff would destroy the resource.

func (n *EvalCheckPreventDestroy) Eval(ctx EvalContext) (interface{}, error)

type EvalClearPrimaryState ¶ added in v0.4.0

type EvalClearPrimaryState struct {
	Name string
}

EvalClearPrimaryState is an EvalNode implementation that clears the primary instance from a resource state.

func (n *EvalClearPrimaryState) Eval(ctx EvalContext) (interface{}, error)

type EvalCloseProvider ¶ added in v0.6.0

type EvalCloseProvider struct {
	Name string
}

EvalCloseProvider is an EvalNode implementation that closes provider connections that aren't needed anymore.

func (n *EvalCloseProvider) Eval(ctx EvalContext) (interface{}, error)

type EvalCloseProvisioner ¶ added in v0.6.0

type EvalCloseProvisioner struct {
	Name string
}

EvalCloseProvisioner is an EvalNode implementation that closes provisioner connections that aren't needed anymore.

func (n *EvalCloseProvisioner) Eval(ctx EvalContext) (interface{}, error)

type EvalCoerceMapVariable ¶ added in v0.7.0

type EvalCoerceMapVariable struct {
	Variables  map[string]interface{}
	ModulePath []string
	ModuleTree *module.Tree
}

EvalCoerceMapVariable is an EvalNode implementation that recognizes a specific ambiguous HCL parsing situation and resolves it. In HCL parsing, a bare map literal is indistinguishable from a list of maps w/ one element.

We take all the same inputs as EvalTypeCheckVariable above, since we need both the target type and the proposed value in order to properly coerce.

func (n *EvalCoerceMapVariable) Eval(ctx EvalContext) (interface{}, error)

type EvalCompareDiff ¶ added in v0.4.0

type EvalCompareDiff struct {
	Info     *InstanceInfo
	One, Two **InstanceDiff
}

EvalCompareDiff is an EvalNode implementation that compares two diffs and errors if the diffs are not equal.

func (n *EvalCompareDiff) Eval(ctx EvalContext) (interface{}, error)

type EvalConfigProvider ¶ added in v0.4.0

type EvalConfigProvider struct {
	Provider string
	Config   **ResourceConfig
}

EvalConfigProvider is an EvalNode implementation that configures a provider that is already initialized and retrieved.

func (n *EvalConfigProvider) Eval(ctx EvalContext) (interface{}, error)

type EvalContext ¶ added in v0.4.0

type EvalContext interface {
	// Path is the current module path.
	Path() []string

	// Hook is used to call hook methods. The callback is called for each
	// hook and should return the hook action to take and the error.
	Hook(func(Hook) (HookAction, error)) error

	// Input is the UIInput object for interacting with the UI.
	Input() UIInput

	// InitProvider initializes the provider with the given name and
	// returns the implementation of the resource provider or an error.
	//
	// It is an error to initialize the same provider more than once.
	InitProvider(string) (ResourceProvider, error)

	// Provider gets the provider instance with the given name (already
	// initialized) or returns nil if the provider isn't initialized.
	Provider(string) ResourceProvider

	// CloseProvider closes provider connections that aren't needed anymore.
	CloseProvider(string) error

	// ConfigureProvider configures the provider with the given
	// configuration. This is a separate context call because this call
	// is used to store the provider configuration for inheritance lookups
	// with ParentProviderConfig().
	ConfigureProvider(string, *ResourceConfig) error
	SetProviderConfig(string, *ResourceConfig) error
	ParentProviderConfig(string) *ResourceConfig

	// ProviderInput and SetProviderInput are used to configure providers
	// from user input.
	ProviderInput(string) map[string]interface{}
	SetProviderInput(string, map[string]interface{})

	// InitProvisioner initializes the provisioner with the given name and
	// returns the implementation of the resource provisioner or an error.
	//
	// It is an error to initialize the same provisioner more than once.
	InitProvisioner(string) (ResourceProvisioner, error)

	// Provisioner gets the provisioner instance with the given name (already
	// initialized) or returns nil if the provisioner isn't initialized.
	Provisioner(string) ResourceProvisioner

	// CloseProvisioner closes provisioner connections that aren't needed
	// anymore.
	CloseProvisioner(string) error

	// Interpolate takes the given raw configuration and completes
	// the interpolations, returning the processed ResourceConfig.
	//
	// The resource argument is optional. If given, it is the resource
	// that is currently being acted upon.
	Interpolate(*config.RawConfig, *Resource) (*ResourceConfig, error)

	// SetVariables sets the variables for the module within
	// this context with the name n. This function call is additive:
	// the second parameter is merged with any previous call.
	SetVariables(string, map[string]interface{})

	// Diff returns the global diff as well as the lock that should
	// be used to modify that diff.
	Diff() (*Diff, *sync.RWMutex)

	// State returns the global state as well as the lock that should
	// be used to modify that state.
	State() (*State, *sync.RWMutex)
}

EvalContext is the interface that is given to eval nodes to execute.

type EvalCountCheckComputed ¶ added in v0.8.0

type EvalCountCheckComputed struct {
	Resource *config.Resource
}

EvalCountCheckComputed is an EvalNode that checks if a resource count is computed and errors if so. This can possibly happen across a module boundary and we don't yet support this.

func (n *EvalCountCheckComputed) Eval(ctx EvalContext) (interface{}, error)

type EvalCountFixZeroOneBoundary ¶ added in v0.4.0

type EvalCountFixZeroOneBoundary struct {
	Resource *config.Resource
}

EvalCountFixZeroOneBoundary is an EvalNode that fixes up the state when there is a resource count with zero/one boundary, i.e. fixing a resource named "aws_instance.foo" to "aws_instance.foo.0" and vice-versa.

func (n *EvalCountFixZeroOneBoundary) Eval(ctx EvalContext) (interface{}, error)

type EvalCountFixZeroOneBoundaryGlobal ¶ added in v0.7.8

type EvalCountFixZeroOneBoundaryGlobal struct{}

EvalCountFixZeroOneBoundaryGlobal is an EvalNode that fixes up the state when there is a resource count with zero/one boundary, i.e. fixing a resource named "aws_instance.foo" to "aws_instance.foo.0" and vice-versa.

This works on the global state.

func (n *EvalCountFixZeroOneBoundaryGlobal) Eval(ctx EvalContext) (interface{}, error)

type EvalDeleteOutput ¶ added in v0.5.0

type EvalDeleteOutput struct {
	Name string
}

EvalDeleteOutput is an EvalNode implementation that deletes an output from the state.

func (n *EvalDeleteOutput) Eval(ctx EvalContext) (interface{}, error)

type EvalDeposeState ¶ added in v0.4.0

type EvalDeposeState struct {
	Name string
}

EvalDeposeState is an EvalNode implementation that takes the primary out of a state and makes it Deposed. This is done at the beginning of create-before-destroy calls so that the create can create while preserving the old state of the to-be-destroyed resource.

func (n *EvalDeposeState) Eval(ctx EvalContext) (interface{}, error)

type EvalDiff ¶ added in v0.4.0

type EvalDiff struct {
	Name        string
	Info        *InstanceInfo
	Config      **ResourceConfig
	Provider    *ResourceProvider
	Diff        **InstanceDiff
	State       **InstanceState
	OutputDiff  **InstanceDiff
	OutputState **InstanceState

	// Resource is needed to fetch the ignore_changes list so we can
	// filter user-requested ignored attributes from the diff.
	Resource *config.Resource
}

EvalDiff is an EvalNode implementation that does a refresh for a resource.

func (n *EvalDiff) Eval(ctx EvalContext) (interface{}, error)

type EvalDiffDestroy ¶ added in v0.4.0

type EvalDiffDestroy struct {
	Info   *InstanceInfo
	State  **InstanceState
	Output **InstanceDiff
}

EvalDiffDestroy is an EvalNode implementation that returns a plain destroy diff.

func (n *EvalDiffDestroy) Eval(ctx EvalContext) (interface{}, error)

type EvalDiffDestroyModule ¶ added in v0.4.0

type EvalDiffDestroyModule struct {
	Path []string
}

EvalDiffDestroyModule is an EvalNode implementation that writes the diff to the full diff.

func (n *EvalDiffDestroyModule) Eval(ctx EvalContext) (interface{}, error)

type EvalEarlyExitError ¶ added in v0.4.0

type EvalEarlyExitError struct{}

EvalEarlyExitError is a special error return value that can be returned by eval nodes that does an early exit.

func (EvalEarlyExitError) Error() string

type EvalFilterDiff ¶ added in v0.4.0

type EvalFilterDiff struct {
	// Input and output
	Diff   **InstanceDiff
	Output **InstanceDiff

	// Destroy, if true, will only include a destroy diff if it is set.
	Destroy bool
}

EvalFilterDiff is an EvalNode implementation that filters the diff according to some filter.

func (n *EvalFilterDiff) Eval(ctx EvalContext) (interface{}, error)

type EvalGetProvider ¶ added in v0.4.0

type EvalGetProvider struct {
	Name   string
	Output *ResourceProvider
}

EvalGetProvider is an EvalNode implementation that retrieves an already initialized provider instance for the given name.

func (n *EvalGetProvider) Eval(ctx EvalContext) (interface{}, error)

type EvalGetProvisioner ¶ added in v0.4.0

type EvalGetProvisioner struct {
	Name   string
	Output *ResourceProvisioner
}

EvalGetProvisioner is an EvalNode implementation that retrieves an already initialized provisioner instance for the given name.

func (n *EvalGetProvisioner) Eval(ctx EvalContext) (interface{}, error)

type EvalIf ¶ added in v0.4.0

type EvalIf struct {
	If   func(EvalContext) (bool, error)
	Then EvalNode
	Else EvalNode
}

EvalIf is an EvalNode that is a conditional.

func (n *EvalIf) Eval(ctx EvalContext) (interface{}, error)

type EvalImportState ¶ added in v0.7.0

type EvalImportState struct {
	Provider *ResourceProvider
	Info     *InstanceInfo
	Id       string
	Output   *[]*InstanceState
}

EvalImportState is an EvalNode implementation that performs an ImportState operation on a provider. This will return the imported states but won't modify any actual state.

func (n *EvalImportState) Eval(ctx EvalContext) (interface{}, error)

type EvalImportStateVerify ¶ added in v0.7.0

type EvalImportStateVerify struct {
	Info  *InstanceInfo
	Id    string
	State **InstanceState
}

EvalImportStateVerify verifies the state after ImportState and after the refresh to make sure it is non-nil and valid.

func (n *EvalImportStateVerify) Eval(ctx EvalContext) (interface{}, error)

type EvalInitProvider ¶ added in v0.4.0

type EvalInitProvider struct {
	Name string
}

EvalInitProvider is an EvalNode implementation that initializes a provider and returns nothing. The provider can be retrieved again with the EvalGetProvider node.

func (n *EvalInitProvider) Eval(ctx EvalContext) (interface{}, error)

type EvalInitProvisioner ¶ added in v0.4.0

type EvalInitProvisioner struct {
	Name string
}

EvalInitProvisioner is an EvalNode implementation that initializes a provisioner and returns nothing. The provisioner can be retrieved again with the EvalGetProvisioner node.

func (n *EvalInitProvisioner) Eval(ctx EvalContext) (interface{}, error)

type EvalInputProvider ¶ added in v0.4.0

type EvalInputProvider struct {
	Name     string
	Provider *ResourceProvider
	Config   **ResourceConfig
}

EvalInputProvider is an EvalNode implementation that asks for input for the given provider configurations.

func (n *EvalInputProvider) Eval(ctx EvalContext) (interface{}, error)

type EvalInstanceInfo ¶ added in v0.4.0

type EvalInstanceInfo struct {
	Info *InstanceInfo
}

EvalInstanceInfo is an EvalNode implementation that fills in the InstanceInfo as much as it can.

func (n *EvalInstanceInfo) Eval(ctx EvalContext) (interface{}, error)

type EvalInterpolate ¶ added in v0.4.0

type EvalInterpolate struct {
	Config   *config.RawConfig
	Resource *Resource
	Output   **ResourceConfig
}

EvalInterpolate is an EvalNode implementation that takes a raw configuration and interpolates it.

func (n *EvalInterpolate) Eval(ctx EvalContext) (interface{}, error)

type EvalNode ¶ added in v0.4.0

type EvalNode interface {
	// Eval evaluates this node with the given context. The second parameter
	// are the argument values. These will match in order and 1-1 with the
	// results of the Args() return value.
	Eval(EvalContext) (interface{}, error)
}

EvalNode is the interface that must be implemented by graph nodes to evaluate/execute.

func CloseProviderEvalTree(n string) EvalNode

func EvalFilter(node EvalNode, fn EvalNodeFilterFunc) EvalNode

func ProviderEvalTree(n string, config *config.RawConfig) EvalNode

type EvalNodeFilterFunc ¶ added in v0.4.0

type EvalNodeFilterFunc func(EvalNode) EvalNode

EvalNodeFilterFunc is the callback used to replace a node with another to node. To not do the replacement, just return the input node.

func EvalNodeFilterOp(op walkOperation) EvalNodeFilterFunc

type EvalNodeFilterable ¶ added in v0.4.0

type EvalNodeFilterable interface {
	EvalNode
	Filter(EvalNodeFilterFunc)
}

EvalNodeFilterable is an interface that can be implemented by EvalNodes to allow filtering of sub-elements. Note that this isn't a common thing to implement and you probably don't need it.

type EvalNodeOpFilterable ¶ added in v0.4.0

type EvalNodeOpFilterable interface {
	IncludeInOp(walkOperation) bool
}

EvalNodeOpFilterable is an interface that EvalNodes can implement to be filterable by the operation that is being run on Terraform.

type EvalNoop ¶ added in v0.4.0

type EvalNoop struct{}

EvalNoop is an EvalNode that does nothing.

func (EvalNoop) Eval(EvalContext) (interface{}, error)

type EvalOpFilter ¶ added in v0.4.0

type EvalOpFilter struct {
	// Ops is the list of operations to include this node in.
	Ops []walkOperation

	// Node is the node to execute
	Node EvalNode
}

EvalOpFilter is an EvalNode implementation that is a proxy to another node but filters based on the operation.

func (n *EvalOpFilter) Eval(ctx EvalContext) (interface{}, error)

func (n *EvalOpFilter) IncludeInOp(op walkOperation) bool

type EvalReadDataApply ¶ added in v0.7.0

type EvalReadDataApply struct {
	Provider *ResourceProvider
	Output   **InstanceState
	Diff     **InstanceDiff
	Info     *InstanceInfo
}

EvalReadDataApply is an EvalNode implementation that executes a data resource's ReadDataApply method to read data from the data source.

func (n *EvalReadDataApply) Eval(ctx EvalContext) (interface{}, error)

type EvalReadDataDiff ¶ added in v0.7.0

type EvalReadDataDiff struct {
	Provider    *ResourceProvider
	Output      **InstanceDiff
	OutputState **InstanceState
	Config      **ResourceConfig
	Info        *InstanceInfo

	// Set Previous when re-evaluating diff during apply, to ensure that
	// the "Destroy" flag is preserved.
	Previous **InstanceDiff
}

EvalReadDataDiff is an EvalNode implementation that executes a data resource's ReadDataDiff method to discover what attributes it exports.

func (n *EvalReadDataDiff) Eval(ctx EvalContext) (interface{}, error)

type EvalReadDiff ¶ added in v0.4.0

type EvalReadDiff struct {
	Name string
	Diff **InstanceDiff
}

EvalReadDiff is an EvalNode implementation that writes the diff to the full diff.

func (n *EvalReadDiff) Eval(ctx EvalContext) (interface{}, error)

type EvalReadState ¶ added in v0.4.0

type EvalReadState struct {
	Name   string
	Output **InstanceState
}

EvalReadState is an EvalNode implementation that reads the primary InstanceState for a specific resource out of the state.

func (n *EvalReadState) Eval(ctx EvalContext) (interface{}, error)

type EvalReadStateDeposed ¶ added in v0.4.0

type EvalReadStateDeposed struct {
	Name   string
	Output **InstanceState
	// Index indicates which instance in the Deposed list to target, or -1 for
	// the last item.
	Index int
}

EvalReadStateDeposed is an EvalNode implementation that reads the deposed InstanceState for a specific resource out of the state

func (n *EvalReadStateDeposed) Eval(ctx EvalContext) (interface{}, error)

type EvalRefresh ¶ added in v0.4.0

type EvalRefresh struct {
	Provider *ResourceProvider
	State    **InstanceState
	Info     *InstanceInfo
	Output   **InstanceState
}

EvalRefresh is an EvalNode implementation that does a refresh for a resource.

func (n *EvalRefresh) Eval(ctx EvalContext) (interface{}, error)

type EvalRequireState ¶ added in v0.4.0

type EvalRequireState struct {
	State **InstanceState
}

EvalRequireState is an EvalNode implementation that early exits if the state doesn't have an ID.

func (n *EvalRequireState) Eval(ctx EvalContext) (interface{}, error)

type EvalReturnError ¶ added in v0.4.0

type EvalReturnError struct {
	Error *error
}

EvalReturnError is an EvalNode implementation that returns an error if it is present.

This is useful for scenarios where an error has been captured by another EvalNode (like EvalApply) for special EvalTree-based error handling, and that handling has completed, so the error should be returned normally.

func (n *EvalReturnError) Eval(ctx EvalContext) (interface{}, error)

type EvalSequence ¶ added in v0.4.0

type EvalSequence struct {
	Nodes []EvalNode
}

EvalSequence is an EvalNode that evaluates in sequence.

func (n *EvalSequence) Eval(ctx EvalContext) (interface{}, error)

func (n *EvalSequence) Filter(fn EvalNodeFilterFunc)

type EvalSetProviderConfig ¶ added in v0.4.1

type EvalSetProviderConfig struct {
	Provider string
	Config   **ResourceConfig
}

EvalSetProviderConfig sets the parent configuration for a provider without configuring that provider, validating it, etc.

func (n *EvalSetProviderConfig) Eval(ctx EvalContext) (interface{}, error)

type EvalSetVariables ¶ added in v0.4.0

type EvalSetVariables struct {
	Module    *string
	Variables map[string]interface{}
}

EvalSetVariables is an EvalNode implementation that sets the variables explicitly for interpolation later.

func (n *EvalSetVariables) Eval(ctx EvalContext) (interface{}, error)

type EvalTypeCheckVariable ¶ added in v0.6.15

type EvalTypeCheckVariable struct {
	Variables  map[string]interface{}
	ModulePath []string
	ModuleTree *module.Tree
}

EvalTypeCheckVariable is an EvalNode which ensures that the variable values which are assigned as inputs to a module (including the root) match the types which are either declared for the variables explicitly or inferred from the default values.

In order to achieve this three things are required:

• a map of the proposed variable values
• the configuration tree of the module in which the variable is declared
• the path to the module (so we know which part of the tree to compare the values against).

func (n *EvalTypeCheckVariable) Eval(ctx EvalContext) (interface{}, error)

type EvalUndeposeState ¶ added in v0.4.0

type EvalUndeposeState struct {
	Name  string
	State **InstanceState
}

EvalUndeposeState is an EvalNode implementation that reads the InstanceState for a specific resource out of the state.

func (n *EvalUndeposeState) Eval(ctx EvalContext) (interface{}, error)

type EvalUpdateStateHook ¶ added in v0.4.0

type EvalUpdateStateHook struct{}

EvalUpdateStateHook is an EvalNode implementation that calls the PostStateUpdate hook with the current state.

func (n *EvalUpdateStateHook) Eval(ctx EvalContext) (interface{}, error)

type EvalValidateCount ¶ added in v0.4.0

type EvalValidateCount struct {
	Resource *config.Resource
}

EvalValidateCount is an EvalNode implementation that validates the count of a resource.

func (n *EvalValidateCount) Eval(ctx EvalContext) (interface{}, error)

type EvalValidateError ¶ added in v0.4.0

type EvalValidateError struct {
	Warnings []string
	Errors   []error
}

EvalValidateError is the error structure returned if there were validation errors.

func (e *EvalValidateError) Error() string

type EvalValidateProvider ¶ added in v0.4.0

type EvalValidateProvider struct {
	Provider *ResourceProvider
	Config   **ResourceConfig
}

EvalValidateProvider is an EvalNode implementation that validates the configuration of a resource.

func (n *EvalValidateProvider) Eval(ctx EvalContext) (interface{}, error)

type EvalValidateProvisioner ¶ added in v0.4.0

type EvalValidateProvisioner struct {
	Provisioner *ResourceProvisioner
	Config      **ResourceConfig
}

EvalValidateProvisioner is an EvalNode implementation that validates the configuration of a resource.

func (n *EvalValidateProvisioner) Eval(ctx EvalContext) (interface{}, error)

type EvalValidateResource ¶ added in v0.4.0

type EvalValidateResource struct {
	Provider     *ResourceProvider
	Config       **ResourceConfig
	ResourceName string
	ResourceType string
	ResourceMode config.ResourceMode

	// IgnoreWarnings means that warnings will not be passed through. This allows
	// "just-in-time" passes of validation to continue execution through warnings.
	IgnoreWarnings bool
}

EvalValidateResource is an EvalNode implementation that validates the configuration of a resource.

func (n *EvalValidateResource) Eval(ctx EvalContext) (interface{}, error)

type EvalVariableBlock ¶ added in v0.4.0

type EvalVariableBlock struct {
	Config         **ResourceConfig
	VariableValues map[string]interface{}
}

EvalVariableBlock is an EvalNode implementation that evaluates the given configuration, and uses the final values as a way to set the mapping.

func (n *EvalVariableBlock) Eval(ctx EvalContext) (interface{}, error)

type EvalWriteDiff ¶ added in v0.4.0

type EvalWriteDiff struct {
	Name string
	Diff **InstanceDiff
}

EvalWriteDiff is an EvalNode implementation that writes the diff to the full diff.

func (n *EvalWriteDiff) Eval(ctx EvalContext) (interface{}, error)

type EvalWriteOutput ¶ added in v0.4.0

type EvalWriteOutput struct {
	Name      string
	Sensitive bool
	Value     *config.RawConfig
}

EvalWriteOutput is an EvalNode implementation that writes the output for the given name to the current state.

func (n *EvalWriteOutput) Eval(ctx EvalContext) (interface{}, error)

type EvalWriteState ¶ added in v0.4.0

type EvalWriteState struct {
	Name         string
	ResourceType string
	Provider     string
	Dependencies []string
	State        **InstanceState
}

EvalWriteState is an EvalNode implementation that writes the primary InstanceState for a specific resource into the state.

func (n *EvalWriteState) Eval(ctx EvalContext) (interface{}, error)

type EvalWriteStateDeposed ¶ added in v0.4.0

type EvalWriteStateDeposed struct {
	Name         string
	ResourceType string
	Provider     string
	Dependencies []string
	State        **InstanceState
	// Index indicates which instance in the Deposed list to target, or -1 to append.
	Index int
}

EvalWriteStateDeposed is an EvalNode implementation that writes an InstanceState out to the Deposed list of a resource in the state.

func (n *EvalWriteStateDeposed) Eval(ctx EvalContext) (interface{}, error)

type ExpandTransform ¶ added in v0.4.0

type ExpandTransform struct {
	Builder GraphBuilder
}

ExpandTransform is a transformer that does a subgraph expansion at graph transform time (vs. at eval time). The benefit of earlier subgraph expansion is that errors with the graph build can be detected at an earlier stage.

func (t *ExpandTransform) Transform(v dag.Vertex) (dag.Vertex, error)

type FlatConfigTransformer ¶ added in v0.7.8

type FlatConfigTransformer struct {
	Concrete ConcreteResourceNodeFunc // What to turn resources into

	Module *module.Tree
}

FlatConfigTransformer is a GraphTransformer that adds the configuration to the graph. The module used to configure this transformer must be the root module.

This transform adds the nodes but doesn't connect any of the references. The ReferenceTransformer should be used for that.

NOTE: In relation to ConfigTransformer: this is a newer generation config transformer. It puts the _entire_ config into the graph (there is no "flattening" step as before).

func (t *FlatConfigTransformer) Transform(g *Graph) error

type FlattenTransformer ¶ added in v0.5.0

type FlattenTransformer struct{}

FlattenTransformer is a transformer that goes through the graph, finds subgraphs that can be flattened, and flattens them into this graph, removing the prior subgraph node.

func (t *FlattenTransformer) Transform(g *Graph) error

type Graph ¶

type Graph struct {
	// Graph is the actual DAG. This is embedded so you can call the DAG
	// methods directly.
	dag.AcyclicGraph

	// Path is the path in the module tree that this Graph represents.
	// The root is represented by a single element list containing
	// RootModuleName
	Path []string
	// contains filtered or unexported fields
}

Graph represents the graph that Terraform uses to represent resources and their dependencies. Each graph represents only one module, but it can contain further modules, which themselves have their own graph.

func (g *Graph) Add(v dag.Vertex) dag.Vertex

func (g *Graph) Annotations(v dag.Vertex) map[string]interface{}

func (g *Graph) ConnectDependent(raw dag.Vertex) []string

func (g *Graph) ConnectDependents()

func (g *Graph) ConnectFrom(source string, target dag.Vertex)

func (g *Graph) ConnectTo(v dag.Vertex, targets []string) []string

func (g *Graph) Dependable(n string) dag.Vertex

func (g *Graph) DirectedGraph() dag.Grapher

func (g *Graph) Remove(v dag.Vertex) dag.Vertex

func (g *Graph) Replace(o, n dag.Vertex) bool

func (g *Graph) Walk(walker GraphWalker) error

type GraphBuilder ¶ added in v0.4.0

type GraphBuilder interface {
	// Build builds the graph for the given module path. It is up to
	// the interface implementation whether this build should expand
	// the graph or not.
	Build(path []string) (*Graph, error)
}

GraphBuilder is an interface that can be implemented and used with Terraform to build the graph that Terraform walks.

type GraphNodeAddressable ¶ added in v0.4.0

type GraphNodeAddressable interface {
	ResourceAddress() *ResourceAddress
}

GraphNodeAddressable is an interface that all graph nodes for the configuration graph need to implement in order to be be addressed / targeted properly.

type GraphNodeAnnotationInit ¶ added in v0.7.8

type GraphNodeAnnotationInit interface {
	AnnotationInit() map[string]interface{}
}

GraphNodeAnnotationInit is an interface that allows a node to initialize it's annotations.

AnnotationInit will be called _once_ when the node is added to a graph for the first time and is expected to return it's initial annotations.

type GraphNodeAttachProvider ¶ added in v0.7.8

type GraphNodeAttachProvider interface {
	// Must be implemented to determine the path for the configuration
	GraphNodeSubPath

	// ProviderName with no module prefix. Example: "aws".
	ProviderName() string

	// Sets the configuration
	AttachProvider(*config.ProviderConfig)
}

GraphNodeAttachProvider is an interface that must be implemented by nodes that want provider configurations attached.

type GraphNodeAttachResourceConfig ¶ added in v0.7.8

type GraphNodeAttachResourceConfig interface {
	// ResourceAddr is the address to the resource
	ResourceAddr() *ResourceAddress

	// Sets the configuration
	AttachResourceConfig(*config.Resource)
}

GraphNodeAttachResourceConfig is an interface that must be implemented by nodes that want resource configurations attached.

type GraphNodeAttachResourceState ¶ added in v0.7.8

type GraphNodeAttachResourceState interface {
	// The address to the resource for the state
	ResourceAddr() *ResourceAddress

	// Sets the state
	AttachResourceState(*ResourceState)
}

GraphNodeAttachResourceState is an interface that can be implemented to request that a ResourceState is attached to the node.

type GraphNodeBasicSubgraph ¶ added in v0.4.0

type GraphNodeBasicSubgraph struct {
	NameValue string
	Graph     *Graph
}

func (n *GraphNodeBasicSubgraph) FlattenGraph() *Graph

func (n *GraphNodeBasicSubgraph) Name() string

func (n *GraphNodeBasicSubgraph) Subgraph() dag.Grapher

type GraphNodeCloseProvider ¶ added in v0.6.0

type GraphNodeCloseProvider interface {
	CloseProviderName() string
}

GraphNodeCloseProvider is an interface that nodes that can be a close provider must implement. The CloseProviderName returned is the name of the provider they satisfy.

type GraphNodeCloseProvisioner ¶ added in v0.6.0

type GraphNodeCloseProvisioner interface {
	CloseProvisionerName() string
}

GraphNodeCloseProvisioner is an interface that nodes that can be a close provisioner must implement. The CloseProvisionerName returned is the name of the provisioner they satisfy.

type GraphNodeConfigModule ¶ added in v0.4.0

type GraphNodeConfigModule struct {
	Path   []string
	Module *config.Module
	Tree   *module.Tree
}

GraphNodeConfigModule represents a module within the configuration graph.

func (n *GraphNodeConfigModule) ConfigType() GraphNodeConfigType

func (n *GraphNodeConfigModule) DependableName() []string

func (n *GraphNodeConfigModule) DependentOn() []string

func (n *GraphNodeConfigModule) Expand(b GraphBuilder) (GraphNodeSubgraph, error)

func (n *GraphNodeConfigModule) Name() string

func (n *GraphNodeConfigModule) ProvidedBy() []string

type GraphNodeConfigOutput ¶ added in v0.4.0

type GraphNodeConfigOutput struct {
	Output *config.Output
}

GraphNodeConfigOutput represents an output configured within the configuration.

func (n *GraphNodeConfigOutput) ConfigType() GraphNodeConfigType

func (n *GraphNodeConfigOutput) DependableName() []string

func (n *GraphNodeConfigOutput) DependentOn() []string

func (n *GraphNodeConfigOutput) DestroyEdgeInclude(dag.Vertex) bool

func (n *GraphNodeConfigOutput) EvalTree() EvalNode

func (n *GraphNodeConfigOutput) Flatten(p []string) (dag.Vertex, error)

func (n *GraphNodeConfigOutput) Name() string

func (n *GraphNodeConfigOutput) OutputName() string

func (n *GraphNodeConfigOutput) Proxy() bool

type GraphNodeConfigOutputFlat ¶ added in v0.5.0

type GraphNodeConfigOutputFlat struct {
	*GraphNodeConfigOutput

	PathValue []string
}

Same as GraphNodeConfigOutput, but for flattening

func (n *GraphNodeConfigOutputFlat) DependableName() []string

func (n *GraphNodeConfigOutputFlat) DependentOn() []string

func (n *GraphNodeConfigOutputFlat) Name() string

func (n *GraphNodeConfigOutputFlat) Path() []string

type GraphNodeConfigProvider ¶ added in v0.4.0

type GraphNodeConfigProvider struct {
	Provider *config.ProviderConfig
}

GraphNodeConfigProvider represents a configured provider within the configuration graph. These are only immediately in the graph when an explicit `provider` configuration block is in the configuration.

func (n *GraphNodeConfigProvider) ConfigType() GraphNodeConfigType

func (n *GraphNodeConfigProvider) DependableName() []string

func (n *GraphNodeConfigProvider) DependentOn() []string

func (n *GraphNodeConfigProvider) DotNode(name string, opts *dag.DotOpts) *dag.DotNode

func (n *GraphNodeConfigProvider) DotOrigin() bool

func (n *GraphNodeConfigProvider) EvalTree() EvalNode

func (n *GraphNodeConfigProvider) Flatten(p []string) (dag.Vertex, error)

func (n *GraphNodeConfigProvider) Name() string

func (n *GraphNodeConfigProvider) ProviderConfig() *config.RawConfig

func (n *GraphNodeConfigProvider) ProviderName() string

type GraphNodeConfigProviderFlat ¶ added in v0.5.0

type GraphNodeConfigProviderFlat struct {
	*GraphNodeConfigProvider

	PathValue []string
}

Same as GraphNodeConfigProvider, but for flattening

func (n *GraphNodeConfigProviderFlat) DependableName() []string

func (n *GraphNodeConfigProviderFlat) DependentOn() []string

func (n *GraphNodeConfigProviderFlat) Name() string

func (n *GraphNodeConfigProviderFlat) Path() []string

func (n *GraphNodeConfigProviderFlat) ProviderName() string

type GraphNodeConfigResource ¶ added in v0.4.0

type GraphNodeConfigResource struct {
	Resource *config.Resource

	// If set to true, this resource represents a resource
	// that will be destroyed in some way.
	Destroy bool

	// Used during DynamicExpand to target indexes
	Targets []ResourceAddress

	Path []string
}

GraphNodeConfigResource represents a resource within the config graph.

func (n *GraphNodeConfigResource) ConfigType() GraphNodeConfigType

func (n *GraphNodeConfigResource) Copy() *GraphNodeConfigResource

func (n *GraphNodeConfigResource) CountDependentOn() []string

func (n *GraphNodeConfigResource) DependableName() []string

func (n *GraphNodeConfigResource) DependentOn() []string

func (n *GraphNodeConfigResource) DestroyNode() GraphNodeDestroy

func (n *GraphNodeConfigResource) DotNode(name string, opts *dag.DotOpts) *dag.DotNode

func (n *GraphNodeConfigResource) DynamicExpand(ctx EvalContext) (*Graph, error)

func (n *GraphNodeConfigResource) EvalTree() EvalNode

func (n *GraphNodeConfigResource) Flatten(p []string) (dag.Vertex, error)

func (n *GraphNodeConfigResource) Name() string

func (n *GraphNodeConfigResource) Noop(opts *NoopOpts) bool

func (n *GraphNodeConfigResource) ProvidedBy() []string

func (n *GraphNodeConfigResource) ProvisionedBy() []string

func (n *GraphNodeConfigResource) ResourceAddress() *ResourceAddress

func (n *GraphNodeConfigResource) SetTargets(targets []ResourceAddress)

func (n *GraphNodeConfigResource) VarWalk(fn func(config.InterpolatedVariable))

type GraphNodeConfigResourceFlat ¶ added in v0.5.0

type GraphNodeConfigResourceFlat struct {
	*GraphNodeConfigResource

	PathValue []string
}

Same as GraphNodeConfigResource, but for flattening

func (n *GraphNodeConfigResourceFlat) DependableName() []string

func (n *GraphNodeConfigResourceFlat) DependentOn() []string

func (n *GraphNodeConfigResourceFlat) DestroyNode() GraphNodeDestroy

func (n *GraphNodeConfigResourceFlat) Name() string

func (n *GraphNodeConfigResourceFlat) Path() []string

func (n *GraphNodeConfigResourceFlat) ProvidedBy() []string

func (n *GraphNodeConfigResourceFlat) ProvisionedBy() []string

type GraphNodeConfigType ¶ added in v0.4.1

type GraphNodeConfigType int

GraphNodeConfigType is an enum for the type of thing that a graph node represents from the configuration.

const (
	GraphNodeConfigTypeInvalid  GraphNodeConfigType = 0
	GraphNodeConfigTypeResource GraphNodeConfigType = iota
	GraphNodeConfigTypeProvider
	GraphNodeConfigTypeModule
	GraphNodeConfigTypeOutput
	GraphNodeConfigTypeVariable
)

func (i GraphNodeConfigType) String() string

type GraphNodeConfigVariable ¶ added in v0.5.0

type GraphNodeConfigVariable struct {
	Variable *config.Variable

	// Value, if non-nil, will be used to set the value of the variable
	// during evaluation. If this is nil, evaluation will do nothing.
	//
	// Module is the name of the module to set the variables on.
	Module string
	Value  *config.RawConfig

	ModuleTree *module.Tree
	ModulePath []string
}

GraphNodeConfigVariable represents a Variable in the config.

func (n *GraphNodeConfigVariable) ConfigType() GraphNodeConfigType

func (n *GraphNodeConfigVariable) DependableName() []string

func (n *GraphNodeConfigVariable) DependentOn() []string

func (n *GraphNodeConfigVariable) DestroyEdgeInclude(v dag.Vertex) bool

func (n *GraphNodeConfigVariable) EvalTree() EvalNode

func (n *GraphNodeConfigVariable) Flatten(p []string) (dag.Vertex, error)

func (n *GraphNodeConfigVariable) Name() string

func (n *GraphNodeConfigVariable) Noop(opts *NoopOpts) bool

func (n *GraphNodeConfigVariable) Proxy() bool

func (n *GraphNodeConfigVariable) RemoveIfNotTargeted() bool

func (n *GraphNodeConfigVariable) VariableName() string

type GraphNodeConfigVariableFlat ¶ added in v0.5.0

type GraphNodeConfigVariableFlat struct {
	*GraphNodeConfigVariable

	PathValue []string
}

func (n *GraphNodeConfigVariableFlat) DependableName() []string

func (n *GraphNodeConfigVariableFlat) DependentOn() []string

func (n *GraphNodeConfigVariableFlat) Name() string

func (n *GraphNodeConfigVariableFlat) Noop(opts *NoopOpts) bool

func (n *GraphNodeConfigVariableFlat) Path() []string

type GraphNodeCountDependent ¶ added in v0.5.0

type GraphNodeCountDependent interface {
	CountDependentOn() []string
}

GraphNodeCountDependent is implemented by resources for giving only the dependencies they have from the "count" field.

type GraphNodeCreator ¶ added in v0.7.8

type GraphNodeCreator interface {
	// ResourceAddr is the address of the resource being created or updated
	CreateAddr() *ResourceAddress
}

GraphNodeCreator must be implemented by nodes that create OR update resources.

type GraphNodeDependable ¶ added in v0.4.0

type GraphNodeDependable interface {
	DependableName() []string
}

GraphNodeDependable is an interface which says that a node can be depended on (an edge can be placed between this node and another) according to the well-known name returned by DependableName.

DependableName can return multiple names it is known by.

type GraphNodeDependent ¶ added in v0.4.0

type GraphNodeDependent interface {
	DependentOn() []string
}

GraphNodeDependent is an interface which says that a node depends on another GraphNodeDependable by some name. By implementing this interface, Graph.ConnectDependents() can be called multiple times safely and efficiently.

type GraphNodeDestroy ¶ added in v0.4.0

type GraphNodeDestroy interface {
	dag.Vertex

	// CreateBeforeDestroy is called to check whether this node
	// should be created before it is destroyed. The CreateBeforeDestroy
	// transformer uses this information to setup the graph.
	CreateBeforeDestroy() bool

	// CreateNode returns the node used for the create side of this
	// destroy. This must already exist within the graph.
	CreateNode() dag.Vertex
}

GraphNodeDestroy is the interface that must implemented by nodes that destroy.

type GraphNodeDestroyEdgeInclude ¶ added in v0.5.0

type GraphNodeDestroyEdgeInclude interface {
	DestroyEdgeInclude(dag.Vertex) bool
}

GraphNodeEdgeInclude can be implemented to not include something as an edge within the destroy graph. This is usually done because it might cause unnecessary cycles.

type GraphNodeDestroyPrunable ¶ added in v0.4.0

type GraphNodeDestroyPrunable interface {
	// DestroyInclude is called to check if this node should be included
	// with the given state. The state and diff must NOT be modified.
	DestroyInclude(*ModuleDiff, *ModuleState) bool
}

GraphNodeDestroyPrunable is the interface that can be implemented to signal that this node can be pruned depending on state.

type GraphNodeDestroyable ¶ added in v0.4.0

type GraphNodeDestroyable interface {
	// DestroyNode returns the node used for the destroy with the given
	// mode. If this returns nil, then a destroy node for that mode
	// will not be added.
	DestroyNode() GraphNodeDestroy
}

GraphNodeDestroyable is the interface that nodes that can be destroyed must implement. This is used to automatically handle the creation of destroy nodes in the graph and the dependency ordering of those destroys.

type GraphNodeDestroyer ¶ added in v0.7.8

type GraphNodeDestroyer interface {
	dag.Vertex

	// ResourceAddr is the address of the resource that is being
	// destroyed by this node. If this returns nil, then this node
	// is not destroying anything.
	DestroyAddr() *ResourceAddress
}

GraphNodeDestroyer must be implemented by nodes that destroy resources.

type GraphNodeDestroyerCBD ¶ added in v0.7.8

type GraphNodeDestroyerCBD interface {
	GraphNodeDestroyer

	// CreateBeforeDestroy returns true if this node represents a node
	// that is doing a CBD.
	CreateBeforeDestroy() bool

	// ModifyCreateBeforeDestroy is called when the CBD state of a node
	// is changed dynamically. This can return an error if this isn't
	// allowed.
	ModifyCreateBeforeDestroy(bool) error
}

GraphNodeDestroyerCBD must be implemented by nodes that might be create-before-destroy destroyers.

type GraphNodeDynamicExpandable ¶ added in v0.4.0

type GraphNodeDynamicExpandable interface {
	DynamicExpand(EvalContext) (*Graph, error)
}

GraphNodeDynamicExpandable is an interface that nodes can implement to signal that they can be expanded at eval-time (hence dynamic). These nodes are given the eval context and are expected to return a new subgraph.

type GraphNodeEvalable ¶ added in v0.4.0