func (s *agentSuite) testOpenAPIState(c *gc.C, ent state.AgentEntity, agentCmd Agent, initialPassword string) {
conf, err := agent.ReadConfig(agent.ConfigPath(s.DataDir(), ent.Tag()))
c.Assert(err, gc.IsNil)
conf.SetPassword("")
err = conf.Write()
c.Assert(err, gc.IsNil)
// Check that it starts initially and changes the password
assertOpen := func(conf agent.Config) {
st, gotEnt, err := openAPIState(conf, agentCmd)
c.Assert(err, gc.IsNil)
c.Assert(st, gc.NotNil)
st.Close()
c.Assert(gotEnt.Tag(), gc.Equals, ent.Tag())
}
assertOpen(conf)
// Check that the initial password is no longer valid.
err = ent.Refresh()
c.Assert(err, gc.IsNil)
c.Assert(ent.PasswordValid(initialPassword), gc.Equals, false)
// Read the configuration and check that we can connect with it.
conf = refreshConfig(c, conf)
// Check we can open the API with the new configuration.
assertOpen(conf)
}
func (s *UpgradeSuite) assertUpgradeSteps(c *gc.C, job state.MachineJob) {
s.agentSuite.PatchValue(&version.Current, s.upgradeToVersion)
err := s.State.SetEnvironAgentVersion(s.upgradeToVersion.Number)
c.Assert(err, gc.IsNil)
oldVersion := s.upgradeToVersion
oldVersion.Major = 1
oldVersion.Minor = 16
var oldConfig agent.Config
s.machine, oldConfig, _ = s.primeAgent(c, oldVersion, job)
a := s.newAgent(c, s.machine)
go func() { c.Check(a.Run(nil), gc.IsNil) }()
defer func() { c.Check(a.Stop(), gc.IsNil) }()
// Wait for upgrade steps to run.
success := false
for attempt := coretesting.LongAttempt.Start(); attempt.Next(); {
conf, err := agent.ReadConfig(agent.ConfigPath(oldConfig.DataDir(), s.machine.Tag()))
c.Assert(err, gc.IsNil)
success = conf.UpgradedToVersion() == s.upgradeToVersion.Number
if success {
break
}
}
// Upgrade worker has completed ok.
c.Assert(success, jc.IsTrue)
}
func (s *agentSuite) assertCanOpenState(c *gc.C, tag, dataDir string) {
config, err := agent.ReadConfig(agent.ConfigPath(dataDir, tag))
c.Assert(err, gc.IsNil)
info, ok := config.StateInfo()
c.Assert(ok, jc.IsTrue)
st, err := state.Open(info, state.DialOpts{}, environs.NewStatePolicy())
c.Assert(err, gc.IsNil)
st.Close()
}
func (s *BootstrapSuite) TestInitialPassword(c *gc.C) {
machineConf, cmd, err := s.initBootstrapCommand(c, nil, "--env-config", s.envcfg, "--instance-id", string(s.instanceId))
c.Assert(err, gc.IsNil)
err = cmd.Run(nil)
c.Assert(err, gc.IsNil)
// Check that we cannot now connect to the state without a
// password.
info := &state.Info{
Addrs: []string{testing.MgoServer.Addr()},
CACert: testing.CACert,
}
testOpenState(c, info, errors.Unauthorizedf(""))
// Check we can log in to mongo as admin.
info.Tag, info.Password = "", testPasswordHash()
st, err := state.Open(info, state.DefaultDialOpts(), environs.NewStatePolicy())
c.Assert(err, gc.IsNil)
// Reset password so the tests can continue to use the same server.
defer st.Close()
defer st.SetAdminMongoPassword("")
// Check that the admin user has been given an appropriate
// password
u, err := st.User("admin")
c.Assert(err, gc.IsNil)
c.Assert(u.PasswordValid(testPassword), gc.Equals, true)
// 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(), "machine-0"))
c.Assert(err, gc.IsNil)
stateinfo, ok := machineConf1.StateInfo()
c.Assert(ok, jc.IsTrue)
st, err = state.Open(stateinfo, state.DialOpts{}, environs.NewStatePolicy())
c.Assert(err, gc.IsNil)
defer st.Close()
m, err := st.Machine("0")
c.Assert(err, gc.IsNil)
c.Assert(m.HasVote(), jc.IsTrue)
}
func (fix *SimpleToolsFixture) checkUnitInstalled(c *gc.C, name, password string) {
tag := names.UnitTag(name)
uconfPath, _, toolsDir := fix.paths(tag)
uconfData, err := ioutil.ReadFile(uconfPath)
c.Assert(err, gc.IsNil)
uconf := string(uconfData)
var execLine string
for _, line := range strings.Split(uconf, "\n") {
if strings.HasPrefix(line, "exec ") {
execLine = line
break
}
}
if execLine == "" {
c.Fatalf("no command found in %s:\n%s", uconfPath, uconf)
}
logPath := filepath.Join(fix.logDir, tag+".log")
jujudPath := filepath.Join(toolsDir, "jujud")
for _, pat := range []string{
"^exec " + jujudPath + " unit ",
" --unit-name " + name + " ",
" >> " + logPath + " 2>&1$",
} {
match, err := regexp.MatchString(pat, execLine)
c.Assert(err, gc.IsNil)
if !match {
c.Fatalf("failed to match:\n%s\nin:\n%s", pat, execLine)
}
}
conf, err := agent.ReadConfig(agent.ConfigPath(fix.dataDir, tag))
c.Assert(err, gc.IsNil)
c.Assert(conf.Tag(), gc.Equals, tag)
c.Assert(conf.DataDir(), gc.Equals, fix.dataDir)
jujudData, err := ioutil.ReadFile(jujudPath)
c.Assert(err, gc.IsNil)
c.Assert(string(jujudData), gc.Equals, fakeJujud)
}
func refreshConfig(c *gc.C, config agent.Config) agent.ConfigSetterWriter {
config1, err := agent.ReadConfig(agent.ConfigPath(config.DataDir(), config.Tag()))
c.Assert(err, gc.IsNil)
return config1
}
func (s *agentSuite) assertCannotOpenState(c *gc.C, tag, dataDir string) {
config, err := agent.ReadConfig(agent.ConfigPath(dataDir, tag))
c.Assert(err, gc.IsNil)
_, ok := config.StateInfo()
c.Assert(ok, jc.IsFalse)
}