func (s *BootstrapSuite) TestInitialPassword(c *gc.C) { machineConf, cmd, err := s.initBootstrapCommand(c, nil, "--model-config", s.b64yamlControllerModelConfig, "--hosted-model-config", s.b64yamlHostedModelConfig, "--instance-id", string(s.instanceId), ) c.Assert(err, jc.ErrorIsNil) err = cmd.Run(nil) c.Assert(err, jc.ErrorIsNil) info := &mongo.MongoInfo{ Info: mongo.Info{ Addrs: []string{gitjujutesting.MgoServer.Addr()}, CACert: testing.CACert, }, } // Check we can log in to mongo as admin. // TODO(dfc) does passing nil for the admin user name make your skin crawl ? mine too. info.Tag, info.Password = nil, testPassword st, err := state.Open(testing.ModelTag, info, mongotest.DialOpts(), environs.NewStatePolicy()) c.Assert(err, jc.ErrorIsNil) defer st.Close() // We're running Mongo with --noauth; let's explicitly verify // that we can login as that user. Even with --noauth, an // explicit Login will still be verified. adminDB := st.MongoSession().DB("admin") err = adminDB.Login("admin", "invalid-password") c.Assert(err, gc.ErrorMatches, "(auth|(.*Authentication)) fail(s|ed)\\.?") err = adminDB.Login("admin", info.Password) c.Assert(err, jc.ErrorIsNil) // Check that the admin user has been given an appropriate // password u, err := st.User(names.NewLocalUserTag("admin")) c.Assert(err, jc.ErrorIsNil) c.Assert(u.PasswordValid(testPassword), jc.IsTrue) // Check that the machine configuration has been given a new // password and that we can connect to mongo as that machine // and that the in-mongo password also verifies correctly. machineConf1, err := agent.ReadConfig(agent.ConfigPath(machineConf.DataDir(), names.NewMachineTag("0"))) c.Assert(err, jc.ErrorIsNil) stateinfo, ok := machineConf1.MongoInfo() c.Assert(ok, jc.IsTrue) st, err = state.Open(testing.ModelTag, stateinfo, mongotest.DialOpts(), environs.NewStatePolicy()) c.Assert(err, jc.ErrorIsNil) defer st.Close() m, err := st.Machine("0") c.Assert(err, jc.ErrorIsNil) c.Assert(m.HasVote(), jc.IsTrue) }
func (s *bootstrapSuite) TestInitializeStateFailsSecondTime(c *gc.C) { dataDir := c.MkDir() configParams := agent.AgentConfigParams{ Paths: agent.Paths{DataDir: dataDir}, Tag: names.NewMachineTag("0"), UpgradedToVersion: jujuversion.Current, StateAddresses: []string{s.mgoInst.Addr()}, CACert: testing.CACert, Password: testing.DefaultMongoPassword, Model: testing.ModelTag, } cfg, err := agent.NewAgentConfig(configParams) c.Assert(err, jc.ErrorIsNil) cfg.SetStateServingInfo(params.StateServingInfo{ APIPort: 5555, StatePort: s.mgoInst.Port(), Cert: "foo", PrivateKey: "bar", SharedSecret: "baz", SystemIdentity: "qux", }) expectHW := instance.MustParseHardware("mem=2048M") mcfg := agentbootstrap.BootstrapMachineConfig{ BootstrapConstraints: constraints.MustParse("mem=1024M"), Jobs: []multiwatcher.MachineJob{multiwatcher.JobManageModel}, InstanceId: "i-bootstrap", Characteristics: expectHW, } envAttrs := dummy.SampleConfig().Delete("admin-secret").Merge(testing.Attrs{ "agent-version": jujuversion.Current.String(), }) envCfg, err := config.New(config.NoDefaults, envAttrs) c.Assert(err, jc.ErrorIsNil) hostedModelConfigAttrs := map[string]interface{}{ "name": "hosted", "uuid": utils.MustNewUUID().String(), } adminUser := names.NewLocalUserTag("agent-admin") st, _, err := agentbootstrap.InitializeState( adminUser, cfg, envCfg, hostedModelConfigAttrs, mcfg, mongotest.DialOpts(), state.Policy(nil), ) c.Assert(err, jc.ErrorIsNil) st.Close() st, _, err = agentbootstrap.InitializeState(adminUser, cfg, envCfg, nil, mcfg, mongotest.DialOpts(), environs.NewStatePolicy()) if err == nil { st.Close() } c.Assert(err, gc.ErrorMatches, "failed to initialize mongo admin user: cannot set admin password: not authorized .*") }
func tryOpenState(modelTag names.ModelTag, info *mongo.MongoInfo) error { st, err := state.Open(modelTag, info, mongotest.DialOpts(), environs.NewStatePolicy()) if err == nil { st.Close() } return err }
func (s *BootstrapSuite) TestSetConstraints(c *gc.C) { bootstrapCons := constraints.Value{Mem: uint64p(4096), CpuCores: uint64p(4)} modelCons := constraints.Value{Mem: uint64p(2048), CpuCores: uint64p(2)} _, cmd, err := s.initBootstrapCommand(c, nil, "--model-config", s.b64yamlControllerModelConfig, "--hosted-model-config", s.b64yamlHostedModelConfig, "--instance-id", string(s.instanceId), "--bootstrap-constraints", bootstrapCons.String(), "--constraints", modelCons.String(), ) c.Assert(err, jc.ErrorIsNil) err = cmd.Run(nil) c.Assert(err, jc.ErrorIsNil) st, err := state.Open(testing.ModelTag, &mongo.MongoInfo{ Info: mongo.Info{ Addrs: []string{gitjujutesting.MgoServer.Addr()}, CACert: testing.CACert, }, Password: testPassword, }, mongotest.DialOpts(), environs.NewStatePolicy()) c.Assert(err, jc.ErrorIsNil) defer st.Close() cons, err := st.ModelConstraints() c.Assert(err, jc.ErrorIsNil) c.Assert(cons, gc.DeepEquals, modelCons) machines, err := st.AllMachines() c.Assert(err, jc.ErrorIsNil) c.Assert(machines, gc.HasLen, 1) cons, err = machines[0].Constraints() c.Assert(err, jc.ErrorIsNil) c.Assert(cons, gc.DeepEquals, bootstrapCons) }
func (s *InitializeSuite) TestInitializeWithInvalidCredentialType(c *gc.C) { owner := names.NewLocalUserTag("initialize-admin") modelCfg := testing.ModelConfig(c) controllerCfg := testing.FakeControllerConfig() credentialTag := names.NewCloudCredentialTag("dummy/" + owner.Canonical() + "/borken") _, err := state.Initialize(state.InitializeParams{ Clock: clock.WallClock, ControllerConfig: controllerCfg, ControllerModelArgs: state.ModelArgs{ CloudName: "dummy", Owner: owner, Config: modelCfg, StorageProviderRegistry: storage.StaticProviderRegistry{}, }, CloudName: "dummy", Cloud: cloud.Cloud{ Type: "dummy", AuthTypes: []cloud.AuthType{ cloud.AccessKeyAuthType, cloud.OAuth1AuthType, }, }, CloudCredentials: map[names.CloudCredentialTag]cloud.Credential{ credentialTag: cloud.NewCredential(cloud.UserPassAuthType, nil), }, MongoInfo: statetesting.NewMongoInfo(), MongoDialOpts: mongotest.DialOpts(), }) c.Assert(err, gc.ErrorMatches, `validating initialization args: validating cloud credentials: credential "dummy/initialize-admin@local/borken" with auth-type "userpass" is not supported \(expected one of \["access-key" "oauth1"\]\)`, ) }
// newState returns a new State that uses the given environment. // The environment must have already been bootstrapped. func newState(environ environs.Environ, mongoInfo *mongo.MongoInfo) (*state.State, error) { config := environ.Config() password := config.AdminSecret() if password == "" { return nil, fmt.Errorf("cannot connect without admin-secret") } modelTag := names.NewModelTag(config.UUID()) mongoInfo.Password = password opts := mongotest.DialOpts() st, err := state.Open(modelTag, mongoInfo, opts, environs.NewStatePolicy()) if errors.IsUnauthorized(errors.Cause(err)) { // We try for a while because we might succeed in // connecting to mongo before the state has been // initialized and the initial password set. for a := redialStrategy.Start(); a.Next(); { st, err = state.Open(modelTag, mongoInfo, opts, environs.NewStatePolicy()) if !errors.IsUnauthorized(errors.Cause(err)) { break } } if err != nil { return nil, err } } else if err != nil { return nil, err } if err := updateSecrets(environ, st); err != nil { st.Close() return nil, fmt.Errorf("unable to push secrets: %v", err) } return st, nil }
func (s *BootstrapSuite) TestDefaultStoragePools(c *gc.C) { _, cmd, err := s.initBootstrapCommand( c, nil, "--model-config", s.b64yamlControllerModelConfig, "--hosted-model-config", s.b64yamlHostedModelConfig, "--instance-id", string(s.instanceId), ) c.Assert(err, jc.ErrorIsNil) err = cmd.Run(nil) c.Assert(err, jc.ErrorIsNil) st, err := state.Open(testing.ModelTag, &mongo.MongoInfo{ Info: mongo.Info{ Addrs: []string{gitjujutesting.MgoServer.Addr()}, CACert: testing.CACert, }, Password: testPassword, }, mongotest.DialOpts(), environs.NewStatePolicy()) c.Assert(err, jc.ErrorIsNil) defer st.Close() settings := state.NewStateSettings(st) pm := poolmanager.New(settings) for _, p := range []string{"ebs-ssd"} { _, err = pm.Get(p) c.Assert(err, jc.ErrorIsNil) } }
func (s *InitializeSuite) TestModelConfigWithoutAgentVersion(c *gc.C) { // admin-secret blocks Initialize. good := testing.ModelConfig(c) attrs := good.AllAttrs() delete(attrs, "agent-version") bad, err := config.New(config.NoDefaults, attrs) c.Assert(err, jc.ErrorIsNil) owner := names.NewLocalUserTag("initialize-admin") _, err = state.Initialize(owner, statetesting.NewMongoInfo(), bad, mongotest.DialOpts(), state.Policy(nil)) c.Assert(err, gc.ErrorMatches, "agent-version must always be set in state") st := statetesting.Initialize(c, owner, good, nil) // yay side effects st.Close() s.openState(c, st.ModelTag()) err = s.State.UpdateModelConfig(map[string]interface{}{}, []string{"agent-version"}, nil) c.Assert(err, gc.ErrorMatches, "agent-version must always be set in state") // ModelConfig remains inviolate. cfg, err := s.State.ModelConfig() c.Assert(err, jc.ErrorIsNil) c.Assert(cfg.AllAttrs(), gc.DeepEquals, good.AllAttrs()) }
func (s *BootstrapSuite) TestInitializeEnvironmentToolsNotFound(c *gc.C) { // bootstrap with 1.99.1 but there will be no tools so version will be reset. envcfg, err := s.envcfg.Apply(map[string]interface{}{ "agent-version": "1.99.1", }) c.Assert(err, jc.ErrorIsNil) b64yamlControllerModelConfig := b64yaml(envcfg.AllAttrs()).encode() hw := instance.MustParseHardware("arch=amd64 mem=8G") _, cmd, err := s.initBootstrapCommand( c, nil, "--model-config", b64yamlControllerModelConfig, "--hosted-model-config", s.b64yamlHostedModelConfig, "--instance-id", string(s.instanceId), "--hardware", hw.String(), ) c.Assert(err, jc.ErrorIsNil) err = cmd.Run(nil) c.Assert(err, jc.ErrorIsNil) st, err := state.Open(testing.ModelTag, &mongo.MongoInfo{ Info: mongo.Info{ Addrs: []string{gitjujutesting.MgoServer.Addr()}, CACert: testing.CACert, }, Password: testPassword, }, mongotest.DialOpts(), environs.NewStatePolicy()) c.Assert(err, jc.ErrorIsNil) defer st.Close() cfg, err := st.ModelConfig() c.Assert(err, jc.ErrorIsNil) vers, ok := cfg.AgentVersion() c.Assert(ok, jc.IsTrue) c.Assert(vers.String(), gc.Equals, "1.99.0") }
func (s *BootstrapSuite) TestDefaultMachineJobs(c *gc.C) { expectedJobs := []state.MachineJob{ state.JobManageModel, state.JobHostUnits, state.JobManageNetworking, } _, cmd, err := s.initBootstrapCommand(c, nil, "--model-config", s.b64yamlControllerModelConfig, "--hosted-model-config", s.b64yamlHostedModelConfig, "--instance-id", string(s.instanceId), ) c.Assert(err, jc.ErrorIsNil) err = cmd.Run(nil) c.Assert(err, jc.ErrorIsNil) st, err := state.Open(testing.ModelTag, &mongo.MongoInfo{ Info: mongo.Info{ Addrs: []string{gitjujutesting.MgoServer.Addr()}, CACert: testing.CACert, }, Password: testPassword, }, mongotest.DialOpts(), environs.NewStatePolicy()) c.Assert(err, jc.ErrorIsNil) defer st.Close() m, err := st.Machine("0") c.Assert(err, jc.ErrorIsNil) c.Assert(m.Jobs(), gc.DeepEquals, expectedJobs) }
func (s *UpgradeSuite) openStateForUpgrade() (*state.State, error) { mongoInfo := s.State.MongoConnectionInfo() st, err := state.Open(s.State.ModelTag(), mongoInfo, mongotest.DialOpts(), environs.NewStatePolicy()) if err != nil { return nil, err } return st, nil }
func (s *AgentSuite) AssertCanOpenState(c *gc.C, tag names.Tag, dataDir string) { config, err := agent.ReadConfig(agent.ConfigPath(dataDir, tag)) c.Assert(err, jc.ErrorIsNil) info, ok := config.MongoInfo() c.Assert(ok, jc.IsTrue) st, err := state.Open(config.Model(), info, mongotest.DialOpts(), environs.NewStatePolicy()) c.Assert(err, jc.ErrorIsNil) st.Close() }
func (s *InitializeSuite) openState(c *gc.C, modelTag names.ModelTag) { st, err := state.Open( modelTag, statetesting.NewMongoInfo(), mongotest.DialOpts(), state.Policy(nil), ) c.Assert(err, jc.ErrorIsNil) s.State = st }
func (s *BootstrapSuite) testToolsMetadata(c *gc.C, exploded bool) { envtesting.RemoveFakeToolsMetadata(c, s.toolsStorage) _, cmd, err := s.initBootstrapCommand(c, nil, "--model-config", s.b64yamlControllerModelConfig, "--hosted-model-config", s.b64yamlHostedModelConfig, "--instance-id", string(s.instanceId), ) c.Assert(err, jc.ErrorIsNil) err = cmd.Run(nil) c.Assert(err, jc.ErrorIsNil) // We don't write metadata at bootstrap anymore. simplestreamsMetadata, err := envtools.ReadMetadata(s.toolsStorage, "released") c.Assert(err, jc.ErrorIsNil) c.Assert(simplestreamsMetadata, gc.HasLen, 0) // The tools should have been added to tools storage, and // exploded into each of the supported series of // the same operating system if the tools were uploaded. st, err := state.Open(testing.ModelTag, &mongo.MongoInfo{ Info: mongo.Info{ Addrs: []string{gitjujutesting.MgoServer.Addr()}, CACert: testing.CACert, }, Password: testPassword, }, mongotest.DialOpts(), environs.NewStatePolicy()) c.Assert(err, jc.ErrorIsNil) defer st.Close() expectedSeries := make(set.Strings) if exploded { for _, ser := range series.SupportedSeries() { os, err := series.GetOSFromSeries(ser) c.Assert(err, jc.ErrorIsNil) hostos, err := series.GetOSFromSeries(series.HostSeries()) c.Assert(err, jc.ErrorIsNil) if os == hostos { expectedSeries.Add(ser) } } } else { expectedSeries.Add(series.HostSeries()) } storage, err := st.ToolsStorage() c.Assert(err, jc.ErrorIsNil) defer storage.Close() metadata, err := storage.AllMetadata() c.Assert(err, jc.ErrorIsNil) c.Assert(metadata, gc.HasLen, expectedSeries.Size()) for _, m := range metadata { v := version.MustParseBinary(m.Version) c.Assert(expectedSeries.Contains(v.Series), jc.IsTrue) } }
func (s *InitializeSuite) TestInitializeWithCloudRegionConfig(c *gc.C) { cfg := testing.ModelConfig(c) uuid := cfg.UUID() // Phony region-config regionInheritedConfigIn := cloud.RegionConfig{ "a-region": cloud.Attrs{ "a-key": "a-value", }, "b-region": cloud.Attrs{ "b-key": "b-value", }, } owner := names.NewLocalUserTag("initialize-admin") controllerCfg := testing.FakeControllerConfig() st, err := state.Initialize(state.InitializeParams{ Clock: clock.WallClock, ControllerConfig: controllerCfg, ControllerModelArgs: state.ModelArgs{ CloudName: "dummy", Owner: owner, Config: cfg, StorageProviderRegistry: storage.StaticProviderRegistry{}, }, CloudName: "dummy", Cloud: cloud.Cloud{ Type: "dummy", AuthTypes: []cloud.AuthType{cloud.EmptyAuthType}, RegionConfig: regionInheritedConfigIn, // Init with phony region-config }, MongoInfo: statetesting.NewMongoInfo(), MongoDialOpts: mongotest.DialOpts(), }) c.Assert(err, jc.ErrorIsNil) c.Assert(st, gc.NotNil) modelTag := st.ModelTag() c.Assert(modelTag.Id(), gc.Equals, uuid) err = st.Close() c.Assert(err, jc.ErrorIsNil) s.openState(c, modelTag) for k := range regionInheritedConfigIn { // Query for config for each region regionInheritedConfig, err := state.ReadSettings( s.State, state.GlobalSettingsC, "dummy#"+k) c.Assert(err, jc.ErrorIsNil) c.Assert( cloud.Attrs(regionInheritedConfig.Map()), jc.DeepEquals, regionInheritedConfigIn[k]) } }
func (s *InitializeSuite) TestInitializeWithCloudRegionHits(c *gc.C) { cfg := testing.ModelConfig(c) uuid := cfg.UUID() controllerInheritedConfigIn := map[string]interface{}{ "no-proxy": "local", } // Phony region-config regionInheritedConfigIn := cloud.RegionConfig{ "a-region": cloud.Attrs{ "no-proxy": "a-value", }, "b-region": cloud.Attrs{ "no-proxy": "b-value", }, } owner := names.NewLocalUserTag("initialize-admin") controllerCfg := testing.FakeControllerConfig() st, err := state.Initialize(state.InitializeParams{ Clock: clock.WallClock, ControllerConfig: controllerCfg, ControllerModelArgs: state.ModelArgs{ CloudName: "dummy", Owner: owner, Config: cfg, StorageProviderRegistry: storage.StaticProviderRegistry{}, }, CloudName: "dummy", Cloud: cloud.Cloud{ Type: "dummy", AuthTypes: []cloud.AuthType{cloud.EmptyAuthType}, RegionConfig: regionInheritedConfigIn, // Init with phony region-config }, ControllerInheritedConfig: controllerInheritedConfigIn, MongoInfo: statetesting.NewMongoInfo(), MongoDialOpts: mongotest.DialOpts(), }) c.Assert(err, jc.ErrorIsNil) c.Assert(st, gc.NotNil) modelTag := st.ModelTag() c.Assert(modelTag.Id(), gc.Equals, uuid) err = st.Close() c.Assert(err, jc.ErrorIsNil) s.openState(c, modelTag) var attrs map[string]interface{} for r := range regionInheritedConfigIn { rspec := &environs.RegionSpec{Cloud: "dummy", Region: r} got, err := s.State.ComposeNewModelConfig(attrs, rspec) c.Check(err, jc.ErrorIsNil) c.Assert(got["no-proxy"], gc.Equals, regionInheritedConfigIn[r]["no-proxy"]) } }
func (s *UpgradeSuite) openStateForUpgrade() (*state.State, error) { mongoInfo := s.State.MongoConnectionInfo() newPolicy := stateenvirons.GetNewPolicyFunc( stateenvirons.GetNewEnvironFunc(environs.New), ) st, err := state.Open(s.State.ModelTag(), s.State.ControllerTag(), mongoInfo, mongotest.DialOpts(), newPolicy) if err != nil { return nil, err } return st, nil }
func testOpenState(c *gc.C, info *mongo.MongoInfo, expectErrType error) { st, err := state.Open(testing.ModelTag, info, mongotest.DialOpts(), environs.NewStatePolicy()) if st != nil { st.Close() } if expectErrType != nil { c.Assert(err, gc.FitsTypeOf, expectErrType) } else { c.Assert(err, jc.ErrorIsNil) } }
// Initialize initializes the state and returns it. If state was not // already initialized, and cfg is nil, the minimal default model // configuration will be used. func Initialize(c *gc.C, owner names.UserTag, cfg *config.Config, policy state.Policy) *state.State { if cfg == nil { cfg = testing.ModelConfig(c) } mgoInfo := NewMongoInfo() dialOpts := mongotest.DialOpts() st, err := state.Initialize(owner, mgoInfo, cfg, dialOpts, policy) c.Assert(err, jc.ErrorIsNil) return st }
func (s *InitializeSuite) TestInitializeWithControllerInheritedConfig(c *gc.C) { cfg := testing.ModelConfig(c) uuid := cfg.UUID() initial := cfg.AllAttrs() controllerInheritedConfigIn := map[string]interface{}{ "default-series": initial["default-series"], } owner := names.NewLocalUserTag("initialize-admin") controllerCfg := testing.FakeControllerConfig() st, err := state.Initialize(state.InitializeParams{ Clock: clock.WallClock, ControllerConfig: controllerCfg, ControllerModelArgs: state.ModelArgs{ CloudName: "dummy", Owner: owner, Config: cfg, StorageProviderRegistry: storage.StaticProviderRegistry{}, }, CloudName: "dummy", Cloud: cloud.Cloud{ Type: "dummy", AuthTypes: []cloud.AuthType{cloud.EmptyAuthType}, }, ControllerInheritedConfig: controllerInheritedConfigIn, MongoInfo: statetesting.NewMongoInfo(), MongoDialOpts: mongotest.DialOpts(), }) c.Assert(err, jc.ErrorIsNil) c.Assert(st, gc.NotNil) modelTag := st.ModelTag() c.Assert(modelTag.Id(), gc.Equals, uuid) err = st.Close() c.Assert(err, jc.ErrorIsNil) s.openState(c, modelTag) controllerInheritedConfig, err := state.ReadSettings(s.State, state.GlobalSettingsC, state.ControllerInheritedSettingsGlobalKey) c.Assert(err, jc.ErrorIsNil) c.Assert(controllerInheritedConfig.Map(), jc.DeepEquals, controllerInheritedConfigIn) expected := cfg.AllAttrs() for k, v := range config.ConfigDefaults() { if _, ok := expected[k]; !ok { expected[k] = v } } // Config as read from state has resources tags coerced to a map. expected["resource-tags"] = map[string]string{} cfg, err = s.State.ModelConfig() c.Assert(err, jc.ErrorIsNil) c.Assert(cfg.AllAttrs(), jc.DeepEquals, expected) }
// InitializeWithArgs initializes the state and returns it. If state was not // already initialized, and args.Config is nil, the minimal default model // configuration will be used. func InitializeWithArgs(c *gc.C, args InitializeArgs) *state.State { if args.InitialConfig == nil { args.InitialConfig = testing.ModelConfig(c) } mgoInfo := NewMongoInfo() dialOpts := mongotest.DialOpts() controllerCfg := testing.FakeControllerConfig() st, err := state.Initialize(state.InitializeParams{ Clock: args.Clock, ControllerConfig: controllerCfg, ControllerModelArgs: state.ModelArgs{ CloudName: "dummy", CloudRegion: "dummy-region", Config: args.InitialConfig, Owner: args.Owner, StorageProviderRegistry: StorageProviders(), }, ControllerInheritedConfig: args.ControllerInheritedConfig, CloudName: "dummy", Cloud: cloud.Cloud{ Type: "dummy", AuthTypes: []cloud.AuthType{cloud.EmptyAuthType}, Regions: []cloud.Region{ cloud.Region{ Name: "dummy-region", Endpoint: "dummy-endpoint", IdentityEndpoint: "dummy-identity-endpoint", StorageEndpoint: "dummy-storage-endpoint", }, cloud.Region{ Name: "nether-region", Endpoint: "nether-endpoint", IdentityEndpoint: "nether-identity-endpoint", StorageEndpoint: "nether-storage-endpoint", }, cloud.Region{ Name: "unused-region", Endpoint: "unused-endpoint", IdentityEndpoint: "unused-identity-endpoint", StorageEndpoint: "unused-storage-endpoint", }, }, RegionConfig: args.RegionConfig, }, MongoInfo: mgoInfo, MongoDialOpts: dialOpts, NewPolicy: args.NewPolicy, }) c.Assert(err, jc.ErrorIsNil) return st }
func (s *provisionerSuite) TestContainerManagerConfigLXC(c *gc.C) { args := params.ContainerManagerConfigParams{Type: instance.LXC} st, err := state.Open(s.State.ModelTag(), s.MongoInfo(c), mongotest.DialOpts(), state.Policy(nil)) c.Assert(err, jc.ErrorIsNil) defer st.Close() tests := []struct { lxcUseClone bool lxcUseCloneAufs bool expectedUseClone string expectedUseCloneAufs string }{{ lxcUseClone: true, expectedUseClone: "true", expectedUseCloneAufs: "false", }, { lxcUseClone: false, expectedUseClone: "false", expectedUseCloneAufs: "false", }, { lxcUseCloneAufs: false, expectedUseClone: "false", expectedUseCloneAufs: "false", }, { lxcUseClone: true, lxcUseCloneAufs: true, expectedUseClone: "true", expectedUseCloneAufs: "true", }} result, err := s.provisioner.ContainerManagerConfig(args) c.Assert(err, jc.ErrorIsNil) c.Assert(result.ManagerConfig[container.ConfigName], gc.Equals, "juju") c.Assert(result.ManagerConfig["use-clone"], gc.Equals, "") // Change lxc-clone, and ensure it gets picked up. for i, t := range tests { c.Logf("test %d: %+v", i, t) err = st.UpdateModelConfig(map[string]interface{}{ "lxc-clone": t.lxcUseClone, "lxc-clone-aufs": t.lxcUseCloneAufs, }, nil, nil) c.Assert(err, jc.ErrorIsNil) result, err := s.provisioner.ContainerManagerConfig(args) c.Assert(err, jc.ErrorIsNil) c.Assert(result.ManagerConfig[container.ConfigName], gc.Equals, "juju") c.Assert(result.ManagerConfig["use-clone"], gc.Equals, t.expectedUseClone) c.Assert(result.ManagerConfig["use-aufs"], gc.Equals, t.expectedUseCloneAufs) } }
func (s *InitializeSuite) TestInitialize(c *gc.C) { cfg := testing.ModelConfig(c) uuid := cfg.UUID() initial := cfg.AllAttrs() owner := names.NewLocalUserTag("initialize-admin") st, err := state.Initialize(owner, statetesting.NewMongoInfo(), cfg, mongotest.DialOpts(), nil) c.Assert(err, jc.ErrorIsNil) c.Assert(st, gc.NotNil) modelTag := st.ModelTag() c.Assert(modelTag.Id(), gc.Equals, uuid) err = st.Close() c.Assert(err, jc.ErrorIsNil) s.openState(c, modelTag) cfg, err = s.State.ModelConfig() c.Assert(err, jc.ErrorIsNil) c.Assert(cfg.AllAttrs(), gc.DeepEquals, initial) // Check that the model has been created. env, err := s.State.Model() c.Assert(err, jc.ErrorIsNil) c.Assert(env.Tag(), gc.Equals, modelTag) // Check that the owner has been created. c.Assert(env.Owner(), gc.Equals, owner) // Check that the owner can be retrieved by the tag. entity, err := s.State.FindEntity(env.Owner()) c.Assert(err, jc.ErrorIsNil) c.Assert(entity.Tag(), gc.Equals, owner) // Check that the owner has an ModelUser created for the bootstrapped model. modelUser, err := s.State.ModelUser(env.Owner()) c.Assert(err, jc.ErrorIsNil) c.Assert(modelUser.UserTag(), gc.Equals, owner) c.Assert(modelUser.ModelTag(), gc.Equals, env.Tag()) // Check that the model can be found through the tag. entity, err = s.State.FindEntity(modelTag) c.Assert(err, jc.ErrorIsNil) cons, err := s.State.ModelConstraints() c.Assert(err, jc.ErrorIsNil) c.Assert(&cons, jc.Satisfies, constraints.IsEmpty) addrs, err := s.State.APIHostPorts() c.Assert(err, jc.ErrorIsNil) c.Assert(addrs, gc.HasLen, 0) info, err := s.State.ControllerInfo() c.Assert(err, jc.ErrorIsNil) c.Assert(info, jc.DeepEquals, &state.ControllerInfo{ModelTag: modelTag}) }
func (s *bootstrapSuite) assertCanLogInAsAdmin(c *gc.C, modelTag names.ModelTag, password string) { info := &mongo.MongoInfo{ Info: mongo.Info{ Addrs: []string{s.mgoInst.Addr()}, CACert: testing.CACert, }, Tag: nil, // admin user Password: password, } st, err := state.Open(modelTag, info, mongotest.DialOpts(), environs.NewStatePolicy()) c.Assert(err, jc.ErrorIsNil) defer st.Close() _, err = st.Machine("0") c.Assert(err, jc.ErrorIsNil) }
func (s *InitializeSuite) testBadModelConfig(c *gc.C, update map[string]interface{}, remove []string, expect string) { good := testing.CustomModelConfig(c, testing.Attrs{"uuid": testing.ModelTag.Id()}) bad, err := good.Apply(update) c.Assert(err, jc.ErrorIsNil) bad, err = bad.Remove(remove) c.Assert(err, jc.ErrorIsNil) owner := names.NewLocalUserTag("initialize-admin") controllerCfg := testing.FakeControllerConfig() args := state.InitializeParams{ Clock: clock.WallClock, ControllerConfig: controllerCfg, ControllerModelArgs: state.ModelArgs{ CloudName: "dummy", CloudRegion: "dummy-region", Owner: owner, Config: bad, StorageProviderRegistry: storage.StaticProviderRegistry{}, }, CloudName: "dummy", Cloud: cloud.Cloud{ Type: "dummy", AuthTypes: []cloud.AuthType{cloud.EmptyAuthType}, Regions: []cloud.Region{{Name: "dummy-region"}}, }, MongoInfo: statetesting.NewMongoInfo(), MongoDialOpts: mongotest.DialOpts(), } _, err = state.Initialize(args) c.Assert(err, gc.ErrorMatches, expect) args.ControllerModelArgs.Config = good st, err := state.Initialize(args) c.Assert(err, jc.ErrorIsNil) st.Close() s.openState(c, st.ModelTag()) err = s.State.UpdateModelConfig(update, remove, nil) c.Assert(err, gc.ErrorMatches, expect) // ModelConfig remains inviolate. cfg, err := s.State.ModelConfig() c.Assert(err, jc.ErrorIsNil) goodWithDefaults, err := config.New(config.UseDefaults, good.AllAttrs()) c.Assert(err, jc.ErrorIsNil) c.Assert(cfg.AllAttrs(), jc.DeepEquals, goodWithDefaults.AllAttrs()) }
// Initialize initializes the state and returns it. If state was not // already initialized, and cfg is nil, the minimal default model // configuration will be used. func Initialize(c *gc.C, owner names.UserTag, cfg *config.Config, controllerInheritedConfig map[string]interface{}, regionConfig cloud.RegionConfig, newPolicy state.NewPolicyFunc) *state.State { if cfg == nil { cfg = testing.ModelConfig(c) } mgoInfo := NewMongoInfo() dialOpts := mongotest.DialOpts() controllerCfg := testing.FakeControllerConfig() st, err := state.Initialize(state.InitializeParams{ Clock: clock.WallClock, ControllerConfig: controllerCfg, ControllerModelArgs: state.ModelArgs{ CloudName: "dummy", CloudRegion: "dummy-region", Config: cfg, Owner: owner, StorageProviderRegistry: StorageProviders(), }, ControllerInheritedConfig: controllerInheritedConfig, CloudName: "dummy", Cloud: cloud.Cloud{ Type: "dummy", AuthTypes: []cloud.AuthType{cloud.EmptyAuthType}, Regions: []cloud.Region{ cloud.Region{ Name: "dummy-region", Endpoint: "dummy-endpoint", IdentityEndpoint: "dummy-identity-endpoint", StorageEndpoint: "dummy-storage-endpoint", }, cloud.Region{ Name: "nether-region", Endpoint: "nether-endpoint", IdentityEndpoint: "nether-identity-endpoint", StorageEndpoint: "nether-storage-endpoint", }, }, RegionConfig: regionConfig, }, MongoInfo: mgoInfo, MongoDialOpts: dialOpts, NewPolicy: newPolicy, }) c.Assert(err, jc.ErrorIsNil) return st }
func (s *ModelConfigSourceSuite) TestUpdateModelConfigDefaults(c *gc.C) { // Set up values that will be removed. attrs := map[string]interface{}{ "http-proxy": "http://http-proxy", "https-proxy": "https://https-proxy", } err := s.State.UpdateModelConfigDefaultValues(attrs, nil, nil) c.Assert(err, jc.ErrorIsNil) attrs = map[string]interface{}{ "apt-mirror": "http://different-mirror", } err = s.State.UpdateModelConfigDefaultValues(attrs, []string{"http-proxy", "https-proxy"}, nil) c.Assert(err, jc.ErrorIsNil) info := statetesting.NewMongoInfo() anotherState, err := state.Open(s.modelTag, s.State.ControllerTag(), info, mongotest.DialOpts(), state.NewPolicyFunc(nil)) c.Assert(err, jc.ErrorIsNil) defer anotherState.Close() cfg, err := anotherState.ModelConfigDefaultValues() c.Assert(err, jc.ErrorIsNil) expectedValues := make(config.ModelDefaultAttributes) for attr, val := range config.ConfigDefaults() { expectedValues[attr] = config.AttributeDefaultValues{ Default: val, } } delete(expectedValues, "http-mirror") delete(expectedValues, "https-mirror") expectedValues["apt-mirror"] = config.AttributeDefaultValues{ Controller: "http://different-mirror", Default: "", Regions: []config.RegionDefaultValue{{ Name: "dummy-region", Value: "http://dummy-mirror", }}} expectedValues["no-proxy"] = config.AttributeDefaultValues{ Default: "", Regions: []config.RegionDefaultValue{{ Name: "dummy-region", Value: "dummy-proxy", }}} c.Assert(cfg, jc.DeepEquals, expectedValues) }
func assertWrittenToState(c *gc.C, metadata cloudimagemetadata.Metadata) { st, err := state.Open(testing.ModelTag, &mongo.MongoInfo{ Info: mongo.Info{ Addrs: []string{gitjujutesting.MgoServer.Addr()}, CACert: testing.CACert, }, Password: testPassword, }, mongotest.DialOpts(), environs.NewStatePolicy()) c.Assert(err, jc.ErrorIsNil) defer st.Close() // find all image metadata in state all, err := st.CloudImageMetadataStorage.FindMetadata(cloudimagemetadata.MetadataFilter{}) c.Assert(err, jc.ErrorIsNil) c.Assert(all, gc.DeepEquals, map[string][]cloudimagemetadata.Metadata{ metadata.Source: []cloudimagemetadata.Metadata{metadata}, }) }
func (s *InitializeSuite) TestDoubleInitializeConfig(c *gc.C) { cfg := testing.ModelConfig(c) owner := names.NewLocalUserTag("initialize-admin") mgoInfo := statetesting.NewMongoInfo() dialOpts := mongotest.DialOpts() st, err := state.Initialize(owner, mgoInfo, cfg, dialOpts, state.Policy(nil)) c.Assert(err, jc.ErrorIsNil) err = st.Close() c.Check(err, jc.ErrorIsNil) st, err = state.Initialize(owner, mgoInfo, cfg, dialOpts, state.Policy(nil)) c.Check(err, gc.ErrorMatches, "already initialized") if !c.Check(st, gc.IsNil) { err = st.Close() c.Check(err, jc.ErrorIsNil) } }
func (s *internalStateSuite) SetUpTest(c *gc.C) { s.MgoSuite.SetUpTest(c) s.BaseSuite.SetUpTest(c) s.owner = names.NewLocalUserTag("test-admin") // Copied from NewMongoInfo (due to import loops). info := &mongo.MongoInfo{ Info: mongo.Info{ Addrs: []string{jujutesting.MgoServer.Addr()}, CACert: testing.CACert, }, } dialopts := mongotest.DialOpts() st, err := Initialize(s.owner, info, testing.ModelConfig(c), dialopts, nil) c.Assert(err, jc.ErrorIsNil) s.state = st s.AddCleanup(func(*gc.C) { s.state.Close() }) }