func openEnviron( c *gc.C, provider environs.EnvironProvider, sender *azuretesting.Senders, attrs ...testing.Attrs, ) environs.Environ { // Opening the environment should not incur network communication, // so we don't set s.sender until after opening. cfg := makeTestModelConfig(c, attrs...) env, err := provider.Open(environs.OpenParams{ Cloud: fakeCloudSpec(), Config: cfg, }) c.Assert(err, jc.ErrorIsNil) // Force an explicit refresh of the access token, so it isn't done // implicitly during the tests. *sender = azuretesting.Senders{ discoverAuthSender(), tokenRefreshSender(), } err = azure.ForceTokenRefresh(env) c.Assert(err, jc.ErrorIsNil) return env }
func prepareForBootstrap( c *gc.C, ctx environs.BootstrapContext, provider environs.EnvironProvider, sender *azuretesting.Senders, attrs ...testing.Attrs, ) environs.Environ { // Opening the environment should not incur network communication, // so we don't set s.sender until after opening. cfg, err := provider.PrepareConfig(environs.PrepareConfigParams{ Config: makeTestModelConfig(c, attrs...), Cloud: fakeCloudSpec(), }) c.Assert(err, jc.ErrorIsNil) env, err := provider.Open(environs.OpenParams{ Cloud: fakeCloudSpec(), Config: cfg, }) c.Assert(err, jc.ErrorIsNil) *sender = azuretesting.Senders{ discoverAuthSender(), tokenRefreshSender(), } err = env.PrepareForBootstrap(ctx) c.Assert(err, jc.ErrorIsNil) return env }
// AssertProviderCredentialsValid asserts that the given provider is // able to validate the given authentication type and credential // attributes; and that removing any one of the attributes will cause // the validation to fail. func AssertProviderCredentialsValid(c *gc.C, p environs.EnvironProvider, authType cloud.AuthType, attrs map[string]string) { schema, ok := p.CredentialSchemas()[authType] c.Assert(ok, jc.IsTrue, gc.Commentf("missing schema for %q auth-type", authType)) validate := func(attrs map[string]string) error { _, err := schema.Finalize(attrs, func(string) ([]byte, error) { return nil, errors.NotSupportedf("reading files") }) return err } err := validate(attrs) c.Assert(err, jc.ErrorIsNil) for excludedKey := range attrs { field, _ := schema.Attribute(excludedKey) if field.Optional { continue } reducedAttrs := make(map[string]string) for key, value := range attrs { if key != excludedKey { reducedAttrs[key] = value } } err := validate(reducedAttrs) if field.FileAttr != "" { c.Assert(err, gc.ErrorMatches, fmt.Sprintf( `either %q or %q must be specified`, excludedKey, field.FileAttr), ) } else { c.Assert(err, gc.ErrorMatches, excludedKey+": expected string, got nothing") } } }
func prepareForBootstrap( c *gc.C, ctx environs.BootstrapContext, provider environs.EnvironProvider, sender *azuretesting.Senders, attrs ...testing.Attrs, ) environs.Environ { // Opening the environment should not incur network communication, // so we don't set s.sender until after opening. cfg := makeTestModelConfig(c, attrs...) cfg, err := cfg.Remove([]string{"controller-resource-group"}) c.Assert(err, jc.ErrorIsNil) *sender = azuretesting.Senders{tokenRefreshSender()} cfg, err = provider.BootstrapConfig(environs.BootstrapConfigParams{ Config: cfg, CloudRegion: "westus", CloudEndpoint: "https://management.azure.com", CloudStorageEndpoint: "https://core.windows.net", Credentials: fakeUserPassCredential(), }) c.Assert(err, jc.ErrorIsNil) env, err := provider.PrepareForBootstrap(ctx, cfg) c.Assert(err, jc.ErrorIsNil) return env }
// AssertProviderAuthTypes asserts that the given provider has credential // schemas for exactly the specified set of authentication types. func AssertProviderAuthTypes(c *gc.C, p environs.EnvironProvider, expectedAuthTypes ...cloud.AuthType) { var authTypes []cloud.AuthType for authType := range p.CredentialSchemas() { authTypes = append(authTypes, authType) } c.Assert(authTypes, jc.SameContents, expectedAuthTypes) }
// AssertProviderCredentialsAttributesHidden asserts that the provider // credentials schema for the given provider and authentication type // marks the specified attributes (and only those attributes) as being // hidden. func AssertProviderCredentialsAttributesHidden(c *gc.C, p environs.EnvironProvider, authType cloud.AuthType, expectedHidden ...string) { var hidden []string schema, ok := p.CredentialSchemas()[authType] c.Assert(ok, jc.IsTrue, gc.Commentf("missing schema for %q auth-type", authType)) for _, field := range schema { if field.Hidden { hidden = append(hidden, field.Name) } } c.Assert(hidden, jc.SameContents, expectedHidden) }
func prepareForBootstrap( c *gc.C, ctx environs.BootstrapContext, provider environs.EnvironProvider, sender *azuretesting.Senders, attrs ...testing.Attrs, ) environs.Environ { // Opening the environment should not incur network communication, // so we don't set s.sender until after opening. cfg := makeTestModelConfig(c, attrs...) cfg, err := cfg.Remove([]string{"controller-resource-group"}) c.Assert(err, jc.ErrorIsNil) *sender = azuretesting.Senders{tokenRefreshSender()} env, err := provider.PrepareForBootstrap(ctx, cfg) c.Assert(err, jc.ErrorIsNil) return env }
// finalizeConfig creates the config object from attributes, // and calls EnvironProvider.PrepareConfig. func finalizeConfig( provider environs.EnvironProvider, cloud environs.CloudSpec, attrs map[string]interface{}, ) (*config.Config, error) { cfg, err := config.New(config.UseDefaults, attrs) if err != nil { return nil, errors.Annotate(err, "creating config from values failed") } cfg, err = provider.PrepareConfig(environs.PrepareConfigParams{ Cloud: cloud, Config: cfg, }) if err != nil { return nil, errors.Annotate(err, "provider config preparation failed") } cfg, err = provider.Validate(cfg, nil) if err != nil { return nil, errors.Annotate(err, "provider config validation failed") } return cfg, nil }
func prepare( ctx environs.BootstrapContext, p environs.EnvironProvider, args PrepareParams, ) (environs.Environ, prepareDetails, error) { var details prepareDetails cfg, err := config.New(config.NoDefaults, args.ModelConfig) if err != nil { return nil, details, errors.Trace(err) } cfg, err = p.PrepareConfig(environs.PrepareConfigParams{args.Cloud, cfg}) if err != nil { return nil, details, errors.Trace(err) } env, err := p.Open(environs.OpenParams{ Cloud: args.Cloud, Config: cfg, }) if err != nil { return nil, details, errors.Trace(err) } if err := env.PrepareForBootstrap(ctx); err != nil { return nil, details, errors.Trace(err) } // We store the base configuration only; we don't want the // default attributes, generated secrets/certificates, or // UUIDs stored in the bootstrap config. Make a copy, so // we don't disturb the caller's config map. details.Config = make(map[string]interface{}) for k, v := range args.ModelConfig { details.Config[k] = v } delete(details.Config, config.UUIDKey) // TODO(axw) change signature of CACert() to not return a bool. // It's no longer possible to have a controller config without // a CA certificate. caCert, ok := args.ControllerConfig.CACert() if !ok { return nil, details, errors.New("controller config is missing CA certificate") } // We want to store attributes describing how a controller has been configured. // These do not include the CACert or UUID since they will be replaced with new // values when/if we need to use this configuration. details.ControllerConfig = make(controller.Config) for k, v := range args.ControllerConfig { if k == controller.CACertKey || k == controller.ControllerUUIDKey { continue } details.ControllerConfig[k] = v } for k, v := range args.ControllerConfig { if k == controller.CACertKey || k == controller.ControllerUUIDKey { continue } details.ControllerConfig[k] = v } details.CACert = caCert details.ControllerUUID = args.ControllerConfig.ControllerUUID() details.ControllerModelUUID = args.ModelConfig[config.UUIDKey].(string) details.User = environs.AdminUser details.Password = args.AdminSecret details.LastKnownAccess = string(permission.SuperuserAccess) details.ModelUUID = cfg.UUID() details.ControllerDetails.Cloud = args.Cloud.Name details.ControllerDetails.CloudRegion = args.Cloud.Region details.BootstrapConfig.CloudType = args.Cloud.Type details.BootstrapConfig.Cloud = args.Cloud.Name details.BootstrapConfig.CloudRegion = args.Cloud.Region details.CloudEndpoint = args.Cloud.Endpoint details.CloudIdentityEndpoint = args.Cloud.IdentityEndpoint details.CloudStorageEndpoint = args.Cloud.StorageEndpoint details.Credential = args.CredentialName return env, details, nil }