// primeAgent writes the configuration file and tools with version vers
// for an agent with the given entity name. It returns the agent's
// configuration and the current tools.
func (s *agentSuite) primeAgent(c *gc.C, tag, password string, vers version.Binary) (agent.ConfigSetterWriter, *coretools.Tools) {
stor := s.Conn.Environ.Storage()
agentTools := envtesting.PrimeTools(c, stor, s.DataDir(), vers)
err := envtools.MergeAndWriteMetadata(stor, coretools.List{agentTools}, envtools.DoNotWriteMirrors)
c.Assert(err, gc.IsNil)
tools1, err := agenttools.ChangeAgentTools(s.DataDir(), tag, vers)
c.Assert(err, gc.IsNil)
c.Assert(tools1, gc.DeepEquals, agentTools)
stateInfo := s.StateInfo(c)
apiInfo := s.APIInfo(c)
conf, err := agent.NewAgentConfig(
agent.AgentConfigParams{
DataDir: s.DataDir(),
Tag: tag,
UpgradedToVersion: vers.Number,
Password: password,
Nonce: state.BootstrapNonce,
StateAddresses: stateInfo.Addrs,
APIAddresses: apiInfo.Addrs,
CACert: stateInfo.CACert,
})
conf.SetPassword(password)
c.Assert(conf.Write(), gc.IsNil)
s.primeAPIHostPorts(c)
return conf, agentTools
}
func (s *RebootSuite) SetUpTest(c *gc.C) {
var err error
s.JujuConnSuite.SetUpTest(c)
testing.PatchExecutableAsEchoArgs(c, s, rebootBin)
s.PatchEnvironment("TEMP", c.MkDir())
s.tmpDir = c.MkDir()
s.rebootScriptName = "juju-reboot-script"
s.PatchValue(reboot.TmpFile, func() (*os.File, error) {
script := s.rebootScript(c)
return os.Create(script)
})
s.mgoInst.EnableAuth = true
err = s.mgoInst.Start(coretesting.Certs)
c.Assert(err, jc.ErrorIsNil)
configParams := agent.AgentConfigParams{
Paths: agent.Paths{DataDir: c.MkDir()},
Tag: names.NewMachineTag("0"),
UpgradedToVersion: version.Current,
StateAddresses: []string{s.mgoInst.Addr()},
CACert: coretesting.CACert,
Password: "******",
Model: s.State.ModelTag(),
}
s.st, _ = s.OpenAPIAsNewMachine(c)
s.acfg, err = agent.NewAgentConfig(configParams)
c.Assert(err, jc.ErrorIsNil)
}
// PrimeAgentVersion writes the configuration file and tools with version
// vers for an agent with the given entity name. It returns the agent's
// configuration and the current tools.
func (s *AgentSuite) PrimeAgentVersion(c *gc.C, tag names.Tag, password string, vers version.Binary) (agent.ConfigSetterWriter, *coretools.Tools) {
c.Logf("priming agent %s", tag.String())
stor, err := filestorage.NewFileStorageWriter(c.MkDir())
c.Assert(err, jc.ErrorIsNil)
agentTools := envtesting.PrimeTools(c, stor, s.DataDir(), "released", vers)
err = envtools.MergeAndWriteMetadata(stor, "released", "released", coretools.List{agentTools}, envtools.DoNotWriteMirrors)
tools1, err := agenttools.ChangeAgentTools(s.DataDir(), tag.String(), vers)
c.Assert(err, jc.ErrorIsNil)
c.Assert(tools1, gc.DeepEquals, agentTools)
stateInfo := s.MongoInfo(c)
apiInfo := s.APIInfo(c)
paths := agent.DefaultPaths
paths.DataDir = s.DataDir()
conf, err := agent.NewAgentConfig(
agent.AgentConfigParams{
Paths: paths,
Tag: tag,
UpgradedToVersion: vers.Number,
Password: password,
Nonce: agent.BootstrapNonce,
StateAddresses: stateInfo.Addrs,
APIAddresses: apiInfo.Addrs,
CACert: stateInfo.CACert,
Model: apiInfo.ModelTag,
})
c.Assert(err, jc.ErrorIsNil)
conf.SetPassword(password)
c.Assert(conf.Write(), gc.IsNil)
s.primeAPIHostPorts(c)
return conf, agentTools
}
func (s *lxcBrokerSuite) SetUpTest(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("Skipping lxc tests on windows")
}
s.lxcSuite.SetUpTest(c)
var err error
s.agentConfig, err = agent.NewAgentConfig(
agent.AgentConfigParams{
Paths: agent.NewPathsWithDefaults(agent.Paths{DataDir: "/not/used/here"}),
Tag: names.NewMachineTag("1"),
UpgradedToVersion: jujuversion.Current,
Password: "******",
Nonce: "nonce",
APIAddresses: []string{"10.0.0.1:1234"},
CACert: coretesting.CACert,
Model: coretesting.ModelTag,
})
c.Assert(err, jc.ErrorIsNil)
managerConfig := container.ManagerConfig{
container.ConfigName: "juju",
"log-dir": c.MkDir(),
"use-clone": "false",
}
s.api = NewFakeAPI()
s.broker, err = provisioner.NewLxcBroker(s.api, s.agentConfig, managerConfig, nil, false, 0)
c.Assert(err, jc.ErrorIsNil)
}
func (s *lxdBrokerSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
if runtime.GOOS == "windows" {
c.Skip("Skipping lxd tests on windows")
}
// To isolate the tests from the host's architecture, we override it here.
s.PatchValue(&arch.HostArch, func() string { return arch.AMD64 })
var err error
s.agentConfig, err = agent.NewAgentConfig(
agent.AgentConfigParams{
Paths: agent.NewPathsWithDefaults(agent.Paths{DataDir: "/not/used/here"}),
Tag: names.NewMachineTag("1"),
UpgradedToVersion: jujuversion.Current,
Password: "******",
Nonce: "nonce",
APIAddresses: []string{"10.0.0.1:1234"},
CACert: coretesting.CACert,
Controller: coretesting.ControllerTag,
Model: coretesting.ModelTag,
})
c.Assert(err, jc.ErrorIsNil)
s.api = NewFakeAPI()
s.manager = &fakeContainerManager{}
s.broker, err = provisioner.NewLxdBroker(s.api, s.manager, s.agentConfig)
c.Assert(err, jc.ErrorIsNil)
}
func (cfg *InstanceConfig) AgentConfig(
tag names.Tag,
toolsVersion version.Number,
) (agent.ConfigSetter, error) {
// TODO for HAState: the stateHostAddrs and apiHostAddrs here assume that
// if the instance is a stateServer then to use localhost. This may be
// sufficient, but needs thought in the new world order.
var password string
if cfg.MongoInfo == nil {
password = cfg.APIInfo.Password
} else {
password = cfg.MongoInfo.Password
}
configParams := agent.AgentConfigParams{
DataDir: cfg.DataDir,
LogDir: cfg.LogDir,
Jobs: cfg.Jobs,
Tag: tag,
UpgradedToVersion: toolsVersion,
Password: password,
Nonce: cfg.MachineNonce,
StateAddresses: cfg.stateHostAddrs(),
APIAddresses: cfg.ApiHostAddrs(),
CACert: cfg.MongoInfo.CACert,
Values: cfg.AgentEnvironment,
PreferIPv6: cfg.PreferIPv6,
Environment: cfg.APIInfo.EnvironTag,
}
if !cfg.Bootstrap {
return agent.NewAgentConfig(configParams)
}
return agent.NewStateMachineConfig(configParams, *cfg.StateServingInfo)
}
func (*suite) TestAPIInfoDoesntAddLocalhostWhenNoServingInfo(c *gc.C) {
attrParams := attributeParams
conf, err := agent.NewAgentConfig(attrParams)
c.Assert(err, gc.IsNil)
apiinfo := conf.APIInfo()
c.Assert(apiinfo.Addrs, gc.DeepEquals, attrParams.APIAddresses)
}
func (*suite) TestStateServingInfoNotAvailable(c *gc.C) {
conf, err := agent.NewAgentConfig(attributeParams)
c.Assert(err, jc.ErrorIsNil)
_, available := conf.StateServingInfo()
c.Assert(available, jc.IsFalse)
}
func (*suite) TestSetAPIHostPorts(c *gc.C) {
conf, err := agent.NewAgentConfig(attributeParams)
c.Assert(err, jc.ErrorIsNil)
addrs, err := conf.APIAddresses()
c.Assert(err, jc.ErrorIsNil)
c.Assert(addrs, gc.DeepEquals, attributeParams.APIAddresses)
// The first cloud-local address for each server is used,
// else if there are none then the first public- or unknown-
// scope address.
//
// If a server has only machine-local addresses, or none
// at all, then it will be excluded.
server1 := network.NewAddresses("0.1.2.3", "0.1.2.4", "zeroonetwothree")
server1[0].Scope = network.ScopeCloudLocal
server1[1].Scope = network.ScopeCloudLocal
server1[2].Scope = network.ScopePublic
server2 := network.NewAddresses("127.0.0.1")
server2[0].Scope = network.ScopeMachineLocal
server3 := network.NewAddresses("0.1.2.5", "zeroonetwofive")
server3[0].Scope = network.ScopeUnknown
server3[1].Scope = network.ScopeUnknown
conf.SetAPIHostPorts([][]network.HostPort{
network.AddressesWithPort(server1, 123),
network.AddressesWithPort(server2, 124),
network.AddressesWithPort(server3, 125),
})
addrs, err = conf.APIAddresses()
c.Assert(err, jc.ErrorIsNil)
c.Assert(addrs, gc.DeepEquals, []string{"0.1.2.3:123", "0.1.2.5:125"})
}
func (*suite) TestSetOldPassword(c *gc.C) {
conf, err := agent.NewAgentConfig(attributeParams)
c.Assert(err, jc.ErrorIsNil)
c.Assert(conf.OldPassword(), gc.Equals, attributeParams.Password)
conf.SetOldPassword("newoldpassword")
c.Assert(conf.OldPassword(), gc.Equals, "newoldpassword")
}
func (*suite) TestSetCACert(c *gc.C) {
conf, err := agent.NewAgentConfig(attributeParams)
c.Assert(err, jc.ErrorIsNil)
c.Assert(conf.CACert(), gc.Equals, "ca cert")
conf.SetCACert("new ca cert")
c.Assert(conf.CACert(), gc.Equals, "new ca cert")
}
func (*suite) TestAPIInfoDoesntAddLocalhostWhenNoServingInfoPreferIPv6On(c *gc.C) {
attrParams := attributeParams
attrParams.PreferIPv6 = true
conf, err := agent.NewAgentConfig(attrParams)
c.Assert(err, jc.ErrorIsNil)
apiinfo, ok := conf.APIInfo()
c.Assert(ok, jc.IsTrue)
c.Assert(apiinfo.Addrs, gc.DeepEquals, attrParams.APIAddresses)
}
func (*suite) TestSetUpgradedToVersion(c *gc.C) {
conf, err := agent.NewAgentConfig(attributeParams)
c.Assert(err, jc.ErrorIsNil)
c.Assert(conf.UpgradedToVersion(), gc.Equals, version.Current)
expectVers := version.MustParse("3.4.5")
conf.SetUpgradedToVersion(expectVers)
c.Assert(conf.UpgradedToVersion(), gc.Equals, expectVers)
}
func (*suite) TestAttributes(c *gc.C) {
conf, err := agent.NewAgentConfig(attributeParams)
c.Assert(err, gc.IsNil)
c.Assert(conf.DataDir(), gc.Equals, "/data/dir")
c.Assert(conf.SystemIdentityPath(), gc.Equals, "/data/dir/system-identity")
c.Assert(conf.Tag(), gc.Equals, "omg")
c.Assert(conf.Dir(), gc.Equals, "/data/dir/agents/omg")
c.Assert(conf.Nonce(), gc.Equals, "a nonce")
c.Assert(conf.UpgradedToVersion(), jc.DeepEquals, version.Current.Number)
}
func (s *bootstrapSuite) TestInitializeStateFailsSecondTime(c *gc.C) {
dataDir := c.MkDir()
configParams := agent.AgentConfigParams{
Paths: agent.Paths{DataDir: dataDir},
Tag: names.NewMachineTag("0"),
UpgradedToVersion: jujuversion.Current,
StateAddresses: []string{s.mgoInst.Addr()},
CACert: testing.CACert,
Password: testing.DefaultMongoPassword,
Model: testing.ModelTag,
}
cfg, err := agent.NewAgentConfig(configParams)
c.Assert(err, jc.ErrorIsNil)
cfg.SetStateServingInfo(params.StateServingInfo{
APIPort: 5555,
StatePort: s.mgoInst.Port(),
Cert: "foo",
PrivateKey: "bar",
SharedSecret: "baz",
SystemIdentity: "qux",
})
expectHW := instance.MustParseHardware("mem=2048M")
mcfg := agentbootstrap.BootstrapMachineConfig{
BootstrapConstraints: constraints.MustParse("mem=1024M"),
Jobs: []multiwatcher.MachineJob{multiwatcher.JobManageModel},
InstanceId: "i-bootstrap",
Characteristics: expectHW,
}
envAttrs := dummy.SampleConfig().Delete("admin-secret").Merge(testing.Attrs{
"agent-version": jujuversion.Current.String(),
})
envCfg, err := config.New(config.NoDefaults, envAttrs)
c.Assert(err, jc.ErrorIsNil)
hostedModelConfigAttrs := map[string]interface{}{
"name": "hosted",
"uuid": utils.MustNewUUID().String(),
}
adminUser := names.NewLocalUserTag("agent-admin")
st, _, err := agentbootstrap.InitializeState(
adminUser, cfg, envCfg, hostedModelConfigAttrs, mcfg,
mongo.DefaultDialOpts(), state.Policy(nil),
)
c.Assert(err, jc.ErrorIsNil)
st.Close()
st, _, err = agentbootstrap.InitializeState(adminUser, cfg, envCfg, nil, mcfg, mongo.DefaultDialOpts(), environs.NewStatePolicy())
if err == nil {
st.Close()
}
c.Assert(err, gc.ErrorMatches, "failed to initialize mongo admin user: cannot set admin password: not authorized .*")
}
func (*suite) TestAttributes(c *gc.C) {
conf, err := agent.NewAgentConfig(attributeParams)
c.Assert(err, jc.ErrorIsNil)
c.Assert(conf.DataDir(), gc.Equals, "/data/dir")
compareSystemIdentityPath := filepath.FromSlash("/data/dir/system-identity")
systemIdentityPath := filepath.FromSlash(conf.SystemIdentityPath())
c.Assert(systemIdentityPath, gc.Equals, compareSystemIdentityPath)
c.Assert(conf.Tag(), gc.Equals, names.NewMachineTag("1"))
c.Assert(conf.Dir(), gc.Equals, "/data/dir/agents/machine-1")
c.Assert(conf.Nonce(), gc.Equals, "a nonce")
c.Assert(conf.UpgradedToVersion(), jc.DeepEquals, version.Current)
}
func (*suite) TestWriteAndRead(c *gc.C) {
testParams := attributeParams
testParams.Paths.DataDir = c.MkDir()
testParams.Paths.LogDir = c.MkDir()
conf, err := agent.NewAgentConfig(testParams)
c.Assert(err, jc.ErrorIsNil)
c.Assert(conf.Write(), gc.IsNil)
reread, err := agent.ReadConfig(agent.ConfigPath(conf.DataDir(), conf.Tag()))
c.Assert(err, jc.ErrorIsNil)
c.Assert(reread, jc.DeepEquals, conf)
}
func (s *suite) TestAPIAddressesCannotWriteBack(c *gc.C) {
conf, err := agent.NewAgentConfig(attributeParams)
c.Assert(err, jc.ErrorIsNil)
value, err := conf.APIAddresses()
c.Assert(err, jc.ErrorIsNil)
c.Assert(value, jc.DeepEquals, []string{"localhost:1235"})
value[0] = "invalidAdr"
//Check out change hasn't gone back into the internals
newValue, err := conf.APIAddresses()
c.Assert(err, jc.ErrorIsNil)
c.Assert(newValue, jc.DeepEquals, []string{"localhost:1235"})
}
func (*suite) TestNewAgentConfig(c *gc.C) {
for i, test := range agentConfigTests {
c.Logf("%v: %s", i, test.about)
_, err := agent.NewAgentConfig(test.params)
if test.checkErr == "" {
c.Assert(err, gc.IsNil)
} else {
c.Assert(err, gc.ErrorMatches, test.checkErr)
}
}
}
func (*suite) TestNewAgentConfig(c *gc.C) {
for i, test := range agentConfigTests {
c.Logf("%v: %s", i, test.about)
config, err := agent.NewAgentConfig(test.params)
if test.checkErr == "" {
c.Assert(err, jc.ErrorIsNil)
if test.inspectConfig != nil {
test.inspectConfig(c, config)
}
} else {
c.Assert(err, gc.ErrorMatches, test.checkErr)
}
}
}
func (s *bootstrapSuite) TestInitializeStateFailsSecondTime(c *gc.C) {
dataDir := c.MkDir()
pwHash := utils.UserPasswordHash(testing.DefaultMongoPassword, utils.CompatSalt)
configParams := agent.AgentConfigParams{
Paths: agent.Paths{DataDir: dataDir},
Tag: names.NewMachineTag("0"),
UpgradedToVersion: version.Current.Number,
StateAddresses: []string{s.mgoInst.Addr()},
CACert: testing.CACert,
Password: pwHash,
Environment: testing.EnvironmentTag,
}
cfg, err := agent.NewAgentConfig(configParams)
c.Assert(err, jc.ErrorIsNil)
cfg.SetStateServingInfo(params.StateServingInfo{
APIPort: 5555,
StatePort: s.mgoInst.Port(),
Cert: "foo",
PrivateKey: "bar",
SharedSecret: "baz",
SystemIdentity: "qux",
})
expectConstraints := constraints.MustParse("mem=1024M")
expectHW := instance.MustParseHardware("mem=2048M")
mcfg := agent.BootstrapMachineConfig{
Constraints: expectConstraints,
Jobs: []multiwatcher.MachineJob{multiwatcher.JobManageEnviron},
InstanceId: "i-bootstrap",
Characteristics: expectHW,
}
envAttrs := dummy.SampleConfig().Delete("admin-secret").Merge(testing.Attrs{
"agent-version": version.Current.Number.String(),
"state-id": "1", // needed so policy can Open config
})
envCfg, err := config.New(config.NoDefaults, envAttrs)
c.Assert(err, jc.ErrorIsNil)
adminUser := names.NewLocalUserTag("agent-admin")
st, _, err := agent.InitializeState(adminUser, cfg, envCfg, mcfg, mongo.DefaultDialOpts(), environs.NewStatePolicy())
c.Assert(err, jc.ErrorIsNil)
st.Close()
st, _, err = agent.InitializeState(adminUser, cfg, envCfg, mcfg, mongo.DefaultDialOpts(), environs.NewStatePolicy())
if err == nil {
st.Close()
}
c.Assert(err, gc.ErrorMatches, "failed to initialize mongo admin user: cannot set admin password: not authorized .*")
}
func (s *bootstrapSuite) TestInitializeStateFailsSecondTime(c *gc.C) {
dataDir := c.MkDir()
pwHash := utils.UserPasswordHash(testing.DefaultMongoPassword, utils.CompatSalt)
configParams := agent.AgentConfigParams{
DataDir: dataDir,
Tag: "machine-0",
UpgradedToVersion: version.Current.Number,
StateAddresses: []string{gitjujutesting.MgoServer.Addr()},
CACert: testing.CACert,
Password: pwHash,
}
cfg, err := agent.NewAgentConfig(configParams)
c.Assert(err, gc.IsNil)
cfg.SetStateServingInfo(params.StateServingInfo{
APIPort: 5555,
StatePort: gitjujutesting.MgoServer.Port(),
Cert: "foo",
PrivateKey: "bar",
SharedSecret: "baz",
SystemIdentity: "qux",
})
expectConstraints := constraints.MustParse("mem=1024M")
expectHW := instance.MustParseHardware("mem=2048M")
mcfg := agent.BootstrapMachineConfig{
Constraints: expectConstraints,
Jobs: []params.MachineJob{params.JobHostUnits},
InstanceId: "i-bootstrap",
Characteristics: expectHW,
}
envAttrs := dummy.SampleConfig().Delete("admin-secret").Merge(testing.Attrs{
"agent-version": version.Current.Number.String(),
"state-id": "1", // needed so policy can Open config
})
envCfg, err := config.New(config.NoDefaults, envAttrs)
c.Assert(err, gc.IsNil)
st, _, err := agent.InitializeState(cfg, envCfg, mcfg, mongo.DialOpts{}, environs.NewStatePolicy())
c.Assert(err, gc.IsNil)
err = st.SetAdminMongoPassword("")
c.Check(err, gc.IsNil)
st.Close()
st, _, err = agent.InitializeState(cfg, envCfg, mcfg, mongo.DialOpts{}, environs.NewStatePolicy())
if err == nil {
st.Close()
}
c.Assert(err, gc.ErrorMatches, "failed to initialize state: cannot create log collection: unauthorized mongo access: unauthorized")
}
func (*suite) TestSetAPIHostPorts(c *gc.C) {
conf, err := agent.NewAgentConfig(attributeParams)
c.Assert(err, jc.ErrorIsNil)
addrs, err := conf.APIAddresses()
c.Assert(err, jc.ErrorIsNil)
c.Assert(addrs, gc.DeepEquals, attributeParams.APIAddresses)
// All the best candidate addresses for each server are
// used. Cloud-local addresses are preferred. Otherwise, public
// or unknown scope addresses are used.
//
// If a server has only machine-local addresses, or none
// at all, then it will be excluded.
server1 := network.NewAddresses("0.1.0.1", "0.1.0.2", "host.com")
server1[0].Scope = network.ScopeCloudLocal
server1[1].Scope = network.ScopeCloudLocal
server1[2].Scope = network.ScopePublic
server2 := network.NewAddresses("0.2.0.1", "0.2.0.2")
server2[0].Scope = network.ScopePublic
server2[1].Scope = network.ScopePublic
server3 := network.NewAddresses("127.0.0.1")
server3[0].Scope = network.ScopeMachineLocal
server4 := network.NewAddresses("0.4.0.1", "elsewhere.net")
server4[0].Scope = network.ScopeUnknown
server4[1].Scope = network.ScopeUnknown
conf.SetAPIHostPorts([][]network.HostPort{
network.AddressesWithPort(server1, 1111),
network.AddressesWithPort(server2, 2222),
network.AddressesWithPort(server3, 3333),
network.AddressesWithPort(server4, 4444),
})
addrs, err = conf.APIAddresses()
c.Assert(err, jc.ErrorIsNil)
c.Assert(addrs, gc.DeepEquals, []string{
"0.1.0.1:1111",
"0.1.0.2:1111",
"host.com:1111",
"0.2.0.1:2222",
"0.2.0.2:2222",
"0.4.0.1:4444",
"elsewhere.net:4444",
})
}
func (s *JujuConnSuite) AgentConfigForTag(c *gc.C, tag string) agent.ConfigSetter {
password, err := utils.RandomPassword()
c.Assert(err, gc.IsNil)
config, err := agent.NewAgentConfig(
agent.AgentConfigParams{
DataDir: s.DataDir(),
Tag: tag,
UpgradedToVersion: version.Current.Number,
Password: password,
Nonce: "nonce",
StateAddresses: s.StateInfo(c).Addrs,
APIAddresses: s.APIInfo(c).Addrs,
CACert: testing.CACert,
})
c.Assert(err, gc.IsNil)
return config
}
func (s *kvmBrokerSuite) SetUpTest(c *gc.C) {
s.kvmSuite.SetUpTest(c)
var err error
s.agentConfig, err = agent.NewAgentConfig(
agent.AgentConfigParams{
DataDir: "/not/used/here",
Tag: names.NewUnitTag("ubuntu/1"),
UpgradedToVersion: version.Current.Number,
Password: "******",
Nonce: "nonce",
APIAddresses: []string{"10.0.0.1:1234"},
CACert: coretesting.CACert,
})
c.Assert(err, gc.IsNil)
managerConfig := container.ManagerConfig{container.ConfigName: "juju"}
s.broker, err = provisioner.NewKvmBroker(&fakeAPI{}, s.agentConfig, managerConfig)
c.Assert(err, gc.IsNil)
}
func (s *bootstrapSuite) TestInitializeStateWithStateServingInfoNotAvailable(c *gc.C) {
configParams := agent.AgentConfigParams{
DataDir: c.MkDir(),
Tag: names.NewMachineTag("0"),
UpgradedToVersion: version.Current.Number,
StateAddresses: []string{s.mgoInst.Addr()},
CACert: testing.CACert,
Password: "******",
}
cfg, err := agent.NewAgentConfig(configParams)
c.Assert(err, gc.IsNil)
_, available := cfg.StateServingInfo()
c.Assert(available, gc.Equals, false)
_, _, err = agent.InitializeState(cfg, nil, agent.BootstrapMachineConfig{}, mongo.DialOpts{}, environs.NewStatePolicy())
// InitializeState will fail attempting to get the api port information
c.Assert(err, gc.ErrorMatches, "state serving information not available")
}
func (s *JujuConnSuite) AgentConfigForTag(c *gc.C, tag names.Tag) agent.ConfigSetter {
password, err := utils.RandomPassword()
c.Assert(err, jc.ErrorIsNil)
paths := agent.DefaultPaths
paths.DataDir = s.DataDir()
config, err := agent.NewAgentConfig(
agent.AgentConfigParams{
Paths: paths,
Tag: tag,
UpgradedToVersion: version.Current.Number,
Password: password,
Nonce: "nonce",
StateAddresses: s.MongoInfo(c).Addrs,
APIAddresses: s.APIInfo(c).Addrs,
CACert: testing.CACert,
Environment: s.State.EnvironTag(),
})
c.Assert(err, jc.ErrorIsNil)
return config
}
func (s *bootstrapSuite) TestInitializeStateWithStateServingInfoNotAvailable(c *gc.C) {
configParams := agent.AgentConfigParams{
Paths: agent.Paths{DataDir: c.MkDir()},
Tag: names.NewMachineTag("0"),
UpgradedToVersion: jujuversion.Current,
StateAddresses: []string{s.mgoInst.Addr()},
CACert: testing.CACert,
Password: "******",
Model: testing.ModelTag,
}
cfg, err := agent.NewAgentConfig(configParams)
c.Assert(err, jc.ErrorIsNil)
_, available := cfg.StateServingInfo()
c.Assert(available, jc.IsFalse)
adminUser := names.NewLocalUserTag("agent-admin")
_, _, err = agentbootstrap.InitializeState(adminUser, cfg, nil, nil, agentbootstrap.BootstrapMachineConfig{}, mongo.DefaultDialOpts(), environs.NewStatePolicy())
// InitializeState will fail attempting to get the api port information
c.Assert(err, gc.ErrorMatches, "state serving information not available")
}
func (s *kvmBrokerSuite) SetUpTest(c *gc.C) {
s.kvmSuite.SetUpTest(c)
tools := &coretools.Tools{
Version: version.MustParseBinary("2.3.4-foo-bar"),
URL: "http://tools.testing.invalid/2.3.4-foo-bar.tgz",
}
var err error
s.agentConfig, err = agent.NewAgentConfig(
agent.AgentConfigParams{
DataDir: "/not/used/here",
Tag: "tag",
UpgradedToVersion: version.Current.Number,
Password: "******",
Nonce: "nonce",
APIAddresses: []string{"10.0.0.1:1234"},
CACert: coretesting.CACert,
})
c.Assert(err, gc.IsNil)
managerConfig := container.ManagerConfig{container.ConfigName: "juju"}
s.broker, err = provisioner.NewKvmBroker(&fakeAPI{}, tools, s.agentConfig, managerConfig)
c.Assert(err, gc.IsNil)
}
func (s *migrateLocalProviderAgentConfigSuite) primeConfig(c *gc.C, st *state.State, job state.MachineJob, tag names.Tag) {
rootDir := c.MkDir()
sharedStorageDir := filepath.Join(rootDir, "shared-storage")
c.Assert(os.MkdirAll(sharedStorageDir, 0755), gc.IsNil)
localLogDir := filepath.Join(rootDir, "log")
c.Assert(os.MkdirAll(localLogDir, 0755), gc.IsNil)
initialConfig, err := agent.NewAgentConfig(agent.AgentConfigParams{
Tag: tag,
Password: "******",
CACert: testing.CACert,
StateAddresses: []string{"localhost:1111"},
DataDir: agent.DefaultDataDir,
LogDir: agent.DefaultLogDir,
UpgradedToVersion: version.MustParse("1.16.0"),
Environment: s.State.EnvironTag(),
Values: map[string]string{
"SHARED_STORAGE_ADDR": "blah",
"SHARED_STORAGE_DIR": sharedStorageDir,
},
})
c.Assert(err, jc.ErrorIsNil)
s.config = initialConfig
c.Assert(s.config.Write(), gc.IsNil)
apiState, _ := s.OpenAPIAsNewMachine(c, job)
s.ctx = &mockContext{
realAgentConfig: initialConfig,
apiState: apiState,
state: st,
}
newCfg := (map[string]interface{}{
"root-dir": rootDir,
})
err = s.State.UpdateEnvironConfig(newCfg, nil, nil)
c.Assert(err, jc.ErrorIsNil)
}
