Merge lp:~axwalk/juju-core/lp1236691-null-provider-default-series-take2 into lp:~go-bot/juju-core/trunk

[Andrew Wilkins]

Providers are responsible for selecting tools

This change makes providers responsible for
selecting bootstrap tools, and ensuring they
are available in storage. The null provider is
updated to select the tools appropriate to the
bootstrap host. Other providers use a default
implementation in environs/bootstrap, which
has been extracted from cmd/juju/bootstrap.go.

One test fails due to a logging change. This is
fixed by https://codereview.appspot.com/14430064/.

Fixes #1236691

https://codereview.appspot.com/14433058/

Providers are responsible for selecting tools

This change makes providers responsible for
selecting bootstrap tools, and ensuring they
are available in storage. The null provider is
updated to select the tools appropriate to the
bootstrap host. Other providers use a default
implementation in environs/bootstrap, which
has been extracted from cmd/juju/bootstrap.go.

One test fails due to a logging change. This is
fixed by https://codereview.appspot.com/14430064/.

Fixes #1236691

https://codereview.appspot.com/14433058/

[Andrew Wilkins (axwalk)]

Reviewers: mp+190032_code.launchpad.net,

Message:
Please take a look.

Description:
provider/null: dynamic default-series

default-series is used to decide which
tools to bootstrap with. This is not
necessarily valid for the null provider,
where the boostrap host's architecture
should instead decide which tools to
locate.

So now we assign default-series dynamically,
by performing detection at Prepare time.
We store the detected series and hardware
characteristics, and use them to avoid
repeating the detection at Bootstrap time.

Fixes #1236691

https://code.launchpad.net/~axwalk/juju-core/lp1236691-null-provider-default-series-take2/+merge/190032

(do not edit description out of merge proposal)

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

Affected files (+346, -76 lines):
   A [revision details]
   M environs/manual/bootstrap.go
   M environs/manual/bootstrap_test.go
   M environs/manual/detection.go
   M environs/manual/detection_test.go
   M environs/manual/fakessh.go
   M environs/manual/provisioner.go
   M environs/manual/provisioner_test.go
   M provider/null/config.go
   M provider/null/config_test.go
   M provider/null/environ.go
   M provider/null/provider.go
   A provider/null/provider_test.go
   A provider/null/suite_test.go

[William Reade (fwereade)]

On 2013/10/09 07:13:51, axw wrote:
> Please take a look.

I don't think this is the right approach, I'm afraid. The possibleTools
arg itself only exists because we couldn't justify refactoring any
further towards sanity given time pressure. Basically all this bootstrap
stuff is inside out... environs should generally know what tools they've
got available anyway, and using default-series to pick the bootstrap
node's is pretty dumb and pointless in the first place.

Ping me tomorrow, we can have a long rambling G+ and see what makes
sense.

https://codereview.appspot.com/14433058/

[Andrew Wilkins (axwalk)]

On 2013/10/09 18:04:30, fwereade wrote:
> On 2013/10/09 07:13:51, axw wrote:
> > Please take a look.

> I don't think this is the right approach, I'm afraid. The
possibleTools arg
> itself only exists because we couldn't justify refactoring any further
towards
> sanity given time pressure. Basically all this bootstrap stuff is
inside out...
> environs should generally know what tools they've got available
anyway, and
> using default-series to pick the bootstrap node's is pretty dumb and
pointless
> in the first place.

Fair enough. I started down the road of adding a "BootstrapSeries"
method to Environ, but started thinking it was a lot of change just for
one provider. But... perhaps this is the right thing to do. Once the
"wire up prechecker" branch is landed we'll have EnvironBase to add
default behaviour to, to keep the ugly down.

> Ping me tomorrow, we can have a long rambling G+ and see what makes
sense.

Sure thing, will be around before the weekly meeting.

https://codereview.appspot.com/14433058/

[Andrew Wilkins (axwalk)]

Please take a look.

https://codereview.appspot.com/14433058/

[William Reade (fwereade)]

Sorry this has taken so long. I'm a bit uncomfortable about the sheer
amount of stuff we do, and feel like there's something more complex than
it needs to be... can we chat about this? Maybe your tomorrow morning?

https://codereview.appspot.com/14433058/diff/5001/environs/bootstrap/bootstrap.go
File environs/bootstrap/bootstrap.go (right):

https://codereview.appspot.com/14433058/diff/5001/environs/bootstrap/bootstrap.go#newcode17
environs/bootstrap/bootstrap.go:17: var logger =
loggo.GetLogger("juju.environs.bootstrap")
Ha. Thanks.

https://codereview.appspot.com/14433058/diff/5001/environs/bootstrap/bootstrap.go#newcode56
environs/bootstrap/bootstrap.go:56: newVersion, toolsList =
toolsList.Newest()
I'm not 100% sure this is right, but that's because it's not clear where
the tools list comes from and what its properties are. Any reason we
can't get it inside here?

Dimiter's just landing a List.NewestCompatible method, that might be
useful?

https://codereview.appspot.com/14433058/diff/5001/environs/bootstrap/synctools.go
File environs/bootstrap/synctools.go (right):

https://codereview.appspot.com/14433058/diff/5001/environs/bootstrap/synctools.go#newcode42
environs/bootstrap/synctools.go:42: logger.Warningf("no tools found, so
attempting to build and upload new tools")
Does this work with released versions of the local provider? That needs
to upload tools, and would ideally do so *without* the
juju.BootstrapComand level hack.

https://codereview.appspot.com/14433058/diff/5001/environs/bootstrap/synctools.go#newcode117
environs/bootstrap/synctools.go:117: // TODO(axw) have syncOrUpload
return the list of tools in the target, and use that.
There's something still a bit off here, in that the copy-from-local
behaviour of upload is conceptually a sync, but ESCOPE.

https://codereview.appspot.com/14433058/diff/5001/environs/manual/bootstrap.go
File environs/manual/bootstrap.go (right):

https://codereview.appspot.com/14433058/diff/5001/environs/manual/bootstrap.go#newcode39
environs/manual/bootstrap.go:39: HardwareCharacteristics
*instance.HardwareCharacteristics
I'll probably see it in a minute -- but when can they be known ahead of
time ina manual bootstrap?

https://codereview.appspot.com/14433058/diff/5001/provider/local/environ.go
File provider/local/environ.go (right):

https://codereview.appspot.com/14433058/diff/5001/provider/local/environ.go#newcode136
provider/local/environ.go:136: }
This seems to be repeated a lot. Can we pull it out into a common func?

https://codereview.appspot.com/14433058/diff/5001/provider/maas/environ_test.go
File provider/maas/environ_test.go (right):

https://codereview.appspot.com/14433058/diff/5001/provider/maas/environ_test.go#newcode448
provider/maas/environ_test.go:448: "agent-version":
version.Current.Number.String(),
That's what it should always choose anyway.

https://codereview.appspot.com/14433058/diff/5001/provider/null/config_test.go
File provider/null/config_test.go (left):

https://codereview.appspot.com/14433058/diff/5001/provider/null/config_test.go#oldcode26
provider/null/config_test.go:26: gc.TestingT(t)
heh, were we double-running these?

https://codereview.appspot.com/14433058/diff/5001...

[Andrew Wilkins (axwalk)]

Please take a look.

https://codereview.appspot.com/14433058/diff/5001/environs/bootstrap/bootstrap.go
File environs/bootstrap/bootstrap.go (right):

https://codereview.appspot.com/14433058/diff/5001/environs/bootstrap/bootstrap.go#newcode56
environs/bootstrap/bootstrap.go:56: newVersion, toolsList =
toolsList.Newest()
On 2013/11/14 09:29:45, fwereade wrote:
> I'm not 100% sure this is right, but that's because it's not clear
where the
> tools list comes from and what its properties are. Any reason we can't
get it
> inside here?

> Dimiter's just landing a List.NewestCompatible method, that might be
useful?

Practically, the list will always come from EnsureToolsAvailabilty. That
function uses environs.FindBootstrapTools, which returns a list of tools
with an appropriate version.

I'm not sure that NewestCompatible is appropriate here.

https://codereview.appspot.com/14433058/diff/5001/environs/bootstrap/synctools.go
File environs/bootstrap/synctools.go (right):

https://codereview.appspot.com/14433058/diff/5001/environs/bootstrap/synctools.go#newcode42
environs/bootstrap/synctools.go:42: logger.Warningf("no tools found, so
attempting to build and upload new tools")
On 2013/11/14 09:29:45, fwereade wrote:
> Does this work with released versions of the local provider? That
needs to
> upload tools, and would ideally do so *without* the
juju.BootstrapComand level
> hack.

There's no change there. AFAICT, the hack in BootstrapCmd isn't
necessary, but I would like to run any change there by thumper, and
preferably do it in another CL.

For posterity: if the hack in BootstrapCmd goes, there's a change
necessary in provider/local/environprovider.go too, to enable
auto-upload. Inside the Open method, the bit that sets agent-version
must be deleted.

https://codereview.appspot.com/14433058/diff/5001/environs/manual/bootstrap.go
File environs/manual/bootstrap.go (right):

https://codereview.appspot.com/14433058/diff/5001/environs/manual/bootstrap.go#newcode39
environs/manual/bootstrap.go:39: HardwareCharacteristics
*instance.HardwareCharacteristics
On 2013/11/14 09:29:45, fwereade wrote:
> I'll probably see it in a minute -- but when can they be known ahead
of time ina
> manual bootstrap?

"Ahead of time" here just means before the environs/manual.Bootstrap
function is called, not "ahead of bootstrap time".

The null/manual provider detects series/hardware in the provider's
Bootstrap method, and then passes it down. See provider/null/environ.go.

https://codereview.appspot.com/14433058/diff/5001/provider/local/environ.go
File provider/local/environ.go (right):

https://codereview.appspot.com/14433058/diff/5001/provider/local/environ.go#newcode136
provider/local/environ.go:136: }
On 2013/11/14 09:29:45, fwereade wrote:
> This seems to be repeated a lot. Can we pull it out into a common
func?

Done. I hadn't done this before, as I didn't want to hide what was
happening. If you think of a better name that describes what's happening
underneath, I'd love to hear it.

https://codereview.appspot.com/14433058/diff/5001/provider/maas/environ_test.go
File provider/maas/environ_test.go (right):

https://codereview.appspot.com/14433058/diff/5001/provider/maas/env...

[Ian Booth (wallyworld)]

In general I like that responsibility for setting up tools has been
delegated to the providers. My main concern is that, as implemented, the
bootstrap is not exiting early enough if the environment is already
bootstrapped.

https://codereview.appspot.com/14433058/diff/9001/cmd/juju/bootstrap.go
File cmd/juju/bootstrap.go (right):

https://codereview.appspot.com/14433058/diff/9001/cmd/juju/bootstrap.go#newcode100
cmd/juju/bootstrap.go:100:
One implication of removing this check and running it as part of
bootstrap.Bootstrap() below is that we may well end up uploading tools
only to then tell the user "sorry, already bootstrapped". This check
really does need to be run asap in the bootstrap process, before we do
anything, so that we fail as early as possible.

https://codereview.appspot.com/14433058/diff/9001/environs/bootstrap/bootstrap.go
File environs/bootstrap/bootstrap.go (right):

https://codereview.appspot.com/14433058/diff/9001/environs/bootstrap/bootstrap.go#newcode50
environs/bootstrap/bootstrap.go:50: // and update the agent-version
configuration attribute.
s/update/updates

