3 files changed, 202 insertions, 7 deletions

diff --git a/vendor/github.com/hashicorp/terraform/plugin/discovery/find.go b/vendor/github.com/hashicorp/terraform/plugin/discovery/find.go
index f5bc4c1..f053312 100644
--- a/vendor/github.com/hashicorp/terraform/plugin/discovery/find.go
+++ b/vendor/github.com/hashicorp/terraform/plugin/discovery/find.go
@@ -3,6 +3,7 @@ package discovery
 import (
         "io/ioutil"
         "log"
+        "os"
         "path/filepath"
         "strings"
 )
@@ -59,7 +60,6 @@ func findPluginPaths(kind string, dirs []string) []string {
                         fullName := item.Name()
 
                         if !strings.HasPrefix(fullName, prefix) {
-                                log.Printf("[DEBUG] skipping %q, not a %s", fullName, kind)
                                 continue
                         }
 
@@ -71,6 +71,12 @@ func findPluginPaths(kind string, dirs []string) []string {
                                         continue
                                 }
 
+                                // Check that the file we found is usable
+                                if !pathIsFile(absPath) {
+                                        log.Printf("[ERROR] ignoring non-file %s", absPath)
+                                        continue
+                                }
+
                                 log.Printf("[DEBUG] found %s %q", kind, fullName)
                                 ret = append(ret, filepath.Clean(absPath))
                                 continue
@@ -83,7 +89,13 @@ func findPluginPaths(kind string, dirs []string) []string {
                                 continue
                         }
 
-                        log.Printf("[WARNING] found legacy %s %q", kind, fullName)
+                        // Check that the file we found is usable
+                        if !pathIsFile(absPath) {
+                                log.Printf("[ERROR] ignoring non-file %s", absPath)
+                                continue
+                        }
+
+                        log.Printf("[WARN] found legacy %s %q", kind, fullName)
 
                         ret = append(ret, filepath.Clean(absPath))
                 }
@@ -92,6 +104,17 @@ func findPluginPaths(kind string, dirs []string) []string {
         return ret
 }
 
+// Returns true if and only if the given path refers to a file or a symlink
+// to a file.
+func pathIsFile(path string) bool {
+        info, err := os.Stat(path)
+        if err != nil {
+                return false
+        }
+
+        return !info.IsDir()
+}
+
 // ResolvePluginPaths takes a list of paths to plugin executables (as returned
 // by e.g. FindPluginPaths) and produces a PluginMetaSet describing the
 // referenced plugins.
diff --git a/vendor/github.com/hashicorp/terraform/plugin/discovery/get.go b/vendor/github.com/hashicorp/terraform/plugin/discovery/get.go
index 241b5cb..815640f 100644
--- a/vendor/github.com/hashicorp/terraform/plugin/discovery/get.go
+++ b/vendor/github.com/hashicorp/terraform/plugin/discovery/get.go
@@ -3,19 +3,22 @@ package discovery
 import (
         "errors"
         "fmt"
+        "io"
         "io/ioutil"
         "log"
         "net/http"
         "os"
+        "path/filepath"
         "runtime"
         "strconv"
         "strings"
 
         "golang.org/x/net/html"
 
-        cleanhttp "github.com/hashicorp/go-cleanhttp"
         getter "github.com/hashicorp/go-getter"
         multierror "github.com/hashicorp/go-multierror"
+        "github.com/hashicorp/terraform/httpclient"
+        "github.com/mitchellh/cli"
 )
 
 // Releases are located by parsing the html listing from releases.hashicorp.com.
@@ -30,7 +33,19 @@ const protocolVersionHeader = "x-terraform-protocol-version"
 
 var releaseHost = "https://releases.hashicorp.com"
 
-var httpClient = cleanhttp.DefaultClient()
+var httpClient *http.Client
+
+func init() {
+        httpClient = httpclient.New()
+
+        httpGetter := &getter.HttpGetter{
+                Client: httpClient,
+                Netrc:  true,
+        }
+
+        getter.Getters["http"] = httpGetter
+        getter.Getters["https"] = httpGetter
+}
 
 // An Installer maintains a local cache of plugins by downloading plugins
 // from an online repository.
