CloseProviderEvalTree returns the evaluation tree for closing provider connections that aren't needed anymore.

Eval evaluates the given EvalNode with the given context, properly evaluating all args in the correct order.

EvalFilter runs the filter on the given node and returns the final filtered value.

EvalNodeFilterOp returns a filter function that filters nodes that include themselves in specific operations.

EvalRaw is like Eval except that it returns all errors, even if they signal something normal such as EvalEarlyExitError.

GraphDot returns the dot formatting of a visual representation of the given Terraform graph.

NewContext creates a new Context structure.

NewResourceConfig creates a new ResourceConfig from a config.RawConfig.

NewSemaphore creates a semaphore that allows up to a given limit of simultaneous acquisitions.

NewState is used to initialize a blank state.

PathCacheKey returns a cache key for a module path.

ProviderEvalTree returns the evaluation tree for initializing and configuring providers.

ReadPlan reads a plan structure out of a reader in the format that was written by WritePlan.

ReadState reads a state structure out of a reader in the format that was written by WriteState.

ReadStateV1 reads a state structure out of a reader in the format that was written by WriteState.

ResourceProviderFactoryFixed is a helper that creates a ResourceProviderFactory that just returns some fixed provider.

WritePlan writes a plan somewhere in a binary format.

WriteState writes a state somewhere in a binary format.

HookActionContinue continues with processing as usual.

HookActionHalt halts immediately: no more hooks are processed and the action that Terraform was about to take is cancelled.

InputModeProvider asks for provider variables.

InputModeStd is the standard operating mode and asks for both variables and providers.

InputModeVar asks for all variables.

InputModeVarUnset asks for variables which are not set yet.

RootModuleName is the name given to the root module implicitly.

StateVersion is the current version for our state file.

VarEnvPrefix is the prefix of variables that are read from the environment to set variables here.

The main version number that is being run at the moment.

A pre-release marker for the version.

RootModulePath is the path for the root module.

AddOutputOrphanTransformer is a transformer that adds output orphans to the graph.

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

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

BuiltinGraphBuilder is responsible for building the complete graph that Terraform uses for execution.

CloseProviderTransformer is a GraphTransformer that adds nodes to the graph that will close open provider connections that aren't needed anymore.

CloseProvisionerTransformer is a GraphTransformer that adds nodes to the graph that will close open provisioner connections that aren't needed anymore.

ConfigTransformer is a GraphTransformer that adds the configuration to the graph.

Context represents all the context that Terraform needs in order to perform operations on infrastructure.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

EvalCountFixZeroOneBoundary is an EvalNode that fixes up the state when there is a resource count with zero/one boundary, i.e.

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

EvalDeposeState is an EvalNode implementation that takes the primary out of a state and makes it Deposed.

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

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

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

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

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

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

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

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

EvalIf is an EvalNode that is a conditional.

EvalInitProvider is an EvalNode implementation that initializes a provider and returns nothing.

EvalInitProvisioner is an EvalNode implementation that initializes a provisioner and returns nothing.

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

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

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

EvalNoop is an EvalNode that does nothing.

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

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

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

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

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

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

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

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

