6 files changed, 367 insertions, 12 deletions

diff --git a/vendor/github.com/hashicorp/terraform/registry/client.go b/vendor/github.com/hashicorp/terraform/registry/client.go
index a18e6b8..93424d1 100644
--- a/vendor/github.com/hashicorp/terraform/registry/client.go
+++ b/vendor/github.com/hashicorp/terraform/registry/client.go
@@ -20,10 +20,11 @@ import (
 )
 
 const (
-        xTerraformGet     = "X-Terraform-Get"
-        xTerraformVersion = "X-Terraform-Version"
-        requestTimeout    = 10 * time.Second
-        serviceID         = "modules.v1"
+        xTerraformGet      = "X-Terraform-Get"
+        xTerraformVersion  = "X-Terraform-Version"
+        requestTimeout     = 10 * time.Second
+        modulesServiceID   = "modules.v1"
+        providersServiceID = "providers.v1"
 )
 
 var tfVersion = version.String()
@@ -58,10 +59,10 @@ func NewClient(services *disco.Disco, client *http.Client) *Client {
 }
 
 // Discover queries the host, and returns the url for the registry.
-func (c *Client) Discover(host svchost.Hostname) (*url.URL, error) {
+func (c *Client) Discover(host svchost.Hostname, serviceID string) (*url.URL, error) {
         service, err := c.services.DiscoverServiceURL(host, serviceID)
         if err != nil {
-                return nil, err
+                return nil, &ServiceUnreachableError{err}
         }
         if !strings.HasSuffix(service.Path, "/") {
                 service.Path += "/"
@@ -69,14 +70,14 @@ func (c *Client) Discover(host svchost.Hostname) (*url.URL, error) {
         return service, nil
 }
 
-// Versions queries the registry for a module, and returns the available versions.
-func (c *Client) Versions(module *regsrc.Module) (*response.ModuleVersions, error) {
+// ModuleVersions queries the registry for a module, and returns the available versions.
+func (c *Client) ModuleVersions(module *regsrc.Module) (*response.ModuleVersions, error) {
         host, err := module.SvcHost()
         if err != nil {
                 return nil, err
         }
 
-        service, err := c.Discover(host)
+        service, err := c.Discover(host, modulesServiceID)
         if err != nil {
                 return nil, err
         }
@@ -141,15 +142,15 @@ func (c *Client) addRequestCreds(host svchost.Hostname, req *http.Request) {
         }
 }
 
-// Location find the download location for a specific version module.
+// ModuleLocation find the download location for a specific version module.
 // This returns a string, because the final location may contain special go-getter syntax.
-func (c *Client) Location(module *regsrc.Module, version string) (string, error) {
+func (c *Client) ModuleLocation(module *regsrc.Module, version string) (string, error) {
         host, err := module.SvcHost()
         if err != nil {
                 return "", err
         }
 
-        service, err := c.Discover(host)
+        service, err := c.Discover(host, modulesServiceID)
         if err != nil {
                 return "", err
         }
@@ -225,3 +226,118 @@ func (c *Client) Location(module *regsrc.Module, version string) (string, error)
 
         return location, nil
 }
+
+// TerraformProviderVersions queries the registry for a provider, and returns the available versions.
+func (c *Client) TerraformProviderVersions(provider *regsrc.TerraformProvider) (*response.TerraformProviderVersions, error) {
+        host, err := provider.SvcHost()
+        if err != nil {
+                return nil, err
+        }
+
+        service, err := c.Discover(host, providersServiceID)
+        if err != nil {
+                return nil, err
+        }
+
+        p, err := url.Parse(path.Join(provider.TerraformProvider(), "versions"))
+        if err != nil {
+                return nil, err
+        }
+
+        service = service.ResolveReference(p)
+
+        log.Printf("[DEBUG] fetching provider versions from %q", service)
+
+        req, err := http.NewRequest("GET", service.String(), nil)
+        if err != nil {
+                return nil, err
+        }
+
+        c.addRequestCreds(host, req)
+        req.Header.Set(xTerraformVersion, tfVersion)
+
+        resp, err := c.client.Do(req)
+        if err != nil {
+                return nil, err
+        }
+        defer resp.Body.Close()
+
+        switch resp.StatusCode {
+        case http.StatusOK:
+                // OK
+        case http.StatusNotFound:
+                return nil, &errProviderNotFound{addr: provider}
+        default:
+                return nil, fmt.Errorf("error looking up provider versions: %s", resp.Status)
+        }
+
+        var versions response.TerraformProviderVersions
+
+        dec := json.NewDecoder(resp.Body)
+        if err := dec.Decode(&versions); err != nil {
+                return nil, err
+        }
+
+        return &versions, nil
+}
+
+// TerraformProviderLocation queries the registry for a provider download metadata
+func (c *Client) TerraformProviderLocation(provider *regsrc.TerraformProvider, version string) (*response.TerraformProviderPlatformLocation, error) {
+        host, err := provider.SvcHost()
+        if err != nil {
+                return nil, err
+        }
+
+        service, err := c.Discover(host, providersServiceID)
+        if err != nil {
+                return nil, err
+        }
+
+        p, err := url.Parse(path.Join(
+                provider.TerraformProvider(),
+                version,
+                "download",
+                provider.OS,
+                provider.Arch,
+        ))
+        if err != nil {
+                return nil, err
+        }
+
+        service = service.ResolveReference(p)
+
+        log.Printf("[DEBUG] fetching provider location from %q", service)
+
+        req, err := http.NewRequest("GET", service.String(), nil)
+        if err != nil {
+                return nil, err
+        }
+
+        c.addRequestCreds(host, req)
+        req.Header.Set(xTerraformVersion, tfVersion)
+
+        resp, err := c.client.Do(req)
+        if err != nil {
+                return nil, err
+        }
+        defer resp.Body.Close()
+
+        var loc response.TerraformProviderPlatformLocation
+
+        dec := json.NewDecoder(resp.Body)
+        if err := dec.Decode(&loc); err != nil {
+                return nil, err
+        }
+
+        switch resp.StatusCode {
+        case http.StatusOK, http.StatusNoContent:
+                // OK
+        case http.StatusNotFound:
+                return nil, fmt.Errorf("provider %q version %q not found", provider.TerraformProvider(), version)
+        default:
+                // anything else is an error:
+                return nil, fmt.Errorf("error getting download location for %q: %s", provider.TerraformProvider(), resp.Status)
+        }
+
+        return &loc, nil
+}
diff --git a/vendor/github.com/hashicorp/terraform/registry/errors.go b/vendor/github.com/hashicorp/terraform/registry/errors.go
index b8dcd31..5a6a31b 100644
--- a/vendor/github.com/hashicorp/terraform/registry/errors.go
+++ b/vendor/github.com/hashicorp/terraform/registry/errors.go
@@ -4,6 +4,7 @@ import (
         "fmt"
 
         "github.com/hashicorp/terraform/registry/regsrc"
+        "github.com/hashicorp/terraform/svchost/disco"
 )
 
 type errModuleNotFound struct {
@@ -21,3 +22,42 @@ func IsModuleNotFound(err error) bool {
         _, ok := err.(*errModuleNotFound)
         return ok
 }
+
+type errProviderNotFound struct {
+        addr *regsrc.TerraformProvider
+}
+
+func (e *errProviderNotFound) Error() string {
+        return fmt.Sprintf("provider %s not found", e.addr)
+}
+
+// IsProviderNotFound returns true only if the given error is a "provider not found"
+// error. This allows callers to recognize this particular error condition
+// as distinct from operational errors such as poor network connectivity.
+func IsProviderNotFound(err error) bool {
+        _, ok := err.(*errProviderNotFound)
+        return ok
+}
+
+// IsServiceNotProvided returns true only if the given error is a "service not provided"
+// error. This allows callers to recognize this particular error condition
+// as distinct from operational errors such as poor network connectivity.
+func IsServiceNotProvided(err error) bool {
+        _, ok := err.(*disco.ErrServiceNotProvided)
+        return ok
+}
+
+// ServiceUnreachableError Registry service is unreachable
+type ServiceUnreachableError struct {
+        err error
+}
+
+func (e *ServiceUnreachableError) Error() string {
+        return e.err.Error()
+}
+
+// IsServiceUnreachable returns true if the registry/discovery service was unreachable
+func IsServiceUnreachable(err error) bool {
+        _, ok := err.(*ServiceUnreachableError)
+        return ok
+}
diff --git a/vendor/github.com/hashicorp/terraform/registry/regsrc/terraform_provider.go b/vendor/github.com/hashicorp/terraform/registry/regsrc/terraform_provider.go
new file mode 100644
index 0000000..58dedee
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/registry/regsrc/terraform_provider.go
@@ -0,0 +1,60 @@
+package regsrc
+
+import (
+        "fmt"
+        "runtime"
+        "strings"
+
+        "github.com/hashicorp/terraform/svchost"
+)
+
+var (
+        // DefaultProviderNamespace represents the namespace for canonical
+        // HashiCorp-controlled providers.
+        DefaultProviderNamespace = "-"
+)
+
+// TerraformProvider describes a Terraform Registry Provider source.
+type TerraformProvider struct {
+        RawHost      *FriendlyHost
+        RawNamespace string
+        RawName      string
+        OS           string
+        Arch         string
+}
+
+// NewTerraformProvider constructs a new provider source.
+func NewTerraformProvider(name, os, arch string) *TerraformProvider {
+        if os == "" {
+                os = runtime.GOOS
+        }
+        if arch == "" {
+                arch = runtime.GOARCH
+        }
+
+        // separate namespace if included
+        namespace := DefaultProviderNamespace
+        if names := strings.SplitN(name, "/", 2); len(names) == 2 {
+                namespace, name = names[0], names[1]
+        }
+        p := &TerraformProvider{
+                RawHost:      PublicRegistryHost,
+                RawNamespace: namespace,
+                RawName:      name,
+                OS:           os,
+                Arch:         arch,
+        }
+
+        return p
+}
+
+// Provider returns just the registry ID of the provider
+func (p *TerraformProvider) TerraformProvider() string {
+        return fmt.Sprintf("%s/%s", p.RawNamespace, p.RawName)
+}
+
+// SvcHost returns the svchost.Hostname for this provider. The
+// default PublicRegistryHost is returned.
+func (p *TerraformProvider) SvcHost() (svchost.Hostname, error) {
+        return svchost.ForComparison(PublicRegistryHost.Raw)
+}
diff --git a/vendor/github.com/hashicorp/terraform/registry/response/provider.go b/vendor/github.com/hashicorp/terraform/registry/response/provider.go
new file mode 100644
index 0000000..5e8bae3
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/registry/response/provider.go
@@ -0,0 +1,36 @@
+package response
+
+import (
+        "time"
+)
+
+// Provider is the response structure with the data for a single provider
+// version. This is just the metadata. A full provider response will be
+// ProviderDetail.
+type Provider struct {
+        ID string `json:"id"`
+
+        //---------------------------------------------------------------
+        // Metadata about the overall provider.
+
+        Owner       string    `json:"owner"`
+        Namespace   string    `json:"namespace"`
+        Name        string    `json:"name"`
+        Version     string    `json:"version"`
+        Description string    `json:"description"`
+        Source      string    `json:"source"`
+        PublishedAt time.Time `json:"published_at"`
+        Downloads   int       `json:"downloads"`
+}
+
+// ProviderDetail represents a Provider with full detail.
+type ProviderDetail struct {
+        Provider
+
+        //---------------------------------------------------------------
+        // The fields below are only set when requesting this specific
+        // module. They are available to easily know all available versions
+        // without multiple API calls.
+
+        Versions []string `json:"versions"` // All versions
+}
diff --git a/vendor/github.com/hashicorp/terraform/registry/response/provider_list.go b/vendor/github.com/hashicorp/terraform/registry/response/provider_list.go
new file mode 100644
index 0000000..1dc7d23
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/registry/response/provider_list.go
@@ -0,0 +1,7 @@
+package response
+
+// ProviderList is the response structure for a pageable list of providers.
+type ProviderList struct {
+        Meta      PaginationMeta `json:"meta"`
+        Providers []*Provider    `json:"providers"`
+}
diff --git a/vendor/github.com/hashicorp/terraform/registry/response/terraform_provider.go b/vendor/github.com/hashicorp/terraform/registry/response/terraform_provider.go
new file mode 100644
index 0000000..64e454a
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/registry/response/terraform_provider.go
@@ -0,0 +1,96 @@
+package response
+
+import (
+        "sort"
+        "strings"
+
+        version "github.com/hashicorp/go-version"
+)
+
+// TerraformProvider is the response structure for all required information for
+// Terraform to choose a download URL. It must include all versions and all
+// platforms for Terraform to perform version and os/arch constraint matching
+// locally.
+type TerraformProvider struct {
+        ID       string `json:"id"`
+        Verified bool   `json:"verified"`
+
+        Versions []*TerraformProviderVersion `json:"versions"`
+}
+
+// TerraformProviderVersion is the Terraform-specific response structure for a
+// provider version.
+type TerraformProviderVersion struct {
+        Version   string   `json:"version"`
+        Protocols []string `json:"protocols"`
+
+        Platforms []*TerraformProviderPlatform `json:"platforms"`
+}
+
+// TerraformProviderVersions is the Terraform-specific response structure for an
+// array of provider versions
+type TerraformProviderVersions struct {
+        ID       string                      `json:"id"`
+        Versions []*TerraformProviderVersion `json:"versions"`
+        Warnings []string                    `json:"warnings"`
+}
+
+// TerraformProviderPlatform is the Terraform-specific response structure for a
+// provider platform.
+type TerraformProviderPlatform struct {
+        OS   string `json:"os"`
+        Arch string `json:"arch"`
+}
+
+// TerraformProviderPlatformLocation is the Terraform-specific response
+// structure for a provider platform with all details required to perform a
+// download.
+type TerraformProviderPlatformLocation struct {
+        Protocols           []string `json:"protocols"`
+        OS                  string   `json:"os"`
+        Arch                string   `json:"arch"`
+        Filename            string   `json:"filename"`
+        DownloadURL         string   `json:"download_url"`
+        ShasumsURL          string   `json:"shasums_url"`
+        ShasumsSignatureURL string   `json:"shasums_signature_url"`
+        Shasum              string   `json:"shasum"`
+
+        SigningKeys SigningKeyList `json:"signing_keys"`
+}
+
+// SigningKeyList is the response structure for a list of signing keys.
+type SigningKeyList struct {
+        GPGKeys []*GPGKey `json:"gpg_public_keys"`
+}
+
+// GPGKey is the response structure for a GPG key.
+type GPGKey struct {
+        ASCIIArmor string  `json:"ascii_armor"`
+        Source     string  `json:"source"`
+        SourceURL  *string `json:"source_url"`
+}
+
+// Collection type for TerraformProviderVersion
+type ProviderVersionCollection []*TerraformProviderVersion
+
+// GPGASCIIArmor returns an ASCII-armor-formatted string for all of the gpg
+// keys in the response.
+func (signingKeys *SigningKeyList) GPGASCIIArmor() string {
+        keys := []string{}
+
+        for _, gpgKey := range signingKeys.GPGKeys {
+                keys = append(keys, gpgKey.ASCIIArmor)
+        }
+
+        return strings.Join(keys, "\n")
+}
+
+// Sort sorts versions from newest to oldest.
+func (v ProviderVersionCollection) Sort() {
+        sort.Slice(v, func(i, j int) bool {
+                versionA, _ := version.NewVersion(v[i].Version)
+                versionB, _ := version.NewVersion(v[j].Version)
+
+                return versionA.GreaterThan(versionB)
+        })
+}