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, osenv.Home())
err := runDeploy(c, "local:dummy", "dummy-service", "--config", "~/testconfig.yaml")
c.Assert(err, gc.IsNil)
}
func (s *TestingEnvironSuite) TestFakeHomeRestoresEnvironment(c *gc.C) {
fake := testing.MakeEmptyFakeHome(c)
fake.Restore()
c.Assert(osenv.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 (s *configSuite) TestValidateConfigWithTildeInRootDir(c *gc.C) {
valid := localConfig(c, map[string]interface{}{
"root-dir": "~/.juju/foo",
})
expectedRootDir := filepath.Join(osenv.Home(), ".juju", "foo")
unknownAttrs := valid.UnknownAttrs()
c.Assert(unknownAttrs["root-dir"], gc.Equals, expectedRootDir)
}
func (s *TestingEnvironSuite) SetUpTest(c *gc.C) {
s.home = osenv.Home()
s.jujuHome = os.Getenv("JUJU_HOME")
osenv.SetHome("/home/eric")
os.Setenv("JUJU_HOME", "/home/eric/juju")
osenv.SetJujuHome("/home/eric/juju")
}
func (s *AuthKeysSuite) SetUpTest(c *gc.C) {
s.LoggingSuite.SetUpTest(c)
old := osenv.Home()
newhome := c.MkDir()
osenv.SetHome(newhome)
s.AddCleanup(func(*gc.C) { osenv.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 := osenv.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 (s *FileVarSuite) TestTildeFileVar(c *gc.C) {
defer testing.MakeEmptyFakeHome(c).Restore()
path := filepath.Join(osenv.Home(), "config.yaml")
err := ioutil.WriteFile(path, []byte("abc"), 0644)
c.Assert(err, gc.IsNil)
var config cmd.FileVar
config.Set("~/config.yaml")
file, err := config.Read(s.ctx)
c.Assert(err, gc.IsNil)
c.Assert(string(file), gc.Equals, "abc")
}
func (s *importSuite) TestHome(c *gc.C) {
s.PatchEnvironment("HOMEPATH", "")
s.PatchEnvironment("HOMEDRIVE", "")
drive := "P:"
path := `\home\foo\bar`
h := drive + path
osenv.SetHome(h)
c.Check(os.Getenv("HOMEPATH"), gc.Equals, path)
c.Check(os.Getenv("HOMEDRIVE"), gc.Equals, drive)
c.Check(osenv.Home(), gc.Equals, h)
// now test that if we only set the path, we don't mess with the drive
path2 := `\home\someotherfoo\bar`
osenv.SetHome(path2)
c.Check(os.Getenv("HOMEPATH"), gc.Equals, path2)
c.Check(os.Getenv("HOMEDRIVE"), gc.Equals, drive)
c.Check(osenv.Home(), gc.Equals, drive+path2)
}
func (s *ConfigSuite) SetUpTest(c *gc.C) {
s.LoggingSuite.SetUpTest(c)
s.savedHome = osenv.Home()
s.savedAccessKey = os.Getenv("AWS_ACCESS_KEY_ID")
s.savedSecretKey = os.Getenv("AWS_SECRET_ACCESS_KEY")
home := c.MkDir()
sshDir := filepath.Join(home, ".ssh")
err := os.Mkdir(sshDir, 0777)
c.Assert(err, gc.IsNil)
err = ioutil.WriteFile(filepath.Join(sshDir, "id_rsa.pub"), []byte("sshkey\n"), 0666)
c.Assert(err, gc.IsNil)
osenv.SetHome(home)
os.Setenv("AWS_ACCESS_KEY_ID", testAuth.AccessKey)
os.Setenv("AWS_SECRET_ACCESS_KEY", testAuth.SecretKey)
aws.Regions["configtest"] = configTestRegion
}
// 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(osenv.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
}
// UserHomeDir returns the home directory for the specified user, or the
// home directory for the current user if the specified user is empty.
func UserHomeDir(userName string) (homeDir string, err error) {
var u *user.User
if userName == "" {
// TODO (wallyworld) - fix tests on Windows
// Ordinarily, we'd always use user.Current() to get the current user
// and then get the HomeDir from that. But our tests rely on poking
// a value into $HOME in order to override the normal home dir for the
// current user. So on *nix, we're forced to use osenv.Home() to make
// the tests pass. All of our tests currently construct paths with the
// default user in mind eg "~/foo".
if runtime.GOOS == "windows" {
u, err = user.Current()
} else {
return osenv.Home(), nil
}
} else {
u, err = user.Lookup(userName)
if err != nil {
return "", err
}
}
return u.HomeDir, nil
}
func MakeEmptyFakeHomeWithoutJuju(c *gc.C) *FakeHome {
oldHomeEnv := osenv.Home()
oldEnvironment := make(map[string]string)
for _, name := range []string{
osenv.JujuHomeEnvKey,
osenv.JujuEnvEnvKey,
osenv.JujuLoggingConfigEnvKey,
} {
oldEnvironment[name] = os.Getenv(name)
}
fakeHome := c.MkDir()
osenv.SetHome(fakeHome)
os.Setenv(osenv.JujuHomeEnvKey, "")
os.Setenv(osenv.JujuEnvEnvKey, "")
os.Setenv(osenv.JujuLoggingConfigEnvKey, "")
jujuHome := filepath.Join(fakeHome, ".juju")
oldJujuHome := osenv.SetJujuHome(jujuHome)
return &FakeHome{
oldHomeEnv: oldHomeEnv,
oldEnvironment: oldEnvironment,
oldJujuHome: oldJujuHome,
files: []TestFile{},
}
}
func (s *importSuite) TestHomeLinux(c *gc.C) {
h := "/home/foo/bar"
s.PatchEnvironment("HOME", h)
c.Check(osenv.Home(), gc.Equals, h)
}
func (s *configSuite) TestValidateConfig(c *gc.C) {
valid := minimalConfig(c)
expectedRootDir := filepath.Join(osenv.Home(), ".juju", "test")
unknownAttrs := valid.UnknownAttrs()
c.Assert(unknownAttrs["root-dir"], gc.Equals, expectedRootDir)
}
func (s *fileSuite) SetUpTest(c *gc.C) {
s.oldHome = osenv.Home()
err := osenv.SetHome("/home/test-user")
c.Assert(err, gc.IsNil)
}
func (s *InitJujuHomeSuite) SetUpTest(c *gc.C) {
s.LoggingSuite.SetUpTest(c)
s.originalHome = osenv.Home()
s.originalJujuHome = os.Getenv("JUJU_HOME")
}
func (s *TestingEnvironSuite) TestFakeHomeSetsConfigJujuHome(c *gc.C) {
_ = testing.MakeEmptyFakeHome(c)
expected := filepath.Join(osenv.Home(), ".juju")
c.Assert(osenv.JujuHome(), gc.Equals, expected)
}
func (s *JujuConnSuite) setUpConn(c *gc.C) {
if s.RootDir != "" {
panic("JujuConnSuite.setUpConn without teardown")
}
s.RootDir = c.MkDir()
s.oldHome = osenv.Home()
home := filepath.Join(s.RootDir, "/home/ubuntu")
err := os.MkdirAll(home, 0777)
c.Assert(err, gc.IsNil)
osenv.SetHome(home)
s.oldJujuHome = osenv.SetJujuHome(filepath.Join(home, ".juju"))
err = os.Mkdir(osenv.JujuHome(), 0777)
c.Assert(err, gc.IsNil)
err = os.MkdirAll(s.DataDir(), 0777)
c.Assert(err, gc.IsNil)
s.PatchEnvironment(osenv.JujuEnvEnvKey, "")
// TODO(rog) remove these files and add them only when
// the tests specifically need them (in cmd/juju for example)
s.writeSampleConfig(c, osenv.JujuHomePath("environments.yaml"))
err = ioutil.WriteFile(osenv.JujuHomePath("dummyenv-cert.pem"), []byte(testing.CACert), 0666)
c.Assert(err, gc.IsNil)
err = ioutil.WriteFile(osenv.JujuHomePath("dummyenv-private-key.pem"), []byte(testing.CAKey), 0600)
c.Assert(err, gc.IsNil)
store, err := configstore.Default()
c.Assert(err, gc.IsNil)
s.ConfigStore = store
ctx := testing.Context(c)
environ, err := environs.PrepareFromName("dummyenv", ctx, s.ConfigStore)
c.Assert(err, gc.IsNil)
// sanity check we've got the correct environment.
c.Assert(environ.Name(), gc.Equals, "dummyenv")
s.PatchValue(&dummy.DataDir, s.DataDir())
s.LogDir = c.MkDir()
s.PatchValue(&dummy.LogDir, s.LogDir)
versions := PreferredDefaultVersions(environ.Config(), version.Binary{Number: version.Current.Number, Series: "precise", Arch: "amd64"})
versions = append(versions, version.Current)
// Upload tools for both preferred and fake default series
envtesting.MustUploadFakeToolsVersions(environ.Storage(), versions...)
c.Assert(bootstrap.Bootstrap(ctx, environ, environs.BootstrapParams{}), gc.IsNil)
s.BackingState = environ.(GetStater).GetStateInAPIServer()
conn, err := juju.NewConn(environ)
c.Assert(err, gc.IsNil)
s.Conn = conn
s.State = conn.State
apiConn, err := juju.NewAPIConn(environ, api.DialOpts{})
c.Assert(err, gc.IsNil)
s.APIConn = apiConn
s.APIState = apiConn.State
s.environ = environ
}
func (s *TestingEnvironSuite) TestFakeHomeReplacesEnvironment(c *gc.C) {
_ = testing.MakeEmptyFakeHome(c)
c.Assert(osenv.Home(), gc.Not(gc.Equals), "/home/eric")
c.Assert(os.Getenv("JUJU_HOME"), gc.Equals, "")
c.Assert(osenv.JujuHome(), gc.Not(gc.Equals), "/home/eric/juju")
}
func HomePath(names ...string) string {
all := append([]string{osenv.Home()}, names...)
return filepath.Join(all...)
}