EvalSequence is an EvalNode that evaluates in sequence.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ExpandTransform is a transformer that does a subgraph expansion at graph transform time (vs.

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.

Graph represents the graph that Terraform uses to represent resources and their dependencies.

GraphDotOpts are the options for generating a dot formatted Graph.

GraphNodeConfigModule represents a module within the configuration graph.

GraphNodeConfigOutput represents an output configured within the configuration.

Same as GraphNodeConfigOutput, but for flattening.

GraphNodeConfigProvider represents a configured provider within the configuration graph.

Same as GraphNodeConfigProvider, but for flattening.

GraphNodeConfigResource represents a resource within the config graph.

Same as GraphNodeConfigResource, but for flattening.

GraphNodeConfigVariable represents a Variable in the config.

GraphProxyEdge is the edge that is used for proxied edges.

InputOpts are options for asking for input.

InstanceDiff is the diff of a resource from some state to another.

InstanceInfo is used to hold information about the instance and/or resource being modified.

InstanceState is used to track the unique state information belonging to a given instance.

Interpolater is the structure responsible for determining the values for interpolations such as `aws_instance.foo.bar`.

InterpolationScope is the current scope of execution.

MissingProviderTransformer is a GraphTransformer that adds nodes for missing providers into the graph.

MissingProvisionerTransformer is a GraphTransformer that adds nodes for missing provisioners into the graph.

MockEvalContext is a mock version of EvalContext that can be used for tests.

MockHook is an implementation of Hook that can be used for tests.

MockResourceProvider implements ResourceProvider but mocks out all the calls for testing purposes.

MockResourceProvisioner implements ResourceProvisioner but mocks out all the calls for testing purposes.

MockUIInput is an implementation of UIInput that can be used for tests.

MockUIOutput is an implementation of UIOutput that can be used for tests.

ModuleDestroyTransformer is a GraphTransformer that adds a node to the graph that will just mark the full module for destroy in the destroy scenario.

ModuleDiff tracks the differences between resources to apply within a single module.

ModuleInputTransformer is a GraphTransformer that adds a node to the graph for setting the module input variables for the remainder of the graph.

ModuleState is used to track all the state relevant to a single module.

NilHook is a Hook implementation that does nothing.

NoopOpts are the options available to determine if your node is a noop.

NullGraphWalker is a GraphWalker implementation that does nothing.

OrphanTransformer is a GraphTransformer that adds orphans to the graph.

Plan represents a single Terraform execution plan, which contains all the information necessary to make an infrastructure change.

PrefixUIInput is an implementation of UIInput that prefixes the ID with a string, allowing queries to be namespaced.

ProviderTransformer is a GraphTransformer that maps resources to providers within the graph.

ProvisionerTransformer is a GraphTransformer that maps resources to provisioners within the graph.

ProvisionerUIOutput is an implementation of UIOutput that calls a hook for the output so that the hooks can handle it.

ProxyTransformer is a transformer that goes through the graph, finds vertices that are marked as proxies, and connects through their dependents.

PruneDestroyTransformer is a GraphTransformer that removes the destroy nodes that aren't in the diff.

PruneNoopTransformer is a graph transform that prunes nodes that consider themselves no-ops.

PruneProviderTransformer is a GraphTransformer that prunes all the providers that aren't needed from the graph.

PruneProvisionerTransformer is a GraphTransformer that prunes all the provisioners that aren't needed from the graph.

RemoteState is used to track the information about a remote state store that we push/pull state to.

Resource encapsulates a resource, its configuration, its provider, its current state, and potentially a desired diff from the state it wants to reach.

ResourceAddress is a way of identifying an individual resource (or, eventually, a subset of resources) within the state.

ResourceAttrDiff is the diff of a single attribute of a resource.

ResourceConfig holds the configuration given for a resource.

ResourceCountTransformer is a GraphTransformer that expands the count out for a specific resource.

ResourceDependency maps a resource to another resource that it depends on to remain intact and uncorrupted.

ResourceProvisionerConfig is used to pair a provisioner with its provided configuration.

ResourceState holds the state of a resource that is used so that a provider can find and manage an existing resource as well as for storing attributes that are used to populate variables of child resources.

ResourceState holds the state of a resource that is used so that a provider can find and manage an existing resource as well as for storing attributes that are uesd to populate variables of child resources.

ResourceType is a type of resource that a resource provider can manage.

RootTransformer is a GraphTransformer that adds a root to the graph.

SemanticCheckModulesExist is an implementation of SemanticChecker that verifies that all the modules that are referenced in the graph exist.

State keeps track of a snapshot state-of-the-world that Terraform can use to keep track of what real world resources it is actually managing.

StateV1 is used to represent the state of Terraform files before 0.3.

TaintedTransformer is a GraphTransformer that adds tainted resources to the graph.

TargetsTransformer is a GraphTransformer that, when the user specifies a list of resources to target, limits the graph to only those resources and their dependencies.

TransitiveReductionTransformer is a GraphTransformer that performs finds the transitive reduction of the graph.

UnorderedSemanticCheckRunner is an implementation of GraphSemanticChecker that runs a list of SemanticCheckers against the vertices of the graph in no specified order.

VertexTransformer is a GraphTransformer that transforms vertices using the GraphVertexTransformers.

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

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

EvalNodeFilterable is an interface that can be implemented by EvalNodes to allow filtering of sub-elements.

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

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

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

GraphNodeCloseProvider is an interface that nodes that can be a close provider must implement.

GraphNodeCloseProvisioner is an interface that nodes that can be a close provisioner must implement.

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

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.

GraphNodeDependent is an interface which says that a node depends on another GraphNodeDependable by some name.

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

GraphNodeDestroyable is the interface that nodes that can be destroyed must implement.

GraphNodeEdgeInclude can be implemented to not include something as an edge within the destroy graph.

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

GraphNodeDotter can be implemented by a node to cause it to be included in the dot graph.

GraphNodeDynamicExpandable is an interface that nodes can implement to signal that they can be expanded at eval-time (hence dynamic).

GraphNodeEvalable is the interface that graph nodes must implement to enable valuation.

GraphNodeExapndable is an interface that nodes can implement to signal that they can be expanded.

GraphNodeFlatGraph must be implemented by nodes that have subgraphs that they want flattened into the graph.

GraphNodeFlattenable must be implemented by all nodes that can be flattened.

GraphNodeNoopPrunable can be implemented by nodes that can be pruned if they are noops.

GraphNodeOutput is an interface that nodes that are outputs must implement.

GraphNodeProvider is an interface that nodes that can be a provider must implement.

GraphNodeProviderConsumer is an interface that nodes that require a provider must implement.

GraphNodeProvisioner is an interface that nodes that can be a provisioner must implement.

GraphNodeProvisionerConsumer is an interface that nodes that require a provisioner must implement.

GraphNodeProxy must be implemented by nodes that are proxies.

GraphNodeStateRepresentative is an interface that can be implemented by a node to say that it is representing a resource in the state.

GraphNodeSubgraph is an interface a node can implement if it has a larger subgraph that should be walked.

GraphNodeSubPath says that a node is part of a graph with a different path, and the context should be adjusted accordingly.

GraphNodeTargetable is an interface for graph nodes to implement when they need to be told about incoming targets.

GraphSemanticChecker is the interface that semantic checks across the entire Terraform graph implement.

GraphTransformer is the interface that transformers implement.

GraphVertexTransformer is an interface that transforms a single Vertex within with graph.

GraphWalker is an interface that can be implemented that when used with Graph.Walk will invoke the given callbacks under certain events.

Hook is the interface that must be implemented to hook into various parts of Terraform, allowing you to inspect or change behavior at runtime.

ResourceProvider is an interface that must be implemented by any resource provider: the thing that creates and manages the resources in a Terraform configuration.

ResourceProviderCloser is an interface that providers that can close connections that aren't needed anymore must implement.

ResourceProvisioner is an interface that must be implemented by any resource provisioner: the thing that initializes resources in a Terraform configuration.

ResourceProvisionerCloser is an interface that provisioners that can close connections that aren't needed anymore must implement.

SemanticChecker is the interface that semantic checks across the Terraform graph implement.

UIInput is the interface that must be implemented to ask for input from this user.

UIOutput is the interface that must be implemented to output data to the end user.

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

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

EvalNodeFilterFunc is the callback used to replace a node with another to node.

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

HookAction is an enum of actions that can be taken as a result of a hook callback.

InputMode defines what sort of input will be asked for when Input is called on Context.

InstanceType is an enum of the various types of instances store in the State.

ResourceKind specifies what kind of instance we're working with, whether its a primary instance, a tainted instance, or an orphan.

ResourceProviderFactory is a function type that creates a new instance of a resource provider.

ResourceProvisionerFactory is a function type that creates a new instance of a resource provisioner.