func (s *assignCleanSuite) TestAssignUsingConstraintsToMachine(c *gc.C) {
for i, t := range assignUsingConstraintsTests {
c.Logf("test %d", i)
cons := constraints.MustParse(t.unitConstraints)
err := s.State.SetEnvironConstraints(cons)
c.Assert(err, gc.IsNil)
unit, err := s.wordpress.AddUnit()
c.Assert(err, gc.IsNil)
m, err := s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, gc.IsNil)
if t.hardwareCharacteristics != "none" {
hc := instance.MustParseHardware(t.hardwareCharacteristics)
err = m.SetProvisioned("inst-id", "fake_nonce", &hc)
c.Assert(err, gc.IsNil)
}
um, err := s.assignUnit(unit)
if t.assignOk {
c.Assert(err, gc.IsNil)
c.Assert(um.Id(), gc.Equals, m.Id())
} else {
c.Assert(um, gc.IsNil)
c.Assert(err, gc.ErrorMatches, eligibleMachinesInUse)
// Destroy the machine so it can't be used for the next test.
err = m.Destroy()
c.Assert(err, gc.IsNil)
}
}
}
func (s *firewallerSuite) TestInstanceId(c *gc.C) {
// Provision 2 machines first.
err := s.machines[0].SetProvisioned("i-am", "fake_nonce", nil)
c.Assert(err, gc.IsNil)
hwChars := instance.MustParseHardware("arch=i386", "mem=4G")
err = s.machines[1].SetProvisioned("i-am-not", "fake_nonce", &hwChars)
c.Assert(err, gc.IsNil)
args := addFakeEntities(params.Entities{Entities: []params.Entity{
{Tag: s.machines[0].Tag()},
{Tag: s.machines[1].Tag()},
{Tag: s.machines[2].Tag()},
{Tag: s.service.Tag()},
{Tag: s.units[2].Tag()},
}})
result, err := s.firewaller.InstanceId(args)
c.Assert(err, gc.IsNil)
c.Assert(result, jc.DeepEquals, params.StringResults{
Results: []params.StringResult{
{Result: "i-am"},
{Result: "i-am-not"},
{Error: apiservertesting.NotProvisionedError("2")},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.NotFoundError("machine 42")},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
}
func (s *machineConfigSuite) TestMachineConfig(c *gc.C) {
addrs := []instance.Address{instance.NewAddress("1.2.3.4", instance.NetworkUnknown)}
hc := instance.MustParseHardware("mem=4G arch=amd64")
apiParams := params.AddMachineParams{
Jobs: []params.MachineJob{params.JobHostUnits},
InstanceId: instance.Id("1234"),
Nonce: "foo",
HardwareCharacteristics: hc,
Addrs: addrs,
}
machines, err := s.APIState.Client().AddMachines([]params.AddMachineParams{apiParams})
c.Assert(err, gc.IsNil)
c.Assert(len(machines), gc.Equals, 1)
machineId := machines[0].Machine
machineConfig, err := client.MachineConfig(s.State, machineId, apiParams.Nonce, "")
c.Assert(err, gc.IsNil)
envConfig, err := s.State.EnvironConfig()
c.Assert(err, gc.IsNil)
env, err := environs.New(envConfig)
c.Assert(err, gc.IsNil)
stateInfo, apiInfo, err := env.StateInfo()
c.Assert(err, gc.IsNil)
c.Check(machineConfig.StateInfo.Addrs, gc.DeepEquals, stateInfo.Addrs)
c.Check(machineConfig.APIInfo.Addrs, gc.DeepEquals, apiInfo.Addrs)
c.Assert(machineConfig.Tools.URL, gc.Not(gc.Equals), "")
}
func (s *withoutStateServerSuite) TestMachinesWithTransientErrors(c *gc.C) {
err := s.machines[0].SetStatus(params.StatusStarted, "blah", nil)
c.Assert(err, gc.IsNil)
err = s.machines[1].SetStatus(params.StatusError, "transient error",
params.StatusData{"transient": true, "foo": "bar"})
c.Assert(err, gc.IsNil)
err = s.machines[2].SetStatus(params.StatusError, "error", params.StatusData{"transient": false})
c.Assert(err, gc.IsNil)
err = s.machines[3].SetStatus(params.StatusError, "error", nil)
c.Assert(err, gc.IsNil)
// Machine 4 is provisioned but error not reset yet.
err = s.machines[4].SetStatus(params.StatusError, "transient error",
params.StatusData{"transient": true, "foo": "bar"})
c.Assert(err, gc.IsNil)
hwChars := instance.MustParseHardware("arch=i386", "mem=4G")
err = s.machines[4].SetProvisioned("i-am", "fake_nonce", &hwChars)
c.Assert(err, gc.IsNil)
result, err := s.provisioner.MachinesWithTransientErrors()
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.StatusResults{
Results: []params.StatusResult{
{Id: "1", Life: "alive", Status: "error", Info: "transient error",
Data: params.StatusData{"transient": true, "foo": "bar"}},
},
})
}
func (s *BootstrapSuite) TestInitializeEnvironment(c *gc.C) {
hw := instance.MustParseHardware("arch=amd64 mem=8G")
machConf, cmd, err := s.initBootstrapCommand(c, nil, "--env-config", s.envcfg, "--instance-id", string(s.instanceId), "--hardware", hw.String())
c.Assert(err, gc.IsNil)
err = cmd.Run(nil)
c.Assert(err, gc.IsNil)
c.Assert(s.fakeEnsureMongo.dataDir, gc.Equals, s.dataDir)
c.Assert(s.fakeEnsureMongo.initiateCount, gc.Equals, 1)
c.Assert(s.fakeEnsureMongo.ensureCount, gc.Equals, 1)
c.Assert(s.fakeEnsureMongo.dataDir, gc.Equals, s.dataDir)
c.Assert(s.fakeEnsureMongo.withHA, jc.IsTrue)
expectInfo, exists := machConf.StateServingInfo()
c.Assert(exists, jc.IsTrue)
c.Assert(expectInfo.SharedSecret, gc.Equals, "")
servingInfo := s.fakeEnsureMongo.info
c.Assert(len(servingInfo.SharedSecret), gc.Not(gc.Equals), 0)
servingInfo.SharedSecret = ""
c.Assert(servingInfo, jc.DeepEquals, expectInfo)
expectDialAddrs := []string{fmt.Sprintf("127.0.0.1:%d", expectInfo.StatePort)}
gotDialAddrs := s.fakeEnsureMongo.initiateParams.DialInfo.Addrs
c.Assert(gotDialAddrs, gc.DeepEquals, expectDialAddrs)
memberHost := fmt.Sprintf("%s:%d", s.bootstrapName, expectInfo.StatePort)
c.Assert(s.fakeEnsureMongo.initiateParams.MemberHostPort, gc.Equals, memberHost)
c.Assert(s.fakeEnsureMongo.initiateParams.User, gc.Equals, "")
c.Assert(s.fakeEnsureMongo.initiateParams.Password, gc.Equals, "")
st, err := state.Open(&state.Info{
Addrs: []string{testing.MgoServer.Addr()},
CACert: testing.CACert,
Password: testPasswordHash(),
}, state.DefaultDialOpts(), environs.NewStatePolicy())
c.Assert(err, gc.IsNil)
defer st.Close()
machines, err := st.AllMachines()
c.Assert(err, gc.IsNil)
c.Assert(machines, gc.HasLen, 1)
instid, err := machines[0].InstanceId()
c.Assert(err, gc.IsNil)
c.Assert(instid, gc.Equals, instance.Id(string(s.instanceId)))
stateHw, err := machines[0].HardwareCharacteristics()
c.Assert(err, gc.IsNil)
c.Assert(stateHw, gc.NotNil)
c.Assert(*stateHw, gc.DeepEquals, hw)
cons, err := st.EnvironConstraints()
c.Assert(err, gc.IsNil)
c.Assert(&cons, jc.Satisfies, constraints.IsEmpty)
}
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{testing.MgoServer.Addr()},
CACert: testing.CACert,
Password: pwHash,
}
cfg, err := agent.NewAgentConfig(configParams)
c.Assert(err, gc.IsNil)
cfg.SetStateServingInfo(params.StateServingInfo{
APIPort: 5555,
StatePort: testing.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, state.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, state.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 (s *machineConfigSuite) TestMachineConfigNoTools(c *gc.C) {
s.PatchValue(&envtools.DefaultBaseURL, "")
addrs := []instance.Address{instance.NewAddress("1.2.3.4", instance.NetworkUnknown)}
hc := instance.MustParseHardware("mem=4G arch=amd64")
apiParams := params.AddMachineParams{
Series: "quantal",
Jobs: []params.MachineJob{params.JobHostUnits},
InstanceId: instance.Id("1234"),
Nonce: "foo",
HardwareCharacteristics: hc,
Addrs: addrs,
}
machines, err := s.APIState.Client().AddMachines([]params.AddMachineParams{apiParams})
c.Assert(err, gc.IsNil)
_, err = client.MachineConfig(s.State, machines[0].Machine, apiParams.Nonce, "")
c.Assert(err, gc.ErrorMatches, coretools.ErrNoMatches.Error())
}
func (s *withoutStateServerSuite) TestSetProvisioned(c *gc.C) {
// Provision machine 0 first.
hwChars := instance.MustParseHardware("arch=i386", "mem=4G")
err := s.machines[0].SetProvisioned("i-am", "fake_nonce", &hwChars)
c.Assert(err, gc.IsNil)
args := params.SetProvisioned{Machines: []params.MachineSetProvisioned{
{Tag: s.machines[0].Tag(), InstanceId: "i-was", Nonce: "fake_nonce", Characteristics: nil},
{Tag: s.machines[1].Tag(), InstanceId: "i-will", Nonce: "fake_nonce", Characteristics: &hwChars},
{Tag: s.machines[2].Tag(), InstanceId: "i-am-too", Nonce: "fake", Characteristics: nil},
{Tag: "machine-42", InstanceId: "", Nonce: "", Characteristics: nil},
{Tag: "unit-foo-0", InstanceId: "", Nonce: "", Characteristics: nil},
{Tag: "service-bar", InstanceId: "", Nonce: "", Characteristics: nil},
}}
result, err := s.provisioner.SetProvisioned(args)
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.ErrorResults{
Results: []params.ErrorResult{
{¶ms.Error{
Message: `cannot set instance data for machine "0": already set`,
}},
{nil},
{nil},
{apiservertesting.NotFoundError("machine 42")},
{apiservertesting.ErrUnauthorized},
{apiservertesting.ErrUnauthorized},
},
})
// Verify machine 1 and 2 were provisioned.
c.Assert(s.machines[1].Refresh(), gc.IsNil)
c.Assert(s.machines[2].Refresh(), gc.IsNil)
instanceId, err := s.machines[1].InstanceId()
c.Assert(err, gc.IsNil)
c.Check(instanceId, gc.Equals, instance.Id("i-will"))
instanceId, err = s.machines[2].InstanceId()
c.Assert(err, gc.IsNil)
c.Check(instanceId, gc.Equals, instance.Id("i-am-too"))
c.Check(s.machines[1].CheckProvisioned("fake_nonce"), jc.IsTrue)
c.Check(s.machines[2].CheckProvisioned("fake"), jc.IsTrue)
gotHardware, err := s.machines[1].HardwareCharacteristics()
c.Assert(err, gc.IsNil)
c.Check(gotHardware, gc.DeepEquals, &hwChars)
}
func (s *BootstrapSuite) TestSuccess(c *gc.C) {
stor := newStorage(s, c)
checkInstanceId := "i-success"
checkHardware := instance.MustParseHardware("mem=2T")
startInstance := func(
_ string, _ constraints.Value, _, _ []string, _ tools.List, mcfg *cloudinit.MachineConfig,
) (
instance.Instance, *instance.HardwareCharacteristics, []network.Info, error,
) {
return &mockInstance{id: checkInstanceId}, &checkHardware, nil, nil
}
var mocksConfig = minimalConfig(c)
var getConfigCalled int
getConfig := func() *config.Config {
getConfigCalled++
return mocksConfig
}
setConfig := func(c *config.Config) error {
mocksConfig = c
return nil
}
restore := envtesting.DisableFinishBootstrap()
defer restore()
env := &mockEnviron{
storage: stor,
startInstance: startInstance,
config: getConfig,
setConfig: setConfig,
}
originalAuthKeys := env.Config().AuthorizedKeys()
ctx := coretesting.Context(c)
err := common.Bootstrap(ctx, env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
authKeys := env.Config().AuthorizedKeys()
c.Assert(authKeys, gc.Not(gc.Equals), originalAuthKeys)
c.Assert(authKeys, jc.HasSuffix, "juju-system-key\n")
}
func (s *bootstrapSuite) TestInitializeState(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{testing.MgoServer.Addr()},
CACert: testing.CACert,
Password: pwHash,
}
servingInfo := params.StateServingInfo{
Cert: testing.ServerCert,
PrivateKey: testing.ServerKey,
APIPort: 1234,
StatePort: testing.MgoServer.Port(),
SystemIdentity: "def456",
}
cfg, err := agent.NewStateMachineConfig(configParams, servingInfo)
c.Assert(err, gc.IsNil)
_, available := cfg.StateServingInfo()
c.Assert(available, gc.Equals, true)
expectConstraints := constraints.MustParse("mem=1024M")
expectHW := instance.MustParseHardware("mem=2048M")
mcfg := agent.BootstrapMachineConfig{
Addresses: instance.NewAddresses("0.1.2.3", "zeroonetwothree"),
Constraints: expectConstraints,
Jobs: []params.MachineJob{params.JobHostUnits},
InstanceId: "i-bootstrap",
Characteristics: expectHW,
SharedSecret: "abc123",
}
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, m, err := agent.InitializeState(cfg, envCfg, mcfg, state.DialOpts{}, environs.NewStatePolicy())
c.Assert(err, gc.IsNil)
defer st.Close()
err = cfg.Write()
c.Assert(err, gc.IsNil)
// Check that initial admin user has been set up correctly.
s.assertCanLogInAsAdmin(c, pwHash)
user, err := st.User("admin")
c.Assert(err, gc.IsNil)
c.Assert(user.PasswordValid(testing.DefaultMongoPassword), jc.IsTrue)
// Check that environment configuration has been added.
newEnvCfg, err := st.EnvironConfig()
c.Assert(err, gc.IsNil)
c.Assert(newEnvCfg.AllAttrs(), gc.DeepEquals, envCfg.AllAttrs())
// Check that the bootstrap machine looks correct.
c.Assert(m.Id(), gc.Equals, "0")
c.Assert(m.Jobs(), gc.DeepEquals, []state.MachineJob{state.JobHostUnits})
c.Assert(m.Series(), gc.Equals, version.Current.Series)
c.Assert(m.CheckProvisioned(state.BootstrapNonce), jc.IsTrue)
c.Assert(m.Addresses(), gc.DeepEquals, mcfg.Addresses)
gotConstraints, err := m.Constraints()
c.Assert(err, gc.IsNil)
c.Assert(gotConstraints, gc.DeepEquals, expectConstraints)
c.Assert(err, gc.IsNil)
gotHW, err := m.HardwareCharacteristics()
c.Assert(err, gc.IsNil)
c.Assert(*gotHW, gc.DeepEquals, expectHW)
gotAddrs := m.Addresses()
c.Assert(gotAddrs, gc.DeepEquals, mcfg.Addresses)
// Check that the API host ports are initialised correctly.
apiHostPorts, err := st.APIHostPorts()
c.Assert(err, gc.IsNil)
c.Assert(apiHostPorts, gc.DeepEquals, [][]instance.HostPort{
instance.AddressesWithPort(mcfg.Addresses, 1234),
})
// Check that the state serving info is initialised correctly.
stateServingInfo, err := st.StateServingInfo()
c.Assert(err, gc.IsNil)
c.Assert(stateServingInfo, jc.DeepEquals, params.StateServingInfo{
APIPort: 1234,
StatePort: testing.MgoServer.Port(),
Cert: testing.ServerCert,
PrivateKey: testing.ServerKey,
SharedSecret: "abc123",
SystemIdentity: "def456",
})
// Check that the machine agent's config has been written
// and that we can use it to connect to the state.
newCfg, err := agent.ReadConfig(agent.ConfigPath(dataDir, "machine-0"))
c.Assert(err, gc.IsNil)
c.Assert(newCfg.Tag(), gc.Equals, "machine-0")
c.Assert(agent.Password(newCfg), gc.Not(gc.Equals), pwHash)
c.Assert(agent.Password(newCfg), gc.Not(gc.Equals), testing.DefaultMongoPassword)
info, ok := cfg.StateInfo()
c.Assert(ok, jc.IsTrue)
st1, err := state.Open(info, state.DialOpts{}, environs.NewStatePolicy())
c.Assert(err, gc.IsNil)
defer st1.Close()
}
func (s *provisionerSuite) TestSetInstanceInfo(c *gc.C) {
// Create a fresh machine, since machine 0 is already provisioned.
notProvisionedMachine, err := s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, gc.IsNil)
apiMachine, err := s.provisioner.Machine(notProvisionedMachine.Tag())
c.Assert(err, gc.IsNil)
instanceId, err := apiMachine.InstanceId()
c.Assert(err, jc.Satisfies, params.IsCodeNotProvisioned)
c.Assert(err, gc.ErrorMatches, "machine 1 is not provisioned")
c.Assert(instanceId, gc.Equals, instance.Id(""))
hwChars := instance.MustParseHardware("cpu-cores=123", "mem=4G")
_, err = s.State.Network("net1")
c.Assert(err, jc.Satisfies, errors.IsNotFound)
_, err = s.State.Network("vlan42")
c.Assert(err, jc.Satisfies, errors.IsNotFound)
ifacesMachine, err := notProvisionedMachine.NetworkInterfaces()
c.Assert(err, gc.IsNil)
c.Assert(ifacesMachine, gc.HasLen, 0)
networks := []params.Network{{
Tag: "network-net1",
ProviderId: "net1",
CIDR: "0.1.2.0/24",
VLANTag: 0,
}, {
Tag: "network-vlan42",
ProviderId: "vlan42",
CIDR: "0.2.2.0/24",
VLANTag: 42,
}, {
Tag: "network-vlan69",
ProviderId: "vlan69",
CIDR: "0.3.2.0/24",
VLANTag: 69,
}, {
Tag: "network-vlan42", // duplicated; ignored
ProviderId: "vlan42",
CIDR: "0.2.2.0/24",
VLANTag: 42,
}}
ifaces := []params.NetworkInterface{{
MACAddress: "aa:bb:cc:dd:ee:f0",
NetworkTag: "network-net1",
InterfaceName: "eth0",
IsVirtual: false,
}, {
MACAddress: "aa:bb:cc:dd:ee:f1",
NetworkTag: "network-net1",
InterfaceName: "eth1",
IsVirtual: false,
}, {
MACAddress: "aa:bb:cc:dd:ee:f1",
NetworkTag: "network-vlan42",
InterfaceName: "eth1.42",
IsVirtual: true,
}, {
MACAddress: "aa:bb:cc:dd:ee:f1",
NetworkTag: "network-vlan69",
InterfaceName: "eth1.69",
IsVirtual: true,
}, {
MACAddress: "aa:bb:cc:dd:ee:f1", // duplicated mac+net; ignored
NetworkTag: "network-vlan42",
InterfaceName: "eth2",
IsVirtual: true,
}, {
MACAddress: "aa:bb:cc:dd:ee:f4",
NetworkTag: "network-net1",
InterfaceName: "eth1", // duplicated name+machine id; ignored
IsVirtual: false,
}}
err = apiMachine.SetInstanceInfo("i-will", "fake_nonce", &hwChars, networks, ifaces)
c.Assert(err, gc.IsNil)
instanceId, err = apiMachine.InstanceId()
c.Assert(err, gc.IsNil)
c.Assert(instanceId, gc.Equals, instance.Id("i-will"))
// Try it again - should fail.
err = apiMachine.SetInstanceInfo("i-wont", "fake", nil, nil, nil)
c.Assert(err, gc.ErrorMatches, `aborted instance "i-wont": cannot set instance data for machine "1": already set`)
// Now try to get machine 0's instance id.
apiMachine, err = s.provisioner.Machine(s.machine.Tag())
c.Assert(err, gc.IsNil)
instanceId, err = apiMachine.InstanceId()
c.Assert(err, gc.IsNil)
c.Assert(instanceId, gc.Equals, instance.Id("i-manager"))
// Check the networks are created.
for i, _ := range networks {
if i == 3 {
// Last one was ignored, so skip it.
break
}
_, networkName, err := names.ParseTag(networks[i].Tag, names.NetworkTagKind)
c.Assert(err, gc.IsNil)
network, err := s.State.Network(networkName)
c.Assert(err, gc.IsNil)
c.Check(network.Name(), gc.Equals, networkName)
c.Check(network.ProviderId(), gc.Equals, networks[i].ProviderId)
c.Check(network.Tag(), gc.Equals, networks[i].Tag)
c.Check(network.VLANTag(), gc.Equals, networks[i].VLANTag)
c.Check(network.CIDR(), gc.Equals, networks[i].CIDR)
}
// And the network interfaces as well.
ifacesMachine, err = notProvisionedMachine.NetworkInterfaces()
c.Assert(err, gc.IsNil)
c.Assert(ifacesMachine, gc.HasLen, 4)
actual := make([]params.NetworkInterface, len(ifacesMachine))
for i, iface := range ifacesMachine {
actual[i].InterfaceName = iface.InterfaceName()
actual[i].NetworkTag = iface.NetworkTag()
actual[i].MACAddress = iface.MACAddress()
actual[i].IsVirtual = iface.IsVirtual()
c.Check(iface.MachineTag(), gc.Equals, notProvisionedMachine.Tag())
c.Check(iface.MachineId(), gc.Equals, notProvisionedMachine.Id())
}
c.Assert(actual, jc.SameContents, ifaces[:4]) // skip the rest as they are ignored.
}
expectedConfig: map[string]interface{}{"name": "banana"},
}, {
input: []string{
"--env-config", base64.StdEncoding.EncodeToString([]byte("name: banana\n")),
"--instance-id", "anything",
"--hardware", "nonsense",
},
err: `invalid value "nonsense" for flag --hardware: malformed characteristic "nonsense"`,
}, {
input: []string{
"--env-config", base64.StdEncoding.EncodeToString([]byte("name: banana\n")),
"--instance-id", "anything",
"--hardware", "arch=amd64 cpu-cores=4 root-disk=2T",
},
expectedInstanceId: "anything",
expectedHardware: instance.MustParseHardware("arch=amd64 cpu-cores=4 root-disk=2T"),
expectedConfig: map[string]interface{}{"name": "banana"},
},
}
func (s *BootstrapSuite) TestBootstrapArgs(c *gc.C) {
for i, t := range bootstrapArgTests {
c.Logf("test %d", i)
var args []string
args = append(args, t.input...)
_, cmd, err := s.initBootstrapCommand(c, nil, args...)
if t.err == "" {
c.Assert(cmd, gc.NotNil)
c.Assert(err, gc.IsNil)
c.Assert(cmd.EnvConfig, gc.DeepEquals, t.expectedConfig)
c.Assert(cmd.InstanceId, gc.Equals, t.expectedInstanceId)
func (s *withoutStateServerSuite) TestSetInstanceInfo(c *gc.C) {
// Provision machine 0 first.
hwChars := instance.MustParseHardware("arch=i386", "mem=4G")
err := s.machines[0].SetInstanceInfo("i-am", "fake_nonce", &hwChars, nil, nil)
c.Assert(err, gc.IsNil)
networks := []params.Network{{
Tag: "network-net1",
ProviderId: "net1",
CIDR: "0.1.2.0/24",
VLANTag: 0,
}, {
Tag: "network-vlan42",
ProviderId: "vlan42",
CIDR: "0.2.2.0/24",
VLANTag: 42,
}, {
Tag: "network-vlan69",
ProviderId: "vlan69",
CIDR: "0.3.2.0/24",
VLANTag: 69,
}, {
Tag: "network-vlan42", // duplicated; ignored
ProviderId: "vlan42",
CIDR: "0.2.2.0/24",
VLANTag: 42,
}}
ifaces := []params.NetworkInterface{{
MACAddress: "aa:bb:cc:dd:ee:f0",
NetworkTag: "network-net1",
InterfaceName: "eth0",
IsVirtual: false,
}, {
MACAddress: "aa:bb:cc:dd:ee:f1",
NetworkTag: "network-net1",
InterfaceName: "eth1",
IsVirtual: false,
}, {
MACAddress: "aa:bb:cc:dd:ee:f1",
NetworkTag: "network-vlan42",
InterfaceName: "eth1.42",
IsVirtual: true,
}, {
MACAddress: "aa:bb:cc:dd:ee:f0",
NetworkTag: "network-vlan69",
InterfaceName: "eth0.69",
IsVirtual: true,
}, {
MACAddress: "aa:bb:cc:dd:ee:f1", // duplicated mac+net; ignored
NetworkTag: "network-vlan42",
InterfaceName: "eth2",
IsVirtual: true,
}, {
MACAddress: "aa:bb:cc:dd:ee:f2",
NetworkTag: "network-net1",
InterfaceName: "eth1", // duplicated name+machine id; ignored for machine 1.
IsVirtual: false,
}}
args := params.InstancesInfo{Machines: []params.InstanceInfo{{
Tag: s.machines[0].Tag(),
InstanceId: "i-was",
Nonce: "fake_nonce",
}, {
Tag: s.machines[1].Tag(),
InstanceId: "i-will",
Nonce: "fake_nonce",
Characteristics: &hwChars,
Networks: networks,
Interfaces: ifaces,
}, {
Tag: s.machines[2].Tag(),
InstanceId: "i-am-too",
Nonce: "fake",
Characteristics: nil,
Networks: networks,
Interfaces: ifaces,
},
{Tag: "machine-42"},
{Tag: "unit-foo-0"},
{Tag: "service-bar"},
}}
result, err := s.provisioner.SetInstanceInfo(args)
c.Assert(err, gc.IsNil)
c.Assert(result, jc.DeepEquals, params.ErrorResults{
Results: []params.ErrorResult{
{¶ms.Error{
Message: `aborted instance "i-was": cannot set instance data for machine "0": already set`,
}},
{nil},
{nil},
{apiservertesting.NotFoundError("machine 42")},
{apiservertesting.ErrUnauthorized},
{apiservertesting.ErrUnauthorized},
},
})
// Verify machine 1 and 2 were provisioned.
c.Assert(s.machines[1].Refresh(), gc.IsNil)
c.Assert(s.machines[2].Refresh(), gc.IsNil)
instanceId, err := s.machines[1].InstanceId()
c.Assert(err, gc.IsNil)
c.Check(instanceId, gc.Equals, instance.Id("i-will"))
instanceId, err = s.machines[2].InstanceId()
c.Assert(err, gc.IsNil)
c.Check(instanceId, gc.Equals, instance.Id("i-am-too"))
c.Check(s.machines[1].CheckProvisioned("fake_nonce"), jc.IsTrue)
c.Check(s.machines[2].CheckProvisioned("fake"), jc.IsTrue)
gotHardware, err := s.machines[1].HardwareCharacteristics()
c.Assert(err, gc.IsNil)
c.Check(gotHardware, gc.DeepEquals, &hwChars)
ifacesMachine1, err := s.machines[1].NetworkInterfaces()
c.Assert(err, gc.IsNil)
c.Assert(ifacesMachine1, gc.HasLen, 4)
actual := make([]params.NetworkInterface, len(ifacesMachine1))
for i, iface := range ifacesMachine1 {
actual[i].InterfaceName = iface.InterfaceName()
actual[i].NetworkTag = iface.NetworkTag()
actual[i].MACAddress = iface.MACAddress()
actual[i].IsVirtual = iface.IsVirtual()
c.Check(iface.MachineId(), gc.Equals, s.machines[1].Id())
c.Check(iface.MachineTag(), gc.Equals, s.machines[1].Tag())
}
c.Assert(actual, jc.SameContents, ifaces[:4])
ifacesMachine2, err := s.machines[2].NetworkInterfaces()
c.Assert(err, gc.IsNil)
c.Assert(ifacesMachine2, gc.HasLen, 1)
c.Assert(ifacesMachine2[0].InterfaceName(), gc.Equals, ifaces[5].InterfaceName)
c.Assert(ifacesMachine2[0].MACAddress(), gc.Equals, ifaces[5].MACAddress)
c.Assert(ifacesMachine2[0].NetworkTag(), gc.Equals, ifaces[5].NetworkTag)
c.Assert(ifacesMachine2[0].MachineId(), gc.Equals, s.machines[2].Id())
for i, _ := range networks {
if i == 3 {
// Last one was ignored, so don't check.
break
}
_, networkName, err := names.ParseTag(networks[i].Tag, names.NetworkTagKind)
c.Assert(err, gc.IsNil)
network, err := s.State.Network(networkName)
c.Assert(err, gc.IsNil)
c.Check(network.Name(), gc.Equals, networkName)
c.Check(network.ProviderId(), gc.Equals, networks[i].ProviderId)
c.Check(network.Tag(), gc.Equals, networks[i].Tag)
c.Check(network.VLANTag(), gc.Equals, networks[i].VLANTag)
c.Check(network.CIDR(), gc.Equals, networks[i].CIDR)
}
}