Merge lp:~axwalk/juju-core/lp1279259-part1-prepare-context into lp:~go-bot/juju-core/trunk

[Andrew Wilkins]

Pass environs.BootstrapContext to Prepare

This is part one of fixing lp:1279259.
In this CL, we pass context to Prepare,
giving providers an opportunity to prompt
the user to initialise an environment.

Passing context was previously restricted to
Bootstrap and EnableBootstrapStorage; this is
insufficient, as there are many ways to prepare
an environment. It is currently possible to
successfully "Prepare" and environment, but
for the result to be unusable in the manual
provider (e.g. if the bootstrap-host address is
invalid). We should that a successfully Prepared
environment should be able to be Destroyed
(with force).

https://codereview.appspot.com/62780044/

Pass environs.BootstrapContext to Prepare

This is part one of fixing lp:1279259.
In this CL, we pass context to Prepare,
giving providers an opportunity to prompt
the user to initialise an environment.

Passing context was previously restricted to
Bootstrap and EnableBootstrapStorage; this is
insufficient, as there are many ways to prepare
an environment. It is currently possible to
successfully "Prepare" and environment, but
for the result to be unusable in the manual
provider (e.g. if the bootstrap-host address is
invalid). We should that a successfully Prepared
environment should be able to be Destroyed
(with force).

The next CL will remove BootstrapStorager and fix
lp:1279259 by initialising the ubuntu user during
Prepare.

https://codereview.appspot.com/62780044/

[Andrew Wilkins (axwalk)]

Reviewers: mp+206082_code.launchpad.net,

Message:
Please take a look.

Description:
Pass environs.BootstrapContext to Prepare

This is part one of fixing lp:1279259.
In this CL, we pass context to Prepare,
giving providers an opportunity to prompt
the user to initialise an environment.

Passing context was previously restricted to
Bootstrap and EnableBootstrapStorage; this is
insufficient, as there are many ways to prepare
an environment. It is currently possible to
successfully "Prepare" and environment, but
for the result to be unusable in the manual
provider (e.g. if the bootstrap-host address is
invalid). We should that a successfully Prepared
environment should be able to be Destroyed
(with force).

The next CL will remove BootstrapStorager and fix
lp:1279259 by initialising the ubuntu user during
Prepare.

https://code.launchpad.net/~axwalk/juju-core/lp1279259-part1-prepare-context/+merge/206082

(do not edit description out of merge proposal)

Please review this at https://codereview.appspot.com/62780044/

Affected files (+223, -270 lines):
   [revision details]
   cmd/cmd.go
   cmd/juju/bootstrap.go
   cmd/juju/bootstrap_test.go
   cmd/juju/destroyenvironment_test.go
   cmd/juju/synctools.go
   cmd/juju/synctools_test.go
   cmd/plugins/juju-metadata/imagemetadata.go
   cmd/plugins/juju-metadata/imagemetadata_test.go
   cmd/plugins/juju-metadata/toolsmetadata_test.go
   cmd/plugins/juju-metadata/validateimagemetadata.go
   cmd/plugins/juju-metadata/validatetoolsmetadata.go
   cmd/plugins/juju-restore/restore.go
   environs/bootstrap/bootstrap_test.go
   environs/emptystorage_test.go
   environs/imagemetadata/urls_test.go
   environs/interface.go
   environs/jujutest/livetests.go
   environs/jujutest/tests.go
   environs/manual/bootstrap.go
   environs/manual/bootstrap_test.go
   environs/open.go
   environs/open_test.go
   environs/storage/storage_test.go
   environs/sync/sync_test.go
   environs/testing/bootstrap.go
   environs/tools/storage_test.go
   environs/tools/tools_test.go
   environs/tools/urls_test.go
   juju/apiconn_test.go
   juju/conn_test.go
   juju/testing/conn.go
   provider/azure/environprovider.go
   provider/common/bootstrap.go
   provider/common/bootstrap_test.go
   provider/dummy/config_test.go
   provider/dummy/environs.go
   provider/ec2/config_test.go
   provider/ec2/ec2.go
   provider/ec2/local_test.go
   provider/joyent/config_test.go
   provider/joyent/provider.go
   provider/local/config_test.go
   provider/local/environ.go
   provider/local/environ_test.go
   provider/local/environprovider.go
   provider/local/environprovider_test.go
   provider/maas/environ_whitebox_test.go
   provider/maas/environprovider.go
   provider/maas/environprovider_test.go
   provider/manual/environ.go
   provider/manual/environ_test.go
   provider/manual/provider.go
   provider/manual/provider_test.go
   provider/openstack/config_test.go
   provider/openstack/live_test.go
   provider/openstack/local_test.go
   provider/openstack/provider.go
   state/apiserver/common/environwatcher_test.go

[Dimiter Naydenov (dimitern)]

The diff is missing, repropose please.

https://codereview.appspot.com/62780044/

[Andrew Wilkins (axwalk)]

Please take a look.

https://codereview.appspot.com/62780044/

[William Reade (fwereade)]

LGTM

https://codereview.appspot.com/62780044/

[Go Bot (go-bot)]

The attempt to merge lp:~axwalk/juju-core/lp1279259-part1-prepare-context into lp:juju-core failed. Below is the output from the failed tests.

ok launchpad.net/juju-core 0.015s
ok launchpad.net/juju-core/agent 1.190s
ok launchpad.net/juju-core/agent/tools 0.259s
ok launchpad.net/juju-core/bzr 6.740s
ok launchpad.net/juju-core/cert 2.988s
ok launchpad.net/juju-core/charm 0.530s
? launchpad.net/juju-core/charm/hooks [no test files]
? launchpad.net/juju-core/charm/testing [no test files]
ok launchpad.net/juju-core/cloudinit 0.035s
ok launchpad.net/juju-core/cloudinit/sshinit 1.128s
ok launchpad.net/juju-core/cmd 0.230s
ok launchpad.net/juju-core/cmd/charm-admin 0.788s
? launchpad.net/juju-core/cmd/charmd [no test files]
? launchpad.net/juju-core/cmd/charmload [no test files]
ok launchpad.net/juju-core/cmd/juju 239.741s
ok launchpad.net/juju-core/cmd/jujud 61.496s
ok launchpad.net/juju-core/cmd/plugins/juju-metadata 10.401s
? launchpad.net/juju-core/cmd/plugins/juju-restore [no test files]
ok launchpad.net/juju-core/constraints 0.027s
ok launchpad.net/juju-core/container 0.037s
ok launchpad.net/juju-core/container/factory 0.051s
ok launchpad.net/juju-core/container/kvm 0.288s
ok launchpad.net/juju-core/container/kvm/mock 0.038s
? launchpad.net/juju-core/container/kvm/testing [no test files]
ok launchpad.net/juju-core/container/lxc 0.268s
? launchpad.net/juju-core/container/lxc/mock [no test files]
? launchpad.net/juju-core/container/lxc/testing [no test files]
? launchpad.net/juju-core/container/testing [no test files]
ok launchpad.net/juju-core/downloader 5.267s
ok launchpad.net/juju-core/environs 3.120s
ok launchpad.net/juju-core/environs/bootstrap 4.481s
ok launchpad.net/juju-core/environs/cloudinit 0.646s
ok launchpad.net/juju-core/environs/config 4.303s
ok launchpad.net/juju-core/environs/configstore 0.038s
ok launchpad.net/juju-core/environs/filestorage 0.032s
ok launchpad.net/juju-core/environs/httpstorage 0.965s
ok launchpad.net/juju-core/environs/imagemetadata 0.611s
? launchpad.net/juju-core/environs/imagemetadata/testing [no test files]
ok launchpad.net/juju-core/environs/instances 0.061s
ok launchpad.net/juju-core/environs/jujutest 0.351s
ok launchpad.net/juju-core/environs/manual 10.041s
ok launchpad.net/juju-core/environs/simplestreams 0.408s
? launchpad.net/juju-core/environs/simplestreams/testing [no test files]
ok launchpad.net/juju-core/environs/sshstorage 1.157s
ok launchpad.net/juju-core/environs/storage 1.201s
ok launchpad.net/juju-core/environs/sync 33.427s
ok launchpad.net/juju-core/environs/testing 0.234s
ok launchpad.net/juju-core/environs/tools 6.893s
? launchpad.net/juju-core/environs/tools/testing [no test files]
ok launchpad.net/juju-core/errors 0.015s
ok launchpad.net/juju-core/instance 0.023s
? launchpad.net/juju-core/instance/testing [no test files]
ok launchpad.net/juju-core/juju 23.668s
ok launchpad.net/juju-core/juju/osenv 0.019s
? launchpad.net/juju-core/juju/testing [no test files]
ok launchpad.net/juju-core/log 0.015s
ok launchpad.net/juju-core/log/syslog 0.023s
? launchpad.net/j...

=== modified file 'cmd/cmd.go'
--- cmd/cmd.go	2013-12-19 09:15:40 +0000
+++ cmd/cmd.go	2014-02-18 02:14:09 +0000
@@ -112,12 +112,27 @@
 	return filepath.Join(ctx.Dir, path)
 }
 
-// InterruptNotify partially satisfies environs/bootstrap.BootstrapContext
+// GetStdin satisfies environs.BootstrapContext
+func (ctx *Context) GetStdin() io.Reader {
+	return ctx.Stdin
+}
+
+// GetStdout satisfies environs.BootstrapContext
+func (ctx *Context) GetStdout() io.Writer {
+	return ctx.Stdout
+}
+
+// GetStderr satisfies environs.BootstrapContext
+func (ctx *Context) GetStderr() io.Writer {
+	return ctx.Stderr
+}
+
+// InterruptNotify satisfies environs.BootstrapContext
 func (ctx *Context) InterruptNotify(c chan<- os.Signal) {
 	signal.Notify(c, os.Interrupt)
 }
 
-// StopInterruptNotify partially satisfies environs/bootstrap.BootstrapContext
+// StopInterruptNotify satisfies environs.BootstrapContext
 func (ctx *Context) StopInterruptNotify(c chan<- os.Signal) {
 	signal.Stop(c)
 }

=== modified file 'cmd/juju/bootstrap.go'
--- cmd/juju/bootstrap.go	2014-02-11 01:35:20 +0000
+++ cmd/juju/bootstrap.go	2014-02-18 02:14:09 +0000
@@ -5,7 +5,6 @@
 
 import (
 	"fmt"
-	"io"
 	"os"
 	"strings"
 
@@ -97,22 +96,6 @@
 	return cmd.CheckEmpty(args)
 }
 
