1 files changed, 129 insertions, 5 deletions

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
+}