https://codereview.appspot.com/14433058/diff/9001/environs/bootstrap/bootstrap.go#newcode51
environs/bootstrap/bootstrap.go:51: func SelectBootstrapTools(environ
environs.Environ, toolsList coretools.List) (coretools.List, error) {
could we rename toolsList to availableTools or possibleTools to better
reflect the purpose of the parameter? callers of this method tend to
pass in a possibleTools variable so maybe that is the name to use

https://codereview.appspot.com/14433058/diff/9001/environs/manual/fakessh.go
File environs/manual/fakessh.go (right):

https://codereview.appspot.com/14433058/diff/9001/environs/manual/fakessh.go#newcode1
environs/manual/fakessh.go:1: // Copyright 2013 Canonical Ltd.
Why did this file get renamed from fakessh_test.go?
The contents are only for testing. In general, we only use non
"_test.go" files for testing if there are methods called from outside
the package (I don't think that's the case here?); and if we do, we
usually introduce a "testing" package into which such files are put to
make it clear that the contents are for testing and not production
business logic.

https://codereview.appspot.com/14433058/diff/9001/environs/testing/tools.go
File environs/testing/tools.go (right):

https://codereview.appspot.com/14433058/diff/9001/environs/testing/tools.go#newcode42
environs/testing/tools.go:42: sync.DefaultToolsLocation = c.MkDir() //
stop sync from going to s3
\o/

https://codereview.appspot.com/14433058/diff/9001/provider/common/bootstrap.go
File provider/common/bootstrap.go (right):

https://codereview.appspot.com/14433058/diff/9001/provider/common/bootstrap.go#newcode29
provider/common/bootstrap.go:29: // before potentially uploading any
tools.
Trouble is, we may already have uploaded tools prior to getting to this
point.

https://codereview.appspot.com/14433058/diff/9001/provider/common/bootstrap.go#newcode76
provider/common/bootstrap.go:76: func SetBootstrapTools(env
environs.Environ, series string, arch *string) (coretools.List, error) {
bikeshed - perhaps call this either SetupBootstrapTools or
EnsureBootstrapTools. I think...

[Andrew Wilkins (axwalk)]

Please take a look.

https://codereview.appspot.com/14433058/diff/9001/cmd/juju/bootstrap.go
File cmd/juju/bootstrap.go (right):

https://codereview.appspot.com/14433058/diff/9001/cmd/juju/bootstrap.go#newcode100
cmd/juju/bootstrap.go:100:
On 2013/11/17 23:48:46, wallyworld wrote:
> One implication of removing this check and running it as part of
> bootstrap.Bootstrap() below is that we may well end up uploading tools
only to
> then tell the user "sorry, already bootstrapped". This check really
does need to
> be run asap in the bootstrap process, before we do anything, so that
we fail as
> early as possible.

There are a couple of nice things about putting it inside Bootstrap, one
being that Bootstrap fails if the machine is already bootstrapped (no
need to test that property via the CLI command). But you're right, we
shouldn't break behaviour for --upload-tools. If nothing else, it'll
make developers' lives harder.

I'll revert this.

https://codereview.appspot.com/14433058/diff/9001/environs/bootstrap/bootstrap.go
File environs/bootstrap/bootstrap.go (right):

https://codereview.appspot.com/14433058/diff/9001/environs/bootstrap/bootstrap.go#newcode50
environs/bootstrap/bootstrap.go:50: // and update the agent-version
configuration attribute.
On 2013/11/17 23:48:46, wallyworld wrote:
> s/update/updates

Done.

https://codereview.appspot.com/14433058/diff/9001/environs/bootstrap/bootstrap.go#newcode51
environs/bootstrap/bootstrap.go:51: func SelectBootstrapTools(environ
environs.Environ, toolsList coretools.List) (coretools.List, error) {
On 2013/11/17 23:48:46, wallyworld wrote:
> could we rename toolsList to availableTools or possibleTools to better
reflect
> the purpose of the parameter? callers of this method tend to pass in a
> possibleTools variable so maybe that is the name to use

Done.

https://codereview.appspot.com/14433058/diff/9001/environs/manual/fakessh.go
File environs/manual/fakessh.go (right):

https://codereview.appspot.com/14433058/diff/9001/environs/manual/fakessh.go#newcode1
environs/manual/fakessh.go:1: // Copyright 2013 Canonical Ltd.
On 2013/11/17 23:48:46, wallyworld wrote:
> Why did this file get renamed from fakessh_test.go?
> The contents are only for testing. In general, we only use non
"_test.go" files
> for testing if there are methods called from outside the package (I
don't think
> that's the case here?); and if we do, we usually introduce a "testing"
package
> into which such files are put to make it clear that the contents are
for testing
> and not production business logic.

I had intended to use it in a separate package, but didn't end up doing
that. I'll revert this.

BTW: normally I'd put the test code in a separate package, but in this
case it needs to know some internals of the package (or otherwise we
expose parts that are even more private, such as the detection script).

https://codereview.appspot.com/14433058/diff/9001/provider/common/bootstrap.go
File provider/common/bootstrap.go (right):

https://codereview.appspot.com/14433058/diff/9001/provider/common/bootstrap.go#newcode29
provider/common/bootstrap.go:29: // before potentially uploading any
tools.
On 2013/11/17 23:48:46, wallyworld wrote:
> ...

[Ian Booth (wallyworld)]

Thanks :-)
LGTM

https://codereview.appspot.com/14433058/diff/9001/cmd/juju/bootstrap.go
File cmd/juju/bootstrap.go (right):

https://codereview.appspot.com/14433058/diff/9001/cmd/juju/bootstrap.go#newcode100
cmd/juju/bootstrap.go:100:
On 2013/11/18 05:10:01, axw wrote:
> On 2013/11/17 23:48:46, wallyworld wrote:
> > One implication of removing this check and running it as part of
> > bootstrap.Bootstrap() below is that we may well end up uploading
tools only to
> > then tell the user "sorry, already bootstrapped". This check really
does need
> to
> > be run asap in the bootstrap process, before we do anything, so that
we fail
> as
> > early as possible.

> There are a couple of nice things about putting it inside Bootstrap,
one being
> that Bootstrap fails if the machine is already bootstrapped (no need
to test
> that property via the CLI command). But you're right, we shouldn't
break
> behaviour for --upload-tools. If nothing else, it'll make developers'
lives
> harder.

> I'll revert this.

Yeah, I agree it's a bit unfortunate. It's not just developers also -
people like Dave and Marco regularly run from source to get the latest
goodness.

https://codereview.appspot.com/14433058/

=== modified file 'cmd/juju/bootstrap.go'
--- cmd/juju/bootstrap.go	2013-11-04 02:01:19 +0000
+++ cmd/juju/bootstrap.go	2013-11-18 06:38:24 +0000
@@ -5,11 +5,9 @@
 
 import (
 	"fmt"
-	"io"
 	"strings"
 
 	"launchpad.net/gnuflag"
-	"launchpad.net/loggo"
 
 	"launchpad.net/juju-core/charm"
 	"launchpad.net/juju-core/cmd"
@@ -19,10 +17,7 @@
 	"launchpad.net/juju-core/environs/config"
 	"launchpad.net/juju-core/environs/configstore"
 	"launchpad.net/juju-core/environs/sync"
-	envtools "launchpad.net/juju-core/environs/tools"
-	"launchpad.net/juju-core/errors"
 	"launchpad.net/juju-core/provider"
-	coretools "launchpad.net/juju-core/tools"
 	"launchpad.net/juju-core/utils/set"
 	"launchpad.net/juju-core/version"
 )
@@ -57,7 +52,6 @@
 	Constraints constraints.Value
 	UploadTools bool
 	Series      []string
-	Source      string
 }
 
 func (c *BootstrapCommand) Info() *cmd.Info {
@@ -73,7 +67,6 @@
 	f.Var(constraints.ConstraintsValue{&c.Constraints}, "constraints", "set environment constraints")
 	f.BoolVar(&c.UploadTools, "upload-tools", false, "upload local version of tools before bootstrapping")
 	f.Var(seriesVar{&c.Series}, "series", "upload tools for supplied comma-separated series list")
-	f.StringVar(&c.Source, "source", "", "local path to use as tools source")
 }
 
 func (c *BootstrapCommand) Init(args []string) error {
@@ -102,8 +95,6 @@
 			return fmt.Errorf("failed to enable bootstrap storage: %v", err)
 		}
 	}
-	// Check to see if the environment is already bootstrapped
-	// before potentially uploading any tools.
 	if err := bootstrap.EnsureNotBootstrapped(environ); err != nil {
 		return err
 	}
@@ -120,10 +111,6 @@
 			return err
 		}
 	}
-	err = c.ensureToolsAvailability(environ, ctx, c.UploadTools)
-	if err != nil {
-		return err
-	}
 	return bootstrap.Bootstrap(environ, c.Constraints)
 }
 
@@ -133,7 +120,7 @@
 	forceVersion := uploadVersion(version.Current.Number, nil)
 	cfg := environ.Config()
 	series := getUploadSeries(cfg, c.Series)
-	agenttools, err := uploadTools(environ.Storage(), &forceVersion, series...)
+	agenttools, err := sync.Upload(environ.Storage(), &forceVersion, series...)
 	if err != nil {
 		return err
 	}
@@ -149,87 +136,6 @@
 	return nil
 }
 
-const NoToolsMessage = `
-Juju cannot bootstrap because no tools are available for your environment.
-An attempt was made to build and upload appropriate tools but this was unsuccessful.
-
-`
-
-const NoToolsNoUploadMessage = `
-Juju cannot bootstrap because no tools are available for your environment.
-In addition, no tools could be located to upload.
-You may want to use the 'tools-metadata-url' configuration setting to specify the tools location.
-
-`
-
-func processToolsError(w io.Writer, err *error, uploadAttempted *bool) {
-
-	if *uploadAttempted && *err != nil {
-		fmt.Fprint(w, NoToolsMessage)
-	} else {
-		if errors.IsNotFoundError(*err) || *err == coretools.ErrNoMatches {
-			fmt.Fprint(w, NoToolsNoUploadMessage)
-		}
-	}
-}
-
-// ensureToolsAvailability verifies the tools are available. If no tools are
-// found, it will automatically synchronize them.
-func (c *BootstrapCommand) ensureToolsAvailability(env environs.Environ, ctx *cmd.Context, uploadPerformed bool) (err error) {
-	uploadAttempted := false
-	defer processToolsError(ctx.Stderr, &err, &uploadAttempted)
-	// Capture possible logging while syncing and write it on the screen.
-	loggo.RegisterWriter("bootstrap", cmd.NewCommandLogWriter("juju.environs.sync", ctx.Stdout, ctx.Stderr), loggo.INFO)
-	defer loggo.RemoveWriter("bootstrap")
-
-	// Try to find bootstrap tools.
-	cfg := env.Config()
-	var vers *version.Number
-	if agentVersion, ok := cfg.AgentVersion(); ok {
-		vers = &agentVersion
-	}
-	logger.Debugf("looking for bootstrap tools")
-	params := envtools.BootstrapToolsParams{
-		Version:    vers,
-		Arch:       c.Constraints.Arch,
-		AllowRetry: uploadPerformed,
-	}
-	_, err = envtools.FindBootstrapTools(env, params)
-	if err == nil || !errors.IsNotFoundError(err) || uploadPerformed {
-		return err
-	}
-	// If no tools are available, synchronize if necessary.
-	uploadRequired := true
-	if c.Source != "" {
-		// If we are syncing tools and it succeeds, we don't need to upload the tools.
-		uploadRequired = false
-		logger.Warningf("no tools available, attempting to retrieve from %v", c.Source)
-		sctx := &sync.SyncContext{
-			Target: env.Storage(),
-			Source: c.Source,
-		}
-		if err = syncTools(sctx); err != nil {
-			if (err == coretools.ErrNoMatches || err == envtools.ErrNoTools) && vers == nil && version.Current.IsDev() {
-				uploadRequired = true
-			} else {
-				return err
-			}
-		}
-	}
-	// No suitable tools could be synced so try uploading.
-	if uploadRequired {
-		logger.Infof("no tools found, so attempting to build and upload new tools")
-		uploadAttempted = true
-		if err = c.uploadTools(env); err != nil {
-			return err
-		}
-	}
-	// Synchronization/upload done, try again.
-	params.AllowRetry = true
-	_, err = envtools.FindBootstrapTools(env, params)
-	return err
-}
-
 type seriesVar struct {
 	target *[]string
 }

=== modified file 'cmd/juju/bootstrap_test.go'
--- cmd/juju/bootstrap_test.go	2013-10-25 22:51:39 +0000
+++ cmd/juju/bootstrap_test.go	2013-11-18 06:38:24 +0000
@@ -46,6 +46,10 @@
 	s.LoggingSuite.SetUpTest(c)
 	s.MgoSuite.SetUpTest(c)
 	s.ToolsFixture.SetUpTest(c)
