Merge lp:~axwalk/juju-core/envcmd-inversion into lp:~go-bot/juju-core/trunk

[Andrew Wilkins]

Invert envcmd relationship

Previously we embedded EnvCommandBase in all commands
requring an environment, and EnvCommandBase included
everything (SetFlags, and Init). The problem with this
is that it was easy to miss initialisation of the
EnvCommandBase type (this happened a few times), which
leads to bad things happening like sync-tools destroying
environments.

I have inverted the relationship so that we now have
envcmd.EnvironCommand, an interface that extends Command
with a SetEnvName method, and EnvCommandBase, which
implements EnvironCommand. A new method, envcmd.Wrap takes
an EnvironCommand and creates a Command that calls
SetEnvName prior to the wrapped method's Init method. If
the environment name cannot be determined, the wrapping
command will error out early.

https://codereview.appspot.com/94350045/

Invert envcmd relationship

Previously we embedded EnvCommandBase in all commands
requring an environment, and EnvCommandBase included
everything (SetFlags, and Init). The problem with this
is that it was easy to miss initialisation of the
EnvCommandBase type (this happened a few times), which
leads to bad things happening like sync-tools destroying
environments.

I have inverted the relationship so that we now have
envcmd.EnvironCommand, an interface that extends Command
with a SetEnvName method, and EnvCommandBase, which
implements EnvironCommand. A new method, envcmd.Wrap takes
an EnvironCommand and creates a Command that calls
SetEnvName prior to the wrapped method's Init method. If
the environment name cannot be determined, the wrapping
command will error out early.

https://codereview.appspot.com/94350045/

[Andrew Wilkins (axwalk)]

Reviewers: mp+219135_code.launchpad.net,

Message:
Please take a look.

Description:
Invert envcmd relationship

Previously we embedded EnvCommandBase in all commands
requring an environment, and EnvCommandBase included
everything (SetFlags, and Init). The problem with this
is that it was easy to miss initialisation of the
EnvCommandBase type (this happened a few times), which
leads to bad things happening like sync-tools destroying
environments.

I have inverted the relationship so that we now have
envcmd.EnvironCommand, an interface that extends Command
with a SetEnvName method, and EnvCommandBase, which
implements EnvironCommand. A new method, envcmd.Wrap takes
an EnvironCommand and creates a Command that calls
SetEnvName prior to the wrapped method's Init method. If
the environment name cannot be determined, the wrapping
command will error out early.

https://code.launchpad.net/~axwalk/juju-core/envcmd-inversion/+merge/219135

(do not edit description out of merge proposal)

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

Affected files (+354, -440 lines):
   A [revision details]
   M cmd/cmd.go
   M cmd/envcmd/environmentcommand.go
   M cmd/envcmd/environmentcommand_test.go
   M cmd/juju/addmachine.go
   M cmd/juju/addmachine_test.go
   M cmd/juju/addrelation.go
   M cmd/juju/addrelation_test.go
   M cmd/juju/addunit.go
   M cmd/juju/addunit_test.go
   M cmd/juju/adduser.go
   M cmd/juju/adduser_test.go
   M cmd/juju/authorizedkeys_add.go
   M cmd/juju/authorizedkeys_delete.go
   M cmd/juju/authorizedkeys_import.go
   M cmd/juju/authorizedkeys_list.go
   M cmd/juju/authorizedkeys_test.go
   M cmd/juju/bootstrap.go
   M cmd/juju/bootstrap_test.go
   M cmd/juju/cmd_test.go
   M cmd/juju/constraints.go
   M cmd/juju/constraints_test.go
   M cmd/juju/debuglog.go
   M cmd/juju/debuglog_test.go
   M cmd/juju/deploy.go
   M cmd/juju/deploy_test.go
   M cmd/juju/endpoint.go
   M cmd/juju/endpoint_test.go
   M cmd/juju/ensureavailability.go
   M cmd/juju/ensureavailability_test.go
   M cmd/juju/environment.go
   M cmd/juju/environment_test.go
   M cmd/juju/expose.go
   M cmd/juju/expose_test.go
   M cmd/juju/get.go
   M cmd/juju/get_test.go
   M cmd/juju/main.go
   M cmd/juju/main_test.go
   M cmd/juju/plugin.go
   M cmd/juju/publish.go
   M cmd/juju/publish_test.go
   M cmd/juju/removemachine.go
   M cmd/juju/removemachine_test.go
   M cmd/juju/removerelation.go
   M cmd/juju/removerelation_test.go
   M cmd/juju/removeservice.go
   M cmd/juju/removeservice_test.go
   M cmd/juju/removeunit.go
   M cmd/juju/removeunit_test.go
   M cmd/juju/removeuser.go
   M cmd/juju/removeuser_test.go
   M cmd/juju/resolved.go
   M cmd/juju/resolved_test.go
   M cmd/juju/retryprovisioning.go
   M cmd/juju/retryprovisioning_test.go
   M cmd/juju/run.go
   M cmd/juju/run_test.go
   M cmd/juju/set.go
   M cmd/juju/set_test.go
   M cmd/juju/ssh.go
   M cmd/juju/ssh_test.go
   M cmd/juju/status.go
   M cmd/juju/status_test.go
   M cmd/juju/synctools.go
   M cmd/juju/synctools_test.go
   M cmd/juju/unexpose.go
   M cmd/juju/unexpose_test.go
   M cmd/juju/unset.go
   M cmd/juju/unset_test.go
   M cmd/juju/upgradecharm.go
   M cmd/juju/upgradecharm_test....

[Ian Booth (wallyworld)]

LGTM with perhaps a 2nd opinion from William.

It does seem that we are missing tests to ensure that each command is
wrapped as expected. We test the wrapping function itself in
environmentcommand but I can't see how or where we are testing that each
business command is wrapped eg for add-machine, how do we test that it
has been registered using
jujucmd.Register(wrap(&AddMachineCommand{}))and not just
jujucmd.Register(&AddMachineCommand{})

We should be able to iterate over all registered commands to check. Can
we do this before landing?

https://codereview.appspot.com/94350045/

[William Reade (fwereade)]

This LGTM as far as it goes (modulo the need for testing -- I'd like it
to be impossible to *casually* add a command that isn't an environment
command).

But I'm wondering whether it's rational to take it a step further -- do
something like insert the EnvName into the Run args, such that the
commands we create/test/etc are not actually cmd.Commands -- thereby
making it impossible(?) to accidentally register an unwrapped env
command.

FWIW, if it were structured that way, I'd be less dogmatic about the
need for testing the list of registered commands...

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

https://codereview.appspot.com/94350045/diff/1/cmd/juju/main.go#newcode140
cmd/juju/main.go:140: jujucmd.Register(wrap(&cmd.VersionCommand{}))
Yeah, as Ian suggested, I'd really like us to be able to directly test
that we actually get functional environment commands -- and ideally we'd
get this tested on *every* registered command.

https://codereview.appspot.com/94350045/

[Andrew Wilkins (axwalk)]

On 2014/05/12 07:24:18, fwereade wrote:
> This LGTM as far as it goes (modulo the need for testing -- I'd like
it to be
> impossible to *casually* add a command that isn't an environment
command).

> But I'm wondering whether it's rational to take it a step further --
do
> something like insert the EnvName into the Run args, such that the
commands we
> create/test/etc are not actually cmd.Commands -- thereby making it
impossible(?)
> to accidentally register an unwrapped env command.

Not all commands operate on an environment. I started down this path of
having an alternative Run method (RunInEnv) which takes *cmd.Context and
envName, but found it too clumsy. The approach I've taken takes us in
that direction, so it could be changed with less churn later if desired.

> FWIW, if it were structured that way, I'd be less dogmatic about the
need for
> testing the list of registered commands...

> https://codereview.appspot.com/94350045/diff/1/cmd/juju/main.go
> File cmd/juju/main.go (right):

https://codereview.appspot.com/94350045/diff/1/cmd/juju/main.go#newcode140
> cmd/juju/main.go:140: jujucmd.Register(wrap(&cmd.VersionCommand{}))
> Yeah, as Ian suggested, I'd really like us to be able to directly test
that we
> actually get functional environment commands -- and ideally we'd get
this tested
> on *every* registered command.

I'll add a test that checks each registered command is an environment
command, with a list of exceptions.

https://codereview.appspot.com/94350045/

[Andrew Wilkins (axwalk)]

On 2014/05/12 07:53:07, axw wrote:
> On 2014/05/12 07:24:18, fwereade wrote:
> > This LGTM as far as it goes (modulo the need for testing -- I'd like
it to be
> > impossible to *casually* add a command that isn't an environment
command).
> >
> > But I'm wondering whether it's rational to take it a step further --
do
> > something like insert the EnvName into the Run args, such that the
commands we
> > create/test/etc are not actually cmd.Commands -- thereby making it
> impossible(?)
> > to accidentally register an unwrapped env command.

> Not all commands operate on an environment. I started down this path
of having
> an alternative Run method (RunInEnv) which takes *cmd.Context and
envName, but
> found it too clumsy. The approach I've taken takes us in that
direction, so it
> could be changed with less churn later if desired.

> > FWIW, if it were structured that way, I'd be less dogmatic about the
need for
> > testing the list of registered commands...
> >
> > https://codereview.appspot.com/94350045/diff/1/cmd/juju/main.go
> > File cmd/juju/main.go (right):
> >
> >
https://codereview.appspot.com/94350045/diff/1/cmd/juju/main.go#newcode140
> > cmd/juju/main.go:140: jujucmd.Register(wrap(&cmd.VersionCommand{}))
> > Yeah, as Ian suggested, I'd really like us to be able to directly
test that we
> > actually get functional environment commands -- and ideally we'd get
this
> tested
> > on *every* registered command.

> I'll add a test that checks each registered command is an environment
command,
> with a list of exceptions.

Actually the test is simpler than that: it just checks that there are no
EnvironCommands registered. All EnvironCommands must be wrapped.

https://codereview.appspot.com/94350045/

[Andrew Wilkins (axwalk)]

Please take a look.

https://codereview.appspot.com/94350045/

[Ian Booth (wallyworld)]

On 2014/05/12 11:11:19, axw wrote:
> Please take a look.

LGTM

https://codereview.appspot.com/94350045/

[Go Bot (go-bot)]

The attempt to merge lp:~axwalk/juju-core/envcmd-inversion into lp:juju-core failed. Below is the output from the failed tests.

ok launchpad.net/juju-core 0.013s
ok launchpad.net/juju-core/agent 0.885s
ok launchpad.net/juju-core/agent/mongo 0.441s
ok launchpad.net/juju-core/agent/tools 0.219s
ok launchpad.net/juju-core/bzr 4.744s
ok launchpad.net/juju-core/cert 2.578s
ok launchpad.net/juju-core/charm 0.511s
? 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.026s
ok launchpad.net/juju-core/cloudinit/sshinit 0.781s
ok launchpad.net/juju-core/cmd 0.142s
ok launchpad.net/juju-core/cmd/charm-admin 0.276s
? launchpad.net/juju-core/cmd/charmd [no test files]
? launchpad.net/juju-core/cmd/charmload [no test files]
ok launchpad.net/juju-core/cmd/envcmd 0.181s
ok launchpad.net/juju-core/cmd/juju 218.654s
ok launchpad.net/juju-core/cmd/jujud 65.577s
ok launchpad.net/juju-core/cmd/plugins/juju-metadata 9.149s
? launchpad.net/juju-core/cmd/plugins/juju-restore [no test files]
ok launchpad.net/juju-core/cmd/plugins/local 0.179s
? launchpad.net/juju-core/cmd/plugins/local/juju-local [no test files]
ok launchpad.net/juju-core/constraints 0.028s
ok launchpad.net/juju-core/container 0.040s
ok launchpad.net/juju-core/container/factory 0.037s
ok launchpad.net/juju-core/container/kvm 0.166s
ok launchpad.net/juju-core/container/kvm/mock 0.040s
? launchpad.net/juju-core/container/kvm/testing [no test files]
ok launchpad.net/juju-core/container/lxc 4.283s
? launchpad.net/juju-core/container/lxc/mock [no test files]
? launchpad.net/juju-core/container/lxc/testing [no test files]
? launchpad.net/juju-core/container/testing [no test files]
ok launchpad.net/juju-core/downloader 5.206s
ok launchpad.net/juju-core/environs 2.176s
ok launchpad.net/juju-core/environs/bootstrap 12.224s
ok launchpad.net/juju-core/environs/cloudinit 0.420s
ok launchpad.net/juju-core/environs/config 1.910s
ok launchpad.net/juju-core/environs/configstore 0.029s
ok launchpad.net/juju-core/environs/filestorage 0.024s
ok launchpad.net/juju-core/environs/httpstorage 0.645s
ok launchpad.net/juju-core/environs/imagemetadata 0.416s
? launchpad.net/juju-core/environs/imagemetadata/testing [no test files]
ok launchpad.net/juju-core/environs/instances 0.044s
ok launchpad.net/juju-core/environs/jujutest 0.168s
ok launchpad.net/juju-core/environs/manual 8.986s
? launchpad.net/juju-core/environs/network [no test files]
ok launchpad.net/juju-core/environs/simplestreams 0.246s
? launchpad.net/juju-core/environs/simplestreams/testing [no test files]
ok launchpad.net/juju-core/environs/sshstorage 0.858s
ok launchpad.net/juju-core/environs/storage 0.757s
ok launchpad.net/juju-core/environs/sync 50.475s
ok launchpad.net/juju-core/environs/testing 0.133s
ok launchpad.net/juju-core/environs/tools 4.920s
? launchpad.net/juju-core/environs/tools/testing [no test files]
ok launchpad.net/juju-core/errors 0.015s
ok launchpad.net/juju-core/instance 0.019s
? launchpad.net/juju-core/instance/testing [...

=== modified file 'cmd/cmd.go'
--- cmd/cmd.go	2014-04-01 07:47:11 +0000
+++ cmd/cmd.go	2014-05-12 11:08:32 +0000
@@ -210,20 +210,23 @@
 	return buf.Bytes()
 }
 
