func (t *Tests) TestBootstrap(c *gc.C) {
e := t.Prepare(c)
t.UploadFakeTools(c, e.Storage())
err := bootstrap.EnsureNotBootstrapped(e)
c.Assert(err, gc.IsNil)
err = bootstrap.Bootstrap(coretesting.Context(c), e, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
info, apiInfo, err := e.StateInfo()
c.Check(info.Addrs, gc.Not(gc.HasLen), 0)
c.Check(apiInfo.Addrs, gc.Not(gc.HasLen), 0)
err = bootstrap.EnsureNotBootstrapped(e)
c.Assert(err, gc.ErrorMatches, "environment is already bootstrapped")
e2 := t.Open(c)
t.UploadFakeTools(c, e2.Storage())
err = bootstrap.EnsureNotBootstrapped(e2)
c.Assert(err, gc.ErrorMatches, "environment is already bootstrapped")
checkSameInfo := func(a, b *state.Info) {
c.Check(a.Addrs, jc.SameContents, b.Addrs)
c.Check(a.CACert, gc.DeepEquals, b.CACert)
}
info2, apiInfo2, err := e2.StateInfo()
checkSameInfo(info2, info)
c.Check(apiInfo2, gc.DeepEquals, apiInfo)
err = environs.Destroy(e2, t.ConfigStore)
c.Assert(err, gc.IsNil)
// Prepare again because Destroy invalidates old environments.
e3 := t.Prepare(c)
t.UploadFakeTools(c, e3.Storage())
err = bootstrap.EnsureNotBootstrapped(e3)
c.Assert(err, gc.IsNil)
err = bootstrap.Bootstrap(coretesting.Context(c), e3, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
err = bootstrap.EnsureNotBootstrapped(e3)
c.Assert(err, gc.ErrorMatches, "environment is already bootstrapped")
}
func (t *Tests) TestBootstrap(c *gc.C) {
e := t.Prepare(c)
t.UploadFakeTools(c, e.Storage())
err := bootstrap.EnsureNotBootstrapped(e)
c.Assert(err, gc.IsNil)
err = bootstrap.Bootstrap(coretesting.Context(c), e, bootstrap.BootstrapParams{})
c.Assert(err, gc.IsNil)
stateServerInstances, err := e.StateServerInstances()
c.Assert(err, gc.IsNil)
c.Assert(stateServerInstances, gc.Not(gc.HasLen), 0)
err = bootstrap.EnsureNotBootstrapped(e)
c.Assert(err, gc.ErrorMatches, "environment is already bootstrapped")
e2 := t.Open(c)
t.UploadFakeTools(c, e2.Storage())
err = bootstrap.EnsureNotBootstrapped(e2)
c.Assert(err, gc.ErrorMatches, "environment is already bootstrapped")
stateServerInstances2, err := e2.StateServerInstances()
c.Assert(err, gc.IsNil)
c.Assert(stateServerInstances2, gc.Not(gc.HasLen), 0)
c.Assert(stateServerInstances2, jc.SameContents, stateServerInstances)
err = environs.Destroy(e2, t.ConfigStore)
c.Assert(err, gc.IsNil)
// Prepare again because Destroy invalidates old environments.
e3 := t.Prepare(c)
t.UploadFakeTools(c, e3.Storage())
err = bootstrap.EnsureNotBootstrapped(e3)
c.Assert(err, gc.IsNil)
err = bootstrap.Bootstrap(coretesting.Context(c), e3, bootstrap.BootstrapParams{})
c.Assert(err, gc.IsNil)
err = bootstrap.EnsureNotBootstrapped(e3)
c.Assert(err, gc.ErrorMatches, "environment is already bootstrapped")
err = environs.Destroy(e3, t.ConfigStore)
c.Assert(err, gc.IsNil)
}
func (t *Tests) TestBootstrap(c *gc.C) {
e := t.Prepare(c)
err := bootstrap.EnsureNotBootstrapped(e)
c.Assert(err, jc.ErrorIsNil)
err = bootstrap.Bootstrap(envtesting.BootstrapContext(c), e, bootstrap.BootstrapParams{})
c.Assert(err, jc.ErrorIsNil)
controllerInstances, err := e.ControllerInstances()
c.Assert(err, jc.ErrorIsNil)
c.Assert(controllerInstances, gc.Not(gc.HasLen), 0)
err = bootstrap.EnsureNotBootstrapped(e)
c.Assert(err, gc.ErrorMatches, "model is already bootstrapped")
e2 := t.Open(c)
err = bootstrap.EnsureNotBootstrapped(e2)
c.Assert(err, gc.ErrorMatches, "model is already bootstrapped")
controllerInstances2, err := e2.ControllerInstances()
c.Assert(err, jc.ErrorIsNil)
c.Assert(controllerInstances2, gc.Not(gc.HasLen), 0)
c.Assert(controllerInstances2, jc.SameContents, controllerInstances)
err = environs.Destroy(e2, t.ConfigStore)
c.Assert(err, jc.ErrorIsNil)
// Prepare again because Destroy invalidates old environments.
e3 := t.Prepare(c)
err = bootstrap.EnsureNotBootstrapped(e3)
c.Assert(err, jc.ErrorIsNil)
err = bootstrap.Bootstrap(envtesting.BootstrapContext(c), e3, bootstrap.BootstrapParams{})
c.Assert(err, jc.ErrorIsNil)
err = bootstrap.EnsureNotBootstrapped(e3)
c.Assert(err, gc.ErrorMatches, "model is already bootstrapped")
err = environs.Destroy(e3, t.ConfigStore)
c.Assert(err, jc.ErrorIsNil)
}
func (s *suite) bootstrapTestEnviron(c *gc.C) environs.Environ {
cfg, err := config.New(config.NoDefaults, s.TestConfig)
c.Assert(err, gc.IsNil)
e, err := environs.Prepare(cfg, testing.Context(c), s.ConfigStore)
c.Assert(err, gc.IsNil, gc.Commentf("preparing environ %#v", s.TestConfig))
c.Assert(e, gc.NotNil)
envtesting.UploadFakeTools(c, e.Storage())
err = bootstrap.EnsureNotBootstrapped(e)
c.Assert(err, gc.IsNil)
err = bootstrap.Bootstrap(testing.Context(c), e, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
return e
}
func (t *LiveTests) TestBootstrapMultiple(c *gc.C) {
// bootstrap.Bootstrap no longer raises errors if the environment is
// already up, this has been moved into the bootstrap command.
t.BootstrapOnce(c)
err := bootstrap.EnsureNotBootstrapped(t.Env)
c.Assert(err, gc.ErrorMatches, "environment is already bootstrapped")
c.Logf("destroy env")
env := t.Env
t.Destroy(c)
env.Destroy() // Again, should work fine and do nothing.
// check that we can bootstrap after destroy
t.BootstrapOnce(c)
}
func (s *suite) bootstrapTestEnviron(c *gc.C, preferIPv6 bool) environs.NetworkingEnviron {
s.TestConfig["prefer-ipv6"] = preferIPv6
cfg, err := config.New(config.NoDefaults, s.TestConfig)
c.Assert(err, jc.ErrorIsNil)
env, err := environs.Prepare(cfg, envtesting.BootstrapContext(c), s.ConfigStore)
c.Assert(err, gc.IsNil, gc.Commentf("preparing environ %#v", s.TestConfig))
c.Assert(env, gc.NotNil)
netenv, supported := environs.SupportsNetworking(env)
c.Assert(supported, jc.IsTrue)
err = bootstrap.EnsureNotBootstrapped(netenv)
c.Assert(err, jc.ErrorIsNil)
err = bootstrap.Bootstrap(envtesting.BootstrapContext(c), netenv, bootstrap.BootstrapParams{})
c.Assert(err, jc.ErrorIsNil)
return netenv
}
func (t *LiveTests) BootstrapOnce(c *gc.C) {
if t.bootstrapped {
return
}
t.PrepareOnce(c)
// We only build and upload tools if there will be a state agent that
// we could connect to (actual live tests, rather than local-only)
cons := constraints.MustParse("mem=2G")
if t.CanOpenState {
_, err := sync.Upload(t.toolsStorage, "released", nil, coretesting.FakeDefaultSeries)
c.Assert(err, jc.ErrorIsNil)
}
err := bootstrap.EnsureNotBootstrapped(t.Env)
c.Assert(err, jc.ErrorIsNil)
err = bootstrap.Bootstrap(envtesting.BootstrapContext(c), t.Env, bootstrap.BootstrapParams{Constraints: cons})
c.Assert(err, jc.ErrorIsNil)
t.bootstrapped = true
}
func (b bootstrapFuncs) EnsureNotBootstrapped(env environs.Environ) error {
return bootstrap.EnsureNotBootstrapped(env)
}