Merge lp:~wallyworld/juju-core/bootstrap-tools-fixes into lp:~go-bot/juju-core/trunk

[Ian Booth]

Fix bootstrap tools issues

These bugs are addressed:

lp:1227722 - tools for wrong arch
lp:1282870 - cannot use constraints to select tools
lp:1282869 - bad failure mode for incorrect arch

tl;dr; you can bootstrap environments which run on
architectures which are different to the client
machine architcture, so long as tools are available.
eg ppc client boottrapping an environment on EC2.

Other error conditions are also addressed eg you cannot
upload tools to a cloud if that cloud does not support
the client machine architecture, since that's what the
uploaded tools would be built for. You also cannot
specify an arch constraint different to your client
machine if you are uploading tools.

A lot of the tools logic was duplicated. It has been
refactoroed to used shared code. There's still more
to do however since it's still possible to do bad things
with upgrade-juju.

https://codereview.appspot.com/77270043/

Fix bootstrap tools issues

These bugs are addressed:

lp:1227722 - tools for wrong arch
lp:1282870 - cannot use constraints to select tools
lp:1282869 - bad failure mode for incorrect arch

tl;dr; you can bootstrap environments which run on
architectures which are different to the client
machine architcture, so long as tools are available.
eg ppc client boottrapping an environment on EC2.

Other error conditions are also addressed eg you cannot
upload tools to a cloud if that cloud does not support
the client machine architecture, since that's what the
uploaded tools would be built for. You also cannot
specify an arch constraint different to your client
machine if you are uploading tools.

A lot of the tools logic was duplicated. It has been
refactoroed to used shared code. There's still more
to do however since it's still possible to do bad things
with upgrade-juju.

https://codereview.appspot.com/77270043/

[Ian Booth (wallyworld)]

Reviewers: mp+211449_code.launchpad.net,

Message:
Please take a look.

Description:
Fix bootstrap tools issues

These bugs are addressed:

lp:1227722 - tools for wrong arch
lp:1282870 - cannot use constraints to select tools
lp:1282869 - bad failure mode for incorrect arch

tl;dr; you can bootstrap environments which run on
architectures which are different to the client
machine architcture, so long as tools are available.
eg ppc client boottrapping an environment on EC2.

Other error conditions are also addressed eg you cannot
upload tools to a cloud if that cloud does not support
the client machine architecture, since that's what the
uploaded tools would be built for. You also cannot
specify an arch constraint different to your client
machine if you are uploading tools.

A lot of the tools logic was duplicated. It has been
refactoroed to used shared code. There's still more
to do however since it's still possible to do bad things
with upgrade-juju.

https://code.launchpad.net/~wallyworld/juju-core/bootstrap-tools-fixes/+merge/211449

(do not edit description out of merge proposal)

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

Affected files (+474, -151 lines):
   A [revision details]
   M cmd/juju/bootstrap.go
   M cmd/juju/bootstrap_test.go
   M cmd/juju/upgradejuju.go
   M environs/bootstrap/bootstrap_test.go
   M environs/bootstrap/synctools.go
   M environs/interface.go
   M environs/manual/init.go
   M environs/testing/tools.go
   M environs/tools/tools_test.go
   M juju/arch/arch.go
   M provider/azure/environ.go
   M provider/azure/environ_test.go
   M provider/common/bootstrap.go
   M provider/common/bootstrap_test.go
   M provider/common/mock_test.go
   M provider/dummy/environs.go
   M provider/ec2/ec2.go
   M provider/ec2/local_test.go
   M provider/joyent/environ.go
   M provider/local/environ.go
   M provider/local/environ_test.go
   M provider/maas/environ.go
   M provider/maas/environ_test.go
   M provider/maas/environ_whitebox_test.go
   M provider/manual/environ.go
   M provider/manual/environ_test.go
   M provider/openstack/local_test.go
   M provider/openstack/provider.go

[John A Meinel (jameinel)]

I like this patch a lot. The only thing that concerns me is that all of
the "SupportedArchitectures()" are hard-coded values. And actual support
is going to vary a lot by cloud installation (especially for MaaS and
Openstack).

I'm fine landing the patch as this, but we'll definitely need to add
some bugs about how we're going to enable other Architectures, or
probing for Architectures.

Maybe change MaaS to be more lenient at least. I'd hate for us to
release this and MaaS doesn't support any of the arm platforms. (I'm
pretty sure the hyperscale work was all done with armhf or arm64
machines.)

LGTM with some discussion.

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

https://codereview.appspot.com/77270043/diff/1/cmd/juju/bootstrap.go#newcode125
cmd/juju/bootstrap.go:125: err = bootstrap.UploadTools(environ,
c.Constraints.Arch, true, c.Series...)
This file looks amazing! :)

https://codereview.appspot.com/77270043/diff/1/environs/bootstrap/bootstrap_test.go
File environs/bootstrap/bootstrap_test.go (right):

https://codereview.appspot.com/77270043/diff/1/environs/bootstrap/bootstrap_test.go#newcode244
environs/bootstrap/bootstrap_test.go:244: // Can't upload tools is agent
version already set.
"if agent version is already set"

https://codereview.appspot.com/77270043/diff/1/environs/bootstrap/synctools.go
File environs/bootstrap/synctools.go (left):

https://codereview.appspot.com/77270043/diff/1/environs/bootstrap/synctools.go#oldcode50
environs/bootstrap/synctools.go:50: }
I'm a little surprised that we have something called "validate*" and we
are doing more validation before we get to it.
Would it make more sense to move the series validation checks into
validateUploadAllowed?

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

https://codereview.appspot.com/77270043/diff/1/environs/bootstrap/synctools.go#newcode31
environs/bootstrap/synctools.go:31: // Not tested directly since there's
numerous tests which use it in cmd/juju and bootstrapSuite.
I'm not sure if the comment here is relevant.
I agree that it is effectively tested, but having a couple of direct
tests can also help define what *this* part of the code is meant to be
doing in isolation.

https://codereview.appspot.com/77270043/diff/1/environs/bootstrap/synctools.go#newcode83
environs/bootstrap/synctools.go:83: func UploadSeries(cfg
*config.Config, series []string) []string {
I think this should be called "SeriesToUpload".
The problem is that "UploadTools" actually does an Upload, but
UploadSeries is just determining what list of series we would like to
use, so I'd rather see it named something that doesn't look like an
action.

https://codereview.appspot.com/77270043/diff/1/provider/joyent/environ.go
File provider/joyent/environ.go (right):

https://codereview.appspot.com/77270043/diff/1/provider/joyent/environ.go#newcode52
provider/joyent/environ.go:52: }
Is there any way we could detect this from the Provider rather than hard
coding it inside Juju?

It seems like if a cloud start supporting a new arch which we already
build tools for, then we...

[Ian Booth (wallyworld)]

On 2014/03/18 06:29:10, jameinel wrote:
> I like this patch a lot. The only thing that concerns me is that all
of the
> "SupportedArchitectures()" are hard-coded values. And actual support
is going to
> vary a lot by cloud installation (especially for MaaS and Openstack).

> I'm fine landing the patch as this, but we'll definitely need to add
some bugs
> about how we're going to enable other Architectures, or probing for
> Architectures.

> Maybe change MaaS to be more lenient at least. I'd hate for us to
release this
> and MaaS doesn't support any of the arm platforms. (I'm pretty sure
the
> hyperscale work was all done with armhf or arm64 machines.)

I agree and I should have been more verbose in my covering letter. The
plan is indeed for the SupportedArchitecures() implementation on each
environs.Environ to probe for what archietcures can be run. But I'm not
sure just yet how to do that an what form it will actually take. We were
effectively previously hardcoding the types of tools we were searching
for so yeah, it's not a regression as such. I wanted to land as is
because there's plenty of value already and we can iterate. There's also
more work required to consolidate the upload/sync tools stuff. It's
still a bit all over the place.

https://codereview.appspot.com/77270043/

[John A Meinel (jameinel)]

So I think we worked out that we want to default to being more permissive on MaaS and other providers (allow any possible arch), and to try to get the information from simplestreams data (since that is what we need to start an instance anyway).

And that we want to use version.Current.Arch, since that is what we would be able to compile anyway.

[Ian Booth (wallyworld)]

Please take a look.

https://codereview.appspot.com/77270043/diff/1/environs/bootstrap/bootstrap_test.go
File environs/bootstrap/bootstrap_test.go (right):

https://codereview.appspot.com/77270043/diff/1/environs/bootstrap/bootstrap_test.go#newcode244
environs/bootstrap/bootstrap_test.go:244: // Can't upload tools is agent
version already set.
On 2014/03/18 06:29:11, jameinel wrote:
> "if agent version is already set"

Done.

https://codereview.appspot.com/77270043/diff/1/environs/bootstrap/synctools.go
File environs/bootstrap/synctools.go (left):

https://codereview.appspot.com/77270043/diff/1/environs/bootstrap/synctools.go#oldcode50
environs/bootstrap/synctools.go:50: }
On 2014/03/18 06:29:11, jameinel wrote:
> I'm a little surprised that we have something called "validate*" and
we are
> doing more validation before we get to it.
> Would it make more sense to move the series validation checks into
> validateUploadAllowed?

Different purposes - the series check just ensures the bootstrapSeries
parameter is syntactically correct. The validateUploadAllowed does
semantic checking to ensure the upload can proceed based on business
rules eg arches must match. The series check is not expected to fail and
is a failsafe with a terse error message. The upload validation error is
quite verbose since it is plausible that failure will occur and the user
needs feedback. So I'd prefer to keep as is but am happy to discuss if
you want.

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

