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 *InitJujuHomeSuite) TestJujuHome(c *gc.C) {
jujuHome := c.MkDir()
os.Setenv("JUJU_HOME", jujuHome)
err := juju.InitJujuHome()
c.Assert(err, gc.IsNil)
c.Assert(osenv.JujuHome(), gc.Equals, jujuHome)
}
func (s *JujuHomeSuite) TestErrorHome(c *gc.C) {
// Invalid juju home leads to panic when retrieving.
f := func() { _ = osenv.JujuHome() }
c.Assert(f, gc.PanicMatches, "juju home hasn't been initialized")
f = func() { _ = osenv.JujuHomePath("environments.yaml") }
c.Assert(f, gc.PanicMatches, "juju home hasn't been initialized")
}
func (s *InitJujuHomeSuite) TestHome(c *gc.C) {
osHome := c.MkDir()
os.Setenv("JUJU_HOME", "")
osenv.SetHome(osHome)
err := juju.InitJujuHome()
c.Assert(err, gc.IsNil)
c.Assert(osenv.JujuHome(), gc.Equals, filepath.Join(osHome, ".juju"))
}
func badrun(c *gc.C, exit int, args ...string) string {
localArgs := append([]string{"-test.run", "TestRunMain", "-run-main", "--", "juju"}, args...)
ps := exec.Command(os.Args[0], localArgs...)
ps.Env = append(os.Environ(), osenv.JujuHomeEnvKey+"="+osenv.JujuHome())
output, err := ps.CombinedOutput()
c.Logf("command output: %q", output)
if exit != 0 {
c.Assert(err, gc.ErrorMatches, fmt.Sprintf("exit status %d", exit))
}
return string(output)
}
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()}...,
)
// Now hook up stdin, stdout, stderr
command.Stdin = ctx.Stdin
command.Stdout = ctx.Stdout
command.Stderr = ctx.Stderr
// And run it!
return command.Run()
}
func (s *ToolsMetadataSuite) TestPatchLevels(c *gc.C) {
currentVersion := version.Current.Number
currentVersion.Build = 0
versionStrings := []string{
currentVersion.String() + "-precise-amd64",
currentVersion.String() + ".1-precise-amd64",
}
metadataDir := osenv.JujuHome() // default metadata dir
ttesting.MakeTools(c, metadataDir, "releases", versionStrings)
ctx := coretesting.Context(c)
code := cmd.Main(&ToolsMetadataCommand{}, ctx, nil)
c.Assert(code, gc.Equals, 0)
output := ctx.Stdout.(*bytes.Buffer).String()
expectedOutput := fmt.Sprintf(`
Finding tools in .*
.*Fetching tools to generate hash: %s
.*Fetching tools to generate hash: %s
.*Writing tools/streams/v1/index\.json
.*Writing tools/streams/v1/com\.ubuntu\.juju:released:tools\.json
`[1:], regexp.QuoteMeta(versionStrings[0]), regexp.QuoteMeta(versionStrings[1]))
c.Assert(output, gc.Matches, expectedOutput)
metadata := ttesting.ParseMetadataFromDir(c, metadataDir, false)
c.Assert(metadata, gc.HasLen, 2)
filename := fmt.Sprintf("juju-%s-precise-amd64.tgz", currentVersion)
size, sha256 := ttesting.SHA256sum(c, filepath.Join(metadataDir, "tools", "releases", filename))
c.Assert(metadata[0], gc.DeepEquals, &tools.ToolsMetadata{
Release: "precise",
Version: currentVersion.String(),
Arch: "amd64",
Size: size,
Path: "releases/" + filename,
FileType: "tar.gz",
SHA256: sha256,
})
filename = fmt.Sprintf("juju-%s.1-precise-amd64.tgz", currentVersion)
size, sha256 = ttesting.SHA256sum(c, filepath.Join(metadataDir, "tools", "releases", filename))
c.Assert(metadata[1], gc.DeepEquals, &tools.ToolsMetadata{
Release: "precise",
Version: currentVersion.String() + ".1",
Arch: "amd64",
Size: size,
Path: "releases/" + filename,
FileType: "tar.gz",
SHA256: sha256,
})
}
func (s *ToolsMetadataSuite) TestGenerateDefaultDirectory(c *gc.C) {
metadataDir := osenv.JujuHome() // default metadata dir
ttesting.MakeTools(c, metadataDir, "releases", versionStrings)
ctx := coretesting.Context(c)
code := cmd.Main(&ToolsMetadataCommand{}, ctx, nil)
c.Assert(code, gc.Equals, 0)
output := ctx.Stdout.(*bytes.Buffer).String()
c.Assert(output, gc.Matches, expectedOutputDirectory)
metadata := ttesting.ParseMetadataFromDir(c, metadataDir, false)
c.Assert(metadata, gc.HasLen, len(versionStrings))
obtainedVersionStrings := make([]string, len(versionStrings))
for i, metadata := range metadata {
s := fmt.Sprintf("%s-%s-%s", metadata.Version, metadata.Release, metadata.Arch)
obtainedVersionStrings[i] = s
}
c.Assert(obtainedVersionStrings, gc.DeepEquals, versionStrings)
}
func (s *localJujuTestSuite) TestDestroyCallSudo(c *gc.C) {
env := s.testBootstrap(c, minimalConfig(c))
s.makeAgentsDir(c, env)
err := env.Destroy()
c.Assert(err, gc.IsNil)
data, err := ioutil.ReadFile(s.fakesudo + ".args")
c.Assert(err, gc.IsNil)
expected := []string{
s.fakesudo,
"env",
"JUJU_HOME=" + osenv.JujuHome(),
os.Args[0],
"destroy-environment",
"-y",
"--force",
env.Config().Name(),
}
c.Assert(string(data), gc.Equals, strings.Join(expected, " ")+"\n")
}
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")
if c.metadataDir == "" {
c.metadataDir = osenv.JujuHome()
} else {
c.metadataDir = context.AbsPath(c.metadataDir)
}
sourceStorage, err := filestorage.NewFileStorageReader(c.metadataDir)
if err != nil {
return err
}
fmt.Fprintf(context.Stdout, "Finding tools in %s\n", c.metadataDir)
const minorVersion = -1
toolsList, err := envtools.ReadList(sourceStorage, version.Current.Major, minorVersion)
if err == envtools.ErrNoTools {
var source string
source, err = envtools.ToolsURL(envtools.DefaultBaseURL)
if err != nil {
return err
}
sourceDataSource := simplestreams.NewURLDataSource("local source", source, utils.VerifySSLHostnames)
toolsList, err = envtools.FindToolsForCloud(
[]simplestreams.DataSource{sourceDataSource}, simplestreams.CloudSpec{},
version.Current.Major, minorVersion, coretools.Filter{})
}
if err != nil {
return err
}
targetStorage, err := filestorage.NewFileStorageWriter(c.metadataDir)
if err != nil {
return err
}
writeMirrors := envtools.DoNotWriteMirrors
if c.public {
writeMirrors = envtools.WriteMirrors
}
return mergeAndWriteMetadata(targetStorage, toolsList, writeMirrors)
}
func (s *JujuHomeSuite) TestStandardHome(c *gc.C) {
testJujuHome := c.MkDir()
defer osenv.SetJujuHome(osenv.SetJujuHome(testJujuHome))
c.Assert(osenv.JujuHome(), gc.Equals, testJujuHome)
}
func getCurrentEnvironmentFilePath() string {
return filepath.Join(osenv.JujuHome(), CurrentEnvironmentFilename)
}
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 *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 MakeEmptyFakeHome(c *gc.C) *FakeHome {
fake := MakeEmptyFakeHomeWithoutJuju(c)
err := os.Mkdir(osenv.JujuHome(), 0700)
c.Assert(err, gc.IsNil)
return fake
}
// Default returns disk-based environment config storage
// rooted at JujuHome.
func Default() (Storage, error) {
return NewDisk(osenv.JujuHome())
}
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
}
