github.com/muratcelep/terraform@v1.1.0-beta2-not-internal-4/not-internal/terraform/transform_state.go (about)

     1  package terraform
     2  
     3  import (
     4  	"log"
     5  
     6  	"github.com/muratcelep/terraform/not-internal/states"
     7  )
     8  
     9  // StateTransformer is a GraphTransformer that adds the elements of
    10  // the state to the graph.
    11  //
    12  // This transform is used for example by the DestroyPlanGraphBuilder to ensure
    13  // that only resources that are in the state are represented in the graph.
    14  type StateTransformer struct {
    15  	// ConcreteCurrent and ConcreteDeposed are used to specialize the abstract
    16  	// resource instance nodes that this transformer will create.
    17  	//
    18  	// If either of these is nil, the objects of that type will be skipped and
    19  	// not added to the graph at all. It doesn't make sense to use this
    20  	// transformer without setting at least one of these, since that would
    21  	// skip everything and thus be a no-op.
    22  	ConcreteCurrent ConcreteResourceInstanceNodeFunc
    23  	ConcreteDeposed ConcreteResourceInstanceDeposedNodeFunc
    24  
    25  	State *states.State
    26  }
    27  
    28  func (t *StateTransformer) Transform(g *Graph) error {
    29  	if t.State == nil {
    30  		log.Printf("[TRACE] StateTransformer: state is nil, so nothing to do")
    31  		return nil
    32  	}
    33  
    34  	switch {
    35  	case t.ConcreteCurrent != nil && t.ConcreteDeposed != nil:
    36  		log.Printf("[TRACE] StateTransformer: creating nodes for both current and deposed instance objects")
    37  	case t.ConcreteCurrent != nil:
    38  		log.Printf("[TRACE] StateTransformer: creating nodes for current instance objects only")
    39  	case t.ConcreteDeposed != nil:
    40  		log.Printf("[TRACE] StateTransformer: creating nodes for deposed instance objects only")
    41  	default:
    42  		log.Printf("[TRACE] StateTransformer: pointless no-op call, creating no nodes at all")
    43  	}
    44  
    45  	for _, ms := range t.State.Modules {
    46  		for _, rs := range ms.Resources {
    47  			resourceAddr := rs.Addr
    48  
    49  			for key, is := range rs.Instances {
    50  				addr := resourceAddr.Instance(key)
    51  
    52  				if obj := is.Current; obj != nil && t.ConcreteCurrent != nil {
    53  					abstract := NewNodeAbstractResourceInstance(addr)
    54  					node := t.ConcreteCurrent(abstract)
    55  					g.Add(node)
    56  					log.Printf("[TRACE] StateTransformer: added %T for %s current object", node, addr)
    57  				}
    58  
    59  				if t.ConcreteDeposed != nil {
    60  					for dk := range is.Deposed {
    61  						abstract := NewNodeAbstractResourceInstance(addr)
    62  						node := t.ConcreteDeposed(abstract, dk)
    63  						g.Add(node)
    64  						log.Printf("[TRACE] StateTransformer: added %T for %s deposed object %s", node, addr, dk)
    65  					}
    66  				}
    67  			}
    68  		}
    69  	}
    70  
    71  	return nil
    72  }