https://codereview.appspot.com/77270043/diff/1/environs/bootstrap/synctools.go#newcode31
environs/bootstrap/synctools.go:31: // Not tested directly since there's
numerous tests which use it in cmd/juju and bootstrapSuite.
On 2014/03/18 06:29:11, jameinel wrote:
> I'm not sure if the comment here is relevant.
> I agree that it is effectively tested, but having a couple of direct
tests can
> also help define what *this* part of the code is meant to be doing in
isolation.

Ok. The functionality was previously not exported. It was only exported
when I removed a bunch of duplicate code. But I'll add a direct test.

https://codereview.appspot.com/77270043/diff/1/environs/bootstrap/synctools.go#newcode83
environs/bootstrap/synctools.go:83: func UploadSeries(cfg
*config.Config, series []string) []string {
On 2014/03/18 06:29:11, jameinel wrote:
> I think this should be called "SeriesToUpload".
> The problem is that "UploadTools" actually does an Upload, but
UploadSeries is
> just determining what list of series we would like to use, so I'd
rather see it
> named something that doesn't look like an action.

Done.

https://codereview.appspot.com/77270043/diff/1/provider/joyent/environ.go
File provider/joyent/environ.go (right):

https://codereview.appspot.com/77270043/diff/1/provider/joyent/environ.go#newcode52
provider/joyent/environ.go:52: }
On 2014/03/18 06:29:11, jameinel wrote:
> Is there any way we could detect this from the Provider rather than
hard coding
> it inside Juju?

> It seems like if a cloud start supporting a new arch which we already
build
> tools for, then we'll have to issue a .patch rele...

[Go Bot (go-bot)]

The attempt to merge lp:~wallyworld/juju-core/bootstrap-tools-fixes into lp:juju-core failed. Below is the output from the failed tests.

ok launchpad.net/juju-core 0.014s
ok launchpad.net/juju-core/agent 1.023s
ok launchpad.net/juju-core/agent/mongo 0.564s
ok launchpad.net/juju-core/agent/tools 0.241s
ok launchpad.net/juju-core/bzr 5.073s
ok launchpad.net/juju-core/cert 2.174s
ok launchpad.net/juju-core/charm 0.446s
? launchpad.net/juju-core/charm/hooks [no test files]
? launchpad.net/juju-core/charm/testing [no test files]
ok launchpad.net/juju-core/cloudinit 0.029s
ok launchpad.net/juju-core/cloudinit/sshinit 0.794s
ok launchpad.net/juju-core/cmd 0.182s
ok launchpad.net/juju-core/cmd/charm-admin 0.720s
? launchpad.net/juju-core/cmd/charmd [no test files]
? launchpad.net/juju-core/cmd/charmload [no test files]

----------------------------------------------------------------------
FAIL: bootstrap_test.go:504: BootstrapSuite.TestAutoUploadAfterFailedSync

[LOG] 38.70757 DEBUG juju.environs.tools no architecture specified when finding tools, looking for any
[LOG] 38.70759 DEBUG juju.environs.tools no series specified when finding tools, looking for any
[LOG] 38.70764 DEBUG juju.environs.simplestreams fetchData failed for "file:///tmp/gocheck-1976235410884491574/13/tools/streams/v1/index.sjson": stat /tmp/gocheck-1976235410884491574/13/tools/streams/v1/index.sjson: no such file or directory
[LOG] 38.70769 DEBUG juju.environs.simplestreams cannot load index "file:///tmp/gocheck-1976235410884491574/13/tools/streams/v1/index.sjson": invalid URL "file:///tmp/gocheck-1976235410884491574/13/tools/streams/v1/index.sjson" not found
[LOG] 38.70773 DEBUG juju.environs.simplestreams fetchData failed for "file:///tmp/gocheck-1976235410884491574/13/tools/streams/v1/index.json": stat /tmp/gocheck-1976235410884491574/13/tools/streams/v1/index.json: no such file or directory
[LOG] 38.70777 DEBUG juju.environs.simplestreams cannot load index "file:///tmp/gocheck-1976235410884491574/13/tools/streams/v1/index.json": invalid URL "file:///tmp/gocheck-1976235410884491574/13/tools/streams/v1/index.json" not found
[LOG] 38.70971 INFO juju.environs.tools Writing tools/streams/v1/index.json
[LOG] 38.70999 INFO juju.environs.tools Writing tools/streams/v1/com.ubuntu.juju:released:tools.json
[LOG] 38.71128 DEBUG juju.environs.tools no architecture specified when finding tools, looking for any
[LOG] 38.71129 DEBUG juju.environs.tools no series specified when finding tools, looking for any
[LOG] 38.71135 DEBUG juju.environs.simplestreams fetchData failed for "file:///tmp/gocheck-1976235410884491574/14/tools/streams/v1/index.sjson": stat /tmp/gocheck-1976235410884491574/14/tools/streams/v1/index.sjson: no such file or directory
[LOG] 38.71140 DEBUG juju.environs.simplestreams cannot load index "file:///tmp/gocheck-1976235410884491574/14/tools/streams/v1/index.sjson": invalid URL "file:///tmp/gocheck-1976235410884491574/14/tools/streams/v1/index.sjson" not found
[LOG] 38.71143 DEBUG juju.environs.simplestreams fetchData failed for "file:///tmp/gocheck-1976235410884491574/14/tools/streams/v1/index.json": stat /tmp/gocheck-1976235410884491574/...

=== modified file 'agent/tools/tools_test.go'
--- agent/tools/tools_test.go	2014-01-21 05:25:30 +0000
+++ agent/tools/tools_test.go	2014-03-19 02:34:50 +0000
@@ -39,7 +39,7 @@
 	// resulting slice has that prefix removed to keep the output short.
 	c.Assert(testbase.FindJujuCoreImports(c, "launchpad.net/juju-core/agent/tools"),
 		gc.DeepEquals,
-		[]string{"tools", "utils/set", "version"})
+		[]string{"juju/arch", "tools", "utils/set", "version"})
 }
 
 const toolsFile = "downloaded-tools.txt"

=== modified file 'cmd/juju/bootstrap.go'
--- cmd/juju/bootstrap.go	2014-03-10 00:45:41 +0000
+++ cmd/juju/bootstrap.go	2014-03-19 02:34:50 +0000
@@ -13,15 +13,10 @@
 	"launchpad.net/juju-core/charm"
 	"launchpad.net/juju-core/cmd"
 	"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/sync"
 	"launchpad.net/juju-core/environs/tools"
 	"launchpad.net/juju-core/provider"
