func (c *SwitchCommand) Run(ctx *cmd.Context) error {
// Switch is an alternative way of dealing with environments than using
// the JUJU_ENV environment setting, and as such, doesn't play too well.
// If JUJU_ENV is set we should report that as the current environment,
// and not allow switching when it is set.
jujuEnv := os.Getenv("JUJU_ENV")
if jujuEnv != "" {
if c.EnvName == "" {
fmt.Fprintf(ctx.Stdout, "Current environment: %q (from JUJU_ENV)\n", jujuEnv)
return nil
} else {
return fmt.Errorf("Cannot switch when JUJU_ENV is overriding the environment (set to %q)", jujuEnv)
}
}
// Passing through the empty string reads the default environments.yaml file.
environments, err := environs.ReadEnvirons("")
if err != nil {
return errors.New("couldn't read the environment.")
}
names := environments.Names()
sort.Strings(names)
currentEnv := readCurrentEnvironment()
if currentEnv == "" {
currentEnv = environments.Default
}
// In order to have only a set environment name quoted, make a small function
env := func() string {
if currentEnv == "" {
return "<not specified>"
}
return fmt.Sprintf("%q", currentEnv)
}
if c.EnvName == "" || c.EnvName == currentEnv {
fmt.Fprintf(ctx.Stdout, "Current environment: %s\n", env())
} else {
// Check to make sure that the specified environment
if !validEnvironmentName(c.EnvName, names) {
return fmt.Errorf("%q is not a name of an existing defined environment", c.EnvName)
}
if err := writeCurrentEnvironment(c.EnvName); err != nil {
return err
}
fmt.Fprintf(ctx.Stdout, "Changed default environment from %s to %q\n", env(), c.EnvName)
}
if c.List {
fmt.Fprintf(ctx.Stdout, "\nEnvironments:\n")
for _, name := range names {
fmt.Fprintf(ctx.Stdout, "\t%s\n", name)
}
}
return nil
}
func (*BootstrapSuite) TestBootstrapCommand(c *C) {
defer makeFakeHome(c, "brokenenv").restore()
err := ioutil.WriteFile(homePath(".juju", "environments.yaml"), []byte(envConfig), 0666)
c.Assert(err, IsNil)
// normal bootstrap
opc, errc := runCommand(new(BootstrapCommand))
c.Check(<-errc, IsNil)
c.Check((<-opc).(dummy.OpBootstrap).Env, Equals, "peckham")
// Check that the CA certificate and key have been automatically generated
// for the environment.
_, err = os.Stat(homePath(".juju", "peckham-cert.pem"))
c.Assert(err, IsNil)
_, err = os.Stat(homePath(".juju", "peckham-private-key.pem"))
c.Assert(err, IsNil)
// bootstrap with tool uploading - checking that a file
// is uploaded should be sufficient, as the detailed semantics
// of UploadTools are tested in environs.
opc, errc = runCommand(new(BootstrapCommand), "--upload-tools")
c.Check(<-errc, IsNil)
c.Check((<-opc).(dummy.OpPutFile).Env, Equals, "peckham")
c.Check((<-opc).(dummy.OpBootstrap).Env, Equals, "peckham")
envs, err := environs.ReadEnvirons("")
c.Assert(err, IsNil)
env, err := envs.Open("peckham")
c.Assert(err, IsNil)
tools, err := environs.FindTools(env, version.Current, environs.CompatVersion)
c.Assert(err, IsNil)
resp, err := http.Get(tools.URL)
c.Assert(err, IsNil)
defer resp.Body.Close()
err = environs.UnpackTools(c.MkDir(), tools, resp.Body)
c.Assert(err, IsNil)
// bootstrap with broken environment
opc, errc = runCommand(new(BootstrapCommand), "-e", "brokenenv")
c.Check(<-errc, ErrorMatches, "dummy.Bootstrap is broken")
c.Check(<-opc, IsNil)
}
func (suite) TestDefaultConfigFile(c *C) {
defer makeFakeHome(c, "only").restore()
env := `
environments:
only:
type: dummy
state-server: false
authorized-keys: i-am-a-key
`
err := ioutil.WriteFile(homePath(".juju", "environments.yaml"), []byte(env), 0666)
c.Assert(err, IsNil)
es, err := environs.ReadEnvirons("")
c.Assert(err, IsNil)
e, err := es.Open("")
c.Assert(err, IsNil)
c.Assert(e.Name(), Equals, "only")
}
func (suite) TestNamedConfigFile(c *C) {
defer makeFakeHome(c, "only").restore()
env := `
environments:
only:
type: dummy
state-server: false
authorized-keys: i-am-a-key
`
path := filepath.Join(c.MkDir(), "a-file")
err := ioutil.WriteFile(path, []byte(env), 0666)
c.Assert(err, IsNil)
es, err := environs.ReadEnvirons(path)
c.Assert(err, IsNil)
e, err := es.Open("")
c.Assert(err, IsNil)
c.Assert(e.Name(), Equals, "only")
}
func (suite) TestNamedConfigFile(c *C) {
defer testing.MakeFakeHomeNoEnvironments(c, "only").Restore()
env := `
environments:
only:
type: dummy
state-server: false
authorized-keys: i-am-a-key
`
path := filepath.Join(c.MkDir(), "a-file")
outfile, err := environs.WriteEnvirons(path, env)
c.Assert(err, IsNil)
c.Assert(path, Equals, outfile)
es, err := environs.ReadEnvirons(path)
c.Assert(err, IsNil)
e, err := es.Open("")
c.Assert(err, IsNil)
c.Assert(e.Name(), Equals, "only")
}
func (suite) TestDefaultConfigFile(c *C) {
defer testing.MakeEmptyFakeHome(c).Restore()
env := `
environments:
only:
type: dummy
state-server: false
authorized-keys: i-am-a-key
`
outfile, err := environs.WriteEnvirons("", env)
c.Assert(err, IsNil)
path := testing.HomePath(".juju", "environments.yaml")
c.Assert(path, Equals, outfile)
es, err := environs.ReadEnvirons("")
c.Assert(err, IsNil)
e, err := es.Open("")
c.Assert(err, IsNil)
c.Assert(e.Name(), Equals, "only")
}
// Run checks to see if there is already an environments.yaml file. In one does not exist already,
// a boilerplate version is created so that the user can edit it to get started.
func (c *InitCommand) Run(context *cmd.Context) error {
out := context.Stdout
config := environs.BoilerplateConfig()
if c.Show {
fmt.Fprint(out, config)
return nil
}
_, err := environs.ReadEnvirons("")
if err == nil && !c.WriteFile {
return errJujuEnvExists
}
if err != nil && !os.IsNotExist(err) {
return err
}
filename, err := environs.WriteEnvirons("", config)
if err != nil {
return fmt.Errorf("A boilerplate environment configuration file could not be created: %s", err.Error())
}
fmt.Fprintf(out, "A boilerplate environment configuration file has been written to %s.\n", filename)
fmt.Fprint(out, "Edit the file to configure your juju environment and run bootstrap.\n")
return nil
}
func (c *PluginCommand) Run(ctx *cmd.Context) error {
env := c.EnvName
if env == "" {
// Passing through the empty string reads the default environments.yaml file.
environments, err := environs.ReadEnvirons("")
if err != nil {
log.Errorf("could not read the environments.yaml file: %s", err)
return fmt.Errorf("could not read the environments.yaml file")
}
env = environments.Default
}
os.Setenv("JUJU_ENV", env)
command := exec.Command(c.name, c.args...)
// Now hook up stdin, stdout, stderr
command.Stdin = ctx.Stdin
command.Stdout = ctx.Stdout
command.Stderr = ctx.Stderr
// And run it!
return command.Run()
}
