package terraform
import (
- "github.com/hashicorp/terraform/config/module"
+ "github.com/hashicorp/terraform/addrs"
+ "github.com/hashicorp/terraform/configs"
"github.com/hashicorp/terraform/dag"
+ "github.com/hashicorp/terraform/states"
+ "github.com/hashicorp/terraform/tfdiags"
)
// DestroyPlanGraphBuilder implements GraphBuilder and is responsible for
// Planning a pure destroy operation is simple because we can ignore most
// ordering configuration and simply reverse the state.
type DestroyPlanGraphBuilder struct {
- // Module is the root module for the graph to build.
- Module *module.Tree
+ // Config is the configuration tree to build the plan from.
+ Config *configs.Config
// State is the current state
- State *State
+ State *states.State
+
+ // Components is a factory for the plug-in components (providers and
+ // provisioners) available for use.
+ Components contextComponentFactory
+
+ // Schemas is the repository of schemas we will draw from to analyse
+ // the configuration.
+ Schemas *Schemas
// Targets are resources to target
- Targets []string
+ Targets []addrs.Targetable
// Validate will do structural validation of the graph.
Validate bool
}
// See GraphBuilder
-func (b *DestroyPlanGraphBuilder) Build(path []string) (*Graph, error) {
+func (b *DestroyPlanGraphBuilder) Build(path addrs.ModuleInstance) (*Graph, tfdiags.Diagnostics) {
return (&BasicGraphBuilder{
Steps: b.Steps(),
Validate: b.Validate,
// See GraphBuilder
func (b *DestroyPlanGraphBuilder) Steps() []GraphTransformer {
- concreteResource := func(a *NodeAbstractResource) dag.Vertex {
- return &NodePlanDestroyableResource{
- NodeAbstractResource: a,
+ concreteResourceInstance := func(a *NodeAbstractResourceInstance) dag.Vertex {
+ return &NodePlanDestroyableResourceInstance{
+ NodeAbstractResourceInstance: a,
+ }
+ }
+ concreteResourceInstanceDeposed := func(a *NodeAbstractResourceInstance, key states.DeposedKey) dag.Vertex {
+ return &NodePlanDeposedResourceInstanceObject{
+ NodeAbstractResourceInstance: a,
+ DeposedKey: key,
+ }
+ }
+
+ concreteProvider := func(a *NodeAbstractProvider) dag.Vertex {
+ return &NodeApplyableProvider{
+ NodeAbstractProvider: a,
}
}
steps := []GraphTransformer{
- // Creates all the nodes represented in the state.
+ // Creates nodes for the resource instances tracked in the state.
&StateTransformer{
- Concrete: concreteResource,
- State: b.State,
+ ConcreteCurrent: concreteResourceInstance,
+ ConcreteDeposed: concreteResourceInstanceDeposed,
+ State: b.State,
},
// Attach the configuration to any resources
- &AttachResourceConfigTransformer{Module: b.Module},
+ &AttachResourceConfigTransformer{Config: b.Config},
+
+ TransformProviders(b.Components.ResourceProviders(), concreteProvider, b.Config),
// Destruction ordering. We require this only so that
// targeting below will prune the correct things.
- &DestroyEdgeTransformer{Module: b.Module, State: b.State},
+ &DestroyEdgeTransformer{
+ Config: b.Config,
+ State: b.State,
+ Schemas: b.Schemas,
+ },
// Target. Note we don't set "Destroy: true" here since we already
// created proper destroy ordering.