func (*BoilerplateConfigSuite) TestBoilerPlateAliases(c *gc.C) {
defer osenv.SetJujuHome(osenv.SetJujuHome(c.MkDir()))
boilerplate_text := environs.BoilerplateConfig()
// There should be only one occurrence of "manual", despite
// there being an alias ("null"). There should be nothing for
// aliases.
n := strings.Count(boilerplate_text, "type: manual")
c.Assert(n, gc.Equals, 1)
n = strings.Count(boilerplate_text, "type: null")
c.Assert(n, gc.Equals, 0)
}
func (h *FakeHome) Restore() {
osenv.SetJujuHome(h.oldJujuHome)
for name, value := range h.oldEnvironment {
os.Setenv(name, value)
}
osenv.SetHome(h.oldHomeEnv)
}
func (suite *EnvironProviderSuite) TestAgentNameShouldNotBeSetByHand(c *gc.C) {
testJujuHome := c.MkDir()
defer osenv.SetJujuHome(osenv.SetJujuHome(testJujuHome))
attrs := testing.FakeConfig().Merge(testing.Attrs{
"type": "maas",
"maas-oauth": "aa:bb:cc",
"maas-server": "http://maas.testing.invalid/maas/",
"maas-agent-name": "foobar",
})
config, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
ctx := testing.Context(c)
_, err = suite.makeEnviron().Provider().Prepare(ctx, config)
c.Assert(err, gc.Equals, errAgentNameAlreadySet)
}
func (s *JujuConnSuite) tearDownConn(c *gc.C) {
serverAlive := testing.MgoServer.Addr() != ""
// Bootstrap will set the admin password, and render non-authorized use
// impossible. s.State may still hold the right password, so try to reset
// the password so that the MgoSuite soft-resetting works. If that fails,
// it will still work, but it will take a while since it has to kill the
// whole database and start over.
if err := s.State.SetAdminMongoPassword(""); err != nil && serverAlive {
c.Logf("cannot reset admin password: %v", err)
}
err := s.Conn.Close()
if serverAlive {
c.Assert(err, gc.IsNil)
}
err = s.APIConn.Close()
if serverAlive {
c.Assert(err, gc.IsNil)
}
dummy.Reset()
s.Conn = nil
s.State = nil
osenv.SetHome(s.oldHome)
osenv.SetJujuHome(s.oldJujuHome)
s.oldHome = ""
s.RootDir = ""
}
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 *MainSuite) TestHelpTopics(c *gc.C) {
// Check that we have correctly registered all the topics
// by checking the help output.
defer osenv.SetJujuHome(osenv.SetJujuHome(c.MkDir()))
out := badrun(c, 0, "help", "topics")
lines := strings.Split(out, "\n")
var names []string
for _, line := range lines {
f := strings.Fields(line)
if len(f) == 0 {
continue
}
names = append(names, f[0])
}
// The names should be output in alphabetical order, so don't sort.
c.Assert(names, gc.DeepEquals, topicNames)
}
func (suite *EnvironProviderSuite) TestOpenReturnsNilInterfaceUponFailure(c *gc.C) {
testJujuHome := c.MkDir()
defer osenv.SetJujuHome(osenv.SetJujuHome(testJujuHome))
const oauth = "wrongly-formatted-oauth-string"
attrs := testing.FakeConfig().Merge(testing.Attrs{
"type": "maas",
"maas-oauth": oauth,
"maas-server": "http://maas.testing.invalid/maas/",
})
config, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
env, err := suite.makeEnviron().Provider().Open(config)
// When Open() fails (i.e. returns a non-nil error), it returns an
// environs.Environ interface object with a nil value and a nil
// type.
c.Check(env, gc.Equals, nil)
c.Check(err, gc.ErrorMatches, ".*malformed maas-oauth.*")
}
func (suite *EnvironProviderSuite) TestSecretAttrsReturnsSensitiveMAASAttributes(c *gc.C) {
testJujuHome := c.MkDir()
defer osenv.SetJujuHome(osenv.SetJujuHome(testJujuHome))
const oauth = "aa:bb:cc"
attrs := testing.FakeConfig().Merge(testing.Attrs{
"type": "maas",
"maas-oauth": oauth,
"maas-server": "http://maas.testing.invalid/maas/",
})
config, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
secretAttrs, err := suite.makeEnviron().Provider().SecretAttrs(config)
c.Assert(err, gc.IsNil)
expectedAttrs := map[string]string{"maas-oauth": oauth}
c.Check(secretAttrs, gc.DeepEquals, expectedAttrs)
}
// InitJujuHome initializes the charm, environs/config and utils/ssh packages
// to use default paths based on the $JUJU_HOME or $HOME environment variables.
// This function should be called before calling NewConn or Conn.Deploy.
func InitJujuHome() error {
jujuHome := osenv.JujuHomeDir()
if jujuHome == "" {
return stderrors.New(
"cannot determine juju home, required environment variables are not set")
}
osenv.SetJujuHome(jujuHome)
charm.CacheDir = osenv.JujuHomePath("charmcache")
if err := ssh.LoadClientKeys(osenv.JujuHomePath("ssh")); err != nil {
return fmt.Errorf("cannot load ssh client keys: %v", err)
}
return nil
}
func (s *MainSuite) TestHelpGlobalOptions(c *gc.C) {
// Check that we have correctly registered all the topics
// by checking the help output.
defer osenv.SetJujuHome(osenv.SetJujuHome(c.MkDir()))
out := badrun(c, 0, "help", "global-options")
c.Assert(out, gc.Matches, `Global Options
These options may be used with any command, and may appear in front of any
command\.(.|\n)*`)
lines := strings.Split(out, "\n")
var flags []string
for _, line := range lines {
f := strings.Fields(line)
if len(f) == 0 || line[0] != '-' {
continue
}
flags = append(flags, line)
}
c.Assert(len(flags), gc.Equals, len(globalFlags))
for i, line := range flags {
c.Assert(line, gc.Matches, globalFlags[i])
}
}
func (suite *EnvironProviderSuite) TestUnknownAttrsContainAgentName(c *gc.C) {
testJujuHome := c.MkDir()
defer osenv.SetJujuHome(osenv.SetJujuHome(testJujuHome))
attrs := testing.FakeConfig().Merge(testing.Attrs{
"type": "maas",
"maas-oauth": "aa:bb:cc",
"maas-server": "http://maas.testing.invalid/maas/",
})
config, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
ctx := testing.Context(c)
environ, err := suite.makeEnviron().Provider().Prepare(ctx, config)
c.Assert(err, gc.IsNil)
preparedConfig := environ.Config()
unknownAttrs := preparedConfig.UnknownAttrs()
uuid, ok := unknownAttrs["maas-agent-name"]
c.Assert(ok, jc.IsTrue)
c.Assert(uuid, jc.Satisfies, utils.IsValidUUIDString)
}
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 (*BoilerplateConfigSuite) TestBoilerPlateGeneration(c *gc.C) {
defer osenv.SetJujuHome(osenv.SetJujuHome(c.MkDir()))
boilerplate_text := environs.BoilerplateConfig()
_, err := environs.ReadEnvironsBytes([]byte(boilerplate_text))
c.Assert(err, gc.IsNil)
}
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 *JujuHomeSuite) TestStandardHome(c *gc.C) {
testJujuHome := c.MkDir()
defer osenv.SetJujuHome(osenv.SetJujuHome(testJujuHome))
c.Assert(osenv.JujuHome(), gc.Equals, testJujuHome)
}
func (s *JujuHomeSuite) TestHomePath(c *gc.C) {
testJujuHome := c.MkDir()
defer osenv.SetJujuHome(osenv.SetJujuHome(testJujuHome))
envPath := osenv.JujuHomePath("environments.yaml")
c.Assert(envPath, gc.Equals, filepath.Join(testJujuHome, "environments.yaml"))
}
func (*CloudInitSuite) testUserData(c *gc.C, bootstrap bool) {
testJujuHome := c.MkDir()
defer osenv.SetJujuHome(osenv.SetJujuHome(testJujuHome))
tools := &tools.Tools{
URL: "http://foo.com/tools/releases/juju1.2.3-linux-amd64.tgz",
Version: version.MustParseBinary("1.2.3-linux-amd64"),
}
envConfig, err := config.New(config.NoDefaults, dummySampleConfig())
c.Assert(err, gc.IsNil)
allJobs := []params.MachineJob{
params.JobManageEnviron,
params.JobHostUnits,
}
cfg := &cloudinit.MachineConfig{
MachineId: "10",
MachineNonce: "5432",
Tools: tools,
StateInfo: &state.Info{
Addrs: []string{"127.0.0.1:1234"},
Password: "******",
CACert: "CA CERT\n" + testing.CACert,
Tag: "machine-10",
},
APIInfo: &api.Info{
Addrs: []string{"127.0.0.1:1234"},
Password: "******",
CACert: "CA CERT\n" + testing.CACert,
Tag: "machine-10",
},
DataDir: environs.DataDir,
LogDir: agent.DefaultLogDir,
Jobs: allJobs,
CloudInitOutputLog: environs.CloudInitOutputLog,
Config: envConfig,
AgentEnvironment: map[string]string{agent.ProviderType: "dummy"},
AuthorizedKeys: "wheredidileavemykeys",
MachineAgentServiceName: "jujud-machine-10",
}
if bootstrap {
cfg.Bootstrap = true
cfg.StateServingInfo = ¶ms.StateServingInfo{
StatePort: envConfig.StatePort(),
APIPort: envConfig.APIPort(),
Cert: testing.ServerCert,
PrivateKey: testing.ServerKey,
}
}
script1 := "script1"
script2 := "script2"
cloudcfg := coreCloudinit.New()
cloudcfg.AddRunCmd(script1)
cloudcfg.AddRunCmd(script2)
result, err := environs.ComposeUserData(cfg, cloudcfg)
c.Assert(err, gc.IsNil)
unzipped, err := utils.Gunzip(result)
c.Assert(err, gc.IsNil)
config := make(map[interface{}]interface{})
err = goyaml.Unmarshal(unzipped, &config)
c.Assert(err, gc.IsNil)
// The scripts given to userData where added as the first
// commands to be run.
runCmd := config["runcmd"].([]interface{})
c.Check(runCmd[0], gc.Equals, script1)
c.Check(runCmd[1], gc.Equals, script2)
if bootstrap {
// The cloudinit config should have nothing but the basics:
// SSH authorized keys, the additional runcmds, and log output.
//
// Note: the additional runcmds *do* belong here, at least
// for MAAS. MAAS needs to configure and then bounce the
// network interfaces, which would sever the SSH connection
// in the synchronous bootstrap phase.
c.Check(config, gc.DeepEquals, map[interface{}]interface{}{
"output": map[interface{}]interface{}{
"all": "| tee -a /var/log/cloud-init-output.log",
},
"runcmd": []interface{}{
"script1", "script2",
"set -xe",
"install -D -m 644 /dev/null '/var/lib/juju/nonce.txt'",
"printf '%s\\n' '5432' > '/var/lib/juju/nonce.txt'",
},
"ssh_authorized_keys": []interface{}{"wheredidileavemykeys"},
})
} else {
// Just check that the cloudinit config looks good,
// and that there are more runcmds than the additional
// ones we passed into ComposeUserData.
c.Check(config["apt_upgrade"], gc.Equals, true)
c.Check(len(runCmd) > 2, jc.IsTrue)
}
}