github.com/r3labs/terraform@v0.8.4/terraform/transform_provider_old.go (about) 1 package terraform 2 3 import ( 4 "fmt" 5 6 "github.com/hashicorp/terraform/config" 7 "github.com/hashicorp/terraform/dag" 8 ) 9 10 // DisableProviderTransformer "disables" any providers that are only 11 // depended on by modules. 12 // 13 // NOTE: "old" = used by old graph builders, will be removed one day 14 type DisableProviderTransformerOld struct{} 15 16 func (t *DisableProviderTransformerOld) Transform(g *Graph) error { 17 // Since we're comparing against edges, we need to make sure we connect 18 g.ConnectDependents() 19 20 for _, v := range g.Vertices() { 21 // We only care about providers 22 pn, ok := v.(GraphNodeProvider) 23 if !ok || pn.ProviderName() == "" { 24 continue 25 } 26 27 // Go through all the up-edges (things that depend on this 28 // provider) and if any is not a module, then ignore this node. 29 nonModule := false 30 for _, sourceRaw := range g.UpEdges(v).List() { 31 source := sourceRaw.(dag.Vertex) 32 cn, ok := source.(graphNodeConfig) 33 if !ok { 34 nonModule = true 35 break 36 } 37 38 if cn.ConfigType() != GraphNodeConfigTypeModule { 39 nonModule = true 40 break 41 } 42 } 43 if nonModule { 44 // We found something that depends on this provider that 45 // isn't a module, so skip it. 46 continue 47 } 48 49 // Disable the provider by replacing it with a "disabled" provider 50 disabled := &graphNodeDisabledProvider{GraphNodeProvider: pn} 51 if !g.Replace(v, disabled) { 52 panic(fmt.Sprintf( 53 "vertex disappeared from under us: %s", 54 dag.VertexName(v))) 55 } 56 } 57 58 return nil 59 } 60 61 type graphNodeDisabledProvider struct { 62 GraphNodeProvider 63 } 64 65 // GraphNodeEvalable impl. 66 func (n *graphNodeDisabledProvider) EvalTree() EvalNode { 67 var resourceConfig *ResourceConfig 68 69 return &EvalOpFilter{ 70 Ops: []walkOperation{walkInput, walkValidate, walkRefresh, walkPlan, walkApply, walkDestroy}, 71 Node: &EvalSequence{ 72 Nodes: []EvalNode{ 73 &EvalInterpolate{ 74 Config: n.ProviderConfig(), 75 Output: &resourceConfig, 76 }, 77 &EvalBuildProviderConfig{ 78 Provider: n.ProviderName(), 79 Config: &resourceConfig, 80 Output: &resourceConfig, 81 }, 82 &EvalSetProviderConfig{ 83 Provider: n.ProviderName(), 84 Config: &resourceConfig, 85 }, 86 }, 87 }, 88 } 89 } 90 91 // GraphNodeFlattenable impl. 92 func (n *graphNodeDisabledProvider) Flatten(p []string) (dag.Vertex, error) { 93 return &graphNodeDisabledProviderFlat{ 94 graphNodeDisabledProvider: n, 95 PathValue: p, 96 }, nil 97 } 98 99 func (n *graphNodeDisabledProvider) Name() string { 100 return fmt.Sprintf("%s (disabled)", dag.VertexName(n.GraphNodeProvider)) 101 } 102 103 // GraphNodeDotter impl. 104 func (n *graphNodeDisabledProvider) DotNode(name string, opts *dag.DotOpts) *dag.DotNode { 105 return &dag.DotNode{ 106 Name: name, 107 Attrs: map[string]string{ 108 "label": n.Name(), 109 "shape": "diamond", 110 }, 111 } 112 } 113 114 // GraphNodeDotterOrigin impl. 115 func (n *graphNodeDisabledProvider) DotOrigin() bool { 116 return true 117 } 118 119 // GraphNodeDependable impl. 120 func (n *graphNodeDisabledProvider) DependableName() []string { 121 return []string{"provider." + n.ProviderName()} 122 } 123 124 // GraphNodeProvider impl. 125 func (n *graphNodeDisabledProvider) ProviderName() string { 126 return n.GraphNodeProvider.ProviderName() 127 } 128 129 // GraphNodeProvider impl. 130 func (n *graphNodeDisabledProvider) ProviderConfig() *config.RawConfig { 131 return n.GraphNodeProvider.ProviderConfig() 132 } 133 134 // Same as graphNodeDisabledProvider, but for flattening 135 type graphNodeDisabledProviderFlat struct { 136 *graphNodeDisabledProvider 137 138 PathValue []string 139 } 140 141 func (n *graphNodeDisabledProviderFlat) Name() string { 142 return fmt.Sprintf( 143 "%s.%s", modulePrefixStr(n.PathValue), n.graphNodeDisabledProvider.Name()) 144 } 145 146 func (n *graphNodeDisabledProviderFlat) Path() []string { 147 return n.PathValue 148 } 149 150 func (n *graphNodeDisabledProviderFlat) ProviderName() string { 151 return fmt.Sprintf( 152 "%s.%s", modulePrefixStr(n.PathValue), 153 n.graphNodeDisabledProvider.ProviderName()) 154 } 155 156 // GraphNodeDependable impl. 157 func (n *graphNodeDisabledProviderFlat) DependableName() []string { 158 return modulePrefixList( 159 n.graphNodeDisabledProvider.DependableName(), 160 modulePrefixStr(n.PathValue)) 161 } 162 163 func (n *graphNodeDisabledProviderFlat) DependentOn() []string { 164 var result []string 165 166 // If we're in a module, then depend on our parent's provider 167 if len(n.PathValue) > 1 { 168 prefix := modulePrefixStr(n.PathValue[:len(n.PathValue)-1]) 169 result = modulePrefixList( 170 n.graphNodeDisabledProvider.DependableName(), prefix) 171 } 172 173 return result 174 }