| package getproviders |
| |
| import ( |
| "fmt" |
| "net/url" |
| |
| svchost "github.com/hashicorp/terraform-svchost" |
| |
| "github.com/hashicorp/terraform/internal/addrs" |
| ) |
| |
| // ErrHostNoProviders is an error type used to indicate that a hostname given |
| // in a provider address does not support the provider registry protocol. |
| type ErrHostNoProviders struct { |
| Hostname svchost.Hostname |
| |
| // HasOtherVersionis set to true if the discovery process detected |
| // declarations of services named "providers" whose version numbers did not |
| // match any version supported by the current version of Terraform. |
| // |
| // If this is set, it's helpful to hint to the user in an error message |
| // that the provider host may be expecting an older or a newer version |
| // of Terraform, rather than that it isn't a provider registry host at all. |
| HasOtherVersion bool |
| } |
| |
| func (err ErrHostNoProviders) Error() string { |
| switch { |
| case err.HasOtherVersion: |
| return fmt.Sprintf("host %s does not support the provider registry protocol required by this Terraform version, but may be compatible with a different Terraform version", err.Hostname.ForDisplay()) |
| default: |
| return fmt.Sprintf("host %s does not offer a Terraform provider registry", err.Hostname.ForDisplay()) |
| } |
| } |
| |
| // ErrHostUnreachable is an error type used to indicate that a hostname |
| // given in a provider address did not resolve in DNS, did not respond to an |
| // HTTPS request for service discovery, or otherwise failed to correctly speak |
| // the service discovery protocol. |
| type ErrHostUnreachable struct { |
| Hostname svchost.Hostname |
| Wrapped error |
| } |
| |
| func (err ErrHostUnreachable) Error() string { |
| return fmt.Sprintf("could not connect to %s: %s", err.Hostname.ForDisplay(), err.Wrapped.Error()) |
| } |
| |
| // Unwrap returns the underlying error that occurred when trying to reach the |
| // indicated host. |
| func (err ErrHostUnreachable) Unwrap() error { |
| return err.Wrapped |
| } |
| |
| // ErrUnauthorized is an error type used to indicate that a hostname |
| // given in a provider address returned a "401 Unauthorized" or "403 Forbidden" |
| // error response when we tried to access it. |
| type ErrUnauthorized struct { |
| Hostname svchost.Hostname |
| |
| // HaveCredentials is true when the request that failed included some |
| // credentials, and thus it seems that those credentials were invalid. |
| // Conversely, HaveCredentials is false if the request did not include |
| // credentials at all, in which case it seems that credentials must be |
| // provided. |
| HaveCredentials bool |
| } |
| |
| func (err ErrUnauthorized) Error() string { |
| switch { |
| case err.HaveCredentials: |
| return fmt.Sprintf("host %s rejected the given authentication credentials", err.Hostname) |
| default: |
| return fmt.Sprintf("host %s requires authentication credentials", err.Hostname) |
| } |
| } |
| |
| // ErrProviderNotFound is an error type used to indicate that requested provider |
| // was not found in the source(s) included in the Description field. This can be |
| // used to produce user-friendly error messages. |
| type ErrProviderNotFound struct { |
| Provider addrs.Provider |
| Sources []string |
| } |
| |
| func (err ErrProviderNotFound) Error() string { |
| return fmt.Sprintf( |
| "provider %s was not found in any of the search locations", |
| err.Provider, |
| ) |
| } |
| |
| // ErrRegistryProviderNotKnown is an error type used to indicate that the hostname |
| // given in a provider address does appear to be a provider registry but that |
| // registry does not know about the given provider namespace or type. |
| // |
| // A caller serving requests from an end-user should recognize this error type |
| // and use it to produce user-friendly hints for common errors such as failing |
| // to specify an explicit source for a provider not in the default namespace |
| // (one not under registry.terraform.io/hashicorp/). The default error message |
| // for this type is a direct description of the problem with no such hints, |
| // because we expect that the caller will have better context to decide what |
| // hints are appropriate, e.g. by looking at the configuration given by the |
| // user. |
| type ErrRegistryProviderNotKnown struct { |
| Provider addrs.Provider |
| } |
| |
| func (err ErrRegistryProviderNotKnown) Error() string { |
| return fmt.Sprintf( |
| "provider registry %s does not have a provider named %s", |
| err.Provider.Hostname.ForDisplay(), |
| err.Provider, |
| ) |
| } |
| |
| // ErrPlatformNotSupported is an error type used to indicate that a particular |
| // version of a provider isn't available for a particular target platform. |
| // |
| // This is returned when DownloadLocation encounters a 404 Not Found response |
| // from the underlying registry, because it presumes that a caller will only |
| // ask for the DownloadLocation for a version it already found the existence |
| // of via AvailableVersions. |
| type ErrPlatformNotSupported struct { |
| Provider addrs.Provider |
| Version Version |
| Platform Platform |
| |
| // MirrorURL, if non-nil, is the base URL of the mirror that serviced |
| // the request in place of the provider's origin registry. MirrorURL |
| // is nil for a direct query. |
| MirrorURL *url.URL |
| } |
| |
| func (err ErrPlatformNotSupported) Error() string { |
| if err.MirrorURL != nil { |
| return fmt.Sprintf( |
| "provider mirror %s does not have a package of %s %s for %s", |
| err.MirrorURL.String(), |
| err.Provider, |
| err.Version, |
| err.Platform, |
| ) |
| } |
| return fmt.Sprintf( |
| "provider %s %s is not available for %s", |
| err.Provider, |
| err.Version, |
| err.Platform, |
| ) |
| } |
| |
| // ErrProtocolNotSupported is an error type used to indicate that a particular |
| // version of a provider is not supported by the current version of Terraform. |
| // |
| // Specfically, this is returned when the version's plugin protocol is not supported. |
| // |
| // When available, the error will include a suggested version that can be displayed to |
| // the user. Otherwise it will return UnspecifiedVersion |
| type ErrProtocolNotSupported struct { |
| Provider addrs.Provider |
| Version Version |
| Suggestion Version |
| } |
| |
| func (err ErrProtocolNotSupported) Error() string { |
| return fmt.Sprintf( |
| "provider %s %s is not supported by this version of terraform", |
| err.Provider, |
| err.Version, |
| ) |
| } |
| |
| // ErrQueryFailed is an error type used to indicate that the hostname given |
| // in a provider address does appear to be a provider registry but that when |
| // we queried it for metadata for the given provider the server returned an |
| // unexpected error. |
| // |
| // This is used for any error responses other than "Not Found", which would |
| // indicate the absense of a provider and is thus reported using |
| // ErrProviderNotKnown instead. |
| type ErrQueryFailed struct { |
| Provider addrs.Provider |
| Wrapped error |
| |
| // MirrorURL, if non-nil, is the base URL of the mirror that serviced |
| // the request in place of the provider's origin registry. MirrorURL |
| // is nil for a direct query. |
| MirrorURL *url.URL |
| } |
| |
| func (err ErrQueryFailed) Error() string { |
| if err.MirrorURL != nil { |
| return fmt.Sprintf( |
| "failed to query provider mirror %s for %s: %s", |
| err.MirrorURL.String(), |
| err.Provider.String(), |
| err.Wrapped.Error(), |
| ) |
| } |
| return fmt.Sprintf( |
| "could not query provider registry for %s: %s", |
| err.Provider.String(), |
| err.Wrapped.Error(), |
| ) |
| } |
| |
| // Unwrap returns the underlying error that occurred when trying to reach the |
| // indicated host. |
| func (err ErrQueryFailed) Unwrap() error { |
| return err.Wrapped |
| } |
| |
| // ErrRequestCanceled is an error type used to indicate that an operation |
| // failed due to being cancelled via the given context.Context object. |
| // |
| // This error type doesn't include information about what was cancelled, |
| // because the expected treatment of this error type is to quickly abort and |
| // exit with minimal ceremony. |
| type ErrRequestCanceled struct { |
| } |
| |
| func (err ErrRequestCanceled) Error() string { |
| return "request canceled" |
| } |
| |
| // ErrIsNotExist returns true if and only if the given error is one of the |
| // errors from this package that represents an affirmative response that a |
| // requested object does not exist. |
| // |
| // This is as opposed to errors indicating that the source is unavailable |
| // or misconfigured in some way, where we therefore cannot say for certain |
| // whether the requested object exists. |
| // |
| // If a caller needs to take a special action based on something not existing, |
| // such as falling back on some other source, use this function rather than |
| // direct type assertions so that the set of possible "not exist" errors can |
| // grow in future. |
| func ErrIsNotExist(err error) bool { |
| switch err.(type) { |
| case ErrProviderNotFound, ErrRegistryProviderNotKnown, ErrPlatformNotSupported: |
| return true |
| default: |
| return false |
| } |
| } |