@@ -47,6 +62,10 @@ type Installer interface {
 type ProviderInstaller struct {
         Dir string
 
+        // Cache is used to access and update a local cache of plugins if non-nil.
+        // Can be nil to disable caching.
+        Cache PluginCache
+
         PluginProtocolVersion uint
 
         // OS and Arch specify the OS and architecture that should be used when
@@ -58,6 +77,8 @@ type ProviderInstaller struct {
 
         // Skip checksum and signature verification
         SkipVerify bool
+
+        Ui cli.Ui // Ui for output
 }
 
 // Get is part of an implementation of type Installer, and attempts to download
@@ -98,6 +119,12 @@ func (i *ProviderInstaller) Get(provider string, req Constraints) (PluginMeta, e
         // sort them newest to oldest
         Versions(versions).Sort()
 
+        // Ensure that our installation directory exists
+        err = os.MkdirAll(i.Dir, os.ModePerm)
+        if err != nil {
+                return PluginMeta{}, fmt.Errorf("failed to create plugin dir %s: %s", i.Dir, err)
+        }
+
         // take the first matching plugin we find
         for _, v := range versions {
                 url := i.providerURL(provider, v.String())
@@ -116,8 +143,9 @@ func (i *ProviderInstaller) Get(provider string, req Constraints) (PluginMeta, e
 
                 log.Printf("[DEBUG] fetching provider info for %s version %s", provider, v)
                 if checkPlugin(url, i.PluginProtocolVersion) {
-                        log.Printf("[DEBUG] getting provider %q version %q at %s", provider, v, url)
-                        err := getter.Get(i.Dir, url)
+                        i.Ui.Info(fmt.Sprintf("- Downloading plugin for provider %q (%s)...", provider, v.String()))
+                        log.Printf("[DEBUG] getting provider %q version %q", provider, v)
+                        err := i.install(provider, v, url)
                         if err != nil {
                                 return PluginMeta{}, err
                         }
@@ -164,6 +192,98 @@ func (i *ProviderInstaller) Get(provider string, req Constraints) (PluginMeta, e
         return PluginMeta{}, ErrorNoVersionCompatible
 }
 
+func (i *ProviderInstaller) install(provider string, version Version, url string) error {
+        if i.Cache != nil {
+                log.Printf("[DEBUG] looking for provider %s %s in plugin cache", provider, version)
+                cached := i.Cache.CachedPluginPath("provider", provider, version)
+                if cached == "" {
+                        log.Printf("[DEBUG] %s %s not yet in cache, so downloading %s", provider, version, url)
+                        err := getter.Get(i.Cache.InstallDir(), url)
+                        if err != nil {
+                                return err
+                        }
+                        // should now be in cache
+                        cached = i.Cache.CachedPluginPath("provider", provider, version)
+                        if cached == "" {
+                                // should never happen if the getter is behaving properly
+                                // and the plugins are packaged properly.
+                                return fmt.Errorf("failed to find downloaded plugin in cache %s", i.Cache.InstallDir())
+                        }
+                }
+
+                // Link or copy the cached binary into our install dir so the
+                // normal resolution machinery can find it.
+                filename := filepath.Base(cached)
+                targetPath := filepath.Join(i.Dir, filename)
+
+                log.Printf("[DEBUG] installing %s %s to %s from local cache %s", provider, version, targetPath, cached)
+
+                // Delete if we can. If there's nothing there already then no harm done.
+                // This is important because we can't create a link if there's
+                // already a file of the same name present.
+                // (any other error here we'll catch below when we try to write here)
+                os.Remove(targetPath)
+
+                // We don't attempt linking on Windows because links are not
+                // comprehensively supported by all tools/apps in Windows and
+                // so we choose to be conservative to avoid creating any
+                // weird issues for Windows users.
+                linkErr := errors.New("link not supported for Windows") // placeholder error, never actually returned
+                if runtime.GOOS != "windows" {
+                        // Try hard linking first. Hard links are preferable because this
+                        // creates a self-contained directory that doesn't depend on the
+                        // cache after install.
+                        linkErr = os.Link(cached, targetPath)
+
+                        // If that failed, try a symlink. This _does_ depend on the cache
+                        // after install, so the user must manage the cache more carefully
+                        // in this case, but avoids creating redundant copies of the
+                        // plugins on disk.
+                        if linkErr != nil {
+                                linkErr = os.Symlink(cached, targetPath)
+                        }
+                }
+
+                // If we still have an error then we'll try a copy as a fallback.
+                // In this case either the OS is Windows or the target filesystem
+                // can't support symlinks.
+                if linkErr != nil {
+                        srcFile, err := os.Open(cached)
+                        if err != nil {
+                                return fmt.Errorf("failed to open cached plugin %s: %s", cached, err)
+                        }
+                        defer srcFile.Close()
+
+                        destFile, err := os.OpenFile(targetPath, os.O_TRUNC|os.O_CREATE|os.O_WRONLY, os.ModePerm)
+                        if err != nil {
+                                return fmt.Errorf("failed to create %s: %s", targetPath, err)
+                        }
+
+                        _, err = io.Copy(destFile, srcFile)
+                        if err != nil {
+                                destFile.Close()
+                                return fmt.Errorf("failed to copy cached plugin from %s to %s: %s", cached, targetPath, err)
+                        }
+
+                        err = destFile.Close()
+                        if err != nil {
+                                return fmt.Errorf("error creating %s: %s", targetPath, err)
+                        }
+                }
+
+                // One way or another, by the time we get here we should have either
+                // a link or a copy of the cached plugin within i.Dir, as expected.
+        } else {
+                log.Printf("[DEBUG] plugin cache is disabled, so downloading %s %s from %s", provider, version, url)
+                err := getter.Get(i.Dir, url)
+                if err != nil {
+                        return err
+                }
+        }
+
+        return nil
+}
+
 func (i *ProviderInstaller) PurgeUnused(used map[string]PluginMeta) (PluginMetaSet, error) {
         purge := make(PluginMetaSet)
 
@@ -261,7 +381,7 @@ func checkPlugin(url string, pluginProtocolVersion uint) bool {
         if proto == "" {
                 // The header isn't present, but we don't make this error fatal since
                 // the latest version will probably work.
-                log.Printf("[WARNING] missing %s from: %s", protocolVersionHeader, url)
+                log.Printf("[WARN] missing %s from: %s", protocolVersionHeader, url)
                 return true
         }
 
@@ -422,3 +542,7 @@ func getFile(url string) ([]byte, error) {
         }
         return data, nil
 }
+
+func GetReleaseHost() string {
+        return releaseHost
+}
diff --git a/vendor/github.com/hashicorp/terraform/plugin/discovery/get_cache.go b/vendor/github.com/hashicorp/terraform/plugin/discovery/get_cache.go
new file mode 100644
index 0000000..1a10042
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/plugin/discovery/get_cache.go
@@ -0,0 +1,48 @@
+package discovery
+
+// PluginCache is an interface implemented by objects that are able to maintain
+// a cache of plugins.
+type PluginCache interface {
+        // CachedPluginPath returns a path where the requested plugin is already
+        // cached, or an empty string if the requested plugin is not yet cached.
+        CachedPluginPath(kind string, name string, version Version) string
+
+        // InstallDir returns the directory that new plugins should be installed into
+        // in order to populate the cache. This directory should be used as the
+        // first argument to getter.Get when downloading plugins with go-getter.
+        //
+        // After installing into this directory, use CachedPluginPath to obtain the
+        // path where the plugin was installed.
+        InstallDir() string
+}
+
+// NewLocalPluginCache returns a PluginCache that caches plugins in a
+// given local directory.
+func NewLocalPluginCache(dir string) PluginCache {
+        return &pluginCache{
+                Dir: dir,
+        }
+}
+
+type pluginCache struct {
+        Dir string
+}
+
+func (c *pluginCache) CachedPluginPath(kind string, name string, version Version) string {
+        allPlugins := FindPlugins(kind, []string{c.Dir})
+        plugins := allPlugins.WithName(name).WithVersion(version)
+
+        if plugins.Count() == 0 {
+                // nothing cached
+                return ""
+        }
+
+        // There should generally be only one plugin here; if there's more than
+        // one match for some reason then we'll just choose one arbitrarily.
+        plugin := plugins.Newest()
+        return plugin.Path
+}
+
+func (c *pluginCache) InstallDir() string {
+        return c.Dir
+}