func (s *MainSuite) TestHelpCommands(c *gc.C) {
defer osenv.SetJujuXDGDataHome(osenv.SetJujuXDGDataHome(c.MkDir()))
// Check that we have correctly registered all the commands
// by checking the help output.
// First check default commands, and then check commands that are
// activated by feature flags.
// remove features behind dev_flag for the first test
// since they are not enabled.
cmdSet := set.NewStrings(commandNames...)
// 1. Default Commands. Disable all features.
setFeatureFlags("")
// Use sorted values here so we can better see what is wrong.
registered := getHelpCommandNames(c)
unknown := registered.Difference(cmdSet)
c.Assert(unknown, jc.DeepEquals, set.NewStrings())
missing := cmdSet.Difference(registered)
c.Assert(missing, jc.DeepEquals, set.NewStrings())
// 2. Enable development features, and test again.
cmdSet = cmdSet.Union(commandNamesBehindFlags)
setFeatureFlags(strings.Join(devFeatures, ","))
registered = getHelpCommandNames(c)
unknown = registered.Difference(cmdSet)
c.Assert(unknown, jc.DeepEquals, set.NewStrings())
missing = cmdSet.Difference(registered)
c.Assert(missing, jc.DeepEquals, set.NewStrings())
}
func (*BoilerplateConfigSuite) TestBoilerPlateAliases(c *gc.C) {
defer osenv.SetJujuXDGDataHome(osenv.SetJujuXDGDataHome(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 (s *JujuOSEnvSuite) SetUpTest(c *gc.C) {
s.oldEnvironment = make(map[string]string)
for _, name := range []string{
osenv.JujuXDGDataHomeEnvKey,
osenv.JujuModelEnvKey,
osenv.JujuLoggingConfigEnvKey,
osenv.JujuFeatureFlagEnvKey,
osenv.XDGDataHome,
} {
s.oldEnvironment[name] = os.Getenv(name)
os.Setenv(name, "")
}
s.oldHomeEnv = utils.Home()
s.oldJujuXDGDataHome = osenv.SetJujuXDGDataHome("")
utils.SetHome("")
// Update the feature flag set to be the requested initial set.
// This works for both windows and unix, even though normally
// the feature flags on windows are determined using the registry.
// For tests, setting with the environment variable isolates us
// from a single resource that was hitting contention during parallel
// test runs.
os.Setenv(osenv.JujuFeatureFlagEnvKey, s.initialFeatureFlags)
featureflag.SetFlagsFromEnvironment(osenv.JujuFeatureFlagEnvKey)
}
func (s *JujuOSEnvSuite) TearDownTest(c *gc.C) {
for name, value := range s.oldEnvironment {
os.Setenv(name, value)
}
utils.SetHome(s.oldHomeEnv)
osenv.SetJujuXDGDataHome(s.oldJujuXDGDataHome)
}
func (s *TestingBaseSuite) SetUpTest(c *gc.C) {
utils.SetHome(home)
os.Setenv("JUJU_DATA", jujuXDGDataHome)
osenv.SetJujuXDGDataHome(jujuXDGDataHome)
s.BaseSuite.SetUpTest(c)
}
// Create a home directory and Juju data home for user username.
// This is used by setUpConn to create the 'ubuntu' user home, after RootDir,
// and may be used again later for other users.
func (s *JujuConnSuite) CreateUserHome(c *gc.C, params *UserHomeParams) {
if s.RootDir == "" {
c.Fatal("JujuConnSuite.setUpConn required first for RootDir")
}
c.Assert(params.Username, gc.Not(gc.Equals), "")
home := filepath.Join(s.RootDir, "home", params.Username)
err := os.MkdirAll(home, 0777)
c.Assert(err, jc.ErrorIsNil)
err = utils.SetHome(home)
c.Assert(err, jc.ErrorIsNil)
jujuHome := filepath.Join(home, ".local", "share")
err = os.MkdirAll(filepath.Join(home, ".local", "share"), 0777)
c.Assert(err, jc.ErrorIsNil)
previousJujuXDGDataHome := osenv.SetJujuXDGDataHome(jujuHome)
if params.SetOldHome {
s.oldJujuXDGDataHome = previousJujuXDGDataHome
}
err = os.MkdirAll(s.DataDir(), 0777)
c.Assert(err, jc.ErrorIsNil)
jujuModelEnvKey := "JUJU_MODEL"
if params.ModelEnvKey != "" {
jujuModelEnvKey = params.ModelEnvKey
}
s.PatchEnvironment(osenv.JujuModelEnvKey, jujuModelEnvKey)
s.ControllerStore = jujuclient.NewFileClientStore()
}
func (s *fakeHomeSuite) SetUpTest(c *gc.C) {
utils.SetHome(home)
os.Setenv("JUJU_DATA", jujuXDGDataHome)
osenv.SetJujuXDGDataHome(jujuXDGDataHome)
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
}
func (s *JujuOSEnvSuite) TearDownTest(c *gc.C) {
for name, value := range s.oldEnvironment {
os.Setenv(name, value)
}
err := utils.SetHome(s.oldHomeEnv)
c.Assert(err, jc.ErrorIsNil)
osenv.SetJujuXDGDataHome(s.oldJujuXDGDataHome)
}
func (s *MainSuite) TestHelpTopics(c *gc.C) {
// Check that we have correctly registered all the topics
// by checking the help output.
defer osenv.SetJujuXDGDataHome(osenv.SetJujuXDGDataHome(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 (s *FakeJujuXDGDataHomeSuite) SetUpTest(c *gc.C) {
s.JujuOSEnvSuite.SetUpTest(c)
s.FakeHomeSuite.SetUpTest(c)
jujuXDGDataHome := gitjujutesting.JujuXDGDataHomePath()
err := os.MkdirAll(jujuXDGDataHome, 0700)
c.Assert(err, jc.ErrorIsNil)
s.oldJujuXDGDataHome = osenv.SetJujuXDGDataHome(jujuXDGDataHome)
}
func (s *cloudSuite) TestWritePublicCloudsMetadata(c *gc.C) {
origHome := osenv.SetJujuXDGDataHome(c.MkDir())
s.AddCleanup(func(*gc.C) { osenv.SetJujuXDGDataHome(origHome) })
clouds := map[string]cloud.Cloud{
"aws-me": cloud.Cloud{
Type: "aws",
AuthTypes: []cloud.AuthType{"userpass"},
},
}
err := cloud.WritePublicCloudMetadata(clouds)
c.Assert(err, jc.ErrorIsNil)
publicClouds, fallbackUsed, err := cloud.PublicCloudMetadata(cloud.JujuPublicCloudsPath())
c.Assert(err, jc.ErrorIsNil)
c.Assert(fallbackUsed, jc.IsFalse)
c.Assert(publicClouds, jc.DeepEquals, clouds)
}
func (s *fakeHomeSuite) SetUpTest(c *gc.C) {
err := utils.SetHome(home)
c.Assert(err, jc.ErrorIsNil)
os.Setenv("JUJU_DATA", jujuXDGDataHome)
osenv.SetJujuXDGDataHome(jujuXDGDataHome)
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
}
func (s *FakeJujuXDGDataHomeSuite) SetUpTest(c *gc.C) {
s.JujuOSEnvSuite.SetUpTest(c)
s.FakeHomeSuite.SetUpTest(c)
jujuXDGDataHome := gitjujutesting.JujuXDGDataHomePath()
err := os.MkdirAll(jujuXDGDataHome, 0700)
c.Assert(err, jc.ErrorIsNil)
s.oldJujuXDGDataHome = osenv.SetJujuXDGDataHome(jujuXDGDataHome)
WriteEnvironments(c, SingleEnvConfig, SampleCertName)
}
func (s *BaseSuite) SetUpTest(c *gc.C) {
s.IsolationSuite.SetUpTest(c)
s.PatchValue(&newConnection, newFakeConnection)
s.initEnv(c)
s.setUpHttpProxy(c)
s.FakeMetadataServer()
osenv.SetJujuXDGDataHome(c.MkDir())
}
func (s *CredentialsSuite) TestUpdateCredentialRemovesDefaultIfNecessary(c *gc.C) {
origHome := osenv.SetJujuXDGDataHome(c.MkDir())
s.AddCleanup(func(*gc.C) { osenv.SetJujuXDGDataHome(origHome) })
s.cloudName = firstTestCloudName(c)
store := jujuclient.NewFileCredentialStore()
err := store.UpdateCredential(s.cloudName, s.credentials)
c.Assert(err, jc.ErrorIsNil)
newCreds := s.credentials
// "peter" is the default credential
delete(newCreds.AuthCredentials, "peter")
err = store.UpdateCredential(s.cloudName, newCreds)
c.Assert(err, jc.ErrorIsNil)
creds, err := store.AllCredentials()
c.Assert(err, jc.ErrorIsNil)
c.Assert(creds[s.cloudName].DefaultCredential, gc.Equals, "")
}
// InitJujuXDGDataHome initializes the charm cache, environs/config and utils/ssh packages
// to use default paths based on the $JUJU_DATA or $HOME environment variables.
// This function should be called before running a Juju CLI command.
func InitJujuXDGDataHome() error {
jujuXDGDataHome := osenv.JujuXDGDataHomeDir()
if jujuXDGDataHome == "" {
return errors.New("cannot determine juju data home, required environment variables are not set")
}
osenv.SetJujuXDGDataHome(jujuXDGDataHome)
charmrepo.CacheDir = osenv.JujuXDGDataHomePath("charmcache")
if err := ssh.LoadClientKeys(osenv.JujuXDGDataHomePath("ssh")); err != nil {
return errors.Annotate(err, "cannot load ssh client keys")
}
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.SetJujuXDGDataHome(osenv.SetJujuXDGDataHome(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 (s *JujuConnSuite) tearDownConn(c *gc.C) {
testServer := gitjujutesting.MgoServer.Addr()
serverAlive := testServer != ""
// Close any api connections we know about first.
for _, st := range s.apiStates {
err := st.Close()
if serverAlive {
c.Check(err, jc.ErrorIsNil)
}
}
s.apiStates = nil
if s.APIState != nil {
err := s.APIState.Close()
s.APIState = nil
if serverAlive {
c.Check(err, gc.IsNil,
gc.Commentf("closing api state failed\n%s\n", errors.ErrorStack(err)),
)
}
}
// Close state.
if s.State != nil {
err := s.State.Close()
if serverAlive {
// This happens way too often with failing tests,
// so add some context in case of an error.
c.Check(err, gc.IsNil,
gc.Commentf("closing state failed\n%s\n", errors.ErrorStack(err)),
)
}
s.State = nil
}
dummy.Reset(c)
err := utils.SetHome(s.oldHome)
c.Assert(err, jc.ErrorIsNil)
osenv.SetJujuXDGDataHome(s.oldJujuXDGDataHome)
s.oldHome = ""
s.RootDir = ""
}
func (s *JujuXDGDataHomeSuite) TestHomePath(c *gc.C) {
testJujuHome := c.MkDir()
osenv.SetJujuXDGDataHome(testJujuHome)
envPath := osenv.JujuXDGDataHomePath("current-environment")
c.Assert(envPath, gc.Equals, filepath.Join(testJujuHome, "current-environment"))
}
func (*BoilerplateConfigSuite) TestBoilerPlateGeneration(c *gc.C) {
defer osenv.SetJujuXDGDataHome(osenv.SetJujuXDGDataHome(c.MkDir()))
boilerplate_text := environs.BoilerplateConfig()
_, err := environs.ReadEnvironsBytes([]byte(boilerplate_text))
c.Assert(err, jc.ErrorIsNil)
}
func (s *FakeJujuXDGDataHomeSuite) TearDownTest(c *gc.C) {
osenv.SetJujuXDGDataHome(s.oldJujuXDGDataHome)
s.FakeHomeSuite.TearDownTest(c)
s.JujuOSEnvSuite.TearDownTest(c)
}
func (s *addSuite) SetUpTest(c *gc.C) {
origHome := osenv.SetJujuXDGDataHome(c.MkDir())
s.AddCleanup(func(*gc.C) { osenv.SetJujuXDGDataHome(origHome) })
}
func (s *JujuConnSuite) setUpConn(c *gc.C) {
if s.RootDir != "" {
c.Fatal("JujuConnSuite.setUpConn without teardown")
}
s.RootDir = c.MkDir()
s.oldHome = utils.Home()
home := filepath.Join(s.RootDir, "/home/ubuntu")
err := os.MkdirAll(home, 0777)
c.Assert(err, jc.ErrorIsNil)
utils.SetHome(home)
err = os.MkdirAll(filepath.Join(home, ".local", "share"), 0777)
c.Assert(err, jc.ErrorIsNil)
s.oldJujuXDGDataHome = osenv.SetJujuXDGDataHome(filepath.Join(home, ".local", "share", "juju"))
err = os.MkdirAll(osenv.JujuXDGDataHome(), 0777)
c.Assert(err, jc.ErrorIsNil)
err = os.MkdirAll(s.DataDir(), 0777)
c.Assert(err, jc.ErrorIsNil)
s.PatchEnvironment(osenv.JujuModelEnvKey, "admin")
cfg, err := config.New(config.UseDefaults, (map[string]interface{})(s.sampleConfig()))
c.Assert(err, jc.ErrorIsNil)
s.ControllerStore = jujuclient.NewFileClientStore()
ctx := testing.Context(c)
environ, err := environs.Prepare(
modelcmd.BootstrapContext(ctx),
s.ControllerStore,
environs.PrepareParams{
BaseConfig: cfg.AllAttrs(),
Credential: cloud.NewEmptyCredential(),
ControllerName: ControllerName,
CloudName: "dummy",
},
)
c.Assert(err, jc.ErrorIsNil)
// sanity check we've got the correct environment.
c.Assert(environ.Config().Name(), gc.Equals, "admin")
s.PatchValue(&dummy.DataDir, s.DataDir())
s.LogDir = c.MkDir()
s.PatchValue(&dummy.LogDir, s.LogDir)
versions := PreferredDefaultVersions(environ.Config(), version.Binary{
Number: jujuversion.Current,
Arch: "amd64",
Series: "precise",
})
current := version.Binary{
Number: jujuversion.Current,
Arch: arch.HostArch(),
Series: series.HostSeries(),
}
versions = append(versions, current)
// Upload tools for both preferred and fake default series
s.DefaultToolsStorageDir = c.MkDir()
s.PatchValue(&tools.DefaultBaseURL, s.DefaultToolsStorageDir)
stor, err := filestorage.NewFileStorageWriter(s.DefaultToolsStorageDir)
c.Assert(err, jc.ErrorIsNil)
// Upload tools to both release and devel streams since config will dictate that we
// end up looking in both places.
envtesting.AssertUploadFakeToolsVersions(c, stor, "released", "released", versions...)
envtesting.AssertUploadFakeToolsVersions(c, stor, "devel", "devel", versions...)
s.DefaultToolsStorage = stor
s.PatchValue(&juju.JujuPublicKey, sstesting.SignedMetadataPublicKey)
err = bootstrap.Bootstrap(modelcmd.BootstrapContext(ctx), environ, bootstrap.BootstrapParams{})
c.Assert(err, jc.ErrorIsNil)
s.BackingState = environ.(GetStater).GetStateInAPIServer()
s.State, err = newState(environ, s.BackingState.MongoConnectionInfo())
c.Assert(err, jc.ErrorIsNil)
apiInfo, err := environs.APIInfo(environ)
c.Assert(err, jc.ErrorIsNil)
apiInfo.Tag = s.AdminUserTag(c)
apiInfo.Password = environ.Config().AdminSecret()
s.APIState, err = api.Open(apiInfo, api.DialOpts{})
c.Assert(err, jc.ErrorIsNil)
err = s.State.SetAPIHostPorts(s.APIState.APIHostPorts())
c.Assert(err, jc.ErrorIsNil)
// Make sure the controller store has the controller api endpoint address set
controller, err := s.ControllerStore.ControllerByName(ControllerName)
c.Assert(err, jc.ErrorIsNil)
controller.APIEndpoints = []string{s.APIState.APIHostPorts()[0][0].String()}
err = s.ControllerStore.UpdateController(ControllerName, *controller)
c.Assert(err, jc.ErrorIsNil)
err = modelcmd.WriteCurrentController(ControllerName)
c.Assert(err, jc.ErrorIsNil)
s.Environ = environ
// Insert expected values...
servingInfo := state.StateServingInfo{
PrivateKey: testing.ServerKey,
Cert: testing.ServerCert,
CAPrivateKey: testing.CAKey,
SharedSecret: "really, really secret",
APIPort: 4321,
StatePort: 1234,
}
s.State.SetStateServingInfo(servingInfo)
}
func (s *JujuXDGDataHomeSuite) TestHomePath(c *gc.C) {
testJujuHome := c.MkDir()
osenv.SetJujuXDGDataHome(testJujuHome)
envPath := osenv.JujuXDGDataHomeDir()
c.Assert(envPath, gc.Equals, testJujuHome)
}
func (s *JujuXDGDataHomeSuite) TestStandardHome(c *gc.C) {
testJujuXDGDataHome := c.MkDir()
osenv.SetJujuXDGDataHome(testJujuXDGDataHome)
c.Assert(osenv.JujuXDGDataHome(), gc.Equals, testJujuXDGDataHome)
}
func (s *JujuXDGDataHomeSuite) TearDownTest(c *gc.C) {
osenv.SetJujuXDGDataHome("")
}
func (*CloudInitSuite) testUserData(c *gc.C, series string, bootstrap bool) {
testJujuXDGDataHome := c.MkDir()
defer osenv.SetJujuXDGDataHome(osenv.SetJujuXDGDataHome(testJujuXDGDataHome))
// Use actual series paths instead of local defaults
logDir := must(paths.LogDir(series))
metricsSpoolDir := must(paths.MetricsSpoolDir(series))
dataDir := must(paths.DataDir(series))
toolsList := tools.List{
&tools.Tools{
URL: "http://tools.testing/tools/released/juju.tgz",
Version: version.Binary{version.MustParse("1.2.3"), "quantal", "amd64"},
},
}
envConfig, err := config.New(config.NoDefaults, dummySampleConfig())
c.Assert(err, jc.ErrorIsNil)
allJobs := []multiwatcher.MachineJob{
multiwatcher.JobManageModel,
multiwatcher.JobHostUnits,
multiwatcher.JobManageNetworking,
}
cfg := &instancecfg.InstanceConfig{
MachineId: "10",
MachineNonce: "5432",
Series: series,
MongoInfo: &mongo.MongoInfo{
Info: mongo.Info{
Addrs: []string{"127.0.0.1:1234"},
CACert: "CA CERT\n" + testing.CACert,
},
Password: "******",
Tag: names.NewMachineTag("10"),
},
APIInfo: &api.Info{
Addrs: []string{"127.0.0.1:1234"},
Password: "******",
CACert: "CA CERT\n" + testing.CACert,
Tag: names.NewMachineTag("10"),
ModelTag: testing.ModelTag,
},
DataDir: dataDir,
LogDir: path.Join(logDir, "juju"),
MetricsSpoolDir: metricsSpoolDir,
Jobs: allJobs,
CloudInitOutputLog: path.Join(logDir, "cloud-init-output.log"),
Config: envConfig,
AgentEnvironment: map[string]string{agent.ProviderType: "dummy"},
AuthorizedKeys: "wheredidileavemykeys",
MachineAgentServiceName: "jujud-machine-10",
EnableOSUpgrade: true,
}
err = cfg.SetTools(toolsList)
c.Assert(err, jc.ErrorIsNil)
if bootstrap {
cfg.Bootstrap = true
cfg.StateServingInfo = ¶ms.StateServingInfo{
StatePort: envConfig.StatePort(),
APIPort: envConfig.APIPort(),
Cert: testing.ServerCert,
PrivateKey: testing.ServerKey,
CAPrivateKey: testing.CAKey,
}
}
script1 := "script1"
script2 := "script2"
cloudcfg, err := cloudinit.New(series)
c.Assert(err, jc.ErrorIsNil)
cloudcfg.AddRunCmd(script1)
cloudcfg.AddRunCmd(script2)
result, err := providerinit.ComposeUserData(cfg, cloudcfg, &openstack.OpenstackRenderer{})
c.Assert(err, jc.ErrorIsNil)
unzipped, err := utils.Gunzip(result)
c.Assert(err, jc.ErrorIsNil)
config := make(map[interface{}]interface{})
err = goyaml.Unmarshal(unzipped, &config)
c.Assert(err, jc.ErrorIsNil)
// 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.
expected := 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 '/etc/init/juju-clean-shutdown.conf'",
"printf '%s\\n' '\nauthor \"Juju Team <*****@*****.**>\"\ndescription \"Stop all network interfaces on shutdown\"\nstart on runlevel [016]\ntask\nconsole output\n\nexec /sbin/ifdown -a -v --force\n' > '/etc/init/juju-clean-shutdown.conf'",
"install -D -m 644 /dev/null '/var/lib/juju/nonce.txt'",
"printf '%s\\n' '5432' > '/var/lib/juju/nonce.txt'",
},
}
// Series with old cloudinit versions don't support adding
// users so need the old way to set SSH authorized keys.
if series == "precise" {
expected["ssh_authorized_keys"] = []interface{}{
"wheredidileavemykeys",
}
} else {
expected["users"] = []interface{}{
map[interface{}]interface{}{
"name": "ubuntu",
"lock_passwd": true,
"groups": []interface{}{"adm", "audio",
"cdrom", "dialout", "dip",
"floppy", "netdev", "plugdev",
"sudo", "video"},
"shell": "/bin/bash",
"sudo": []interface{}{"ALL=(ALL) NOPASSWD:ALL"},
"ssh-authorized-keys": []interface{}{"wheredidileavemykeys"},
},
}
}
c.Check(config, jc.DeepEquals, expected)
} 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["package_upgrade"], jc.IsTrue)
c.Check(len(runCmd) > 2, jc.IsTrue)
}
}
func (s *defaultCredentialSuite) SetUpTest(c *gc.C) {
origHome := osenv.SetJujuXDGDataHome(c.MkDir())
s.AddCleanup(func(*gc.C) { osenv.SetJujuXDGDataHome(origHome) })
}
func (s *JujuXDGDataHomeSuite) TestIsHomeSet(c *gc.C) {
c.Assert(osenv.IsJujuXDGDataHomeSet(), jc.IsFalse)
osenv.SetJujuXDGDataHome(c.MkDir())
c.Assert(osenv.IsJujuXDGDataHomeSet(), jc.IsTrue)
}
func (s *JujuConnSuite) setUpConn(c *gc.C) {
if s.RootDir != "" {
panic("JujuConnSuite.setUpConn without teardown")
}
s.RootDir = c.MkDir()
s.oldHome = utils.Home()
home := filepath.Join(s.RootDir, "/home/ubuntu")
err := os.MkdirAll(home, 0777)
c.Assert(err, jc.ErrorIsNil)
utils.SetHome(home)
err = os.MkdirAll(filepath.Join(home, ".local", "share"), 0777)
c.Assert(err, jc.ErrorIsNil)
s.oldJujuXDGDataHome = osenv.SetJujuXDGDataHome(filepath.Join(home, ".local", "share", "juju"))
err = os.MkdirAll(osenv.JujuXDGDataHome(), 0777)
c.Assert(err, jc.ErrorIsNil)
err = os.MkdirAll(s.DataDir(), 0777)
c.Assert(err, jc.ErrorIsNil)
s.PatchEnvironment(osenv.JujuModelEnvKey, "")
// TODO(rog) remove these files and add them only when
// the tests specifically need them (in cmd/juju for example)
s.writeSampleConfig(c, osenv.JujuXDGDataHomePath("environments.yaml"))
err = ioutil.WriteFile(osenv.JujuXDGDataHomePath("dummymodel-cert.pem"), []byte(testing.CACert), 0666)
c.Assert(err, jc.ErrorIsNil)
err = ioutil.WriteFile(osenv.JujuXDGDataHomePath("dummymodel-private-key.pem"), []byte(testing.CAKey), 0600)
c.Assert(err, jc.ErrorIsNil)
store, err := configstore.Default()
c.Assert(err, jc.ErrorIsNil)
s.ConfigStore = store
ctx := testing.Context(c)
environ, err := environs.PrepareFromName("dummymodel", modelcmd.BootstrapContext(ctx), s.ConfigStore)
c.Assert(err, jc.ErrorIsNil)
// sanity check we've got the correct environment.
c.Assert(environ.Config().Name(), gc.Equals, "dummymodel")
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,
Arch: "amd64",
Series: "precise",
})
current := version.Binary{
Number: version.Current,
Arch: arch.HostArch(),
Series: series.HostSeries(),
}
versions = append(versions, current)
// Upload tools for both preferred and fake default series
s.DefaultToolsStorageDir = c.MkDir()
s.PatchValue(&tools.DefaultBaseURL, s.DefaultToolsStorageDir)
stor, err := filestorage.NewFileStorageWriter(s.DefaultToolsStorageDir)
c.Assert(err, jc.ErrorIsNil)
// Upload tools to both release and devel streams since config will dictate that we
// end up looking in both places.
envtesting.AssertUploadFakeToolsVersions(c, stor, "released", "released", versions...)
envtesting.AssertUploadFakeToolsVersions(c, stor, "devel", "devel", versions...)
s.DefaultToolsStorage = stor
s.PatchValue(&simplestreams.SimplestreamsJujuPublicKey, sstesting.SignedMetadataPublicKey)
err = bootstrap.Bootstrap(modelcmd.BootstrapContext(ctx), environ, bootstrap.BootstrapParams{})
c.Assert(err, jc.ErrorIsNil)
s.BackingState = environ.(GetStater).GetStateInAPIServer()
s.State, err = newState(environ, s.BackingState.MongoConnectionInfo())
c.Assert(err, jc.ErrorIsNil)
s.APIState, err = juju.NewAPIState(s.AdminUserTag(c), environ, api.DialOpts{})
c.Assert(err, jc.ErrorIsNil)
err = s.State.SetAPIHostPorts(s.APIState.APIHostPorts())
c.Assert(err, jc.ErrorIsNil)
// Make sure the config store has the api endpoint address set
info, err := s.ConfigStore.ReadInfo("dummymodel")
c.Assert(err, jc.ErrorIsNil)
endpoint := info.APIEndpoint()
endpoint.Addresses = []string{s.APIState.APIHostPorts()[0][0].String()}
info.SetAPIEndpoint(endpoint)
err = info.Write()
c.Assert(err, jc.ErrorIsNil)
// Make sure the jenv file has the local host ports.
c.Logf("jenv host ports: %#v", s.APIState.APIHostPorts())
s.Environ = environ
// Insert expected values...
servingInfo := state.StateServingInfo{
PrivateKey: testing.ServerKey,
Cert: testing.ServerCert,
CAPrivateKey: testing.CAKey,
SharedSecret: "really, really secret",
APIPort: 4321,
StatePort: 1234,
}
s.State.SetStateServingInfo(servingInfo)
}
