1 files changed, 400 insertions, 174 deletions

diff --git a/vendor/github.com/hashicorp/terraform/terraform/transform_provider.go b/vendor/github.com/hashicorp/terraform/terraform/transform_provider.go
index b9695d5..c4772b4 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/transform_provider.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/transform_provider.go
@@ -1,19 +1,46 @@
 package terraform
 
 import (
+        "errors"
         "fmt"
         "log"
         "strings"
 
         "github.com/hashicorp/go-multierror"
+        "github.com/hashicorp/terraform/config"
+        "github.com/hashicorp/terraform/config/module"
         "github.com/hashicorp/terraform/dag"
 )
 
+func TransformProviders(providers []string, concrete ConcreteProviderNodeFunc, mod *module.Tree) GraphTransformer {
+        return GraphTransformMulti(
+                // Add providers from the config
+                &ProviderConfigTransformer{
+                        Module:    mod,
+                        Providers: providers,
+                        Concrete:  concrete,
+                },
+                // Add any remaining missing providers
+                &MissingProviderTransformer{
+                        Providers: providers,
+                        Concrete:  concrete,
+                },
+                // Connect the providers
+                &ProviderTransformer{},
+                // Remove unused providers and proxies
+                &PruneProviderTransformer{},
+                // Connect provider to their parent provider nodes
+                &ParentProviderTransformer{},
+        )
+}
+
 // GraphNodeProvider is an interface that nodes that can be a provider
-// must implement. The ProviderName returned is the name of the provider
-// they satisfy.
+// must implement.
+// ProviderName returns the name of the provider this satisfies.
+// Name returns the full name of the provider in the config.
 type GraphNodeProvider interface {
         ProviderName() string
+        Name() string
 }
 
 // GraphNodeCloseProvider is an interface that nodes that can be a close
