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 }