func (s *destroyEnvSuite) TestDestroyEnvironmentCommandEFlag(c *gc.C) {
// Prepare the environment so we can destroy it.
_, err := environs.PrepareFromName("dummyenv", cmdtesting.NullContext(c), s.ConfigStore)
c.Assert(err, gc.IsNil)
// check that either environment or the flag is mandatory
opc, errc := cmdtesting.RunCommand(cmdtesting.NullContext(c), new(DestroyEnvironmentCommand))
c.Check(<-errc, gc.Equals, NoEnvironmentError)
// We don't allow them to supply both entries at the same time
opc, errc = cmdtesting.RunCommand(cmdtesting.NullContext(c), new(DestroyEnvironmentCommand), "-e", "dummyenv", "dummyenv", "--yes")
c.Check(<-errc, gc.Equals, DoubleEnvironmentError)
// We treat --environment the same way
opc, errc = cmdtesting.RunCommand(cmdtesting.NullContext(c), new(DestroyEnvironmentCommand), "--environment", "dummyenv", "dummyenv", "--yes")
c.Check(<-errc, gc.Equals, DoubleEnvironmentError)
// destroy using the -e flag
opc, errc = cmdtesting.RunCommand(cmdtesting.NullContext(c), new(DestroyEnvironmentCommand), "-e", "dummyenv", "--yes")
c.Check(<-errc, gc.IsNil)
c.Check((<-opc).(dummy.OpDestroy).Env, gc.Equals, "dummyenv")
// Verify that the environment information has been removed.
_, err = s.ConfigStore.ReadInfo("dummyenv")
c.Assert(err, jc.Satisfies, errors.IsNotFound)
}
func (s *destroyEnvSuite) checkDestroyEnvironment(c *gc.C, blocked, force bool) {
//Setup environment
envName := "dummyenv"
s.startEnvironment(c, envName)
if blocked {
s.BlockDestroyEnvironment(c, "checkDestroyEnvironment")
}
opc := make(chan dummy.Operation)
errc := make(chan error)
if force {
opc, errc = cmdtesting.RunCommand(cmdtesting.NullContext(c), newDestroyEnvironmentCommand(), envName, "--yes", "--force")
} else {
opc, errc = cmdtesting.RunCommand(cmdtesting.NullContext(c), newDestroyEnvironmentCommand(), envName, "--yes")
}
if force || !blocked {
c.Check(<-errc, gc.IsNil)
c.Check((<-opc).(dummy.OpDestroy).Env, gc.Equals, envName)
// Verify that the environment information has been removed.
_, err := s.ConfigStore.ReadInfo(envName)
c.Assert(err, jc.Satisfies, errors.IsNotFound)
} else {
c.Check(<-errc, gc.Not(gc.IsNil))
c.Check((<-opc), gc.IsNil)
// Verify that the environment information has not been removed.
_, err := s.ConfigStore.ReadInfo(envName)
c.Assert(err, jc.ErrorIsNil)
}
}
func (s *destroyEnvSuite) TestDestroyEnvironmentCommandConfirmation(c *gc.C) {
var stdin, stdout bytes.Buffer
ctx, err := cmd.DefaultContext()
c.Assert(err, gc.IsNil)
ctx.Stdout = &stdout
ctx.Stdin = &stdin
// Prepare the environment so we can destroy it.
env, err := environs.PrepareFromName("dummyenv", cmdtesting.NullContext(c), s.ConfigStore)
c.Assert(err, gc.IsNil)
assertEnvironNotDestroyed(c, env, s.ConfigStore)
// Ensure confirmation is requested if "-y" is not specified.
stdin.WriteString("n")
opc, errc := cmdtesting.RunCommand(ctx, new(DestroyEnvironmentCommand), "dummyenv")
c.Check(<-errc, gc.ErrorMatches, "environment destruction aborted")
c.Check(<-opc, gc.IsNil)
c.Check(stdout.String(), gc.Matches, "WARNING!.*dummyenv.*\\(type: dummy\\)(.|\n)*")
assertEnvironNotDestroyed(c, env, s.ConfigStore)
// EOF on stdin: equivalent to answering no.
stdin.Reset()
stdout.Reset()
opc, errc = cmdtesting.RunCommand(ctx, new(DestroyEnvironmentCommand), "dummyenv")
c.Check(<-opc, gc.IsNil)
c.Check(<-errc, gc.ErrorMatches, "environment destruction aborted")
assertEnvironNotDestroyed(c, env, s.ConfigStore)
// "--yes" passed: no confirmation request.
stdin.Reset()
stdout.Reset()
opc, errc = cmdtesting.RunCommand(ctx, new(DestroyEnvironmentCommand), "dummyenv", "--yes")
c.Check(<-errc, gc.IsNil)
c.Check((<-opc).(dummy.OpDestroy).Env, gc.Equals, "dummyenv")
c.Check(stdout.String(), gc.Equals, "")
assertEnvironDestroyed(c, env, s.ConfigStore)
// Any of casing of "y" and "yes" will confirm.
for _, answer := range []string{"y", "Y", "yes", "YES"} {
// Prepare the environment so we can destroy it.
s.Reset(c)
env, err := environs.PrepareFromName("dummyenv", cmdtesting.NullContext(c), s.ConfigStore)
c.Assert(err, gc.IsNil)
stdin.Reset()
stdout.Reset()
stdin.WriteString(answer)
opc, errc = cmdtesting.RunCommand(ctx, new(DestroyEnvironmentCommand), "dummyenv")
c.Check(<-errc, gc.IsNil)
c.Check((<-opc).(dummy.OpDestroy).Env, gc.Equals, "dummyenv")
c.Check(stdout.String(), gc.Matches, "WARNING!.*dummyenv.*\\(type: dummy\\)(.|\n)*")
assertEnvironDestroyed(c, env, s.ConfigStore)
}
}
func (s *DestroySuite) TestDestroyCommandConfirmation(c *gc.C) {
var stdin, stdout bytes.Buffer
ctx, err := cmd.DefaultContext()
c.Assert(err, jc.ErrorIsNil)
ctx.Stdout = &stdout
ctx.Stdin = &stdin
// Ensure confirmation is requested if "-y" is not specified.
stdin.WriteString("n")
_, errc := cmdtesting.RunCommand(ctx, s.NewDestroyCommand(), "test2")
select {
case err := <-errc:
c.Check(err, gc.ErrorMatches, "environment destruction: aborted")
case <-time.After(testing.LongWait):
c.Fatalf("command took too long")
}
c.Check(testing.Stdout(ctx), gc.Matches, "WARNING!.*test2(.|\n)*")
checkEnvironmentExistsInStore(c, "test1", s.store)
// EOF on stdin: equivalent to answering no.
stdin.Reset()
stdout.Reset()
_, errc = cmdtesting.RunCommand(ctx, s.NewDestroyCommand(), "test2")
select {
case err := <-errc:
c.Check(err, gc.ErrorMatches, "environment destruction: aborted")
case <-time.After(testing.LongWait):
c.Fatalf("command took too long")
}
c.Check(testing.Stdout(ctx), gc.Matches, "WARNING!.*test2(.|\n)*")
checkEnvironmentExistsInStore(c, "test1", s.store)
for _, answer := range []string{"y", "Y", "yes", "YES"} {
stdin.Reset()
stdout.Reset()
stdin.WriteString(answer)
_, errc = cmdtesting.RunCommand(ctx, s.NewDestroyCommand(), "test2")
select {
case err := <-errc:
c.Check(err, jc.ErrorIsNil)
case <-time.After(testing.LongWait):
c.Fatalf("command took too long")
}
checkEnvironmentRemovedFromStore(c, "test2", s.store)
// Add the test2 environment back into the store for the next test
s.resetEnvironment(c)
}
}
func (s *destroyEnvSuite) TestDestroyEnvironmentCommandTwiceOnNonStateServer(c *gc.C) {
s.setupHostedEnviron(c, "dummy-non-state-server")
oldInfo, err := s.ConfigStore.ReadInfo("dummy-non-state-server")
c.Assert(err, jc.ErrorIsNil)
opc, errc := cmdtesting.RunCommand(cmdtesting.NullContext(c), newDestroyEnvironmentCommand(), "dummy-non-state-server", "--yes")
c.Check(<-errc, gc.IsNil)
c.Check(<-opc, gc.IsNil)
_, err = s.ConfigStore.ReadInfo("dummy-non-state-server")
c.Assert(err, jc.Satisfies, errors.IsNotFound)
// Simluate another client calling destroy on the same environment. This
// client will have a local cache of the environ info, so write it back out.
info := s.ConfigStore.CreateInfo("dummy-non-state-server")
info.SetAPIEndpoint(oldInfo.APIEndpoint())
info.SetAPICredentials(oldInfo.APICredentials())
err = info.Write()
c.Assert(err, jc.ErrorIsNil)
// Call destroy again.
context, err := coretesting.RunCommand(c, newDestroyEnvironmentCommand(), "dummy-non-state-server", "--yes")
c.Assert(err, jc.ErrorIsNil)
c.Assert(coretesting.Stderr(context), gc.Equals, "environment not found, removing config file\n")
// Check that the client's cached info has been removed.
_, err = s.ConfigStore.ReadInfo("dummy-non-state-server")
c.Assert(err, jc.Satisfies, errors.IsNotFound)
}
func (s *BootstrapSuite) TestBootstrapDestroy(c *gc.C) {
resetJujuXDGDataHome(c)
s.patchVersion(c)
opc, errc := cmdtesting.RunCommand(
cmdtesting.NullContext(c), s.newBootstrapCommand(),
"devcontroller", "dummy-cloud/region-1",
"--config", "broken=Bootstrap Destroy",
"--auto-upgrade",
)
err := <-errc
c.Assert(err, gc.ErrorMatches, "failed to bootstrap model: dummy.Bootstrap is broken")
var opDestroy *dummy.OpDestroy
for opDestroy == nil {
select {
case op := <-opc:
switch op := op.(type) {
case dummy.OpDestroy:
opDestroy = &op
}
default:
c.Error("expected call to env.Destroy")
return
}
}
c.Assert(opDestroy.Error, gc.ErrorMatches, "dummy.Destroy is broken")
}
func (s *BootstrapSuite) TestBootstrapKeepBroken(c *gc.C) {
resetJujuHome(c, "devenv")
devVersion := version.Current
// Force a dev version by having a non zero build number.
// This is because we have not uploaded any tools and auto
// upload is only enabled for dev versions.
devVersion.Build = 1234
s.PatchValue(&version.Current, devVersion)
opc, errc := cmdtesting.RunCommand(cmdtesting.NullContext(c), envcmd.Wrap(new(BootstrapCommand)), "-e", "brokenenv", "--keep-broken")
err := <-errc
c.Assert(err, gc.ErrorMatches, "failed to bootstrap environment: dummy.Bootstrap is broken")
done := false
for !done {
select {
case op, ok := <-opc:
if !ok {
done = true
break
}
switch op.(type) {
case dummy.OpDestroy:
c.Error("unexpected call to env.Destroy")
break
}
default:
break
}
}
}
func (s *BootstrapSuite) TestBootstrapKeepBroken(c *gc.C) {
resetJujuXDGDataHome(c)
s.patchVersion(c)
opc, errc := cmdtesting.RunCommand(cmdtesting.NullContext(c), s.newBootstrapCommand(),
"--keep-broken",
"devcontroller", "dummy-cloud/region-1",
"--config", "broken=Bootstrap Destroy",
"--auto-upgrade",
)
err := <-errc
c.Assert(err, gc.ErrorMatches, "failed to bootstrap model: dummy.Bootstrap is broken")
done := false
for !done {
select {
case op, ok := <-opc:
if !ok {
done = true
break
}
switch op.(type) {
case dummy.OpDestroy:
c.Error("unexpected call to env.Destroy")
break
}
default:
break
}
}
}
func (s *BootstrapSuite) TestAutoUploadOnlyForDev(c *gc.C) {
s.setupAutoUploadTest(c, "1.8.3", "precise")
_, errc := cmdtesting.RunCommand(cmdtesting.NullContext(c), envcmd.Wrap(new(BootstrapCommand)))
err := <-errc
c.Assert(err, gc.ErrorMatches,
"failed to bootstrap environment: Juju cannot bootstrap because no tools are available for your environment(.|\n)*")
}
func (s *BootstrapSuite) TestBootstrapDestroy(c *gc.C) {
resetJujuHome(c, "devenv")
devVersion := version.Current
// Force a dev version by having a non zero build number.
// This is because we have not uploaded any tools and auto
// upload is only enabled for dev versions.
devVersion.Build = 1234
s.PatchValue(&version.Current, devVersion)
opc, errc := cmdtesting.RunCommand(cmdtesting.NullContext(c), envcmd.Wrap(new(BootstrapCommand)), "-e", "brokenenv")
err := <-errc
c.Assert(err, gc.ErrorMatches, "failed to bootstrap environment: dummy.Bootstrap is broken")
var opDestroy *dummy.OpDestroy
for opDestroy == nil {
select {
case op := <-opc:
switch op := op.(type) {
case dummy.OpDestroy:
opDestroy = &op
}
default:
c.Error("expected call to env.Destroy")
return
}
}
c.Assert(opDestroy.Error, gc.ErrorMatches, "dummy.Destroy is broken")
}
func (s *destroyEnvSuite) TestDestroyEnvironmentCommandBroken(c *gc.C) {
oldinfo, err := s.ConfigStore.ReadInfo("dummyenv")
c.Assert(err, gc.IsNil)
bootstrapConfig := oldinfo.BootstrapConfig()
apiEndpoint := oldinfo.APIEndpoint()
apiCredentials := oldinfo.APICredentials()
err = oldinfo.Destroy()
c.Assert(err, gc.IsNil)
newinfo := s.ConfigStore.CreateInfo("dummyenv")
bootstrapConfig["broken"] = "Destroy"
newinfo.SetBootstrapConfig(bootstrapConfig)
newinfo.SetAPIEndpoint(apiEndpoint)
newinfo.SetAPICredentials(apiCredentials)
err = newinfo.Write()
c.Assert(err, gc.IsNil)
// Prepare the environment so we can destroy it.
_, err = environs.PrepareFromName("dummyenv", cmdtesting.NullContext(c), s.ConfigStore)
c.Assert(err, gc.IsNil)
// destroy with broken environment
opc, errc := cmdtesting.RunCommand(cmdtesting.NullContext(c), new(DestroyEnvironmentCommand), "dummyenv", "--yes")
op, ok := (<-opc).(dummy.OpDestroy)
c.Assert(ok, jc.IsTrue)
c.Assert(op.Error, gc.ErrorMatches, "dummy.Destroy is broken")
c.Check(<-errc, gc.Equals, op.Error)
c.Check(<-opc, gc.IsNil)
}
func (s *BootstrapSuite) TestBootstrapKeepBroken(c *gc.C) {
resetJujuHome(c, "devenv")
s.patchVersion(c)
opc, errc := cmdtesting.RunCommand(cmdtesting.NullContext(c), newBootstrapCommand(), "-e", "brokenenv", "--keep-broken", "--auto-upgrade")
err := <-errc
c.Assert(err, gc.ErrorMatches, "failed to bootstrap environment: dummy.Bootstrap is broken")
done := false
for !done {
select {
case op, ok := <-opc:
if !ok {
done = true
break
}
switch op.(type) {
case dummy.OpDestroy:
c.Error("unexpected call to env.Destroy")
break
}
default:
break
}
}
}
func (s *destroyEnvSuite) TestDestroyEnvironmentCommand(c *gc.C) {
// Prepare the environment so we can destroy it.
_, err := environs.PrepareFromName("dummyenv", cmdtesting.NullContext(c), s.ConfigStore)
c.Assert(err, gc.IsNil)
// check environment is mandatory
opc, errc := cmdtesting.RunCommand(cmdtesting.NullContext(c), new(DestroyEnvironmentCommand))
c.Check(<-errc, gc.Equals, NoEnvironmentError)
// normal destroy
opc, errc = cmdtesting.RunCommand(cmdtesting.NullContext(c), new(DestroyEnvironmentCommand), "dummyenv", "--yes")
c.Check(<-errc, gc.IsNil)
c.Check((<-opc).(dummy.OpDestroy).Env, gc.Equals, "dummyenv")
// Verify that the environment information has been removed.
_, err = s.ConfigStore.ReadInfo("dummyenv")
c.Assert(err, jc.Satisfies, errors.IsNotFound)
}
func (s *BootstrapSuite) TestAutoUploadOnlyForDev(c *gc.C) {
s.setupAutoUploadTest(c, "1.8.3", "precise")
_, errc := cmdtesting.RunCommand(
cmdtesting.NullContext(c), s.newBootstrapCommand(),
"devcontroller", "dummy-cloud/region-1",
)
err := <-errc
c.Assert(err, gc.ErrorMatches,
"failed to bootstrap model: Juju cannot bootstrap because no tools are available for your model(.|\n)*")
}
func (s *destroyEnvSuite) TestForceDestroyEnvironmentCommandOnNonStateServerNoConfimFails(c *gc.C) {
s.setupHostedEnviron(c, "dummy-non-state-server")
opc, errc := cmdtesting.RunCommand(cmdtesting.NullContext(c), newDestroyEnvironmentCommand(), "dummy-non-state-server", "--force")
c.Check(<-errc, gc.ErrorMatches, "cannot force destroy environment without bootstrap information")
c.Check(<-opc, gc.IsNil)
serverInfo, err := s.ConfigStore.ReadInfo("dummy-non-state-server")
c.Assert(err, jc.ErrorIsNil)
c.Assert(serverInfo, gc.Not(gc.IsNil))
}
func (s *destroyEnvSuite) TestDestroyEnvironmentCommandNonStateServer(c *gc.C) {
s.setupHostedEnviron(c, "dummy-non-state-server")
opc, errc := cmdtesting.RunCommand(cmdtesting.NullContext(c), newDestroyEnvironmentCommand(), "dummy-non-state-server", "--yes")
c.Check(<-errc, gc.IsNil)
// Check that there are no operations on the provider, we do not want to call
// Destroy on it.
c.Check(<-opc, gc.IsNil)
_, err := s.ConfigStore.ReadInfo("dummy-non-state-server")
c.Assert(err, jc.Satisfies, errors.IsNotFound)
}
func (s *BootstrapSuite) TestAutoUploadAfterFailedSync(c *gc.C) {
s.PatchValue(&version.Current.Series, config.LatestLtsSeries())
s.setupAutoUploadTest(c, "1.7.3", "quantal")
// Run command and check for that upload has been run for tools matching
// the current juju version.
opc, errc := cmdtesting.RunCommand(cmdtesting.NullContext(c), envcmd.Wrap(new(BootstrapCommand)), "-e", "devenv")
c.Assert(<-errc, gc.IsNil)
c.Check((<-opc).(dummy.OpBootstrap).Env, gc.Equals, "devenv")
icfg := (<-opc).(dummy.OpFinalizeBootstrap).InstanceConfig
c.Assert(icfg, gc.NotNil)
c.Assert(icfg.Tools.Version.String(), gc.Equals, "1.7.3.1-raring-"+arch.HostArch())
}
func (s *destroyEnvSuite) TestDestroyEnvironmentCommandEmptyJenv(c *gc.C) {
oldinfo, err := s.ConfigStore.ReadInfo("dummyenv")
info := s.ConfigStore.CreateInfo("dummy-no-bootstrap")
info.SetAPICredentials(oldinfo.APICredentials())
info.SetAPIEndpoint(oldinfo.APIEndpoint())
err = info.Write()
c.Assert(err, jc.ErrorIsNil)
opc, errc := cmdtesting.RunCommand(cmdtesting.NullContext(c), newDestroyEnvironmentCommand(), "dummy-no-bootstrap", "--yes")
c.Check(<-errc, gc.IsNil)
c.Check((<-opc).(dummy.OpDestroy).Env, gc.Equals, "dummyenv")
// Verify that the environment information has been removed.
_, err = s.ConfigStore.ReadInfo("dummyenv")
c.Assert(err, jc.Satisfies, errors.IsNotFound)
}
func (s *BootstrapSuite) TestAutoUploadAfterFailedSync(c *gc.C) {
s.PatchValue(&series.HostSeries, func() string { return series.LatestLts() })
s.setupAutoUploadTest(c, "1.7.3", "quantal")
// Run command and check for that upload has been run for tools matching
// the current juju version.
opc, errc := cmdtesting.RunCommand(
cmdtesting.NullContext(c), s.newBootstrapCommand(),
"devcontroller", "dummy-cloud/region-1",
"--config", "default-series=raring",
"--auto-upgrade",
)
c.Assert(<-errc, gc.IsNil)
c.Check((<-opc).(dummy.OpBootstrap).Env, gc.Equals, "admin")
icfg := (<-opc).(dummy.OpFinalizeBootstrap).InstanceConfig
c.Assert(icfg, gc.NotNil)
c.Assert(icfg.AgentVersion().String(), gc.Equals, "1.7.3.1-raring-"+arch.HostArch())
}
func (s *BootstrapSuite) TestBootstrapJenvWarning(c *gc.C) {
const envName = "devenv"
s.patchVersionAndSeries(c, envName)
store, err := configstore.Default()
c.Assert(err, jc.ErrorIsNil)
ctx := coretesting.Context(c)
environs.PrepareFromName(envName, envcmd.BootstrapContext(ctx), store)
logger := "jenv.warning.test"
var testWriter loggo.TestWriter
loggo.RegisterWriter(logger, &testWriter, loggo.WARNING)
defer loggo.RemoveWriter(logger)
_, errc := cmdtesting.RunCommand(ctx, newBootstrapCommand(), "-e", envName, "--auto-upgrade")
c.Assert(<-errc, gc.IsNil)
c.Assert(testWriter.Log(), jc.LogMatches, []string{"ignoring environments.yaml: using bootstrap config in .*"})
}
func (s *KillSuite) TestKillCommandConfirmation(c *gc.C) {
var stdin, stdout bytes.Buffer
ctx, err := cmd.DefaultContext()
c.Assert(err, jc.ErrorIsNil)
ctx.Stdout = &stdout
ctx.Stdin = &stdin
// Ensure confirmation is requested if "-y" is not specified.
stdin.WriteString("n")
_, errc := cmdtesting.RunCommand(ctx, s.newKillCommand(), "local.test1")
select {
case err := <-errc:
c.Check(err, gc.ErrorMatches, "controller destruction aborted")
case <-time.After(testing.LongWait):
c.Fatalf("command took too long")
}
c.Check(testing.Stdout(ctx), gc.Matches, "WARNING!.*local.test1(.|\n)*")
checkControllerExistsInStore(c, "local.test1", s.store)
}
func (s *UnregisterSuite) unregisterCommandAborts(c *gc.C, answer string) {
var stdin, stdout bytes.Buffer
ctx, err := cmd.DefaultContext()
c.Assert(err, jc.ErrorIsNil)
ctx.Stdout = &stdout
ctx.Stdin = &stdin
// Ensure confirmation is requested if "-y" is not specified.
stdin.WriteString(answer)
_, errc := cmdtesting.RunCommand(ctx, controller.NewUnregisterCommand(s.store), "fake1")
select {
case err, ok := <-errc:
c.Assert(ok, jc.IsTrue)
c.Check(err, gc.ErrorMatches, "unregistering controller: aborted")
case <-time.After(testing.LongWait):
c.Fatalf("command took too long")
}
c.Check(testing.Stdout(ctx), gc.Equals, unregisterMsg)
c.Check(s.store.lookupName, gc.Equals, "fake1")
c.Check(s.store.removedName, gc.Equals, "")
}
func (s *UnregisterSuite) unregisterCommandConfirms(c *gc.C, answer string) {
var stdin, stdout bytes.Buffer
ctx, err := cmd.DefaultContext()
c.Assert(err, jc.ErrorIsNil)
ctx.Stdout = &stdout
ctx.Stdin = &stdin
stdin.Reset()
stdout.Reset()
stdin.WriteString(answer)
_, errc := cmdtesting.RunCommand(ctx, controller.NewUnregisterCommand(s.store), "fake1")
select {
case err, ok := <-errc:
c.Assert(ok, jc.IsTrue)
c.Check(err, jc.ErrorIsNil)
case <-time.After(testing.LongWait):
c.Fatalf("command took too long")
}
c.Check(s.store.lookupName, gc.Equals, "fake1")
c.Check(s.store.removedName, gc.Equals, "fake1")
}
func (s *BootstrapSuite) TestBootstrapCleansUpIfEnvironPrepFails(c *gc.C) {
cleanupRan := false
s.PatchValue(&environType, func(string) (string, error) { return "", nil })
s.PatchValue(
&environFromName,
func(
*cmd.Context,
string,
string,
func(environs.Environ) error,
) (environs.Environ, func(), error) {
return nil, func() { cleanupRan = true }, fmt.Errorf("mock")
},
)
ctx := coretesting.Context(c)
_, errc := cmdtesting.RunCommand(ctx, newBootstrapCommand(), "-m", "peckham")
c.Check(<-errc, gc.Not(gc.IsNil))
c.Check(cleanupRan, jc.IsTrue)
}
func (s *BootstrapSuite) TestBootstrapAlreadyExists(c *gc.C) {
const controllerName = "devcontroller"
expectedBootstrappedName := bootstrappedControllerName(controllerName)
s.patchVersionAndSeries(c, "raring")
s.writeControllerModelAccountInfo(c, "local.devcontroller", "fredmodel", "fred@local")
ctx := coretesting.Context(c)
_, errc := cmdtesting.RunCommand(ctx, s.newBootstrapCommand(), controllerName, "dummy", "--auto-upgrade")
err := <-errc
c.Assert(err, jc.Satisfies, errors.IsAlreadyExists)
c.Assert(err, gc.ErrorMatches, fmt.Sprintf(`controller %q already exists`, expectedBootstrappedName))
currentController, err := modelcmd.ReadCurrentController()
c.Assert(err, jc.ErrorIsNil)
c.Assert(currentController, gc.Equals, "local.devcontroller")
currentAccount, err := s.store.CurrentAccount(currentController)
c.Assert(err, jc.ErrorIsNil)
c.Assert(currentAccount, gc.Equals, "fred@local")
currentModel, err := s.store.CurrentModel(currentController, currentAccount)
c.Assert(err, jc.ErrorIsNil)
c.Assert(currentModel, gc.Equals, "fredmodel")
}
func (s *BootstrapSuite) TestBootstrapDestroy(c *gc.C) {
resetJujuHome(c, "devenv")
s.patchVersion(c)
opc, errc := cmdtesting.RunCommand(cmdtesting.NullContext(c), newBootstrapCommand(), "-e", "brokenenv", "--auto-upgrade")
err := <-errc
c.Assert(err, gc.ErrorMatches, "failed to bootstrap environment: dummy.Bootstrap is broken")
var opDestroy *dummy.OpDestroy
for opDestroy == nil {
select {
case op := <-opc:
switch op := op.(type) {
case dummy.OpDestroy:
opDestroy = &op
}
default:
c.Error("expected call to env.Destroy")
return
}
}
c.Assert(opDestroy.Error, gc.ErrorMatches, "dummy.Destroy is broken")
}
// When attempting to bootstrap, check that when prepare errors out,
// bootstrap will stop immediately. Nothing will be destroyed.
func (s *BootstrapSuite) TestBootstrapFailToPrepareDiesGracefully(c *gc.C) {
destroyed := false
s.PatchValue(&environsDestroy, func(string, environs.Environ, jujuclient.ControllerRemover) error {
destroyed = true
return nil
})
s.PatchValue(&environsPrepare, func(
environs.BootstrapContext,
jujuclient.ClientStore,
environs.PrepareParams,
) (environs.Environ, error) {
return nil, fmt.Errorf("mock-prepare")
})
ctx := coretesting.Context(c)
_, errc := cmdtesting.RunCommand(
ctx, s.newBootstrapCommand(),
"devcontroller", "dummy",
)
c.Check(<-errc, gc.ErrorMatches, ".*mock-prepare$")
c.Check(destroyed, jc.IsFalse)
}
func (s *BootstrapSuite) TestBootstrapJenvWarning(c *gc.C) {
env := resetJujuHome(c, "devenv")
defaultSeriesVersion := version.Current
defaultSeriesVersion.Series = config.PreferredSeries(env.Config())
// Force a dev version by having a non zero build number.
// This is because we have not uploaded any tools and auto
// upload is only enabled for dev versions.
defaultSeriesVersion.Build = 1234
s.PatchValue(&version.Current, defaultSeriesVersion)
store, err := configstore.Default()
c.Assert(err, jc.ErrorIsNil)
ctx := coretesting.Context(c)
environs.PrepareFromName("devenv", envcmd.BootstrapContext(ctx), store)
logger := "jenv.warning.test"
var testWriter loggo.TestWriter
loggo.RegisterWriter(logger, &testWriter, loggo.WARNING)
defer loggo.RemoveWriter(logger)
_, errc := cmdtesting.RunCommand(ctx, envcmd.Wrap(new(BootstrapCommand)), "-e", "devenv")
c.Assert(<-errc, gc.IsNil)
c.Assert(testWriter.Log(), jc.LogMatches, []string{"ignoring environments.yaml: using bootstrap config in .*"})
}
// When attempting to bootstrap, check that when prepare errors out,
// the code cleans up the created jenv file, but *not* any existing
// environment that may have previously been bootstrapped.
func (s *BootstrapSuite) TestBootstrapFailToPrepareDiesGracefully(c *gc.C) {
destroyedEnvRan := false
destroyedInfoRan := false
// Mock functions
mockDestroyPreparedEnviron := func(
*cmd.Context,
environs.Environ,
configstore.Storage,
string,
) {
destroyedEnvRan = true
}
mockDestroyEnvInfo := func(
ctx *cmd.Context,
cfgName string,
store configstore.Storage,
action string,
) {
destroyedInfoRan = true
}
mockEnvironFromName := func(
ctx *cmd.Context,
envName string,
action string,
_ func(environs.Environ) error,
) (environs.Environ, func(), error) {
// Always show that the environment is bootstrapped.
return environFromNameProductionFunc(
ctx,
envName,
action,
func(env environs.Environ) error {
return environs.ErrAlreadyBootstrapped
})
}
mockPrepare := func(
string,
environs.BootstrapContext,
configstore.Storage,
) (environs.Environ, error) {
return nil, fmt.Errorf("mock-prepare")
}
// Simulation: prepare should fail and we should only clean up the
// jenv file. Any existing environment should not be destroyed.
s.PatchValue(&destroyPreparedEnviron, mockDestroyPreparedEnviron)
s.PatchValue(&environType, func(string) (string, error) { return "", nil })
s.PatchValue(&environFromName, mockEnvironFromName)
s.PatchValue(&environs.PrepareFromName, mockPrepare)
s.PatchValue(&destroyEnvInfo, mockDestroyEnvInfo)
ctx := coretesting.Context(c)
_, errc := cmdtesting.RunCommand(ctx, envcmd.Wrap(new(BootstrapCommand)), "-e", "peckham")
c.Check(<-errc, gc.ErrorMatches, ".*mock-prepare$")
c.Check(destroyedEnvRan, jc.IsFalse)
c.Check(destroyedInfoRan, jc.IsTrue)
}
func (s *BootstrapSuite) run(c *gc.C, test bootstrapTest) (restore gitjujutesting.Restorer) {
// Create home with dummy provider and remove all
// of its envtools.
env := resetJujuHome(c, "peckham")
// Although we're testing PrepareEndpointsForCaching interactions
// separately in the juju package, here we just ensure it gets
// called with the right arguments.
prepareCalled := false
addrConnectedTo := "localhost:17070"
restore = gitjujutesting.PatchValue(
&prepareEndpointsForCaching,
func(info configstore.EnvironInfo, hps [][]network.HostPort, addr network.HostPort) (_, _ []string, _ bool) {
prepareCalled = true
addrs, hosts, changed := juju.PrepareEndpointsForCaching(info, hps, addr)
// Because we're bootstrapping the addresses will always
// change, as there's no .jenv file saved yet.
c.Assert(changed, jc.IsTrue)
return addrs, hosts, changed
},
)
if test.version != "" {
useVersion := strings.Replace(test.version, "%LTS%", config.LatestLtsSeries(), 1)
origVersion := version.Current
version.Current = version.MustParseBinary(useVersion)
restore = restore.Add(func() {
version.Current = origVersion
})
}
if test.hostArch != "" {
origArch := arch.HostArch
arch.HostArch = func() string {
return test.hostArch
}
restore = restore.Add(func() {
arch.HostArch = origArch
})
}
// Run command and check for uploads.
opc, errc := cmdtesting.RunCommand(cmdtesting.NullContext(c), envcmd.Wrap(new(BootstrapCommand)), test.args...)
// Check for remaining operations/errors.
if test.err != "" {
err := <-errc
c.Assert(err, gc.NotNil)
stripped := strings.Replace(err.Error(), "\n", "", -1)
c.Check(stripped, gc.Matches, test.err)
return restore
}
if !c.Check(<-errc, gc.IsNil) {
return restore
}
opBootstrap := (<-opc).(dummy.OpBootstrap)
c.Check(opBootstrap.Env, gc.Equals, "peckham")
c.Check(opBootstrap.Args.Constraints, gc.DeepEquals, test.constraints)
c.Check(opBootstrap.Args.Placement, gc.Equals, test.placement)
opFinalizeBootstrap := (<-opc).(dummy.OpFinalizeBootstrap)
c.Check(opFinalizeBootstrap.Env, gc.Equals, "peckham")
c.Check(opFinalizeBootstrap.InstanceConfig.Tools, gc.NotNil)
if test.upload != "" {
c.Check(opFinalizeBootstrap.InstanceConfig.Tools.Version.String(), gc.Equals, test.upload)
}
store, err := configstore.Default()
c.Assert(err, jc.ErrorIsNil)
// Check a CA cert/key was generated by reloading the environment.
env, err = environs.NewFromName("peckham", store)
c.Assert(err, jc.ErrorIsNil)
_, hasCert := env.Config().CACert()
c.Check(hasCert, jc.IsTrue)
_, hasKey := env.Config().CAPrivateKey()
c.Check(hasKey, jc.IsTrue)
info, err := store.ReadInfo("peckham")
c.Assert(err, jc.ErrorIsNil)
c.Assert(info, gc.NotNil)
c.Assert(prepareCalled, jc.IsTrue)
c.Assert(info.APIEndpoint().Addresses, gc.DeepEquals, []string{addrConnectedTo})
return restore
}
