CheckRequiredVersion verifies that any version requirements specified by the configuration are met.

StateCompatible returns an error if the state is not compatible with the current version of terraform.

CloseDebugInfo is the exported interface to Close the debug info handler.

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.

GraphTransformIf is a helper function that conditionally returns a GraphTransformer given.

GraphTransformMulti combines multiple graph transformers into a single GraphTransformer that runs all the individual graph transformers.

GraphWalkerPanicwrap wraps an existing Graphwalker to wrap and swallow the panics.

InputGraphBuilder creates the graph for the input operation.

ModuleTreeDependencies returns the dependencies of the tree of modules described by the given configuration tree and state.

NewContext creates a new Context structure.

NewReferenceMap is used to create a new reference map for the given set of vertices.

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.

ParseResourceAddressForInstanceDiff creates a ResourceAddress for a resource name as described in a module diff.

ParseResourceStateKey accepts a key in the format used by ModuleState.Resources and returns a resource name and resource index.

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.

ReferenceFromInterpolatedVar returns the reference from this variable, or an empty string if there is no reference.

Returns the reference name for a module path.

ReferencesFromConfig returns the references that a configuration has based on the interpolated variables in a configuration.

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

ResourceProviderResolverFixed returns a ResourceProviderResolver that has a fixed set of provider factories provided by the caller.

SetDebugInfo initializes the debug handler with a backing file in the provided directory.

TestStateFile writes the given state to the path.

Generate a UserAgent string Deprecated: Use httpclient.UserAgentString if you are setting your own User-Agent header.

ValidateGraphBuilder creates the graph for the validate operation.

Variables returns the fully loaded set of variables to use with ContextOpts and NewContext, loading any additional variables from the environment or any other sources.

TODO: update providers to use the version package directly.

WritePlan writes a plan somewhere in a binary format.

WriteState writes a state somewhere in a binary format.

TODO: Actually use DiffRefresh in core too, for less confusion.

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.

ErrNoState is returned by ReadState when the io.Reader contains no data.

GraphTypeMap is a mapping of human-readable string to GraphType.

RootModulePath is the path for the root module.

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

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

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

BackendState stores the configuration to connect to a remote backend.

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.

CBDEdgeTransformer modifies the edges of CBD nodes that went through the DestroyEdgeTransformer to have the right dependencies.

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 all the resources from 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.

ContextMeta is metadata about the running context.

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

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

DataSource is a data source that a resource provider implements.

DebugHook implements all methods of the terraform.Hook interface, and writes the arguments to a file in the archive.

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

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

DestroyEdgeTransformer is a GraphTransformer that creates the proper references for destroy resources.

DestroyOutputTransformer is a GraphTransformer that adds nodes to delete outputs during destroy.

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

DestroyReferenceTransformer is a GraphTransformer that reverses the edges for locals and outputs that depend on other nodes which will be removed during destroy.

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

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

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.

EvalApplyPre is an EvalNode implementation that does the pre-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.

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.

EvalCoerceMapVariable is an EvalNode implementation that recognizes a specific ambiguous HCL parsing situation and resolves it.

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.

EvalCountCheckComputed is an EvalNode that checks if a resource count is computed and errors if so.

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

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

EvalDeleteLocal is an EvalNode implementation that deletes a Local value from the state.

EvalDeleteModule is an EvalNode implementation that removes an empty module entry from the state.

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.

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.

EvalImportState is an EvalNode implementation that performs an ImportState operation on a provider.

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

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.

EvalInterpolateProvider is an EvalNode implementation that takes a ProviderConfig and interpolates it.

EvalLocal is an EvalNode implementation that evaluates the expression for a local value and writes it into a transient part of the state.

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.

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

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

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.

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.

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

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.

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.

EvalValidateResourceSelfRef is an EvalNode implementation that validates that a configuration doesn't contain a reference to the resource itself.

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.

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

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

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

ImportGraphBuilder implements GraphBuilder and is responsible for building a graph for importing resources into Terraform.

ImportOpts are used as the configuration for Import.

ImportProviderValidateTransformer is a GraphTransformer that goes through the providers in the graph and validates that they only depend on variables.

ImportStateTransformer is a GraphTransformer that adds nodes to the graph to represent the imports we want to do for resources.

ImportTarget is a single resource to import.

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.

LocalTransformer is a GraphTransformer that adds all the local values from the configuration to the graph.

MissingProviderTransformer is a GraphTransformer that adds nodes for all required 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.

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

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

ModuleVariableTransformer is a GraphTransformer that adds all the variables in the configuration to the graph.

NilHook is a Hook implementation that does nothing.

NodeAbstractCountResource should be embedded instead of NodeAbstractResource if the resource has a `count` value that needs to be expanded.

NodeAbstractProvider represents a provider that has no associated operations.

NodeAbstractResource represents a resource that has no associated operations.

NodeApplyableModuleVariable represents a module variable input during the apply step.

NodeApplyableOutput represents an output that is "applyable": it is ready to be applied.

NodeApplyableProvider represents a provider during an apply.

