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() })
}