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