-	"launchpad.net/juju-core/utils/set"
-	"launchpad.net/juju-core/version"
 )
 
 const bootstrapDoc = `
@@ -127,7 +122,7 @@
 		c.UploadTools = true
 	}
 	if c.UploadTools {
-		err = c.uploadTools(environ)
+		err = bootstrap.UploadTools(environ, c.Constraints.Arch, true, c.Series...)
 		if err != nil {
 			return err
 		}
@@ -135,28 +130,6 @@
 	return bootstrap.Bootstrap(ctx, environ, c.Constraints)
 }
 
-func (c *BootstrapCommand) uploadTools(environ environs.Environ) error {
-	// Force version.Current, for consistency with subsequent upgrade-juju
-	// (see UpgradeJujuCommand).
-	forceVersion := uploadVersion(version.Current.Number, nil)
-	cfg := environ.Config()
-	series := getUploadSeries(cfg, c.Series)
-	agenttools, err := sync.Upload(environ.Storage(), &forceVersion, series...)
-	if err != nil {
-		return err
-	}
-	cfg, err = cfg.Apply(map[string]interface{}{
-		"agent-version": agenttools.Version.Number.String(),
-	})
-	if err == nil {
-		err = environ.SetConfig(cfg)
-	}
-	if err != nil {
-		return fmt.Errorf("failed to update environment configuration: %v", err)
-	}
-	return nil
-}
-
 type seriesVar struct {
 	target *[]string
 }
@@ -175,16 +148,3 @@
 func (v seriesVar) String() string {
 	return strings.Join(*v.target, ",")
 }
-
-// getUploadSeries returns the supplied series with duplicates removed if
-// non-empty; otherwise it returns a default list of series we should
-// probably upload, based on cfg.
-func getUploadSeries(cfg *config.Config, series []string) []string {
-	unique := set.NewStrings(series...)
-	if unique.IsEmpty() {
-		unique.Add(version.Current.Series)
-		unique.Add(config.DefaultSeries)
-		unique.Add(cfg.DefaultSeries())
-	}
-	return unique.Values()
-}

=== modified file 'cmd/juju/bootstrap_test.go'
--- cmd/juju/bootstrap_test.go	2014-03-13 23:30:56 +0000
+++ cmd/juju/bootstrap_test.go	2014-03-19 02:34:50 +0000
@@ -26,6 +26,7 @@
 	envtools "launchpad.net/juju-core/environs/tools"
 	ttesting "launchpad.net/juju-core/environs/tools/testing"
 	"launchpad.net/juju-core/errors"
+	"launchpad.net/juju-core/juju/arch"
 	"launchpad.net/juju-core/provider/dummy"
 	coretesting "launchpad.net/juju-core/testing"
 	"launchpad.net/juju-core/testing/testbase"
@@ -81,27 +82,30 @@
 	addVersionToSource bool
 }
 
+var noToolsAvailableMessage = "cannot upload bootstrap tools: Juju cannot bootstrap because no tools are available for your environment.*"
+var toolsNotFoundMessage = "cannot find bootstrap tools: tools not found"
+
 var bootstrapRetryTests = []bootstrapRetryTest{{
-	info:               "no tools uploaded, first check has no retries; no matching binary in source; sync fails with no second attempt",
+	info:               "no tools uploaded, first check has no retries; no matching binary in source; no second attempt",
 	expectedAllowRetry: []bool{false},
-	err:                "cannot find bootstrap tools: no matching tools available",
+	err:                noToolsAvailableMessage,
 	version:            "1.16.0-precise-amd64",
 }, {
-	info:               "no tools uploaded, first check has no retries; matching binary in source; check after sync has retries",
+	info:               "no tools uploaded, first check has no retries; matching binary in source; check after upload has retries",
 	expectedAllowRetry: []bool{false, true},
-	err:                "cannot find bootstrap tools: tools not found",
-	version:            "1.16.0-precise-amd64",
+	err:                toolsNotFoundMessage,
+	version:            "1.17.0-precise-amd64", // dev version to force upload
 	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:                "cannot find bootstrap tools: tools not found",
+	err:                toolsNotFoundMessage,
 	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:                "cannot find bootstrap tools: no matching tools available",
+	err:                noToolsAvailableMessage,
 }}
 
 // Test test checks that bootstrap calls FindTools with the expected allowRetry flag.
@@ -141,7 +145,8 @@
 	_, errc := runCommand(nullContext(), new(BootstrapCommand), test.args...)
 	err := <-errc
 	c.Check(findToolsRetryValues, gc.DeepEquals, test.expectedAllowRetry)
-	c.Check(err, gc.ErrorMatches, test.err)
+	stripped := strings.Replace(err.Error(), "\n", "", -1)
+	c.Check(stripped, gc.Matches, test.err)
 }
 
 // mockUploadTools simulates the effect of tools.Upload, but skips the time-
@@ -187,6 +192,7 @@
 	// will be uploaded before running the test.
 	uploads     []string
 	constraints constraints.Value
+	hostArch    string
 }
 
 func (test bootstrapTest) run(c *gc.C) {
@@ -201,6 +207,14 @@
 		defer func() { version.Current = origVersion }()
 	}
 
+	if test.hostArch != "" {
+		origVersion := arch.HostArch
+		arch.HostArch = func() string {
+			return test.hostArch
+		}
+		defer func() { arch.HostArch = origVersion }()
+	}
+
 	uploadCount := len(test.uploads)
 	if uploadCount == 0 {
 		usefulVersion := version.Current
@@ -210,6 +224,17 @@
 
 	// Run command and check for uploads.
 	opc, errc := runCommand(nullContext(), new(BootstrapCommand), test.args...)
+	// Check for remaining operations/errors.
+	if test.err != "" {
+		err := <-errc
+		stripped := strings.Replace(err.Error(), "\n", "", -1)
+		c.Check(stripped, gc.Matches, test.err)
+		return
+	}
+	if !c.Check(<-errc, gc.IsNil) {
+		return
+	}
+
 	if uploadCount > 0 {
 		for i := 0; i < uploadCount; i++ {
 			c.Check((<-opc).(dummy.OpPutFile).Env, gc.Equals, "peckham")
@@ -227,15 +252,6 @@
 			c.Check(found, gc.Equals, true)
 		}
 	}
-
-	// Check for remaining operations/errors.
-	if test.err != "" {
-		c.Check(<-errc, gc.ErrorMatches, test.err)
-		return
-	}
-	if !c.Check(<-errc, gc.IsNil) {
-		return
-	}
 	if len(test.uploads) > 0 {
 		indexFile := (<-opc).(dummy.OpPutFile)
 		c.Check(indexFile.FileName, gc.Equals, "tools/streams/v1/index.json")
@@ -302,6 +318,17 @@
 		"1.2.3.1-precise-amd64", // from environs/config.DefaultSeries
 	},
 }, {
+	info:     "--upload-tools uses arch from constraint if it matches current version",
+	version:  "1.3.3-saucy-ppc64",
+	hostArch: "ppc64",
+	args:     []string{"--upload-tools", "--constraints", "arch=ppc64"},
+	uploads: []string{
+		"1.3.3.1-saucy-ppc64",   // from version.Current
+		"1.3.3.1-raring-ppc64",  // from env.Config().DefaultSeries()
+		"1.3.3.1-precise-ppc64", // from environs/config.DefaultSeries
+	},
+	constraints: constraints.MustParse("arch=ppc64"),
+}, {
 	info:    "--upload-tools only uploads each file once",
 	version: "1.2.3-precise-amd64",
 	args:    []string{"--upload-tools"},
@@ -315,6 +342,17 @@
 	args:    []string{"--upload-tools", "--series", "ping,ping,pong"},
 	err:     `invalid series "ping"`,
 }, {
+	info:    "--upload-tools rejects mismatched arch",
+	version: "1.3.3-saucy-amd64",
+	args:    []string{"--upload-tools", "--constraints", "arch=ppc64"},
+	err:     `cannot build tools for "ppc64" using a machine running on "amd64"`,
+}, {
+	info:     "--upload-tools rejects non-supported arch",
+	version:  "1.3.3-saucy-arm64",
+	hostArch: "arm64",
+	args:     []string{"--upload-tools"},
+	err:      `environment "peckham" of type dummy does not support instances running on "arm64"`,
+}, {
 	info:    "--upload-tools always bumps build number",
 	version: "1.2.3.4-raring-amd64",
 	args:    []string{"--upload-tools"},
@@ -493,7 +531,8 @@
 	s.setupAutoUploadTest(c, "1.8.3", "precise")
 	_, errc := runCommand(nullContext(), new(BootstrapCommand))
 	err := <-errc
-	c.Assert(err, gc.ErrorMatches, "cannot find bootstrap tools: no matching tools available")
+	stripped := strings.Replace(err.Error(), "\n", "", -1)
+	c.Assert(stripped, gc.Matches, noToolsAvailableMessage)
 }
 
 func (s *BootstrapSuite) TestMissingToolsError(c *gc.C) {
@@ -503,7 +542,7 @@
 	c.Assert(code, gc.Equals, 1)
 	errText := context.Stderr.(*bytes.Buffer).String()
 	errText = strings.Replace(errText, "\n", "", -1)
-	expectedErrText := "error: cannot find bootstrap tools: no matching tools available"
+	expectedErrText := "error: cannot upload bootstrap tools: Juju cannot bootstrap because no tools are available for your environment.*"
 	c.Assert(errText, gc.Matches, expectedErrText)
 }
 
@@ -519,7 +558,7 @@
 	c.Assert(code, gc.Equals, 1)
 	errText := context.Stderr.(*bytes.Buffer).String()
 	errText = strings.Replace(errText, "\n", "", -1)
-	expectedErrText := "error: cannot find bootstrap tools: an error"
+	expectedErrText := "error: cannot upload bootstrap tools: an error"
 	c.Assert(errText, gc.Matches, expectedErrText)
 }
 

=== modified file 'cmd/juju/upgradejuju.go'
--- cmd/juju/upgradejuju.go	2014-03-13 10:40:55 +0000
+++ cmd/juju/upgradejuju.go	2014-03-19 02:34:50 +0000
@@ -13,6 +13,7 @@
 
 	"launchpad.net/juju-core/cmd"
 	"launchpad.net/juju-core/environs"
+	"launchpad.net/juju-core/environs/bootstrap"
 	"launchpad.net/juju-core/environs/config"
 	"launchpad.net/juju-core/environs/storage"
 	"launchpad.net/juju-core/environs/sync"
@@ -141,7 +142,7 @@
 		return err
 	}
 	if c.UploadTools {
-		series := getUploadSeries(cfg, c.Series)
+		series := bootstrap.SeriesToUpload(cfg, c.Series)
 		if err := context.uploadTools(series); err != nil {
 			return err
 		}
@@ -395,7 +396,7 @@
 		return err
 	}
 	if c.UploadTools {
-		series := getUploadSeries(cfg, c.Series)
+		series := bootstrap.SeriesToUpload(cfg, c.Series)
 		if err := context.uploadTools1dot16(env.Storage(), series); err != nil {
 			return err
 		}

=== modified file 'cmd/package_test.go'
--- cmd/package_test.go	2014-01-22 22:48:54 +0000
+++ cmd/package_test.go	2014-03-19 02:34:50 +0000
@@ -23,5 +23,5 @@
 	// really be moved into "juju/osenv".
 	c.Assert(testbase.FindJujuCoreImports(c, "launchpad.net/juju-core/cmd"),
 		gc.DeepEquals,
-		[]string{"juju/osenv", "names", "version"})
+		[]string{"juju/arch", "juju/osenv", "names", "version"})
 }

=== modified file 'environs/bootstrap/bootstrap_test.go'
--- environs/bootstrap/bootstrap_test.go	2014-03-03 10:10:44 +0000
+++ environs/bootstrap/bootstrap_test.go	2014-03-19 02:34:50 +0000
@@ -5,6 +5,7 @@
 
 import (
 	"fmt"
+	"strings"
 	stdtesting "testing"
 
 	gc "launchpad.net/gocheck"
@@ -14,10 +15,13 @@
 	"launchpad.net/juju-core/environs/bootstrap"
 	"launchpad.net/juju-core/environs/config"
 	"launchpad.net/juju-core/environs/configstore"
+	"launchpad.net/juju-core/environs/filestorage"
 	"launchpad.net/juju-core/environs/simplestreams"
 	"launchpad.net/juju-core/environs/storage"
+	"launchpad.net/juju-core/environs/sync"
 	envtesting "launchpad.net/juju-core/environs/testing"
 	envtools "launchpad.net/juju-core/environs/tools"
+	"launchpad.net/juju-core/juju/arch"
 	"launchpad.net/juju-core/provider/dummy"
 	coretesting "launchpad.net/juju-core/testing"
 	"launchpad.net/juju-core/testing/testbase"
@@ -54,7 +58,7 @@
 }
 
 func (s *bootstrapSuite) TestBootstrapNeedsSettings(c *gc.C) {
-	env := newEnviron("bar", noKeysDefined)
+	env := newEnviron("bar", noKeysDefined, nil)
 	s.setDummyStorage(c, env)
 	fixEnv := func(key string, value interface{}) {
 		cfg, err := env.Config().Apply(map[string]interface{}{
@@ -88,7 +92,7 @@
 }
 
 func (s *bootstrapSuite) TestBootstrapEmptyConstraints(c *gc.C) {
-	env := newEnviron("foo", useDefaultKeys)
+	env := newEnviron("foo", useDefaultKeys, nil)
 	s.setDummyStorage(c, env)
 	err := bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
 	c.Assert(err, gc.IsNil)
@@ -97,7 +101,7 @@
 }
 
 func (s *bootstrapSuite) TestBootstrapSpecifiedConstraints(c *gc.C) {
-	env := newEnviron("foo", useDefaultKeys)
+	env := newEnviron("foo", useDefaultKeys, nil)
 	s.setDummyStorage(c, env)
 	cons := constraints.MustParse("cpu-cores=2 mem=4G")
 	err := bootstrap.Bootstrap(coretesting.Context(c), env, cons)
@@ -135,10 +139,18 @@
 		DefaultSeries: "precise",
 		Arch:          "i386",
 		Expect:        []version.Binary{envtesting.V120p32},
+	}, {
+		Info:          "dev cli has different arch to available",
+		Available:     envtesting.V1all,
+		CliVersion:    envtesting.V310qppc64,
+		DefaultSeries: "precise",
+		Expect:        []version.Binary{envtesting.V3101qppc64},
 	}}
 
 func (s *bootstrapSuite) TestBootstrapTools(c *gc.C) {
 	allTests := append(envtesting.BootstrapToolsTests, bootstrapSetAgentVersionTests...)
+	// version.Current is set in the loop so ensure it is restored later.
+	s.PatchValue(&version.Current, version.Current)
 	for i, test := range allTests {
 		c.Logf("\ntest %d: %s", i, test.Info)
 		dummy.Reset()
@@ -166,8 +178,9 @@
 			cons = constraints.MustParse("arch=" + test.Arch)
 		}
 		err = bootstrap.Bootstrap(coretesting.Context(c), env, cons)
-		if test.Err != nil {
-			c.Check(err, gc.ErrorMatches, ".*"+test.Err.Error())
+		if test.Err != "" {
+			stripped := strings.Replace(err.Error(), "\n", "", -1)
+			c.Check(stripped, gc.Matches, ".*"+stripped)
 			continue
 		} else {
 			c.Check(err, gc.IsNil)
@@ -185,7 +198,7 @@
 }
 
 func (s *bootstrapSuite) TestBootstrapNoTools(c *gc.C) {
-	env := newEnviron("foo", useDefaultKeys)
+	env := newEnviron("foo", useDefaultKeys, nil)
 	s.setDummyStorage(c, env)
 	envtesting.RemoveFakeTools(c, env.Storage())
 	err := bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
@@ -194,12 +207,182 @@
 	c.Assert(err, gc.IsNil)
 }
 
+func (s *bootstrapSuite) TestEnsureToolsAvailabilityIncompatibleHostArch(c *gc.C) {
+	// Host runs amd64, want ppc64 tools.
+	s.PatchValue(&arch.HostArch, func() string {
+		return "amd64"
+	})
+	env := newEnviron("foo", useDefaultKeys, nil)
+	s.setDummyStorage(c, env)
+	envtesting.RemoveFakeTools(c, env.Storage())
+	arch := "ppc64"
+	_, err := bootstrap.EnsureToolsAvailability(env, env.Config().DefaultSeries(), &arch)
+	c.Assert(err, gc.NotNil)
+	stripped := strings.Replace(err.Error(), "\n", "", -1)
+	c.Assert(stripped,
+		gc.Matches,
+		`cannot upload bootstrap tools: cannot build tools for "ppc64" using a machine running on "amd64"`)
+}
+
+func (s *bootstrapSuite) TestEnsureToolsAvailabilityIncompatibleTargetArch(c *gc.C) {
+	// Host runs ppc64, environment only supports amd64, arm64.
+	s.PatchValue(&arch.HostArch, func() string {
+		return "ppc64"
+	})
+	env := newEnviron("foo", useDefaultKeys, nil)
+	s.setDummyStorage(c, env)
+	envtesting.RemoveFakeTools(c, env.Storage())
+	_, err := bootstrap.EnsureToolsAvailability(env, env.Config().DefaultSeries(), nil)
+	c.Assert(err, gc.NotNil)
+	stripped := strings.Replace(err.Error(), "\n", "", -1)
+	c.Assert(stripped,
+		gc.Matches,
+		`cannot upload bootstrap tools: environment "foo" of type dummy does not support instances running on "ppc64"`)
+}
+
+func (s *bootstrapSuite) TestEnsureToolsAvailabilityAgentVersionAlreadySet(c *gc.C) {
+	// Can't upload tools if agent version already set.
+	env := newEnviron("foo", useDefaultKeys, map[string]interface{}{"agent-version": "1.16.0"})
+	s.setDummyStorage(c, env)
+	envtesting.RemoveFakeTools(c, env.Storage())
+	_, err := bootstrap.EnsureToolsAvailability(env, env.Config().DefaultSeries(), nil)
+	c.Assert(err, gc.NotNil)
+	stripped := strings.Replace(err.Error(), "\n", "", -1)
+	c.Assert(stripped,
+		gc.Matches,
+		"cannot upload bootstrap tools: Juju cannot bootstrap because no tools are available for your environment.*")
+}
+
+func (s *bootstrapSuite) TestEnsureToolsAvailabilityNonDevVersion(c *gc.C) {
+	// Can't upload tools for released versions.
+	s.PatchValue(&version.Current, version.MustParseBinary("1.18.0-trusty-arm64"))
+	env := newEnviron("foo", useDefaultKeys, nil)
+	s.setDummyStorage(c, env)
+	envtesting.RemoveFakeTools(c, env.Storage())
+	_, err := bootstrap.EnsureToolsAvailability(env, env.Config().DefaultSeries(), nil)
+	c.Assert(err, gc.NotNil)
+	stripped := strings.Replace(err.Error(), "\n", "", -1)
+	c.Assert(stripped,
+		gc.Matches,
+		"cannot upload bootstrap tools: Juju cannot bootstrap because no tools are available for your environment.*")
+}
+
+// getMockBuildTools returns a sync.BuildToolsTarballFunc implementation which generates
+// a fake tools tarball.
+func (s *bootstrapSuite) getMockBuildTools(c *gc.C) sync.BuildToolsTarballFunc {
+	toolsDir := c.MkDir()
+	return func(forceVersion *version.Number) (*sync.BuiltTools, error) {
+		// UploadFakeToolsVersions requires a storage to write to.
+		stor, err := filestorage.NewFileStorageWriter(toolsDir)
+		c.Assert(err, gc.IsNil)
+		vers := version.Current
+		if forceVersion != nil {
+			vers.Number = *forceVersion
+		}
+		versions := []version.Binary{vers}
+		uploadedTools, err := envtesting.UploadFakeToolsVersions(stor, versions...)
+		c.Assert(err, gc.IsNil)
+		agentTools := uploadedTools[0]
+		return &sync.BuiltTools{
+			Dir:         toolsDir,
+			StorageName: envtools.StorageName(vers),
+			Version:     vers,
+			Size:        agentTools.Size,
+			Sha256Hash:  agentTools.SHA256,
+		}, nil
+	}
+}
+
 func (s *bootstrapSuite) TestEnsureToolsAvailability(c *gc.C) {
-	env := newEnviron("foo", useDefaultKeys)
+	existingToolsVersion := version.MustParseBinary("1.19.0-trusty-amd64")
+	s.PatchValue(&version.Current, existingToolsVersion)
+	env := newEnviron("foo", useDefaultKeys, nil)
+	s.setDummyStorage(c, env)
+	// At this point, as a result of setDummyStorage, env has tools for amd64 uploaded.
+	// Set version.Current to be arm64 to simulate a different CLI version.
+	cliVersion := version.Current
+	cliVersion.Arch = "arm64"
+	version.Current = cliVersion
+	s.PatchValue(&sync.BuildToolsTarball, s.getMockBuildTools(c))
+	// Host runs arm64, environment supports arm64.
+	s.PatchValue(&arch.HostArch, func() string {
+		return "arm64"
+	})
+	arch := "arm64"
+	agentTools, err := bootstrap.EnsureToolsAvailability(env, env.Config().DefaultSeries(), &arch)
+	c.Assert(err, gc.IsNil)
+	c.Assert(agentTools, gc.HasLen, 1)
+	expectedVers := version.Current
+	expectedVers.Number.Build++
+	expectedVers.Series = env.Config().DefaultSeries()
+	c.Assert(agentTools[0].Version, gc.DeepEquals, expectedVers)
+}
+
+func (s *bootstrapSuite) TestSeriesToUpload(c *gc.C) {
+	vers := version.Current
+	vers.Series = "quantal"
+	s.PatchValue(&version.Current, vers)
+	env := newEnviron("foo", useDefaultKeys, nil)
+	cfg := env.Config()
+	c.Assert(bootstrap.SeriesToUpload(cfg, nil), gc.DeepEquals, []string{"quantal", "precise"})
+	c.Assert(bootstrap.SeriesToUpload(cfg, []string{"quantal"}), gc.DeepEquals, []string{"quantal"})
+	env = newEnviron("foo", useDefaultKeys, map[string]interface{}{"default-series": "lucid"})
+	cfg = env.Config()
+	c.Assert(bootstrap.SeriesToUpload(cfg, nil), gc.DeepEquals, []string{"quantal", "precise", "lucid"})
+}
+
+func (s *bootstrapSuite) assertUploadTools(c *gc.C, vers version.Binary, allowRelease bool, errMessage string) {
+	s.PatchValue(&version.Current, vers)
+	// If we allow released tools to be uploaded, the build number is incremented so in that case
+	// we need to ensure the environment is set up to allow dev tools to be used.
+	env := newEnviron("foo", useDefaultKeys, map[string]interface{}{"development": allowRelease})
 	s.setDummyStorage(c, env)
 	envtesting.RemoveFakeTools(c, env.Storage())
-	_, err := bootstrap.EnsureToolsAvailability(env, env.Config().DefaultSeries(), nil)
-	c.Check(err, gc.ErrorMatches, ".*no tools available")
+
+	// At this point, as a result of setDummyStorage, env has tools for amd64 uploaded.
+	// Set version.Current to be arm64 to simulate a different CLI version.
+	cliVersion := version.Current
+	cliVersion.Arch = "arm64"
+	version.Current = cliVersion
+	s.PatchValue(&sync.BuildToolsTarball, s.getMockBuildTools(c))
+	// Host runs arm64, environment supports arm64.
+	s.PatchValue(&arch.HostArch, func() string {
+		return "arm64"
+	})
+	arch := "arm64"
+	err := bootstrap.UploadTools(env, &arch, allowRelease, "precise")
+	if errMessage != "" {
+		stripped := strings.Replace(err.Error(), "\n", "", -1)
+		c.Assert(stripped, gc.Matches, errMessage)
+		return
+	}
+	c.Assert(err, gc.IsNil)
+	params := envtools.BootstrapToolsParams{
+		Arch:   &arch,
+		Series: "precise",
+	}
+	agentTools, err := envtools.FindBootstrapTools(env, params)
+	c.Assert(err, gc.IsNil)
+	c.Assert(agentTools, gc.HasLen, 1)
+	expectedVers := vers
+	expectedVers.Number.Build++
+	expectedVers.Series = "precise"
+	c.Assert(agentTools[0].Version, gc.DeepEquals, expectedVers)
+}
+
+func (s *bootstrapSuite) TestUploadTools(c *gc.C) {
+	vers := version.MustParseBinary("1.19.0-trusty-arm64")
+	s.assertUploadTools(c, vers, false, "")
+}
+
+func (s *bootstrapSuite) TestUploadToolsReleaseVersionAllowed(c *gc.C) {
+	vers := version.MustParseBinary("1.18.0-trusty-arm64")
+	s.assertUploadTools(c, vers, true, "")
+}
+
+func (s *bootstrapSuite) TestUploadToolsReleaseVersionDisallowed(c *gc.C) {
+	vers := version.MustParseBinary("1.18.0-trusty-arm64")
+	s.assertUploadTools(c, vers, false, "Juju cannot bootstrap because no tools are available for your environment.*")
 }
 
 type bootstrapEnviron struct {
@@ -222,8 +405,8 @@
 		storage.NewStorageSimpleStreamsDataSource("cloud storage", e.Storage(), storage.BaseToolsPath)}, nil
 }
 
-func newEnviron(name string, defaultKeys bool) *bootstrapEnviron {
-	m := dummy.SampleConfig()
+func newEnviron(name string, defaultKeys bool, extraAttrs map[string]interface{}) *bootstrapEnviron {
+	m := dummy.SampleConfig().Merge(extraAttrs)
 	if !defaultKeys {
 		m = m.Delete(
 			"ca-cert",
@@ -273,3 +456,7 @@
 func (e *bootstrapEnviron) Storage() storage.Storage {
 	return e.storage
 }
+
+func (e *bootstrapEnviron) SupportedArchitectures() ([]string, error) {
+	return []string{"amd64", "arm64"}, nil
+}

=== modified file 'environs/bootstrap/synctools.go'
--- environs/bootstrap/synctools.go	2014-01-20 23:32:00 +0000
+++ environs/bootstrap/synctools.go	2014-03-19 02:34:50 +0000
@@ -8,9 +8,11 @@
 
 	"launchpad.net/juju-core/environs"
 	"launchpad.net/juju-core/environs/config"
+	"launchpad.net/juju-core/environs/simplestreams"
 	"launchpad.net/juju-core/environs/sync"
 	envtools "launchpad.net/juju-core/environs/tools"
 	"launchpad.net/juju-core/errors"
+	"launchpad.net/juju-core/juju/arch"
 	coretools "launchpad.net/juju-core/tools"
 	"launchpad.net/juju-core/utils/set"
 	"launchpad.net/juju-core/version"
@@ -21,46 +23,29 @@
 `
 
 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)