-type bootstrapContext struct {
-	*cmd.Context
-}
-
-func (c bootstrapContext) Stdin() io.Reader {
-	return c.Context.Stdin
-}
-
-func (c bootstrapContext) Stdout() io.Writer {
-	return c.Context.Stdout
-}
-
-func (c bootstrapContext) Stderr() io.Writer {
-	return c.Context.Stderr
-}
-
 func destroyPreparedEnviron(env environs.Environ, store configstore.Storage, err *error, action string) {
 	if *err == nil {
 		return
@@ -134,18 +117,17 @@
 	if _, err := store.ReadInfo(c.EnvName); !errors.IsNotFoundError(err) {
 		existing = true
 	}
-	environ, err := environs.PrepareFromName(c.EnvName, store)
+	environ, err := environs.PrepareFromName(c.EnvName, ctx, store)
 	if err != nil {
 		return err
 	}
 	if !existing {
 		defer destroyPreparedEnviron(environ, store, &resultErr, "Bootstrap")
 	}
-	bootstrapContext := bootstrapContext{ctx}
 	// If the environment has a special bootstrap Storage, use it wherever
 	// we'd otherwise use environ.Storage.
 	if bs, ok := environ.(environs.BootstrapStorager); ok {
-		if err := bs.EnableBootstrapStorage(bootstrapContext); err != nil {
+		if err := bs.EnableBootstrapStorage(ctx); err != nil {
 			return errgo.Annotate(err, "failed to enable bootstrap storage")
 		}
 	}
@@ -179,7 +161,7 @@
 			return err
 		}
 	}
-	return bootstrap.Bootstrap(bootstrapContext, environ, c.Constraints)
+	return bootstrap.Bootstrap(ctx, environ, c.Constraints)
 }
 
 func (c *BootstrapCommand) uploadTools(environ environs.Environ) error {

=== modified file 'cmd/juju/bootstrap_test.go'
--- cmd/juju/bootstrap_test.go	2014-02-03 06:58:26 +0000
+++ cmd/juju/bootstrap_test.go	2014-02-18 02:14:09 +0000
@@ -516,7 +516,7 @@
 	dummy.Reset()
 	store, err := configstore.Default()
 	c.Assert(err, gc.IsNil)
-	env, err := environs.PrepareFromName("peckham", store)
+	env, err := environs.PrepareFromName("peckham", nullContext(), store)
 	c.Assert(err, gc.IsNil)
 	envtesting.RemoveAllTools(c, env)
 	return env, fake

=== modified file 'cmd/juju/destroyenvironment_test.go'
--- cmd/juju/destroyenvironment_test.go	2014-02-03 09:09:49 +0000
+++ cmd/juju/destroyenvironment_test.go	2014-02-18 02:14:09 +0000
@@ -27,7 +27,7 @@
 
 func (s *destroyEnvSuite) TestDestroyEnvironmentCommand(c *gc.C) {
 	// Prepare the environment so we can destroy it.
-	_, err := environs.PrepareFromName("dummyenv", s.ConfigStore)
+	_, err := environs.PrepareFromName("dummyenv", nullContext(), s.ConfigStore)
 	c.Assert(err, gc.IsNil)
 
 	// check environment is mandatory
@@ -46,7 +46,7 @@
 
 func (s *destroyEnvSuite) TestDestroyEnvironmentCommandEFlag(c *gc.C) {
 	// Prepare the environment so we can destroy it.
-	_, err := environs.PrepareFromName("dummyenv", s.ConfigStore)
+	_, err := environs.PrepareFromName("dummyenv", nullContext(), s.ConfigStore)
 	c.Assert(err, gc.IsNil)
 
 	// check that either environment or the flag is mandatory
@@ -89,7 +89,7 @@
 	c.Assert(err, gc.IsNil)
 
 	// Prepare the environment so we can destroy it.
-	_, err = environs.PrepareFromName("dummyenv", s.ConfigStore)
+	_, err = environs.PrepareFromName("dummyenv", nullContext(), s.ConfigStore)
 	c.Assert(err, gc.IsNil)
 
 	// destroy with broken environment
@@ -122,7 +122,7 @@
 	ctx.Stdin = &stdin
 
 	// Prepare the environment so we can destroy it.
-	env, err := environs.PrepareFromName("dummyenv", s.ConfigStore)
+	env, err := environs.PrepareFromName("dummyenv", nullContext(), s.ConfigStore)
 	c.Assert(err, gc.IsNil)
 
 	assertEnvironNotDestroyed(c, env, s.ConfigStore)
@@ -156,7 +156,7 @@
 	for _, answer := range []string{"y", "Y", "yes", "YES"} {
 		// Prepare the environment so we can destroy it.
 		s.Reset(c)
-		env, err := environs.PrepareFromName("dummyenv", s.ConfigStore)
+		env, err := environs.PrepareFromName("dummyenv", nullContext(), s.ConfigStore)
 		c.Assert(err, gc.IsNil)
 
 		stdin.Reset()

=== modified file 'cmd/juju/synctools.go'
--- cmd/juju/synctools.go	2014-02-17 21:23:26 +0000
+++ cmd/juju/synctools.go	2014-02-18 02:14:09 +0000
@@ -92,7 +92,7 @@
 	if _, err := store.ReadInfo(c.EnvName); !errors.IsNotFoundError(err) {
 		existing = true
 	}
-	environ, err := environs.PrepareFromName(c.EnvName, store)
+	environ, err := environs.PrepareFromName(c.EnvName, ctx, store)
 	if err != nil {
 		return err
 	}

=== modified file 'cmd/juju/synctools_test.go'
--- cmd/juju/synctools_test.go	2014-02-17 21:23:26 +0000
+++ cmd/juju/synctools_test.go	2014-02-18 02:14:09 +0000
@@ -125,7 +125,7 @@
 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", s.configStore)
+		targetEnv, err := environs.PrepareFromName("test-target", nullContext(), s.configStore)
 		c.Assert(err, gc.IsNil)
 		called := false
 		syncTools = func(sctx *sync.SyncContext) error {

=== modified file 'cmd/plugins/juju-metadata/imagemetadata.go'
--- cmd/plugins/juju-metadata/imagemetadata.go	2014-01-31 00:14:11 +0000
+++ cmd/plugins/juju-metadata/imagemetadata.go	2014-02-18 02:14:09 +0000
@@ -61,10 +61,16 @@
 }
 
 func (c *ImageMetadataCommand) Init(args []string) error {
+	return cmd.CheckEmpty(args)
+}
+
+// setParams sets parameters based on the environment configuration
+// for those which have not been explicitly specified.
+func (c *ImageMetadataCommand) setParams(context *cmd.Context) error {
 	c.privateStorage = "<private storage name>"
 	var environ environs.Environ
 	if store, err := configstore.Default(); err == nil {
-		if environ, err = environs.PrepareFromName(c.EnvName, store); err == nil {
+		if environ, err = environs.PrepareFromName(c.EnvName, context, store); err == nil {
 			logger.Infof("creating image metadata for environment %q", environ.Name())
 			// If the user has not specified region and endpoint, try and get it from the environment.
 			if c.Region == "" || c.Endpoint == "" {
@@ -120,8 +126,7 @@
 			return err
 		}
 	}
-
-	return cmd.CheckEmpty(args)
+	return nil
 }
 
 var helpDoc = `
@@ -143,8 +148,10 @@
 `
 
 func (c *ImageMetadataCommand) Run(context *cmd.Context) error {
+	if err := c.setParams(context); err != nil {
+		return err
+	}
 	out := context.Stdout
-
 	im := &imagemetadata.ImageMetadata{
 		Id:   c.ImageId,
 		Arch: c.Arch,

=== modified file 'cmd/plugins/juju-metadata/imagemetadata_test.go'
--- cmd/plugins/juju-metadata/imagemetadata_test.go	2013-11-04 00:24:21 +0000
+++ cmd/plugins/juju-metadata/imagemetadata_test.go	2014-02-18 02:14:09 +0000
@@ -228,6 +228,6 @@
 		c.Logf("test: %d", i)
 		ctx := testing.Context(c)
 		code := cmd.Main(&ImageMetadataCommand{}, ctx, t.args)
-		c.Check(code, gc.Equals, 2)
+		c.Check(code, gc.Equals, 1)
 	}
 }

=== modified file 'cmd/plugins/juju-metadata/toolsmetadata_test.go'
--- cmd/plugins/juju-metadata/toolsmetadata_test.go	2014-01-31 04:29:28 +0000
+++ cmd/plugins/juju-metadata/toolsmetadata_test.go	2014-02-18 02:14:09 +0000
@@ -43,7 +43,7 @@
 		dummy.Reset()
 		loggo.ResetLoggers()
 	})
-	env, err := environs.PrepareFromName("erewhemos", configstore.NewMem())
+	env, err := environs.PrepareFromName("erewhemos", coretesting.Context(c), configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 	s.env = env
 	envtesting.RemoveAllTools(c, s.env)

=== modified file 'cmd/plugins/juju-metadata/validateimagemetadata.go'
--- cmd/plugins/juju-metadata/validateimagemetadata.go	2014-01-29 06:45:16 +0000
+++ cmd/plugins/juju-metadata/validateimagemetadata.go	2014-02-18 02:14:09 +0000
@@ -134,7 +134,7 @@
 		if err != nil {
 			return err
 		}
-		environ, err := environs.PrepareFromName(c.EnvName, store)
+		environ, err := environs.PrepareFromName(c.EnvName, context, store)
 		if err != nil {
 			return err
 		}

=== modified file 'cmd/plugins/juju-metadata/validatetoolsmetadata.go'
--- cmd/plugins/juju-metadata/validatetoolsmetadata.go	2013-10-10 11:40:54 +0000
+++ cmd/plugins/juju-metadata/validatetoolsmetadata.go	2014-02-18 02:14:09 +0000
@@ -141,7 +141,7 @@
 		if err != nil {
 			return err
 		}
-		environ, err := environs.PrepareFromName(c.EnvName, store)
+		environ, err := environs.PrepareFromName(c.EnvName, context, store)
 		if err == nil {
 			mdLookup, ok := environ.(simplestreams.MetadataValidator)
 			if !ok {

=== modified file 'cmd/plugins/juju-restore/restore.go'
--- cmd/plugins/juju-restore/restore.go	2014-02-06 11:18:27 +0000
+++ cmd/plugins/juju-restore/restore.go	2014-02-18 02:14:09 +0000
@@ -12,7 +12,6 @@
 	"io/ioutil"
 	"os"
 	"os/exec"
-	"os/signal"
 	"path"
 	"text/template"
 
@@ -154,7 +153,7 @@
 	if err != nil {
 		return err
 	}
-	env, err := rebootstrap(cfg, c.Constraints)
+	env, err := rebootstrap(cfg, ctx, c.Constraints)
 	if err != nil {
 		return fmt.Errorf("cannot re-bootstrap environment: %v", err)
 	}
@@ -203,7 +202,7 @@
 	fmt.Printf("%s\n", fmt.Sprintf(f, a...))
 }
 
-func rebootstrap(cfg *config.Config, cons constraints.Value) (environs.Environ, error) {
+func rebootstrap(cfg *config.Config, ctx *cmd.Context, cons constraints.Value) (environs.Environ, error) {
 	progress("re-bootstrapping environment")
 	// Turn on safe mode so that the newly bootstrapped instance
 	// will not destroy all the instances it does not know about.
@@ -245,7 +244,7 @@
 	// error-prone) or we could provide a --no-check flag to make
 	// it go ahead anyway without the check.
 
-	if err := bootstrap.Bootstrap(bootstrapContext{}, env, cons); err != nil {
+	if err := bootstrap.Bootstrap(ctx, env, cons); err != nil {
 		return nil, fmt.Errorf("cannot bootstrap new instance: %v", err)
 	}
 	return env, nil
@@ -462,25 +461,3 @@
 	}
 	return buf.String()
 }
-
-type bootstrapContext struct{}
-
-func (bootstrapContext) Stdin() io.Reader {
-	return os.Stdin
-}
-
-func (bootstrapContext) Stdout() io.Writer {
-	return os.Stdout
-}
-
-func (bootstrapContext) Stderr() io.Writer {
-	return os.Stderr
-}
-
-func (bootstrapContext) InterruptNotify(c chan<- os.Signal) {
-	signal.Notify(c, os.Interrupt)
-}
-
-func (bootstrapContext) StopInterruptNotify(c chan<- os.Signal) {
-	signal.Stop(c)
-}

=== modified file 'environs/bootstrap/bootstrap_test.go'
--- environs/bootstrap/bootstrap_test.go	2014-01-20 23:32:00 +0000
+++ environs/bootstrap/bootstrap_test.go	2014-02-18 02:14:09 +0000
@@ -53,11 +53,6 @@
 	s.LoggingSuite.TearDownTest(c)
 }
 
-func bootstrapContext(c *gc.C) environs.BootstrapContext {
-	ctx := coretesting.Context(c)
-	return envtesting.NewBootstrapContext(ctx)
-}
-
 func (s *bootstrapSuite) TestBootstrapNeedsSettings(c *gc.C) {
 	env := newEnviron("bar", noKeysDefined)
 	s.setDummyStorage(c, env)
@@ -69,20 +64,20 @@
 		env.cfg = cfg
 	}
 
-	err := bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err := bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
 	c.Assert(err, gc.ErrorMatches, "environment configuration has no admin-secret")
 
 	fixEnv("admin-secret", "whatever")
-	err = bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err = bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
 	c.Assert(err, gc.ErrorMatches, "environment configuration has no ca-cert")
 
 	fixEnv("ca-cert", coretesting.CACert)
-	err = bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err = bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
 	c.Assert(err, gc.ErrorMatches, "environment configuration has no ca-private-key")
 
 	fixEnv("ca-private-key", coretesting.CAKey)
 	uploadTools(c, env)
-	err = bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err = bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 }
 
@@ -95,7 +90,7 @@
 func (s *bootstrapSuite) TestBootstrapEmptyConstraints(c *gc.C) {
 	env := newEnviron("foo", useDefaultKeys)
 	s.setDummyStorage(c, env)
-	err := bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err := bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 	c.Assert(env.bootstrapCount, gc.Equals, 1)
 	c.Assert(env.constraints, gc.DeepEquals, constraints.Value{})
@@ -105,7 +100,7 @@
 	env := newEnviron("foo", useDefaultKeys)
 	s.setDummyStorage(c, env)
 	cons := constraints.MustParse("cpu-cores=2 mem=4G")
-	err := bootstrap.Bootstrap(bootstrapContext(c), env, cons)
+	err := bootstrap.Bootstrap(coretesting.Context(c), env, cons)
 	c.Assert(err, gc.IsNil)
 	c.Assert(env.bootstrapCount, gc.Equals, 1)
 	c.Assert(env.constraints, gc.DeepEquals, cons)
@@ -157,7 +152,7 @@
 		}
 		cfg, err := config.New(config.NoDefaults, attrs)
 		c.Assert(err, gc.IsNil)
-		env, err := environs.Prepare(cfg, configstore.NewMem())
+		env, err := environs.Prepare(cfg, coretesting.Context(c), configstore.NewMem())
 		c.Assert(err, gc.IsNil)
 		envtesting.RemoveAllTools(c, env)
 
@@ -170,7 +165,7 @@
 		if test.Arch != "" {
 			cons = constraints.MustParse("arch=" + test.Arch)
 		}
-		err = bootstrap.Bootstrap(bootstrapContext(c), env, cons)
+		err = bootstrap.Bootstrap(coretesting.Context(c), env, cons)
 		if test.Err != nil {
 			c.Check(err, gc.ErrorMatches, ".*"+test.Err.Error())
 			continue
@@ -193,7 +188,7 @@
 	env := newEnviron("foo", useDefaultKeys)
 	s.setDummyStorage(c, env)
 	envtesting.RemoveFakeTools(c, env.Storage())
-	err := bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err := bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
 	// bootstrap.Bootstrap leaves it to the provider to
 	// locate bootstrap tools.
 	c.Assert(err, gc.IsNil)

=== modified file 'environs/emptystorage_test.go'
--- environs/emptystorage_test.go	2013-10-03 01:28:51 +0000
+++ environs/emptystorage_test.go	2014-02-18 02:14:09 +0000
@@ -63,7 +63,8 @@
 func (s *verifyStorageSuite) TestVerifyStorage(c *gc.C) {
 	defer testing.MakeFakeHome(c, existingEnv, "existing").Restore()
 
-	environ, err := environs.PrepareFromName("test", configstore.NewMem())
+	ctx := testing.Context(c)
+	environ, err := environs.PrepareFromName("test", ctx, configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 	stor := environ.Storage()
 	err = environs.VerifyStorage(stor)
@@ -80,7 +81,8 @@
 func (s *verifyStorageSuite) TestVerifyStorageFails(c *gc.C) {
 	defer testing.MakeFakeHome(c, existingEnv, "existing").Restore()
 
-	environ, err := environs.PrepareFromName("test", configstore.NewMem())
+	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")

=== modified file 'environs/imagemetadata/urls_test.go'
--- environs/imagemetadata/urls_test.go	2014-01-30 07:37:38 +0000
+++ environs/imagemetadata/urls_test.go	2014-02-18 02:14:09 +0000
@@ -46,7 +46,7 @@
 	}
 	cfg, err := config.New(config.NoDefaults, attrs)
 	c.Assert(err, gc.IsNil)
-	env, err := environs.Prepare(cfg, configstore.NewMem())
+	env, err := environs.Prepare(cfg, testing.Context(c), configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 	// Put a file in images since the dummy storage provider requires a
 	// file to exist before the URL can be found. This is to ensure it behaves

=== modified file 'environs/interface.go'
--- environs/interface.go	2013-12-20 02:38:56 +0000
+++ environs/interface.go	2014-02-18 02:14:09 +0000
@@ -21,7 +21,7 @@
 	// configuration attributes in the returned environment should
 	// be saved to be used later. If the environment is already
 	// prepared, this call is equivalent to Open.
-	Prepare(cfg *config.Config) (Environ, error)
+	Prepare(ctx BootstrapContext, cfg *config.Config) (Environ, error)
 
 	// Open opens the environment and returns it.
 	// The configuration must have come from a previously
@@ -201,9 +201,9 @@
 // information about and manipulating the context in which
 // it is being invoked.
 type BootstrapContext interface {
-	Stdin() io.Reader
-	Stdout() io.Writer
-	Stderr() io.Writer
+	GetStdin() io.Reader
+	GetStdout() io.Writer
+	GetStderr() io.Writer
 
 	// InterruptNotify starts watching for interrupt signals
 	// on behalf of the caller, sending them to the supplied

=== modified file 'environs/jujutest/livetests.go'
--- environs/jujutest/livetests.go	2014-01-07 07:35:12 +0000
+++ environs/jujutest/livetests.go	2014-02-18 02:14:09 +0000
@@ -118,7 +118,7 @@
 	}
 	cfg, err := config.New(config.NoDefaults, t.TestConfig)
 	c.Assert(err, gc.IsNil)
-	e, err := environs.Prepare(cfg, t.ConfigStore)
+	e, err := environs.Prepare(cfg, coretesting.Context(c), t.ConfigStore)
 	c.Assert(err, gc.IsNil, gc.Commentf("preparing environ %#v", t.TestConfig))
 	c.Assert(e, gc.NotNil)
 	t.Env = e
@@ -140,7 +140,7 @@
 	envtesting.UploadFakeTools(c, t.Env.Storage())
 	err := common.EnsureNotBootstrapped(t.Env)
 	c.Assert(err, gc.IsNil)
-	err = bootstrap.Bootstrap(bootstrapContext(c), t.Env, cons)
+	err = bootstrap.Bootstrap(coretesting.Context(c), t.Env, cons)
 	c.Assert(err, gc.IsNil)
 	t.bootstrapped = true
 }
@@ -895,7 +895,7 @@
 		"state-server": false,
 		"name":         "dummy storage",
 	}))
-	dummyenv, err := environs.Prepare(dummyCfg, configstore.NewMem())
+	dummyenv, err := environs.Prepare(dummyCfg, coretesting.Context(c), configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 	defer dummyenv.Destroy()
 
@@ -904,7 +904,7 @@
 	attrs := t.TestConfig.Merge(coretesting.Attrs{"default-series": other.Series})
 	cfg, err := config.New(config.NoDefaults, attrs)
 	c.Assert(err, gc.IsNil)
-	env, err := environs.Prepare(cfg, t.ConfigStore)
+	env, err := environs.Prepare(cfg, coretesting.Context(c), t.ConfigStore)
 	c.Assert(err, gc.IsNil)
 	defer environs.Destroy(env, t.ConfigStore)
 
@@ -924,7 +924,7 @@
 	err = storageCopy(dummyStorage, currentName, envStorage, otherName)
 	c.Assert(err, gc.IsNil)
 
-	err = bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err = bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 
 	conn, err := juju.NewConn(env)

=== modified file 'environs/jujutest/tests.go'
--- environs/jujutest/tests.go	2013-12-20 02:38:56 +0000
+++ environs/jujutest/tests.go	2014-02-18 02:14:09 +0000
@@ -61,7 +61,7 @@
 func (t *Tests) Prepare(c *gc.C) environs.Environ {
 	cfg, err := config.New(config.NoDefaults, t.TestConfig)
 	c.Assert(err, gc.IsNil)
-	e, err := environs.Prepare(cfg, t.ConfigStore)
+	e, err := environs.Prepare(cfg, coretesting.Context(c), t.ConfigStore)
 	c.Assert(err, gc.IsNil, gc.Commentf("preparing environ %#v", t.TestConfig))
 	c.Assert(e, gc.NotNil)
 	return e
@@ -78,10 +78,6 @@
 	t.LoggingSuite.TearDownTest(c)
 }
 
-func bootstrapContext(c *gc.C) environs.BootstrapContext {
-	return envtesting.NewBootstrapContext(coretesting.Context(c))
-}
-
 func (t *Tests) TestStartStop(c *gc.C) {
 	e := t.Prepare(c)
 	envtesting.UploadFakeTools(c, e.Storage())
@@ -138,7 +134,7 @@
 	envtesting.UploadFakeTools(c, e.Storage())
 	err := common.EnsureNotBootstrapped(e)
 	c.Assert(err, gc.IsNil)
-	err = bootstrap.Bootstrap(bootstrapContext(c), e, constraints.Value{})
+	err = bootstrap.Bootstrap(coretesting.Context(c), e, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 
 	info, apiInfo, err := e.StateInfo()
@@ -166,7 +162,7 @@
 
 	err = common.EnsureNotBootstrapped(e3)
 	c.Assert(err, gc.IsNil)
-	err = bootstrap.Bootstrap(bootstrapContext(c), e3, constraints.Value{})
+	err = bootstrap.Bootstrap(coretesting.Context(c), e3, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 
 	err = common.EnsureNotBootstrapped(e3)

=== modified file 'environs/manual/bootstrap.go'
--- environs/manual/bootstrap.go	2014-01-06 07:38:53 +0000
+++ environs/manual/bootstrap.go	2014-02-18 02:14:09 +0000
@@ -136,5 +136,5 @@
 	for k, v := range agentEnv {
 		mcfg.AgentEnvironment[k] = v
 	}
-	return provisionMachineAgent(args.Host, mcfg, args.Context.Stderr())
+	return provisionMachineAgent(args.Host, mcfg, args.Context.GetStderr())
 }

=== modified file 'environs/manual/bootstrap_test.go'
--- environs/manual/bootstrap_test.go	2014-01-06 07:17:46 +0000
+++ environs/manual/bootstrap_test.go	2014-02-18 02:14:09 +0000
@@ -12,7 +12,6 @@
 	"launchpad.net/juju-core/environs/bootstrap"
 	"launchpad.net/juju-core/environs/filestorage"
 	"launchpad.net/juju-core/environs/storage"
-	envtesting "launchpad.net/juju-core/environs/testing"
 	"launchpad.net/juju-core/environs/tools"
 	"launchpad.net/juju-core/instance"
 	"launchpad.net/juju-core/juju/testing"
@@ -81,7 +80,7 @@
 		HardwareCharacteristics: &instance.HardwareCharacteristics{
 			Arch: &arch,
 		},
-		Context: envtesting.NewBootstrapContext(coretesting.Context(c)),
+		Context: coretesting.Context(c),
 	}
 }
 

=== modified file 'environs/open.go'
--- environs/open.go	2014-02-13 10:08:31 +0000
+++ environs/open.go	2014-02-18 02:14:09 +0000
@@ -118,12 +118,12 @@
 // and environment information is created using the
 // given store. If the environment is already prepared,
 // it behaves like NewFromName.
-func PrepareFromName(name string, store configstore.Storage) (Environ, error) {
+func PrepareFromName(name string, ctx BootstrapContext, store configstore.Storage) (Environ, error) {
 	cfg, _, err := ConfigForName(name, store)
 	if err != nil {
 		return nil, err
 	}
-	return Prepare(cfg, store)
+	return Prepare(cfg, ctx, store)
 }
 
 // NewFromAttrs returns a new environment based on the provided configuration
@@ -148,7 +148,7 @@
 
 // Prepare prepares a new environment based on the provided configuration.
 // If the environment is already prepared, it behaves like New.
-func Prepare(cfg *config.Config, store configstore.Storage) (Environ, error) {
+func Prepare(cfg *config.Config, ctx BootstrapContext, store configstore.Storage) (Environ, error) {
 	p, err := Provider(cfg.Type())
 	if err != nil {
 		return nil, err
@@ -175,7 +175,7 @@
 	if err != nil {
 		return nil, fmt.Errorf("cannot create new info for environment %q: %v", cfg.Name(), err)
 	}
-	env, err := prepare(cfg, info, p)
+	env, err := prepare(ctx, cfg, info, p)
 	if err != nil {
 		if err := info.Destroy(); err != nil {
 			logger.Warningf("cannot destroy newly created environment info: %v", err)
@@ -189,7 +189,7 @@
 	return env, nil
 }
 
-func prepare(cfg *config.Config, info configstore.EnvironInfo, p EnvironProvider) (Environ, error) {
+func prepare(ctx BootstrapContext, cfg *config.Config, info configstore.EnvironInfo, p EnvironProvider) (Environ, error) {
 	cfg, err := ensureAdminSecret(cfg)
 	if err != nil {
 		return nil, fmt.Errorf("cannot generate admin-secret: %v", err)
@@ -198,7 +198,7 @@
 	if err != nil {
 		return nil, fmt.Errorf("cannot ensure CA certificate: %v", err)
 	}
-	return p.Prepare(cfg)
+	return p.Prepare(ctx, cfg)
 }
 
 // ensureAdminSecret returns a config with a non-empty admin-secret.

=== modified file 'environs/open_test.go'
--- environs/open_test.go	2014-02-11 02:50:17 +0000
+++ environs/open_test.go	2014-02-18 02:14:09 +0000
@@ -37,10 +37,10 @@
 	// matches *Settings.Map()
 	cfg, err := config.New(config.NoDefaults, dummySampleConfig())
 	c.Assert(err, gc.IsNil)
-	env, err := environs.Prepare(cfg, configstore.NewMem())
+	ctx := testing.Context(c)
+	env, err := environs.Prepare(cfg, ctx, configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 	envtesting.UploadFakeTools(c, env.Storage())
-	ctx := envtesting.NewBootstrapContext(testing.Context(c))
 	err = bootstrap.Bootstrap(ctx, env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 }
@@ -57,7 +57,8 @@
 func (*OpenSuite) TestNewFromName(c *gc.C) {
 	defer testing.MakeFakeHome(c, testing.MultipleEnvConfigNoDefault, testing.SampleCertName).Restore()
 	store := configstore.NewMem()
-	e, err := environs.PrepareFromName("erewhemos", store)
+	ctx := testing.Context(c)
+	e, err := environs.PrepareFromName("erewhemos", ctx, store)
 	c.Assert(err, gc.IsNil)
 
 	e, err = environs.NewFromName("erewhemos", store)
@@ -96,7 +97,8 @@
 
 func (*OpenSuite) TestPrepareFromName(c *gc.C) {
 	defer testing.MakeFakeHome(c, testing.MultipleEnvConfigNoDefault, testing.SampleCertName).Restore()
-	e, err := environs.PrepareFromName("erewhemos", configstore.NewMem())
+	ctx := testing.Context(c)
+	e, err := environs.PrepareFromName("erewhemos", ctx, configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 	c.Assert(e.Name(), gc.Equals, "erewhemos")
 	// Check we can access storage ok, which implies the environment has been prepared.
@@ -175,7 +177,8 @@
 	cfg, err := config.New(config.NoDefaults, baselineAttrs)
 	c.Assert(err, gc.IsNil)
 	store := configstore.NewMem()
-	env, err := environs.Prepare(cfg, store)
+	ctx := testing.Context(c)
+	env, err := environs.Prepare(cfg, ctx, store)
 	c.Assert(err, gc.IsNil)
 	// Check we can access storage ok, which implies the environment has been prepared.
 	c.Assert(env.Storage(), gc.NotNil)
@@ -204,7 +207,7 @@
 	c.Assert(caCert.Subject.CommonName, gc.Equals, `juju-generated CA for environment "`+testing.SampleEnvName+`"`)
 
 	// Check we can call Prepare again.
-	env, err = environs.Prepare(cfg, store)
+	env, err = environs.Prepare(cfg, ctx, store)
 	c.Assert(err, gc.IsNil)
 	c.Assert(env.Name(), gc.Equals, "erewhemos")
 	c.Assert(env.Storage(), gc.NotNil)
@@ -221,13 +224,14 @@
 	cfg, err := config.New(config.NoDefaults, baselineAttrs)
 	c.Assert(err, gc.IsNil)
 
-	env0, err := environs.Prepare(cfg, configstore.NewMem())
+	ctx := testing.Context(c)
+	env0, err := environs.Prepare(cfg, ctx, configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 	adminSecret0 := env0.Config().AdminSecret()
 	c.Assert(adminSecret0, gc.HasLen, 32)
 	c.Assert(adminSecret0, gc.Matches, "^[0-9a-f]*$")
 
-	env1, err := environs.Prepare(cfg, configstore.NewMem())
+	env1, err := environs.Prepare(cfg, ctx, configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 	adminSecret1 := env1.Config().AdminSecret()
 	c.Assert(adminSecret1, gc.HasLen, 32)
@@ -246,7 +250,7 @@
 	))
 	c.Assert(err, gc.IsNil)
 	store := configstore.NewMem()
-	env, err := environs.Prepare(cfg, store)
+	env, err := environs.Prepare(cfg, testing.Context(c), store)
 	c.Assert(err, gc.ErrorMatches, "cannot ensure CA certificate: environment configuration with a certificate but no CA private key")
 	c.Assert(env, gc.IsNil)
 	// Ensure that the config storage info is cleaned up.
@@ -264,7 +268,8 @@
 		},
 	))
 	c.Assert(err, gc.IsNil)
-	env, err := environs.Prepare(cfg, configstore.NewMem())
+	ctx := testing.Context(c)
+	env, err := environs.Prepare(cfg, ctx, configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 	cfgCertPEM, cfgCertOK := env.Config().CACert()
 	cfgKeyPEM, cfgKeyOK := env.Config().CAPrivateKey()
@@ -286,7 +291,8 @@
 	store := configstore.NewMem()
 	// Prepare the environment and sanity-check that
 	// the config storage info has been made.
-	e, err := environs.Prepare(cfg, store)
+	ctx := testing.Context(c)
+	e, err := environs.Prepare(cfg, ctx, store)
 	c.Assert(err, gc.IsNil)
 	_, err = store.ReadInfo(e.Name())
 	c.Assert(err, gc.IsNil)
@@ -332,7 +338,8 @@
 func (s *checkEnvironmentSuite) TestCheckEnvironment(c *gc.C) {
 	defer testing.MakeFakeHome(c, checkEnv, "existing").Restore()
 
-	environ, err := environs.PrepareFromName("test", configstore.NewMem())
+	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
@@ -347,7 +354,8 @@
 func (s *checkEnvironmentSuite) TestCheckEnvironmentFileNotFound(c *gc.C) {
 	defer testing.MakeFakeHome(c, checkEnv, "existing").Restore()
 
-	environ, err := environs.PrepareFromName("test", configstore.NewMem())
+	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
@@ -368,7 +376,8 @@
 func (s *checkEnvironmentSuite) TestCheckEnvironmentGetFails(c *gc.C) {
 	defer testing.MakeFakeHome(c, checkEnv, "existing").Restore()
 
-	environ, err := environs.PrepareFromName("test", configstore.NewMem())
+	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
@@ -388,7 +397,8 @@
 func (s *checkEnvironmentSuite) TestCheckEnvironmentBadContent(c *gc.C) {
 	defer testing.MakeFakeHome(c, checkEnv, "existing").Restore()
 
-	environ, err := environs.PrepareFromName("test", configstore.NewMem())
+	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.

=== modified file 'environs/storage/storage_test.go'
--- environs/storage/storage_test.go	2014-01-31 00:14:11 +0000
+++ environs/storage/storage_test.go	2014-02-18 02:14:09 +0000
@@ -42,7 +42,7 @@
 
 func (s *datasourceSuite) SetUpTest(c *gc.C) {
 	s.home = testing.MakeFakeHome(c, existingEnv, "existing")
-	environ, err := environs.PrepareFromName("test", configstore.NewMem())
+	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("")

=== modified file 'environs/sync/sync_test.go'
--- environs/sync/sync_test.go	2014-01-30 06:21:03 +0000
+++ environs/sync/sync_test.go	2014-02-18 02:14:09 +0000
@@ -68,7 +68,7 @@
 `)
 	s.AddCleanup(func(*gc.C) { fakeHome.Restore() })
 	var err error
-	s.targetEnv, err = environs.PrepareFromName("test-target", configstore.NewMem())
+	s.targetEnv, err = environs.PrepareFromName("test-target", coretesting.Context(c), configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 	envtesting.RemoveAllTools(c, s.targetEnv)
 
@@ -264,7 +264,7 @@
 	// We only want to use simplestreams to find any synced tools.
 	cfg, err := config.New(config.NoDefaults, dummy.SampleConfig())
 	c.Assert(err, gc.IsNil)
-	s.env, err = environs.Prepare(cfg, configstore.NewMem())
+	s.env, err = environs.Prepare(cfg, coretesting.Context(c), configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 }
 

=== modified file 'environs/testing/bootstrap.go'
--- environs/testing/bootstrap.go	2014-01-28 04:58:43 +0000
+++ environs/testing/bootstrap.go	2014-02-18 02:14:09 +0000
@@ -4,11 +4,8 @@
 package testing
 
 import (
-	"io"
-
 	"github.com/loggo/loggo"
 
-	"launchpad.net/juju-core/cmd"
 	"launchpad.net/juju-core/environs"
 	"launchpad.net/juju-core/environs/cloudinit"
 	"launchpad.net/juju-core/instance"
@@ -29,23 +26,3 @@
 	}
 	return testbase.PatchValue(&common.FinishBootstrap, f)
 }
-
-type bootstrapContext struct {
-	*cmd.Context
-}
-
-func (c bootstrapContext) Stdin() io.Reader {
-	return c.Context.Stdin
-}
-
-func (c bootstrapContext) Stdout() io.Writer {
-	return c.Context.Stdout
-}
-
-func (c bootstrapContext) Stderr() io.Writer {
-	return c.Context.Stderr
-}
-
-func NewBootstrapContext(ctx *cmd.Context) environs.BootstrapContext {
-	return bootstrapContext{ctx}
-}

=== modified file 'environs/tools/storage_test.go'
--- environs/tools/storage_test.go	2013-09-27 02:31:45 +0000
+++ environs/tools/storage_test.go	2014-02-18 02:14:09 +0000
@@ -12,6 +12,7 @@
 	envtesting "launchpad.net/juju-core/environs/testing"
 	envtools "launchpad.net/juju-core/environs/tools"
 	"launchpad.net/juju-core/provider/dummy"
+	"launchpad.net/juju-core/testing"
 	"launchpad.net/juju-core/testing/testbase"
 	coretools "launchpad.net/juju-core/tools"
 	"launchpad.net/juju-core/version"
@@ -29,7 +30,7 @@
 	s.LoggingSuite.SetUpTest(c)
 	cfg, err := config.New(config.NoDefaults, dummy.SampleConfig())
 	c.Assert(err, gc.IsNil)
-	s.env, err = environs.Prepare(cfg, configstore.NewMem())
+	s.env, err = environs.Prepare(cfg, testing.Context(c), configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 	s.dataDir = c.MkDir()
 }

=== modified file 'environs/tools/tools_test.go'
--- environs/tools/tools_test.go	2014-01-30 07:37:38 +0000
+++ environs/tools/tools_test.go	2014-02-18 02:14:09 +0000
@@ -25,6 +25,7 @@
 	envtools "launchpad.net/juju-core/environs/tools"
 	"launchpad.net/juju-core/errors"
 	"launchpad.net/juju-core/provider/dummy"
+	"launchpad.net/juju-core/testing"
 	jc "launchpad.net/juju-core/testing/checkers"
 	"launchpad.net/juju-core/testing/testbase"
 	coretools "launchpad.net/juju-core/tools"
@@ -171,7 +172,7 @@
 	dummy.Reset()
 	cfg, err := config.New(config.NoDefaults, dummy.SampleConfig().Merge(attrs))
 	c.Assert(err, gc.IsNil)
-	env, err := environs.Prepare(cfg, configstore.NewMem())
+	env, err := environs.Prepare(cfg, testing.Context(c), configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 	s.env = env
 	s.removeTools(c)

=== modified file 'environs/tools/urls_test.go'
--- environs/tools/urls_test.go	2014-01-31 00:14:11 +0000
+++ environs/tools/urls_test.go	2014-02-18 02:14:09 +0000
@@ -43,7 +43,7 @@
 	}
 	cfg, err := config.New(config.NoDefaults, attrs)
 	c.Assert(err, gc.IsNil)
-	env, err := environs.Prepare(cfg, configstore.NewMem())
+	env, err := environs.Prepare(cfg, testing.Context(c), configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 	return env
 }

=== modified file 'juju/apiconn_test.go'
--- juju/apiconn_test.go	2014-01-22 22:48:54 +0000
+++ juju/apiconn_test.go	2014-02-18 02:14:09 +0000
@@ -46,11 +46,12 @@
 func (*NewAPIConnSuite) TestNewConn(c *gc.C) {
 	cfg, err := config.New(config.NoDefaults, dummy.SampleConfig())
 	c.Assert(err, gc.IsNil)
-	env, err := environs.Prepare(cfg, configstore.NewMem())
+	ctx := coretesting.Context(c)
+	env, err := environs.Prepare(cfg, ctx, configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 
 	envtesting.UploadFakeTools(c, env.Storage())
-	err = bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err = bootstrap.Bootstrap(ctx, env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 
 	cfg = env.Config()

=== modified file 'juju/conn_test.go'
--- juju/conn_test.go	2014-01-30 13:50:27 +0000
+++ juju/conn_test.go	2014-02-18 02:14:09 +0000
@@ -62,17 +62,14 @@
 	c.Assert(err, gc.IsNil)
 }
 
-func bootstrapContext(c *gc.C) environs.BootstrapContext {
-	return envtesting.NewBootstrapContext(coretesting.Context(c))
-}
-
 func (*NewConnSuite) TestNewConnWithoutAdminSecret(c *gc.C) {
 	cfg, err := config.New(config.NoDefaults, dummy.SampleConfig())
 	c.Assert(err, gc.IsNil)
-	env, err := environs.Prepare(cfg, configstore.NewMem())
+	ctx := coretesting.Context(c)
+	env, err := environs.Prepare(cfg, ctx, configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 	envtesting.UploadFakeTools(c, env.Storage())
-	err = bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err = bootstrap.Bootstrap(ctx, env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 
 	attrs := env.Config().AllAttrs()
@@ -88,10 +85,11 @@
 	if store == nil {
 		store = configstore.NewMem()
 	}
-	env, err := environs.PrepareFromName(envName, store)
+	ctx := coretesting.Context(c)
+	env, err := environs.PrepareFromName(envName, ctx, store)
 	c.Assert(err, gc.IsNil)
 	envtesting.UploadFakeTools(c, env.Storage())
-	err = bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err = bootstrap.Bootstrap(ctx, env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 }
 
@@ -133,10 +131,11 @@
 	})
 	cfg, err := config.New(config.NoDefaults, attrs)
 	c.Assert(err, gc.IsNil)
-	env, err := environs.Prepare(cfg, configstore.NewMem())
+	ctx := coretesting.Context(c)
+	env, err := environs.Prepare(cfg, ctx, configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 	envtesting.UploadFakeTools(c, env.Storage())
-	err = bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err = bootstrap.Bootstrap(ctx, env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 	info, _, err := env.StateInfo()
 	c.Assert(err, gc.IsNil)
@@ -182,10 +181,11 @@
 	})
 	cfg, err := config.New(config.NoDefaults, attrs)
 	c.Assert(err, gc.IsNil)
-	env, err := environs.Prepare(cfg, configstore.NewMem())
+	ctx := coretesting.Context(c)
+	env, err := environs.Prepare(cfg, ctx, configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 	envtesting.UploadFakeTools(c, env.Storage())
-	err = bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err = bootstrap.Bootstrap(ctx, env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 
 	// Make a new Conn, which will push the secrets.
@@ -218,10 +218,11 @@
 	})
 	cfg, err := config.New(config.NoDefaults, attrs)
 	c.Assert(err, gc.IsNil)
-	env, err := environs.Prepare(cfg, configstore.NewMem())
+	ctx := coretesting.Context(c)
+	env, err := environs.Prepare(cfg, ctx, configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 	envtesting.UploadFakeTools(c, env.Storage())
-	err = bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err = bootstrap.Bootstrap(ctx, env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 
 	// Check that Bootstrap has correctly used a hash
@@ -272,10 +273,11 @@
 	s.ToolsFixture.SetUpTest(c)
 	cfg, err := config.New(config.NoDefaults, dummy.SampleConfig())
 	c.Assert(err, gc.IsNil)
-	environ, err := environs.Prepare(cfg, configstore.NewMem())
+	ctx := coretesting.Context(c)
+	environ, err := environs.Prepare(cfg, ctx, configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 	envtesting.UploadFakeTools(c, environ.Storage())
-	err = bootstrap.Bootstrap(bootstrapContext(c), environ, constraints.Value{})
+	err = bootstrap.Bootstrap(ctx, environ, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 	s.conn, err = juju.NewConn(environ)
 	c.Assert(err, gc.IsNil)

=== modified file 'juju/testing/conn.go'
--- juju/testing/conn.go	2014-02-13 00:54:09 +0000
+++ juju/testing/conn.go	2014-02-18 02:14:09 +0000
@@ -196,13 +196,13 @@
 	c.Assert(err, gc.IsNil)
 	s.ConfigStore = store
 
-	environ, err := environs.PrepareFromName("dummyenv", s.ConfigStore)
+	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.Name(), gc.Equals, "dummyenv")
 
 	envtesting.MustUploadFakeTools(environ.Storage())
-	ctx := envtesting.NewBootstrapContext(testing.Context(c))
 	c.Assert(bootstrap.Bootstrap(ctx, environ, constraints.Value{}), gc.IsNil)
 
 	s.BackingState = environ.(GetStater).GetStateInAPIServer()

=== modified file 'provider/azure/environprovider.go'
--- provider/azure/environprovider.go	2014-01-28 04:58:43 +0000
+++ provider/azure/environprovider.go	2014-02-18 02:14:09 +0000
@@ -42,7 +42,7 @@
 }
 
 // Prepare is specified in the EnvironProvider interface.
-func (prov azureEnvironProvider) Prepare(cfg *config.Config) (environs.Environ, error) {
+func (prov azureEnvironProvider) Prepare(ctx environs.BootstrapContext, cfg *config.Config) (environs.Environ, error) {
 	// TODO prepare environment as necessary
 	return prov.Open(cfg)
 }

=== modified file 'provider/common/bootstrap.go'
--- provider/common/bootstrap.go	2014-01-30 14:13:54 +0000
+++ provider/common/bootstrap.go	2014-02-18 02:14:09 +0000
@@ -68,12 +68,12 @@
 		return err
 	}
 
-	fmt.Fprintln(ctx.Stderr(), "Launching instance")
+	fmt.Fprintln(ctx.GetStderr(), "Launching instance")
 	inst, hw, err := env.StartInstance(cons, selectedTools, machineConfig)
 	if err != nil {
 		return fmt.Errorf("cannot start bootstrap instance: %v", err)
 	}
-	fmt.Fprintf(ctx.Stderr(), " - %s\n", inst.Id())
+	fmt.Fprintf(ctx.GetStderr(), " - %s\n", inst.Id())
 
 	var characteristics []instance.HardwareCharacteristics
 	if hw != nil {
@@ -144,12 +144,12 @@
 	defer close(ch)
 	go func() {
 		for _ = range ch {
-			fmt.Fprintln(ctx.Stderr(), "Cleaning up failed bootstrap")
+			fmt.Fprintln(ctx.GetStderr(), "Cleaning up failed bootstrap")
 		}
 	}()
 
 	if inst != nil {
-		fmt.Fprintln(ctx.Stderr(), "Stopping instance...")
+		fmt.Fprintln(ctx.GetStderr(), "Stopping instance...")
 		if stoperr := env.StopInstances([]instance.Instance{inst}); stoperr != nil {
 			logger.Errorf("cannot stop failed bootstrap instance %q: %v", inst.Id(), stoperr)
 		} else {
@@ -217,7 +217,7 @@
 		Host:           "ubuntu@" + addr,
 		Client:         client,
 		Config:         cloudcfg,
-		ProgressWriter: ctx.Stderr(),
+		ProgressWriter: ctx.GetStderr(),
 	})
 }
 
@@ -365,14 +365,14 @@
 	checker := parallelHostChecker{
 		Try:             parallel.NewTry(0, nil),
 		client:          client,
-		stderr:          ctx.Stderr(),
+		stderr:          ctx.GetStderr(),
 		active:          make(map[instance.Address]chan struct{}),
 		checkDelay:      timeout.RetryDelay,
 		checkHostScript: checkHostScript,
 	}
 	defer checker.Kill()
 
-	fmt.Fprintln(ctx.Stderr(), "Waiting for address")
+	fmt.Fprintln(ctx.GetStderr(), "Waiting for address")
 	for {
 		select {
 		case <-pollAddresses.C:

=== modified file 'provider/common/bootstrap_test.go'
--- provider/common/bootstrap_test.go	2014-01-30 17:27:26 +0000
+++ provider/common/bootstrap_test.go	2014-02-18 02:14:09 +0000
@@ -4,7 +4,6 @@
 package common_test
 
 import (
-	"bytes"
 	"fmt"
 	"os"
 	"time"
@@ -76,22 +75,13 @@
 	return func() *config.Config { return cfg }
 }
 
-// bootstrapContext creates a BootstrapContext which
-// writes stderr to the bytes.Buffer returned.
-func bootstrapContext(c *gc.C) (ctx environs.BootstrapContext, stderr *bytes.Buffer) {
-	cmdContext := coretesting.Context(c)
-	stderr = &bytes.Buffer{}
-	cmdContext.Stderr = stderr
-	return envtesting.NewBootstrapContext(cmdContext), stderr
-}
-
 func (s *BootstrapSuite) TestCannotWriteStateFile(c *gc.C) {
 	brokenStorage := &mockStorage{
 		Storage: newStorage(s, c),
 		putErr:  fmt.Errorf("noes!"),
 	}
 	env := &mockEnviron{storage: brokenStorage}
-	ctx, _ := bootstrapContext(c)
+	ctx := coretesting.Context(c)
 	err := common.Bootstrap(ctx, env, constraints.Value{})
 	c.Assert(err, gc.ErrorMatches, "cannot create initial state file: noes!")
 }
@@ -118,7 +108,7 @@
 		config:        configGetter(c),
 	}
 
-	ctx, _ := bootstrapContext(c)
+	ctx := coretesting.Context(c)
 	err = common.Bootstrap(ctx, env, checkCons)
 	c.Assert(err, gc.ErrorMatches, "cannot start bootstrap instance: meh, not started")
 }
@@ -149,7 +139,7 @@
 		config:        configGetter(c),
 	}
 
-	ctx, _ := bootstrapContext(c)
+	ctx := coretesting.Context(c)
 	err := common.Bootstrap(ctx, env, constraints.Value{})
 	c.Assert(err, gc.ErrorMatches, "cannot save state: suddenly a wild blah")
 	c.Assert(stopped, gc.HasLen, 1)
@@ -186,7 +176,7 @@
 		config:        configGetter(c),
 	}
 
-	ctx, _ := bootstrapContext(c)
+	ctx := coretesting.Context(c)
 	err := common.Bootstrap(ctx, env, constraints.Value{})
 	c.Assert(err, gc.ErrorMatches, "cannot save state: suddenly a wild blah")
 	c.Assert(stopped, gc.HasLen, 1)
@@ -231,7 +221,7 @@
 		setConfig:     setConfig,
 	}
 	originalAuthKeys := env.Config().AuthorizedKeys()
-	ctx, _ := bootstrapContext(c)
+	ctx := coretesting.Context(c)
 	err := common.Bootstrap(ctx, env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 
@@ -268,14 +258,14 @@
 }
 
 func (s *BootstrapSuite) TestWaitSSHTimesOutWaitingForAddresses(c *gc.C) {
-	ctx, stderr := bootstrapContext(c)
+	ctx := coretesting.Context(c)
 	_, err := common.WaitSSH(ctx, nil, ssh.DefaultClient, "/bin/true", neverAddresses{}, testSSHTimeout)
 	c.Check(err, gc.ErrorMatches, `waited for `+testSSHTimeout.Timeout.String()+` without getting any addresses`)
-	c.Check(stderr.String(), gc.Matches, "Waiting for address\n")
+	c.Check(coretesting.Stderr(ctx), gc.Matches, "Waiting for address\n")
 }
 
 func (s *BootstrapSuite) TestWaitSSHKilledWaitingForAddresses(c *gc.C) {
-	ctx, stderr := bootstrapContext(c)
+	ctx := coretesting.Context(c)
 	interrupted := make(chan os.Signal, 1)
 	go func() {
 		<-time.After(2 * time.Millisecond)
@@ -283,7 +273,7 @@
 	}()
 	_, err := common.WaitSSH(ctx, interrupted, ssh.DefaultClient, "/bin/true", neverAddresses{}, testSSHTimeout)
 	c.Check(err, gc.ErrorMatches, "interrupted")
-	c.Check(stderr.String(), gc.Matches, "Waiting for address\n")
+	c.Check(coretesting.Stderr(ctx), gc.Matches, "Waiting for address\n")
 }
 
 type brokenAddresses struct {
@@ -295,10 +285,10 @@
 }
 
 func (s *BootstrapSuite) TestWaitSSHStopsOnBadError(c *gc.C) {
-	ctx, stderr := bootstrapContext(c)
+	ctx := coretesting.Context(c)
 	_, err := common.WaitSSH(ctx, nil, ssh.DefaultClient, "/bin/true", brokenAddresses{}, testSSHTimeout)
 	c.Check(err, gc.ErrorMatches, "getting addresses: Addresses will never work")
-	c.Check(stderr.String(), gc.Equals, "Waiting for address\n")
+	c.Check(coretesting.Stderr(ctx), gc.Equals, "Waiting for address\n")
 }
 
 type neverOpensPort struct {
@@ -311,12 +301,12 @@
 }
 
 func (s *BootstrapSuite) TestWaitSSHTimesOutWaitingForDial(c *gc.C) {
-	ctx, stderr := bootstrapContext(c)
+	ctx := coretesting.Context(c)
 	// 0.x.y.z addresses are always invalid
 	_, err := common.WaitSSH(ctx, nil, ssh.DefaultClient, "/bin/true", &neverOpensPort{addr: "0.1.2.3"}, testSSHTimeout)
 	c.Check(err, gc.ErrorMatches,
 		`waited for `+testSSHTimeout.Timeout.String()+` without being able to connect: mock connection failure to 0.1.2.3`)
-	c.Check(stderr.String(), gc.Matches,
+	c.Check(coretesting.Stderr(ctx), gc.Matches,
 		"Waiting for address\n"+
 			"(Attempting to connect to 0.1.2.3:22\n)+")
 }
@@ -339,14 +329,14 @@
 }
 
 func (s *BootstrapSuite) TestWaitSSHKilledWaitingForDial(c *gc.C) {
-	ctx, stderr := bootstrapContext(c)
+	ctx := coretesting.Context(c)
 	timeout := testSSHTimeout
 	timeout.Timeout = 1 * time.Minute
 	interrupted := make(chan os.Signal, 1)
 	_, err := common.WaitSSH(ctx, interrupted, ssh.DefaultClient, "", &interruptOnDial{name: "0.1.2.3", interrupted: interrupted}, timeout)
 	c.Check(err, gc.ErrorMatches, "interrupted")
 	// Exact timing is imprecise but it should have tried a few times before being killed
-	c.Check(stderr.String(), gc.Matches,
+	c.Check(coretesting.Stderr(ctx), gc.Matches,
 		"Waiting for address\n"+
 			"(Attempting to connect to 0.1.2.3:22\n)+")
 }
@@ -371,7 +361,7 @@
 }
 
 func (s *BootstrapSuite) TestWaitSSHRefreshAddresses(c *gc.C) {
-	ctx, stderr := bootstrapContext(c)
+	ctx := coretesting.Context(c)
 	_, err := common.WaitSSH(ctx, nil, ssh.DefaultClient, "", &addressesChange{addrs: [][]string{
 		nil,
 		nil,
@@ -383,10 +373,11 @@
 	// Not necessarily the last one in the list, due to scheduling.
 	c.Check(err, gc.ErrorMatches,
 		`waited for `+testSSHTimeout.Timeout.String()+` without being able to connect: mock connection failure to 0.1.2.[34]`)
-	c.Check(stderr.String(), gc.Matches,
+	stderr := coretesting.Stderr(ctx)
+	c.Check(stderr, gc.Matches,
 		"Waiting for address\n"+
 			"(.|\n)*(Attempting to connect to 0.1.2.3:22\n)+(.|\n)*")
-	c.Check(stderr.String(), gc.Matches,
+	c.Check(stderr, gc.Matches,
 		"Waiting for address\n"+
 			"(.|\n)*(Attempting to connect to 0.1.2.4:22\n)+(.|\n)*")
 }

=== modified file 'provider/dummy/config_test.go'
--- provider/dummy/config_test.go	2013-10-01 16:46:31 +0000
+++ provider/dummy/config_test.go	2014-02-18 02:14:09 +0000
@@ -29,7 +29,8 @@
 	attrs := dummy.SampleConfig().Delete("secret")
 	cfg, err := config.New(config.NoDefaults, attrs)
 	c.Assert(err, gc.IsNil)
-	env, err := environs.Prepare(cfg, configstore.NewMem())
+	ctx := testing.Context(c)
+	env, err := environs.Prepare(cfg, ctx, configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 	defer env.Destroy()
 	expected := map[string]string{
@@ -81,7 +82,8 @@
 			c.Assert(err, gc.ErrorMatches, test.errorMsg)
 			continue
 		}
-		env, err := environs.Prepare(cfg, configstore.NewMem())
+		ctx := testing.Context(c)
+		env, err := environs.Prepare(cfg, ctx, configstore.NewMem())
 		if test.errorMsg != "" {
 			c.Assert(err, gc.ErrorMatches, test.errorMsg)
 			continue

=== modified file 'provider/dummy/environs.go'
--- provider/dummy/environs.go	2014-02-03 06:58:26 +0000
+++ provider/dummy/environs.go	2014-02-18 02:14:09 +0000
@@ -422,7 +422,7 @@
 	return env, nil
 }
 
-func (p *environProvider) Prepare(cfg *config.Config) (environs.Environ, error) {
+func (p *environProvider) Prepare(ctx environs.BootstrapContext, cfg *config.Config) (environs.Environ, error) {
 	cfg, err := p.prepare(cfg)
 	if err != nil {
 		return nil, err

=== modified file 'provider/ec2/config_test.go'
--- provider/ec2/config_test.go	2013-10-24 00:20:59 +0000
+++ provider/ec2/config_test.go	2014-02-18 02:14:09 +0000
@@ -294,12 +294,13 @@
 	cfg, err := config.New(config.NoDefaults, attrs)
 	c.Assert(err, gc.IsNil)
 
-	env0, err := providerInstance.Prepare(cfg)
+	ctx := testing.Context(c)
+	env0, err := providerInstance.Prepare(ctx, cfg)
 	c.Assert(err, gc.IsNil)
 	bucket0 := env0.(*environ).ecfg().controlBucket()
 	c.Assert(bucket0, gc.Matches, "[a-f0-9]{32}")
 
-	env1, err := providerInstance.Prepare(cfg)
+	env1, err := providerInstance.Prepare(ctx, cfg)
 	c.Assert(err, gc.IsNil)
 	bucket1 := env1.(*environ).ecfg().controlBucket()
 	c.Assert(bucket1, gc.Matches, "[a-f0-9]{32}")
@@ -315,7 +316,7 @@
 	cfg, err := config.New(config.NoDefaults, attrs)
 	c.Assert(err, gc.IsNil)
 
-	env, err := providerInstance.Prepare(cfg)
+	env, err := providerInstance.Prepare(testing.Context(c), cfg)
 	c.Assert(err, gc.IsNil)
 	bucket := env.(*environ).ecfg().controlBucket()
 	c.Assert(bucket, gc.Equals, "burblefoo")

=== modified file 'provider/ec2/ec2.go'
--- provider/ec2/ec2.go	2014-01-29 09:58:08 +0000
+++ provider/ec2/ec2.go	2014-02-18 02:14:09 +0000
@@ -207,7 +207,7 @@
 	return e, nil
 }
 
-func (p environProvider) Prepare(cfg *config.Config) (environs.Environ, error) {
+func (p environProvider) Prepare(ctx environs.BootstrapContext, cfg *config.Config) (environs.Environ, error) {
 	attrs := cfg.UnknownAttrs()
 	if _, ok := attrs["control-bucket"]; !ok {
 		uuid, err := utils.NewUUID()

=== modified file 'provider/ec2/local_test.go'
--- provider/ec2/local_test.go	2014-01-29 06:45:16 +0000
+++ provider/ec2/local_test.go	2014-02-18 02:14:09 +0000
@@ -74,7 +74,7 @@
 	}
 	cfg, err := config.New(config.NoDefaults, envAttrs)
 	c.Assert(err, gc.IsNil)
-	env, err := environs.Prepare(cfg, configstore.NewMem())
+	env, err := environs.Prepare(cfg, coretesting.Context(c), configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 	c.Assert(env, gc.NotNil)
 
@@ -229,10 +229,6 @@
 	t.srv.stopServer(c)
 }
 
-func bootstrapContext(c *gc.C) environs.BootstrapContext {
-	return envtesting.NewBootstrapContext(coretesting.Context(c))
-}
-
 func (t *localServerSuite) TestPrecheck(c *gc.C) {
 	env := t.Prepare(c)
 	prechecker, ok := env.(environs.Prechecker)
@@ -247,7 +243,7 @@
 func (t *localServerSuite) TestBootstrapInstanceUserDataAndState(c *gc.C) {
 	env := t.Prepare(c)
 	envtesting.UploadFakeTools(c, env.Storage())
-	err := bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err := bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 
 	// check that the state holds the id of the bootstrap machine.
@@ -334,7 +330,7 @@
 func (t *localServerSuite) TestInstanceStatus(c *gc.C) {
 	env := t.Prepare(c)
 	envtesting.UploadFakeTools(c, env.Storage())
-	err := bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err := bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 	t.srv.ec2srv.SetInitialInstanceState(ec2test.Terminated)
 	inst, _ := testing.AssertStartInstance(c, env, "1")
@@ -345,7 +341,7 @@
 func (t *localServerSuite) TestStartInstanceHardwareCharacteristics(c *gc.C) {
 	env := t.Prepare(c)
 	envtesting.UploadFakeTools(c, env.Storage())
-	err := bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err := bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 	_, hc := testing.AssertStartInstance(c, env, "1")
 	c.Check(*hc.Arch, gc.Equals, "amd64")
@@ -357,7 +353,7 @@
 func (t *localServerSuite) TestAddresses(c *gc.C) {
 	env := t.Prepare(c)
 	envtesting.UploadFakeTools(c, env.Storage())
-	err := bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err := bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 	inst, _ := testing.AssertStartInstance(c, env, "1")
 	c.Assert(err, gc.IsNil)
@@ -442,7 +438,7 @@
 
 	cfg, err := config.New(config.NoDefaults, localConfigAttrs)
 	c.Assert(err, gc.IsNil)
-	env, err := environs.Prepare(cfg, configstore.NewMem())
+	env, err := environs.Prepare(cfg, coretesting.Context(c), configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 	t.env = env
 }

=== modified file 'provider/joyent/config_test.go'
--- provider/joyent/config_test.go	2013-11-21 17:53:05 +0000
+++ provider/joyent/config_test.go	2014-02-18 02:14:09 +0000
@@ -286,7 +286,7 @@
 		c.Logf("test %d: %s", i, test.info)
 		attrs := validAttrs().Merge(test.insert).Delete(test.remove...)
 		testConfig := newConfig(c, attrs)
-		preparedConfig, err := joyent.Provider.Prepare(testConfig)
+		preparedConfig, err := joyent.Provider.Prepare(testing.Context(c), testConfig)
 		if test.err == "" {
 			c.Assert(err, gc.IsNil)
 			attrs := preparedConfig.Config().AllAttrs()

=== modified file 'provider/joyent/provider.go'
--- provider/joyent/provider.go	2014-01-28 04:58:43 +0000
+++ provider/joyent/provider.go	2014-02-18 02:14:09 +0000
@@ -30,7 +30,7 @@
 
 var errNotImplemented = errors.New("not implemented in Joyent provider")
 
-func (environProvider) Prepare(cfg *config.Config) (environs.Environ, error) {
+func (environProvider) Prepare(ctx environs.BootstrapContext, cfg *config.Config) (environs.Environ, error) {
 	// This method may be called with an incomplete cfg. It should make every
 	// reasonable effort to create a valid configuration based on the supplied,
 	// and open the resulting environment.

=== modified file 'provider/local/config_test.go'
--- provider/local/config_test.go	2014-01-31 08:44:08 +0000
+++ provider/local/config_test.go	2014-02-18 02:14:09 +0000
@@ -10,7 +10,6 @@
 
 	"launchpad.net/juju-core/constraints"
 	"launchpad.net/juju-core/environs/config"
-	envtesting "launchpad.net/juju-core/environs/testing"
 	"launchpad.net/juju-core/juju/osenv"
 	"launchpad.net/juju-core/provider"
 	"launchpad.net/juju-core/provider/local"
@@ -109,8 +108,8 @@
 func (s *configSuite) TestBootstrapAsRoot(c *gc.C) {
 	restore := local.SetRootCheckFunction(func() bool { return true })
 	defer restore()
-	env, err := local.Provider.Prepare(minimalConfig(c))
+	env, err := local.Provider.Prepare(testing.Context(c), minimalConfig(c))
 	c.Assert(err, gc.IsNil)
-	err = env.Bootstrap(envtesting.NewBootstrapContext(testing.Context(c)), constraints.Value{})
+	err = env.Bootstrap(testing.Context(c), constraints.Value{})
 	c.Assert(err, gc.ErrorMatches, "bootstrapping a local environment must not be done as root")
 }

=== modified file 'provider/local/environ.go'
--- provider/local/environ.go	2014-02-14 03:11:25 +0000
+++ provider/local/environ.go	2014-02-18 02:14:09 +0000
@@ -195,8 +195,8 @@
 	}
 	cmd := exec.Command("sudo", "/bin/bash", "-s")
 	cmd.Stdin = strings.NewReader(script)
-	cmd.Stdout = ctx.Stdout()
-	cmd.Stderr = ctx.Stderr()
+	cmd.Stdout = ctx.GetStdout()
+	cmd.Stderr = ctx.GetStderr()
 	return cmd.Run()
 }
 

=== modified file 'provider/local/environ_test.go'
--- provider/local/environ_test.go	2014-02-12 02:56:13 +0000
+++ provider/local/environ_test.go	2014-02-18 02:14:09 +0000
@@ -161,11 +161,11 @@
 		return nil
 	})
 	testConfig := minimalConfig(c)
-	environ, err := local.Provider.Prepare(testConfig)
+	ctx := coretesting.Context(c)
+	environ, err := local.Provider.Prepare(ctx, testConfig)
 	c.Assert(err, gc.IsNil)
 	envtesting.UploadFakeTools(c, environ.Storage())
 	defer environ.Storage().RemoveAll()
-	ctx := envtesting.NewBootstrapContext(coretesting.Context(c))
 	err = environ.Bootstrap(ctx, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 }

=== modified file 'provider/local/environprovider.go'
--- provider/local/environprovider.go	2014-02-14 04:26:21 +0000
+++ provider/local/environprovider.go	2014-02-18 02:14:09 +0000
@@ -86,7 +86,7 @@
 var detectAptProxies = utils.DetectAptProxies
 
 // Prepare implements environs.EnvironProvider.Prepare.
-func (p environProvider) Prepare(cfg *config.Config) (environs.Environ, error) {
+func (p environProvider) Prepare(ctx environs.BootstrapContext, cfg *config.Config) (environs.Environ, error) {
 	// The user must not set bootstrap-ip; this is determined by the provider,
 	// and its presence used to determine whether the environment has yet been
 	// bootstrapped.

=== modified file 'provider/local/environprovider_test.go'
--- provider/local/environprovider_test.go	2014-02-14 03:41:57 +0000
+++ provider/local/environprovider_test.go	2014-02-18 02:14:09 +0000
@@ -215,7 +215,7 @@
 			testConfig, err = baseConfig.Apply(test.extraConfig)
 			c.Assert(err, gc.IsNil)
 		}
-		env, err := provider.Prepare(testConfig)
+		env, err := provider.Prepare(testing.Context(c), testConfig)
 		c.Assert(err, gc.IsNil)
 
 		envConfig := env.Config()
@@ -269,7 +269,7 @@
 		s.PatchValue(local.UserCurrent, func() (*user.User, error) {
 			return &user.User{Username: test.userOS}, test.userOSErr
 		})
-		env, err := provider.Prepare(basecfg)
+		env, err := provider.Prepare(testing.Context(c), basecfg)
 		if test.err == "" {
 			c.Assert(err, gc.IsNil)
 			cfg := env.Config()

=== modified file 'provider/maas/environ_whitebox_test.go'
--- provider/maas/environ_whitebox_test.go	2014-01-29 06:45:16 +0000
+++ provider/maas/environ_whitebox_test.go	2014-02-18 02:14:09 +0000
@@ -149,16 +149,12 @@
 	return utils.Gunzip(data)
 }
 
-func bootstrapContext(c *gc.C) environs.BootstrapContext {
-	return envtesting.NewBootstrapContext(coretesting.Context(c))
-}
-
 func (suite *environSuite) TestStartInstanceStartsInstance(c *gc.C) {
 	suite.setupFakeTools(c)
 	env := suite.makeEnviron()
 	// Create node 0: it will be used as the bootstrap node.
 	suite.testMAASObject.TestServer.NewNode(`{"system_id": "node0", "hostname": "host0"}`)
-	err := bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err := bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 	// The bootstrap node has been acquired and started.
 	operations := suite.testMAASObject.TestServer.NodeOperations()
@@ -372,7 +368,7 @@
 	suite.setupFakeTools(c)
 	env := suite.makeEnviron()
 	suite.testMAASObject.TestServer.NewNode(`{"system_id": "thenode", "hostname": "host"}`)
-	err := bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err := bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 }
 
@@ -388,14 +384,14 @@
 	c.Assert(err, gc.IsNil)
 	err = env.SetConfig(cfg)
 	c.Assert(err, gc.IsNil)
-	err = bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err = bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
 	c.Check(err, gc.ErrorMatches, "cannot find bootstrap tools.*")
 }
 
 func (suite *environSuite) TestBootstrapFailsIfNoNodes(c *gc.C) {
 	suite.setupFakeTools(c)
 	env := suite.makeEnviron()
-	err := bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err := bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
 	// Since there are no nodes, the attempt to allocate one returns a
 	// 409: Conflict.
 	c.Check(err, gc.ErrorMatches, ".*409.*")
@@ -407,7 +403,7 @@
 	suite.testMAASObject.TestServer.NewNode(`{"system_id": "bootstrapnode", "hostname": "host"}`)
 
 	// bootstrap.Bootstrap calls Environ.Bootstrap.  This works.
-	err := bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err := bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 }
 

=== modified file 'provider/maas/environprovider.go'
--- provider/maas/environprovider.go	2014-01-28 04:58:43 +0000
+++ provider/maas/environprovider.go	2014-02-18 02:14:09 +0000
@@ -41,7 +41,7 @@
 var errAgentNameAlreadySet = errors.New(
 	"maas-agent-name is already set; this should not be set by hand")
 
-func (p maasEnvironProvider) Prepare(cfg *config.Config) (environs.Environ, error) {
+func (p maasEnvironProvider) Prepare(ctx environs.BootstrapContext, cfg *config.Config) (environs.Environ, error) {
 	attrs := cfg.UnknownAttrs()
 	oldName, found := attrs["maas-agent-name"]
 	if found && oldName != "" {

=== modified file 'provider/maas/environprovider_test.go'
--- provider/maas/environprovider_test.go	2014-01-22 22:48:54 +0000
+++ provider/maas/environprovider_test.go	2014-02-18 02:14:09 +0000
@@ -52,7 +52,8 @@
 	config, err := config.New(config.NoDefaults, attrs)
 	c.Assert(err, gc.IsNil)
 
-	environ, err := suite.makeEnviron().Provider().Prepare(config)
+	ctx := testing.Context(c)
+	environ, err := suite.makeEnviron().Provider().Prepare(ctx, config)
 	c.Assert(err, gc.IsNil)
 
 	preparedConfig := environ.Config()
@@ -76,7 +77,8 @@
 	config, err := config.New(config.NoDefaults, attrs)
 	c.Assert(err, gc.IsNil)
 
-	_, err = suite.makeEnviron().Provider().Prepare(config)
+	ctx := testing.Context(c)
+	_, err = suite.makeEnviron().Provider().Prepare(ctx, config)
 	c.Assert(err, gc.Equals, errAgentNameAlreadySet)
 }
 

=== modified file 'provider/manual/environ.go'
--- provider/manual/environ.go	2014-02-10 11:35:13 +0000
+++ provider/manual/environ.go	2014-02-18 02:14:09 +0000
@@ -100,7 +100,7 @@
 		return nil
 	}
 	cfg := e.envConfig()
-	err := initUbuntuUser(cfg.bootstrapHost(), cfg.bootstrapUser(), cfg.AuthorizedKeys(), ctx.Stdin(), ctx.Stdout())
+	err := initUbuntuUser(cfg.bootstrapHost(), cfg.bootstrapUser(), cfg.AuthorizedKeys(), ctx.GetStdin(), ctx.GetStdout())
 	if err != nil {
 		logger.Errorf("initializing ubuntu user: %v", err)
 		return err

=== modified file 'provider/manual/environ_test.go'
--- provider/manual/environ_test.go	2014-02-10 07:27:49 +0000
+++ provider/manual/environ_test.go	2014-02-18 02:14:09 +0000
@@ -13,7 +13,6 @@
 	"launchpad.net/juju-core/environs"
 	"launchpad.net/juju-core/environs/manual"
 	"launchpad.net/juju-core/environs/storage"
-	envtesting "launchpad.net/juju-core/environs/testing"
 	"launchpad.net/juju-core/environs/tools"
 	"launchpad.net/juju-core/instance"
 	coretesting "launchpad.net/juju-core/testing"
@@ -139,7 +138,7 @@
 		return initUbuntuResult
 	})
 
-	ctx := envtesting.NewBootstrapContext(coretesting.Context(c))
+	ctx := coretesting.Context(c)
 	initUbuntuResult = errors.New("failed to initialise ubuntu user")
 	c.Assert(s.env.EnableBootstrapStorage(ctx), gc.Equals, initUbuntuResult)
 	initUbuntuResult = nil

=== modified file 'provider/manual/provider.go'
--- provider/manual/provider.go	2014-02-10 12:32:35 +0000
+++ provider/manual/provider.go	2014-02-18 02:14:09 +0000
@@ -21,7 +21,7 @@
 
 var errNoBootstrapHost = errors.New("bootstrap-host must be specified")
 
-func (p manualProvider) Prepare(cfg *config.Config) (environs.Environ, error) {
+func (p manualProvider) Prepare(ctx environs.BootstrapContext, cfg *config.Config) (environs.Environ, error) {
 	if _, ok := cfg.UnknownAttrs()["storage-auth-key"]; !ok {
 		uuid, err := utils.NewUUID()
 		if err != nil {

=== modified file 'provider/manual/provider_test.go'
--- provider/manual/provider_test.go	2014-02-10 12:32:35 +0000
+++ provider/manual/provider_test.go	2014-02-18 02:14:09 +0000
@@ -12,6 +12,7 @@
 	"launchpad.net/juju-core/environs/config"
 	"launchpad.net/juju-core/environs/storage"
 	"launchpad.net/juju-core/provider/manual"
+	coretesting "launchpad.net/juju-core/testing"
 	jc "launchpad.net/juju-core/testing/checkers"
 	"launchpad.net/juju-core/testing/testbase"
 	"launchpad.net/juju-core/utils"
@@ -29,7 +30,7 @@
 	delete(minimal, "storage-auth-key")
 	testConfig, err := config.New(config.UseDefaults, minimal)
 	c.Assert(err, gc.IsNil)
-	env, err := manual.ProviderInstance.Prepare(testConfig)
+	env, err := manual.ProviderInstance.Prepare(coretesting.Context(c), testConfig)
 	c.Assert(err, gc.IsNil)
 	cfg := env.Config()
 	key, _ := cfg.UnknownAttrs()["storage-auth-key"].(string)
@@ -41,7 +42,7 @@
 	minimal["use-sshstorage"] = false
 	testConfig, err := config.New(config.UseDefaults, minimal)
 	c.Assert(err, gc.IsNil)
-	_, err = manual.ProviderInstance.Prepare(testConfig)
+	_, err = manual.ProviderInstance.Prepare(coretesting.Context(c), testConfig)
 	c.Assert(err, gc.ErrorMatches, "use-sshstorage must not be specified")
 
 	s.PatchValue(manual.NewSSHStorage, func(sshHost, storageDir, storageTmpdir string) (storage.Storage, error) {
@@ -50,7 +51,7 @@
 	minimal["use-sshstorage"] = true
 	testConfig, err = config.New(config.UseDefaults, minimal)
 	c.Assert(err, gc.IsNil)
-	_, err = manual.ProviderInstance.Prepare(testConfig)
+	_, err = manual.ProviderInstance.Prepare(coretesting.Context(c), testConfig)
 	c.Assert(err, gc.ErrorMatches, "initialising SSH storage failed: newSSHStorage failed")
 }
 

=== modified file 'provider/openstack/config_test.go'
--- provider/openstack/config_test.go	2014-01-28 04:58:43 +0000
+++ provider/openstack/config_test.go	2014-02-18 02:14:09 +0000
@@ -460,12 +460,13 @@
 	cfg, err := config.New(config.NoDefaults, attrs)
 	c.Assert(err, gc.IsNil)
 
-	env0, err := providerInstance.Prepare(cfg)
+	ctx := testing.Context(c)
+	env0, err := providerInstance.Prepare(ctx, cfg)
 	c.Assert(err, gc.IsNil)
 	bucket0 := env0.(*environ).ecfg().controlBucket()
 	c.Assert(bucket0, gc.Matches, "[a-f0-9]{32}")
 
-	env1, err := providerInstance.Prepare(cfg)
+	env1, err := providerInstance.Prepare(ctx, cfg)
 	c.Assert(err, gc.IsNil)
 	bucket1 := env1.(*environ).ecfg().controlBucket()
 	c.Assert(bucket1, gc.Matches, "[a-f0-9]{32}")
@@ -482,7 +483,7 @@
 	cfg, err := config.New(config.NoDefaults, attrs)
 	c.Assert(err, gc.IsNil)
 
-	env, err := providerInstance.Prepare(cfg)
+	env, err := providerInstance.Prepare(testing.Context(c), cfg)
 	c.Assert(err, gc.IsNil)
 	bucket := env.(*environ).ecfg().controlBucket()
 	c.Assert(bucket, gc.Equals, "burblefoo")

=== modified file 'provider/openstack/live_test.go'
--- provider/openstack/live_test.go	2014-02-17 12:57:06 +0000
+++ provider/openstack/live_test.go	2014-02-18 02:14:09 +0000
@@ -230,7 +230,7 @@
 	c.Assert(env, gc.NotNil)
 	defer env.Destroy()
 	// Bootstrap and start an instance.
-	err = bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err = bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 	inst, _ := jujutesting.AssertStartInstance(c, env, "100")
 	// Check whether the instance has the default security group assigned.

=== modified file 'provider/openstack/local_test.go'
--- provider/openstack/local_test.go	2014-02-14 01:03:03 +0000
+++ provider/openstack/local_test.go	2014-02-18 02:14:09 +0000
@@ -252,10 +252,6 @@
 	s.LoggingSuite.TearDownTest(c)
 }
 
-func bootstrapContext(c *gc.C) environs.BootstrapContext {
-	return envtesting.NewBootstrapContext(coretesting.Context(c))
-}
-
 func (s *localServerSuite) TestPrecheck(c *gc.C) {
 	var cons constraints.Value
 	env := s.Prepare(c)
@@ -285,7 +281,7 @@
 	c.Assert(err, gc.IsNil)
 	env, err := environs.New(cfg)
 	c.Assert(err, gc.IsNil)
-	err = bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err = bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
 	c.Assert(err, gc.ErrorMatches, "(.|\n)*cannot allocate a public IP as needed(.|\n)*")
 }
 
@@ -312,9 +308,9 @@
 		"use-floating-ip": false,
 	}))
 	c.Assert(err, gc.IsNil)
-	env, err := environs.Prepare(cfg, s.ConfigStore)
+	env, err := environs.Prepare(cfg, coretesting.Context(c), s.ConfigStore)
 	c.Assert(err, gc.IsNil)
-	err = bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err = bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 	inst, _ := testing.AssertStartInstance(c, env, "100")
 	err = env.StopInstances([]instance.Instance{inst})
@@ -323,7 +319,7 @@
 
 func (s *localServerSuite) TestStartInstanceHardwareCharacteristics(c *gc.C) {
 	env := s.Prepare(c)
-	err := bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err := bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 	_, hc := testing.AssertStartInstanceWithConstraints(c, env, "100", constraints.MustParse("mem=1024"))
 	c.Check(*hc.Arch, gc.Equals, "amd64")
@@ -522,7 +518,7 @@
 // It should be moved to environs.jujutests.Tests.
 func (s *localServerSuite) TestBootstrapInstanceUserDataAndState(c *gc.C) {
 	env := s.Prepare(c)
-	err := bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err := bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 
 	// check that the state holds the id of the bootstrap machine.
@@ -760,7 +756,7 @@
 	c.Assert(attrs["auth-url"].(string)[:8], gc.Equals, "https://")
 	cfg, err := config.New(config.NoDefaults, attrs)
 	c.Assert(err, gc.IsNil)
-	s.env, err = environs.Prepare(cfg, configstore.NewMem())
+	s.env, err = environs.Prepare(cfg, coretesting.Context(c), configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 	s.attrs = s.env.Config().AllAttrs()
 }
@@ -817,7 +813,7 @@
 	openstack.UseTestImageData(metadataStorage, s.cred)
 	defer openstack.RemoveTestImageData(metadataStorage)
 
-	err = bootstrap.Bootstrap(bootstrapContext(c), s.env, constraints.Value{})
+	err = bootstrap.Bootstrap(coretesting.Context(c), s.env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 }
 
@@ -960,7 +956,7 @@
 
 func (s *localServerSuite) TestAllInstancesIgnoresOtherMachines(c *gc.C) {
 	env := s.Prepare(c)
-	err := bootstrap.Bootstrap(bootstrapContext(c), env, constraints.Value{})
+	err := bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 
 	// Check that we see 1 instance in the environment

=== modified file 'provider/openstack/provider.go'
--- provider/openstack/provider.go	2014-01-29 09:58:08 +0000
+++ provider/openstack/provider.go	2014-02-18 02:14:09 +0000
@@ -180,7 +180,7 @@
 	return e, nil
 }
 
-func (p environProvider) Prepare(cfg *config.Config) (environs.Environ, error) {
+func (p environProvider) Prepare(ctx environs.BootstrapContext, cfg *config.Config) (environs.Environ, error) {
 	attrs := cfg.UnknownAttrs()
 	if _, ok := attrs["control-bucket"]; !ok {
 		uuid, err := utils.NewUUID()

=== modified file 'state/apiserver/common/environwatcher_test.go'
--- state/apiserver/common/environwatcher_test.go	2014-01-21 13:56:50 +0000
+++ state/apiserver/common/environwatcher_test.go	2014-02-18 02:14:09 +0000
@@ -16,6 +16,7 @@
 	"launchpad.net/juju-core/state/api/params"
 	"launchpad.net/juju-core/state/apiserver/common"
 	apiservertesting "launchpad.net/juju-core/state/apiserver/testing"
+	"launchpad.net/juju-core/testing"
 	jc "launchpad.net/juju-core/testing/checkers"
 	"launchpad.net/juju-core/testing/testbase"
 )
@@ -187,7 +188,7 @@
 func testingEnvConfig(c *gc.C) *config.Config {
 	cfg, err := config.New(config.NoDefaults, dummy.SampleConfig())
 	c.Assert(err, gc.IsNil)
-	env, err := environs.Prepare(cfg, configstore.NewMem())
+	env, err := environs.Prepare(cfg, testing.Context(c), configstore.NewMem())
 	c.Assert(err, gc.IsNil)
 	return env.Config()
 }