func (s *providerRegistrySuite) TestSupportedEnvironProviders(c *gc.C) {
ptypeFoo := storage.ProviderType("foo")
ptypeBar := storage.ProviderType("bar")
registry.RegisterEnvironStorageProviders("ec2", ptypeFoo, ptypeBar)
c.Assert(registry.IsProviderSupported("ec2", ptypeFoo), jc.IsTrue)
c.Assert(registry.IsProviderSupported("ec2", ptypeBar), jc.IsTrue)
c.Assert(registry.IsProviderSupported("ec2", storage.ProviderType("foobar")), jc.IsFalse)
c.Assert(registry.IsProviderSupported("openstack", ptypeBar), jc.IsFalse)
}
func (s *providerRegistrySuite) TestRegisterEnvironProvidersMultipleCalls(c *gc.C) {
ptypeFoo := storage.ProviderType("foo")
ptypeBar := storage.ProviderType("bar")
registry.RegisterEnvironStorageProviders("ec2", ptypeFoo)
registry.RegisterEnvironStorageProviders("ec2", ptypeBar)
registry.RegisterEnvironStorageProviders("ec2", ptypeBar)
c.Assert(registry.IsProviderSupported("ec2", ptypeFoo), jc.IsTrue)
c.Assert(registry.IsProviderSupported("ec2", ptypeBar), jc.IsTrue)
}
func (*maasProviderSuite) TestSupportedProviders(c *gc.C) {
supported := []storage.ProviderType{maas.MaasStorageProviderType}
for _, providerType := range supported {
ok := registry.IsProviderSupported("maas", providerType)
c.Assert(ok, jc.IsTrue)
}
}
// validateStoragePool validates the storage pool for the environment.
// If machineId is non-nil, the storage scope will be validated against
// the machineId; if the storage is not machine-scoped, then the machineId
// will be updated to "".
func validateStoragePool(
st *State, poolName string, kind storage.StorageKind, machineId *string,
) error {
if poolName == "" {
return errors.New("pool name is required")
}
providerType, provider, err := poolStorageProvider(st, poolName)
if err != nil {
return errors.Trace(err)
}
// Ensure the storage provider supports the specified kind.
kindSupported := provider.Supports(kind)
if !kindSupported && kind == storage.StorageKindFilesystem {
// Filesystems can be created if either filesystem
// or block storage are supported.
if provider.Supports(storage.StorageKindBlock) {
kindSupported = true
// The filesystem is to be backed by a volume,
// so the filesystem must be managed on the
// machine. Skip the scope-check below by
// setting the pointer to nil.
machineId = nil
}
}
if !kindSupported {
return errors.Errorf("%q provider does not support %q storage", providerType, kind)
}
// Check the storage scope.
if machineId != nil {
switch provider.Scope() {
case storage.ScopeMachine:
if *machineId == "" {
return errors.Annotate(err, "machine unspecified for machine-scoped storage")
}
default:
// The storage is not machine-scoped, so we clear out
// the machine ID to inform the caller that the storage
// scope should be the environment.
*machineId = ""
}
}
// Ensure the pool type is supported by the environment.
conf, err := st.EnvironConfig()
if err != nil {
return errors.Trace(err)
}
envType := conf.Type()
if !registry.IsProviderSupported(envType, providerType) {
return errors.Errorf(
"pool %q uses storage provider %q which is not supported for environments of type %q",
poolName,
providerType,
envType,
)
}
return nil
}
func (*providerSuite) TestSupportedProviders(c *gc.C) {
supported := []storage.ProviderType{ec2.EBS_ProviderType}
for _, providerType := range supported {
ok := registry.IsProviderSupported("ec2", providerType)
c.Assert(ok, jc.IsTrue)
}
}
func (*providerSuite) TestSupportedProviders(c *gc.C) {
supported := []storage.ProviderType{provider.HostLoopProviderType}
for _, providerType := range supported {
ok := registry.IsProviderSupported("local", providerType)
c.Assert(ok, jc.IsTrue)
}
}
func (s *providerRegistrySuite) TestSupportedEnvironCommonProviders(c *gc.C) {
for _, envProvider := range environs.RegisteredProviders() {
for storageProvider := range provider.CommonProviders() {
c.Logf("Checking storage provider %v is registered for env provider %v", storageProvider, envProvider)
c.Assert(registry.IsProviderSupported(envProvider, storageProvider), jc.IsTrue)
}
}
}
func (a *API) isValidProviderCriteria(providers []string) (bool, error) {
envName, err := a.storage.EnvName()
if err != nil {
return false, errors.Annotate(err, "getting env name")
}
for _, p := range providers {
if !registry.IsProviderSupported(envName, storage.ProviderType(p)) {
return false, errors.NotSupportedf("%q for environment %q", p, envName)
}
}
return true, nil
}
func (a *API) validateProviderCriteria(providers []string) error {
envName, err := a.storage.ModelName()
if err != nil {
return errors.Annotate(err, "getting model name")
}
for _, p := range providers {
if !registry.IsProviderSupported(envName, storage.ProviderType(p)) {
return errors.NotSupportedf("%q", p)
}
}
return nil
}