func (s *ClientKeysSuite) TestPrivateKeyFiles(c *gc.C) {
// Create/load client keys. They will be cached in memory:
// any files added to the directory will not be considered
// unless LoadClientKeys is called again.
err := ssh.LoadClientKeys("~/.juju/ssh")
c.Assert(err, gc.IsNil)
checkPrivateKeyFiles(c, "~/.juju/ssh/juju_id_rsa")
priv, pub, err := ssh.GenerateKey("whatever")
c.Assert(err, gc.IsNil)
err = ioutil.WriteFile(testing.HomePath(".juju", "ssh", "whatever"), []byte(priv), 0600)
c.Assert(err, gc.IsNil)
err = ssh.LoadClientKeys("~/.juju/ssh")
c.Assert(err, gc.IsNil)
// The new private key won't be observed until the
// corresponding public key exists.
checkPrivateKeyFiles(c, "~/.juju/ssh/juju_id_rsa")
err = ioutil.WriteFile(testing.HomePath(".juju", "ssh", "whatever.pub"), []byte(pub), 0600)
c.Assert(err, gc.IsNil)
// new keys won't be reported until we call LoadClientKeys again
checkPublicKeyFiles(c, "~/.juju/ssh/juju_id_rsa.pub")
checkPrivateKeyFiles(c, "~/.juju/ssh/juju_id_rsa")
err = ssh.LoadClientKeys("~/.juju/ssh")
c.Assert(err, gc.IsNil)
checkPublicKeyFiles(c, "~/.juju/ssh/juju_id_rsa.pub", "~/.juju/ssh/whatever.pub")
checkPrivateKeyFiles(c, "~/.juju/ssh/juju_id_rsa", "~/.juju/ssh/whatever")
}
func (suite *PluginSuite) makeFullPlugin(params PluginParams) {
// Create a new template and parse the plugin into it.
t := template.Must(template.New("plugin").Parse(pluginTemplate))
content := &bytes.Buffer{}
filename := testing.HomePath("juju-" + params.Name)
// Create the files in the temp dirs, so we don't pollute the working space
if params.Creates != "" {
params.Creates = testing.HomePath(params.Creates)
}
if params.DependsOn != "" {
params.DependsOn = testing.HomePath(params.DependsOn)
}
t.Execute(content, params)
ioutil.WriteFile(filename, content.Bytes(), 0755)
}
func (*suite) TestConfigPerm(c *gc.C) {
defer testing.MakeSampleHome(c).Restore()
path := testing.HomePath(".juju")
info, err := os.Lstat(path)
c.Assert(err, gc.IsNil)
oldPerm := info.Mode().Perm()
env := `
environments:
only:
type: dummy
state-server: false
authorized-keys: i-am-a-key
`
outfile, err := environs.WriteEnvirons("", env)
c.Assert(err, gc.IsNil)
info, err = os.Lstat(outfile)
c.Assert(err, gc.IsNil)
c.Assert(info.Mode().Perm(), gc.Equals, os.FileMode(0600))
info, err = os.Lstat(filepath.Dir(outfile))
c.Assert(err, gc.IsNil)
c.Assert(info.Mode().Perm(), gc.Equals, oldPerm)
}
func (s *ClientKeysSuite) TestLoadClientKeysDirExists(c *gc.C) {
err := os.MkdirAll(testing.HomePath(".juju", "ssh"), 0755)
c.Assert(err, gc.IsNil)
err = ssh.LoadClientKeys("~/.juju/ssh")
c.Assert(err, gc.IsNil)
checkPrivateKeyFiles(c, "~/.juju/ssh/juju_id_rsa")
}
// The boilerplate is sent to stdout with --show, and the environments.yaml
// is not created.
func (*InitSuite) TestBoilerPlatePrinted(c *gc.C) {
defer testing.MakeEmptyFakeHome(c).Restore()
ctx := testing.Context(c)
code := cmd.Main(&InitCommand{}, ctx, []string{"--show"})
c.Check(code, gc.Equals, 0)
outStr := ctx.Stdout.(*bytes.Buffer).String()
strippedOut := strings.Replace(outStr, "\n", "", -1)
c.Check(strippedOut, gc.Matches, ".*# This is the Juju config file, which you can use.*")
environpath := testing.HomePath(".juju", "environments.yaml")
_, err := ioutil.ReadFile(environpath)
c.Assert(err, gc.NotNil)
}
func (s *ClientKeysSuite) TestPublicKeyFiles(c *gc.C) {
// LoadClientKeys will create the specified directory
// and populate it with a key pair.
err := ssh.LoadClientKeys("~/.juju/ssh")
c.Assert(err, gc.IsNil)
checkPublicKeyFiles(c, "~/.juju/ssh/juju_id_rsa.pub")
// All files ending with .pub in the client key dir get picked up.
priv, pub, err := ssh.GenerateKey("whatever")
c.Assert(err, gc.IsNil)
err = ioutil.WriteFile(testing.HomePath(".juju", "ssh", "whatever.pub"), []byte(pub), 0600)
c.Assert(err, gc.IsNil)
err = ssh.LoadClientKeys("~/.juju/ssh")
c.Assert(err, gc.IsNil)
// The new public key won't be observed until the
// corresponding private key exists.
checkPublicKeyFiles(c, "~/.juju/ssh/juju_id_rsa.pub")
err = ioutil.WriteFile(testing.HomePath(".juju", "ssh", "whatever"), []byte(priv), 0600)
c.Assert(err, gc.IsNil)
err = ssh.LoadClientKeys("~/.juju/ssh")
c.Assert(err, gc.IsNil)
checkPublicKeyFiles(c, "~/.juju/ssh/juju_id_rsa.pub", "~/.juju/ssh/whatever.pub")
}
// An existing environments.yaml will not be overwritten without
// the explicit -f option.
func (*InitSuite) TestExistingEnvironmentNotOverwritten(c *gc.C) {
defer testing.MakeFakeHome(c, existingEnv, "existing").Restore()
ctx := testing.Context(c)
code := cmd.Main(&InitCommand{}, ctx, nil)
c.Check(code, gc.Equals, 1)
errOut := ctx.Stderr.(*bytes.Buffer).String()
strippedOut := strings.Replace(errOut, "\n", "", -1)
c.Check(strippedOut, gc.Matches, ".*A juju environment configuration already exists.*")
environpath := testing.HomePath(".juju", "environments.yaml")
data, err := ioutil.ReadFile(environpath)
c.Assert(err, gc.IsNil)
c.Assert(string(data), gc.Equals, existingEnv)
}
// The environments.yaml is created by default if it
// does not already exist.
func (*InitSuite) TestBoilerPlateEnvironment(c *gc.C) {
defer testing.MakeEmptyFakeHome(c).Restore()
ctx := testing.Context(c)
code := cmd.Main(&InitCommand{}, ctx, nil)
c.Check(code, gc.Equals, 0)
outStr := ctx.Stdout.(*bytes.Buffer).String()
strippedOut := strings.Replace(outStr, "\n", "", -1)
c.Check(strippedOut, gc.Matches, ".*A boilerplate environment configuration file has been written.*")
environpath := testing.HomePath(".juju", "environments.yaml")
data, err := ioutil.ReadFile(environpath)
c.Assert(err, gc.IsNil)
strippedData := strings.Replace(string(data), "\n", "", -1)
c.Assert(strippedData, gc.Matches, ".*# This is the Juju config file, which you can use.*")
}
func (*suite) TestDefaultConfigFile(c *gc.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, gc.IsNil)
path := testing.HomePath(".juju", "environments.yaml")
c.Assert(path, gc.Equals, outfile)
envs, err := environs.ReadEnvirons("")
c.Assert(err, gc.IsNil)
cfg, err := envs.Config("")
c.Assert(err, gc.IsNil)
c.Assert(cfg.Name(), gc.Equals, "only")
}
func (suite *PluginSuite) SetUpTest(c *gc.C) {
suite.LoggingSuite.SetUpTest(c)
suite.oldPath = os.Getenv("PATH")
suite.home = testing.MakeSampleHome(c)
os.Setenv("PATH", "/bin:"+testing.HomePath())
}
func (suite *PluginSuite) makeFailingPlugin(name string, exitStatus int) {
content := fmt.Sprintf("#!/bin/bash --norc\necho failing\nexit %d", exitStatus)
filename := testing.HomePath(JujuPluginPrefix + name)
ioutil.WriteFile(filename, []byte(content), 0755)
}
func (suite *PluginSuite) makePlugin(name string, perm os.FileMode) {
content := fmt.Sprintf("#!/bin/bash --norc\necho %s $*", name)
filename := testing.HomePath(JujuPluginPrefix + name)
ioutil.WriteFile(filename, []byte(content), perm)
}