-// Errors from commands can be either ErrHelp, which means "show the help" or
-// some other error related to needed flags missing, or needed positional args
-// missing, in which case we should print the error and return a non-zero
-// return code.
-func handleCommandError(c Command, ctx *Context, err error, f *gnuflag.FlagSet) (int, bool) {
-	if err == gnuflag.ErrHelp {
+// Errors from commands can be ErrSilent (don't print an error message),
+// ErrHelp (show the help) or some other error related to needed flags
+// missing, or needed positional args missing, in which case we should
+// print the error and return a non-zero return code.
+func handleCommandError(c Command, ctx *Context, err error, f *gnuflag.FlagSet) (rc int, done bool) {
+	switch err {
+	case nil:
+		return 0, false
+	case gnuflag.ErrHelp:
 		ctx.Stdout.Write(c.Info().Help(f))
 		return 0, true
-	}
-	if err != nil {
+	case ErrSilent:
+		return 2, true
+	default:
 		fmt.Fprintf(ctx.Stderr, "error: %v\n", err)
 		return 2, true
 	}
-	return 0, false
 }
 
 // Main runs the given Command in the supplied Context with the given

=== modified file 'cmd/envcmd/environmentcommand.go'
--- cmd/envcmd/environmentcommand.go	2014-05-09 13:24:50 +0000
+++ cmd/envcmd/environmentcommand.go	2014-05-12 11:08:32 +0000
@@ -24,13 +24,6 @@
 // has been explicitly specified, and there is no default environment.
 var ErrNoEnvironmentSpecified = fmt.Errorf("no environment specified")
 
-// The purpose of EnvCommandBase is to provide a default member and flag
-// setting for commands that deal across different environments.
-type EnvCommandBase struct {
-	cmd.CommandBase
-	EnvName string
-}
-
 func getCurrentEnvironmentFilePath() string {
 	return filepath.Join(osenv.JujuHome(), CurrentEnvironmentFilename)
 }
@@ -60,39 +53,86 @@
 
 // There is simple ordering for the default environment.  Firstly check the
 // JUJU_ENV environment variable.  If that is set, it gets used.  If it isn't
-// set, look in the $JUJU_HOME/current-environment file.
-func getDefaultEnvironment() string {
-	defaultEnv := os.Getenv(osenv.JujuEnvEnvKey)
-	if defaultEnv != "" {
-		return defaultEnv
-	}
-	return ReadCurrentEnvironment()
-}
-
-// EnsureEnvName ensures that c.EnvName is non-empty, or sets it to the default
-// environment name. If there is no default environment name, then
-// EnsureEnvName returns ErrNoEnvironmentSpecified.
-func (c *EnvCommandBase) EnsureEnvName() error {
-	if c.EnvName == "" {
-		envs, err := environs.ReadEnvirons("")
-		if err != nil {
-			return err
-		}
-		if envs.Default == "" {
-			return ErrNoEnvironmentSpecified
-		}
-		c.EnvName = envs.Default
-	}
+// set, look in the $JUJU_HOME/current-environment file.  If neither are
+// available, read environments.yaml and use the default environment therein.
+func getDefaultEnvironment() (string, error) {
+	if defaultEnv := os.Getenv(osenv.JujuEnvEnvKey); defaultEnv != "" {
+		return defaultEnv, nil
+	}
+	if currentEnv := ReadCurrentEnvironment(); currentEnv != "" {
+		return currentEnv, nil
+	}
+	envs, err := environs.ReadEnvirons("")
+	if err != nil {
+		return "", err
+	}
+	if envs.Default == "" {
+		return "", ErrNoEnvironmentSpecified
+	}
+	return envs.Default, nil
+}
+
+// EnvironCommand extends cmd.Command with a SetEnvName method.
+type EnvironCommand interface {
+	cmd.Command
+
+	// SetEnvName is called prior to the wrapped command's Init method
+	// with the active environment name. The environment name is guaranteed
+	// to be non-empty at entry of Init.
+	SetEnvName(envName string)
+}
+
+// EnvCommandBase is a convenience type for embedding in commands
+// that wish to implement EnvironCommand.
+type EnvCommandBase struct {
+	cmd.CommandBase
+	EnvName string
+}
+
+func (c *EnvCommandBase) SetEnvName(envName string) {
+	c.EnvName = envName
+}
+
+// Wrap wraps the specified EnvironCommand, returning a Command
+// that proxies to each of the EnvironCommand methods.
+func Wrap(c EnvironCommand) cmd.Command {
+	return &environCommandWrapper{EnvironCommand: c}
+}
+
+type environCommandWrapper struct {
+	EnvironCommand
+	envName string
+}
+
+func (w *environCommandWrapper) EnvironName() string {
+	return w.envName
+}
+
+// ensureEnvName ensures that w.envName is non-empty, or sets it to
+// the default environment name. If there is no default environment name,
+// then ensureEnvName returns ErrNoEnvironmentSpecified.
+func (w *environCommandWrapper) ensureEnvName() error {
+	if w.envName != "" {
+		return nil
+	}
+	defaultEnv, err := getDefaultEnvironment()
+	if err != nil {
+		return err
+	}
+	w.envName = defaultEnv
 	return nil
 }
 
-func (c *EnvCommandBase) SetFlags(f *gnuflag.FlagSet) {
-	defaultEnv := getDefaultEnvironment()
-	f.StringVar(&c.EnvName, "e", defaultEnv, "juju environment to operate in")
-	f.StringVar(&c.EnvName, "environment", defaultEnv, "")
+func (w *environCommandWrapper) SetFlags(f *gnuflag.FlagSet) {
+	f.StringVar(&w.envName, "e", "", "juju environment to operate in")
+	f.StringVar(&w.envName, "environment", "", "")
+	w.EnvironCommand.SetFlags(f)
 }
 
-// EnvironName returns the name of the environment for this command
-func (c *EnvCommandBase) EnvironName() string {
-	return c.EnvName
+func (w *environCommandWrapper) Init(args []string) error {
+	if err := w.ensureEnvName(); err != nil {
+		return err
+	}
+	w.SetEnvName(w.envName)
+	return w.EnvironCommand.Init(args)
 }

=== modified file 'cmd/envcmd/environmentcommand_test.go'
--- cmd/envcmd/environmentcommand_test.go	2014-05-09 13:24:50 +0000
+++ cmd/envcmd/environmentcommand_test.go	2014-05-12 11:08:32 +0000
@@ -12,6 +12,7 @@
 	"launchpad.net/gnuflag"
 	gc "launchpad.net/gocheck"
 
+	"launchpad.net/juju-core/cmd"
 	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/environs"
 	"launchpad.net/juju-core/juju/osenv"
@@ -47,29 +48,33 @@
 }
 
 func (s *EnvironmentCommandSuite) TestGetDefaultEnvironmentNothingSet(c *gc.C) {
-	env := envcmd.GetDefaultEnvironment()
+	env, err := envcmd.GetDefaultEnvironment()
 	c.Assert(env, gc.Equals, "")
+	c.Assert(err, jc.Satisfies, environs.IsNoEnv)
 }
 
 func (s *EnvironmentCommandSuite) TestGetDefaultEnvironmentCurrentEnvironmentSet(c *gc.C) {
 	err := envcmd.WriteCurrentEnvironment("fubar")
 	c.Assert(err, gc.IsNil)
-	env := envcmd.GetDefaultEnvironment()
+	env, err := envcmd.GetDefaultEnvironment()
 	c.Assert(env, gc.Equals, "fubar")
+	c.Assert(err, gc.IsNil)
 }
 
 func (s *EnvironmentCommandSuite) TestGetDefaultEnvironmentJujuEnvSet(c *gc.C) {
 	os.Setenv(osenv.JujuEnvEnvKey, "magic")
-	env := envcmd.GetDefaultEnvironment()
+	env, err := envcmd.GetDefaultEnvironment()
 	c.Assert(env, gc.Equals, "magic")
+	c.Assert(err, gc.IsNil)
 }
 
 func (s *EnvironmentCommandSuite) TestGetDefaultEnvironmentBothSet(c *gc.C) {
 	os.Setenv(osenv.JujuEnvEnvKey, "magic")
 	err := envcmd.WriteCurrentEnvironment("fubar")
 	c.Assert(err, gc.IsNil)
-	env := envcmd.GetDefaultEnvironment()
+	env, err := envcmd.GetDefaultEnvironment()
 	c.Assert(env, gc.Equals, "magic")
+	c.Assert(err, gc.IsNil)
 }
 
 func (s *EnvironmentCommandSuite) TestWriteAddsNewline(c *gc.C) {
@@ -87,12 +92,12 @@
 	c.Assert(err, gc.ErrorMatches, "unable to write to the environment file: .*")
 }
 
-func (s *EnvironmentCommandSuite) TestEnsureEnvName(c *gc.C) {
+func (s *EnvironmentCommandSuite) TestEnvironCommandInit(c *gc.C) {
 	// Take environment name from command line arg.
-	cmd := initEnvCommandBase(c, "explicit")
-	err := cmd.EnsureEnvName()
+	cmd, envName := prepareEnvCommand(c, "explicit")
+	err := cmd.Init(nil)
 	c.Assert(err, gc.IsNil)
-	c.Assert(cmd.EnvName, gc.Equals, "explicit")
+	c.Assert(*envName, gc.Equals, "explicit")
 
 	// Take environment name from the default.
 	defer coretesting.MakeFakeHome(c, coretesting.MultipleEnvConfig).Restore()
@@ -108,33 +113,52 @@
 	testEnsureEnvName(c, "fubar")
 }
 
-func (s *EnvironmentCommandSuite) TestEnsureEnvNameErrors(c *gc.C) {
-	err := initEnvCommandBase(c, "").EnsureEnvName()
+func (s *EnvironmentCommandSuite) TestEnvironCommandInitErrors(c *gc.C) {
+	cmd, _ := prepareEnvCommand(c, "")
+	err := cmd.Init(nil)
 	c.Assert(err, jc.Satisfies, environs.IsNoEnv)
 
 	// If there are multiple environments but no default,
 	// an error should be returned.
 	defer coretesting.MakeFakeHome(c, coretesting.MultipleEnvConfigNoDefault).Restore()
-	err = initEnvCommandBase(c, "").EnsureEnvName()
+	cmd, _ = prepareEnvCommand(c, "")
+	err = cmd.Init(nil)
 	c.Assert(err, gc.Equals, envcmd.ErrNoEnvironmentSpecified)
 }
 
-func initEnvCommandBase(c *gc.C, name string) *envcmd.EnvCommandBase {
+type testCommand struct {
+	envcmd.EnvCommandBase
+}
+
+func (c *testCommand) Info() *cmd.Info {
+	panic("should not be called")
+}
+
+func (c *testCommand) Run(ctx *cmd.Context) error {
+	panic("should not be called")
+}
+
+// prepareEnvCommand prepares a Command for a call to Init,
+// returning the Command and a pointer to a string that will
+// contain the environment name after the Command's Init method
+// has been called.
+func prepareEnvCommand(c *gc.C, name string) (cmd.Command, *string) {
 	var flags gnuflag.FlagSet
-	var cmd envcmd.EnvCommandBase
-	cmd.SetFlags(&flags)
+	var cmd testCommand
+	wrapped := envcmd.Wrap(&cmd)
+	wrapped.SetFlags(&flags)
 	var args []string
 	if name != "" {
 		args = []string{"-e", name}
 	}
 	err := flags.Parse(false, args)
 	c.Assert(err, gc.IsNil)
-	return &cmd
+	return wrapped, &cmd.EnvName
 }
 
 func testEnsureEnvName(c *gc.C, expect string) {
-	cmd := initEnvCommandBase(c, "")
-	err := cmd.EnsureEnvName()
+	cmd, envName := prepareEnvCommand(c, "")
+	err := cmd.Init(nil)
 	c.Assert(err, gc.IsNil)
-	c.Assert(cmd.EnvName, gc.Equals, expect)
+	c.Assert(*envName, gc.Equals, expect)
 }

=== modified file 'cmd/juju/addmachine.go'
--- cmd/juju/addmachine.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/addmachine.go	2014-05-12 11:08:32 +0000
@@ -74,15 +74,11 @@
 }
 
 func (c *AddMachineCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	f.StringVar(&c.Series, "series", "", "the charm series")
 	f.Var(constraints.ConstraintsValue{Target: &c.Constraints}, "constraints", "additional machine constraints")
 }
 
 func (c *AddMachineCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	if c.Constraints.Container != nil {
 		return fmt.Errorf("container constraint %q not allowed when adding a machine", *c.Constraints.Container)
 	}
@@ -92,7 +88,7 @@
 	}
 	c.Placement, err = instance.ParsePlacement(placement)
 	if err == instance.ErrPlacementScopeMissing {
-		placement = c.EnvironName() + ":" + placement
+		placement = c.EnvName + ":" + placement
 		c.Placement, err = instance.ParsePlacement(placement)
 	}
 	if err != nil {

=== modified file 'cmd/juju/addmachine_test.go'
--- cmd/juju/addmachine_test.go	2014-04-23 05:38:27 +0000
+++ cmd/juju/addmachine_test.go	2014-05-12 11:08:32 +0000
@@ -10,6 +10,7 @@
 	jc "github.com/juju/testing/checkers"
 	gc "launchpad.net/gocheck"
 
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/constraints"
 	"launchpad.net/juju-core/instance"
 	jujutesting "launchpad.net/juju-core/juju/testing"
@@ -24,7 +25,7 @@
 var _ = gc.Suite(&AddMachineSuite{})
 
 func runAddMachine(c *gc.C, args ...string) error {
-	_, err := testing.RunCommand(c, &AddMachineCommand{}, args)
+	_, err := testing.RunCommand(c, envcmd.Wrap(&AddMachineCommand{}), args)
 	return err
 }
 

=== modified file 'cmd/juju/addrelation.go'
--- cmd/juju/addrelation.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/addrelation.go	2014-05-12 11:08:32 +0000
@@ -26,9 +26,6 @@
 }
 
 func (c *AddRelationCommand) Init(args []string) error {
-	if err := c.EnsureEnvName(); err != nil {
-		return err
-	}
 	if len(args) != 2 {
 		return fmt.Errorf("a relation must involve two services")
 	}

=== modified file 'cmd/juju/addrelation_test.go'
--- cmd/juju/addrelation_test.go	2013-09-13 14:48:13 +0000
+++ cmd/juju/addrelation_test.go	2014-05-12 11:08:32 +0000
@@ -6,6 +6,7 @@
 import (
 	gc "launchpad.net/gocheck"
 
+	"launchpad.net/juju-core/cmd/envcmd"
 	jujutesting "launchpad.net/juju-core/juju/testing"
 	"launchpad.net/juju-core/testing"
 )
@@ -17,7 +18,7 @@
 var _ = gc.Suite(&AddRelationSuite{})
 
 func runAddRelation(c *gc.C, args ...string) error {
-	_, err := testing.RunCommand(c, &AddRelationCommand{}, args)
+	_, err := testing.RunCommand(c, envcmd.Wrap(&AddRelationCommand{}), args)
 	return err
 }
 

=== modified file 'cmd/juju/addunit.go'
--- cmd/juju/addunit.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/addunit.go	2014-05-12 11:08:32 +0000
@@ -74,15 +74,11 @@
 }
 
 func (c *AddUnitCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	c.UnitCommandBase.SetFlags(f)
 	f.IntVar(&c.NumUnits, "n", 1, "number of service units to add")
 }
 
 func (c *AddUnitCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	switch len(args) {
 	case 1:
 		c.ServiceName = args[0]

=== modified file 'cmd/juju/addunit_test.go'
--- cmd/juju/addunit_test.go	2013-12-05 17:30:02 +0000
+++ cmd/juju/addunit_test.go	2014-05-12 11:08:32 +0000
@@ -7,6 +7,7 @@
 	gc "launchpad.net/gocheck"
 
 	"launchpad.net/juju-core/charm"
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/instance"
 	jujutesting "launchpad.net/juju-core/juju/testing"
 	"launchpad.net/juju-core/state"
@@ -38,13 +39,13 @@
 func (s *AddUnitSuite) TestInitErrors(c *gc.C) {
 	for i, t := range initAddUnitErrorTests {
 		c.Logf("test %d", i)
-		err := testing.InitCommand(&AddUnitCommand{}, t.args)
+		err := testing.InitCommand(envcmd.Wrap(&AddUnitCommand{}), t.args)
 		c.Check(err, gc.ErrorMatches, t.err)
 	}
 }
 
 func runAddUnit(c *gc.C, args ...string) error {
-	_, err := testing.RunCommand(c, &AddUnitCommand{}, args)
+	_, err := testing.RunCommand(c, envcmd.Wrap(&AddUnitCommand{}), args)
 	return err
 }
 

=== modified file 'cmd/juju/adduser.go'
--- cmd/juju/adduser.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/adduser.go	2014-05-12 11:08:32 +0000
@@ -51,9 +51,6 @@
 	})
 }
 func (c *AddUserCommand) Init(args []string) error {
-	if err := c.EnsureEnvName(); err != nil {
-		return err
-	}
 	switch len(args) {
 	case 0:
 		return fmt.Errorf("no username supplied")

=== modified file 'cmd/juju/adduser_test.go'
--- cmd/juju/adduser_test.go	2014-03-28 10:55:18 +0000
+++ cmd/juju/adduser_test.go	2014-05-12 11:08:32 +0000
@@ -11,6 +11,8 @@
 	"launchpad.net/goyaml"
 	jujutesting "launchpad.net/juju-core/juju/testing"
 
+	"launchpad.net/juju-core/cmd"
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/testing"
 )
 
@@ -22,22 +24,26 @@
 
 var _ = gc.Suite(&AddUserSuite{})
 
+func newAddUserCommand() cmd.Command {
+	return envcmd.Wrap(&AddUserCommand{})
+}
+
 func (s *AddUserSuite) TestAddUser(c *gc.C) {
 
-	_, err := testing.RunCommand(c, &AddUserCommand{}, []string{"foobar", "password"})
+	_, err := testing.RunCommand(c, newAddUserCommand(), []string{"foobar", "password"})
 	c.Assert(err, gc.IsNil)
 
-	_, err = testing.RunCommand(c, &AddUserCommand{}, []string{"foobar", "newpassword"})
+	_, err = testing.RunCommand(c, newAddUserCommand(), []string{"foobar", "newpassword"})
 	c.Assert(err, gc.ErrorMatches, "Failed to create user: user already exists")
 }
 
 func (s *AddUserSuite) TestTooManyArgs(c *gc.C) {
-	_, err := testing.RunCommand(c, &AddUserCommand{}, []string{"foobar", "password", "whoops"})
+	_, err := testing.RunCommand(c, newAddUserCommand(), []string{"foobar", "password", "whoops"})
 	c.Assert(err, gc.ErrorMatches, `unrecognized args: \["whoops"\]`)
 }
 
 func (s *AddUserSuite) TestNotEnoughArgs(c *gc.C) {
-	_, err := testing.RunCommand(c, &AddUserCommand{}, []string{})
+	_, err := testing.RunCommand(c, newAddUserCommand(), []string{})
 	c.Assert(err, gc.ErrorMatches, `no username supplied`)
 }
 
@@ -50,7 +56,7 @@
 	tempFile, err := ioutil.TempFile("", "adduser-test")
 	tempFile.Close()
 	c.Assert(err, gc.IsNil)
-	_, err = testing.RunCommand(c, &AddUserCommand{}, []string{"foobar", "password", "-o", tempFile.Name()})
+	_, err = testing.RunCommand(c, newAddUserCommand(), []string{"foobar", "password", "-o", tempFile.Name()})
 	c.Assert(err, gc.IsNil)
 	data, err := ioutil.ReadFile(tempFile.Name())
 	result := map[string]interface{}{}
@@ -65,7 +71,7 @@
 		"password":      "password",
 		"state-servers": []interface{}{},
 		"ca-cert":       ""}
-	ctx, err := testing.RunCommand(c, &AddUserCommand{}, []string{"foobar", "password"})
+	ctx, err := testing.RunCommand(c, newAddUserCommand(), []string{"foobar", "password"})
 	c.Assert(err, gc.IsNil)
 	stdout := ctx.Stdout.(*bytes.Buffer).Bytes()
 	result := map[string]interface{}{}
@@ -80,7 +86,7 @@
 	tempFile, err := ioutil.TempFile("", "adduser-test")
 	tempFile.Close()
 	c.Assert(err, gc.IsNil)
-	_, err = testing.RunCommand(c, &AddUserCommand{}, []string{"foobar", "password", "-o", tempFile.Name(), "--format", "json"})
+	_, err = testing.RunCommand(c, newAddUserCommand(), []string{"foobar", "password", "-o", tempFile.Name(), "--format", "json"})
 	c.Assert(err, gc.IsNil)
 	data, err := ioutil.ReadFile(tempFile.Name())
 	c.Assert(string(data), gc.DeepEquals, expected)
@@ -89,14 +95,14 @@
 func (s *AddUserSuite) TestJenvJsonFileOutput(c *gc.C) {
 	expected := `{"User":"foobar","Password":"password","state-servers":null,"ca-cert":""}
 `
-	ctx, err := testing.RunCommand(c, &AddUserCommand{}, []string{"foobar", "password", "--format", "json"})
+	ctx, err := testing.RunCommand(c, newAddUserCommand(), []string{"foobar", "password", "--format", "json"})
 	c.Assert(err, gc.IsNil)
 	stdout := ctx.Stdout.(*bytes.Buffer).String()
 	c.Assert(stdout, gc.DeepEquals, expected)
 }
 
 func (s *AddUserSuite) TestGeneratePassword(c *gc.C) {
-	ctx, err := testing.RunCommand(c, &AddUserCommand{}, []string{"foobar"})
+	ctx, err := testing.RunCommand(c, newAddUserCommand(), []string{"foobar"})
 	c.Assert(err, gc.IsNil)
 	stdout := ctx.Stdout.(*bytes.Buffer).Bytes()
 	var d map[string]interface{}

=== modified file 'cmd/juju/authorizedkeys.go'
--- cmd/juju/authorizedkeys.go	2014-04-25 06:39:01 +0000
+++ cmd/juju/authorizedkeys.go	2014-05-12 11:08:32 +0000
@@ -7,6 +7,7 @@
 	"launchpad.net/gnuflag"
 
 	"launchpad.net/juju-core/cmd"
+	"launchpad.net/juju-core/cmd/envcmd"
 )
 
 var authKeysDoc = `
@@ -29,10 +30,10 @@
 			Aliases:     []string{"authorised-keys"},
 		}),
 	}
-	sshkeyscmd.Register(&AddKeysCommand{})
-	sshkeyscmd.Register(&DeleteKeysCommand{})
-	sshkeyscmd.Register(&ImportKeysCommand{})
-	sshkeyscmd.Register(&ListKeysCommand{})
+	sshkeyscmd.Register(envcmd.Wrap(&AddKeysCommand{}))
+	sshkeyscmd.Register(envcmd.Wrap(&DeleteKeysCommand{}))
+	sshkeyscmd.Register(envcmd.Wrap(&ImportKeysCommand{}))
+	sshkeyscmd.Register(envcmd.Wrap(&ListKeysCommand{}))
 	return sshkeyscmd
 }
 

=== modified file 'cmd/juju/authorizedkeys_add.go'
--- cmd/juju/authorizedkeys_add.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/authorizedkeys_add.go	2014-05-12 11:08:32 +0000
@@ -35,9 +35,6 @@
 }
 
 func (c *AddKeysCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	switch len(args) {
 	case 0:
 		return errors.New("no ssh key specified")
@@ -48,7 +45,6 @@
 }
 
 func (c *AddKeysCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	f.StringVar(&c.user, "user", "admin", "the user for which to add the keys")
 }
 

=== modified file 'cmd/juju/authorizedkeys_delete.go'
--- cmd/juju/authorizedkeys_delete.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/authorizedkeys_delete.go	2014-05-12 11:08:32 +0000
@@ -37,9 +37,6 @@
 }
 
 func (c *DeleteKeysCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	switch len(args) {
 	case 0:
 		return errors.New("no ssh key id specified")
@@ -50,7 +47,6 @@
 }
 
 func (c *DeleteKeysCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	f.StringVar(&c.user, "user", "admin", "the user for which to delete the keys")
 }
 

=== modified file 'cmd/juju/authorizedkeys_import.go'
--- cmd/juju/authorizedkeys_import.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/authorizedkeys_import.go	2014-05-12 11:08:32 +0000
@@ -36,9 +36,6 @@
 }
 
 func (c *ImportKeysCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	switch len(args) {
 	case 0:
 		return errors.New("no ssh key id specified")
@@ -49,7 +46,6 @@
 }
 
 func (c *ImportKeysCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	f.StringVar(&c.user, "user", "admin", "the user for which to import the keys")
 }
 

=== modified file 'cmd/juju/authorizedkeys_list.go'
--- cmd/juju/authorizedkeys_list.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/authorizedkeys_list.go	2014-05-12 11:08:32 +0000
@@ -37,18 +37,10 @@
 }
 
 func (c *ListKeysCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	f.BoolVar(&c.showFullKey, "full", false, "show full key instead of just the key fingerprint")
 	f.StringVar(&c.user, "user", "admin", "the user for which to list the keys")
 }
 
-func (c *ListKeysCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
-	return cmd.CheckEmpty(args)
-}
-
 func (c *ListKeysCommand) Run(context *cmd.Context) error {
 	client, err := juju.NewKeyManagerClient(c.EnvName)
 	if err != nil {

=== modified file 'cmd/juju/authorizedkeys_test.go'
--- cmd/juju/authorizedkeys_test.go	2014-04-25 06:39:01 +0000
+++ cmd/juju/authorizedkeys_test.go	2014-05-12 11:08:32 +0000
@@ -9,6 +9,7 @@
 
 	gc "launchpad.net/gocheck"
 
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/juju/osenv"
 	jujutesting "launchpad.net/juju-core/juju/testing"
 	keymanagerserver "launchpad.net/juju-core/state/apiserver/keymanager"
@@ -127,7 +128,7 @@
 	key2 := sshtesting.ValidKeyTwo.Key + " another@host"
 	s.setAuthorizedKeys(c, key1, key2)
 
-	context, err := coretesting.RunCommand(c, &ListKeysCommand{}, []string{})
+	context, err := coretesting.RunCommand(c, envcmd.Wrap(&ListKeysCommand{}), []string{})
 	c.Assert(err, gc.IsNil)
 	output := strings.TrimSpace(coretesting.Stdout(context))
 	c.Assert(err, gc.IsNil)
@@ -139,7 +140,7 @@
 	key2 := sshtesting.ValidKeyTwo.Key + " another@host"
 	s.setAuthorizedKeys(c, key1, key2)
 
-	context, err := coretesting.RunCommand(c, &ListKeysCommand{}, []string{"--full"})
+	context, err := coretesting.RunCommand(c, envcmd.Wrap(&ListKeysCommand{}), []string{"--full"})
 	c.Assert(err, gc.IsNil)
 	output := strings.TrimSpace(coretesting.Stdout(context))
 	c.Assert(err, gc.IsNil)
@@ -153,7 +154,7 @@
 	_, err := s.State.AddUser("fred", "password")
 	c.Assert(err, gc.IsNil)
 
-	context, err := coretesting.RunCommand(c, &ListKeysCommand{}, []string{"--user", "fred"})
+	context, err := coretesting.RunCommand(c, envcmd.Wrap(&ListKeysCommand{}), []string{"--user", "fred"})
 	c.Assert(err, gc.IsNil)
 	output := strings.TrimSpace(coretesting.Stdout(context))
 	c.Assert(err, gc.IsNil)
@@ -161,7 +162,7 @@
 }
 
 func (s *ListKeysSuite) TestTooManyArgs(c *gc.C) {
-	_, err := coretesting.RunCommand(c, &ListKeysCommand{}, []string{"foo"})
+	_, err := coretesting.RunCommand(c, envcmd.Wrap(&ListKeysCommand{}), []string{"foo"})
 	c.Assert(err, gc.ErrorMatches, `unrecognized args: \["foo"\]`)
 }
 
@@ -176,7 +177,7 @@
 	s.setAuthorizedKeys(c, key1)
 
 	key2 := sshtesting.ValidKeyTwo.Key + " another@host"
-	context, err := coretesting.RunCommand(c, &AddKeysCommand{}, []string{key2, "invalid-key"})
+	context, err := coretesting.RunCommand(c, envcmd.Wrap(&AddKeysCommand{}), []string{key2, "invalid-key"})
 	c.Assert(err, gc.IsNil)
 	c.Assert(coretesting.Stderr(context), gc.Matches, `cannot add key "invalid-key".*\n`)
 	s.assertEnvironKeys(c, key1, key2)
@@ -189,7 +190,7 @@
 	c.Assert(err, gc.IsNil)
 
 	key2 := sshtesting.ValidKeyTwo.Key + " another@host"
-	context, err := coretesting.RunCommand(c, &AddKeysCommand{}, []string{"--user", "fred", key2})
+	context, err := coretesting.RunCommand(c, envcmd.Wrap(&AddKeysCommand{}), []string{"--user", "fred", key2})
 	c.Assert(err, gc.IsNil)
 	c.Assert(coretesting.Stderr(context), gc.Equals, "")
 	s.assertEnvironKeys(c, key1, key2)
@@ -207,7 +208,7 @@
 	s.setAuthorizedKeys(c, key1, key2)
 
 	context, err := coretesting.RunCommand(
-		c, &DeleteKeysCommand{}, []string{sshtesting.ValidKeyTwo.Fingerprint, "invalid-key"})
+		c, envcmd.Wrap(&DeleteKeysCommand{}), []string{sshtesting.ValidKeyTwo.Fingerprint, "invalid-key"})
 	c.Assert(err, gc.IsNil)
 	c.Assert(coretesting.Stderr(context), gc.Matches, `cannot delete key id "invalid-key".*\n`)
 	s.assertEnvironKeys(c, key1)
@@ -221,7 +222,7 @@
 	c.Assert(err, gc.IsNil)
 
 	context, err := coretesting.RunCommand(
-		c, &DeleteKeysCommand{}, []string{"--user", "fred", sshtesting.ValidKeyTwo.Fingerprint})
+		c, envcmd.Wrap(&DeleteKeysCommand{}), []string{"--user", "fred", sshtesting.ValidKeyTwo.Fingerprint})
 	c.Assert(err, gc.IsNil)
 	c.Assert(coretesting.Stderr(context), gc.Equals, "")
 	s.assertEnvironKeys(c, key1)
@@ -242,7 +243,7 @@
 	key1 := sshtesting.ValidKeyOne.Key + " user@host"
 	s.setAuthorizedKeys(c, key1)
 
-	context, err := coretesting.RunCommand(c, &ImportKeysCommand{}, []string{"lp:validuser", "invalid-key"})
+	context, err := coretesting.RunCommand(c, envcmd.Wrap(&ImportKeysCommand{}), []string{"lp:validuser", "invalid-key"})
 	c.Assert(err, gc.IsNil)
 	c.Assert(coretesting.Stderr(context), gc.Matches, `cannot import key id "invalid-key".*\n`)
 	s.assertEnvironKeys(c, key1, sshtesting.ValidKeyThree.Key)
@@ -254,7 +255,7 @@
 	_, err := s.State.AddUser("fred", "password")
 	c.Assert(err, gc.IsNil)
 
-	context, err := coretesting.RunCommand(c, &ImportKeysCommand{}, []string{"--user", "fred", "lp:validuser"})
+	context, err := coretesting.RunCommand(c, envcmd.Wrap(&ImportKeysCommand{}), []string{"--user", "fred", "lp:validuser"})
 	c.Assert(err, gc.IsNil)
 	c.Assert(coretesting.Stderr(context), gc.Equals, "")
 	s.assertEnvironKeys(c, key1, sshtesting.ValidKeyThree.Key)

=== modified file 'cmd/juju/bootstrap.go'
--- cmd/juju/bootstrap.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/bootstrap.go	2014-05-12 11:08:32 +0000
@@ -78,7 +78,6 @@
 }
 
 func (c *BootstrapCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	f.Var(constraints.ConstraintsValue{Target: &c.Constraints}, "constraints", "set environment constraints")
 	f.BoolVar(&c.UploadTools, "upload-tools", false, "upload local version of tools before bootstrapping")
 	f.Var(newSeriesValue(nil, &c.Series), "upload-series", "upload tools for supplied comma-separated series list")
@@ -88,9 +87,6 @@
 }
 
 func (c *BootstrapCommand) Init(args []string) (err error) {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	if len(c.Series) > 0 && !c.UploadTools {
 		return fmt.Errorf("--upload-series requires --upload-tools")
 	}

=== modified file 'cmd/juju/bootstrap_test.go'
--- cmd/juju/bootstrap_test.go	2014-05-12 00:24:54 +0000
+++ cmd/juju/bootstrap_test.go	2014-05-12 11:08:32 +0000
@@ -12,6 +12,7 @@
 	gc "launchpad.net/gocheck"
 
 	"launchpad.net/juju-core/cmd"
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/constraints"
 	"launchpad.net/juju-core/environs"
 	"launchpad.net/juju-core/environs/config"
@@ -142,7 +143,7 @@
 	restore := envtools.TestingPatchBootstrapFindTools(mockFindTools)
 	defer restore()
 
-	_, errc := runCommand(nullContext(c), new(BootstrapCommand), test.args...)
+	_, errc := runCommand(nullContext(c), envcmd.Wrap(new(BootstrapCommand)), test.args...)
 	err := <-errc
 	c.Check(findToolsRetryValues, gc.DeepEquals, test.expectedAllowRetry)
 	stripped := strings.Replace(err.Error(), "\n", "", -1)
@@ -225,7 +226,7 @@
 	}
 
 	// Run command and check for uploads.
-	opc, errc := runCommand(nullContext(c), new(BootstrapCommand), test.args...)
+	opc, errc := runCommand(nullContext(c), envcmd.Wrap(new(BootstrapCommand)), test.args...)
 	// Check for remaining operations/errors.
 	if test.err != "" {
 		err := <-errc
@@ -402,10 +403,10 @@
 	defaultSeriesVersion.Minor = 11
 	s.PatchValue(&version.Current, defaultSeriesVersion)
 
-	_, err := coretesting.RunCommand(c, &BootstrapCommand{}, nil)
+	_, err := coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}), nil)
 	c.Assert(err, gc.IsNil)
 
-	_, err = coretesting.RunCommand(c, &BootstrapCommand{}, nil)
+	_, err = coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}), nil)
 	c.Assert(err, gc.ErrorMatches, "environment is already bootstrapped")
 }
 
@@ -428,7 +429,7 @@
 	_, fake := makeEmptyFakeHome(c)
 	defer fake.Restore()
 
-	ctx, err := coretesting.RunCommand(c, &BootstrapCommand{},
+	ctx, err := coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}),
 		[]string{"--upload-tools", argVariant, "foo,bar"})
 
 	c.Assert(err, gc.IsNil)
@@ -457,7 +458,7 @@
 	loggo.RegisterWriter(logger, testWriter, loggo.WARNING)
 	defer loggo.RemoveWriter(logger)
 
-	_, errc := runCommand(ctx, new(BootstrapCommand), "-e", "peckham")
+	_, errc := runCommand(ctx, envcmd.Wrap(new(BootstrapCommand)), "-e", "peckham")
 	c.Assert(<-errc, gc.IsNil)
 	c.Assert(testWriter.Log, jc.LogMatches, []string{"ignoring environments.yaml: using bootstrap config in .*"})
 }
@@ -469,7 +470,7 @@
 
 	// Bootstrap the environment with an invalid source.
 	// The command returns with an error.
-	_, err := coretesting.RunCommand(c, &BootstrapCommand{}, []string{"--metadata-source", c.MkDir()})
+	_, err := coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}), []string{"--metadata-source", c.MkDir()})
 	c.Check(err, gc.ErrorMatches, "cannot upload bootstrap tools: Juju "+
 		"cannot bootstrap because no tools are available for your "+
 		"environment(.|\n)*")
@@ -524,7 +525,7 @@
 	devVersion.Minor = 11
 	s.PatchValue(&version.Current, devVersion)
 
-	_, err := coretesting.RunCommand(c, &BootstrapCommand{}, []string{"--metadata-source", sourceDir})
+	_, err := coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}), []string{"--metadata-source", sourceDir})
 	c.Assert(err, gc.IsNil)
 	c.Assert(imagemetadata.DefaultBaseURL, gc.Equals, imagemetadata.UbuntuCloudImagesURL)
 
@@ -541,7 +542,7 @@
 	// Bootstrap the environment with the valid source.
 	// The bootstrapping has to show no error, because the tools
 	// are automatically synchronized.
-	_, err := coretesting.RunCommand(c, &BootstrapCommand{}, []string{"--metadata-source", sourceDir})
+	_, err := coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}), []string{"--metadata-source", sourceDir})
 	c.Assert(err, gc.IsNil)
 
 	// Now check the available tools which are the 1.2.0 envtools.
@@ -575,7 +576,7 @@
 
 	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(c), new(BootstrapCommand))
+	opc, errc := runCommand(nullContext(c), envcmd.Wrap(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)
@@ -603,7 +604,7 @@
 
 func (s *BootstrapSuite) TestAutoUploadOnlyForDev(c *gc.C) {
 	s.setupAutoUploadTest(c, "1.8.3", "precise")
-	_, errc := runCommand(nullContext(c), new(BootstrapCommand))
+	_, errc := runCommand(nullContext(c), envcmd.Wrap(new(BootstrapCommand)))
 	err := <-errc
 	stripped := strings.Replace(err.Error(), "\n", "", -1)
 	c.Assert(stripped, gc.Matches, noToolsAvailableMessage)
@@ -612,7 +613,7 @@
 func (s *BootstrapSuite) TestMissingToolsError(c *gc.C) {
 	s.setupAutoUploadTest(c, "1.8.3", "precise")
 
-	_, err := coretesting.RunCommand(c, &BootstrapCommand{}, nil)
+	_, err := coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}), nil)
 	c.Assert(err, gc.ErrorMatches, "cannot upload bootstrap tools: Juju "+
 		"cannot bootstrap because no tools are available for your "+
 		"environment(.|\n)*")
@@ -626,7 +627,7 @@
 	s.setupAutoUploadTest(c, "1.7.3", "precise")
 	s.PatchValue(&sync.Upload, uploadToolsAlwaysFails)
 
-	ctx, err := coretesting.RunCommand(c, &BootstrapCommand{}, nil)
+	ctx, err := coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}), nil)
 
 	c.Check(coretesting.Stderr(ctx), gc.Matches,
 		"uploading tools for series \\[precise .* raring\\]\n")
@@ -642,7 +643,7 @@
 	// upload is only enabled for dev versions.
 	devVersion.Minor = 11
 	s.PatchValue(&version.Current, devVersion)
-	opc, errc := runCommand(nullContext(c), new(BootstrapCommand), "-e", "brokenenv")
+	opc, errc := runCommand(nullContext(c), envcmd.Wrap(new(BootstrapCommand)), "-e", "brokenenv")
 	err := <-errc
 	c.Assert(err, gc.ErrorMatches, "dummy.Bootstrap is broken")
 	var opDestroy *dummy.OpDestroy

=== modified file 'cmd/juju/cmd_test.go'
--- cmd/juju/cmd_test.go	2014-05-11 22:52:40 +0000
+++ cmd/juju/cmd_test.go	2014-05-12 11:08:32 +0000
@@ -13,6 +13,7 @@
 	gc "launchpad.net/gocheck"
 
 	"launchpad.net/juju-core/cmd"
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/juju/osenv"
 	"launchpad.net/juju-core/juju/testing"
 	"launchpad.net/juju-core/provider/dummy"
@@ -68,12 +69,12 @@
 	}
 }
 
-// assertConnName asserts that the Command is using
+// assertEnvName asserts that the Command is using
 // the given environment name.
 // Since every command has a different type,
 // we use reflection to look at the value of the
 // Conn field in the value.
-func assertConnName(c *gc.C, com cmd.Command, name string) {
+func assertEnvName(c *gc.C, com cmd.Command, name string) {
 	v := reflect.ValueOf(com).Elem().FieldByName("EnvName")
 	c.Assert(v, jc.Satisfies, reflect.Value.IsValid)
 	c.Assert(v.Interface(), gc.Equals, name)
@@ -81,12 +82,12 @@
 
 // All members of EnvironmentInitTests are tested for the -environment and -e
 // flags, and that extra arguments will cause parsing to fail.
-var EnvironmentInitTests = []func() (cmd.Command, []string){
-	func() (cmd.Command, []string) { return new(BootstrapCommand), nil },
-	func() (cmd.Command, []string) {
+var EnvironmentInitTests = []func() (envcmd.EnvironCommand, []string){
+	func() (envcmd.EnvironCommand, []string) { return new(BootstrapCommand), nil },
+	func() (envcmd.EnvironCommand, []string) {
 		return new(DeployCommand), []string{"charm-name", "service-name"}
 	},
-	func() (cmd.Command, []string) { return new(StatusCommand), nil },
+	func() (envcmd.EnvironCommand, []string) { return new(StatusCommand), nil },
 }
 
 // TestEnvironmentInit tests that all commands which accept
@@ -96,24 +97,24 @@
 	for i, cmdFunc := range EnvironmentInitTests {
 		c.Logf("test %d", i)
 		com, args := cmdFunc()
-		testInit(c, com, args, "")
-		assertConnName(c, com, "peckham")
-
-		com, args = cmdFunc()
-		testInit(c, com, append(args, "-e", "walthamstow"), "")
-		assertConnName(c, com, "walthamstow")
-
-		com, args = cmdFunc()
-		testInit(c, com, append(args, "--environment", "walthamstow"), "")
-		assertConnName(c, com, "walthamstow")
+		testInit(c, envcmd.Wrap(com), args, "")
+		assertEnvName(c, com, "peckham")
+
+		com, args = cmdFunc()
+		testInit(c, envcmd.Wrap(com), append(args, "-e", "walthamstow"), "")
+		assertEnvName(c, com, "walthamstow")
+
+		com, args = cmdFunc()
+		testInit(c, envcmd.Wrap(com), append(args, "--environment", "walthamstow"), "")
+		assertEnvName(c, com, "walthamstow")
 
 		// JUJU_ENV is the final place the environment can be overriden
 		com, args = cmdFunc()
 		oldenv := os.Getenv(osenv.JujuEnvEnvKey)
 		os.Setenv(osenv.JujuEnvEnvKey, "walthamstow")
-		testInit(c, com, args, "")
+		testInit(c, envcmd.Wrap(com), args, "")
 		os.Setenv(osenv.JujuEnvEnvKey, oldenv)
-		assertConnName(c, com, "walthamstow")
+		assertEnvName(c, com, "walthamstow")
 	}
 }
 
@@ -192,7 +193,7 @@
 
 func initDeployCommand(args ...string) (*DeployCommand, error) {
 	com := &DeployCommand{}
-	return com, coretesting.InitCommand(com, args)
+	return com, coretesting.InitCommand(envcmd.Wrap(com), args)
 }
 
 func (*CmdSuite) TestDeployCommandInit(c *gc.C) {

=== modified file 'cmd/juju/constraints.go'
--- cmd/juju/constraints.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/constraints.go	2014-05-12 11:08:32 +0000
@@ -70,7 +70,6 @@
 }
 
 func (c *GetConstraintsCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	c.out.AddFlags(f, "constraints", map[string]cmd.Formatter{
 		"constraints": formatConstraints,
 		"yaml":        cmd.FormatYaml,
@@ -79,9 +78,6 @@
 }
 
 func (c *GetConstraintsCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	if len(args) > 0 {
 		if !names.IsService(args[0]) {
 			return fmt.Errorf("invalid service name %q", args[0])
@@ -127,15 +123,11 @@
 }
 
 func (c *SetConstraintsCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	f.StringVar(&c.ServiceName, "s", "", "set service constraints")
 	f.StringVar(&c.ServiceName, "service", "", "")
 }
 
 func (c *SetConstraintsCommand) Init(args []string) (err error) {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	if c.ServiceName != "" && !names.IsService(c.ServiceName) {
 		return fmt.Errorf("invalid service name %q", c.ServiceName)
 	}

=== modified file 'cmd/juju/constraints_test.go'
--- cmd/juju/constraints_test.go	2014-03-13 07:54:56 +0000
+++ cmd/juju/constraints_test.go	2014-05-12 11:08:32 +0000
@@ -10,6 +10,7 @@
 	gc "launchpad.net/gocheck"
 
 	"launchpad.net/juju-core/cmd"
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/constraints"
 	"launchpad.net/juju-core/juju/testing"
 	coretesting "launchpad.net/juju-core/testing"
@@ -35,7 +36,7 @@
 }
 
 func assertSet(c *gc.C, args ...string) {
-	rcode, rstdout, rstderr := runCmdLine(c, &SetConstraintsCommand{}, args...)
+	rcode, rstdout, rstderr := runCmdLine(c, envcmd.Wrap(&SetConstraintsCommand{}), args...)
 	c.Assert(rcode, gc.Equals, 0)
 	c.Assert(rstdout, gc.Equals, "")
 	c.Assert(rstderr, gc.Equals, "")
@@ -78,7 +79,7 @@
 }
 
 func assertSetError(c *gc.C, code int, stderr string, args ...string) {
-	rcode, rstdout, rstderr := runCmdLine(c, &SetConstraintsCommand{}, args...)
+	rcode, rstdout, rstderr := runCmdLine(c, envcmd.Wrap(&SetConstraintsCommand{}), args...)
 	c.Assert(rcode, gc.Equals, code)
 	c.Assert(rstdout, gc.Equals, "")
 	c.Assert(rstderr, gc.Matches, "error: "+stderr+"\n")

=== modified file 'cmd/juju/debuglog.go'
--- cmd/juju/debuglog.go	2014-05-11 22:36:42 +0000
+++ cmd/juju/debuglog.go	2014-05-12 11:08:32 +0000
@@ -44,8 +44,6 @@
 }
 
 func (c *DebugLogCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
-
 	f.Var(cmd.NewAppendStringsValue(&c.params.IncludeEntity), "i", "only show log messages for these entities")
 	f.Var(cmd.NewAppendStringsValue(&c.params.IncludeEntity), "include", "only show log messages for these entities")
 	f.Var(cmd.NewAppendStringsValue(&c.params.ExcludeEntity), "x", "do not show log messages for these entities")
@@ -63,9 +61,6 @@
 }
 
 func (c *DebugLogCommand) Init(args []string) error {
-	if err := c.EnsureEnvName(); err != nil {
-		return err
-	}
 	if c.level != "" {
 		level, ok := loggo.ParseLevel(c.level)
 		if !ok || level < loggo.TRACE || level > loggo.ERROR {

=== modified file 'cmd/juju/debuglog_test.go'
--- cmd/juju/debuglog_test.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/debuglog_test.go	2014-05-12 11:08:32 +0000
@@ -14,6 +14,7 @@
 	gc "launchpad.net/gocheck"
 
 	"launchpad.net/juju-core/cmd"
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/errors"
 	"launchpad.net/juju-core/state/api"
 	"launchpad.net/juju-core/testing"
@@ -91,7 +92,7 @@
 	} {
 		c.Logf("test %v", i)
 		command := &DebugLogCommand{}
-		err := testing.InitCommand(command, test.args)
+		err := testing.InitCommand(envcmd.Wrap(command), test.args)
 		if test.errMatch == "" {
 			c.Check(err, gc.IsNil)
 			c.Check(command.params, jc.DeepEquals, test.expected)
@@ -106,7 +107,7 @@
 	s.PatchValue(&getDebugLogAPI, func(envName string) (DebugLogAPI, error) {
 		return fake, nil
 	})
-	_, err := testing.RunCommand(c, &DebugLogCommand{}, []string{
+	_, err := testing.RunCommand(c, envcmd.Wrap(&DebugLogCommand{}), []string{
 		"-i", "machine-1*", "-x", "machine-1-lxc-1",
 		"--include-module=juju.provisioner",
 		"--lines=500",
@@ -126,7 +127,7 @@
 	s.PatchValue(&getDebugLogAPI, func(envName string) (DebugLogAPI, error) {
 		return &fakeDebugLogAPI{log: "this is the log output"}, nil
 	})
-	ctx, err := testing.RunCommand(c, &DebugLogCommand{}, nil)
+	ctx, err := testing.RunCommand(c, envcmd.Wrap(&DebugLogCommand{}), nil)
 	c.Assert(err, gc.IsNil)
 	c.Assert(testing.Stdout(ctx), gc.Equals, "this is the log output")
 }
@@ -139,7 +140,7 @@
 	s.PatchValue(&getDebugLogAPI, func(envName string) (DebugLogAPI, error) {
 		return &fakeDebugLogAPI{err: errors.NotSupportedf("testing")}, nil
 	})
-	ctx, err := testing.RunCommand(c, &DebugLogCommand{}, []string{"-n", "100"})
+	ctx, err := testing.RunCommand(c, envcmd.Wrap(&DebugLogCommand{}), []string{"-n", "100"})
 	c.Assert(err, gc.IsNil)
 	c.Check(testing.Stderr(ctx), gc.Equals, "Server does not support new stream log, falling back to tail\n")
 	c.Check(testing.Stdout(ctx), gc.Equals, "[tail -n -100 -f /var/log/juju/all-machines.log]")

=== modified file 'cmd/juju/deploy.go'
--- cmd/juju/deploy.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/deploy.go	2014-05-12 11:08:32 +0000
@@ -100,7 +100,6 @@
 }
 
 func (c *DeployCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	c.UnitCommandBase.SetFlags(f)
 	f.IntVar(&c.NumUnits, "n", 1, "number of service units to deploy for principal charms")
 	f.BoolVar(&c.BumpRevision, "u", false, "increment local charm directory revision (DEPRECATED)")
@@ -113,9 +112,6 @@
 }
 
 func (c *DeployCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	switch len(args) {
 	case 2:
 		if !names.IsService(args[1]) {

=== modified file 'cmd/juju/deploy_test.go'
--- cmd/juju/deploy_test.go	2014-05-02 22:26:15 +0000
+++ cmd/juju/deploy_test.go	2014-05-12 11:08:32 +0000
@@ -10,6 +10,7 @@
 	gc "launchpad.net/gocheck"
 
 	"launchpad.net/juju-core/charm"
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/constraints"
 	"launchpad.net/juju-core/errors"
 	"launchpad.net/juju-core/instance"
@@ -26,7 +27,7 @@
 var _ = gc.Suite(&DeploySuite{})
 
 func runDeploy(c *gc.C, args ...string) error {
-	_, err := coretesting.RunCommand(c, &DeployCommand{}, args)
+	_, err := coretesting.RunCommand(c, envcmd.Wrap(&DeployCommand{}), args)
 	return err
 }
 
@@ -64,7 +65,7 @@
 func (s *DeploySuite) TestInitErrors(c *gc.C) {
 	for i, t := range initErrorTests {
 		c.Logf("test %d", i)
-		err := coretesting.InitCommand(&DeployCommand{}, t.args)
+		err := coretesting.InitCommand(envcmd.Wrap(&DeployCommand{}), t.args)
 		c.Assert(err, gc.ErrorMatches, t.err)
 	}
 }
@@ -84,7 +85,7 @@
 
 func (s *DeploySuite) TestUpgradeReportsDeprecated(c *gc.C) {
 	coretesting.Charms.ClonedDirPath(s.SeriesPath, "dummy")
-	ctx, err := coretesting.RunCommand(c, &DeployCommand{}, []string{"local:dummy", "-u"})
+	ctx, err := coretesting.RunCommand(c, envcmd.Wrap(&DeployCommand{}), []string{"local:dummy", "-u"})
 	c.Assert(err, gc.IsNil)
 
 	c.Assert(coretesting.Stdout(ctx), gc.Equals, "")

=== modified file 'cmd/juju/endpoint.go'
--- cmd/juju/endpoint.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/endpoint.go	2014-05-12 11:08:32 +0000
@@ -37,15 +37,7 @@
 	}
 }
 
-func (c *EndpointCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
-	return cmd.CheckEmpty(args)
-}
-
 func (c *EndpointCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	c.out.AddFlags(f, "smart", cmd.DefaultFormatters)
 	f.BoolVar(&c.refresh, "refresh", false, "connect to the API to ensure up-to-date endpoint locations")
 }

=== modified file 'cmd/juju/endpoint_test.go'
--- cmd/juju/endpoint_test.go	2013-08-15 15:00:54 +0000
+++ cmd/juju/endpoint_test.go	2014-05-12 11:08:32 +0000
@@ -10,6 +10,7 @@
 	gc "launchpad.net/gocheck"
 
 	"launchpad.net/juju-core/cmd"
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/juju/testing"
 	coretesting "launchpad.net/juju-core/testing"
 )
@@ -22,7 +23,7 @@
 
 func (s *EndpointSuite) TestEndpoint(c *gc.C) {
 	ctx := coretesting.Context(c)
-	code := cmd.Main(&EndpointCommand{}, ctx, []string{})
+	code := cmd.Main(envcmd.Wrap(&EndpointCommand{}), ctx, []string{})
 	c.Check(code, gc.Equals, 0)
 	c.Assert(ctx.Stderr.(*bytes.Buffer).String(), gc.Equals, "")
 	output := string(ctx.Stdout.(*bytes.Buffer).Bytes())

=== modified file 'cmd/juju/ensureavailability.go'
--- cmd/juju/ensureavailability.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/ensureavailability.go	2014-05-12 11:08:32 +0000
@@ -56,16 +56,12 @@
 }
 
 func (c *EnsureAvailabilityCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	f.IntVar(&c.NumStateServers, "n", 0, "number of state servers to make available")
 	f.StringVar(&c.Series, "series", "", "the charm series")
 	f.Var(constraints.ConstraintsValue{&c.Constraints}, "constraints", "additional machine constraints")
 }
 
 func (c *EnsureAvailabilityCommand) Init(args []string) error {
-	if err := c.EnsureEnvName(); err != nil {
-		return err
-	}
 	if c.NumStateServers < 0 || (c.NumStateServers%2 != 1 && c.NumStateServers != 0) {
 		return fmt.Errorf("must specify a number of state servers odd and non-negative")
 	}

=== modified file 'cmd/juju/ensureavailability_test.go'
--- cmd/juju/ensureavailability_test.go	2014-04-23 11:57:06 +0000
+++ cmd/juju/ensureavailability_test.go	2014-05-12 11:08:32 +0000
@@ -9,6 +9,7 @@
 	jc "github.com/juju/testing/checkers"
 	gc "launchpad.net/gocheck"
 
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/constraints"
 	jujutesting "launchpad.net/juju-core/juju/testing"
 	"launchpad.net/juju-core/state"
@@ -49,7 +50,7 @@
 }
 
 func runEnsureAvailability(c *gc.C, args ...string) error {
-	_, err := coretesting.RunCommand(c, &EnsureAvailabilityCommand{}, args)
+	_, err := coretesting.RunCommand(c, envcmd.Wrap(&EnsureAvailabilityCommand{}), args)
 	return err
 }
 

=== modified file 'cmd/juju/environment.go'
--- cmd/juju/environment.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/environment.go	2014-05-12 11:08:32 +0000
@@ -45,14 +45,10 @@
 }
 
 func (c *GetEnvironmentCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	c.out.AddFlags(f, "smart", cmd.DefaultFormatters)
 }
 
 func (c *GetEnvironmentCommand) Init(args []string) (err error) {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	c.key, err = cmd.ZeroOrOneArgs(args)
 	return
 }
@@ -102,12 +98,7 @@
 	}
 }
 
-// SetFlags handled entirely by envcmd.EnvCommandBase
-
 func (c *SetEnvironmentCommand) Init(args []string) (err error) {
-	if err := c.EnsureEnvName(); err != nil {
-		return err
-	}
 	if len(args) == 0 {
 		return fmt.Errorf("No key, value pairs specified")
 	}
@@ -166,9 +157,6 @@
 }
 
 func (c *UnsetEnvironmentCommand) Init(args []string) (err error) {
-	if err := c.EnsureEnvName(); err != nil {
-		return err
-	}
 	if len(args) == 0 {
 		return fmt.Errorf("No keys specified")
 	}

=== modified file 'cmd/juju/environment_test.go'
--- cmd/juju/environment_test.go	2014-04-09 16:36:12 +0000
+++ cmd/juju/environment_test.go	2014-05-12 11:08:32 +0000
@@ -10,6 +10,7 @@
 	jc "github.com/juju/testing/checkers"
 	gc "launchpad.net/gocheck"
 
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/environs/config"
 	jujutesting "launchpad.net/juju-core/juju/testing"
 	"launchpad.net/juju-core/provider/dummy"
@@ -45,7 +46,7 @@
 
 func (s *GetEnvironmentSuite) TestSingleValue(c *gc.C) {
 	for _, t := range singleValueTests {
-		context, err := testing.RunCommand(c, &GetEnvironmentCommand{}, []string{t.key})
+		context, err := testing.RunCommand(c, envcmd.Wrap(&GetEnvironmentCommand{}), []string{t.key})
 		if t.err != "" {
 			c.Assert(err, gc.ErrorMatches, t.err)
 		} else {
@@ -57,12 +58,12 @@
 }
 
 func (s *GetEnvironmentSuite) TestTooManyArgs(c *gc.C) {
-	_, err := testing.RunCommand(c, &GetEnvironmentCommand{}, []string{"name", "type"})
+	_, err := testing.RunCommand(c, envcmd.Wrap(&GetEnvironmentCommand{}), []string{"name", "type"})
 	c.Assert(err, gc.ErrorMatches, `unrecognized args: \["type"\]`)
 }
 
 func (s *GetEnvironmentSuite) TestAllValues(c *gc.C) {
-	context, _ := testing.RunCommand(c, &GetEnvironmentCommand{}, []string{})
+	context, _ := testing.RunCommand(c, envcmd.Wrap(&GetEnvironmentCommand{}), []string{})
 	output := strings.TrimSpace(testing.Stdout(context))
 
 	// Make sure that all the environment keys are there. The admin
@@ -116,7 +117,7 @@
 func (s *SetEnvironmentSuite) TestInit(c *gc.C) {
 	for _, t := range setEnvInitTests {
 		command := &SetEnvironmentCommand{}
-		testing.TestInit(c, command, t.args, t.err)
+		testing.TestInit(c, envcmd.Wrap(command), t.args, t.err)
 		if t.expected != nil {
 			c.Assert(command.values, gc.DeepEquals, t.expected)
 		}
@@ -131,7 +132,7 @@
 	c.Assert(ok, gc.Equals, true)
 	c.Assert(series, gc.Equals, "precise") // default-series set in RepoSuite.SetUpTest
 
-	_, err = testing.RunCommand(c, &SetEnvironmentCommand{}, []string{"default-series=raring"})
+	_, err = testing.RunCommand(c, envcmd.Wrap(&SetEnvironmentCommand{}), []string{"default-series=raring"})
 	c.Assert(err, gc.IsNil)
 
 	stateConfig, err = s.State.EnvironConfig()
@@ -143,7 +144,7 @@
 }
 
 func (s *SetEnvironmentSuite) TestChangeBooleanAttribute(c *gc.C) {
-	_, err := testing.RunCommand(c, &SetEnvironmentCommand{}, []string{"ssl-hostname-verification=false"})
+	_, err := testing.RunCommand(c, envcmd.Wrap(&SetEnvironmentCommand{}), []string{"ssl-hostname-verification=false"})
 	c.Assert(err, gc.IsNil)
 
 	stateConfig, err := s.State.EnvironConfig()
@@ -152,7 +153,7 @@
 }
 
 func (s *SetEnvironmentSuite) TestChangeMultipleValues(c *gc.C) {
-	_, err := testing.RunCommand(c, &SetEnvironmentCommand{}, []string{"default-series=spartan", "broken=nope", "secret=sekrit"})
+	_, err := testing.RunCommand(c, envcmd.Wrap(&SetEnvironmentCommand{}), []string{"default-series=spartan", "broken=nope", "secret=sekrit"})
 	c.Assert(err, gc.IsNil)
 
 	stateConfig, err := s.State.EnvironConfig()
@@ -164,10 +165,10 @@
 }
 
 func (s *SetEnvironmentSuite) TestChangeAsCommandPair(c *gc.C) {
-	_, err := testing.RunCommand(c, &SetEnvironmentCommand{}, []string{"default-series=raring"})
+	_, err := testing.RunCommand(c, envcmd.Wrap(&SetEnvironmentCommand{}), []string{"default-series=raring"})
 	c.Assert(err, gc.IsNil)
 
-	context, err := testing.RunCommand(c, &GetEnvironmentCommand{}, []string{"default-series"})
+	context, err := testing.RunCommand(c, envcmd.Wrap(&GetEnvironmentCommand{}), []string{"default-series"})
 	c.Assert(err, gc.IsNil)
 	output := strings.TrimSpace(testing.Stdout(context))
 
@@ -185,7 +186,7 @@
 func (s *SetEnvironmentSuite) TestImmutableConfigValues(c *gc.C) {
 	for name, value := range immutableConfigTests {
 		param := fmt.Sprintf("%s=%s", name, value)
-		_, err := testing.RunCommand(c, &SetEnvironmentCommand{}, []string{param})
+		_, err := testing.RunCommand(c, envcmd.Wrap(&SetEnvironmentCommand{}), []string{param})
 		errorPattern := fmt.Sprintf("cannot change %s from .* to [\"]?%v[\"]?", name, value)
 		c.Assert(err, gc.ErrorMatches, errorPattern)
 	}
@@ -239,7 +240,7 @@
 	for _, t := range unsetEnvTests {
 		c.Logf("testing unset-env %v", t.args)
 		s.initConfig(c)
-		_, err := testing.RunCommand(c, &UnsetEnvironmentCommand{}, t.args)
+		_, err := testing.RunCommand(c, envcmd.Wrap(&UnsetEnvironmentCommand{}), t.args)
 		if t.err != "" {
 			c.Assert(err, gc.ErrorMatches, t.err)
 		} else {

=== modified file 'cmd/juju/expose.go'
--- cmd/juju/expose.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/expose.go	2014-05-12 11:08:32 +0000
@@ -33,9 +33,6 @@
 }
 
 func (c *ExposeCommand) Init(args []string) error {
-	if err := c.EnsureEnvName(); err != nil {
-		return err
-	}
 	if len(args) == 0 {
 		return errors.New("no service name specified")
 	}

=== modified file 'cmd/juju/expose_test.go'
--- cmd/juju/expose_test.go	2013-09-13 14:48:13 +0000
+++ cmd/juju/expose_test.go	2014-05-12 11:08:32 +0000
@@ -7,6 +7,7 @@
 	gc "launchpad.net/gocheck"
 
 	"launchpad.net/juju-core/charm"
+	"launchpad.net/juju-core/cmd/envcmd"
 	jujutesting "launchpad.net/juju-core/juju/testing"
 	"launchpad.net/juju-core/testing"
 )
@@ -18,7 +19,7 @@
 var _ = gc.Suite(&ExposeSuite{})
 
 func runExpose(c *gc.C, args ...string) error {
-	_, err := testing.RunCommand(c, &ExposeCommand{}, args)
+	_, err := testing.RunCommand(c, envcmd.Wrap(&ExposeCommand{}), args)
 	return err
 }
 

=== modified file 'cmd/juju/get.go'
--- cmd/juju/get.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/get.go	2014-05-12 11:08:32 +0000
@@ -29,7 +29,6 @@
 }
 
 func (c *GetCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	// TODO(dfc) add json formatting ?
 	c.out.AddFlags(f, "yaml", map[string]cmd.Formatter{
 		"yaml": cmd.FormatYaml,
@@ -37,9 +36,6 @@
 }
 
 func (c *GetCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	// TODO(dfc) add --schema-only
 	if len(args) == 0 {
 		return errors.New("no service name specified")

=== modified file 'cmd/juju/get_test.go'
--- cmd/juju/get_test.go	2013-10-09 13:55:14 +0000
+++ cmd/juju/get_test.go	2014-05-12 11:08:32 +0000
@@ -11,6 +11,7 @@
 
 	"launchpad.net/juju-core/charm"
 	"launchpad.net/juju-core/cmd"
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/juju/testing"
 	coretesting "launchpad.net/juju-core/testing"
 )
@@ -67,7 +68,7 @@
 	c.Assert(err, gc.IsNil)
 	for _, t := range getTests {
 		ctx := coretesting.Context(c)
-		code := cmd.Main(&GetCommand{}, ctx, []string{t.service})
+		code := cmd.Main(envcmd.Wrap(&GetCommand{}), ctx, []string{t.service})
 		c.Check(code, gc.Equals, 0)
 		c.Assert(ctx.Stderr.(*bytes.Buffer).String(), gc.Equals, "")
 		// round trip via goyaml to avoid being sucked into a quagmire of

=== modified file 'cmd/juju/main.go'
--- cmd/juju/main.go	2014-05-09 22:56:29 +0000
+++ cmd/juju/main.go	2014-05-12 11:08:32 +0000
@@ -10,6 +10,7 @@
 	"github.com/juju/loggo"
 
 	"launchpad.net/juju-core/cmd"
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/environs"
 	"launchpad.net/juju-core/juju"
 
@@ -72,104 +73,99 @@
 
 	jujucmd.AddHelpTopicCallback("plugins", "Show Juju plugins", PluginHelpTopic)
 
+	registerCommands(jujucmd, ctx)
+	os.Exit(cmd.Main(jujucmd, ctx, args[1:]))
+}
+
+type commandRegistry interface {
+	Register(cmd.Command)
+}
+
+// registerCommands registers commands in the specified registry.
+// EnvironCommands must be wrapped with an envCmdWrapper.
+func registerCommands(r commandRegistry, ctx *cmd.Context) {
+	wrapEnvCommand := func(c envcmd.EnvironCommand) cmd.Command {
+		return envCmdWrapper{envcmd.Wrap(c), ctx}
+	}
+
 	// Creation commands.
-	jujucmd.Register(wrap(&BootstrapCommand{}))
-	jujucmd.Register(wrap(&AddMachineCommand{}))
-	jujucmd.Register(wrap(&DeployCommand{}))
-	jujucmd.Register(wrap(&AddRelationCommand{}))
-	jujucmd.Register(wrap(&AddUnitCommand{}))
+	r.Register(wrapEnvCommand(&BootstrapCommand{}))
+	r.Register(wrapEnvCommand(&AddMachineCommand{}))
+	r.Register(wrapEnvCommand(&DeployCommand{}))
+	r.Register(wrapEnvCommand(&AddRelationCommand{}))
+	r.Register(wrapEnvCommand(&AddUnitCommand{}))
 
 	// Destruction commands.
-	jujucmd.Register(wrap(&RemoveMachineCommand{}))
-	jujucmd.Register(wrap(&RemoveRelationCommand{}))
-	jujucmd.Register(wrap(&RemoveServiceCommand{}))
-	jujucmd.Register(wrap(&RemoveUnitCommand{}))
-	jujucmd.Register(wrap(&DestroyEnvironmentCommand{}))
+	r.Register(wrapEnvCommand(&RemoveMachineCommand{}))
+	r.Register(wrapEnvCommand(&RemoveRelationCommand{}))
+	r.Register(wrapEnvCommand(&RemoveServiceCommand{}))
+	r.Register(wrapEnvCommand(&RemoveUnitCommand{}))
+	r.Register(&DestroyEnvironmentCommand{})
 
 	// Reporting commands.
-	jujucmd.Register(wrap(&StatusCommand{}))
-	jujucmd.Register(wrap(&SwitchCommand{}))
-	jujucmd.Register(wrap(&EndpointCommand{}))
+	r.Register(wrapEnvCommand(&StatusCommand{}))
+	r.Register(&SwitchCommand{})
+	r.Register(wrapEnvCommand(&EndpointCommand{}))
 
 	// Error resolution and debugging commands.
-	jujucmd.Register(wrap(&RunCommand{}))
-	jujucmd.Register(wrap(&SCPCommand{}))
-	jujucmd.Register(wrap(&SSHCommand{}))
-	jujucmd.Register(wrap(&ResolvedCommand{}))
-	jujucmd.Register(wrap(&DebugLogCommand{}))
-	jujucmd.Register(wrap(&DebugHooksCommand{}))
-	jujucmd.Register(wrap(&RetryProvisioningCommand{}))
+	r.Register(wrapEnvCommand(&RunCommand{}))
+	r.Register(wrapEnvCommand(&SCPCommand{}))
+	r.Register(wrapEnvCommand(&SSHCommand{}))
+	r.Register(wrapEnvCommand(&ResolvedCommand{}))
+	r.Register(wrapEnvCommand(&DebugLogCommand{}))
+	r.Register(wrapEnvCommand(&DebugHooksCommand{}))
+	r.Register(wrapEnvCommand(&RetryProvisioningCommand{}))
 
 	// Configuration commands.
-	jujucmd.Register(wrap(&InitCommand{}))
-	jujucmd.Register(wrap(&GetCommand{}))
-	jujucmd.Register(wrap(&SetCommand{}))
-	jujucmd.Register(wrap(&UnsetCommand{}))
-	jujucmd.Register(wrap(&GetConstraintsCommand{}))
-	jujucmd.Register(wrap(&SetConstraintsCommand{}))
-	jujucmd.Register(wrap(&GetEnvironmentCommand{}))
-	jujucmd.Register(wrap(&SetEnvironmentCommand{}))
-	jujucmd.Register(wrap(&UnsetEnvironmentCommand{}))
-	jujucmd.Register(wrap(&ExposeCommand{}))
-	jujucmd.Register(wrap(&SyncToolsCommand{}))
-	jujucmd.Register(wrap(&UnexposeCommand{}))
-	jujucmd.Register(wrap(&UpgradeJujuCommand{}))
-	jujucmd.Register(wrap(&UpgradeCharmCommand{}))
+	r.Register(&InitCommand{})
+	r.Register(wrapEnvCommand(&GetCommand{}))
+	r.Register(wrapEnvCommand(&SetCommand{}))
+	r.Register(wrapEnvCommand(&UnsetCommand{}))
+	r.Register(wrapEnvCommand(&GetConstraintsCommand{}))
+	r.Register(wrapEnvCommand(&SetConstraintsCommand{}))
+	r.Register(wrapEnvCommand(&GetEnvironmentCommand{}))
+	r.Register(wrapEnvCommand(&SetEnvironmentCommand{}))
+	r.Register(wrapEnvCommand(&UnsetEnvironmentCommand{}))
+	r.Register(wrapEnvCommand(&ExposeCommand{}))
+	r.Register(wrapEnvCommand(&SyncToolsCommand{}))
+	r.Register(wrapEnvCommand(&UnexposeCommand{}))
+	r.Register(wrapEnvCommand(&UpgradeJujuCommand{}))
+	r.Register(wrapEnvCommand(&UpgradeCharmCommand{}))
 
 	// Charm publishing commands.
-	jujucmd.Register(wrap(&PublishCommand{}))
+	r.Register(wrapEnvCommand(&PublishCommand{}))
 
 	// Charm tool commands.
-	jujucmd.Register(wrap(&HelpToolCommand{}))
+	r.Register(&HelpToolCommand{})
 
 	// Manage authorized ssh keys.
-	jujucmd.Register(wrap(NewAuthorizedKeysCommand()))
+	r.Register(NewAuthorizedKeysCommand())
 
 	// Manage state server availability.
-	// TODO: enable once the backend is ready for it.
-	jujucmd.Register(wrap(&EnsureAvailabilityCommand{}))
+	r.Register(wrapEnvCommand(&EnsureAvailabilityCommand{}))
 
 	// Common commands.
-	jujucmd.Register(wrap(&cmd.VersionCommand{}))
-
-	os.Exit(cmd.Main(jujucmd, ctx, args[1:]))
-}
-
-// wrap encapsulates code that wraps some of the commands in a helper class
-// that handles some common errors
-func wrap(c cmd.Command) cmd.Command {
-	if ec, ok := c.(envCmd); ok {
-		return envCmdWrapper{ec}
-	}
-	return c
-}
-
-// envCmd is a Command that interacts with the juju client environment
-type envCmd interface {
-	cmd.Command
-	EnvironName() string
+	r.Register(&cmd.VersionCommand{})
 }
 
 // envCmdWrapper is a struct that wraps an environment command and lets us handle
-// errors returned from Run before they're returned to the main function
+// errors returned from Init before they're returned to the main function.
 type envCmdWrapper struct {
-	envCmd
+	cmd.Command
+	ctx *cmd.Context
 }
 
-// Run in envCmdWrapper gives us an opportunity to handle errors after the command is
-// run. This is used to give informative messages to the user.
-func (c envCmdWrapper) Run(ctx *cmd.Context) error {
-	err := c.envCmd.Run(ctx)
-	if environs.IsNoEnv(err) && c.EnvironName() == "" {
-		fmt.Fprintln(ctx.Stderr, "No juju environment configuration file exists.")
-		fmt.Fprintln(ctx.Stderr, err)
-		fmt.Fprintln(ctx.Stderr, "Please create a configuration by running:")
-		fmt.Fprintln(ctx.Stderr, "    juju init")
-		fmt.Fprintln(ctx.Stderr, "then edit the file to configure your juju environment.")
-		fmt.Fprintln(ctx.Stderr, "You can then re-run the command.")
+func (w envCmdWrapper) Init(args []string) error {
+	err := w.Command.Init(args)
+	if environs.IsNoEnv(err) {
+		fmt.Fprintln(w.ctx.Stderr, "No juju environment configuration file exists.")
+		fmt.Fprintln(w.ctx.Stderr, err)
+		fmt.Fprintln(w.ctx.Stderr, "Please create a configuration by running:")
+		fmt.Fprintln(w.ctx.Stderr, "    juju init")
+		fmt.Fprintln(w.ctx.Stderr, "then edit the file to configure your juju environment.")
+		fmt.Fprintln(w.ctx.Stderr, "You can then re-run the command.")
 		return cmd.ErrSilent
 	}
-
 	return err
 }
 

=== modified file 'cmd/juju/main_test.go'
--- cmd/juju/main_test.go	2014-04-25 13:57:06 +0000
+++ cmd/juju/main_test.go	2014-05-12 11:08:32 +0000
@@ -19,6 +19,7 @@
 	gc "launchpad.net/gocheck"
 
 	"launchpad.net/juju-core/cmd"
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/juju/osenv"
 	_ "launchpad.net/juju-core/provider/dummy"
 	"launchpad.net/juju-core/testing"
@@ -70,11 +71,11 @@
 }
 
 func deployHelpText() string {
-	return helpText(&DeployCommand{}, "juju deploy")
+	return helpText(envcmd.Wrap(&DeployCommand{}), "juju deploy")
 }
 
 func syncToolsHelpText() string {
-	return helpText(&SyncToolsCommand{}, "juju sync-tools")
+	return helpText(envcmd.Wrap(&SyncToolsCommand{}), "juju sync-tools")
 }
 
 func (s *MainSuite) TestRunMain(c *gc.C) {
@@ -350,3 +351,20 @@
 		c.Assert(line, gc.Matches, globalFlags[i])
 	}
 }
+
+type commands []cmd.Command
+
+func (r *commands) Register(c cmd.Command) {
+	*r = append(*r, c)
+}
+
+func (s *MainSuite) TestEnvironCommands(c *gc.C) {
+	var commands commands
+	registerCommands(&commands, testing.Context(c))
+	// There should not be any EnvironCommands registered.
+	// EnvironCommands must be wrapped using envcmd.Wrap.
+	for _, cmd := range commands {
+		c.Logf("%v", cmd.Info().Name)
+		c.Check(cmd, gc.Not(gc.FitsTypeOf), envcmd.EnvironCommand(&BootstrapCommand{}))
+	}
+}

=== modified file 'cmd/juju/plugin.go'
--- cmd/juju/plugin.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/plugin.go	2014-05-12 11:08:32 +0000
@@ -46,7 +46,7 @@
 
 func RunPlugin(ctx *cmd.Context, subcommand string, args []string) error {
 	cmdName := JujuPluginPrefix + subcommand
-	plugin := &PluginCommand{name: cmdName}
+	plugin := envcmd.Wrap(&PluginCommand{name: cmdName})
 
 	// We process common flags supported by Juju commands.
 	// To do this, we extract only those supported flags from the
@@ -84,22 +84,15 @@
 }
 
 func (c *PluginCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	c.args = args
 	return nil
 }
 
-func (c *PluginCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
-}
-
 func (c *PluginCommand) Run(ctx *cmd.Context) error {
 	command := exec.Command(c.name, c.args...)
 	command.Env = append(os.Environ(), []string{
 		osenv.JujuHomeEnvKey + "=" + osenv.JujuHome(),
-		osenv.JujuEnvEnvKey + "=" + c.EnvironName()}...,
+		osenv.JujuEnvEnvKey + "=" + c.EnvName}...,
 	)
 
 	// Now hook up stdin, stdout, stderr

=== modified file 'cmd/juju/publish.go'
--- cmd/juju/publish.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/publish.go	2014-05-12 11:08:32 +0000
@@ -55,14 +55,10 @@
 }
 
 func (c *PublishCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	f.StringVar(&c.CharmPath, "from", ".", "path for charm to be published")
 }
 
 func (c *PublishCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	if len(args) == 0 {
 		return nil
 	}

=== modified file 'cmd/juju/publish_test.go'
--- cmd/juju/publish_test.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/publish_test.go	2014-05-12 11:08:32 +0000
@@ -12,6 +12,7 @@
 	"launchpad.net/juju-core/bzr"
 	"launchpad.net/juju-core/charm"
 	"launchpad.net/juju-core/cmd"
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/testing"
 	"launchpad.net/juju-core/testing/testbase"
 )
@@ -52,7 +53,7 @@
 }
 
 func (s *PublishSuite) runPublish(c *gc.C, args ...string) (*cmd.Context, error) {
-	return testing.RunCommandInDir(c, &PublishCommand{}, args, s.dir)
+	return testing.RunCommandInDir(c, envcmd.Wrap(&PublishCommand{}), args, s.dir)
 }
 
 const pollDelay = testing.ShortWait
@@ -94,7 +95,7 @@
 
 func (s *PublishSuite) TestNoBranch(c *gc.C) {
 	dir := c.MkDir()
-	_, err := testing.RunCommandInDir(c, &PublishCommand{}, []string{"cs:precise/wordpress"}, dir)
+	_, err := testing.RunCommandInDir(c, envcmd.Wrap(&PublishCommand{}), []string{"cs:precise/wordpress"}, dir)
 	c.Assert(err, gc.ErrorMatches, fmt.Sprintf("not a charm branch: %s", dir))
 }
 
@@ -104,7 +105,7 @@
 }
 
 func (s *PublishSuite) TestFrom(c *gc.C) {
-	_, err := testing.RunCommandInDir(c, &PublishCommand{}, []string{"--from", s.dir, "cs:precise/wordpress"}, c.MkDir())
+	_, err := testing.RunCommandInDir(c, envcmd.Wrap(&PublishCommand{}), []string{"--from", s.dir, "cs:precise/wordpress"}, c.MkDir())
 	c.Assert(err, gc.ErrorMatches, `cannot obtain local digest: branch has no content`)
 }
 
@@ -149,7 +150,7 @@
 		panic("unreachable")
 	})
 
-	_, err := testing.RunCommandInDir(c, cmd, []string{"precise/wordpress"}, s.dir)
+	_, err := testing.RunCommandInDir(c, envcmd.Wrap(cmd), []string{"precise/wordpress"}, s.dir)
 	c.Assert(err, gc.IsNil)
 	c.Fatal("shouldn't get here; location closure didn't run?")
 }
@@ -264,7 +265,7 @@
 	body = `{"cs:~user/precise/wordpress": {"kind": "published", "digest": %q, "revision": 42}}`
 	testing.Server.Response(200, nil, []byte(fmt.Sprintf(body, digest)))
 
-	ctx, err := testing.RunCommandInDir(c, cmd, []string{"cs:~user/precise/wordpress"}, s.dir)
+	ctx, err := testing.RunCommandInDir(c, envcmd.Wrap(cmd), []string{"cs:~user/precise/wordpress"}, s.dir)
 	c.Assert(err, gc.IsNil)
 	c.Assert(testing.Stdout(ctx), gc.Equals, "cs:~user/precise/wordpress-42\n")
 
@@ -320,7 +321,7 @@
 	body = `{"cs:~user/precise/wordpress": {"kind": "published", "digest": %q, "revision": 42}}`
 	testing.Server.Response(200, nil, []byte(fmt.Sprintf(body, digest)))
 
-	ctx, err := testing.RunCommandInDir(c, cmd, []string{"cs:~user/precise/wordpress"}, s.dir)
+	ctx, err := testing.RunCommandInDir(c, envcmd.Wrap(cmd), []string{"cs:~user/precise/wordpress"}, s.dir)
 	c.Assert(err, gc.IsNil)
 	c.Assert(testing.Stdout(ctx), gc.Equals, "cs:~user/precise/wordpress-42\n")
 
@@ -376,7 +377,7 @@
 	body = `{"cs:~user/precise/wordpress": {"kind": "published", "digest": "surprising-digest", "revision": 42}}`
 	testing.Server.Response(200, nil, []byte(body))
 
-	_, err = testing.RunCommandInDir(c, cmd, []string{"cs:~user/precise/wordpress"}, s.dir)
+	_, err = testing.RunCommandInDir(c, envcmd.Wrap(cmd), []string{"cs:~user/precise/wordpress"}, s.dir)
 	c.Assert(err, gc.ErrorMatches, `charm changed but not to local charm digest; publishing race\?`)
 
 	// Ensure the branch was actually pushed.

=== modified file 'cmd/juju/removemachine.go'
--- cmd/juju/removemachine.go	2014-05-11 22:52:40 +0000
+++ cmd/juju/removemachine.go	2014-05-12 11:08:32 +0000
@@ -46,14 +46,10 @@
 }
 
 func (c *RemoveMachineCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	f.BoolVar(&c.Force, "force", false, "completely remove machine and all dependencies")
 }
 
 func (c *RemoveMachineCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	if len(args) == 0 {
 		return fmt.Errorf("no machines specified")
 	}

=== modified file 'cmd/juju/removemachine_test.go'
--- cmd/juju/removemachine_test.go	2014-05-09 22:56:29 +0000
+++ cmd/juju/removemachine_test.go	2014-05-12 11:08:32 +0000
@@ -7,6 +7,7 @@
 	jc "github.com/juju/testing/checkers"
 	gc "launchpad.net/gocheck"
 
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/errors"
 	jujutesting "launchpad.net/juju-core/juju/testing"
 	"launchpad.net/juju-core/state"
@@ -20,7 +21,7 @@
 var _ = gc.Suite(&RemoveMachineSuite{})
 
 func runRemoveMachine(c *gc.C, args ...string) error {
-	_, err := testing.RunCommand(c, &RemoveMachineCommand{}, args)
+	_, err := testing.RunCommand(c, envcmd.Wrap(&RemoveMachineCommand{}), args)
 	return err
 }
 

=== modified file 'cmd/juju/removerelation.go'
--- cmd/juju/removerelation.go	2014-05-11 22:52:40 +0000
+++ cmd/juju/removerelation.go	2014-05-12 11:08:32 +0000
@@ -27,9 +27,6 @@
 }
 
 func (c *RemoveRelationCommand) Init(args []string) error {
-	if err := c.EnsureEnvName(); err != nil {
-		return err
-	}
 	if len(args) != 2 {
 		return fmt.Errorf("a relation must involve two services")
 	}

=== modified file 'cmd/juju/removerelation_test.go'
--- cmd/juju/removerelation_test.go	2014-05-08 21:27:00 +0000
+++ cmd/juju/removerelation_test.go	2014-05-12 11:08:32 +0000
@@ -6,6 +6,7 @@
 import (
 	gc "launchpad.net/gocheck"
 
+	"launchpad.net/juju-core/cmd/envcmd"
 	jujutesting "launchpad.net/juju-core/juju/testing"
 	"launchpad.net/juju-core/testing"
 )
@@ -17,7 +18,7 @@
 var _ = gc.Suite(&RemoveRelationSuite{})
 
 func runRemoveRelation(c *gc.C, args ...string) error {
-	_, err := testing.RunCommand(c, &RemoveRelationCommand{}, args)
+	_, err := testing.RunCommand(c, envcmd.Wrap(&RemoveRelationCommand{}), args)
 	return err
 }
 

=== modified file 'cmd/juju/removeservice.go'
--- cmd/juju/removeservice.go	2014-05-11 22:52:40 +0000
+++ cmd/juju/removeservice.go	2014-05-12 11:08:32 +0000
@@ -29,9 +29,6 @@
 }
 
 func (c *RemoveServiceCommand) Init(args []string) error {
-	if err := c.EnsureEnvName(); err != nil {
-		return err
-	}
 	if len(args) == 0 {
 		return fmt.Errorf("no service specified")
 	}

=== modified file 'cmd/juju/removeservice_test.go'
--- cmd/juju/removeservice_test.go	2014-05-08 21:27:00 +0000
+++ cmd/juju/removeservice_test.go	2014-05-12 11:08:32 +0000
@@ -6,6 +6,7 @@
 import (
 	gc "launchpad.net/gocheck"
 
+	"launchpad.net/juju-core/cmd/envcmd"
 	jujutesting "launchpad.net/juju-core/juju/testing"
 	"launchpad.net/juju-core/state"
 	"launchpad.net/juju-core/testing"
@@ -18,7 +19,7 @@
 var _ = gc.Suite(&RemoveServiceSuite{})
 
 func runRemoveService(c *gc.C, args ...string) error {
-	_, err := testing.RunCommand(c, &RemoveServiceCommand{}, args)
+	_, err := testing.RunCommand(c, envcmd.Wrap(&RemoveServiceCommand{}), args)
 	return err
 }
 

=== modified file 'cmd/juju/removeunit.go'
--- cmd/juju/removeunit.go	2014-05-11 22:52:40 +0000
+++ cmd/juju/removeunit.go	2014-05-12 11:08:32 +0000
@@ -29,9 +29,6 @@
 }
 
 func (c *RemoveUnitCommand) Init(args []string) error {
-	if err := c.EnsureEnvName(); err != nil {
-		return err
-	}
 	c.UnitNames = args
 	if len(c.UnitNames) == 0 {
 		return errors.New("no units specified")

=== modified file 'cmd/juju/removeunit_test.go'
--- cmd/juju/removeunit_test.go	2014-05-08 21:27:00 +0000
+++ cmd/juju/removeunit_test.go	2014-05-12 11:08:32 +0000
@@ -7,6 +7,7 @@
 	gc "launchpad.net/gocheck"
 
 	"launchpad.net/juju-core/charm"
+	"launchpad.net/juju-core/cmd/envcmd"
 	jujutesting "launchpad.net/juju-core/juju/testing"
 	"launchpad.net/juju-core/state"
 	"launchpad.net/juju-core/testing"
@@ -19,7 +20,7 @@
 var _ = gc.Suite(&RemoveUnitSuite{})
 
 func runRemoveUnit(c *gc.C, args ...string) error {
-	_, err := testing.RunCommand(c, &RemoveUnitCommand{}, args)
+	_, err := testing.RunCommand(c, envcmd.Wrap(&RemoveUnitCommand{}), args)
 	return err
 }
 

=== modified file 'cmd/juju/removeuser.go'
--- cmd/juju/removeuser.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/removeuser.go	2014-05-12 11:08:32 +0000
@@ -33,9 +33,6 @@
 }
 
 func (c *RemoveUserCommand) Init(args []string) error {
-	if err := c.EnsureEnvName(); err != nil {
-		return err
-	}
 	if len(args) == 0 {
 		return errors.New("no username supplied")
 	}

=== modified file 'cmd/juju/removeuser_test.go'
--- cmd/juju/removeuser_test.go	2014-03-27 04:28:45 +0000
+++ cmd/juju/removeuser_test.go	2014-05-12 11:08:32 +0000
@@ -6,6 +6,7 @@
 import (
 	gc "launchpad.net/gocheck"
 
+	"launchpad.net/juju-core/cmd/envcmd"
 	jujutesting "launchpad.net/juju-core/juju/testing"
 	"launchpad.net/juju-core/testing"
 )
@@ -17,19 +18,19 @@
 var _ = gc.Suite(&RemoveUserSuite{})
 
 func (s *RemoveUserSuite) TestRemoveUser(c *gc.C) {
-	_, err := testing.RunCommand(c, &AddUserCommand{}, []string{"foobar", "password"})
+	_, err := testing.RunCommand(c, envcmd.Wrap(&AddUserCommand{}), []string{"foobar", "password"})
 	c.Assert(err, gc.IsNil)
 
-	_, err = testing.RunCommand(c, &RemoveUserCommand{}, []string{"foobar"})
+	_, err = testing.RunCommand(c, envcmd.Wrap(&RemoveUserCommand{}), []string{"foobar"})
 	c.Assert(err, gc.IsNil)
 }
 
 func (s *RemoveUserSuite) TestTooManyArgs(c *gc.C) {
-	_, err := testing.RunCommand(c, &RemoveUserCommand{}, []string{"foobar", "password"})
+	_, err := testing.RunCommand(c, envcmd.Wrap(&RemoveUserCommand{}), []string{"foobar", "password"})
 	c.Assert(err, gc.ErrorMatches, `unrecognized args: \["password"\]`)
 }
 
 func (s *RemoveUserSuite) TestNotEnoughArgs(c *gc.C) {
-	_, err := testing.RunCommand(c, &RemoveUserCommand{}, []string{})
+	_, err := testing.RunCommand(c, envcmd.Wrap(&RemoveUserCommand{}), []string{})
 	c.Assert(err, gc.ErrorMatches, `no username supplied`)
 }

=== modified file 'cmd/juju/resolved.go'
--- cmd/juju/resolved.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/resolved.go	2014-05-12 11:08:32 +0000
@@ -30,15 +30,11 @@
 }
 
 func (c *ResolvedCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	f.BoolVar(&c.Retry, "r", false, "re-execute failed hooks")
 	f.BoolVar(&c.Retry, "retry", false, "")
 }
 
 func (c *ResolvedCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	if len(args) > 0 {
 		c.UnitName = args[0]
 		if !names.IsUnit(c.UnitName) {

=== modified file 'cmd/juju/resolved_test.go'
--- cmd/juju/resolved_test.go	2013-09-18 15:57:30 +0000
+++ cmd/juju/resolved_test.go	2014-05-12 11:08:32 +0000
@@ -6,6 +6,7 @@
 import (
 	gc "launchpad.net/gocheck"
 
+	"launchpad.net/juju-core/cmd/envcmd"
 	jujutesting "launchpad.net/juju-core/juju/testing"
 	"launchpad.net/juju-core/state"
 	"launchpad.net/juju-core/state/api/params"
@@ -19,7 +20,7 @@
 var _ = gc.Suite(&ResolvedSuite{})
 
 func runResolved(c *gc.C, args []string) error {
-	_, err := testing.RunCommand(c, &ResolvedCommand{}, args)
+	_, err := testing.RunCommand(c, envcmd.Wrap(&ResolvedCommand{}), args)
 	return err
 }
 

=== modified file 'cmd/juju/retryprovisioning.go'
--- cmd/juju/retryprovisioning.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/retryprovisioning.go	2014-05-12 11:08:32 +0000
@@ -28,9 +28,6 @@
 }
 
 func (c *RetryProvisioningCommand) Init(args []string) error {
-	if err := c.EnsureEnvName(); err != nil {
-		return err
-	}
 	if len(args) == 0 {
 		return fmt.Errorf("no machine specified")
 	}

=== modified file 'cmd/juju/retryprovisioning_test.go'
--- cmd/juju/retryprovisioning_test.go	2014-03-26 12:42:30 +0000
+++ cmd/juju/retryprovisioning_test.go	2014-05-12 11:08:32 +0000
@@ -9,6 +9,7 @@
 	jc "github.com/juju/testing/checkers"
 	gc "launchpad.net/gocheck"
 
+	"launchpad.net/juju-core/cmd/envcmd"
 	jujutesting "launchpad.net/juju-core/juju/testing"
 	"launchpad.net/juju-core/state"
 	"launchpad.net/juju-core/state/api/params"
@@ -61,7 +62,7 @@
 
 	for i, t := range resolvedMachineTests {
 		c.Logf("test %d: %v", i, t.args)
-		context, err := testing.RunCommand(c, &RetryProvisioningCommand{}, t.args)
+		context, err := testing.RunCommand(c, envcmd.Wrap(&RetryProvisioningCommand{}), t.args)
 		if t.err != "" {
 			c.Check(err, gc.ErrorMatches, t.err)
 			continue

=== modified file 'cmd/juju/run.go'
--- cmd/juju/run.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/run.go	2014-05-12 11:08:32 +0000
@@ -70,7 +70,6 @@
 }
 
 func (c *RunCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	c.out.AddFlags(f, "smart", cmd.DefaultFormatters)
 	f.BoolVar(&c.all, "all", false, "run the commands on all the machines")
 	f.DurationVar(&c.timeout, "timeout", 5*time.Minute, "how long to wait before the remote command is considered to have failed")
@@ -80,9 +79,6 @@
 }
 
 func (c *RunCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	if len(args) == 0 {
 		return errors.New("no commands specified")
 	}

=== modified file 'cmd/juju/run_test.go'
--- cmd/juju/run_test.go	2014-03-27 04:10:28 +0000
+++ cmd/juju/run_test.go	2014-05-12 11:08:32 +0000
@@ -11,6 +11,7 @@
 	gc "launchpad.net/gocheck"
 
 	"launchpad.net/juju-core/cmd"
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/state/api/params"
 	"launchpad.net/juju-core/testing"
 	"launchpad.net/juju-core/utils/exec"
@@ -106,7 +107,7 @@
 	}} {
 		c.Log(fmt.Sprintf("%v: %s", i, test.message))
 		runCmd := &RunCommand{}
-		testing.TestInit(c, runCmd, test.args, test.errMatch)
+		testing.TestInit(c, envcmd.Wrap(runCmd), test.args, test.errMatch)
 		if test.errMatch == "" {
 			c.Check(runCmd.all, gc.Equals, test.all)
 			c.Check(runCmd.machines, gc.DeepEquals, test.machines)
@@ -142,7 +143,7 @@
 	}} {
 		c.Log(fmt.Sprintf("%v: %s", i, test.message))
 		runCmd := &RunCommand{}
-		testing.TestInit(c, runCmd, test.args, test.errMatch)
+		testing.TestInit(c, envcmd.Wrap(runCmd), test.args, test.errMatch)
 		if test.errMatch == "" {
 			c.Check(runCmd.timeout, gc.Equals, test.timeout)
 		}
@@ -257,7 +258,7 @@
 	jsonFormatted, err := cmd.FormatJson(unformatted)
 	c.Assert(err, gc.IsNil)
 
-	context, err := testing.RunCommand(c, &RunCommand{}, []string{
+	context, err := testing.RunCommand(c, envcmd.Wrap(&RunCommand{}), []string{
 		"--format=json", "--machine=0", "--unit=unit/0", "hostname",
 	})
 	c.Assert(err, gc.IsNil)
@@ -337,7 +338,7 @@
 			args = append(args, "--format", test.format)
 		}
 		args = append(args, "--all", "ignored")
-		context, err := testing.RunCommand(c, &RunCommand{}, args)
+		context, err := testing.RunCommand(c, envcmd.Wrap(&RunCommand{}), args)
 		if test.errorMatch != "" {
 			c.Check(err, gc.ErrorMatches, test.errorMatch)
 		} else {

=== modified file 'cmd/juju/set.go'
--- cmd/juju/set.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/set.go	2014-05-12 11:08:32 +0000
@@ -39,14 +39,10 @@
 }
 
 func (c *SetCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	f.Var(&c.SettingsYAML, "config", "path to yaml-formatted service config")
 }
 
 func (c *SetCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	if len(args) == 0 || len(strings.Split(args[0], "=")) > 1 {
 		return errors.New("no service name specified")
 	}

=== modified file 'cmd/juju/set_test.go'
--- cmd/juju/set_test.go	2013-10-09 13:55:14 +0000
+++ cmd/juju/set_test.go	2014-05-12 11:08:32 +0000
@@ -11,6 +11,7 @@
 
 	"launchpad.net/juju-core/charm"
 	"launchpad.net/juju-core/cmd"
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/juju/testing"
 	"launchpad.net/juju-core/state"
 	coretesting "launchpad.net/juju-core/testing"
@@ -73,7 +74,7 @@
 // assertSetSuccess sets configuration options and checks the expected settings.
 func assertSetSuccess(c *gc.C, dir string, svc *state.Service, args []string, expect charm.Settings) {
 	ctx := coretesting.ContextForDir(c, dir)
-	code := cmd.Main(&SetCommand{}, ctx, append([]string{"dummy-service"}, args...))
+	code := cmd.Main(envcmd.Wrap(&SetCommand{}), ctx, append([]string{"dummy-service"}, args...))
 	c.Check(code, gc.Equals, 0)
 	settings, err := svc.ConfigSettings()
 	c.Assert(err, gc.IsNil)
@@ -83,7 +84,7 @@
 // assertSetFail sets configuration options and checks the expected error.
 func assertSetFail(c *gc.C, dir string, args []string, err string) {
 	ctx := coretesting.ContextForDir(c, dir)
-	code := cmd.Main(&SetCommand{}, ctx, append([]string{"dummy-service"}, args...))
+	code := cmd.Main(envcmd.Wrap(&SetCommand{}), ctx, append([]string{"dummy-service"}, args...))
 	c.Check(code, gc.Not(gc.Equals), 0)
 	c.Assert(ctx.Stderr.(*bytes.Buffer).String(), gc.Matches, err)
 }

=== modified file 'cmd/juju/ssh.go'
--- cmd/juju/ssh.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/ssh.go	2014-05-12 11:08:32 +0000
@@ -40,7 +40,6 @@
 }
 
 func (c *SSHCommon) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	f.BoolVar(&c.proxy, "proxy", true, "proxy through the API server")
 	f.BoolVar(&c.pty, "pty", true, "enable pseudo-tty allocation")
 }
@@ -94,9 +93,6 @@
 }
 
 func (c *SSHCommand) Init(args []string) error {
-	if err := c.EnsureEnvName(); err != nil {
-		return err
-	}
 	if len(args) == 0 {
 		return errors.New("no target name specified")
 	}

=== modified file 'cmd/juju/ssh_test.go'
--- cmd/juju/ssh_test.go	2014-05-09 07:41:52 +0000
+++ cmd/juju/ssh_test.go	2014-05-12 11:08:32 +0000
@@ -14,6 +14,7 @@
 
 	"launchpad.net/juju-core/charm"
 	"launchpad.net/juju-core/cmd"
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/instance"
 	"launchpad.net/juju-core/juju/testing"
 	"launchpad.net/juju-core/state"
@@ -113,7 +114,7 @@
 		c.Logf("test %d: %s -> %s\n", i, t.about, t.args)
 		ctx := coretesting.Context(c)
 		jujucmd := cmd.NewSuperCommand(cmd.SuperCommandParams{})
-		jujucmd.Register(&SSHCommand{})
+		jujucmd.Register(envcmd.Wrap(&SSHCommand{}))
 
 		code := cmd.Main(jujucmd, ctx, t.args)
 		c.Check(code, gc.Equals, 0)

=== modified file 'cmd/juju/status.go'
--- cmd/juju/status.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/status.go	2014-05-12 11:08:32 +0000
@@ -50,7 +50,6 @@
 }
 
 func (c *StatusCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	c.out.AddFlags(f, "yaml", map[string]cmd.Formatter{
 		"yaml": cmd.FormatYaml,
 		"json": cmd.FormatJson,
@@ -58,9 +57,6 @@
 }
 
 func (c *StatusCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	c.patterns = args
 	return nil
 }

=== modified file 'cmd/juju/status_test.go'
--- cmd/juju/status_test.go	2014-05-01 17:56:04 +0000
+++ cmd/juju/status_test.go	2014-05-12 11:08:32 +0000
@@ -17,6 +17,7 @@
 
 	"launchpad.net/juju-core/charm"
 	"launchpad.net/juju-core/cmd"
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/constraints"
 	"launchpad.net/juju-core/environs/network"
 	"launchpad.net/juju-core/instance"
@@ -31,7 +32,7 @@
 
 func runStatus(c *gc.C, args ...string) (code int, stdout, stderr []byte) {
 	ctx := coretesting.Context(c)
-	code = cmd.Main(&StatusCommand{}, ctx, args)
+	code = cmd.Main(envcmd.Wrap(&StatusCommand{}), ctx, args)
 	stdout = ctx.Stdout.(*bytes.Buffer).Bytes()
 	stderr = ctx.Stderr.(*bytes.Buffer).Bytes()
 	return

=== modified file 'cmd/juju/synctools.go'
--- cmd/juju/synctools.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/synctools.go	2014-05-12 11:08:32 +0000
@@ -52,7 +52,6 @@
 }
 
 func (c *SyncToolsCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	f.BoolVar(&c.allVersions, "all", false, "copy all versions, not just the latest")
 	f.StringVar(&c.versionStr, "version", "", "copy a specific major[.minor] version")
 	f.BoolVar(&c.dryRun, "dry-run", false, "don't copy, just print what would be copied")
@@ -64,9 +63,6 @@
 }
 
 func (c *SyncToolsCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	if c.destination != "" {
 		// Override localDir with destination as localDir now replaces destination
 		c.localDir = c.destination

=== modified file 'cmd/juju/synctools_test.go'
--- cmd/juju/synctools_test.go	2014-03-24 10:42:51 +0000
+++ cmd/juju/synctools_test.go	2014-05-12 11:08:32 +0000
@@ -12,6 +12,7 @@
 	gc "launchpad.net/gocheck"
 
 	"launchpad.net/juju-core/cmd"
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/environs"
 	"launchpad.net/juju-core/environs/configstore"
 	"launchpad.net/juju-core/environs/sync"
@@ -61,7 +62,7 @@
 }
 
 func runSyncToolsCommand(c *gc.C, args ...string) (*cmd.Context, error) {
-	return coretesting.RunCommand(c, &SyncToolsCommand{}, args)
+	return coretesting.RunCommand(c, envcmd.Wrap(&SyncToolsCommand{}), args)
 }
 
 func wait(signal chan struct{}) error {

=== modified file 'cmd/juju/unexpose.go'
--- cmd/juju/unexpose.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/unexpose.go	2014-05-12 11:08:32 +0000
@@ -26,9 +26,6 @@
 }
 
 func (c *UnexposeCommand) Init(args []string) error {
-	if err := c.EnsureEnvName(); err != nil {
-		return err
-	}
 	if len(args) == 0 {
 		return errors.New("no service name specified")
 	}

=== modified file 'cmd/juju/unexpose_test.go'
--- cmd/juju/unexpose_test.go	2013-09-13 14:48:13 +0000
+++ cmd/juju/unexpose_test.go	2014-05-12 11:08:32 +0000
@@ -7,6 +7,7 @@
 	gc "launchpad.net/gocheck"
 
 	"launchpad.net/juju-core/charm"
+	"launchpad.net/juju-core/cmd/envcmd"
 	jujutesting "launchpad.net/juju-core/juju/testing"
 	"launchpad.net/juju-core/testing"
 )
@@ -18,7 +19,7 @@
 var _ = gc.Suite(&UnexposeSuite{})
 
 func runUnexpose(c *gc.C, args ...string) error {
-	_, err := testing.RunCommand(c, &UnexposeCommand{}, args)
+	_, err := testing.RunCommand(c, envcmd.Wrap(&UnexposeCommand{}), args)
 	return err
 }
 

=== modified file 'cmd/juju/unset.go'
--- cmd/juju/unset.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/unset.go	2014-05-12 11:08:32 +0000
@@ -6,8 +6,6 @@
 import (
 	"errors"
 
-	"launchpad.net/gnuflag"
-
 	"launchpad.net/juju-core/cmd"
 	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/juju"
@@ -36,14 +34,7 @@
 	}
 }
 
-func (c *UnsetCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
-}
-
 func (c *UnsetCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	if len(args) == 0 {
 		return errors.New("no service name specified")
 	}

=== modified file 'cmd/juju/unset_test.go'
--- cmd/juju/unset_test.go	2013-11-28 15:53:00 +0000
+++ cmd/juju/unset_test.go	2014-05-12 11:08:32 +0000
@@ -10,6 +10,7 @@
 
 	"launchpad.net/juju-core/charm"
 	"launchpad.net/juju-core/cmd"
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/juju/testing"
 	"launchpad.net/juju-core/state"
 	coretesting "launchpad.net/juju-core/testing"
@@ -77,7 +78,7 @@
 // assertUnsetSuccess unsets configuration options and checks the expected settings.
 func assertUnsetSuccess(c *gc.C, dir string, svc *state.Service, args []string, expect charm.Settings) {
 	ctx := coretesting.ContextForDir(c, dir)
-	code := cmd.Main(&UnsetCommand{}, ctx, append([]string{"dummy-service"}, args...))
+	code := cmd.Main(envcmd.Wrap(&UnsetCommand{}), ctx, append([]string{"dummy-service"}, args...))
 	c.Check(code, gc.Equals, 0)
 	settings, err := svc.ConfigSettings()
 	c.Assert(err, gc.IsNil)
@@ -87,7 +88,7 @@
 // assertUnsetFail unsets configuration options and checks the expected error.
 func assertUnsetFail(c *gc.C, dir string, args []string, err string) {
 	ctx := coretesting.ContextForDir(c, dir)
-	code := cmd.Main(&UnsetCommand{}, ctx, append([]string{"dummy-service"}, args...))
+	code := cmd.Main(envcmd.Wrap(&UnsetCommand{}), ctx, append([]string{"dummy-service"}, args...))
 	c.Check(code, gc.Not(gc.Equals), 0)
 	c.Assert(ctx.Stderr.(*bytes.Buffer).String(), gc.Matches, err)
 }

=== modified file 'cmd/juju/upgradecharm.go'
--- cmd/juju/upgradecharm.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/upgradecharm.go	2014-05-12 11:08:32 +0000
@@ -76,7 +76,6 @@
 }
 
 func (c *UpgradeCharmCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	f.BoolVar(&c.Force, "force", false, "upgrade all units immediately, even if in error state")
 	f.StringVar(&c.RepoPath, "repository", os.Getenv("JUJU_REPOSITORY"), "local charm repository path")
 	f.StringVar(&c.SwitchURL, "switch", "", "crossgrade to a different charm")
@@ -84,9 +83,6 @@
 }
 
 func (c *UpgradeCharmCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	switch len(args) {
 	case 1:
 		if !names.IsService(args[0]) {

=== modified file 'cmd/juju/upgradecharm_test.go'
--- cmd/juju/upgradecharm_test.go	2014-03-18 05:08:25 +0000
+++ cmd/juju/upgradecharm_test.go	2014-05-12 11:08:32 +0000
@@ -13,6 +13,7 @@
 
 	"launchpad.net/juju-core/charm"
 	charmtesting "launchpad.net/juju-core/charm/testing"
+	"launchpad.net/juju-core/cmd/envcmd"
 	jujutesting "launchpad.net/juju-core/juju/testing"
 	"launchpad.net/juju-core/state"
 	"launchpad.net/juju-core/testing"
@@ -34,7 +35,7 @@
 var _ = gc.Suite(&UpgradeCharmErrorsSuite{})
 
 func runUpgradeCharm(c *gc.C, args ...string) error {
-	_, err := testing.RunCommand(c, &UpgradeCharmCommand{}, args)
+	_, err := testing.RunCommand(c, envcmd.Wrap(&UpgradeCharmCommand{}), args)
 	return err
 }
 

=== modified file 'cmd/juju/upgradejuju.go'
--- cmd/juju/upgradejuju.go	2014-05-09 13:24:50 +0000
+++ cmd/juju/upgradejuju.go	2014-05-12 11:08:32 +0000
@@ -76,16 +76,12 @@
 }
 
 func (c *UpgradeJujuCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	f.StringVar(&c.vers, "version", "", "upgrade to specific version")
 	f.BoolVar(&c.UploadTools, "upload-tools", false, "upload local version of tools")
 	f.Var(newSeriesValue(nil, &c.Series), "series", "upload tools for supplied comma-separated series list")
 }
 
 func (c *UpgradeJujuCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	if c.vers != "" {
 		vers, err := version.Parse(c.vers)
 		if err != nil {

=== modified file 'cmd/juju/upgradejuju_test.go'
--- cmd/juju/upgradejuju_test.go	2014-04-09 16:36:12 +0000
+++ cmd/juju/upgradejuju_test.go	2014-05-12 11:08:32 +0000
@@ -14,6 +14,7 @@
 	jc "github.com/juju/testing/checkers"
 	gc "launchpad.net/gocheck"
 
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/environs/config"
 	"launchpad.net/juju-core/environs/filestorage"
 	"launchpad.net/juju-core/environs/storage"
@@ -313,7 +314,7 @@
 		// Set up apparent CLI version and initialize the command.
 		version.Current = version.MustParseBinary(test.currentVersion)
 		com := &UpgradeJujuCommand{}
-		if err := coretesting.InitCommand(com, test.args); err != nil {
+		if err := coretesting.InitCommand(envcmd.Wrap(com), test.args); err != nil {
 			if test.expectInitErr != "" {
 				c.Check(err, gc.ErrorMatches, test.expectInitErr)
 			} else {

=== modified file 'cmd/plugins/juju-metadata/imagemetadata.go'
--- cmd/plugins/juju-metadata/imagemetadata.go	2014-05-09 13:24:50 +0000
+++ cmd/plugins/juju-metadata/imagemetadata.go	2014-05-12 11:08:32 +0000
@@ -53,7 +53,6 @@
 }
 
 func (c *ImageMetadataCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	f.StringVar(&c.Series, "s", "", "the charm series")
 	f.StringVar(&c.Arch, "a", arch.AMD64, "the image achitecture")
 	f.StringVar(&c.Dir, "d", "", "the destination directory in which to place the metadata files")
@@ -62,13 +61,6 @@
 	f.StringVar(&c.Endpoint, "u", "", "the cloud endpoint (for Openstack, this is the Identity Service endpoint)")
 }
 
-func (c *ImageMetadataCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
-	return cmd.CheckEmpty(args)
-}
-
 // setParams sets parameters based on the environment configuration
 // for those which have not been explicitly specified.
 func (c *ImageMetadataCommand) setParams(context *cmd.Context) error {

=== modified file 'cmd/plugins/juju-metadata/imagemetadata_test.go'
--- cmd/plugins/juju-metadata/imagemetadata_test.go	2014-05-09 21:54:06 +0000
+++ cmd/plugins/juju-metadata/imagemetadata_test.go	2014-05-12 11:08:32 +0000
@@ -15,6 +15,7 @@
 	gc "launchpad.net/gocheck"
 
 	"launchpad.net/juju-core/cmd"
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/environs/config"
 	"launchpad.net/juju-core/provider/dummy"
 	"launchpad.net/juju-core/testing"
@@ -116,7 +117,7 @@
 func (s *ImageMetadataSuite) TestImageMetadataFilesNoEnv(c *gc.C) {
 	ctx := testing.Context(c)
 	code := cmd.Main(
-		&ImageMetadataCommand{}, ctx, []string{
+		envcmd.Wrap(&ImageMetadataCommand{}), ctx, []string{
 			"-d", s.dir, "-i", "1234", "-r", "region", "-a", "arch", "-u", "endpoint", "-s", "raring"})
 	c.Assert(code, gc.Equals, 0)
 	out := testing.Stdout(ctx)
@@ -130,7 +131,7 @@
 func (s *ImageMetadataSuite) TestImageMetadataFilesDefaultArch(c *gc.C) {
 	ctx := testing.Context(c)
 	code := cmd.Main(
-		&ImageMetadataCommand{}, ctx, []string{
+		envcmd.Wrap(&ImageMetadataCommand{}), ctx, []string{
 			"-d", s.dir, "-i", "1234", "-r", "region", "-u", "endpoint", "-s", "raring"})
 	c.Assert(code, gc.Equals, 0)
 	out := testing.Stdout(ctx)
@@ -144,7 +145,7 @@
 func (s *ImageMetadataSuite) TestImageMetadataFilesLatestLts(c *gc.C) {
 	ctx := testing.Context(c)
 	code := cmd.Main(
-		&ImageMetadataCommand{}, ctx, []string{
+		envcmd.Wrap(&ImageMetadataCommand{}), ctx, []string{
 			"-d", s.dir, "-i", "1234", "-r", "region", "-a", "arch", "-u", "endpoint"})
 	c.Assert(code, gc.Equals, 0)
 	out := testing.Stdout(ctx)
@@ -158,7 +159,7 @@
 func (s *ImageMetadataSuite) TestImageMetadataFilesUsingEnv(c *gc.C) {
 	ctx := testing.Context(c)
 	code := cmd.Main(
-		&ImageMetadataCommand{}, ctx, []string{"-d", s.dir, "-e", "ec2", "-i", "1234"})
+		envcmd.Wrap(&ImageMetadataCommand{}), ctx, []string{"-d", s.dir, "-e", "ec2", "-i", "1234"})
 	c.Assert(code, gc.Equals, 0)
 	out := testing.Stdout(ctx)
 	expected := expectedMetadata{
@@ -173,7 +174,7 @@
 func (s *ImageMetadataSuite) TestImageMetadataFilesUsingEnvWithRegionOverride(c *gc.C) {
 	ctx := testing.Context(c)
 	code := cmd.Main(
-		&ImageMetadataCommand{}, ctx, []string{
+		envcmd.Wrap(&ImageMetadataCommand{}), ctx, []string{
 			"-d", s.dir, "-e", "ec2", "-r", "us-west-1", "-u", "https://ec2.us-west-1.amazonaws.com", "-i", "1234"})
 	c.Assert(code, gc.Equals, 0)
 	out := testing.Stdout(ctx)
@@ -189,7 +190,7 @@
 func (s *ImageMetadataSuite) TestImageMetadataFilesUsingEnvWithNoHasRegion(c *gc.C) {
 	ctx := testing.Context(c)
 	code := cmd.Main(
-		&ImageMetadataCommand{}, ctx, []string{
+		envcmd.Wrap(&ImageMetadataCommand{}), ctx, []string{
 			"-d", s.dir, "-e", "azure", "-r", "region", "-u", "endpoint", "-i", "1234"})
 	c.Assert(code, gc.Equals, 0)
 	out := testing.Stdout(ctx)
@@ -234,7 +235,7 @@
 	for i, t := range errTests {
 		c.Logf("test: %d", i)
 		ctx := testing.Context(c)
-		code := cmd.Main(&ImageMetadataCommand{}, ctx, t.args)
+		code := cmd.Main(envcmd.Wrap(&ImageMetadataCommand{}), ctx, t.args)
 		c.Check(code, gc.Equals, 1)
 	}
 }

=== modified file 'cmd/plugins/juju-metadata/metadata.go'
--- cmd/plugins/juju-metadata/metadata.go	2014-03-21 14:28:36 +0000
+++ cmd/plugins/juju-metadata/metadata.go	2014-05-12 11:08:32 +0000
@@ -10,6 +10,7 @@
 	"github.com/juju/loggo"
 
 	"launchpad.net/juju-core/cmd"
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/juju"
 	_ "launchpad.net/juju-core/provider/all"
 )
@@ -41,10 +42,10 @@
 		Purpose:     "tools for generating and validating image and tools metadata",
 		Log:         &cmd.Log{}})
 
-	metadatacmd.Register(&ValidateImageMetadataCommand{})
-	metadatacmd.Register(&ImageMetadataCommand{})
-	metadatacmd.Register(&ToolsMetadataCommand{})
-	metadatacmd.Register(&ValidateToolsMetadataCommand{})
+	metadatacmd.Register(envcmd.Wrap(&ValidateImageMetadataCommand{}))
+	metadatacmd.Register(envcmd.Wrap(&ImageMetadataCommand{}))
+	metadatacmd.Register(envcmd.Wrap(&ToolsMetadataCommand{}))
+	metadatacmd.Register(envcmd.Wrap(&ValidateToolsMetadataCommand{}))
 	metadatacmd.Register(&SignMetadataCommand{})
 
 	os.Exit(cmd.Main(metadatacmd, ctx, args[1:]))

=== modified file 'cmd/plugins/juju-metadata/toolsmetadata.go'
--- cmd/plugins/juju-metadata/toolsmetadata.go	2014-05-09 13:24:50 +0000
+++ cmd/plugins/juju-metadata/toolsmetadata.go	2014-05-12 11:08:32 +0000
@@ -37,18 +37,10 @@
 }
 
 func (c *ToolsMetadataCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	f.StringVar(&c.metadataDir, "d", "", "local directory in which to store metadata")
 	f.BoolVar(&c.public, "public", false, "tools are for a public cloud, so generate mirrors information")
 }
 
-func (c *ToolsMetadataCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
-	return cmd.CheckEmpty(args)
-}
-
 func (c *ToolsMetadataCommand) Run(context *cmd.Context) error {
 	loggo.RegisterWriter("toolsmetadata", cmd.NewCommandLogWriter("juju.environs.tools", context.Stdout, context.Stderr), loggo.INFO)
 	defer loggo.RemoveWriter("toolsmetadata")

=== modified file 'cmd/plugins/juju-metadata/toolsmetadata_test.go'
--- cmd/plugins/juju-metadata/toolsmetadata_test.go	2014-04-09 16:36:12 +0000
+++ cmd/plugins/juju-metadata/toolsmetadata_test.go	2014-05-12 11:08:32 +0000
@@ -14,6 +14,7 @@
 	gc "launchpad.net/gocheck"
 
 	"launchpad.net/juju-core/cmd"
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/environs"
 	"launchpad.net/juju-core/environs/configstore"
 	envtesting "launchpad.net/juju-core/environs/testing"
@@ -100,7 +101,7 @@
 	metadataDir := osenv.JujuHome() // default metadata dir
 	ttesting.MakeTools(c, metadataDir, "releases", versionStrings)
 	ctx := coretesting.Context(c)
-	code := cmd.Main(&ToolsMetadataCommand{}, ctx, nil)
+	code := cmd.Main(envcmd.Wrap(&ToolsMetadataCommand{}), ctx, nil)
 	c.Assert(code, gc.Equals, 0)
 	output := ctx.Stdout.(*bytes.Buffer).String()
 	c.Assert(output, gc.Matches, expectedOutputDirectory)
@@ -118,7 +119,7 @@
 	metadataDir := c.MkDir()
 	ttesting.MakeTools(c, metadataDir, "releases", versionStrings)
 	ctx := coretesting.Context(c)
-	code := cmd.Main(&ToolsMetadataCommand{}, ctx, []string{"-d", metadataDir})
+	code := cmd.Main(envcmd.Wrap(&ToolsMetadataCommand{}), ctx, []string{"-d", metadataDir})
 	c.Assert(code, gc.Equals, 0)
 	output := ctx.Stdout.(*bytes.Buffer).String()
 	c.Assert(output, gc.Matches, expectedOutputDirectory)
@@ -139,7 +140,7 @@
 	// Run the command with no local metadata.
 	ctx := coretesting.Context(c)
 	metadataDir := c.MkDir()
-	code := cmd.Main(&ToolsMetadataCommand{}, ctx, []string{"-d", metadataDir})
+	code := cmd.Main(envcmd.Wrap(&ToolsMetadataCommand{}), ctx, []string{"-d", metadataDir})
 	c.Assert(code, gc.Equals, 0)
 	metadata := ttesting.ParseMetadataFromDir(c, metadataDir, false)
 	c.Assert(metadata, gc.HasLen, len(versionStrings))
@@ -155,7 +156,7 @@
 	metadataDir := c.MkDir()
 	ttesting.MakeTools(c, metadataDir, "releases", versionStrings)
 	ctx := coretesting.Context(c)
-	code := cmd.Main(&ToolsMetadataCommand{}, ctx, []string{"--public", "-d", metadataDir})
+	code := cmd.Main(envcmd.Wrap(&ToolsMetadataCommand{}), ctx, []string{"--public", "-d", metadataDir})
 	c.Assert(code, gc.Equals, 0)
 	output := ctx.Stdout.(*bytes.Buffer).String()
 	c.Assert(output, gc.Matches, expectedOutputMirrors)
@@ -171,7 +172,7 @@
 
 func (s *ToolsMetadataSuite) TestNoTools(c *gc.C) {
 	ctx := coretesting.Context(c)
-	code := cmd.Main(&ToolsMetadataCommand{}, ctx, nil)
+	code := cmd.Main(envcmd.Wrap(&ToolsMetadataCommand{}), ctx, nil)
 	c.Assert(code, gc.Equals, 1)
 	stdout := ctx.Stdout.(*bytes.Buffer).String()
 	c.Assert(stdout, gc.Matches, "Finding tools in .*\n")
@@ -189,7 +190,7 @@
 	metadataDir := osenv.JujuHome() // default metadata dir
 	ttesting.MakeTools(c, metadataDir, "releases", versionStrings)
 	ctx := coretesting.Context(c)
-	code := cmd.Main(&ToolsMetadataCommand{}, ctx, nil)
+	code := cmd.Main(envcmd.Wrap(&ToolsMetadataCommand{}), ctx, nil)
 	c.Assert(code, gc.Equals, 0)
 	output := ctx.Stdout.(*bytes.Buffer).String()
 	expectedOutput := fmt.Sprintf(`

=== modified file 'cmd/plugins/juju-metadata/validateimagemetadata.go'
--- cmd/plugins/juju-metadata/validateimagemetadata.go	2014-05-09 13:24:50 +0000
+++ cmd/plugins/juju-metadata/validateimagemetadata.go	2014-05-12 11:08:32 +0000
@@ -81,7 +81,6 @@
 }
 
 func (c *ValidateImageMetadataCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	c.out.AddFlags(f, "smart", cmd.DefaultFormatters)
 	f.StringVar(&c.providerType, "p", "", "the provider type eg ec2, openstack")
 	f.StringVar(&c.metadataDir, "d", "", "directory where metadata files are found")
@@ -92,9 +91,6 @@
 }
 
 func (c *ValidateImageMetadataCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	if c.providerType != "" {
 		if c.series == "" {
 			return fmt.Errorf("series required if provider type is specified")

=== modified file 'cmd/plugins/juju-metadata/validateimagemetadata_test.go'
--- cmd/plugins/juju-metadata/validateimagemetadata_test.go	2014-05-08 09:27:50 +0000
+++ cmd/plugins/juju-metadata/validateimagemetadata_test.go	2014-05-12 11:08:32 +0000
@@ -11,6 +11,7 @@
 	gc "launchpad.net/gocheck"
 
 	"launchpad.net/juju-core/cmd"
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/environs/filestorage"
 	"launchpad.net/juju-core/environs/imagemetadata"
 	"launchpad.net/juju-core/environs/simplestreams"
@@ -27,7 +28,7 @@
 var _ = gc.Suite(&ValidateImageMetadataSuite{})
 
 func runValidateImageMetadata(c *gc.C, args ...string) error {
-	_, err := coretesting.RunCommand(c, &ValidateImageMetadataCommand{}, args)
+	_, err := coretesting.RunCommand(c, envcmd.Wrap(&ValidateImageMetadataCommand{}), args)
 	return err
 }
 
@@ -50,7 +51,7 @@
 func (s *ValidateImageMetadataSuite) TestInitErrors(c *gc.C) {
 	for i, t := range validateInitImageErrorTests {
 		c.Logf("test %d", i)
-		err := coretesting.InitCommand(&ValidateImageMetadataCommand{}, t.args)
+		err := coretesting.InitCommand(envcmd.Wrap(&ValidateImageMetadataCommand{}), t.args)
 		c.Check(err, gc.ErrorMatches, t.err)
 	}
 }
@@ -130,7 +131,7 @@
 	s.setupEc2LocalMetadata(c, "us-east-1", stream)
 	ctx := coretesting.Context(c)
 	code := cmd.Main(
-		&ValidateImageMetadataCommand{}, ctx, []string{"-e", "ec2", "-d", s.metadataDir, "-m", stream},
+		envcmd.Wrap(&ValidateImageMetadataCommand{}), ctx, []string{"-e", "ec2", "-d", s.metadataDir, "-m", stream},
 	)
 	c.Assert(code, gc.Equals, 0)
 	errOut := ctx.Stdout.(*bytes.Buffer).String()
@@ -154,7 +155,7 @@
 	s.setupEc2LocalMetadata(c, "us-east-1", "")
 	ctx := coretesting.Context(c)
 	code := cmd.Main(
-		&ValidateImageMetadataCommand{}, ctx, []string{"-e", "ec2", "-d", s.metadataDir},
+		envcmd.Wrap(&ValidateImageMetadataCommand{}), ctx, []string{"-e", "ec2", "-d", s.metadataDir},
 	)
 	c.Assert(code, gc.Equals, 1)
 	errOut := ctx.Stderr.(*bytes.Buffer).String()
@@ -166,7 +167,7 @@
 	s.setupEc2LocalMetadata(c, "us-west-1", "")
 	ctx := coretesting.Context(c)
 	code := cmd.Main(
-		&ValidateImageMetadataCommand{}, ctx, []string{
+		envcmd.Wrap(&ValidateImageMetadataCommand{}), ctx, []string{
 			"-p", "ec2", "-s", "precise", "-r", "us-west-1",
 			"-u", "https://ec2.us-west-1.amazonaws.com", "-d", s.metadataDir},
 	)
@@ -182,13 +183,13 @@
 	s.setupEc2LocalMetadata(c, "us-east-1", "")
 	ctx := coretesting.Context(c)
 	code := cmd.Main(
-		&ValidateImageMetadataCommand{}, ctx, []string{
+		envcmd.Wrap(&ValidateImageMetadataCommand{}), ctx, []string{
 			"-p", "ec2", "-s", "raring", "-r", "us-west-1",
 			"-u", "https://ec2.us-west-1.amazonaws.com", "-d", s.metadataDir},
 	)
 	c.Assert(code, gc.Equals, 1)
 	code = cmd.Main(
-		&ValidateImageMetadataCommand{}, ctx, []string{
+		envcmd.Wrap(&ValidateImageMetadataCommand{}), ctx, []string{
 			"-p", "ec2", "-s", "precise", "-r", "region",
 			"-u", "https://ec2.region.amazonaws.com", "-d", s.metadataDir},
 	)
@@ -202,7 +203,7 @@
 	s.makeLocalMetadata(c, "1234", "region-2", "raring", "some-auth-url", "")
 	ctx := coretesting.Context(c)
 	code := cmd.Main(
-		&ValidateImageMetadataCommand{}, ctx, []string{
+		envcmd.Wrap(&ValidateImageMetadataCommand{}), ctx, []string{
 			"-p", "openstack", "-s", "raring", "-r", "region-2",
 			"-u", "some-auth-url", "-d", s.metadataDir},
 	)
@@ -218,7 +219,7 @@
 	s.makeLocalMetadata(c, "1234", "region-2", "raring", "some-auth-url", "")
 	ctx := coretesting.Context(c)
 	code := cmd.Main(
-		&ValidateImageMetadataCommand{}, ctx, []string{
+		envcmd.Wrap(&ValidateImageMetadataCommand{}), ctx, []string{
 			"-p", "openstack", "-s", "precise", "-r", "region-2",
 			"-u", "some-auth-url", "-d", s.metadataDir},
 	)
@@ -227,7 +228,7 @@
 	strippedOut := strings.Replace(errOut, "\n", "", -1)
 	c.Check(strippedOut, gc.Matches, `.*Resolve Metadata:.*`)
 	code = cmd.Main(
-		&ValidateImageMetadataCommand{}, ctx, []string{
+		envcmd.Wrap(&ValidateImageMetadataCommand{}), ctx, []string{
 			"-p", "openstack", "-s", "raring", "-r", "region-3",
 			"-u", "some-auth-url", "-d", s.metadataDir},
 	)

=== modified file 'cmd/plugins/juju-metadata/validatetoolsmetadata.go'
--- cmd/plugins/juju-metadata/validatetoolsmetadata.go	2014-05-09 13:24:50 +0000
+++ cmd/plugins/juju-metadata/validatetoolsmetadata.go	2014-05-12 11:08:32 +0000
@@ -103,7 +103,6 @@
 }
 
 func (c *ValidateToolsMetadataCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	c.out.AddFlags(f, "smart", cmd.DefaultFormatters)
 	f.StringVar(&c.providerType, "p", "", "the provider type eg ec2, openstack")
 	f.StringVar(&c.metadataDir, "d", "", "directory where metadata files are found")
@@ -118,9 +117,6 @@
 }
 
 func (c *ValidateToolsMetadataCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	if c.providerType != "" {
 		if c.region == "" {
 			return fmt.Errorf("region required if provider type is specified")

=== modified file 'cmd/plugins/juju-metadata/validatetoolsmetadata_test.go'
--- cmd/plugins/juju-metadata/validatetoolsmetadata_test.go	2014-03-18 15:43:41 +0000
+++ cmd/plugins/juju-metadata/validatetoolsmetadata_test.go	2014-05-12 11:08:32 +0000
@@ -11,6 +11,7 @@
 	gc "launchpad.net/gocheck"
 
 	"launchpad.net/juju-core/cmd"
+	"launchpad.net/juju-core/cmd/envcmd"
 	"launchpad.net/juju-core/environs/filestorage"
 	"launchpad.net/juju-core/environs/tools"
 	coretesting "launchpad.net/juju-core/testing"
@@ -27,7 +28,7 @@
 var _ = gc.Suite(&ValidateToolsMetadataSuite{})
 
 func runValidateToolsMetadata(c *gc.C, args ...string) error {
-	_, err := coretesting.RunCommand(c, &ValidateToolsMetadataCommand{}, args)
+	_, err := coretesting.RunCommand(c, envcmd.Wrap(&ValidateToolsMetadataCommand{}), args)
 	return err
 }
 
@@ -56,7 +57,7 @@
 func (s *ValidateToolsMetadataSuite) TestInitErrors(c *gc.C) {
 	for i, t := range validateInitToolsErrorTests {
 		c.Logf("test %d", i)
-		err := coretesting.InitCommand(&ValidateToolsMetadataCommand{}, t.args)
+		err := coretesting.InitCommand(envcmd.Wrap(&ValidateToolsMetadataCommand{}), t.args)
 		c.Check(err, gc.ErrorMatches, t.err)
 	}
 }
@@ -112,7 +113,7 @@
 	s.setupEc2LocalMetadata(c, "us-east-1")
 	ctx := coretesting.Context(c)
 	code := cmd.Main(
-		&ValidateToolsMetadataCommand{}, ctx, []string{"-e", "ec2", "-j", "1.11.4", "-d", s.metadataDir},
+		envcmd.Wrap(&ValidateToolsMetadataCommand{}), ctx, []string{"-e", "ec2", "-j", "1.11.4", "-d", s.metadataDir},
 	)
 	c.Assert(code, gc.Equals, 0)
 	errOut := ctx.Stdout.(*bytes.Buffer).String()
@@ -126,7 +127,7 @@
 	s.setupEc2LocalMetadata(c, "us-east-1")
 	ctx := coretesting.Context(c)
 	code := cmd.Main(
-		&ValidateToolsMetadataCommand{}, ctx, []string{"-e", "ec2", "-j", "1.11.4"},
+		envcmd.Wrap(&ValidateToolsMetadataCommand{}), ctx, []string{"-e", "ec2", "-j", "1.11.4"},
 	)
 	c.Assert(code, gc.Equals, 1)
 	errOut := ctx.Stderr.(*bytes.Buffer).String()
@@ -138,7 +139,7 @@
 	s.setupEc2LocalMetadata(c, "us-west-1")
 	ctx := coretesting.Context(c)
 	code := cmd.Main(
-		&ValidateToolsMetadataCommand{}, ctx, []string{
+		envcmd.Wrap(&ValidateToolsMetadataCommand{}), ctx, []string{
 			"-p", "ec2", "-s", "precise", "-r", "us-west-1", "-j", "1.11.4",
 			"-u", "https://ec2.us-west-1.amazonaws.com", "-d", s.metadataDir},
 	)
@@ -152,13 +153,13 @@
 	s.setupEc2LocalMetadata(c, "us-east-1")
 	ctx := coretesting.Context(c)
 	code := cmd.Main(
-		&ValidateToolsMetadataCommand{}, ctx, []string{
+		envcmd.Wrap(&ValidateToolsMetadataCommand{}), ctx, []string{
 			"-p", "ec2", "-s", "raring", "-r", "us-west-1",
 			"-u", "https://ec2.us-west-1.amazonaws.com", "-d", s.metadataDir},
 	)
 	c.Assert(code, gc.Equals, 1)
 	code = cmd.Main(
-		&ValidateToolsMetadataCommand{}, ctx, []string{
+		envcmd.Wrap(&ValidateToolsMetadataCommand{}), ctx, []string{
 			"-p", "ec2", "-s", "precise", "-r", "region",
 			"-u", "https://ec2.region.amazonaws.com", "-d", s.metadataDir},
 	)
@@ -172,7 +173,7 @@
 	s.makeLocalMetadata(c, "1.11.4", "region-2", "raring", "some-auth-url")
 	ctx := coretesting.Context(c)
 	code := cmd.Main(
-		&ValidateToolsMetadataCommand{}, ctx, []string{
+		envcmd.Wrap(&ValidateToolsMetadataCommand{}), ctx, []string{
 			"-p", "openstack", "-s", "raring", "-r", "region-2", "-j", "1.11.4",
 			"-u", "some-auth-url", "-d", s.metadataDir},
 	)
@@ -186,13 +187,13 @@
 	s.makeLocalMetadata(c, "1.11.4", "region-2", "raring", "some-auth-url")
 	ctx := coretesting.Context(c)
 	code := cmd.Main(
-		&ValidateToolsMetadataCommand{}, ctx, []string{
+		envcmd.Wrap(&ValidateToolsMetadataCommand{}), ctx, []string{
 			"-p", "openstack", "-s", "precise", "-r", "region-2",
 			"-u", "some-auth-url", "-d", s.metadataDir},
 	)
 	c.Assert(code, gc.Equals, 1)
 	code = cmd.Main(
-		&ValidateToolsMetadataCommand{}, ctx, []string{
+		envcmd.Wrap(&ValidateToolsMetadataCommand{}), ctx, []string{
 			"-p", "openstack", "-s", "raring", "-r", "region-3",
 			"-u", "some-auth-url", "-d", s.metadataDir},
 	)
@@ -206,7 +207,7 @@
 	s.makeLocalMetadata(c, version.Current.Number.String(), "region-2", "raring", "some-auth-url")
 	ctx := coretesting.Context(c)
 	code := cmd.Main(
-		&ValidateToolsMetadataCommand{}, ctx, []string{
+		envcmd.Wrap(&ValidateToolsMetadataCommand{}), ctx, []string{
 			"-p", "openstack", "-s", "raring", "-r", "region-2",
 			"-u", "some-auth-url", "-d", s.metadataDir},
 	)
@@ -220,7 +221,7 @@
 	s.makeLocalMetadata(c, "1.11.4", "region-2", "raring", "some-auth-url")
 	ctx := coretesting.Context(c)
 	code := cmd.Main(
-		&ValidateToolsMetadataCommand{}, ctx, []string{
+		envcmd.Wrap(&ValidateToolsMetadataCommand{}), ctx, []string{
 			"-p", "openstack", "-s", "raring", "-r", "region-2",
 			"-u", "some-auth-url", "-d", s.metadataDir, "-m", "1"},
 	)
@@ -234,7 +235,7 @@
 	s.makeLocalMetadata(c, "1.12.1", "region-2", "raring", "some-auth-url")
 	ctx := coretesting.Context(c)
 	code := cmd.Main(
-		&ValidateToolsMetadataCommand{}, ctx, []string{
+		envcmd.Wrap(&ValidateToolsMetadataCommand{}), ctx, []string{
 			"-p", "openstack", "-s", "raring", "-r", "region-2",
 			"-u", "some-auth-url", "-d", s.metadataDir, "-m", "1.12"},
 	)
@@ -248,7 +249,7 @@
 	s.makeLocalMetadata(c, version.Current.Number.String(), "region-2", "raring", "some-auth-url")
 	ctx := coretesting.Context(c)
 	code := cmd.Main(
-		&ValidateToolsMetadataCommand{}, ctx, []string{"-s", "raring", "-d", s.metadataDir},
+		envcmd.Wrap(&ValidateToolsMetadataCommand{}), ctx, []string{"-s", "raring", "-d", s.metadataDir},
 	)
 	c.Assert(code, gc.Equals, 0)
 	errOut := ctx.Stdout.(*bytes.Buffer).String()

=== modified file 'cmd/plugins/juju-restore/restore.go'
--- cmd/plugins/juju-restore/restore.go	2014-05-09 13:24:50 +0000
+++ cmd/plugins/juju-restore/restore.go	2014-05-12 11:08:32 +0000
@@ -48,7 +48,7 @@
 		fmt.Fprintf(os.Stderr, "error: %s\n", err)
 		os.Exit(2)
 	}
-	os.Exit(cmd.Main(&restoreCommand{}, ctx, args[1:]))
+	os.Exit(cmd.Main(envcmd.Wrap(&restoreCommand{}), ctx, args[1:]))
 }
 
 var logger = loggo.GetLogger("juju.plugins.restore")
@@ -82,16 +82,12 @@
 }
 
 func (c *restoreCommand) SetFlags(f *gnuflag.FlagSet) {
-	c.EnvCommandBase.SetFlags(f)
 	f.Var(constraints.ConstraintsValue{Target: &c.Constraints}, "constraints", "set environment constraints")
 	f.BoolVar(&c.showDescription, "description", false, "show the purpose of this plugin")
 	c.Log.AddFlags(f)
 }
 
 func (c *restoreCommand) Init(args []string) error {
-	if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
-		return err
-	}
 	if c.showDescription {
 		return cmd.CheckEmpty(args)
 	}