NodeApplyableResource represents a resource that is "applyable": it is ready to be applied and is represented by a diff.

NodeCountBoundary fixes any "count boundarie" in the state: resources that are named "foo.0" when they should be named "foo".

NodeDestroyableDataResource represents a resource that is "plannable": it is ready to be planned in order to create a diff.

NodeDestroyableOutput represents an output that is "destroybale": its application will remove the output from the state.

NodeDestroyResource represents a resource that is to be destroyed.

NodeDisabledProvider represents a provider that is disabled.

NodeLocal represents a named local value in a particular module.

NodeModuleRemoved represents a module that is no longer in the config.

NodeOutputOrphan represents an output that is an orphan.

NodePlanDestroyableResource represents a resource that is "applyable": it is ready to be applied and is represented by a diff.

NodePlannableResource represents a resource that is "plannable": it is ready to be planned in order to create a diff.

NodePlannableResourceInstance represents a _single_ resource instance that is plannable.

NodePlannableResourceOrphan represents a resource that is "applyable": it is ready to be applied and is represented by a diff.

NodeProvisioner represents a provider that has no associated operations.

NodeRefreshableDataResource represents a resource that is "plannable": it is ready to be planned in order to create a diff.

NodeRefreshableDataResourceInstance represents a _single_ resource instance that is refreshable.

NodeRefreshableManagedResource represents a resource that is expanabled into NodeRefreshableManagedResourceInstance.

NodeRefreshableManagedResourceInstance represents a resource that is "applyable": it is ready to be applied and is represented by a diff.

NodeRootVariable represents a root variable input.

NodeValidatableResource represents a resource that is used for validation only.

This represents a _single_ resource instance to validate.

NullGraphWalker is a GraphWalker implementation that does nothing.

OrphanOutputTransformer finds the outputs that aren't present in the given config that are in the state and adds them to the graph for deletion.

OrphanResourceCountTransformer is a GraphTransformer that adds orphans for an expanded count to the graph.

OrphanResourceTransformer is a GraphTransformer that adds resource orphans to the graph.

OutputState is used to track the state relevant to a single output.

OutputTransformer is a GraphTransformer that adds all the outputs in the configuration to the graph.

ParentProviderTransformer connects provider nodes to their parents.

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

PlanGraphBuilder implements GraphBuilder and is responsible for building a graph for planning (creating a Terraform Diff).

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

ProviderConfigTransformer adds all provider nodes from the configuration and attaches the configs.

ProviderSchema represents the schema for a provider's own configuration and the configuration for some or all of its resources and data sources.

ProviderSchemaRequest is used to describe to a ResourceProvider which aspects of schema are required, when calling the GetSchema method.

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.

PruneProviderTransformer removes any providers that are not actually used by anything, and provider proxies.

PruneUnusedValuesTransformer is s GraphTransformer that removes local and output values which are not referenced in the graph.

ReferenceMap is a structure that can be used to efficiently check for references on a graph.

ReferenceTransformer is a GraphTransformer that connects all the nodes that reference each other in order to form the proper ordering.

RefreshGraphBuilder implements GraphBuilder and is responsible for building a graph for refreshing (updating the Terraform state).

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

RemoveModuleTransformer implements GraphTransformer to add nodes indicating when a module was removed from the configuration.

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.

ResourceProviderError may be returned when creating a Context if the required providers cannot be satisfied.

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.

ResourceStateKey is a structured representation of the key used for the ModuleState.Resources mapping.

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

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

RootVariableTransformer is a GraphTransformer that adds all the root variables to the graph.

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.

StateFilter is responsible for filtering and searching a state.

StateFilterResult is a single result from a filter operation.

StateTransformer is a GraphTransformer that adds the elements of the state 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.

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

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

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

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.

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

GraphNodeDestroyer must be implemented by nodes that destroy resources.

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

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.

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.

GraphNodeReferenceable must be implemented by any node that represents a Terraform thing that can be referenced (resource, module, etc.).

GraphNodeReferenceGlobal is an interface that can optionally be implemented.

GraphNodeReferencer must be implemented by nodes that reference other Terraform items and therefore depend on them.

GraphNodeResource is implemented by any nodes that represent a resource.

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.

GraphNodeTargetDownstream is an interface for graph nodes that need to be remain present under targeting if any of their dependencies are targeted.

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.

GrpahWalkerPanicwrapper can be optionally implemented to catch panics that occur while walking the graph.

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

RemovableIfNotTargeted is a special interface for graph nodes that aren't directly addressable, but need to be removed from the graph when they are not targeted.

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.

ResourceProviderResolver is an interface implemented by objects that are able to resolve a given set of resource provider version constraints into ResourceProviderFactory callbacks.

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.

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

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

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.

GraphType is an enum of the type of graph to create with a Context.

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.

ProviderSchemas is a map from provider names to provider schemas.

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.

ResourceProviderResolverFunc wraps a callback function and turns it into a ResourceProviderResolver implementation, for convenience in situations where a function and its associated closure are sufficient as a resolver implementation.

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

StateFilterResultSlice is a slice of results that implements sort.Interface.