+
+	// Set up a local source with tools.
+	sourceDir := createToolsSource(c, vAll)
+	s.PatchValue(&sync.DefaultToolsLocation, sourceDir)
 }
 
 func (s *BootstrapSuite) TearDownSuite(c *gc.C) {
@@ -76,24 +80,24 @@
 var bootstrapRetryTests = []bootstrapRetryTest{{
 	info:               "no tools uploaded, first check has no retries; no matching binary in source; sync fails with no second attempt",
 	expectedAllowRetry: []bool{false},
-	err:                "no tools available",
+	err:                "cannot find bootstrap tools: no matching tools available",
 	version:            "1.16.0-precise-amd64",
 }, {
 	info:               "no tools uploaded, first check has no retries; matching binary in source; check after sync has retries",
 	expectedAllowRetry: []bool{false, true},
-	err:                "tools not found",
+	err:                "cannot find bootstrap tools: tools not found",
 	version:            "1.16.0-precise-amd64",
 	addVersionToSource: true,
 }, {
 	info:               "no tools uploaded, first check has no retries; no matching binary in source; check after upload has retries",
 	expectedAllowRetry: []bool{false, true},
-	err:                "tools not found",
+	err:                "cannot find bootstrap tools: tools not found",
 	version:            "1.15.1-precise-amd64", // dev version to force upload
 }, {
 	info:               "new tools uploaded, so we want to allow retries to give them a chance at showing up",
 	args:               []string{"--upload-tools"},
 	expectedAllowRetry: []bool{true},
-	err:                "tools not found",
+	err:                "cannot find bootstrap tools: no matching tools available",
 }}
 
 // Test test checks that bootstrap calls FindTools with the expected allowRetry flag.
@@ -105,20 +109,20 @@
 }
 
 func (s *BootstrapSuite) runAllowRetriesTest(c *gc.C, test bootstrapRetryTest) {
-	var extraVersions []version.Binary
+	toolsVersions := envtesting.VAll
 	if test.version != "" {
 		testVersion := version.MustParseBinary(test.version)
 		restore := testbase.PatchValue(&version.Current, testVersion)
 		defer restore()
 		if test.addVersionToSource {
-			extraVersions = append(extraVersions, testVersion)
+			toolsVersions = append([]version.Binary{}, toolsVersions...)
+			toolsVersions = append(toolsVersions, testVersion)
 		}
 	}
 	_, fake := makeEmptyFakeHome(c)
 	defer fake.Restore()
-	// Create some source tools in a local directory.
-	sourceDir := createToolsSource(c, extraVersions)
-	test.args = append(test.args, []string{"--source", sourceDir}...)
+	sourceDir := createToolsSource(c, toolsVersions)
+	s.PatchValue(&sync.DefaultToolsLocation, sourceDir)
 
 	var findToolsRetryValues []bool
 	mockFindTools := func(cloudInst environs.ConfigGetter, majorVersion, minorVersion int,
@@ -137,9 +141,7 @@
 }
 
 func (s *BootstrapSuite) TestTest(c *gc.C) {
-	uploadTools = mockUploadTools
-	defer func() { uploadTools = sync.Upload }()
-
+	s.PatchValue(&sync.Upload, mockUploadTools)
 	for i, test := range bootstrapTests {
 		c.Logf("\ntest %d: %s", i, test.info)
 		test.run(c)
@@ -160,9 +162,6 @@
 }
 
 func (test bootstrapTest) run(c *gc.C) {
-	// Prepare a mock storage for testing.
-	sourceDir := createToolsSource(c, vAll)
-
 	// Create home with dummy provider and remove all
 	// of its envtools.
 	env, fake := makeEmptyFakeHome(c)
@@ -182,7 +181,6 @@
 	}
 
 	// Run command and check for uploads.
-	test.args = append(test.args, []string{"--source", sourceDir}...)
 	opc, errc := runCommand(nullContext(), new(BootstrapCommand), test.args...)
 	if uploadCount > 0 {
 		for i := 0; i < uploadCount; i++ {
@@ -303,10 +301,9 @@
 	defer fake.Restore()
 	defaultSeriesVersion := version.Current
 	defaultSeriesVersion.Series = env.Config().DefaultSeries()
-	sourceDir := createToolsSource(c, append(vAll, defaultSeriesVersion))
 
 	ctx := coretesting.Context(c)
-	code := cmd.Main(&BootstrapCommand{}, ctx, []string{"--source", sourceDir})
+	code := cmd.Main(&BootstrapCommand{}, ctx, nil)
 	c.Check(code, gc.Equals, 0)
 
 	ctx2 := coretesting.Context(c)
@@ -316,51 +313,10 @@
 	c.Check(coretesting.Stdout(ctx2), gc.Equals, "")
 }
 
-func (s *BootstrapSuite) TestAutoSyncLocalSource(c *gc.C) {
-	// Prepare a tools directory for testing and store the
-	// dummy tools in there.
-	sourceDir := createToolsSource(c, vAll)
-
-	// Change the version and ensure its later restoring.
-	origVersion := version.Current
-	version.Current.Number = version.MustParse("1.2.0")
-	defer func() {
-		version.Current = origVersion
-	}()
-
-	// Create home with dummy provider and remove all
-	// of its envtools.
-	env, fake := makeEmptyFakeHome(c)
-	defer fake.Restore()
-
-	// Bootstrap the environment with an invalid source.
-	// The command returns with an error.
-	ctx := coretesting.Context(c)
-	code := cmd.Main(&BootstrapCommand{}, ctx, []string{"--source", c.MkDir()})
-	c.Check(code, gc.Equals, 1)
-
-	// Now check that there are no tools available.
-	_, err := envtools.FindTools(
-		env, version.Current.Major, version.Current.Minor, coretools.Filter{}, envtools.DoNotAllowRetry)
-	c.Assert(err, gc.FitsTypeOf, errors.NotFoundf(""))
-
-	// Bootstrap the environment with the valid source. This time
-	// the bootstrapping has to show no error, because the tools
-	// are automatically synchronized.
-	ctx = coretesting.Context(c)
-	code = cmd.Main(&BootstrapCommand{}, ctx, []string{"--source", sourceDir})
-	c.Check(code, gc.Equals, 0)
-
-	// Now check the available tools which are the 1.2.0 envtools.
-	checkTools(c, env, v120All)
-}
-
-func (s *BootstrapSuite) setupAutoUploadTest(c *gc.C, vers, series string) (environs.Environ, string) {
-	uploadTools = mockUploadTools
-	s.AddCleanup(func(*gc.C) { uploadTools = sync.Upload })
-
-	// Set up a local source with tools.
-	sourceDir := createToolsSource(c, vAll)
+func (s *BootstrapSuite) setupAutoUploadTest(c *gc.C, vers, series string) environs.Environ {
+	s.PatchValue(&sync.Upload, mockUploadTools)
+	sourceDir := createToolsSource(c, vAll)
+	s.PatchValue(&sync.DefaultToolsLocation, sourceDir)
 
 	// Change the tools location to be the test location and also
 	// the version and ensure their later restoring.
@@ -375,7 +331,7 @@
 	// of its envtools.
 	env, fake := makeEmptyFakeHome(c)
 	s.AddCleanup(func(*gc.C) { fake.Restore() })
-	return env, sourceDir
+	return env
 }
 
 func (s *BootstrapSuite) TestAutoUploadAfterFailedSync(c *gc.C) {
@@ -383,9 +339,9 @@
 	if otherSeries == version.Current.Series {
 		otherSeries = "raring"
 	}
-	env, sourceDir := s.setupAutoUploadTest(c, "1.7.3", otherSeries)
+	env := s.setupAutoUploadTest(c, "1.7.3", otherSeries)
 	// Run command and check for that upload has been run for tools matching the current juju version.
-	opc, errc := runCommand(nullContext(), new(BootstrapCommand), "--source", sourceDir)
+	opc, errc := runCommand(nullContext(), new(BootstrapCommand))
 	c.Assert(<-errc, gc.IsNil)
 	c.Assert((<-opc).(dummy.OpPutFile).Env, gc.Equals, "peckham")
 	list, err := envtools.FindTools(env, version.Current.Major, version.Current.Minor, coretools.Filter{}, false)
@@ -405,20 +361,20 @@
 }
 
 func (s *BootstrapSuite) TestAutoUploadOnlyForDev(c *gc.C) {
-	_, sourceDir := s.setupAutoUploadTest(c, "1.8.3", "precise")
-	_, errc := runCommand(nullContext(), new(BootstrapCommand), "--source", sourceDir)
+	s.setupAutoUploadTest(c, "1.8.3", "precise")
+	_, errc := runCommand(nullContext(), new(BootstrapCommand))
 	err := <-errc
-	c.Assert(err, gc.ErrorMatches, "no matching tools available")
+	c.Assert(err, gc.ErrorMatches, "cannot find bootstrap tools: no matching tools available")
 }
 
 func (s *BootstrapSuite) TestMissingToolsError(c *gc.C) {
-	_, sourceDir := s.setupAutoUploadTest(c, "1.8.3", "precise")
+	s.setupAutoUploadTest(c, "1.8.3", "precise")
 	context := coretesting.Context(c)
-	code := cmd.Main(&BootstrapCommand{}, context, []string{"--source", sourceDir})
+	code := cmd.Main(&BootstrapCommand{}, context, nil)
 	c.Assert(code, gc.Equals, 1)
 	errText := context.Stderr.(*bytes.Buffer).String()
 	errText = strings.Replace(errText, "\n", "", -1)
-	expectedErrText := strings.Replace(fmt.Sprintf(".*%s.*", NoToolsNoUploadMessage), "\n", "", -1)
+	expectedErrText := "error: cannot find bootstrap tools: no matching tools available"
 	c.Assert(errText, gc.Matches, expectedErrText)
 }
 
@@ -427,14 +383,14 @@
 }
 
 func (s *BootstrapSuite) TestMissingToolsUploadFailedError(c *gc.C) {
-	_, sourceDir := s.setupAutoUploadTest(c, "1.7.3", "precise")
-	uploadTools = uploadToolsAlwaysFails
+	s.setupAutoUploadTest(c, "1.7.3", "precise")
+	s.PatchValue(&sync.Upload, uploadToolsAlwaysFails)
 	context := coretesting.Context(c)
-	code := cmd.Main(&BootstrapCommand{}, context, []string{"--source", sourceDir})
+	code := cmd.Main(&BootstrapCommand{}, context, nil)
 	c.Assert(code, gc.Equals, 1)
 	errText := context.Stderr.(*bytes.Buffer).String()
 	errText = strings.Replace(errText, "\n", "", -1)
-	expectedErrText := strings.Replace(fmt.Sprintf(".*%s.*", NoToolsMessage), "\n", "", -1)
+	expectedErrText := "error: cannot find bootstrap tools: an error"
 	c.Assert(errText, gc.Matches, expectedErrText)
 }
 

=== modified file 'cmd/juju/upgradejuju.go'
--- cmd/juju/upgradejuju.go	2013-11-14 09:07:52 +0000
+++ cmd/juju/upgradejuju.go	2013-11-18 06:38:24 +0000
@@ -31,8 +31,6 @@
 	Series      []string
 }
 
-var uploadTools = sync.Upload
-
 var upgradeJujuDoc = `
 The upgrade-juju command upgrades a running environment by setting a version
 number for all juju agents to run. By default, it chooses the most recent
@@ -226,7 +224,7 @@
 	// include all the extra series we build, so we can set *that* onto
 	// v.available and maybe one day be able to check that a given upgrade
 	// won't leave out-of-date machines lying around, starved of envtools.
-	uploaded, err := uploadTools(storage, &v.chosen, series...)
+	uploaded, err := sync.Upload(storage, &v.chosen, series...)
 	if err != nil {
 		return err
 	}

=== modified file 'cmd/juju/upgradejuju_test.go'
--- cmd/juju/upgradejuju_test.go	2013-11-14 09:07:52 +0000
+++ cmd/juju/upgradejuju_test.go	2013-11-18 06:38:24 +0000
@@ -273,11 +273,10 @@
 }
 
 func (s *UpgradeJujuSuite) TestUpgradeJuju(c *gc.C) {
+	s.PatchValue(&sync.Upload, mockUploadTools)
 	oldVersion := version.Current
-	uploadTools = mockUploadTools
 	defer func() {
 		version.Current = oldVersion
-		uploadTools = sync.Upload
 	}()
 
 	for i, test := range upgradeJujuTests {

=== modified file 'cmd/jujud/bootstrap.go'
--- cmd/jujud/bootstrap.go	2013-10-04 17:10:00 +0000
+++ cmd/jujud/bootstrap.go	2013-11-18 06:38:24 +0000
@@ -15,10 +15,10 @@
 	"launchpad.net/juju-core/agent"
 	"launchpad.net/juju-core/cmd"
 	"launchpad.net/juju-core/constraints"
+	"launchpad.net/juju-core/environs/bootstrap"
 	"launchpad.net/juju-core/environs/cloudinit"
 	"launchpad.net/juju-core/environs/config"
 	"launchpad.net/juju-core/instance"
-	"launchpad.net/juju-core/provider/common"
 	"launchpad.net/juju-core/state"
 )
 
@@ -62,7 +62,7 @@
 		return fmt.Errorf("cannot read provider-state-url file: %v", err)
 	}
 	stateInfoURL := strings.Split(string(data), "\n")[0]
-	bsState, err := common.LoadStateFromURL(stateInfoURL)
+	bsState, err := bootstrap.LoadStateFromURL(stateInfoURL)
 	if err != nil {
 		return fmt.Errorf("cannot load state from URL %q (read from %q): %v", stateInfoURL, providerStateURLFile, err)
 	}

=== modified file 'cmd/jujud/bootstrap_test.go'
--- cmd/jujud/bootstrap_test.go	2013-11-06 13:38:01 +0000
+++ cmd/jujud/bootstrap_test.go	2013-11-18 06:38:24 +0000
@@ -13,10 +13,10 @@
 
 	"launchpad.net/juju-core/agent"
 	"launchpad.net/juju-core/constraints"
+	"launchpad.net/juju-core/environs/bootstrap"
 	"launchpad.net/juju-core/environs/jujutest"
 	"launchpad.net/juju-core/errors"
 	"launchpad.net/juju-core/instance"
-	"launchpad.net/juju-core/provider/common"
 	"launchpad.net/juju-core/provider/dummy"
 	"launchpad.net/juju-core/state"
 	"launchpad.net/juju-core/testing"
@@ -46,12 +46,12 @@
 func (s *BootstrapSuite) SetUpSuite(c *gc.C) {
 	s.LoggingSuite.SetUpSuite(c)
 	s.MgoSuite.SetUpSuite(c)
-	stateInfo := common.BootstrapState{
+	stateInfo := bootstrap.BootstrapState{
 		StateInstances: []instance.Id{instance.Id("dummy.instance.id")},
 	}
 	stateData, err := goyaml.Marshal(stateInfo)
 	c.Assert(err, gc.IsNil)
-	content := map[string]string{"/" + common.StateFile: string(stateData)}
+	content := map[string]string{"/" + bootstrap.StateFile: string(stateData)}
 	testRoundTripper.Sub = jujutest.NewCannedRoundTripper(content, nil)
 	s.providerStateURLFile = filepath.Join(c.MkDir(), "provider-state-url")
 	providerStateURLFile = s.providerStateURLFile

=== modified file 'environs/bootstrap/bootstrap.go'
--- environs/bootstrap/bootstrap.go	2013-10-04 16:16:10 +0000
+++ environs/bootstrap/bootstrap.go	2013-11-18 06:38:24 +0000
@@ -10,12 +10,11 @@
 
 	"launchpad.net/juju-core/constraints"
 	"launchpad.net/juju-core/environs"
-	"launchpad.net/juju-core/environs/tools"
-	"launchpad.net/juju-core/provider/common"
+	coretools "launchpad.net/juju-core/tools"
 	"launchpad.net/juju-core/version"
 )
 
-var logger = loggo.GetLogger("juju.environs.boostrap")
+var logger = loggo.GetLogger("juju.environs.bootstrap")
 
 // Bootstrap bootstraps the given environment. The supplied constraints are
 // used to provision the instance, and are also set within the bootstrapped
@@ -43,51 +42,40 @@
 	if err := environs.VerifyStorage(environ.Storage()); err != nil {
 		return err
 	}
-
 	logger.Infof("bootstrapping environment %q", environ.Name())
-	var vers *version.Number
-	if agentVersion, ok := cfg.AgentVersion(); ok {
-		vers = &agentVersion
-	}
-	params := tools.BootstrapToolsParams{
-		Version: vers,
-		Arch:    cons.Arch,
-	}
-	newestTools, err := tools.FindBootstrapTools(environ, params)
-	if err != nil {
-		return fmt.Errorf("cannot find bootstrap tools: %v", err)
-	}
+	return environ.Bootstrap(cons)
+}
 
-	// If agent version was not previously known, set it here using the latest compatible tools version.
-	if vers == nil {
-		// We probably still have a mix of versions available; discard older ones
-		// and update environment configuration to use only those remaining.
-		var newVersion version.Number
-		newVersion, newestTools = newestTools.Newest()
-		vers = &newVersion
-		logger.Infof("environs: picked newest version: %s", *vers)
-		cfg, err = cfg.Apply(map[string]interface{}{
-			"agent-version": vers.String(),
+// SetBootstrapTools returns the newest tools from the given tools list,
+// and updates the agent-version configuration attribute.
+func SetBootstrapTools(environ environs.Environ, possibleTools coretools.List) (coretools.List, error) {
+	if len(possibleTools) == 0 {
+		return nil, fmt.Errorf("no bootstrap tools available")
+	}
+	var newVersion version.Number
+	newVersion, toolsList := possibleTools.Newest()
+	logger.Infof("picked newest version: %s", newVersion)
+	cfg := environ.Config()
+	if agentVersion, _ := cfg.AgentVersion(); agentVersion != newVersion {
+		cfg, err := cfg.Apply(map[string]interface{}{
+			"agent-version": newVersion.String(),
 		})
 		if err == nil {
 			err = environ.SetConfig(cfg)
 		}
 		if err != nil {
-			return fmt.Errorf("failed to update environment configuration: %v", err)
+			return nil, fmt.Errorf("failed to update environment configuration: %v", err)
 		}
 	}
-	// ensure we have at least one valid tools
-	if len(newestTools) == 0 {
-		return fmt.Errorf("No bootstrap tools found")
-	}
-	return environ.Bootstrap(cons, newestTools)
+	return toolsList, nil
 }
 
 // EnsureNotBootstrapped returns null if the environment is not bootstrapped,
 // and an error if it is or if the function was not able to tell.
 func EnsureNotBootstrapped(env environs.Environ) error {
-	_, err := common.LoadState(env.Storage())
-	// If there is no error loading the bootstrap state, then we are bootstrapped.
+	_, err := LoadState(env.Storage())
+	// If there is no error loading the bootstrap state, then we are
+	// bootstrapped.
 	if err == nil {
 		return fmt.Errorf("environment is already bootstrapped")
 	}

=== modified file 'environs/bootstrap/bootstrap_test.go'
--- environs/bootstrap/bootstrap_test.go	2013-10-24 00:20:59 +0000
+++ environs/bootstrap/bootstrap_test.go	2013-11-18 06:38:24 +0000
@@ -21,7 +21,6 @@
 	"launchpad.net/juju-core/provider/dummy"
 	coretesting "launchpad.net/juju-core/testing"
 	"launchpad.net/juju-core/testing/testbase"
-	"launchpad.net/juju-core/tools"
 	"launchpad.net/juju-core/version"
 )
 
@@ -183,11 +182,21 @@
 	}
 }
 
-func (s *bootstrapSuite) TestBootstrapNeedsTools(c *gc.C) {
+func (s *bootstrapSuite) TestBootstrapNoTools(c *gc.C) {
 	env := newEnviron("foo", useDefaultKeys)
 	s.setDummyStorage(c, env)
 	envtesting.RemoveFakeTools(c, env.Storage())
 	err := bootstrap.Bootstrap(env, constraints.Value{})
+	// bootstrap.Bootstrap leaves it to the provider to
+	// locate bootstrap tools.
+	c.Assert(err, gc.IsNil)
+}
+
+func (s *bootstrapSuite) TestEnsureToolsAvailability(c *gc.C) {
+	env := newEnviron("foo", useDefaultKeys)
+	s.setDummyStorage(c, env)
+	envtesting.RemoveFakeTools(c, env.Storage())
+	_, err := bootstrap.EnsureToolsAvailability(env, env.Config().DefaultSeries(), nil)
 	c.Check(err, gc.ErrorMatches, "cannot find bootstrap tools: invalid URL.*")
 }
 
@@ -243,7 +252,7 @@
 	return e.name
 }
 
-func (e *bootstrapEnviron) Bootstrap(cons constraints.Value, possibleTools tools.List) error {
+func (e *bootstrapEnviron) Bootstrap(cons constraints.Value) error {
 	e.bootstrapCount++
 	e.constraints = cons
 	return nil

=== added file 'environs/bootstrap/state.go'
--- environs/bootstrap/state.go	1970-01-01 00:00:00 +0000
+++ environs/bootstrap/state.go	2013-11-18 06:38:24 +0000
@@ -0,0 +1,97 @@
+// Copyright 2012, 2013 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package bootstrap
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+
+	"launchpad.net/goyaml"
+
+	"launchpad.net/juju-core/environs"
+	"launchpad.net/juju-core/environs/storage"
+	coreerrors "launchpad.net/juju-core/errors"
+	"launchpad.net/juju-core/instance"
+)
+
+// StateFile is the name of the file where the provider's state is stored.
+const StateFile = "provider-state"
+
+// BootstrapState is the state information that is stored in StateFile.
+//
+// Individual providers may define their own state structures instead of
+// this one, and use their own code for loading and saving those, but this is
+// the definition that most practically useful providers share unchanged.
+type BootstrapState struct {
+	// StateInstances are the state servers.
+	StateInstances []instance.Id `yaml:"state-instances"`
+	// Characteristics reflect the hardware each state server is running on.
+	// This is used at bootstrap time so the state server knows what hardware it has.
+	// The state *may* be updated later without this information, but by then it's
+	// served it's purpose.
+	Characteristics []instance.HardwareCharacteristics `yaml:"characteristics,omitempty"`
+}
+
+// putState writes the given data to the state file on the given storage.
+// The file's name is as defined in StateFile.
+func putState(storage storage.StorageWriter, data []byte) error {
+	return storage.Put(StateFile, bytes.NewBuffer(data), int64(len(data)))
+}
+
+// CreateStateFile creates an empty state file on the given storage, and
+// returns its URL.
+func CreateStateFile(storage storage.Storage) (string, error) {
+	err := putState(storage, []byte{})
+	if err != nil {
+		return "", fmt.Errorf("cannot create initial state file: %v", err)
+	}
+	return storage.URL(StateFile)
+}
+
+// SaveState writes the given state to the given storage.
+func SaveState(storage storage.StorageWriter, state *BootstrapState) error {
+	data, err := goyaml.Marshal(state)
+	if err != nil {
+		return err
+	}
+	return putState(storage, data)
+}
+
+// LoadStateFromURL reads state from the given URL.
+func LoadStateFromURL(url string) (*BootstrapState, error) {
+	resp, err := http.Get(url)
+	if err != nil {
+		return nil, err
+	}
+	return loadState(resp.Body)
+}
+
+// LoadState reads state from the given storage.
+func LoadState(stor storage.StorageReader) (*BootstrapState, error) {
+	r, err := storage.Get(stor, StateFile)
+	if err != nil {
+		if coreerrors.IsNotFoundError(err) {
+			return nil, environs.ErrNotBootstrapped
+		}
+		return nil, err
+	}
+	return loadState(r)
+}
+
+func loadState(r io.ReadCloser) (*BootstrapState, error) {
+	defer r.Close()
+	data, err := ioutil.ReadAll(r)
+	if err != nil {
+		return nil, fmt.Errorf("error reading %q: %v", StateFile, err)
+	}
+	var state BootstrapState
+	err = goyaml.Unmarshal(data, &state)
+	if err != nil {
+		return nil, fmt.Errorf("error unmarshalling %q: %v", StateFile, err)
+	}
+	return &state, nil
+}

=== added file 'environs/bootstrap/state_test.go'
--- environs/bootstrap/state_test.go	1970-01-01 00:00:00 +0000
+++ environs/bootstrap/state_test.go	2013-11-18 06:38:24 +0000
@@ -0,0 +1,118 @@
+// Copyright 2013 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package bootstrap_test
+
+import (
+	"bytes"
+	"io/ioutil"
+
+	gc "launchpad.net/gocheck"
+	"launchpad.net/goyaml"
+
+	"launchpad.net/juju-core/environs"
+	"launchpad.net/juju-core/environs/bootstrap"
+	"launchpad.net/juju-core/environs/storage"
+	envtesting "launchpad.net/juju-core/environs/testing"
+	"launchpad.net/juju-core/instance"
+	"launchpad.net/juju-core/testing/testbase"
+)
+
+type StateSuite struct {
+	testbase.LoggingSuite
+}
+
+var _ = gc.Suite(&StateSuite{})
+
+func (suite *StateSuite) newStorage(c *gc.C) storage.Storage {
+	closer, stor, _ := envtesting.CreateLocalTestStorage(c)
+	suite.AddCleanup(func(*gc.C) { closer.Close() })
+	envtesting.UploadFakeTools(c, stor)
+	return stor
+}
+
+func (suite *StateSuite) TestCreateStateFileWritesEmptyStateFile(c *gc.C) {
+	stor := suite.newStorage(c)
+
+	url, err := bootstrap.CreateStateFile(stor)
+	c.Assert(err, gc.IsNil)
+
+	reader, err := storage.Get(stor, bootstrap.StateFile)
+	c.Assert(err, gc.IsNil)
+	data, err := ioutil.ReadAll(reader)
+	c.Assert(err, gc.IsNil)
+	c.Check(string(data), gc.Equals, "")
+	c.Assert(url, gc.NotNil)
+	expectedURL, err := stor.URL(bootstrap.StateFile)
+	c.Assert(err, gc.IsNil)
+	c.Check(url, gc.Equals, expectedURL)
+}
+
+func (suite *StateSuite) TestSaveStateWritesStateFile(c *gc.C) {
+	stor := suite.newStorage(c)
+	arch := "amd64"
+	state := bootstrap.BootstrapState{
+		StateInstances:  []instance.Id{instance.Id("an-instance-id")},
+		Characteristics: []instance.HardwareCharacteristics{{Arch: &arch}}}
+	marshaledState, err := goyaml.Marshal(state)
+	c.Assert(err, gc.IsNil)
+
+	err = bootstrap.SaveState(stor, &state)
+	c.Assert(err, gc.IsNil)
+
+	loadedState, err := storage.Get(stor, bootstrap.StateFile)
+	c.Assert(err, gc.IsNil)
+	content, err := ioutil.ReadAll(loadedState)
+	c.Assert(err, gc.IsNil)
+	c.Check(content, gc.DeepEquals, marshaledState)
+}
+
+func (suite *StateSuite) setUpSavedState(c *gc.C, stor storage.Storage) bootstrap.BootstrapState {
+	arch := "amd64"
+	state := bootstrap.BootstrapState{
+		StateInstances:  []instance.Id{instance.Id("an-instance-id")},
+		Characteristics: []instance.HardwareCharacteristics{{Arch: &arch}}}
+	content, err := goyaml.Marshal(state)
+	c.Assert(err, gc.IsNil)
+	err = stor.Put(bootstrap.StateFile, ioutil.NopCloser(bytes.NewReader(content)), int64(len(content)))
+	c.Assert(err, gc.IsNil)
+	return state
+}
+
+func (suite *StateSuite) TestLoadStateReadsStateFile(c *gc.C) {
+	storage := suite.newStorage(c)
+	state := suite.setUpSavedState(c, storage)
+	storedState, err := bootstrap.LoadState(storage)
+	c.Assert(err, gc.IsNil)
+	c.Check(*storedState, gc.DeepEquals, state)
+}
+
+func (suite *StateSuite) TestLoadStateFromURLReadsStateFile(c *gc.C) {
+	stor := suite.newStorage(c)
+	state := suite.setUpSavedState(c, stor)
+	url, err := stor.URL(bootstrap.StateFile)
+	c.Assert(err, gc.IsNil)
+	storedState, err := bootstrap.LoadStateFromURL(url)
+	c.Assert(err, gc.IsNil)
+	c.Check(*storedState, gc.DeepEquals, state)
+}
+
+func (suite *StateSuite) TestLoadStateMissingFile(c *gc.C) {
+	stor := suite.newStorage(c)
+	_, err := bootstrap.LoadState(stor)
+	c.Check(err, gc.Equals, environs.ErrNotBootstrapped)
+}
+
+func (suite *StateSuite) TestLoadStateIntegratesWithSaveState(c *gc.C) {
+	storage := suite.newStorage(c)
+	arch := "amd64"
+	state := bootstrap.BootstrapState{
+		StateInstances:  []instance.Id{instance.Id("an-instance-id")},
+		Characteristics: []instance.HardwareCharacteristics{{Arch: &arch}}}
+	err := bootstrap.SaveState(storage, &state)
+	c.Assert(err, gc.IsNil)
+	storedState, err := bootstrap.LoadState(storage)
+	c.Assert(err, gc.IsNil)
+
+	c.Check(*storedState, gc.DeepEquals, state)
+}

=== added file 'environs/bootstrap/synctools.go'
--- environs/bootstrap/synctools.go	1970-01-01 00:00:00 +0000
+++ environs/bootstrap/synctools.go	2013-11-18 06:38:24 +0000
@@ -0,0 +1,123 @@
+// Copyright 2012, 2013 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package bootstrap
+
+import (
+	"fmt"
+
+	"launchpad.net/juju-core/environs"
+	"launchpad.net/juju-core/environs/config"
+	"launchpad.net/juju-core/environs/sync"
+	envtools "launchpad.net/juju-core/environs/tools"
+	"launchpad.net/juju-core/errors"
+	coretools "launchpad.net/juju-core/tools"
+	"launchpad.net/juju-core/utils/set"
+	"launchpad.net/juju-core/version"
+)
+
+const noToolsMessage = `Juju cannot bootstrap because no tools are available for your environment.
+An attempt was made to build and upload appropriate tools but this was unsuccessful.
+`
+
+const noToolsNoUploadMessage = `Juju cannot bootstrap because no tools are available for your environment.
+In addition, no tools could be located to upload.
+You may want to use the 'tools-metadata-url' configuration setting to specify the tools location.
+`
+
+// syncOrUpload first attempts to synchronize tools from
+// the default tools source to the environment's storage.
+//
+// If synchronization fails due to no matching tools,
+// a development version of juju is running, and no
+// agent-version has been specified, then attempt to
+// build and upload local tools.
+func syncOrUpload(env environs.Environ, bootstrapSeries string) error {
+	sctx := &sync.SyncContext{
+		Target: env.Storage(),
+	}
+	err := sync.SyncTools(sctx)
+	if err == coretools.ErrNoMatches || err == envtools.ErrNoTools {
+		if _, hasAgentVersion := env.Config().AgentVersion(); !hasAgentVersion && version.Current.IsDev() {
+			logger.Warningf("no tools found, so attempting to build and upload new tools")
+			if err = uploadTools(env, bootstrapSeries); err != nil {
+				logger.Errorf("%s", noToolsMessage)
+				return err
+			}
+		} else {
+			logger.Errorf("%s", noToolsNoUploadMessage)
+		}
+	}
+	return err
+}
+
+func uploadTools(env environs.Environ, bootstrapSeries string) error {
+	cfg := env.Config()
+	uploadVersion := version.Current.Number
+	uploadVersion.Build++
+	uploadSeries := set.NewStrings(
+		bootstrapSeries,
+		cfg.DefaultSeries(),
+		config.DefaultSeries,
+	)
+	tools, err := sync.Upload(env.Storage(), &uploadVersion, uploadSeries.Values()...)
+	if err != nil {
+		return err
+	}
+	cfg, err = cfg.Apply(map[string]interface{}{
+		"agent-version": tools.Version.Number.String(),
+	})
+	if err == nil {
+		err = env.SetConfig(cfg)
+	}
+	if err != nil {
+		return fmt.Errorf("failed to update environment configuration: %v", err)
+	}
+	return nil
+}
+
+// EnsureToolsAvailability verifies the tools are available. If no tools are
+// found, it will automatically synchronize them.
+func EnsureToolsAvailability(env environs.Environ, series string, arch *string) (coretools.List, error) {
+	cfg := env.Config()
+	var vers *version.Number
+	if agentVersion, ok := cfg.AgentVersion(); ok {
+		vers = &agentVersion
+	}
+
+	logger.Debugf(
+		"looking for bootstrap tools: series=%q, arch=%v, version=%v",
+		series, arch, vers,
+	)
+	params := envtools.BootstrapToolsParams{
+		Version: vers,
+		Arch:    arch,
+		Series:  series,
+		// If vers.Build>0, the tools may have been uploaded in this session.
+		// Allow retries, so we wait until the storage has caught up.
+		AllowRetry: vers != nil && vers.Build > 0,
+	}
+	toolsList, err := envtools.FindBootstrapTools(env, params)
+	if err == nil {
+		return toolsList, nil
+	} else if !errors.IsNotFoundError(err) {
+		return nil, err
+	}
+
+	// No tools available, so synchronize.
+	logger.Warningf("no tools available, attempting to retrieve from %v", sync.DefaultToolsLocation)
+	if syncErr := syncOrUpload(env, series); syncErr != nil {
+		// The target may have tools that don't match, so don't
+		// return a misleading "no tools found" error.
+		if syncErr != envtools.ErrNoTools {
+			err = syncErr
+		}
+		return nil, fmt.Errorf("cannot find bootstrap tools: %v", err)
+	}
+	// TODO(axw) have syncOrUpload return the list of tools in the target, and use that.
+	params.AllowRetry = true
+	if toolsList, err = envtools.FindBootstrapTools(env, params); err != nil {
+		return nil, fmt.Errorf("cannot find bootstrap tools: %v", err)
+	}
+	return toolsList, nil
+}

=== modified file 'environs/interface.go'
--- environs/interface.go	2013-10-25 22:24:35 +0000
+++ environs/interface.go	2013-11-18 06:38:24 +0000
@@ -10,7 +10,6 @@
 	"launchpad.net/juju-core/instance"
 	"launchpad.net/juju-core/state"
 	"launchpad.net/juju-core/state/api"
-	"launchpad.net/juju-core/tools"
 )
 
 // A EnvironProvider represents a computing and storage provider.
@@ -133,7 +132,11 @@
 	//
 	// The supplied constraints are used to choose the initial instance
 	// specification, and will be stored in the new environment's state.
-	Bootstrap(cons constraints.Value, possibleTools tools.List) error
+	//
+	// Bootstrap is responsible for selecting the appropriate tools,
+	// and setting the agent-version configuration attribute prior to
+	// bootstrapping the environment.
+	Bootstrap(cons constraints.Value) error
 
 	// StateInfo returns information on the state initialized
 	// by Bootstrap.

=== modified file 'environs/jujutest/livetests.go'
--- environs/jujutest/livetests.go	2013-10-03 01:28:51 +0000
+++ environs/jujutest/livetests.go	2013-11-18 06:38:24 +0000
@@ -27,6 +27,7 @@
 	"launchpad.net/juju-core/instance"
 	"launchpad.net/juju-core/juju"
 	"launchpad.net/juju-core/juju/testing"
+	"launchpad.net/juju-core/provider/common"
 	"launchpad.net/juju-core/provider/dummy"
 	"launchpad.net/juju-core/state"
 	"launchpad.net/juju-core/state/api"
@@ -137,7 +138,7 @@
 		c.Assert(err, gc.IsNil)
 	}
 	envtesting.UploadFakeTools(c, t.Env.Storage())
-	err := bootstrap.EnsureNotBootstrapped(t.Env)
+	err := common.EnsureNotBootstrapped(t.Env)
 	c.Assert(err, gc.IsNil)
 	err = bootstrap.Bootstrap(t.Env, cons)
 	c.Assert(err, gc.IsNil)
@@ -391,7 +392,7 @@
 	// already up, this has been moved into the bootstrap command.
 	t.BootstrapOnce(c)
 
-	err := bootstrap.EnsureNotBootstrapped(t.Env)
+	err := common.EnsureNotBootstrapped(t.Env)
 	c.Assert(err, gc.ErrorMatches, "environment is already bootstrapped")
 
 	c.Logf("destroy env")

=== modified file 'environs/jujutest/tests.go'
--- environs/jujutest/tests.go	2013-10-03 01:28:51 +0000
+++ environs/jujutest/tests.go	2013-11-18 06:38:24 +0000
@@ -21,6 +21,7 @@
 	"launchpad.net/juju-core/errors"
 	"launchpad.net/juju-core/instance"
 	"launchpad.net/juju-core/juju/testing"
+	"launchpad.net/juju-core/provider/common"
 	coretesting "launchpad.net/juju-core/testing"
 	jc "launchpad.net/juju-core/testing/checkers"
 	"launchpad.net/juju-core/testing/testbase"
@@ -131,7 +132,7 @@
 func (t *Tests) TestBootstrap(c *gc.C) {
 	e := t.Prepare(c)
 	envtesting.UploadFakeTools(c, e.Storage())
-	err := bootstrap.EnsureNotBootstrapped(e)
+	err := common.EnsureNotBootstrapped(e)
 	c.Assert(err, gc.IsNil)
 	err = bootstrap.Bootstrap(e, constraints.Value{})
 	c.Assert(err, gc.IsNil)
@@ -140,12 +141,12 @@
 	c.Check(info.Addrs, gc.Not(gc.HasLen), 0)
 	c.Check(apiInfo.Addrs, gc.Not(gc.HasLen), 0)
 
-	err = bootstrap.EnsureNotBootstrapped(e)
+	err = common.EnsureNotBootstrapped(e)
 	c.Assert(err, gc.ErrorMatches, "environment is already bootstrapped")
 
 	e2 := t.Open(c)
 	envtesting.UploadFakeTools(c, e2.Storage())
-	err = bootstrap.EnsureNotBootstrapped(e2)
+	err = common.EnsureNotBootstrapped(e2)
 	c.Assert(err, gc.ErrorMatches, "environment is already bootstrapped")
 
 	info2, apiInfo2, err := e2.StateInfo()
@@ -159,12 +160,12 @@
 	e3 := t.Prepare(c)
 	envtesting.UploadFakeTools(c, e3.Storage())
 
-	err = bootstrap.EnsureNotBootstrapped(e3)
+	err = common.EnsureNotBootstrapped(e3)
 	c.Assert(err, gc.IsNil)
 	err = bootstrap.Bootstrap(e3, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 
-	err = bootstrap.EnsureNotBootstrapped(e3)
+	err = common.EnsureNotBootstrapped(e3)
 	c.Assert(err, gc.ErrorMatches, "environment is already bootstrapped")
 }
 

=== modified file 'environs/manual/bootstrap.go'
--- environs/manual/bootstrap.go	2013-11-14 08:27:15 +0000
+++ environs/manual/bootstrap.go	2013-11-18 06:38:24 +0000
@@ -9,9 +9,9 @@
 
 	"launchpad.net/juju-core/constraints"
 	"launchpad.net/juju-core/environs"
+	"launchpad.net/juju-core/environs/bootstrap"
 	envtools "launchpad.net/juju-core/environs/tools"
 	"launchpad.net/juju-core/instance"
-	"launchpad.net/juju-core/provider/common"
 	"launchpad.net/juju-core/tools"
 	"launchpad.net/juju-core/worker/localstorage"
 )
@@ -30,6 +30,13 @@
 	DataDir       string
 	Environ       LocalStorageEnviron
 	PossibleTools tools.List
+
+	// If series and hardware characteristics
+	// are known ahead of time, they can be
+	// set here and Bootstrap will not attempt
+	// to detect them again.
+	Series                  string
+	HardwareCharacteristics *instance.HardwareCharacteristics
 }
 
 func errMachineIdInvalid(machineId string) error {
@@ -58,9 +65,16 @@
 		return ErrProvisioned
 	}
 
-	hc, series, err := detectSeriesAndHardwareCharacteristics(args.Host)
-	if err != nil {
-		return fmt.Errorf("error detecting hardware characteristics: %v", err)
+	var series string
+	var hc instance.HardwareCharacteristics
+	if args.Series != "" && args.HardwareCharacteristics != nil {
+		series = args.Series
+		hc = *args.HardwareCharacteristics
+	} else {
+		hc, series, err = DetectSeriesAndHardwareCharacteristics(args.Host)
+		if err != nil {
+			return fmt.Errorf("error detecting hardware characteristics: %v", err)
+		}
 	}
 
 	// Filter tools based on detected series/arch.
@@ -76,9 +90,9 @@
 	// Store the state file. If provisioning fails, we'll remove the file.
 	logger.Infof("Saving bootstrap state file to bootstrap storage")
 	bootstrapStorage := args.Environ.Storage()
-	err = common.SaveState(
+	err = bootstrap.SaveState(
 		bootstrapStorage,
-		&common.BootstrapState{
+		&bootstrap.BootstrapState{
 			StateInstances:  []instance.Id{BootstrapInstanceId},
 			Characteristics: []instance.HardwareCharacteristics{hc},
 		},
@@ -89,7 +103,7 @@
 	defer func() {
 		if err != nil {
 			logger.Errorf("bootstrapping failed, removing state file: %v", err)
-			bootstrapStorage.Remove(common.StateFile)
+			bootstrapStorage.Remove(bootstrap.StateFile)
 		}
 	}()
 
@@ -107,7 +121,7 @@
 	}
 
 	// Finally, provision the machine agent.
-	stateFileURL := fmt.Sprintf("file://%s/%s", storageDir, common.StateFile)
+	stateFileURL := fmt.Sprintf("file://%s/%s", storageDir, bootstrap.StateFile)
 	mcfg := environs.NewBootstrapMachineConfig(stateFileURL)
 	if args.DataDir != "" {
 		mcfg.DataDir = args.DataDir

=== modified file 'environs/manual/bootstrap_test.go'
--- environs/manual/bootstrap_test.go	2013-10-02 10:39:12 +0000
+++ environs/manual/bootstrap_test.go	2013-11-18 06:38:24 +0000
@@ -9,12 +9,12 @@
 	gc "launchpad.net/gocheck"
 
 	"launchpad.net/juju-core/environs"
+	"launchpad.net/juju-core/environs/bootstrap"
 	"launchpad.net/juju-core/environs/filestorage"
 	"launchpad.net/juju-core/environs/storage"
 	"launchpad.net/juju-core/environs/tools"
 	"launchpad.net/juju-core/instance"
 	"launchpad.net/juju-core/juju/testing"
-	"launchpad.net/juju-core/provider/common"
 )
 
 type bootstrapSuite struct {
@@ -81,11 +81,11 @@
 	args := s.getArgs(c)
 	args.Host = "ubuntu@" + args.Host
 
-	defer fakeSSH{series: s.Conn.Environ.Config().DefaultSeries()}.install(c).Restore()
+	defer fakeSSH{Series: s.Conn.Environ.Config().DefaultSeries()}.install(c).Restore()
 	err := Bootstrap(args)
 	c.Assert(err, gc.IsNil)
 
-	bootstrapState, err := common.LoadState(s.env.Storage())
+	bootstrapState, err := bootstrap.LoadState(s.env.Storage())
 	c.Assert(err, gc.IsNil)
 	c.Assert(
 		bootstrapState.StateInstances,
@@ -96,7 +96,7 @@
 	// Do it all again; this should work, despite the fact that
 	// there's a bootstrap state file. Existence for that is
 	// checked in general bootstrap code (environs/bootstrap).
-	defer fakeSSH{series: s.Conn.Environ.Config().DefaultSeries()}.install(c).Restore()
+	defer fakeSSH{Series: s.Conn.Environ.Config().DefaultSeries()}.install(c).Restore()
 	err = Bootstrap(args)
 	c.Assert(err, gc.IsNil)
 
@@ -106,17 +106,56 @@
 	c.Assert(err, gc.Equals, ErrProvisioned)
 }
 
+func (s *bootstrapSuite) TestBootstrapSkipDetection(c *gc.C) {
+	args := s.getArgs(c)
+	hc, err := instance.ParseHardware("arch=amd64")
+	c.Assert(err, gc.IsNil)
+
+	type test struct {
+		series string
+		hc     *instance.HardwareCharacteristics
+	}
+	tests := []test{{
+		series: "",
+		hc:     nil,
+	}, {
+		series: "precise",
+		hc:     nil,
+	}, {
+		series: "",
+		hc:     &hc,
+	}, {
+		series: "precise",
+		hc:     &hc,
+	}}
+
+	for i, test := range tests {
+		c.Logf("test %d: %+v", i, test)
+		args.Series = test.series
+		args.HardwareCharacteristics = test.hc
+		var ssh fakeSSH
+		if args.Series != "" && args.HardwareCharacteristics != nil {
+			// If neither series nor hardware-characteristics
+			// is missing, detection is skipped.
+			ssh.SkipDetection = true
+		}
+		defer ssh.install(c).Restore()
+		err = Bootstrap(args)
+		c.Assert(err, gc.IsNil)
+	}
+}
+
 func (s *bootstrapSuite) TestBootstrapScriptFailure(c *gc.C) {
 	args := s.getArgs(c)
 	args.Host = "ubuntu@" + args.Host
 	series := s.Conn.Environ.Config().DefaultSeries()
-	defer fakeSSH{series: series, provisionAgentExitCode: 1}.install(c).Restore()
+	defer fakeSSH{Series: series, ProvisionAgentExitCode: 1}.install(c).Restore()
 	err := Bootstrap(args)
 	c.Assert(err, gc.NotNil)
 
 	// Since the script failed, the state file should have been
 	// removed from storage.
-	_, err = common.LoadState(s.env.Storage())
+	_, err = bootstrap.LoadState(s.env.Storage())
 	c.Check(err, gc.Equals, environs.ErrNotBootstrapped)
 }
 
@@ -143,11 +182,11 @@
 	args := s.getArgs(c)
 	args.PossibleTools = nil
 	series := s.Conn.Environ.Config().DefaultSeries()
-	defer fakeSSH{series: series, skipProvisionAgent: true}.install(c).Restore()
+	defer fakeSSH{Series: series, SkipProvisionAgent: true}.install(c).Restore()
 	c.Assert(Bootstrap(args), gc.ErrorMatches, "no matching tools available")
 
 	// Non-empty list, but none that match the series/arch.
-	defer fakeSSH{series: "edgy", skipProvisionAgent: true}.install(c).Restore()
+	defer fakeSSH{Series: "edgy", SkipProvisionAgent: true}.install(c).Restore()
 	args = s.getArgs(c)
 	c.Assert(Bootstrap(args), gc.ErrorMatches, "no matching tools available")
 }

=== modified file 'environs/manual/detection.go'
--- environs/manual/detection.go	2013-09-16 03:24:54 +0000
+++ environs/manual/detection.go	2013-11-18 06:38:24 +0000
@@ -45,10 +45,12 @@
 	return provisioned, nil
 }
 
-// detectSeriesHardwareCharacteristics detects the OS series
-// and hardware characteristics of the remote machine by
-// connecting to the machine and executing a bash script.
-func detectSeriesAndHardwareCharacteristics(sshHost string) (hc instance.HardwareCharacteristics, series string, err error) {
+// DetectSeriesAndHardwareCharacteristics detects the OS
+// series and hardware characteristics of the remote machine
+// by connecting to the machine and executing a bash script.
+//
+// The sshHost argument must be a hostname of the form [user@]host.
+func DetectSeriesAndHardwareCharacteristics(sshHost string) (hc instance.HardwareCharacteristics, series string, err error) {
 	logger.Infof("Detecting series and characteristics on %s", sshHost)
 	cmd := sshCommand(sshHost, "bash")
 	cmd.Stdin = bytes.NewBufferString(detectionScript)

=== modified file 'environs/manual/detection_test.go'
--- environs/manual/detection_test.go	2013-09-20 04:41:12 +0000
+++ environs/manual/detection_test.go	2013-11-18 06:38:24 +0000
@@ -26,14 +26,14 @@
 		"processor: 0",
 	}, "\n")
 	defer installFakeSSH(c, detectionScript, response, 0)()
-	_, series, err := detectSeriesAndHardwareCharacteristics("whatever")
+	_, series, err := DetectSeriesAndHardwareCharacteristics("whatever")
 	c.Assert(err, gc.IsNil)
 	c.Assert(series, gc.Equals, "edgy")
 }
 
 func (s *detectionSuite) TestDetectionError(c *gc.C) {
 	defer installFakeSSH(c, detectionScript, "oh noes", 33)()
-	_, _, err := detectSeriesAndHardwareCharacteristics("whatever")
+	_, _, err := DetectSeriesAndHardwareCharacteristics("whatever")
 	c.Assert(err, gc.ErrorMatches, "exit status 33 \\(oh noes\\)")
 }
 
@@ -93,7 +93,7 @@
 		c.Logf("test %d: %s", i, test.summary)
 		scriptResponse := strings.Join(test.scriptResponse, "\n")
 		defer installFakeSSH(c, detectionScript, scriptResponse, 0)()
-		hc, _, err := detectSeriesAndHardwareCharacteristics("hostname")
+		hc, _, err := DetectSeriesAndHardwareCharacteristics("hostname")
 		c.Assert(err, gc.IsNil)
 		c.Assert(hc.String(), gc.Equals, test.expectedHc)
 	}

=== renamed file 'environs/manual/fakessh_test.go' => 'environs/manual/fakessh.go'
--- environs/manual/fakessh_test.go	2013-10-21 21:49:04 +0000
+++ environs/manual/fakessh.go	2013-11-18 06:38:24 +0000
@@ -67,29 +67,13 @@
 	return testbase.PatchEnvironment("PATH", fakebin+":"+os.Getenv("PATH"))
 }
 
-// fakeSSH wraps the invocation of installFakeSSH based on the parameters.
-type fakeSSH struct {
-	series string
-	arch   string
-
-	// exit code for the machine agent provisioning script.
-	provisionAgentExitCode int
-
-	// there are conditions other than error in the above
-	// that might cause provisioning to not go ahead, such
-	// as tools being missing.
-	skipProvisionAgent bool
-}
-
-// install installs fake SSH commands, which will respond to
-// manual provisioning/bootstrapping commands with the specified
-// output and exit codes.
-func (r fakeSSH) install(c *gc.C) testbase.Restorer {
-	series := r.series
+// installDetectionFakeSSH installs a fake SSH command, which will respond
+// to the series/hardware detection script with the specified
+// series/arch.
+func installDetectionFakeSSH(c *gc.C, series, arch string) testbase.Restorer {
 	if series == "" {
 		series = "precise"
 	}
-	arch := r.arch
 	if arch == "" {
 		arch = "amd64"
 	}
@@ -99,14 +83,41 @@
 		"MemTotal: 4096 kB",
 		"processor: 0",
 	}, "\n")
+	return installFakeSSH(c, detectionScript, detectionoutput, 0)
+}
+
+// FakeSSH wraps the invocation of installFakeSSH based on the parameters.
+type fakeSSH struct {
+	Series string
+	Arch   string
+
+	// exit code for the machine agent provisioning script.
+	ProvisionAgentExitCode int
+
+	// there are conditions other than error in the above
+	// that might cause provisioning to not go ahead, such
+	// as tools being missing.
+	SkipProvisionAgent bool
+
+	// detection will be skipped if the series/hardware were
+	// detected ahead of time.
+	SkipDetection bool
+}
+
+// install installs fake SSH commands, which will respond to
+// manual provisioning/bootstrapping commands with the specified
+// output and exit codes.
+func (r fakeSSH) install(c *gc.C) testbase.Restorer {
 	var restore testbase.Restorer
 	add := func(input string, output interface{}, rc int) {
 		restore = restore.Add(installFakeSSH(c, input, output, rc))
 	}
-	if !r.skipProvisionAgent {
-		add("", nil, r.provisionAgentExitCode)
-	}
-	add(detectionScript, detectionoutput, 0)
+	if !r.SkipProvisionAgent {
+		add("", nil, r.ProvisionAgentExitCode)
+	}
+	if !r.SkipDetection {
+		restore.Add(installDetectionFakeSSH(c, r.Series, r.Arch))
+	}
 	add("", nil, 0) // checkProvisioned
 	return restore
 }

=== modified file 'environs/manual/provisioner.go'
--- environs/manual/provisioner.go	2013-11-14 08:27:15 +0000
+++ environs/manual/provisioner.go	2013-11-18 06:38:24 +0000
@@ -137,7 +137,7 @@
 		return "", "", "", ErrProvisioned
 	}
 
-	hc, series, err := detectSeriesAndHardwareCharacteristics(host)
+	hc, series, err := DetectSeriesAndHardwareCharacteristics(host)
 	if err != nil {
 		err = fmt.Errorf("error detecting hardware characteristics: %v", err)
 		return "", "", "", err

=== modified file 'environs/manual/provisioner_test.go'
--- environs/manual/provisioner_test.go	2013-11-08 02:52:25 +0000
+++ environs/manual/provisioner_test.go	2013-11-18 06:38:24 +0000
@@ -42,7 +42,7 @@
 
 	envtesting.RemoveTools(c, s.Conn.Environ.Storage())
 	defer fakeSSH{
-		series: series, arch: arch, skipProvisionAgent: true,
+		Series: series, Arch: arch, SkipProvisionAgent: true,
 	}.install(c).Restore()
 	// Attempt to provision a machine with no tools available, expect it to fail.
 	machineId, err := ProvisionMachine(args)
@@ -58,9 +58,9 @@
 	for i, errorCode := range []int{255, 0} {
 		c.Logf("test %d: code %d", i, errorCode)
 		defer fakeSSH{
-			series: series,
-			arch:   arch,
-			provisionAgentExitCode: errorCode,
+			Series: series,
+			Arch:   arch,
+			ProvisionAgentExitCode: errorCode,
 		}.install(c).Restore()
 		machineId, err = ProvisionMachine(args)
 		if errorCode != 0 {

=== modified file 'environs/simplestreams/simplestreams.go'
--- environs/simplestreams/simplestreams.go	2013-11-05 04:32:17 +0000
+++ environs/simplestreams/simplestreams.go	2013-11-18 06:38:24 +0000
@@ -970,6 +970,7 @@
 	if err != nil {
 		return nil, err
 	}
+	logger.Debugf("metadata: %v", metadata)
 	matches, err := GetLatestMetadata(metadata, cons, indexRef.Source, indexRef.valueParams.FilterFunc)
 	if err != nil {
 		return nil, err

=== modified file 'environs/sync/sync.go'
--- environs/sync/sync.go	2013-10-30 02:28:40 +0000
+++ environs/sync/sync.go	2013-11-18 06:38:24 +0000
@@ -12,6 +12,7 @@
 	"net/http"
 	"os"
 	"path/filepath"
+	"strings"
 
 	"launchpad.net/loggo"
 
@@ -138,10 +139,14 @@
 
 // selectSourceStorage returns a storage reader based on the source setting.
 func selectSourceStorage(syncContext *SyncContext) (storage.StorageReader, error) {
-	if syncContext.Source == "" {
-		return httpstorage.NewHTTPStorageReader(DefaultToolsLocation), nil
-	}
-	return filestorage.NewFileStorageReader(syncContext.Source)
+	source := syncContext.Source
+	if source == "" {
+		source = DefaultToolsLocation
+	}
+	if strings.HasPrefix(source, "http") {
+		return httpstorage.NewHTTPStorageReader(source), nil
+	}
+	return filestorage.NewFileStorageReader(source)
 }
 
 // copyTools copies a set of tools from the source to the target.
@@ -199,6 +204,11 @@
 	return err
 }
 
+// UploadFunc is the type of Upload, which may be
+// reassigned to control the behaviour of tools
+// uploading.
+type UploadFunc func(stor storage.Storage, forceVersion *version.Number, series ...string) (*coretools.Tools, error)
+
 // Upload builds whatever version of launchpad.net/juju-core is in $GOPATH,
 // uploads it to the given storage, and returns a Tools instance describing
 // them. If forceVersion is not nil, the uploaded tools bundle will report
@@ -206,7 +216,9 @@
 // of the built tools will be uploaded for use by machines of those series.
 // Juju tools built for one series do not necessarily run on another, but this
 // func exists only for development use cases.
-func Upload(stor storage.Storage, forceVersion *version.Number, fakeSeries ...string) (*coretools.Tools, error) {
+var Upload UploadFunc = upload
+
+func upload(stor storage.Storage, forceVersion *version.Number, fakeSeries ...string) (*coretools.Tools, error) {
 	// TODO(rog) find binaries from $PATH when not using a development
 	// version of juju within a $GOPATH.
 

=== modified file 'environs/testing/tools.go'
--- environs/testing/tools.go	2013-10-29 22:58:43 +0000
+++ environs/testing/tools.go	2013-11-18 06:38:24 +0000
@@ -16,6 +16,7 @@
 	"launchpad.net/juju-core/environs/config"
 	"launchpad.net/juju-core/environs/simplestreams"
 	"launchpad.net/juju-core/environs/storage"
+	"launchpad.net/juju-core/environs/sync"
 	envtools "launchpad.net/juju-core/environs/tools"
 	"launchpad.net/juju-core/log"
 	"launchpad.net/juju-core/state"
@@ -29,16 +30,20 @@
 // ToolsFixture is used as a fixture to stub out the default tools URL so we
 // don't hit the real internet during tests.
 type ToolsFixture struct {
-	origDefaultURL string
-	DefaultBaseURL string
+	origDefaultURL          string
+	origDefaultSyncLocation string
+	DefaultBaseURL          string
 }
 
 func (s *ToolsFixture) SetUpTest(c *gc.C) {
 	s.origDefaultURL = envtools.DefaultBaseURL
+	s.origDefaultSyncLocation = sync.DefaultToolsLocation
 	envtools.DefaultBaseURL = s.DefaultBaseURL
+	sync.DefaultToolsLocation = c.MkDir() // stop sync from going to s3
 }
 
 func (s *ToolsFixture) TearDownTest(c *gc.C) {
+	sync.DefaultToolsLocation = sync.DefaultToolsLocation
 	envtools.DefaultBaseURL = s.origDefaultURL
 }
 

=== modified file 'environs/tools/storage.go'
--- environs/tools/storage.go	2013-09-27 02:31:45 +0000
+++ environs/tools/storage.go	2013-11-18 06:38:24 +0000
@@ -47,6 +47,7 @@
 		var t coretools.Tools
 		vers := name[len(toolPrefix) : len(name)-len(toolSuffix)]
 		if t.Version, err = version.ParseBinary(vers); err != nil {
+			logger.Debugf("failed to parse version %q: %v", vers, err)
 			continue
 		}
 		foundAnyTools = true

=== modified file 'environs/tools/tools.go'
--- environs/tools/tools.go	2013-10-08 06:17:07 +0000
+++ environs/tools/tools.go	2013-11-18 06:38:24 +0000
@@ -153,6 +153,7 @@
 type BootstrapToolsParams struct {
 	Version    *version.Number
 	Arch       *string
+	Series     string
 	AllowRetry bool
 }
 
@@ -164,7 +165,7 @@
 	cfg := cloudInst.Config()
 	cliVersion := version.Current.Number
 	filter := coretools.Filter{
-		Series: cfg.DefaultSeries(),
+		Series: params.Series,
 		Arch:   stringOrEmpty(params.Arch),
 	}
 	if params.Version != nil {

=== modified file 'environs/tools/tools_test.go'
--- environs/tools/tools_test.go	2013-11-05 04:32:17 +0000
+++ environs/tools/tools_test.go	2013-11-18 06:38:24 +0000
@@ -291,8 +291,7 @@
 	for i, test := range envtesting.BootstrapToolsTests {
 		c.Logf("\ntest %d: %s", i, test.Info)
 		attrs := map[string]interface{}{
-			"development":    test.Development,
-			"default-series": test.DefaultSeries,
+			"development": test.Development,
 		}
 		var agentVersion *version.Number
 		if test.AgentVersion != version.Zero {
@@ -305,6 +304,7 @@
 
 		params := envtools.BootstrapToolsParams{
 			Version: agentVersion,
+			Series:  test.DefaultSeries,
 			Arch:    &test.Arch,
 		}
 		actual, err := envtools.FindBootstrapTools(s.env, params)

=== modified file 'provider/azure/environ.go'
--- provider/azure/environ.go	2013-11-01 06:20:19 +0000
+++ provider/azure/environ.go	2013-11-18 06:38:24 +0000
@@ -231,7 +231,7 @@
 }
 
 // Bootstrap is specified in the Environ interface.
-func (env *azureEnviron) Bootstrap(cons constraints.Value, possibleTools tools.List) (err error) {
+func (env *azureEnviron) Bootstrap(cons constraints.Value) (err error) {
 	// The creation of the affinity group and the virtual network is specific to the Azure provider.
 	err = env.createAffinityGroup()
 	if err != nil {
@@ -253,7 +253,7 @@
 			env.deleteVirtualNetwork()
 		}
 	}()
-	err = common.Bootstrap(env, cons, possibleTools)
+	err = common.Bootstrap(env, cons)
 	return err
 }
 

=== modified file 'provider/azure/environ_test.go'
--- provider/azure/environ_test.go	2013-11-01 06:20:19 +0000
+++ provider/azure/environ_test.go	2013-11-18 06:38:24 +0000
@@ -21,6 +21,7 @@
 
 	"launchpad.net/juju-core/constraints"
 	"launchpad.net/juju-core/environs"
+	"launchpad.net/juju-core/environs/bootstrap"
 	"launchpad.net/juju-core/environs/config"
 	"launchpad.net/juju-core/environs/imagemetadata"
 	"launchpad.net/juju-core/environs/simplestreams"
@@ -28,7 +29,6 @@
 	envtesting "launchpad.net/juju-core/environs/testing"
 	"launchpad.net/juju-core/environs/tools"
 	"launchpad.net/juju-core/instance"
-	"launchpad.net/juju-core/provider/common"
 	"launchpad.net/juju-core/testing"
 	jc "launchpad.net/juju-core/testing/checkers"
 )
@@ -456,9 +456,9 @@
 	}})
 	env := makeEnviron(c)
 	s.setDummyStorage(c, env)
-	err := common.SaveState(
+	err := bootstrap.SaveState(
 		env.Storage(),
-		&common.BootstrapState{StateInstances: []instance.Id{instance.Id(instanceID)}})
+		&bootstrap.BootstrapState{StateInstances: []instance.Id{instance.Id(instanceID)}})
 	c.Assert(err, gc.IsNil)
 
 	stateInfo, apiInfo, err := env.StateInfo()
@@ -787,9 +787,9 @@
 	env := makeEnviron(c)
 	s.setDummyStorage(c, env)
 	// Populate storage.
-	err := common.SaveState(
+	err := bootstrap.SaveState(
 		env.Storage(),
-		&common.BootstrapState{StateInstances: []instance.Id{instance.Id("test-id")}})
+		&bootstrap.BootstrapState{StateInstances: []instance.Id{instance.Id("test-id")}})
 	c.Assert(err, gc.IsNil)
 	responses := []gwacl.DispatcherResponse{
 		gwacl.NewDispatcherResponse(nil, http.StatusBadRequest, nil),
@@ -808,9 +808,9 @@
 	env := makeEnviron(c)
 	s.setDummyStorage(c, env)
 	// Populate storage.
-	err := common.SaveState(
+	err := bootstrap.SaveState(
 		env.Storage(),
-		&common.BootstrapState{StateInstances: []instance.Id{instance.Id("test-id")}})
+		&bootstrap.BootstrapState{StateInstances: []instance.Id{instance.Id("test-id")}})
 	c.Assert(err, gc.IsNil)
 	services := []gwacl.HostedServiceDescriptor{}
 	responses := getAzureServiceListResponse(c, services)

=== modified file 'provider/common/bootstrap.go'
--- provider/common/bootstrap.go	2013-10-02 19:30:07 +0000
+++ provider/common/bootstrap.go	2013-11-18 06:38:24 +0000
@@ -10,6 +10,7 @@
 
 	"launchpad.net/juju-core/constraints"
 	"launchpad.net/juju-core/environs"
+	"launchpad.net/juju-core/environs/bootstrap"
 	"launchpad.net/juju-core/instance"
 	coretools "launchpad.net/juju-core/tools"
 )
@@ -19,7 +20,7 @@
 // Bootstrap is a common implementation of the Bootstrap method defined on
 // environs.Environ; we strongly recommend that this implementation be used
 // when writing a new provider.
-func Bootstrap(env environs.Environ, cons constraints.Value, possibleTools coretools.List) error {
+func Bootstrap(env environs.Environ, cons constraints.Value) error {
 	// TODO make safe in the case of racing Bootstraps
 	// If two Bootstraps are called concurrently, there's
 	// no way to make sure that only one succeeds.
@@ -27,12 +28,18 @@
 	// Create an empty bootstrap state file so we can get its URL.
 	// It will be updated with the instance id and hardware characteristics
 	// after the bootstrap instance is started.
-	stateFileURL, err := CreateStateFile(env.Storage())
+	stateFileURL, err := bootstrap.CreateStateFile(env.Storage())
 	if err != nil {
 		return err
 	}
 	machineConfig := environs.NewBootstrapMachineConfig(stateFileURL)
-	inst, hw, err := env.StartInstance(cons, possibleTools, machineConfig)
+
+	selectedTools, err := EnsureBootstrapTools(env, env.Config().DefaultSeries(), cons.Arch)
+	if err != nil {
+		return err
+	}
+
+	inst, hw, err := env.StartInstance(cons, selectedTools, machineConfig)
 	if err != nil {
 		return fmt.Errorf("cannot start bootstrap instance: %v", err)
 	}
@@ -40,9 +47,9 @@
 	if hw != nil {
 		characteristics = []instance.HardwareCharacteristics{*hw}
 	}
-	err = SaveState(
+	err = bootstrap.SaveState(
 		env.Storage(),
-		&BootstrapState{
+		&bootstrap.BootstrapState{
 			StateInstances:  []instance.Id{inst.Id()},
 			Characteristics: characteristics,
 		})
@@ -56,3 +63,29 @@
 	}
 	return nil
 }
+
+// EnsureBootstrapTools finds tools, syncing with an external tools source as
+// necessary; it then selects the newest tools to bootstrap with, and sets
+// agent-version.
+func EnsureBootstrapTools(env environs.Environ, series string, arch *string) (coretools.List, error) {
+	possibleTools, err := bootstrap.EnsureToolsAvailability(env, series, arch)
+	if err != nil {
+		return nil, err
+	}
+	return bootstrap.SetBootstrapTools(env, possibleTools)
+}
+
+// EnsureNotBootstrapped returns null if the environment is not bootstrapped,
+// and an error if it is or if the function was not able to tell.
+func EnsureNotBootstrapped(env environs.Environ) error {
+	_, err := bootstrap.LoadState(env.Storage())
+	// If there is no error loading the bootstrap state, then we are
+	// bootstrapped.
+	if err == nil {
+		return fmt.Errorf("environment is already bootstrapped")
+	}
+	if err == environs.ErrNotBootstrapped {
+		return nil
+	}
+	return err
+}

=== modified file 'provider/common/bootstrap_test.go'
--- provider/common/bootstrap_test.go	2013-10-02 00:29:29 +0000
+++ provider/common/bootstrap_test.go	2013-11-18 06:38:24 +0000
@@ -11,34 +11,79 @@
 
 	"launchpad.net/juju-core/constraints"
 	"launchpad.net/juju-core/environs"
+	"launchpad.net/juju-core/environs/bootstrap"
 	"launchpad.net/juju-core/environs/cloudinit"
+	"launchpad.net/juju-core/environs/config"
+	"launchpad.net/juju-core/environs/storage"
+	envtesting "launchpad.net/juju-core/environs/testing"
 	"launchpad.net/juju-core/instance"
 	"launchpad.net/juju-core/provider/common"
+	coretesting "launchpad.net/juju-core/testing"
 	jc "launchpad.net/juju-core/testing/checkers"
 	"launchpad.net/juju-core/testing/testbase"
 	"launchpad.net/juju-core/tools"
-	"launchpad.net/juju-core/version"
 )
 
 type BootstrapSuite struct {
 	testbase.LoggingSuite
+	envtesting.ToolsFixture
 }
 
 var _ = gc.Suite(&BootstrapSuite{})
 
+type cleaner interface {
+	AddCleanup(testbase.CleanupFunc)
+}
+
+func (s *BootstrapSuite) SetUpTest(c *gc.C) {
+	s.LoggingSuite.SetUpTest(c)
+	s.ToolsFixture.SetUpTest(c)
+}
+
+func (s *BootstrapSuite) TearDownTest(c *gc.C) {
+	s.ToolsFixture.TearDownTest(c)
+	s.LoggingSuite.TearDownTest(c)
+}
+
+func newStorage(suite cleaner, c *gc.C) storage.Storage {
+	closer, stor, _ := envtesting.CreateLocalTestStorage(c)
+	suite.AddCleanup(func(*gc.C) { closer.Close() })
+	envtesting.UploadFakeTools(c, stor)
+	return stor
+}
+
+func minimalConfig(c *gc.C) *config.Config {
+	attrs := map[string]interface{}{
+		"name":           "whatever",
+		"type":           "anything, really",
+		"ca-cert":        coretesting.CACert,
+		"ca-private-key": coretesting.CAKey,
+	}
+	cfg, err := config.New(config.UseDefaults, attrs)
+	c.Assert(err, gc.IsNil)
+	return cfg
+}
+
+func configGetter(c *gc.C) configFunc {
+	cfg := minimalConfig(c)
+	return func() *config.Config { return cfg }
+}
+
 func (s *BootstrapSuite) TestCannotWriteStateFile(c *gc.C) {
-	brokenStorage := &mockStorage{putErr: fmt.Errorf("noes!")}
+	brokenStorage := &mockStorage{
+		Storage: newStorage(s, c),
+		putErr:  fmt.Errorf("noes!"),
+	}
 	env := &mockEnviron{storage: brokenStorage}
-	err := common.Bootstrap(env, constraints.Value{}, nil)
+	err := common.Bootstrap(env, constraints.Value{})
 	c.Assert(err, gc.ErrorMatches, "cannot create initial state file: noes!")
 }
 
 func (s *BootstrapSuite) TestCannotStartInstance(c *gc.C) {
 	stor := newStorage(s, c)
-	checkURL, err := stor.URL(common.StateFile)
+	checkURL, err := stor.URL(bootstrap.StateFile)
 	c.Assert(err, gc.IsNil)
 	checkCons := constraints.MustParse("mem=8G")
-	checkTools := tools.List{&tools.Tools{Version: version.Current}}
 
 	startInstance := func(
 		cons constraints.Value, possibleTools tools.List, mcfg *cloudinit.MachineConfig,
@@ -46,7 +91,6 @@
 		instance.Instance, *instance.HardwareCharacteristics, error,
 	) {
 		c.Assert(cons, gc.DeepEquals, checkCons)
-		c.Assert(possibleTools, gc.DeepEquals, checkTools)
 		c.Assert(mcfg, gc.DeepEquals, environs.NewBootstrapMachineConfig(checkURL))
 		return nil, nil, fmt.Errorf("meh, not started")
 	}
@@ -54,9 +98,10 @@
 	env := &mockEnviron{
 		storage:       stor,
 		startInstance: startInstance,
+		config:        configGetter(c),
 	}
 
-	err = common.Bootstrap(env, checkCons, checkTools)
+	err = common.Bootstrap(env, checkCons)
 	c.Assert(err, gc.ErrorMatches, "cannot start bootstrap instance: meh, not started")
 }
 
@@ -83,9 +128,10 @@
 		storage:       stor,
 		startInstance: startInstance,
 		stopInstances: stopInstances,
+		config:        configGetter(c),
 	}
 
-	err := common.Bootstrap(env, constraints.Value{}, nil)
+	err := common.Bootstrap(env, constraints.Value{})
 	c.Assert(err, gc.ErrorMatches, "cannot save state: suddenly a wild blah")
 	c.Assert(stopped, gc.HasLen, 1)
 	c.Assert(stopped[0].Id(), gc.Equals, instance.Id("i-blah"))
@@ -118,9 +164,10 @@
 		storage:       stor,
 		startInstance: startInstance,
 		stopInstances: stopInstances,
+		config:        configGetter(c),
 	}
 
-	err := common.Bootstrap(env, constraints.Value{}, nil)
+	err := common.Bootstrap(env, constraints.Value{})
 	c.Assert(err, gc.ErrorMatches, "cannot save state: suddenly a wild blah")
 	c.Assert(stopped, gc.HasLen, 1)
 	c.Assert(stopped[0].Id(), gc.Equals, instance.Id("i-blah"))
@@ -144,16 +191,23 @@
 		return &mockInstance{id: checkInstanceId}, &checkHardware, nil
 	}
 
+	var getConfigCalled int
+	getConfig := func() *config.Config {
+		getConfigCalled++
+		return minimalConfig(c)
+	}
+
 	env := &mockEnviron{
 		storage:       stor,
 		startInstance: startInstance,
+		config:        getConfig,
 	}
-	err := common.Bootstrap(env, constraints.Value{}, nil)
+	err := common.Bootstrap(env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
 
-	savedState, err := common.LoadStateFromURL(checkURL)
+	savedState, err := bootstrap.LoadStateFromURL(checkURL)
 	c.Assert(err, gc.IsNil)
-	c.Assert(savedState, gc.DeepEquals, &common.BootstrapState{
+	c.Assert(savedState, gc.DeepEquals, &bootstrap.BootstrapState{
 		StateInstances:  []instance.Id{instance.Id(checkInstanceId)},
 		Characteristics: []instance.HardwareCharacteristics{checkHardware},
 	})

=== modified file 'provider/common/mock_test.go'
--- provider/common/mock_test.go	2013-10-02 00:29:29 +0000
+++ provider/common/mock_test.go	2013-11-18 06:38:24 +0000
@@ -9,6 +9,8 @@
 	"launchpad.net/juju-core/constraints"
 	"launchpad.net/juju-core/environs"
 	"launchpad.net/juju-core/environs/cloudinit"
+	"launchpad.net/juju-core/environs/config"
+	"launchpad.net/juju-core/environs/simplestreams"
 	"launchpad.net/juju-core/environs/storage"
 	"launchpad.net/juju-core/instance"
 	"launchpad.net/juju-core/tools"
@@ -17,12 +19,18 @@
 type allInstancesFunc func() ([]instance.Instance, error)
 type startInstanceFunc func(constraints.Value, tools.List, *cloudinit.MachineConfig) (instance.Instance, *instance.HardwareCharacteristics, error)
 type stopInstancesFunc func([]instance.Instance) error
+type getToolsSourcesFunc func() ([]simplestreams.DataSource, error)
+type configFunc func() *config.Config
+type setConfigFunc func(*config.Config) error
 
 type mockEnviron struct {
 	storage          storage.Storage
 	allInstances     allInstancesFunc
 	startInstance    startInstanceFunc
 	stopInstances    stopInstancesFunc
+	getToolsSources  getToolsSourcesFunc
+	config           configFunc
+	setConfig        setConfigFunc
 	environs.Environ // stub out other methods with panics
 }
 
@@ -49,6 +57,25 @@
 	return env.stopInstances(instances)
 }
 
+func (env *mockEnviron) Config() *config.Config {
+	return env.config()
+}
+
+func (env *mockEnviron) SetConfig(cfg *config.Config) error {
+	if env.setConfig != nil {
+		return env.setConfig(cfg)
+	}
+	return nil
+}
+
+func (env *mockEnviron) GetToolsSources() ([]simplestreams.DataSource, error) {
+	if env.getToolsSources != nil {
+		return env.getToolsSources()
+	}
+	datasource := storage.NewStorageSimpleStreamsDataSource(env.Storage(), storage.BaseToolsPath)
+	return []simplestreams.DataSource{datasource}, nil
+}
+
 type mockInstance struct {
 	id                string
 	instance.Instance // stub out other methods with panics

=== modified file 'provider/common/state.go'
--- provider/common/state.go	2013-10-01 12:03:33 +0000
+++ provider/common/state.go	2013-11-18 06:38:24 +0000
@@ -4,103 +4,18 @@
 package common
 
 import (
-	"bytes"
 	"errors"
 	"fmt"
-	"io"
-	"io/ioutil"
-	"net/http"
-
-	"launchpad.net/goyaml"
 
 	"launchpad.net/juju-core/environs"
+	"launchpad.net/juju-core/environs/bootstrap"
 	"launchpad.net/juju-core/environs/config"
-	"launchpad.net/juju-core/environs/storage"
-	coreerrors "launchpad.net/juju-core/errors"
 	"launchpad.net/juju-core/instance"
 	"launchpad.net/juju-core/log"
 	"launchpad.net/juju-core/state"
 	"launchpad.net/juju-core/state/api"
 )
 
-// StateFile is the name of the file where the provider's state is stored.
-const StateFile = "provider-state"
-
-// BootstrapState is the state information that is stored in StateFile.
-//
-// Individual providers may define their own state structures instead of
-// this one, and use their own code for loading and saving those, but this is
-// the definition that most practically useful providers share unchanged.
-type BootstrapState struct {
-	// StateInstances are the state servers.
-	StateInstances []instance.Id `yaml:"state-instances"`
-	// Characteristics reflect the hardware each state server is running on.
-	// This is used at bootstrap time so the state server knows what hardware it has.
-	// The state *may* be updated later without this information, but by then it's
-	// served it's purpose.
-	Characteristics []instance.HardwareCharacteristics `yaml:"characteristics,omitempty"`
-}
-
-// putState writes the given data to the state file on the given storage.
-// The file's name is as defined in StateFile.
-func putState(storage storage.StorageWriter, data []byte) error {
-	return storage.Put(StateFile, bytes.NewBuffer(data), int64(len(data)))
-}
-
-// CreateStateFile creates an empty state file on the given storage, and
-// returns its URL.
-func CreateStateFile(storage storage.Storage) (string, error) {
-	err := putState(storage, []byte{})
-	if err != nil {
-		return "", fmt.Errorf("cannot create initial state file: %v", err)
-	}
-	return storage.URL(StateFile)
-}
-
-// SaveState writes the given state to the given storage.
-func SaveState(storage storage.StorageWriter, state *BootstrapState) error {
-	data, err := goyaml.Marshal(state)
-	if err != nil {
-		return err
-	}
-	return putState(storage, data)
-}
-
-// LoadStateFromURL reads state from the given URL.
-func LoadStateFromURL(url string) (*BootstrapState, error) {
-	resp, err := http.Get(url)
-	if err != nil {
-		return nil, err
-	}
-	return loadState(resp.Body)
-}
-
-// LoadState reads state from the given storage.
-func LoadState(stor storage.StorageReader) (*BootstrapState, error) {
-	r, err := storage.Get(stor, StateFile)
-	if err != nil {
-		if coreerrors.IsNotFoundError(err) {
-			return nil, environs.ErrNotBootstrapped
-		}
-		return nil, err
-	}
-	return loadState(r)
-}
-
-func loadState(r io.ReadCloser) (*BootstrapState, error) {
-	defer r.Close()
-	data, err := ioutil.ReadAll(r)
-	if err != nil {
-		return nil, fmt.Errorf("error reading %q: %v", StateFile, err)
-	}
-	var state BootstrapState
-	err = goyaml.Unmarshal(data, &state)
-	if err != nil {
-		return nil, fmt.Errorf("error unmarshalling %q: %v", StateFile, err)
-	}
-	return &state, nil
-}
-
 // getDNSNames queries and returns the DNS names for the given instances,
 // ignoring nil instances or ones without DNS names.
 func getDNSNames(instances []instance.Instance) []string {
@@ -147,7 +62,7 @@
 // StateInfo is a reusable implementation of Environ.StateInfo, available to
 // providers that also use the other functionality from this file.
 func StateInfo(env environs.Environ) (*state.Info, *api.Info, error) {
-	st, err := LoadState(env.Storage())
+	st, err := bootstrap.LoadState(env.Storage())
 	if err != nil {
 		return nil, nil, err
 	}

=== modified file 'provider/common/state_test.go'
--- provider/common/state_test.go	2013-10-02 10:39:12 +0000
+++ provider/common/state_test.go	2013-11-18 06:38:24 +0000
@@ -4,16 +4,9 @@
 package common_test
 
 import (
-	"bytes"
-	"io/ioutil"
-
 	gc "launchpad.net/gocheck"
-	"launchpad.net/goyaml"
 
-	"launchpad.net/juju-core/environs"
 	"launchpad.net/juju-core/environs/config"
-	"launchpad.net/juju-core/environs/storage"
-	envtesting "launchpad.net/juju-core/environs/testing"
 	"launchpad.net/juju-core/instance"
 	"launchpad.net/juju-core/provider/common"
 	"launchpad.net/juju-core/testing"
@@ -26,102 +19,6 @@
 
 var _ = gc.Suite(&StateSuite{})
 
-type cleaner interface {
-	AddCleanup(testbase.CleanupFunc)
-}
-
-func newStorage(suite cleaner, c *gc.C) storage.Storage {
-	closer, stor, _ := envtesting.CreateLocalTestStorage(c)
-	suite.AddCleanup(func(*gc.C) { closer.Close() })
-	return stor
-}
-
-func (suite *StateSuite) TestCreateStateFileWritesEmptyStateFile(c *gc.C) {
-	stor := newStorage(suite, c)
-
-	url, err := common.CreateStateFile(stor)
-	c.Assert(err, gc.IsNil)
-
-	reader, err := storage.Get(stor, common.StateFile)
-	c.Assert(err, gc.IsNil)
-	data, err := ioutil.ReadAll(reader)
-	c.Assert(err, gc.IsNil)
-	c.Check(string(data), gc.Equals, "")
-	c.Assert(url, gc.NotNil)
-	expectedURL, err := stor.URL(common.StateFile)
-	c.Assert(err, gc.IsNil)
-	c.Check(url, gc.Equals, expectedURL)
-}
-
-func (suite *StateSuite) TestSaveStateWritesStateFile(c *gc.C) {
-	stor := newStorage(suite, c)
-	arch := "amd64"
-	state := common.BootstrapState{
-		StateInstances:  []instance.Id{instance.Id("an-instance-id")},
-		Characteristics: []instance.HardwareCharacteristics{{Arch: &arch}}}
-	marshaledState, err := goyaml.Marshal(state)
-	c.Assert(err, gc.IsNil)
-
-	err = common.SaveState(stor, &state)
-	c.Assert(err, gc.IsNil)
-
-	loadedState, err := storage.Get(stor, common.StateFile)
-	c.Assert(err, gc.IsNil)
-	content, err := ioutil.ReadAll(loadedState)
-	c.Assert(err, gc.IsNil)
-	c.Check(content, gc.DeepEquals, marshaledState)
-}
-
-func (suite *StateSuite) setUpSavedState(c *gc.C, stor storage.Storage) common.BootstrapState {
-	arch := "amd64"
-	state := common.BootstrapState{
-		StateInstances:  []instance.Id{instance.Id("an-instance-id")},
-		Characteristics: []instance.HardwareCharacteristics{{Arch: &arch}}}
-	content, err := goyaml.Marshal(state)
-	c.Assert(err, gc.IsNil)
-	err = stor.Put(common.StateFile, ioutil.NopCloser(bytes.NewReader(content)), int64(len(content)))
-	c.Assert(err, gc.IsNil)
-	return state
-}
-
-func (suite *StateSuite) TestLoadStateReadsStateFile(c *gc.C) {
-	storage := newStorage(suite, c)
-	state := suite.setUpSavedState(c, storage)
-	storedState, err := common.LoadState(storage)
-	c.Assert(err, gc.IsNil)
-	c.Check(*storedState, gc.DeepEquals, state)
-}
-
-func (suite *StateSuite) TestLoadStateFromURLReadsStateFile(c *gc.C) {
-	stor := newStorage(suite, c)
-	state := suite.setUpSavedState(c, stor)
-	url, err := stor.URL(common.StateFile)
-	c.Assert(err, gc.IsNil)
-	storedState, err := common.LoadStateFromURL(url)
-	c.Assert(err, gc.IsNil)
-	c.Check(*storedState, gc.DeepEquals, state)
-}
-
-func (suite *StateSuite) TestLoadStateMissingFile(c *gc.C) {
-	stor := newStorage(suite, c)
-	_, err := common.LoadState(stor)
-	c.Check(err, gc.Equals, environs.ErrNotBootstrapped)
-}
-
-func (suite *StateSuite) TestLoadStateIntegratesWithSaveState(c *gc.C) {
-	storage := newStorage(suite, c)
-	arch := "amd64"
-	state := common.BootstrapState{
-		StateInstances:  []instance.Id{instance.Id("an-instance-id")},
-		Characteristics: []instance.HardwareCharacteristics{{Arch: &arch}}}
-	err := common.SaveState(storage, &state)
-	c.Assert(err, gc.IsNil)
-	storedState, err := common.LoadState(storage)
-	c.Assert(err, gc.IsNil)
-
-	c.Check(*storedState, gc.DeepEquals, state)
-}
-
 func (suite *StateSuite) TestGetDNSNamesAcceptsNil(c *gc.C) {
 	result := common.GetDNSNames(nil)
 	c.Check(result, gc.DeepEquals, []string{})

=== modified file 'provider/dummy/environs.go'
--- provider/dummy/environs.go	2013-11-07 09:09:55 +0000
+++ provider/dummy/environs.go	2013-11-18 06:38:24 +0000
@@ -37,6 +37,7 @@
 
 	"launchpad.net/juju-core/constraints"
 	"launchpad.net/juju-core/environs"
+	"launchpad.net/juju-core/environs/bootstrap"
 	"launchpad.net/juju-core/environs/cloudinit"
 	"launchpad.net/juju-core/environs/config"
 	"launchpad.net/juju-core/environs/imagemetadata"
@@ -520,7 +521,12 @@
 		storage.NewStorageSimpleStreamsDataSource(e.Storage(), storage.BaseToolsPath)}, nil
 }
 
-func (e *environ) Bootstrap(cons constraints.Value, possibleTools coretools.List) error {
+func (e *environ) Bootstrap(cons constraints.Value) error {
+	selectedTools, err := common.EnsureBootstrapTools(e, e.Config().DefaultSeries(), cons.Arch)
+	if err != nil {
+		return err
+	}
+
 	defer delay()
 	if err := e.checkBroken("Bootstrap"); err != nil {
 		return err
@@ -533,7 +539,7 @@
 		return fmt.Errorf("no CA certificate in environment configuration")
 	}
 
-	logger.Infof("would pick tools from %s", possibleTools)
+	logger.Infof("would pick tools from %s", selectedTools)
 	cfg, err := environs.BootstrapConfig(e.Config())
 	if err != nil {
 		return fmt.Errorf("cannot make bootstrap config: %v", err)
@@ -552,7 +558,7 @@
 	// we need to release the mutex for the save state to work, so regain
 	// it after the call.
 	estate.mu.Unlock()
-	if err := common.SaveState(e.Storage(), &common.BootstrapState{StateInstances: []instance.Id{"localhost"}}); err != nil {
+	if err := bootstrap.SaveState(e.Storage(), &bootstrap.BootstrapState{StateInstances: []instance.Id{"localhost"}}); err != nil {
 		logger.Errorf("failed to save state instances: %v", err)
 		estate.mu.Lock() // otherwise defered unlock will fail
 		return err

=== modified file 'provider/ec2/ec2.go'
--- provider/ec2/ec2.go	2013-11-01 06:20:19 +0000
+++ provider/ec2/ec2.go	2013-11-18 06:38:24 +0000
@@ -305,8 +305,8 @@
 	return stor
 }
 
-func (e *environ) Bootstrap(cons constraints.Value, possibleTools tools.List) error {
-	return common.Bootstrap(e, cons, possibleTools)
+func (e *environ) Bootstrap(cons constraints.Value) error {
+	return common.Bootstrap(e, cons)
 }
 
 func (e *environ) StateInfo() (*state.Info, *api.Info, error) {

=== modified file 'provider/ec2/local_test.go'
--- provider/ec2/local_test.go	2013-11-01 06:20:19 +0000
+++ provider/ec2/local_test.go	2013-11-18 06:38:24 +0000
@@ -28,7 +28,6 @@
 	"launchpad.net/juju-core/environs/tools"
 	"launchpad.net/juju-core/instance"
 	"launchpad.net/juju-core/juju/testing"
-	"launchpad.net/juju-core/provider/common"
 	"launchpad.net/juju-core/provider/ec2"
 	coretesting "launchpad.net/juju-core/testing"
 	jc "launchpad.net/juju-core/testing/checkers"
@@ -210,7 +209,7 @@
 	c.Assert(err, gc.IsNil)
 
 	// check that the state holds the id of the bootstrap machine.
-	bootstrapState, err := common.LoadState(env.Storage())
+	bootstrapState, err := bootstrap.LoadState(env.Storage())
 	c.Assert(err, gc.IsNil)
 	c.Assert(bootstrapState.StateInstances, gc.HasLen, 1)
 
@@ -263,7 +262,7 @@
 	err = env.Destroy()
 	c.Assert(err, gc.IsNil)
 
-	_, err = common.LoadState(env.Storage())
+	_, err = bootstrap.LoadState(env.Storage())
 	c.Assert(err, gc.NotNil)
 }
 

=== modified file 'provider/local/environ.go'
--- provider/local/environ.go	2013-11-11 21:38:30 +0000
+++ provider/local/environ.go	2013-11-18 06:38:24 +0000
@@ -19,6 +19,7 @@
 	"launchpad.net/juju-core/container"
 	"launchpad.net/juju-core/container/lxc"
 	"launchpad.net/juju-core/environs"
+	"launchpad.net/juju-core/environs/bootstrap"
 	"launchpad.net/juju-core/environs/cloudinit"
 	"launchpad.net/juju-core/environs/config"
 	"launchpad.net/juju-core/environs/filestorage"
@@ -95,7 +96,7 @@
 }
 
 // Bootstrap is specified in the Environ interface.
-func (env *localEnviron) Bootstrap(cons constraints.Value, possibleTools tools.List) error {
+func (env *localEnviron) Bootstrap(cons constraints.Value) error {
 	if !env.config.runningAsRoot {
 		return fmt.Errorf("bootstrapping a local environment must be done as root")
 	}
@@ -113,13 +114,19 @@
 
 	// Before we write the agent config file, we need to make sure the
 	// instance is saved in the StateInfo.
-	if err := common.SaveState(env.Storage(), &common.BootstrapState{
+	if err := bootstrap.SaveState(env.Storage(), &bootstrap.BootstrapState{
 		StateInstances: []instance.Id{bootstrapInstanceId},
 	}); err != nil {
 		logger.Errorf("failed to save state instances: %v", err)
 		return err
 	}
 
+	vers := version.Current
+	selectedTools, err := common.EnsureBootstrapTools(env, vers.Series, &vers.Arch)
+	if err != nil {
+		return err
+	}
+
 	// Need to write out the agent file for machine-0 before initializing
 	// state, as as part of that process, it will reset the password in the
 	// agent file.
@@ -132,7 +139,7 @@
 		return err
 	}
 
-	return env.setupLocalMachineAgent(cons, possibleTools)
+	return env.setupLocalMachineAgent(cons, selectedTools)
 }
 
 // StateInfo is specified in the Environ interface.

=== modified file 'provider/maas/environ.go'
--- provider/maas/environ.go	2013-11-04 22:24:51 +0000
+++ provider/maas/environ.go	2013-11-18 06:38:24 +0000
@@ -77,8 +77,8 @@
 }
 
 // Bootstrap is specified in the Environ interface.
-func (env *maasEnviron) Bootstrap(cons constraints.Value, possibleTools tools.List) error {
-	return common.Bootstrap(env, cons, possibleTools)
+func (env *maasEnviron) Bootstrap(cons constraints.Value) error {
+	return common.Bootstrap(env, cons)
 }
 
 // StateInfo is specified in the Environ interface.

=== modified file 'provider/maas/environ_test.go'
--- provider/maas/environ_test.go	2013-11-04 22:24:51 +0000
+++ provider/maas/environ_test.go	2013-11-18 06:38:24 +0000
@@ -26,7 +26,6 @@
 	"launchpad.net/juju-core/errors"
 	"launchpad.net/juju-core/instance"
 	"launchpad.net/juju-core/juju/testing"
-	"launchpad.net/juju-core/provider/common"
 	jc "launchpad.net/juju-core/testing/checkers"
 	"launchpad.net/juju-core/tools"
 	"launchpad.net/juju-core/utils"
@@ -59,7 +58,7 @@
 }
 
 func (suite *environSuite) setupFakeProviderStateFile(c *gc.C) {
-	suite.testMAASObject.TestServer.NewFile(common.StateFile, []byte("test file content"))
+	suite.testMAASObject.TestServer.NewFile(bootstrap.StateFile, []byte("test file content"))
 }
 
 func (suite *environSuite) setupFakeTools(c *gc.C) {
@@ -216,7 +215,7 @@
 
 	// Test the instance id is correctly recorded for the bootstrap node.
 	// Check that the state holds the id of the bootstrap machine.
-	stateData, err := common.LoadState(env.Storage())
+	stateData, err := bootstrap.LoadState(env.Storage())
 	c.Assert(err, gc.IsNil)
 	c.Assert(stateData.StateInstances, gc.HasLen, 1)
 	insts, err := env.AllInstances()
@@ -370,9 +369,9 @@
 	input := `{"system_id": "system_id", "hostname": "` + hostname + `"}`
 	node := suite.testMAASObject.TestServer.NewNode(input)
 	testInstance := &maasInstance{&node, suite.makeEnviron()}
-	err := common.SaveState(
+	err := bootstrap.SaveState(
 		env.Storage(),
-		&common.BootstrapState{StateInstances: []instance.Id{testInstance.Id()}})
+		&bootstrap.BootstrapState{StateInstances: []instance.Id{testInstance.Id()}})
 	c.Assert(err, gc.IsNil)
 
 	stateInfo, apiInfo, err := env.StateInfo()
@@ -429,7 +428,14 @@
 	env := suite.makeEnviron()
 	// Can't RemoveAllTools, no public storage.
 	envtesting.RemoveTools(c, env.Storage())
-	err := bootstrap.Bootstrap(env, constraints.Value{})
+	// Disable auto-uploading by setting the agent version.
+	cfg, err := env.Config().Apply(map[string]interface{}{
+		"agent-version": version.Current.Number.String(),
+	})
+	c.Assert(err, gc.IsNil)
+	err = env.SetConfig(cfg)
+	c.Assert(err, gc.IsNil)
+	err = bootstrap.Bootstrap(env, constraints.Value{})
 	c.Check(err, gc.ErrorMatches, "cannot find bootstrap tools.*")
 }
 

=== modified file 'provider/null/config_test.go'
--- provider/null/config_test.go	2013-10-04 09:32:51 +0000
+++ provider/null/config_test.go	2013-11-18 06:38:24 +0000
@@ -6,7 +6,6 @@
 import (
 	"fmt"
 	"regexp"
-	stdtesting "testing"
 
 	gc "launchpad.net/gocheck"
 
@@ -22,10 +21,6 @@
 
 var _ = gc.Suite(&configSuite{})
 
-func Test(t *stdtesting.T) {
-	gc.TestingT(t)
-}
-
 func minimalConfigValues() map[string]interface{} {
 	return map[string]interface{}{
 		"name":             "test",

=== modified file 'provider/null/environ.go'
--- provider/null/environ.go	2013-10-24 00:20:59 +0000
+++ provider/null/environ.go	2013-11-18 06:38:24 +0000
@@ -85,12 +85,23 @@
 	return e.envConfig().Name()
 }
 
-func (e *nullEnviron) Bootstrap(_ constraints.Value, possibleTools tools.List) error {
+func (e *nullEnviron) Bootstrap(cons constraints.Value) error {
+	envConfig := e.envConfig()
+	hc, series, err := manual.DetectSeriesAndHardwareCharacteristics(envConfig.sshHost())
+	if err != nil {
+		return err
+	}
+	selectedTools, err := common.EnsureBootstrapTools(e, series, hc.Arch)
+	if err != nil {
+		return err
+	}
 	return manual.Bootstrap(manual.BootstrapArgs{
-		Host:          e.envConfig().sshHost(),
-		DataDir:       dataDir,
-		Environ:       e,
-		PossibleTools: possibleTools,
+		Host:                    e.envConfig().sshHost(),
+		DataDir:                 dataDir,
+		Environ:                 e,
+		PossibleTools:           selectedTools,
+		Series:                  series,
+		HardwareCharacteristics: &hc,
 	})
 }
 

=== modified file 'provider/null/provider.go'
--- provider/null/provider.go	2013-10-08 13:35:41 +0000
+++ provider/null/provider.go	2013-11-18 06:38:24 +0000
@@ -31,7 +31,11 @@
 	if err != nil {
 		return nil, err
 	}
-	return &nullEnviron{cfg: envConfig}, nil
+	return p.open(envConfig)
+}
+
+func (p nullProvider) open(cfg *environConfig) (environs.Environ, error) {
+	return &nullEnviron{cfg: cfg}, nil
 }
 
 func checkImmutableString(cfg, old *environConfig, key string) error {

=== added file 'provider/null/suite_test.go'
--- provider/null/suite_test.go	1970-01-01 00:00:00 +0000
+++ provider/null/suite_test.go	2013-11-18 06:38:24 +0000
@@ -0,0 +1,14 @@
+// Copyright 2013 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package null
+
+import (
+	"testing"
+
+	gc "launchpad.net/gocheck"
+)
+
+func Test(t *testing.T) {
+	gc.TestingT(t)
+}

=== modified file 'provider/openstack/local_test.go'
--- provider/openstack/local_test.go	2013-11-05 04:32:17 +0000
+++ provider/openstack/local_test.go	2013-11-18 06:38:24 +0000
@@ -32,7 +32,6 @@
 	"launchpad.net/juju-core/environs/tools"
 	"launchpad.net/juju-core/instance"
 	"launchpad.net/juju-core/juju/testing"
-	"launchpad.net/juju-core/provider/common"
 	"launchpad.net/juju-core/provider/openstack"
 	coretesting "launchpad.net/juju-core/testing"
 	jc "launchpad.net/juju-core/testing/checkers"
@@ -477,7 +476,7 @@
 	c.Assert(err, gc.IsNil)
 
 	// check that the state holds the id of the bootstrap machine.
-	stateData, err := common.LoadState(env.Storage())
+	stateData, err := bootstrap.LoadState(env.Storage())
 	c.Assert(err, gc.IsNil)
 	c.Assert(stateData.StateInstances, gc.HasLen, 1)
 

=== modified file 'provider/openstack/provider.go'
--- provider/openstack/provider.go	2013-11-04 02:49:34 +0000
+++ provider/openstack/provider.go	2013-11-18 06:38:24 +0000
@@ -470,7 +470,7 @@
 	return stor
 }
 
-func (e *environ) Bootstrap(cons constraints.Value, possibleTools tools.List) error {
+func (e *environ) Bootstrap(cons constraints.Value) error {
 	// The client's authentication may have been reset when finding tools if the agent-version
 	// attribute was updated so we need to re-authenticate. This will be a no-op if already authenticated.
 	// An authenticated client is needed for the URL() call below.
@@ -478,7 +478,7 @@
 	if err != nil {
 		return err
 	}
-	return common.Bootstrap(e, cons, possibleTools)
+	return common.Bootstrap(e, cons)
 }
 
 func (e *environ) StateInfo() (*state.Info, *api.Info, error) {