providers: Resolver and Factory types
These new types are adaptations of terraform.ProviderResolver and terraform.ResourceProviderFactory respectively. In a later commit we will update users of the old types to use these new types, possibly in a "gradual repair" sort of fashion by initially using type aliases, though that won't 100% solve the problem because the types themselves have changed in this move to return providers.Interface instead of terraform.ResourceProvider.
This commit is contained in:
parent
bddfd0412c
commit
594a821ab3
|
@ -0,0 +1,112 @@
|
|||
package providers
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/hashicorp/terraform/plugin/discovery"
|
||||
)
|
||||
|
||||
// Resolver is an interface implemented by objects that are able to resolve
|
||||
// a given set of resource provider version constraints into Factory
|
||||
// callbacks.
|
||||
type Resolver interface {
|
||||
// Given a constraint map, return a Factory for each requested provider.
|
||||
// If some or all of the constraints cannot be satisfied, return a non-nil
|
||||
// slice of errors describing the problems.
|
||||
ResolveProviders(reqd discovery.PluginRequirements) (map[string]Factory, []error)
|
||||
}
|
||||
|
||||
// ResolverFunc wraps a callback function and turns it into a Resolver
|
||||
// implementation, for convenience in situations where a function and its
|
||||
// associated closure are sufficient as a resolver implementation.
|
||||
type ResolverFunc func(reqd discovery.PluginRequirements) (map[string]Factory, []error)
|
||||
|
||||
// ResolveProviders implements Resolver by calling the
|
||||
// wrapped function.
|
||||
func (f ResolverFunc) ResolveProviders(reqd discovery.PluginRequirements) (map[string]Factory, []error) {
|
||||
return f(reqd)
|
||||
}
|
||||
|
||||
// ResolverFixed returns a Resolver that has a fixed set of provider factories
|
||||
// provided by the caller. The returned resolver ignores version constraints
|
||||
// entirely and just returns the given factory for each requested provider
|
||||
// name.
|
||||
//
|
||||
// This function is primarily used in tests, to provide mock providers or
|
||||
// in-process providers under test.
|
||||
func ResolverFixed(factories map[string]Factory) Resolver {
|
||||
return ResolverFunc(func(reqd discovery.PluginRequirements) (map[string]Factory, []error) {
|
||||
ret := make(map[string]Factory, len(reqd))
|
||||
var errs []error
|
||||
for name := range reqd {
|
||||
if factory, exists := factories[name]; exists {
|
||||
ret[name] = factory
|
||||
} else {
|
||||
errs = append(errs, fmt.Errorf("provider %q is not available", name))
|
||||
}
|
||||
}
|
||||
return ret, errs
|
||||
})
|
||||
}
|
||||
|
||||
// Factory is a function type that creates a new instance of a resource
|
||||
// provider, or returns an error if that is impossible.
|
||||
type Factory func() (Interface, error)
|
||||
|
||||
// FactoryFixed is a helper that creates a Factory that just returns some given
|
||||
// single provider.
|
||||
//
|
||||
// Unlike usual factories, the exact same instance is returned for each call
|
||||
// to the factory and so this must be used in only specialized situations where
|
||||
// the caller can take care to either not mutate the given provider at all
|
||||
// or to mutate it in ways that will not cause unexpected behavior for others
|
||||
// holding the same reference.
|
||||
func FactoryFixed(p Interface) Factory {
|
||||
return func() (Interface, error) {
|
||||
return p, nil
|
||||
}
|
||||
}
|
||||
|
||||
// ProviderHasResource is a helper that requests schema from the given provider
|
||||
// and checks if it has a resource type of the given name.
|
||||
//
|
||||
// This function is more expensive than it may first appear since it must
|
||||
// retrieve the entire schema from the underlying provider, and so it should
|
||||
// be used sparingly and especially not in tight loops.
|
||||
//
|
||||
// Since retrieving the provider may fail (e.g. if the provider is accessed
|
||||
// over an RPC channel that has operational problems), this function will
|
||||
// return false if the schema cannot be retrieved, under the assumption that
|
||||
// a subsequent call to do anything with the resource type would fail
|
||||
// anyway.
|
||||
func ProviderHasResource(provider Interface, typeName string) bool {
|
||||
resp := provider.GetSchema()
|
||||
if resp.Diagnostics.HasErrors() {
|
||||
return false
|
||||
}
|
||||
|
||||
_, exists := resp.ResourceTypes[typeName]
|
||||
return exists
|
||||
}
|
||||
|
||||
// ProviderHasDataSource is a helper that requests schema from the given
|
||||
// provider and checks if it has a data source of the given name.
|
||||
//
|
||||
// This function is more expensive than it may first appear since it must
|
||||
// retrieve the entire schema from the underlying provider, and so it should
|
||||
// be used sparingly and especially not in tight loops.
|
||||
//
|
||||
// Since retrieving the provider may fail (e.g. if the provider is accessed
|
||||
// over an RPC channel that has operational problems), this function will
|
||||
// return false if the schema cannot be retrieved, under the assumption that
|
||||
// a subsequent call to do anything with the data source would fail
|
||||
// anyway.
|
||||
func ProviderHasDataSource(provider Interface, dataSourceName string) bool {
|
||||
resp := provider.GetSchema()
|
||||
if resp.Diagnostics.HasErrors() {
|
||||
return false
|
||||
}
|
||||
|
||||
_, exists := resp.DataSources[dataSourceName]
|
||||
return exists
|
||||
}
|
Loading…
Reference in New Issue