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