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", 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 := 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 = 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 = 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", nullContext(c), s.ConfigStore)
c.Assert(err, gc.IsNil)
stdin.Reset()
stdout.Reset()
stdin.WriteString(answer)
opc, errc = 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 *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", nullContext(c), s.ConfigStore)
c.Assert(err, gc.IsNil)
// destroy with broken environment
opc, errc := runCommand(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 *syncToolsSuite) TestSyncToolsCommand(c *gc.C) {
for i, test := range syncToolsCommandTests {
c.Logf("test %d: %s", i, test.description)
targetEnv, err := environs.PrepareFromName("test-target", nullContext(c), s.configStore)
c.Assert(err, gc.IsNil)
called := false
syncTools = func(sctx *sync.SyncContext) error {
c.Assert(sctx.AllVersions, gc.Equals, test.sctx.AllVersions)
c.Assert(sctx.MajorVersion, gc.Equals, test.sctx.MajorVersion)
c.Assert(sctx.MinorVersion, gc.Equals, test.sctx.MinorVersion)
c.Assert(sctx.DryRun, gc.Equals, test.sctx.DryRun)
c.Assert(sctx.Dev, gc.Equals, test.sctx.Dev)
c.Assert(sctx.Public, gc.Equals, test.sctx.Public)
c.Assert(sctx.Source, gc.Equals, test.sctx.Source)
c.Assert(dummy.IsSameStorage(sctx.Target, targetEnv.Storage()), jc.IsTrue)
called = true
return nil
}
ctx, err := runSyncToolsCommand(c, test.args...)
c.Assert(err, gc.IsNil)
c.Assert(ctx, gc.NotNil)
c.Assert(called, jc.IsTrue)
s.Reset(c)
}
}
// environFromName loads an existing environment or prepares a new
// one. If there are no errors, it returns the environ and a closure to
// clean up in case we need to further up the stack. If an error has
// occurred, the environment and cleanup function will be nil, and the
// error will be filled in.
func environFromName(
ctx *cmd.Context,
envName string,
action string,
) (env environs.Environ, cleanup func(), err error) {
store, err := configstore.Default()
if err != nil {
return nil, nil, err
}
envExisted := false
if environInfo, err := store.ReadInfo(envName); err == nil {
envExisted = true
logger.Warningf(
"ignoring environments.yaml: using bootstrap config in %s",
environInfo.Location(),
)
} else if !errors.IsNotFound(err) {
return nil, nil, err
}
if env, err = environs.PrepareFromName(envName, ctx, store); err != nil {
return nil, nil, err
}
cleanup = func() {
if !envExisted {
destroyPreparedEnviron(ctx, env, store, action)
}
}
return env, cleanup, nil
}
func (s *destroyEnvSuite) TestDestroyEnvironmentCommandEFlag(c *gc.C) {
// Prepare the environment so we can destroy it.
_, err := environs.PrepareFromName("dummyenv", nullContext(c), s.ConfigStore)
c.Assert(err, gc.IsNil)
// check that either environment or the flag is mandatory
opc, errc := runCommand(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 = runCommand(nullContext(c), new(DestroyEnvironmentCommand), "-e", "dummyenv", "dummyenv", "--yes")
c.Check(<-errc, gc.Equals, DoubleEnvironmentError)
// We treat --environment the same way
opc, errc = runCommand(nullContext(c), new(DestroyEnvironmentCommand), "--environment", "dummyenv", "dummyenv", "--yes")
c.Check(<-errc, gc.Equals, DoubleEnvironmentError)
// destroy using the -e flag
opc, errc = runCommand(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 *NewAPIClientSuite) bootstrapEnv(c *gc.C, envName string, store configstore.Storage) {
if store == nil {
store = configstore.NewMem()
}
ctx := envtesting.BootstrapContext(c)
c.Logf("env name: %s", envName)
env, err := environs.PrepareFromName(envName, ctx, store)
c.Assert(err, jc.ErrorIsNil)
storageDir := c.MkDir()
s.PatchValue(&envtools.DefaultBaseURL, storageDir)
stor, err := filestorage.NewFileStorageWriter(storageDir)
c.Assert(err, jc.ErrorIsNil)
envtesting.UploadFakeTools(c, stor, "released", "released")
err = bootstrap.Bootstrap(ctx, env, bootstrap.BootstrapParams{})
c.Assert(err, jc.ErrorIsNil)
info, err := store.ReadInfo(envName)
c.Assert(err, jc.ErrorIsNil)
creds := info.APICredentials()
creds.User = dummy.AdminUserTag().Name()
c.Logf("set creds: %#v", creds)
info.SetAPICredentials(creds)
err = info.Write()
c.Assert(err, jc.ErrorIsNil)
c.Logf("creds: %#v", info.APICredentials())
info, err = store.ReadInfo(envName)
c.Assert(err, jc.ErrorIsNil)
c.Logf("read creds: %#v", info.APICredentials())
c.Logf("store: %#v", store)
}
func (s *JujuConnSuite) setUpConn(c *gc.C) {
if s.RootDir != "" {
panic("JujuConnSuite.setUpConn without teardown")
}
s.RootDir = c.MkDir()
s.oldHome = utils.Home()
home := filepath.Join(s.RootDir, "/home/ubuntu")
err := os.MkdirAll(home, 0777)
c.Assert(err, gc.IsNil)
utils.SetHome(home)
s.oldJujuHome = osenv.SetJujuHome(filepath.Join(home, ".juju"))
err = os.Mkdir(osenv.JujuHome(), 0777)
c.Assert(err, gc.IsNil)
err = os.MkdirAll(s.DataDir(), 0777)
c.Assert(err, gc.IsNil)
s.PatchEnvironment(osenv.JujuEnvEnvKey, "")
// TODO(rog) remove these files and add them only when
// the tests specifically need them (in cmd/juju for example)
s.writeSampleConfig(c, osenv.JujuHomePath("environments.yaml"))
err = ioutil.WriteFile(osenv.JujuHomePath("dummyenv-cert.pem"), []byte(testing.CACert), 0666)
c.Assert(err, gc.IsNil)
err = ioutil.WriteFile(osenv.JujuHomePath("dummyenv-private-key.pem"), []byte(testing.CAKey), 0600)
c.Assert(err, gc.IsNil)
store, err := configstore.Default()
c.Assert(err, gc.IsNil)
s.ConfigStore = store
ctx := testing.Context(c)
environ, err := environs.PrepareFromName("dummyenv", ctx, s.ConfigStore)
c.Assert(err, gc.IsNil)
// sanity check we've got the correct environment.
c.Assert(environ.Config().Name(), gc.Equals, "dummyenv")
s.PatchValue(&dummy.DataDir, s.DataDir())
s.LogDir = c.MkDir()
s.PatchValue(&dummy.LogDir, s.LogDir)
versions := PreferredDefaultVersions(environ.Config(), version.Binary{Number: version.Current.Number, Series: "precise", Arch: "amd64"})
versions = append(versions, version.Current)
// Upload tools for both preferred and fake default series
envtesting.MustUploadFakeToolsVersions(environ.Storage(), versions...)
err = bootstrap.Bootstrap(ctx, environ, bootstrap.BootstrapParams{})
c.Assert(err, gc.IsNil)
s.BackingState = environ.(GetStater).GetStateInAPIServer()
s.State, err = newState(environ, s.BackingState.MongoConnectionInfo())
c.Assert(err, gc.IsNil)
s.APIState, err = juju.NewAPIState(environ, api.DialOpts{})
c.Assert(err, gc.IsNil)
s.Environ = environ
}
func (*OpenSuite) TestPrepareFromName(c *gc.C) {
ctx := testing.Context(c)
e, err := environs.PrepareFromName("erewhemos", ctx, configstore.NewMem())
c.Assert(err, gc.IsNil)
c.Assert(e.Config().Name(), gc.Equals, "erewhemos")
// Check we can access storage ok, which implies the environment has been prepared.
c.Assert(e.Storage(), gc.NotNil)
}
func (s *datasourceSuite) SetUpTest(c *gc.C) {
s.FakeJujuHomeSuite.SetUpTest(c)
testing.WriteEnvironments(c, existingEnv)
environ, err := environs.PrepareFromName("test", testing.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
s.stor = environ.Storage()
s.baseURL, err = s.stor.URL("")
c.Assert(err, gc.IsNil)
}
func (*OpenSuite) TestNewFromName(c *gc.C) {
store := configstore.NewMem()
ctx := testing.Context(c)
e, err := environs.PrepareFromName("erewhemos", ctx, store)
c.Assert(err, gc.IsNil)
e, err = environs.NewFromName("erewhemos", store)
c.Assert(err, gc.IsNil)
c.Assert(e.Config().Name(), gc.Equals, "erewhemos")
}
func (s *verifyStorageSuite) TestVerifyStorageFails(c *gc.C) {
ctx := testing.Context(c)
environ, err := environs.PrepareFromName("test", ctx, configstore.NewMem())
c.Assert(err, gc.IsNil)
stor := environ.Storage()
someError := errors.Unauthorizedf("you shall not pass")
dummy.Poison(stor, environs.VerificationFilename, someError)
err = environs.VerifyStorage(stor)
c.Assert(err, gc.Equals, environs.VerifyStorageError)
}
func bootstrapEnv(c *gc.C, envName string, store configstore.Storage) {
if store == nil {
store = configstore.NewMem()
}
ctx := coretesting.Context(c)
env, err := environs.PrepareFromName(envName, ctx, store)
c.Assert(err, gc.IsNil)
envtesting.UploadFakeTools(c, env.Storage())
err = bootstrap.Bootstrap(ctx, env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
}
// resetJujuHome restores an new, clean Juju home environment without tools.
func resetJujuHome(c *gc.C, envName string) environs.Environ {
jenvDir := gitjujutesting.HomePath(".juju", "environments")
err := os.RemoveAll(jenvDir)
c.Assert(err, jc.ErrorIsNil)
coretesting.WriteEnvironments(c, envConfig)
dummy.Reset()
store, err := configstore.Default()
c.Assert(err, jc.ErrorIsNil)
env, err := environs.PrepareFromName(envName, envcmd.BootstrapContext(cmdtesting.NullContext(c)), store)
c.Assert(err, jc.ErrorIsNil)
return env
}
// resetJujuHome restores an new, clean Juju home environment without tools.
func resetJujuHome(c *gc.C) environs.Environ {
jenvDir := gitjujutesting.HomePath(".juju", "environments")
err := os.RemoveAll(jenvDir)
c.Assert(err, gc.IsNil)
coretesting.WriteEnvironments(c, envConfig)
dummy.Reset()
store, err := configstore.Default()
c.Assert(err, gc.IsNil)
env, err := environs.PrepareFromName("peckham", cmdtesting.NullContext(c), store)
c.Assert(err, gc.IsNil)
envtesting.RemoveAllTools(c, env)
return env
}
func (s *checkEnvironmentSuite) TestCheckEnvironment(c *gc.C) {
ctx := testing.Context(c)
environ, err := environs.PrepareFromName("test", ctx, configstore.NewMem())
c.Assert(err, gc.IsNil)
// VerifyStorage is sufficient for our tests and much simpler
// than Bootstrap which calls it.
stor := environ.Storage()
err = environs.VerifyStorage(stor)
c.Assert(err, gc.IsNil)
err = environs.CheckEnvironment(environ)
c.Assert(err, gc.IsNil)
}
func (s *OpenSuite) TestUpdateEnvInfo(c *gc.C) {
store := configstore.NewMem()
ctx := envtesting.BootstrapContext(c)
_, err := environs.PrepareFromName("erewhemos", ctx, store)
c.Assert(err, jc.ErrorIsNil)
info, err := store.ReadInfo("erewhemos")
c.Assert(err, jc.ErrorIsNil)
c.Assert(info, gc.NotNil)
c.Assert(info.APIEndpoint().CACert, gc.Not(gc.Equals), "")
c.Assert(info.APIEndpoint().EnvironUUID, gc.Not(gc.Equals), "")
c.Assert(info.APICredentials().Password, gc.Not(gc.Equals), "")
c.Assert(info.APICredentials().User, gc.Equals, "admin")
}
func (s *verifyStorageSuite) TestVerifyStorage(c *gc.C) {
ctx := testing.Context(c)
environ, err := environs.PrepareFromName("test", ctx, configstore.NewMem())
c.Assert(err, gc.IsNil)
stor := environ.Storage()
err = environs.VerifyStorage(stor)
c.Assert(err, gc.IsNil)
reader, err := storage.Get(stor, environs.VerificationFilename)
c.Assert(err, gc.IsNil)
defer reader.Close()
contents, err := ioutil.ReadAll(reader)
c.Assert(err, gc.IsNil)
c.Check(string(contents), gc.Equals,
"juju-core storage writing verified: ok\n")
}
func (s *ToolsMetadataSuite) SetUpTest(c *gc.C) {
s.FakeJujuHomeSuite.SetUpTest(c)
s.AddCleanup(func(*gc.C) {
dummy.Reset()
loggo.ResetLoggers()
})
env, err := environs.PrepareFromName(
"erewhemos", envcmd.BootstrapContextNoVerify(coretesting.Context(c)), configstore.NewMem())
c.Assert(err, jc.ErrorIsNil)
s.env = env
loggo.GetLogger("").SetLogLevel(loggo.INFO)
// Switch the default tools location.
s.publicStorageDir = c.MkDir()
s.PatchValue(&tools.DefaultBaseURL, s.publicStorageDir)
}
func (s *checkEnvironmentSuite) TestCheckEnvironmentBadContent(c *gc.C) {
ctx := testing.Context(c)
environ, err := environs.PrepareFromName("test", ctx, configstore.NewMem())
c.Assert(err, gc.IsNil)
// We mock a bad (eg. from a Python-juju environment) bootstrap-verify.
stor := environ.Storage()
content := "bad verification content"
reader := strings.NewReader(content)
err = stor.Put(environs.VerificationFilename, reader, int64(len(content)))
c.Assert(err, gc.IsNil)
// When the bootstrap-verify file contains unexpected content,
// we get an InvalidEnvironmentError.
err = environs.CheckEnvironment(environ)
c.Assert(err, gc.Equals, environs.InvalidEnvironmentError)
}
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 *destroyEnvSuite) TestDestroyEnvironmentCommand(c *gc.C) {
// Prepare the environment so we can destroy it.
_, err := environs.PrepareFromName("dummyenv", nullContext(c), s.ConfigStore)
c.Assert(err, gc.IsNil)
// check environment is mandatory
opc, errc := runCommand(nullContext(c), new(DestroyEnvironmentCommand))
c.Check(<-errc, gc.Equals, NoEnvironmentError)
// normal destroy
opc, errc = runCommand(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 *checkEnvironmentSuite) TestCheckEnvironmentGetFails(c *gc.C) {
ctx := testing.Context(c)
environ, err := environs.PrepareFromName("test", ctx, configstore.NewMem())
c.Assert(err, gc.IsNil)
// VerifyStorage is sufficient for our tests and much simpler
// than Bootstrap which calls it.
stor := environ.Storage()
err = environs.VerifyStorage(stor)
c.Assert(err, gc.IsNil)
// When fetching the verification file from storage fails,
// we get an InvalidEnvironmentError.
someError := errors.Unauthorizedf("you shall not pass")
dummy.Poison(stor, environs.VerificationFilename, someError)
err = environs.CheckEnvironment(environ)
c.Assert(err, gc.Equals, someError)
}
func environFromNameProductionFunc(
ctx *cmd.Context,
envName string,
action string,
ensureNotBootstrapped func(environs.Environ) error,
) (env environs.Environ, cleanup func(), err error) {
store, err := configstore.Default()
if err != nil {
return nil, nil, err
}
envExisted := false
if environInfo, err := store.ReadInfo(envName); err == nil {
envExisted = true
logger.Warningf(
"ignoring environments.yaml: using bootstrap config in %s",
environInfo.Location(),
)
} else if !errors.IsNotFound(err) {
return nil, nil, err
}
cleanup = func() {
// Distinguish b/t removing the jenv file or tearing down the
// environment. We want to remove the jenv file if preparation
// was not successful. We want to tear down the environment
// only in the case where the environment didn't already
// exist.
if env == nil {
logger.Debugf("Destroying environment info.")
destroyEnvInfo(ctx, envName, store, action)
} else if !envExisted && ensureNotBootstrapped(env) != environs.ErrAlreadyBootstrapped {
logger.Debugf("Destroying environment.")
destroyPreparedEnviron(ctx, env, store, action)
}
}
if env, err = environs.PrepareFromName(envName, envcmd.BootstrapContext(ctx), store); err != nil {
return nil, cleanup, err
}
return env, cleanup, err
}
func (s *syncSuite) setUpTest(c *gc.C) {
s.FakeJujuHomeSuite.SetUpTest(c)
s.ToolsFixture.SetUpTest(c)
s.origVersion = version.Current
// It's important that this be v1.8.x to match the test data.
version.Current.Number = version.MustParse("1.8.3")
// Create a target environments.yaml.
envConfig := `
environments:
test-target:
type: dummy
state-server: false
authorized-keys: "not-really-one"
`
coretesting.WriteEnvironments(c, envConfig)
var err error
s.targetEnv, err = environs.PrepareFromName("test-target", coretesting.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
envtesting.RemoveAllTools(c, s.targetEnv)
// Create a source storage.
baseDir := c.MkDir()
stor, err := filestorage.NewFileStorageWriter(baseDir)
c.Assert(err, gc.IsNil)
s.storage = stor
// Create a local tools directory.
s.localStorage = c.MkDir()
// Populate both local and default tools locations with the public tools.
versionStrings := make([]string, len(vAll))
for i, vers := range vAll {
versionStrings[i] = vers.String()
}
toolstesting.MakeTools(c, baseDir, "releases", versionStrings)
toolstesting.MakeTools(c, s.localStorage, "releases", versionStrings)
// Switch the default tools location.
baseURL, err := s.storage.URL(storage.BaseToolsPath)
c.Assert(err, gc.IsNil)
s.PatchValue(&envtools.DefaultBaseURL, baseURL)
}
func (s *checkEnvironmentSuite) TestCheckEnvironmentFileNotFound(c *gc.C) {
ctx := testing.Context(c)
environ, err := environs.PrepareFromName("test", ctx, configstore.NewMem())
c.Assert(err, gc.IsNil)
// VerifyStorage is sufficient for our tests and much simpler
// than Bootstrap which calls it.
stor := environ.Storage()
err = environs.VerifyStorage(stor)
c.Assert(err, gc.IsNil)
// When the bootstrap-verify file does not exist, it still believes
// the environment is a juju-core one because earlier versions
// did not create that file.
err = stor.Remove(environs.VerificationFilename)
c.Assert(err, gc.IsNil)
err = environs.CheckEnvironment(environ)
c.Assert(err, gc.IsNil)
}
func (s *APIEndpointForEnvSuite) TestAPIEndpointNotCached(c *gc.C) {
coretesting.WriteEnvironments(c, coretesting.MultipleEnvConfig)
store, err := configstore.Default()
c.Assert(err, gc.IsNil)
ctx := coretesting.Context(c)
env, err := environs.PrepareFromName("erewhemos", ctx, store)
c.Assert(err, gc.IsNil)
defer dummy.Reset()
envtesting.UploadFakeTools(c, env.Storage())
err = bootstrap.Bootstrap(ctx, env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
// Note: if we get Bootstrap to start caching the API endpoint
// immediately, we'll still want to have this test for compatibility.
// We can just write blank info instead of reading and checking it is empty.
savedInfo, err := store.ReadInfo("erewhemos")
c.Assert(err, gc.IsNil)
// Ensure that the data isn't cached
c.Check(savedInfo.APIEndpoint().Addresses, gc.HasLen, 0)
called := 0
expectState := mockedAPIState(true, true)
apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (juju.APIState, error) {
c.Check(apiInfo.Tag, gc.Equals, "user-admin")
c.Check(string(apiInfo.CACert), gc.Equals, coretesting.CACert)
c.Check(apiInfo.Password, gc.Equals, coretesting.DefaultMongoPassword)
c.Check(opts, gc.DeepEquals, api.DefaultDialOpts())
// we didn't know about it when connecting
c.Check(apiInfo.EnvironTag, gc.Equals, "")
called++
return expectState, nil
}
endpoint, err := juju.APIEndpointInStore("erewhemos", false, store, apiOpen)
c.Assert(err, gc.IsNil)
c.Assert(called, gc.Equals, 1)
c.Check(endpoint.Addresses, gc.DeepEquals, []string{"0.1.2.3:1234"})
c.Check(endpoint.EnvironUUID, gc.Equals, "fake-uuid")
}
// environFromName loads an existing environment or prepares a new one.
func environFromName(
ctx *cmd.Context, envName string, resultErr *error, action string) (environs.Environ, func(), error) {
store, err := configstore.Default()
if err != nil {
return nil, nil, err
}
var existing bool
if environInfo, err := store.ReadInfo(envName); !errors.IsNotFound(err) {
existing = true
logger.Warningf("ignoring environments.yaml: using bootstrap config in %s", environInfo.Location())
}
environ, err := environs.PrepareFromName(envName, ctx, store)
if err != nil {
return nil, nil, err
}
cleanup := func() {
if !existing {
destroyPreparedEnviron(ctx, environ, store, resultErr, action)
}
}
return environ, cleanup, nil
}
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 .*"})
}
func (s *JujuConnSuite) setUpConn(c *gc.C) {
if s.RootDir != "" {
panic("JujuConnSuite.setUpConn without teardown")
}
s.RootDir = c.MkDir()
s.oldHome = utils.Home()
home := filepath.Join(s.RootDir, "/home/ubuntu")
err := os.MkdirAll(home, 0777)
c.Assert(err, jc.ErrorIsNil)
utils.SetHome(home)
s.oldJujuHome = osenv.SetJujuHome(filepath.Join(home, ".juju"))
err = os.Mkdir(osenv.JujuHome(), 0777)
c.Assert(err, jc.ErrorIsNil)
err = os.MkdirAll(s.DataDir(), 0777)
c.Assert(err, jc.ErrorIsNil)
s.PatchEnvironment(osenv.JujuEnvEnvKey, "")
// TODO(rog) remove these files and add them only when
// the tests specifically need them (in cmd/juju for example)
s.writeSampleConfig(c, osenv.JujuHomePath("environments.yaml"))
err = ioutil.WriteFile(osenv.JujuHomePath("dummyenv-cert.pem"), []byte(testing.CACert), 0666)
c.Assert(err, jc.ErrorIsNil)
err = ioutil.WriteFile(osenv.JujuHomePath("dummyenv-private-key.pem"), []byte(testing.CAKey), 0600)
c.Assert(err, jc.ErrorIsNil)
store, err := configstore.Default()
c.Assert(err, jc.ErrorIsNil)
s.ConfigStore = store
ctx := testing.Context(c)
environ, err := environs.PrepareFromName("dummyenv", envcmd.BootstrapContext(ctx), s.ConfigStore)
c.Assert(err, jc.ErrorIsNil)
// sanity check we've got the correct environment.
c.Assert(environ.Config().Name(), gc.Equals, "dummyenv")
s.PatchValue(&dummy.DataDir, s.DataDir())
s.LogDir = c.MkDir()
s.PatchValue(&dummy.LogDir, s.LogDir)
versions := PreferredDefaultVersions(environ.Config(), version.Binary{Number: version.Current.Number, Series: "precise", Arch: "amd64"})
versions = append(versions, version.Current)
// Upload tools for both preferred and fake default series
s.DefaultToolsStorageDir = c.MkDir()
s.PatchValue(&tools.DefaultBaseURL, s.DefaultToolsStorageDir)
stor, err := filestorage.NewFileStorageWriter(s.DefaultToolsStorageDir)
c.Assert(err, jc.ErrorIsNil)
// Upload tools to both release and devel streams since config will dictate that we
// end up looking in both places.
envtesting.AssertUploadFakeToolsVersions(c, stor, "released", "released", versions...)
envtesting.AssertUploadFakeToolsVersions(c, stor, "devel", "devel", versions...)
s.DefaultToolsStorage = stor
err = bootstrap.Bootstrap(envcmd.BootstrapContext(ctx), environ, bootstrap.BootstrapParams{})
c.Assert(err, jc.ErrorIsNil)
s.BackingState = environ.(GetStater).GetStateInAPIServer()
s.State, err = newState(environ, s.BackingState.MongoConnectionInfo())
c.Assert(err, jc.ErrorIsNil)
s.APIState, err = juju.NewAPIState(s.AdminUserTag(c), environ, api.DialOpts{})
c.Assert(err, jc.ErrorIsNil)
err = s.State.SetAPIHostPorts(s.APIState.APIHostPorts())
c.Assert(err, jc.ErrorIsNil)
// Make sure the config store has the api endpoint address set
info, err := s.ConfigStore.ReadInfo("dummyenv")
c.Assert(err, jc.ErrorIsNil)
endpoint := info.APIEndpoint()
endpoint.Addresses = []string{s.APIState.APIHostPorts()[0][0].String()}
info.SetAPIEndpoint(endpoint)
err = info.Write()
c.Assert(err, jc.ErrorIsNil)
// Make sure the jenv file has the local host ports.
c.Logf("jenv host ports: %#v", s.APIState.APIHostPorts())
s.Environ = environ
// Insert expected values...
servingInfo := state.StateServingInfo{
PrivateKey: testing.ServerKey,
Cert: testing.ServerCert,
CAPrivateKey: testing.CAKey,
SharedSecret: "really, really secret",
APIPort: 4321,
StatePort: 1234,
}
s.State.SetStateServingInfo(servingInfo)
}
func (*OpenSuite) TestPrepareFromName(c *gc.C) {
ctx := envtesting.BootstrapContext(c)
e, err := environs.PrepareFromName("erewhemos", ctx, configstore.NewMem())
c.Assert(err, jc.ErrorIsNil)
c.Assert(e.Config().Name(), gc.Equals, "erewhemos")
}