+// UploadTools uploads tools for the specified series and any other relevant series to
+// the environment storage, after which it sets the agent-version.
+func UploadTools(env environs.Environ, toolsArch *string, allowRelease bool, bootstrapSeries ...string) error {
+	logger.Infof("checking that upload is possible")
+	// Check the series are valid.
+	for _, series := range bootstrapSeries {
+		if _, err := simplestreams.SeriesVersion(series); err != nil {
+			return err
 		}
 	}
-	return err
-}
+	// See that we are allowed to upload the tools.
+	if err := validateUploadAllowed(env, toolsArch, allowRelease); err != nil {
+		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()...)
+	forceVersion := uploadVersion(version.Current.Number, nil)
+	uploadSeries := SeriesToUpload(cfg, bootstrapSeries)
+	logger.Infof("uploading tools for series %s", uploadSeries)
+	tools, err := sync.Upload(env.Storage(), &forceVersion, uploadSeries...)
 	if err != nil {
 		return err
 	}
@@ -76,9 +61,74 @@
 	return nil
 }
 
+// uploadVersion returns a copy of the supplied version with a build number
+// higher than any of the supplied tools that share its major, minor and patch.
+func uploadVersion(vers version.Number, existing coretools.List) version.Number {
+	vers.Build++
+	for _, t := range existing {
+		if t.Version.Major != vers.Major || t.Version.Minor != vers.Minor || t.Version.Patch != vers.Patch {
+			continue
+		}
+		if t.Version.Build >= vers.Build {
+			vers.Build = t.Version.Build + 1
+		}
+	}
+	return vers
+}
+
+// SeriesToUpload returns the supplied series with duplicates removed if
+// non-empty; otherwise it returns a default list of series we should
+// probably upload, based on cfg.
+func SeriesToUpload(cfg *config.Config, series []string) []string {
+	unique := set.NewStrings(series...)
+	if unique.IsEmpty() {
+		unique.Add(version.Current.Series)
+		unique.Add(config.DefaultSeries)
+		unique.Add(cfg.DefaultSeries())
+	}
+	return unique.Values()
+}
+
+// validateUploadAllowed returns an error if an attempt to upload tools should
+// not be allowed.
+func validateUploadAllowed(env environs.Environ, toolsArch *string, allowRelease bool) error {
+	// First, check that there isn't already an agent version specified, and that we
+	// are running a development version.
+	if _, hasAgentVersion := env.Config().AgentVersion(); hasAgentVersion || (!allowRelease && !version.Current.IsDev()) {
+		return fmt.Errorf(noToolsNoUploadMessage)
+	}
+
+	// Now check that the architecture for which we are setting up an
+	// environment matches that from which we are bootstrapping.
+	hostArch := arch.HostArch()
+	// We can't build tools for a different architecture if one is specified.
+	if toolsArch != nil && *toolsArch != hostArch {
+		return fmt.Errorf("cannot build tools for %q using a machine running on %q", *toolsArch, hostArch)
+	}
+	// If no architecture is specified, ensure the target provider supports instances matching our architecture.
+	supportedArchitectures, err := env.SupportedArchitectures()
+	if err != nil {
+		return fmt.Errorf(
+			"no packaged tools available and cannot determine environment's supported architectures: %v", err)
+	}
+	archSupported := false
+	for _, arch := range supportedArchitectures {
+		if hostArch == arch {
+			archSupported = true
+			break
+		}
+	}
+	if !archSupported {
+		envType := env.Config().Type()
+		return fmt.Errorf(
+			"environment %q of type %s does not support instances running on %q", env.Name(), envType, hostArch)
+	}
+	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) {
+func EnsureToolsAvailability(env environs.Environ, series string, toolsArch *string) (coretools.List, error) {
 	cfg := env.Config()
 	var vers *version.Number
 	if agentVersion, ok := cfg.AgentVersion(); ok {
@@ -87,11 +137,11 @@
 
 	logger.Debugf(
 		"looking for bootstrap tools: series=%q, arch=%v, version=%v",
-		series, arch, vers,
+		series, toolsArch, vers,
 	)
 	params := envtools.BootstrapToolsParams{
 		Version: vers,
-		Arch:    arch,
+		Arch:    toolsArch,
 		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.
@@ -104,17 +154,14 @@
 		return nil, err
 	}
 
-	// No tools available, so synchronize.
-	logger.Warningf("no tools available, attempting to retrieve from %v", envtools.DefaultBaseURL)
-	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)
+	// No tools available so our only hope is to build locally and upload.
+	logger.Warningf("no prepackaged tools available")
+	uploadSeries := SeriesToUpload(cfg, nil)
+	if err := UploadTools(env, toolsArch, false,  append(uploadSeries, series)...); err != nil {
+		logger.Errorf("%s", noToolsMessage)
+		return nil, fmt.Errorf("cannot upload bootstrap tools: %v", err)
 	}
-	// TODO(axw) have syncOrUpload return the list of tools in the target, and use that.
+	// TODO(axw) have uploadTools 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)

=== modified file 'environs/interface.go'
--- environs/interface.go	2014-02-20 08:23:40 +0000
+++ environs/interface.go	2014-03-19 02:34:50 +0000
@@ -15,6 +15,14 @@
 	"launchpad.net/juju-core/state/api"
 )
 
+// EnvironCapability implements access to metadata about the capabilities
+// of an environment.
+type EnvironCapability interface {
+	// SupportedArchitectures returns the image architectures which can
+	// be hosted by this environment.
+	SupportedArchitectures() ([]string, error)
+}
+
 // A EnvironProvider represents a computing and storage provider.
 type EnvironProvider interface {
 	// Prepare prepares an environment for use. Any additional
@@ -63,7 +71,7 @@
 	Storage() storage.Storage
 }
 
-// ConfigGetter implements access to an environments configuration.
+// ConfigGetter implements access to an environment's configuration.
 type ConfigGetter interface {
 	// Config returns the configuration data with which the Environ was created.
 	// Note that this is not necessarily current; the canonical location
@@ -116,6 +124,9 @@
 	// ConfigGetter allows the retrieval of the configuration data.
 	ConfigGetter
 
+	// EnvironCapability allows access to this environment's capabilities.
+	EnvironCapability
+
 	// SetConfig updates the Environ's configuration.
 	//
 	// Calls to SetConfig do not affect the configuration of

=== modified file 'environs/manual/init.go'
--- environs/manual/init.go	2014-03-17 03:45:21 +0000
+++ environs/manual/init.go	2014-03-19 02:34:50 +0000
@@ -57,10 +57,13 @@
 	return provisioned, nil
 }
 
-// DetectSeriesAndHardwareCharacteristics detects the OS
+// Patch for testing.
+var DetectSeriesAndHardwareCharacteristics = detectSeriesAndHardwareCharacteristics
+
+// detectSeriesAndHardwareCharacteristics detects the OS
 // series and hardware characteristics of the remote machine
 // by connecting to the machine and executing a bash script.
-func DetectSeriesAndHardwareCharacteristics(host string) (hc instance.HardwareCharacteristics, series string, err error) {
+func detectSeriesAndHardwareCharacteristics(host string) (hc instance.HardwareCharacteristics, series string, err error) {
 	logger.Infof("Detecting series and characteristics on %s", host)
 	cmd := ssh.Command("ubuntu@"+host, []string{"/bin/bash"}, nil)
 	var stdout, stderr bytes.Buffer
@@ -76,10 +79,7 @@
 	lines := strings.Split(stdout.String(), "\n")
 	series = strings.TrimSpace(lines[0])
 
-	arch, err := arch.NormaliseArch(lines[1])
-	if err != nil {
-		return hc, "", err
-	}
+	arch := arch.NormaliseArch(lines[1])
 	hc.Arch = &arch
 
 	// HardwareCharacteristics wants memory in megabytes,

=== modified file 'environs/testing/tools.go'
--- environs/testing/tools.go	2014-03-17 06:05:54 +0000
+++ environs/testing/tools.go	2014-03-19 02:34:50 +0000
@@ -269,6 +269,9 @@
 	V220q64 = version.MustParseBinary("2.2.0-quantal-amd64")
 	V220all = []version.Binary{V220p64, V220p32, V220q64, V220q32}
 	VAll    = append(V1all, V220all...)
+
+	V310qppc64  = version.MustParseBinary("3.1.0-quantal-ppc64")
+	V3101qppc64 = version.MustParseBinary("3.1.0.1-quantal-ppc64")
 )
 
 type BootstrapToolsTest struct {
@@ -280,15 +283,17 @@
 	Development   bool
 	Arch          string
 	Expect        []version.Binary
-	Err           error
+	Err           string
 }
 
+var noToolsMessage = "Juju cannot bootstrap because no tools are available for your environment.*"
+
 var BootstrapToolsTests = []BootstrapToolsTest{
 	{
 		Info:          "no tools at all",
 		CliVersion:    V100p64,
 		DefaultSeries: "precise",
-		Err:           coretools.ErrNoMatches,
+		Err:           noToolsMessage,
 	}, {
 		Info:          "released cli: use newest compatible release version",
 		Available:     VAll,
@@ -345,70 +350,70 @@
 		Available:     V220all,
 		CliVersion:    V100p64,
 		DefaultSeries: "precise",
-		Err:           coretools.ErrNoMatches,
+		Err:           noToolsMessage,
 	}, {
 		Info:          "released cli: minor upgrades bad",
 		Available:     V120all,
 		CliVersion:    V100p64,
 		DefaultSeries: "precise",
-		Err:           coretools.ErrNoMatches,
+		Err:           noToolsMessage,
 	}, {
 		Info:          "released cli: major downgrades bad",
 		Available:     V100Xall,
 		CliVersion:    V220p64,
 		DefaultSeries: "precise",
-		Err:           coretools.ErrNoMatches,
+		Err:           noToolsMessage,
 	}, {
 		Info:          "released cli: minor downgrades bad",
 		Available:     V100Xall,
 		CliVersion:    V120p64,
 		DefaultSeries: "quantal",
-		Err:           coretools.ErrNoMatches,
+		Err:           noToolsMessage,
 	}, {
 		Info:          "released cli: no matching series",
 		Available:     VAll,
 		CliVersion:    V100p64,
 		DefaultSeries: "raring",
-		Err:           coretools.ErrNoMatches,
+		Err:           noToolsMessage,
 	}, {
 		Info:          "released cli: no matching arches",
 		Available:     VAll,
 		CliVersion:    V100p64,
 		DefaultSeries: "precise",
 		Arch:          "arm",
-		Err:           coretools.ErrNoMatches,
+		Err:           noToolsMessage,
 	}, {
 		Info:          "released cli: specific bad major 1",
 		Available:     VAll,
 		CliVersion:    V220p64,
 		AgentVersion:  V120,
 		DefaultSeries: "precise",
-		Err:           coretools.ErrNoMatches,
+		Err:           noToolsMessage,
 	}, {
 		Info:          "released cli: specific bad major 2",
 		Available:     VAll,
 		CliVersion:    V120p64,
 		AgentVersion:  V220,
 		DefaultSeries: "precise",
-		Err:           coretools.ErrNoMatches,
+		Err:           noToolsMessage,
 	}, {
 		Info:          "released cli: ignore dev tools 1",
 		Available:     V110all,
 		CliVersion:    V100p64,
 		DefaultSeries: "precise",
-		Err:           coretools.ErrNoMatches,
+		Err:           noToolsMessage,
 	}, {
 		Info:          "released cli: ignore dev tools 2",
 		Available:     V110all,
 		CliVersion:    V120p64,
 		DefaultSeries: "precise",
-		Err:           coretools.ErrNoMatches,
+		Err:           noToolsMessage,
 	}, {
 		Info:          "released cli: ignore dev tools 3",
 		Available:     []version.Binary{V1001p64},
 		CliVersion:    V100p64,
 		DefaultSeries: "precise",
-		Err:           coretools.ErrNoMatches,
+		Err:           noToolsMessage,
 	}, {
 		Info:          "released cli with dev setting respects agent-version",
 		Available:     VAll,

=== modified file 'environs/tools/tools_test.go'
--- environs/tools/tools_test.go	2014-03-13 07:54:56 +0000
+++ environs/tools/tools_test.go	2014-03-19 02:34:50 +0000
@@ -240,7 +240,7 @@
 			Arch:    &test.Arch,
 		}
 		actual, err := envtools.FindBootstrapTools(s.env, params)
-		if test.Err != nil {
+		if test.Err != "" {
 			if len(actual) > 0 {
 				c.Logf(actual.String())
 			}

=== modified file 'juju/arch/arch.go'
--- juju/arch/arch.go	2014-03-17 03:38:08 +0000
+++ juju/arch/arch.go	2014-03-19 02:34:50 +0000
@@ -4,11 +4,9 @@
 package arch
 
 import (
-	"fmt"
 	"regexp"
+	"runtime"
 	"strings"
-
-	"launchpad.net/juju-core/utils"
 )
 
 // The following constants define the machine architectures supported by Juju.
@@ -36,32 +34,32 @@
 	arch string
 }{
 	{regexp.MustCompile("amd64|x86_64"), AMD64},
-	{regexp.MustCompile("i[3-9]86"), I386},
+	{regexp.MustCompile("i?[3-9]86"), I386},
 	{regexp.MustCompile("armv.*"), ARM},
 	{regexp.MustCompile("aarch64"), ARM64},
 	{regexp.MustCompile("ppc64el|ppc64le"), PPC64},
 }
 
+// Override for testing.
+var HostArch = hostArch
+
 // HostArch returns the Juju architecture of the machine on which it is run.
-func HostArch() (string, error) {
-	rawArch, err := utils.RunCommand("uname", "-m")
-	if err != nil {
-		return "", err
-	}
-	return NormaliseArch(rawArch)
+func hostArch() string {
+	return NormaliseArch(runtime.GOARCH)
 }
 
-// NormaliseArch returns the Juju architecture corresponding to the
-// output of `uname -m`.
-func NormaliseArch(rawArch string) (string, error) {
+// NormaliseArch returns the Juju architecture corresponding to a machine's
+// reported architecture. The Juju architecture is used to filter simple
+// streams lookup of tools and images.
+func NormaliseArch(rawArch string) string {
 	rawArch = strings.TrimSpace(rawArch)
 	for _, re := range archREs {
 		if re.Match([]byte(rawArch)) {
-			return re.arch, nil
+			return re.arch
 			break
 		}
 	}
-	return "", fmt.Errorf("unrecognised architecture: %s", rawArch)
+	return rawArch
 }
 
 // IsSupportedArch returns true if arch is one supported by Juju.

=== modified file 'juju/arch/arch_test.go'
--- juju/arch/arch_test.go	2014-03-17 03:45:21 +0000
+++ juju/arch/arch_test.go	2014-03-19 02:34:50 +0000
@@ -18,8 +18,7 @@
 var _ = gc.Suite(&archSuite{})
 
 func (s *archSuite) TestHostArch(c *gc.C) {
-	a, err := arch.HostArch()
-	c.Assert(err, gc.IsNil)
+	a := arch.HostArch()
 	c.Assert(arch.IsSupportedArch(a), jc.IsTrue)
 }
 
@@ -28,9 +27,10 @@
 		raw  string
 		arch string
 	}{
-		{"invalid", ""},
+		{"windows", "windows"},
 		{"amd64", "amd64"},
 		{"x86_64", "amd64"},
+		{"386", "i386"},
 		{"i386", "i386"},
 		{"i486", "i386"},
 		{"armv", "arm"},
@@ -39,12 +39,8 @@
 		{"ppc64el", "ppc64"},
 		{"ppc64le", "ppc64"},
 	} {
-		arch, err := arch.NormaliseArch(test.raw)
-		if test.arch == "" {
-			c.Check(err, gc.ErrorMatches, "unrecognised architecture:.*")
-		} else {
-			c.Check(arch, gc.Equals, test.arch)
-		}
+		arch := arch.NormaliseArch(test.raw)
+		c.Check(arch, gc.Equals, test.arch)
 	}
 }
 

=== modified file 'provider/azure/environ.go'
--- provider/azure/environ.go	2014-03-17 03:45:21 +0000
+++ provider/azure/environ.go	2014-03-19 02:34:50 +0000
@@ -302,9 +302,6 @@
 	return req, nil
 }
 
-// supportedArches lists the CPU architectures supported by Azure.
-var supportedArches = []string{arch.AMD64, arch.I386}
-
 // newHostedService creates a hosted service.  It will make up a unique name,
 // starting with the given prefix.
 func newHostedService(azure *gwacl.ManagementAPI, prefix string, affinityGroupName string, location string) (*gwacl.CreateHostedService, error) {
@@ -322,6 +319,14 @@
 	return svc, nil
 }
 
+// supportedArches lists the CPU architectures supported by Azure.
+var supportedArches = []string{arch.AMD64, arch.I386}
+
+// SupportedArchitectures is specified on the EnvironCapability interface.
+func (*azureEnviron) SupportedArchitectures() ([]string, error) {
+	return supportedArches, nil
+}
+
 // selectInstanceTypeAndImage returns the appropriate instance-type name and
 // the OS image name for launching a virtual machine with the given parameters.
 func (env *azureEnviron) selectInstanceTypeAndImage(cons constraints.Value, series, location string) (string, string, error) {

=== modified file 'provider/azure/environ_test.go'
--- provider/azure/environ_test.go	2014-03-13 07:54:56 +0000
+++ provider/azure/environ_test.go	2014-03-19 02:34:50 +0000
@@ -163,6 +163,13 @@
 	return gwacl.PatchManagementAPIResponses(responses)
 }
 
+func (*environSuite) TestSupportedArchitectures(c *gc.C) {
+	env := makeEnviron(c)
+	a, err := env.SupportedArchitectures()
+	c.Assert(err, gc.IsNil)
+	c.Assert(a, gc.DeepEquals, []string{"amd64", "i386"})
+}
+
 func (suite *environSuite) TestGetEnvPrefixContainsEnvName(c *gc.C) {
 	env := makeEnviron(c)
 	c.Check(strings.Contains(env.getEnvPrefix(), env.Name()), jc.IsTrue)

=== modified file 'provider/common/bootstrap.go'
--- provider/common/bootstrap.go	2014-03-17 08:25:06 +0000
+++ provider/common/bootstrap.go	2014-03-19 02:34:50 +0000
@@ -41,6 +41,12 @@
 	var inst instance.Instance
 	defer func() { handleBootstrapError(err, ctx, inst, env) }()
 
+	// First thing, ensure we have tools otherwise there's no point.
+	selectedTools, err := EnsureBootstrapTools(env, env.Config().DefaultSeries(), cons.Arch)
+	if err != nil {
+		return err
+	}
+
 	// Get the bootstrap SSH client. Do this early, so we know
 	// not to bother with any of the below if we can't finish the job.
 	client := ssh.DefaultClient
@@ -64,11 +70,6 @@
 	}
 	machineConfig := environs.NewBootstrapMachineConfig(stateFileURL, privateKey)
 
-	selectedTools, err := EnsureBootstrapTools(env, env.Config().DefaultSeries(), cons.Arch)
-	if err != nil {
-		return err
-	}
-
 	fmt.Fprintln(ctx.GetStderr(), "Launching instance")
 	inst, hw, err := env.StartInstance(environs.StartInstanceParams{
 		Constraints:   cons,

=== modified file 'provider/common/bootstrap_test.go'
--- provider/common/bootstrap_test.go	2014-03-13 07:54:56 +0000
+++ provider/common/bootstrap_test.go	2014-03-19 02:34:50 +0000
@@ -80,7 +80,7 @@
 		Storage: newStorage(s, c),
 		putErr:  fmt.Errorf("noes!"),
 	}
-	env := &mockEnviron{storage: brokenStorage}
+	env := &mockEnviron{storage: brokenStorage, config: configGetter(c)}
 	ctx := coretesting.Context(c)
 	err := common.Bootstrap(ctx, env, constraints.Value{})
 	c.Assert(err, gc.ErrorMatches, "cannot create initial state file: noes!")

=== modified file 'provider/common/mock_test.go'
--- provider/common/mock_test.go	2014-03-13 05:09:14 +0000
+++ provider/common/mock_test.go	2014-03-19 02:34:50 +0000
@@ -38,6 +38,10 @@
 	return "mock environment"
 }
 
+func (*mockEnviron) SupportedArchitectures() ([]string, error) {
+	return []string{"amd64", "arm64"}, nil
+}
+
 func (env *mockEnviron) Storage() storage.Storage {
 	return env.storage
 }

=== modified file 'provider/dummy/environs.go'
--- provider/dummy/environs.go	2014-03-13 05:09:14 +0000
+++ provider/dummy/environs.go	2014-03-19 02:34:50 +0000
@@ -44,6 +44,7 @@
 	"launchpad.net/juju-core/environs/storage"
 	"launchpad.net/juju-core/environs/tools"
 	"launchpad.net/juju-core/instance"
+	"launchpad.net/juju-core/juju/arch"
 	"launchpad.net/juju-core/names"
 	"launchpad.net/juju-core/provider"
 	"launchpad.net/juju-core/provider/common"
@@ -524,6 +525,11 @@
 	return e.name
 }
 
+// SupportedArchitectures is specified on the EnvironCapability interface.
+func (*environ) SupportedArchitectures() ([]string, error) {
+	return []string{arch.AMD64, arch.PPC64}, nil
+}
+
 // GetImageSources returns a list of sources which are used to search for simplestreams image metadata.
 func (e *environ) GetImageSources() ([]simplestreams.DataSource, error) {
 	return []simplestreams.DataSource{

=== modified file 'provider/ec2/ec2.go'
--- provider/ec2/ec2.go	2014-03-17 03:45:21 +0000
+++ provider/ec2/ec2.go	2014-03-19 02:34:50 +0000
@@ -337,6 +337,11 @@
 	return common.StateInfo(e)
 }
 
+// SupportedArchitectures is specified on the EnvironCapability interface.
+func (*environ) SupportedArchitectures() ([]string, error) {
+	return supportedArches, nil
+}
+
 // MetadataLookupParams returns parameters which are used to query simplestreams metadata.
 func (e *environ) MetadataLookupParams(region string) (*simplestreams.MetadataLookupParams, error) {
 	if region == "" {

=== modified file 'provider/ec2/local_test.go'
--- provider/ec2/local_test.go	2014-03-13 20:52:41 +0000
+++ provider/ec2/local_test.go	2014-03-19 02:34:50 +0000
@@ -399,6 +399,13 @@
 	c.Assert(strings.Contains(url, ec2.ControlBucketName(env)+"/tools"), jc.IsTrue)
 }
 
+func (t *localServerSuite) TestSupportedArchitectures(c *gc.C) {
+	env := t.Prepare(c)
+	a, err := env.SupportedArchitectures()
+	c.Assert(err, gc.IsNil)
+	c.Assert(a, gc.DeepEquals, []string{"amd64", "i386"})
+}
+
 // localNonUSEastSuite is similar to localServerSuite but the S3 mock server
 // behaves as if it is not in the us-east region.
 type localNonUSEastSuite struct {

=== modified file 'provider/joyent/environ.go'
--- provider/joyent/environ.go	2014-03-10 00:10:29 +0000
+++ provider/joyent/environ.go	2014-03-19 02:34:50 +0000
@@ -10,6 +10,7 @@
 	"launchpad.net/juju-core/environs"
 	"launchpad.net/juju-core/environs/config"
 	"launchpad.net/juju-core/environs/storage"
+	"launchpad.net/juju-core/juju/arch"
 	"launchpad.net/juju-core/provider/common"
 	"launchpad.net/juju-core/state"
 	"launchpad.net/juju-core/state/api"
@@ -45,6 +46,11 @@
 	return providerInstance
 }
 
+// SupportedArchitectures is specified on the EnvironCapability interface.
+func (*environ) SupportedArchitectures() ([]string, error) {
+	return []string{arch.AMD64}, nil
+}
+
 func (env *environ) SetConfig(cfg *config.Config) error {
 	env.lock.Lock()
 	defer env.lock.Unlock()

=== modified file 'provider/local/environ.go'
--- provider/local/environ.go	2014-03-18 03:51:15 +0000
+++ provider/local/environ.go	2014-03-19 02:34:50 +0000
@@ -33,6 +33,7 @@
 	"launchpad.net/juju-core/environs/storage"
 	envtools "launchpad.net/juju-core/environs/tools"
 	"launchpad.net/juju-core/instance"
+	"launchpad.net/juju-core/juju/arch"
 	"launchpad.net/juju-core/juju/osenv"
 	"launchpad.net/juju-core/provider/common"
 	"launchpad.net/juju-core/state"
@@ -70,6 +71,12 @@
 		storage.NewStorageSimpleStreamsDataSource("cloud storage", e.Storage(), storage.BaseToolsPath)}, nil
 }
 
+// SupportedArchitectures is specified on the EnvironCapability interface.
+func (*localEnviron) SupportedArchitectures() ([]string, error) {
+	localArch := arch.HostArch()
+	return []string{localArch}, nil
+}
+
 // Name is specified in the Environ interface.
 func (env *localEnviron) Name() string {
 	return env.name

=== modified file 'provider/local/environ_test.go'
--- provider/local/environ_test.go	2014-03-13 07:54:56 +0000
+++ provider/local/environ_test.go	2014-03-19 02:34:50 +0000
@@ -20,6 +20,7 @@
 	"launchpad.net/juju-core/environs/jujutest"
 	envtesting "launchpad.net/juju-core/environs/testing"
 	"launchpad.net/juju-core/environs/tools"
+	"launchpad.net/juju-core/juju/arch"
 	"launchpad.net/juju-core/juju/osenv"
 	"launchpad.net/juju-core/provider/local"
 	"launchpad.net/juju-core/state/api/params"
@@ -77,6 +78,18 @@
 	c.Assert(strings.Contains(url, "/tools"), jc.IsTrue)
 }
 
+func (*environSuite) TestSupportedArchitectures(c *gc.C) {
+	testConfig := minimalConfig(c)
+	environ, err := local.Provider.Open(testConfig)
+	c.Assert(err, gc.IsNil)
+	c.Assert(err, gc.IsNil)
+	arches, err := environ.SupportedArchitectures()
+	c.Assert(err, gc.IsNil)
+	for _, a := range arches {
+		c.Assert(arch.IsSupportedArch(a), jc.IsTrue)
+	}
+}
+
 type localJujuTestSuite struct {
 	baseProviderSuite
 	jujutest.Tests

=== modified file 'provider/maas/environ.go'
--- provider/maas/environ.go	2014-03-14 13:57:26 +0000
+++ provider/maas/environ.go	2014-03-19 02:34:50 +0000
@@ -22,6 +22,7 @@
 	"launchpad.net/juju-core/environs/storage"
 	envtools "launchpad.net/juju-core/environs/tools"
 	"launchpad.net/juju-core/instance"
+	"launchpad.net/juju-core/juju/arch"
 	"launchpad.net/juju-core/provider/common"
 	"launchpad.net/juju-core/state"
 	"launchpad.net/juju-core/state/api"
@@ -130,6 +131,12 @@
 	return nil
 }
 
+// SupportedArchitectures is specified on the EnvironCapability interface.
+func (*maasEnviron) SupportedArchitectures() ([]string, error) {
+	// TODO(wallyworld) - how to find out what architectures a MAAS environ supports
+	return arch.AllSupportedArches, nil
+}
+
 // getMAASClient returns a MAAS client object to use for a request, in a
 // lock-protected fashion.
 func (env *maasEnviron) getMAASClient() *gomaasapi.MAASObject {

=== modified file 'provider/maas/environ_test.go'
--- provider/maas/environ_test.go	2013-12-06 11:00:58 +0000
+++ provider/maas/environ_test.go	2014-03-19 02:34:50 +0000
@@ -11,6 +11,7 @@
 
 	"launchpad.net/juju-core/environs/config"
 	envtesting "launchpad.net/juju-core/environs/testing"
+	"launchpad.net/juju-core/juju/arch"
 	"launchpad.net/juju-core/provider/maas"
 	coretesting "launchpad.net/juju-core/testing"
 	"launchpad.net/juju-core/testing/testbase"
@@ -56,8 +57,6 @@
 	s.LoggingSuite.TearDownSuite(c)
 }
 
-var _ = gc.Suite(&environSuite{})
-
 func getSimpleTestConfig(c *gc.C, extraAttrs coretesting.Attrs) *config.Config {
 	attrs := coretesting.FakeConfig()
 	attrs["type"] = "maas"
@@ -195,3 +194,12 @@
 	c.Check(err, gc.IsNil)
 	c.Check(env.Name(), gc.Equals, "testenv")
 }
+
+func (*environSuite) TestSupportedArchitectures(c *gc.C) {
+	cfg := getSimpleTestConfig(c, nil)
+	env, err := maas.NewEnviron(cfg)
+	c.Assert(err, gc.IsNil)
+	a, err := env.SupportedArchitectures()
+	c.Assert(err, gc.IsNil)
+	c.Assert(a, gc.DeepEquals, arch.AllSupportedArches)
+}

=== modified file 'provider/maas/environ_whitebox_test.go'
--- provider/maas/environ_whitebox_test.go	2014-03-13 07:54:56 +0000
+++ provider/maas/environ_whitebox_test.go	2014-03-19 02:34:50 +0000
@@ -9,6 +9,7 @@
 	"fmt"
 	"io/ioutil"
 	"net/url"
+	"strings"
 
 	jc "github.com/juju/testing/checkers"
 	gc "launchpad.net/gocheck"
@@ -385,7 +386,10 @@
 	err = env.SetConfig(cfg)
 	c.Assert(err, gc.IsNil)
 	err = bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
-	c.Check(err, gc.ErrorMatches, "cannot find bootstrap tools.*")
+	stripped := strings.Replace(err.Error(), "\n", "", -1)
+	c.Check(stripped,
+		gc.Matches,
+		"cannot upload bootstrap tools: Juju cannot bootstrap because no tools are available for your environment.*")
 }
 
 func (suite *environSuite) TestBootstrapFailsIfNoNodes(c *gc.C) {

=== modified file 'provider/manual/environ.go'
--- provider/manual/environ.go	2014-03-13 05:09:14 +0000
+++ provider/manual/environ.go	2014-03-19 02:34:50 +0000
@@ -89,6 +89,17 @@
 	return e.envConfig().Name()
 }
 
+// SupportedArchitectures is specified on the EnvironCapability interface.
+func (e *manualEnviron) SupportedArchitectures() ([]string, error) {
+	envConfig := e.envConfig()
+	host := envConfig.bootstrapHost()
+	hc, _, err := manual.DetectSeriesAndHardwareCharacteristics(host)
+	if err != nil {
+		return nil, err
+	}
+	return []string{*hc.Arch}, nil
+}
+
 func (e *manualEnviron) Bootstrap(ctx environs.BootstrapContext, cons constraints.Value) error {
 	// Set "use-sshstorage" to false, so agents know not to use sshstorage.
 	cfg, err := e.Config().Apply(map[string]interface{}{"use-sshstorage": false})

=== modified file 'provider/manual/environ_test.go'
--- provider/manual/environ_test.go	2014-03-13 07:54:56 +0000
+++ provider/manual/environ_test.go	2014-03-19 02:34:50 +0000
@@ -129,3 +129,13 @@
 	c.Assert(err, gc.IsNil)
 	c.Assert(strings.Contains(url, "/tools"), jc.IsTrue)
 }
+
+func (s *environSuite) TestSupportedArchitectures(c *gc.C) {
+	s.PatchValue(&manual.DetectSeriesAndHardwareCharacteristics, func(host string) (instance.HardwareCharacteristics, string, error) {
+		c.Assert(host, gc.Equals, "hostname")
+		return instance.MustParseHardware("arch=arm64"), "precise", nil
+	})
+	a, err := s.env.SupportedArchitectures()
+	c.Assert(err, gc.IsNil)
+	c.Assert(a, gc.DeepEquals, []string{"arm64"})
+}

=== modified file 'provider/openstack/local_test.go'
--- provider/openstack/local_test.go	2014-03-13 07:54:56 +0000
+++ provider/openstack/local_test.go	2014-03-19 02:34:50 +0000
@@ -587,6 +587,13 @@
 	c.Assert(err, gc.IsNil)
 }
 
+func (s *localServerSuite) TestSupportedArchitectures(c *gc.C) {
+	env := s.Open(c)
+	a, err := env.SupportedArchitectures()
+	c.Assert(err, gc.IsNil)
+	c.Assert(a, gc.DeepEquals, []string{"amd64", "arm", "arm64", "ppc64"})
+}
+
 func (s *localServerSuite) TestFindImageBadDefaultImage(c *gc.C) {
 	// Prevent falling over to the public datasource.
 	s.PatchValue(&imagemetadata.DefaultBaseURL, "")

=== modified file 'provider/openstack/provider.go'
--- provider/openstack/provider.go	2014-03-17 03:45:21 +0000
+++ provider/openstack/provider.go	2014-03-19 02:34:50 +0000
@@ -520,6 +520,11 @@
 	return e.name
 }
 
+// SupportedArchitectures is specified on the EnvironCapability interface.
+func (*environ) SupportedArchitectures() ([]string, error) {
+	return supportedArches, nil
+}
+
 func (e *environ) Storage() storage.Storage {
 	e.ecfgMutex.Lock()
 	stor := e.storageUnlocked

=== modified file 'version/version.go'
--- version/version.go	2014-03-14 16:45:23 +0000
+++ version/version.go	2014-03-19 02:34:50 +0000
@@ -12,11 +12,12 @@
 	"os"
 	"path/filepath"
 	"regexp"
-	"runtime"
 	"strconv"
 	"strings"
 
 	"labix.org/v2/mgo/bson"
+
+	"launchpad.net/juju-core/juju/arch"
 )
 
 // The presence and format of this constant is very important.
@@ -34,7 +35,7 @@
 var Current = Binary{
 	Number: MustParse(version),
 	Series: readSeries(lsbReleaseFile),
-	Arch:   ubuntuArch(runtime.GOARCH),
+	Arch:   arch.HostArch(),
 }
 
 func init() {
@@ -340,13 +341,6 @@
 	return ""
 }
 
-func ubuntuArch(arch string) string {
-	if arch == "386" {
-		arch = "i386"
-	}
-	return arch
-}
-
 // ParseMajorMinor takes an argument of the form "major.minor" and returns ints major and minor.
 func ParseMajorMinor(vers string) (int, int, error) {
 	parts := strings.Split(vers, ".")