func (s *DeploySuite) TestRelativeConfigPath(c *gc.C) {
coretesting.Charms.BundlePath(s.SeriesPath, "dummy")
// Putting a config file in home is okay as $HOME is set to a tempdir
setupConfigFile(c, utils.Home())
err := runDeploy(c, "local:dummy", "dummy-service", "--config", "~/testconfig.yaml")
c.Assert(err, gc.IsNil)
}
// jujuHomeLinux returns the directory where juju should store application-specific files on Linux.
func jujuHomeLinux() string {
home := utils.Home()
if home == "" {
return ""
}
return filepath.Join(home, ".juju")
}
func (s *fakeHomeSuite) TearDownTest(c *gc.C) {
s.FakeJujuHomeSuite.TearDownTest(c)
// Test that the environment is restored.
c.Assert(utils.Home(), gc.Equals, "/home/eric")
c.Assert(os.Getenv("JUJU_HOME"), gc.Equals, "/home/eric/juju")
c.Assert(osenv.JujuHome(), gc.Equals, "/home/eric/juju")
}
func (h *FakeHome) AddFiles(c *gc.C, files ...TestFile) {
for _, f := range files {
path := filepath.Join(utils.Home(), f.Name)
err := os.MkdirAll(filepath.Dir(path), 0700)
c.Assert(err, gc.IsNil)
err = ioutil.WriteFile(path, []byte(f.Data), 0666)
c.Assert(err, gc.IsNil)
h.files = append(h.files, f)
}
}
func (s *AuthKeysSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
old := utils.Home()
newhome := c.MkDir()
utils.SetHome(newhome)
s.AddCleanup(func(*gc.C) { utils.SetHome(old) })
s.dotssh = filepath.Join(newhome, ".ssh")
err := os.Mkdir(s.dotssh, 0755)
c.Assert(err, gc.IsNil)
}
func (s *filestorageSuite) TestPathRelativeToHome(c *gc.C) {
homeDir := utils.Home()
tempDir, err := ioutil.TempDir(homeDir, "")
c.Assert(err, gc.IsNil)
defer os.RemoveAll(tempDir)
dirName := strings.Replace(tempDir, homeDir, "", -1)
reader, err := filestorage.NewFileStorageReader(filepath.Join("~", dirName))
c.Assert(err, gc.IsNil)
url, err := reader.URL("")
c.Assert(err, gc.IsNil)
c.Assert(url, gc.Equals, "file://"+filepath.Join(homeDir, dirName))
}
func (t *BaseSuite) SetUpTest(c *gc.C) {
t.CleanupSuite.SetUpTest(c)
t.LoggingSuite.SetUpTest(c)
t.oldEnvironment = make(map[string]string)
for _, name := range []string{
osenv.JujuHomeEnvKey,
osenv.JujuEnvEnvKey,
osenv.JujuLoggingConfigEnvKey,
} {
t.oldEnvironment[name] = os.Getenv(name)
}
t.oldHomeEnv = utils.Home()
utils.SetHome("")
os.Setenv(osenv.JujuHomeEnvKey, "")
os.Setenv(osenv.JujuEnvEnvKey, "")
os.Setenv(osenv.JujuLoggingConfigEnvKey, "")
}
// ReadAuthorizedKeys implements the standard juju behaviour for finding
// authorized_keys. It returns a set of keys in in authorized_keys format
// (see sshd(8) for a description). If path is non-empty, it names the
// file to use; otherwise the user's .ssh directory will be searched.
// Home directory expansion will be performed on the path if it starts with
// a ~; if the expanded path is relative, it will be interpreted relative
// to $HOME/.ssh.
//
// The result of utils/ssh.PublicKeyFiles will always be prepended to the
// result. In practice, this means ReadAuthorizedKeys never returns an
// error when the call originates in the CLI.
func ReadAuthorizedKeys(path string) (string, error) {
files := ssh.PublicKeyFiles()
if path == "" {
files = append(files, "id_dsa.pub", "id_rsa.pub", "identity.pub")
} else {
files = append(files, path)
}
var firstError error
var keyData []byte
for _, f := range files {
f, err := utils.NormalizePath(f)
if err != nil {
if firstError == nil {
firstError = err
}
continue
}
if !filepath.IsAbs(f) {
f = filepath.Join(utils.Home(), ".ssh", f)
}
data, err := ioutil.ReadFile(f)
if err != nil {
if firstError == nil && !os.IsNotExist(err) {
firstError = err
}
continue
}
keyData = append(keyData, bytes.Trim(data, "\n")...)
keyData = append(keyData, '\n')
}
if len(keyData) == 0 {
if firstError == nil {
firstError = fmt.Errorf("no public ssh keys found")
}
return "", firstError
}
return string(keyData), nil
}
// HomePath joins the specified path snippets and returns
// an absolute path under Juju home.
func HomePath(names ...string) string {
all := append([]string{utils.Home()}, names...)
return filepath.Join(all...)
}
func (s *fakeHomeSuite) TestFakeHomeSetsConfigJujuHome(c *gc.C) {
expected := filepath.Join(utils.Home(), ".juju")
c.Assert(osenv.JujuHome(), gc.Equals, expected)
}
func (s *homeSuite) TestHomeLinux(c *gc.C) {
h := "/home/foo/bar"
s.PatchEnvironment("HOME", h)
c.Check(utils.Home(), gc.Equals, h)
}