@@ -25,9 +52,12 @@ type GraphNodeCloseProvider interface {
 
 // GraphNodeProviderConsumer is an interface that nodes that require
 // a provider must implement. ProvidedBy must return the name of the provider
-// to use.
+// to use. This may be a provider by type, type.alias or a fully resolved
+// provider name
 type GraphNodeProviderConsumer interface {
-        ProvidedBy() []string
+        ProvidedBy() string
+        // Set the resolved provider address for this resource.
+        SetProvider(string)
 }
 
 // ProviderTransformer is a GraphTransformer that maps resources to
@@ -41,18 +71,52 @@ func (t *ProviderTransformer) Transform(g *Graph) error {
         m := providerVertexMap(g)
         for _, v := range g.Vertices() {
                 if pv, ok := v.(GraphNodeProviderConsumer); ok {
-                        for _, p := range pv.ProvidedBy() {
-                                target := m[providerMapKey(p, pv)]
-                                if target == nil {
-                                        println(fmt.Sprintf("%#v\n\n%#v", m, providerMapKey(p, pv)))
-                                        err = multierror.Append(err, fmt.Errorf(
-                                                "%s: provider %s couldn't be found",
-                                                dag.VertexName(v), p))
-                                        continue
+                        p := pv.ProvidedBy()
+
+                        key := providerMapKey(p, pv)
+                        target := m[key]
+
+                        sp, ok := pv.(GraphNodeSubPath)
+                        if !ok && target == nil {
+                                // no target, and no path to walk up
+                                err = multierror.Append(err, fmt.Errorf(
+                                        "%s: provider %s couldn't be found",
+                                        dag.VertexName(v), p))
+                                break
+                        }
+
+                        // if we don't have a provider at this level, walk up the path looking for one
+                        for i := 1; target == nil; i++ {
+                                path := normalizeModulePath(sp.Path())
+                                if len(path) < i {
+                                        break
+                                }
+
+                                key = ResolveProviderName(p, path[:len(path)-i])
+                                target = m[key]
+                                if target != nil {
+                                        break
                                 }
+                        }
+
+                        if target == nil {
+                                err = multierror.Append(err, fmt.Errorf(
+                                        "%s: configuration for %s is not present; a provider configuration block is required for all operations",
+                                        dag.VertexName(v), p,
+                                ))
+                                break
+                        }
 
-                                g.Connect(dag.BasicEdge(v, target))
+                        // see if this in  an inherited provider
+                        if p, ok := target.(*graphNodeProxyProvider); ok {
+                                g.Remove(p)
+                                target = p.Target()
+                                key = target.(GraphNodeProvider).Name()
                         }
+
+                        log.Printf("[DEBUG] resource %s using provider %s", dag.VertexName(pv), key)
+                        pv.SetProvider(key)
+                        g.Connect(dag.BasicEdge(v, target))
                 }
         }
 
@@ -67,36 +131,32 @@ type CloseProviderTransformer struct{}
 
 func (t *CloseProviderTransformer) Transform(g *Graph) error {
         pm := providerVertexMap(g)
-        cpm := closeProviderVertexMap(g)
+        cpm := make(map[string]*graphNodeCloseProvider)
         var err error
-        for _, v := range g.Vertices() {
-                if pv, ok := v.(GraphNodeProviderConsumer); ok {
-                        for _, p := range pv.ProvidedBy() {
-                                key := p
-                                source := cpm[key]
-
-                                if source == nil {
-                                        // Create a new graphNodeCloseProvider and add it to the graph
-                                        source = &graphNodeCloseProvider{ProviderNameValue: p}
-                                        g.Add(source)
-
-                                        // Close node needs to depend on provider
-                                        provider, ok := pm[key]
-                                        if !ok {
-                                                err = multierror.Append(err, fmt.Errorf(
-                                                        "%s: provider %s couldn't be found for closing",
-                                                        dag.VertexName(v), p))
-                                                continue
-                                        }
-                                        g.Connect(dag.BasicEdge(source, provider))
-
-                                        // Make sure we also add the new graphNodeCloseProvider to the map
-                                        // so we don't create and add any duplicate graphNodeCloseProviders.
-                                        cpm[key] = source
-                                }
 
-                                // Close node depends on all nodes provided by the provider
-                                g.Connect(dag.BasicEdge(source, v))
+        for _, v := range pm {
+                p := v.(GraphNodeProvider)
+
+                // get the close provider of this type if we alread created it
+                closer := cpm[p.Name()]
+
+                if closer == nil {
+                        // create a closer for this provider type
+                        closer = &graphNodeCloseProvider{ProviderNameValue: p.Name()}
+                        g.Add(closer)
+                        cpm[p.Name()] = closer
+                }
+
+                // Close node depends on the provider itself
+                // this is added unconditionally, so it will connect to all instances
+                // of the provider. Extra edges will be removed by transitive
+                // reduction.
+                g.Connect(dag.BasicEdge(closer, p))
+
+                // connect all the provider's resources to the close node
+                for _, s := range g.UpEdges(p).List() {
+                        if _, ok := s.(GraphNodeProviderConsumer); ok {
+                                g.Connect(dag.BasicEdge(closer, s))
                         }
                 }
         }
@@ -104,18 +164,14 @@ func (t *CloseProviderTransformer) Transform(g *Graph) error {
         return err
 }
 
-// MissingProviderTransformer is a GraphTransformer that adds nodes
-// for missing providers into the graph. Specifically, it creates provider
-// configuration nodes for all the providers that we support. These are
-// pruned later during an optimization pass.
+// MissingProviderTransformer is a GraphTransformer that adds nodes for all
+// required providers into the graph. Specifically, it creates provider
+// configuration nodes for all the providers that we support. These are pruned
+// later during an optimization pass.
 type MissingProviderTransformer struct {
         // Providers is the list of providers we support.
         Providers []string
 
-        // AllowAny will not check that a provider is supported before adding
-        // it to the graph.
-        AllowAny bool
-
         // Concrete, if set, overrides how the providers are made.
         Concrete ConcreteProviderNodeFunc
 }
@@ -128,99 +184,57 @@ func (t *MissingProviderTransformer) Transform(g *Graph) error {
                 }
         }
 
-        // Create a set of our supported providers
-        supported := make(map[string]struct{}, len(t.Providers))
-        for _, v := range t.Providers {
-                supported[v] = struct{}{}
-        }
-
-        // Get the map of providers we already have in our graph
+        var err error
         m := providerVertexMap(g)
-
-        // Go through all the provider consumers and make sure we add
-        // that provider if it is missing. We use a for loop here instead
-        // of "range" since we'll modify check as we go to add more to check.
-        check := g.Vertices()
-        for i := 0; i < len(check); i++ {
-                v := check[i]
-
+        for _, v := range g.Vertices() {
                 pv, ok := v.(GraphNodeProviderConsumer)
                 if !ok {
                         continue
                 }
 
-                // If this node has a subpath, then we use that as a prefix
-                // into our map to check for an existing provider.
-                var path []string
-                if sp, ok := pv.(GraphNodeSubPath); ok {
-                        raw := normalizeModulePath(sp.Path())
-                        if len(raw) > len(rootModulePath) {
-                                path = raw
-                        }
-                }
+                p := pv.ProvidedBy()
+                // this may be the resolved provider from the state, so we need to get
+                // the base provider name.
+                parts := strings.SplitAfter(p, "provider.")
+                p = parts[len(parts)-1]
 
-                for _, p := range pv.ProvidedBy() {
-                        key := providerMapKey(p, pv)
-                        if _, ok := m[key]; ok {
-                                // This provider already exists as a configure node
-                                continue
-                        }
+                key := ResolveProviderName(p, nil)
+                provider := m[key]
 
-                        // If the provider has an alias in it, we just want the type
-                        ptype := p
-                        if idx := strings.IndexRune(p, '.'); idx != -1 {
-                                ptype = p[:idx]
-                        }
+                // we already have it
+                if provider != nil {
+                        continue
+                }
 
-                        if !t.AllowAny {
-                                if _, ok := supported[ptype]; !ok {
-                                        // If we don't support the provider type, skip it.
-                                        // Validation later will catch this as an error.
-                                        continue
-                                }
-                        }
+                // we don't implicitly create aliased providers
+                if strings.Contains(p, ".") {
+                        log.Println("[DEBUG] not adding missing provider alias:", p)
+                        continue
+                }
 
-                        // Add the missing provider node to the graph
-                        v := t.Concrete(&NodeAbstractProvider{
-                                NameValue: p,
-                                PathValue: path,
-                        }).(dag.Vertex)
-                        if len(path) > 0 {
-                                // We'll need the parent provider as well, so let's
-                                // add a dummy node to check to make sure that we add
-                                // that parent provider.
-                                check = append(check, &graphNodeProviderConsumerDummy{
-                                        ProviderValue: p,
-                                        PathValue:     path[:len(path)-1],
-                                })
-                        }
+                log.Println("[DEBUG] adding missing provider:", p)
 
-                        m[key] = g.Add(v)
-                }
+                // create the misisng top-level provider
+                provider = t.Concrete(&NodeAbstractProvider{
+                        NameValue: p,
+                }).(dag.Vertex)
+
+                m[key] = g.Add(provider)
         }
 
-        return nil
+        return err
 }
 
 // ParentProviderTransformer connects provider nodes to their parents.
 //
 // This works by finding nodes that are both GraphNodeProviders and
 // GraphNodeSubPath. It then connects the providers to their parent
-// path.
+// path. The parent provider is always at the root level.
 type ParentProviderTransformer struct{}
 
 func (t *ParentProviderTransformer) Transform(g *Graph) error {
-        // Make a mapping of path to dag.Vertex, where path is: "path.name"
-        m := make(map[string]dag.Vertex)
-
-        // Also create a map that maps a provider to its parent
-        parentMap := make(map[dag.Vertex]string)
-        for _, raw := range g.Vertices() {
-                // If it is the flat version, then make it the non-flat version.
-                // We eventually want to get rid of the flat version entirely so
-                // this is a stop-gap while it still exists.
-                var v dag.Vertex = raw
-
+        pm := providerVertexMap(g)
+        for _, v := range g.Vertices() {
                 // Only care about providers
                 pn, ok := v.(GraphNodeProvider)
                 if !ok || pn.ProviderName() == "" {
@@ -228,53 +242,48 @@ func (t *ParentProviderTransformer) Transform(g *Graph) error {
                 }
 
                 // Also require a subpath, if there is no subpath then we
-                // just totally ignore it. The expectation of this transform is
-                // that it is used with a graph builder that is already flattened.
-                var path []string
-                if pn, ok := raw.(GraphNodeSubPath); ok {
-                        path = pn.Path()
-                }
-                path = normalizeModulePath(path)
-
-                // Build the key with path.name i.e. "child.subchild.aws"
-                key := fmt.Sprintf("%s.%s", strings.Join(path, "."), pn.ProviderName())
-                m[key] = raw
-
-                // Determine the parent if we're non-root. This is length 1 since
-                // the 0 index should be "root" since we normalize above.
-                if len(path) > 1 {
-                        path = path[:len(path)-1]
-                        key := fmt.Sprintf("%s.%s", strings.Join(path, "."), pn.ProviderName())
-                        parentMap[raw] = key
+                // can't have a parent.
+                if pn, ok := v.(GraphNodeSubPath); ok {
+                        if len(normalizeModulePath(pn.Path())) <= 1 {
+                                continue
+                        }
                 }
-        }
 
-        // Connect!
-        for v, key := range parentMap {
-                if parent, ok := m[key]; ok {
+                // this provider may be disabled, but we can only get it's name from
+                // the ProviderName string
+                name := ResolveProviderName(strings.SplitN(pn.ProviderName(), " ", 2)[0], nil)
+                parent := pm[name]
+                if parent != nil {
                         g.Connect(dag.BasicEdge(v, parent))
                 }
-        }
 
+        }
         return nil
 }
 
-// PruneProviderTransformer is a GraphTransformer that prunes all the
-// providers that aren't needed from the graph. A provider is unneeded if
-// no resource or module is using that provider.
+// PruneProviderTransformer removes any providers that are not actually used by
+// anything, and provider proxies. This avoids the provider being initialized
+// and configured.  This both saves resources but also avoids errors since
+// configuration may imply initialization which may require auth.
 type PruneProviderTransformer struct{}
 
 func (t *PruneProviderTransformer) Transform(g *Graph) error {
         for _, v := range g.Vertices() {
-                // We only care about the providers
-                if pn, ok := v.(GraphNodeProvider); !ok || pn.ProviderName() == "" {
+                // We only care about providers
+                pn, ok := v.(GraphNodeProvider)
+                if !ok || pn.ProviderName() == "" {
                         continue
                 }
-                // Does anything depend on this? If not, then prune it.
-                if s := g.UpEdges(v); s.Len() == 0 {
-                        if nv, ok := v.(dag.NamedVertex); ok {
-                                log.Printf("[DEBUG] Pruning provider with no dependencies: %s", nv.Name())
-                        }
+
+                // ProxyProviders will have up edges, but we're now done with them in the graph
+                if _, ok := v.(*graphNodeProxyProvider); ok {
+                        log.Printf("[DEBUG] pruning proxy provider %s", dag.VertexName(v))
+                        g.Remove(v)
+                }
+
+                // Remove providers with no dependencies.
+                if g.UpEdges(v).Len() == 0 {
+                        log.Printf("[DEBUG] pruning unused provider %s", dag.VertexName(v))
                         g.Remove(v)
                 }
         }
@@ -285,23 +294,26 @@ func (t *PruneProviderTransformer) Transform(g *Graph) error {
 // providerMapKey is a helper that gives us the key to use for the
 // maps returned by things such as providerVertexMap.
 func providerMapKey(k string, v dag.Vertex) string {
-        pathPrefix := ""
-        if sp, ok := v.(GraphNodeSubPath); ok {
-                raw := normalizeModulePath(sp.Path())
-                if len(raw) > len(rootModulePath) {
-                        pathPrefix = modulePrefixStr(raw) + "."
-                }
+        if strings.Contains(k, "provider.") {
+                // this is already resolved
+                return k
         }
 
-        return pathPrefix + k
+        // we create a dummy provider to
+        var path []string
+        if sp, ok := v.(GraphNodeSubPath); ok {
+                path = normalizeModulePath(sp.Path())
+        }
+        return ResolveProviderName(k, path)
 }
 
 func providerVertexMap(g *Graph) map[string]dag.Vertex {
         m := make(map[string]dag.Vertex)
         for _, v := range g.Vertices() {
                 if pv, ok := v.(GraphNodeProvider); ok {
-                        key := providerMapKey(pv.ProviderName(), v)
-                        m[key] = v
+                        // TODO:  The Name may have meta info, like " (disabled)"
+                        name := strings.SplitN(pv.Name(), " ", 2)[0]
+                        m[name] = v
                 }
         }
 
@@ -324,7 +336,7 @@ type graphNodeCloseProvider struct {
 }
 
 func (n *graphNodeCloseProvider) Name() string {
-        return fmt.Sprintf("provider.%s (close)", n.ProviderNameValue)
+        return n.ProviderNameValue + " (close)"
 }
 
 // GraphNodeEvalable impl.
@@ -362,19 +374,233 @@ func (n *graphNodeCloseProvider) RemoveIfNotTargeted() bool {
         return true
 }
 
-// graphNodeProviderConsumerDummy is a struct that never enters the real
-// graph (though it could to no ill effect). It implements
-// GraphNodeProviderConsumer and GraphNodeSubpath as a way to force
-// certain transformations.
-type graphNodeProviderConsumerDummy struct {
-        ProviderValue string
-        PathValue     []string
+// graphNodeProxyProvider is a GraphNodeProvider implementation that is used to
+// store the name and value of a provider node for inheritance between modules.
+// These nodes are only used to store the data while loading the provider
+// configurations, and are removed after all the resources have been connected
+// to their providers.
+type graphNodeProxyProvider struct {
+        nameValue string
+        path      []string
+        target    GraphNodeProvider
+}
+
+func (n *graphNodeProxyProvider) ProviderName() string {
+        return n.Target().ProviderName()
+}
+
+func (n *graphNodeProxyProvider) Name() string {
+        return ResolveProviderName(n.nameValue, n.path)
+}
+
+// find the concrete provider instance
+func (n *graphNodeProxyProvider) Target() GraphNodeProvider {
+        switch t := n.target.(type) {
+        case *graphNodeProxyProvider:
+                return t.Target()
+        default:
+                return n.target
+        }
+}
+
+// ProviderConfigTransformer adds all provider nodes from the configuration and
+// attaches the configs.
+type ProviderConfigTransformer struct {
+        Providers []string
+        Concrete  ConcreteProviderNodeFunc
+
+        // each provider node is stored here so that the proxy nodes can look up
+        // their targets by name.
+        providers map[string]GraphNodeProvider
+        // record providers that can be overriden with a proxy
+        proxiable map[string]bool
+
+        // Module is the module to add resources from.
+        Module *module.Tree
 }
 
-func (n *graphNodeProviderConsumerDummy) Path() []string {
-        return n.PathValue
+func (t *ProviderConfigTransformer) Transform(g *Graph) error {
+        // If no module is given, we don't do anything
+        if t.Module == nil {
+                return nil
+        }
+
+        // If the module isn't loaded, that is simply an error
+        if !t.Module.Loaded() {
+                return errors.New("module must be loaded for ProviderConfigTransformer")
+        }
+
+        t.providers = make(map[string]GraphNodeProvider)
+        t.proxiable = make(map[string]bool)
+
+        // Start the transformation process
+        if err := t.transform(g, t.Module); err != nil {
+                return err
+        }
+
+        // finally attach the configs to the new nodes
+        return t.attachProviderConfigs(g)
 }
 
-func (n *graphNodeProviderConsumerDummy) ProvidedBy() []string {
-        return []string{n.ProviderValue}
+func (t *ProviderConfigTransformer) transform(g *Graph, m *module.Tree) error {
+        // If no config, do nothing
+        if m == nil {
+                return nil
+        }
+
+        // Add our resources
+        if err := t.transformSingle(g, m); err != nil {
+                return err
+        }
+
+        // Transform all the children.
+        for _, c := range m.Children() {
+                if err := t.transform(g, c); err != nil {
+                        return err
+                }
+        }
+        return nil
+}
+
+func (t *ProviderConfigTransformer) transformSingle(g *Graph, m *module.Tree) error {
+        log.Printf("[TRACE] ProviderConfigTransformer: Starting for path: %v", m.Path())
+
+        // Get the configuration for this module
+        conf := m.Config()
+
+        // Build the path we're at
+        path := m.Path()
+        if len(path) > 0 {
+                path = append([]string{RootModuleName}, path...)
+        }
+
+        // add all providers from the configuration
+        for _, p := range conf.ProviderConfigs {
+                name := p.Name
+                if p.Alias != "" {
+                        name += "." + p.Alias
+                }
+
+                v := t.Concrete(&NodeAbstractProvider{
+                        NameValue: name,
+                        PathValue: path,
+                })
+
+                // Add it to the graph
+                g.Add(v)
+                fullName := ResolveProviderName(name, path)
+                t.providers[fullName] = v.(GraphNodeProvider)
+                t.proxiable[fullName] = len(p.RawConfig.RawMap()) == 0
+        }
+
+        // Now replace the provider nodes with proxy nodes if a provider was being
+        // passed in, and create implicit proxies if there was no config. Any extra
+        // proxies will be removed in the prune step.
+        return t.addProxyProviders(g, m)
+}
+
+func (t *ProviderConfigTransformer) addProxyProviders(g *Graph, m *module.Tree) error {
+        path := m.Path()
+
+        // can't add proxies at the root
+        if len(path) == 0 {
+                return nil
+        }
+
+        parentPath := path[:len(path)-1]
+        parent := t.Module.Child(parentPath)
+        if parent == nil {
+                return nil
+        }
+
+        var parentCfg *config.Module
+        for _, mod := range parent.Config().Modules {
+                if mod.Name == m.Name() {
+                        parentCfg = mod
+                        break
+                }
+        }
+
+        if parentCfg == nil {
+                // this can't really happen during normal execution.
+                return fmt.Errorf("parent module config not found for %s", m.Name())
+        }
+
+        // Go through all the providers the parent is passing in, and add proxies to
+        // the parent provider nodes.
+        for name, parentName := range parentCfg.Providers {
+                fullName := ResolveProviderName(name, path)
+                fullParentName := ResolveProviderName(parentName, parentPath)
+
+                parentProvider := t.providers[fullParentName]
+
+                if parentProvider == nil {
+                        return fmt.Errorf("missing provider %s", fullParentName)
+                }
+
+                proxy := &graphNodeProxyProvider{
+                        nameValue: name,
+                        path:      path,
+                        target:    parentProvider,
+                }
+
+                concreteProvider := t.providers[fullName]
+
+                // replace the concrete node with the provider passed in
+                if concreteProvider != nil && t.proxiable[fullName] {
+                        g.Replace(concreteProvider, proxy)
+                        t.providers[fullName] = proxy
+                        continue
+                }
+
+                // aliased providers can't be implicitly passed in
+                if strings.Contains(name, ".") {
+                        continue
+                }
+
+                // There was no concrete provider, so add this as an implicit provider.
+                // The extra proxy will be pruned later if it's unused.
+                g.Add(proxy)
+                t.providers[fullName] = proxy
+        }
+        return nil
+}
+
+func (t *ProviderConfigTransformer) attachProviderConfigs(g *Graph) error {
+        for _, v := range g.Vertices() {
+                // Only care about GraphNodeAttachProvider implementations
+                apn, ok := v.(GraphNodeAttachProvider)
+                if !ok {
+                        continue
+                }
+
+                // Determine what we're looking for
+                path := normalizeModulePath(apn.Path())[1:]
+                name := apn.ProviderName()
+                log.Printf("[TRACE] Attach provider request: %#v %s", path, name)
+
+                // Get the configuration.
+                tree := t.Module.Child(path)
+                if tree == nil {
+                        continue
+                }
+
+                // Go through the provider configs to find the matching config
+                for _, p := range tree.Config().ProviderConfigs {
+                        // Build the name, which is "name.alias" if an alias exists
+                        current := p.Name
+                        if p.Alias != "" {
+                                current += "." + p.Alias
+                        }
+
+                        // If the configs match then attach!
+                        if current == name {
+                                log.Printf("[TRACE] Attaching provider config: %#v", p)
+                                apn.AttachProvider(p)
+                                break
+                        }
+                }
+        }
+
+        return nil
 }