func (t *Tests) TestStartStop(c *gc.C) {
e := t.Prepare(c)
t.UploadFakeTools(c, e.Storage())
cfg, err := e.Config().Apply(map[string]interface{}{
"agent-version": version.Current.Number.String(),
})
c.Assert(err, gc.IsNil)
err = e.SetConfig(cfg)
c.Assert(err, gc.IsNil)
insts, err := e.Instances(nil)
c.Assert(err, gc.IsNil)
c.Assert(insts, gc.HasLen, 0)
inst0, hc := testing.AssertStartInstance(c, e, "0")
c.Assert(inst0, gc.NotNil)
id0 := inst0.Id()
// Sanity check for hardware characteristics.
c.Assert(hc.Arch, gc.NotNil)
c.Assert(hc.Mem, gc.NotNil)
c.Assert(hc.CpuCores, gc.NotNil)
inst1, _ := testing.AssertStartInstance(c, e, "1")
c.Assert(inst1, gc.NotNil)
id1 := inst1.Id()
insts, err = e.Instances([]instance.Id{id0, id1})
c.Assert(err, gc.IsNil)
c.Assert(insts, gc.HasLen, 2)
c.Assert(insts[0].Id(), gc.Equals, id0)
c.Assert(insts[1].Id(), gc.Equals, id1)
// order of results is not specified
insts, err = e.AllInstances()
c.Assert(err, gc.IsNil)
c.Assert(insts, gc.HasLen, 2)
c.Assert(insts[0].Id(), gc.Not(gc.Equals), insts[1].Id())
err = e.StopInstances(inst0.Id())
c.Assert(err, gc.IsNil)
insts, err = e.Instances([]instance.Id{id0, id1})
c.Assert(err, gc.Equals, environs.ErrPartialInstances)
c.Assert(insts[0], gc.IsNil)
c.Assert(insts[1].Id(), gc.Equals, id1)
insts, err = e.AllInstances()
c.Assert(err, gc.IsNil)
c.Assert(insts[0].Id(), gc.Equals, id1)
}
// primeAgent adds a new Machine to run the given jobs, and sets up the
// machine agent's directory. It returns the new machine, the
// agent's configuration and the tools currently running.
func (s *commonMachineSuite) primeAgent(
c *gc.C, vers version.Binary,
jobs ...state.MachineJob) (m *state.Machine, config agent.ConfigSetterWriter, tools *tools.Tools) {
// Add a machine and ensure it is provisioned.
m, err := s.State.AddMachine("quantal", jobs...)
c.Assert(err, gc.IsNil)
inst, md := jujutesting.AssertStartInstance(c, s.Conn.Environ, m.Id())
c.Assert(m.SetProvisioned(inst.Id(), state.BootstrapNonce, md), gc.IsNil)
// Add an address for the tests in case the maybeInitiateMongoServer
// codepath is exercised.
s.setFakeMachineAddresses(c, m)
// Set up the new machine.
err = m.SetAgentVersion(vers)
c.Assert(err, gc.IsNil)
err = m.SetPassword(initialMachinePassword)
c.Assert(err, gc.IsNil)
tag := names.MachineTag(m.Id())
if m.IsManager() {
err = m.SetMongoPassword(initialMachinePassword)
c.Assert(err, gc.IsNil)
config, tools = s.agentSuite.primeStateAgent(c, tag, initialMachinePassword, vers)
info, ok := config.StateServingInfo()
c.Assert(ok, jc.IsTrue)
err = s.State.SetStateServingInfo(info)
c.Assert(err, gc.IsNil)
} else {
config, tools = s.agentSuite.primeAgent(c, tag, initialMachinePassword, vers)
}
err = config.Write()
c.Assert(err, gc.IsNil)
return m, config, tools
}
func (t *localServerSuite) TestAddresses(c *gc.C) {
env := t.Prepare(c)
envtesting.UploadFakeTools(c, env.Storage())
err := bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
inst, _ := testing.AssertStartInstance(c, env, "1")
c.Assert(err, gc.IsNil)
addrs, err := inst.Addresses()
c.Assert(err, gc.IsNil)
// Expected values use Address type but really contain a regexp for
// the value rather than a valid ip or hostname.
expected := []instance.Address{{
Value: "*.testing.invalid",
Type: instance.HostName,
NetworkScope: instance.NetworkPublic,
}, {
Value: "*.internal.invalid",
Type: instance.HostName,
NetworkScope: instance.NetworkCloudLocal,
}, {
Value: "8.0.0.*",
Type: instance.Ipv4Address,
NetworkScope: instance.NetworkPublic,
}, {
Value: "127.0.0.*",
Type: instance.Ipv4Address,
NetworkScope: instance.NetworkCloudLocal,
}}
c.Assert(addrs, gc.HasLen, len(expected))
for i, addr := range addrs {
c.Check(addr.Value, gc.Matches, expected[i].Value)
c.Check(addr.Type, gc.Equals, expected[i].Type)
c.Check(addr.NetworkScope, gc.Equals, expected[i].NetworkScope)
}
}
func (s *LiveTests) assertStartInstanceDefaultSecurityGroup(c *gc.C, useDefault bool) {
attrs := s.TestConfig.Merge(coretesting.Attrs{
"name": "sample-" + randomName(),
"control-bucket": "juju-test-" + randomName(),
"use-default-secgroup": useDefault,
})
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
// Set up a test environment.
env, err := environs.New(cfg)
c.Assert(err, gc.IsNil)
c.Assert(env, gc.NotNil)
defer env.Destroy()
// Bootstrap and start an instance.
err = bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
inst, _ := jujutesting.AssertStartInstance(c, env, "100")
// Check whether the instance has the default security group assigned.
novaClient := openstack.GetNovaClient(env)
groups, err := novaClient.GetServerSecurityGroups(string(inst.Id()))
c.Assert(err, gc.IsNil)
defaultGroupFound := false
for _, group := range groups {
if group.Name == "default" {
defaultGroupFound = true
break
}
}
c.Assert(defaultGroupFound, gc.Equals, useDefault)
}
func (t *localServerSuite) TestInstanceStatus(c *gc.C) {
env := t.Prepare(c)
envtesting.UploadFakeTools(c, env.Storage())
err := bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
t.srv.ec2srv.SetInitialInstanceState(ec2test.Terminated)
inst, _ := testing.AssertStartInstance(c, env, "1")
c.Assert(err, gc.IsNil)
c.Assert(inst.Status(), gc.Equals, "terminated")
}
func (t *localServerSuite) TestStartInstanceHardwareCharacteristics(c *gc.C) {
env := t.Prepare(c)
envtesting.UploadFakeTools(c, env.Storage())
err := bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
_, hc := testing.AssertStartInstance(c, env, "1")
c.Check(*hc.Arch, gc.Equals, "amd64")
c.Check(*hc.Mem, gc.Equals, uint64(1740))
c.Check(*hc.CpuCores, gc.Equals, uint64(1))
c.Assert(*hc.CpuPower, gc.Equals, uint64(100))
}
// TestStartStop is similar to Tests.TestStartStop except
// that it does not assume a pristine environment.
func (t *LiveTests) TestStartStop(c *gc.C) {
t.PrepareOnce(c)
t.UploadFakeTools(c, t.Env.Storage())
inst, _ := testing.AssertStartInstance(c, t.Env, "0")
c.Assert(inst, gc.NotNil)
id0 := inst.Id()
insts, err := t.Env.Instances([]instance.Id{id0, id0})
c.Assert(err, gc.IsNil)
c.Assert(insts, gc.HasLen, 2)
c.Assert(insts[0].Id(), gc.Equals, id0)
c.Assert(insts[1].Id(), gc.Equals, id0)
// Asserting on the return of AllInstances makes the test fragile,
// as even comparing the before and after start values can be thrown
// off if other instances have been created or destroyed in the same
// time frame. Instead, just check the instance we created exists.
insts, err = t.Env.AllInstances()
c.Assert(err, gc.IsNil)
found := false
for _, inst := range insts {
if inst.Id() == id0 {
c.Assert(found, gc.Equals, false, gc.Commentf("%v", insts))
found = true
}
}
c.Assert(found, gc.Equals, true, gc.Commentf("expected %v in %v", inst, insts))
dns, err := inst.WaitDNSName()
c.Assert(err, gc.IsNil)
c.Assert(dns, gc.Not(gc.Equals), "")
insts, err = t.Env.Instances([]instance.Id{id0, ""})
c.Assert(err, gc.Equals, environs.ErrPartialInstances)
c.Assert(insts, gc.HasLen, 2)
c.Check(insts[0].Id(), gc.Equals, id0)
c.Check(insts[1], gc.IsNil)
err = t.Env.StopInstances(inst.Id())
c.Assert(err, gc.IsNil)
// The machine may not be marked as shutting down
// immediately. Repeat a few times to ensure we get the error.
for a := t.Attempt.Start(); a.Next(); {
insts, err = t.Env.Instances([]instance.Id{id0})
if err != nil {
break
}
}
c.Assert(err, gc.Equals, environs.ErrNoInstances)
c.Assert(insts, gc.HasLen, 0)
}
func (s *CommonProvisionerSuite) startUnknownInstance(c *gc.C, id string) instance.Instance {
instance, _ := testing.AssertStartInstance(c, s.Conn.Environ, id)
select {
case o := <-s.op:
switch o := o.(type) {
case dummy.OpStartInstance:
default:
c.Fatalf("unexpected operation %#v", o)
}
case <-time.After(coretesting.LongWait):
c.Fatalf("timed out waiting for startinstance operation")
}
return instance
}
func (s *SSHCommonSuite) makeMachines(n int, c *gc.C, setAddresses bool) []*state.Machine {
var machines = make([]*state.Machine, n)
for i := 0; i < n; i++ {
m, err := s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, gc.IsNil)
if setAddresses {
s.setAddresses(m, c)
}
// must set an instance id as the ssh command uses that as a signal the
// machine has been provisioned
inst, md := testing.AssertStartInstance(c, s.Conn.Environ, m.Id())
c.Assert(m.SetProvisioned(inst.Id(), "fake_nonce", md), gc.IsNil)
machines[i] = m
}
return machines
}
func (t *localServerSuite) TestBootstrapInstanceUserDataAndState(c *gc.C) {
env := t.Prepare(c)
envtesting.UploadFakeTools(c, env.Storage())
err := bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
// check that the state holds the id of the bootstrap machine.
bootstrapState, err := bootstrap.LoadState(env.Storage())
c.Assert(err, gc.IsNil)
c.Assert(bootstrapState.StateInstances, gc.HasLen, 1)
insts, err := env.AllInstances()
c.Assert(err, gc.IsNil)
c.Assert(insts, gc.HasLen, 1)
c.Check(insts[0].Id(), gc.Equals, bootstrapState.StateInstances[0])
// check that the user data is configured to start zookeeper
// and the machine and provisioning agents.
// check that the user data is configured to only configure
// authorized SSH keys and set the log output; everything
// else happens after the machine is brought up.
inst := t.srv.ec2srv.Instance(string(insts[0].Id()))
c.Assert(inst, gc.NotNil)
bootstrapDNS, err := insts[0].DNSName()
c.Assert(err, gc.IsNil)
c.Assert(bootstrapDNS, gc.Not(gc.Equals), "")
userData, err := utils.Gunzip(inst.UserData)
c.Assert(err, gc.IsNil)
c.Logf("first instance: UserData: %q", userData)
var userDataMap map[interface{}]interface{}
err = goyaml.Unmarshal(userData, &userDataMap)
c.Assert(err, gc.IsNil)
c.Assert(userDataMap, jc.DeepEquals, map[interface{}]interface{}{
"output": map[interface{}]interface{}{
"all": "| tee -a /var/log/cloud-init-output.log",
},
"ssh_authorized_keys": splitAuthKeys(env.Config().AuthorizedKeys()),
"runcmd": []interface{}{
"set -xe",
"install -D -m 644 /dev/null '/var/lib/juju/nonce.txt'",
"printf '%s\\n' 'user-admin:bootstrap' > '/var/lib/juju/nonce.txt'",
},
})
// check that a new instance will be started with a machine agent
inst1, hc := testing.AssertStartInstance(c, env, "1")
c.Check(*hc.Arch, gc.Equals, "amd64")
c.Check(*hc.Mem, gc.Equals, uint64(1740))
c.Check(*hc.CpuCores, gc.Equals, uint64(1))
c.Assert(*hc.CpuPower, gc.Equals, uint64(100))
inst = t.srv.ec2srv.Instance(string(inst1.Id()))
c.Assert(inst, gc.NotNil)
userData, err = utils.Gunzip(inst.UserData)
c.Assert(err, gc.IsNil)
c.Logf("second instance: UserData: %q", userData)
userDataMap = nil
err = goyaml.Unmarshal(userData, &userDataMap)
c.Assert(err, gc.IsNil)
CheckPackage(c, userDataMap, "git", true)
CheckPackage(c, userDataMap, "mongodb-server", false)
CheckScripts(c, userDataMap, "jujud bootstrap-state", false)
CheckScripts(c, userDataMap, "/var/lib/juju/agents/machine-1/agent.conf", true)
// TODO check for provisioning agent
err = env.Destroy()
c.Assert(err, gc.IsNil)
_, err = bootstrap.LoadState(env.Storage())
c.Assert(err, gc.NotNil)
}
// startInstance starts a new instance for the given machine.
func (s *FirewallerSuite) startInstance(c *gc.C, m *state.Machine) instance.Instance {
inst, hc := testing.AssertStartInstance(c, s.Conn.Environ, m.Id())
err := m.SetProvisioned(inst.Id(), "fake_nonce", hc)
c.Assert(err, gc.IsNil)
return inst
}
func (t *LiveTests) TestGlobalPorts(c *gc.C) {
t.PrepareOnce(c)
t.UploadFakeTools(c, t.Env.Storage())
// Change configuration.
oldConfig := t.Env.Config()
defer func() {
err := t.Env.SetConfig(oldConfig)
c.Assert(err, gc.IsNil)
}()
attrs := t.Env.Config().AllAttrs()
attrs["firewall-mode"] = "global"
newConfig, err := t.Env.Config().Apply(attrs)
c.Assert(err, gc.IsNil)
err = t.Env.SetConfig(newConfig)
c.Assert(err, gc.IsNil)
// Create instances and check open ports on both instances.
inst1, _ := testing.AssertStartInstance(c, t.Env, "1")
defer t.Env.StopInstances(inst1.Id())
ports, err := t.Env.Ports()
c.Assert(err, gc.IsNil)
c.Assert(ports, gc.HasLen, 0)
inst2, _ := testing.AssertStartInstance(c, t.Env, "2")
ports, err = t.Env.Ports()
c.Assert(err, gc.IsNil)
c.Assert(ports, gc.HasLen, 0)
defer t.Env.StopInstances(inst2.Id())
err = t.Env.OpenPorts([]instance.Port{{"udp", 67}, {"tcp", 45}, {"tcp", 89}, {"tcp", 99}})
c.Assert(err, gc.IsNil)
ports, err = t.Env.Ports()
c.Assert(err, gc.IsNil)
c.Assert(ports, gc.DeepEquals, []instance.Port{{"tcp", 45}, {"tcp", 89}, {"tcp", 99}, {"udp", 67}})
// Check closing some ports.
err = t.Env.ClosePorts([]instance.Port{{"tcp", 99}, {"udp", 67}})
c.Assert(err, gc.IsNil)
ports, err = t.Env.Ports()
c.Assert(err, gc.IsNil)
c.Assert(ports, gc.DeepEquals, []instance.Port{{"tcp", 45}, {"tcp", 89}})
// Check that we can close ports that aren't there.
err = t.Env.ClosePorts([]instance.Port{{"tcp", 111}, {"udp", 222}})
c.Assert(err, gc.IsNil)
ports, err = t.Env.Ports()
c.Assert(err, gc.IsNil)
c.Assert(ports, gc.DeepEquals, []instance.Port{{"tcp", 45}, {"tcp", 89}})
// Check errors when acting on instances.
err = inst1.OpenPorts("1", []instance.Port{{"tcp", 80}})
c.Assert(err, gc.ErrorMatches, `invalid firewall mode "global" for opening ports on instance`)
err = inst1.ClosePorts("1", []instance.Port{{"tcp", 80}})
c.Assert(err, gc.ErrorMatches, `invalid firewall mode "global" for closing ports on instance`)
_, err = inst1.Ports("1")
c.Assert(err, gc.ErrorMatches, `invalid firewall mode "global" for retrieving ports from instance`)
}
func (t *LiveTests) TestPorts(c *gc.C) {
t.PrepareOnce(c)
t.UploadFakeTools(c, t.Env.Storage())
inst1, _ := testing.AssertStartInstance(c, t.Env, "1")
c.Assert(inst1, gc.NotNil)
defer t.Env.StopInstances(inst1.Id())
ports, err := inst1.Ports("1")
c.Assert(err, gc.IsNil)
c.Assert(ports, gc.HasLen, 0)
inst2, _ := testing.AssertStartInstance(c, t.Env, "2")
c.Assert(inst2, gc.NotNil)
ports, err = inst2.Ports("2")
c.Assert(err, gc.IsNil)
c.Assert(ports, gc.HasLen, 0)
defer t.Env.StopInstances(inst2.Id())
// Open some ports and check they're there.
err = inst1.OpenPorts("1", []instance.Port{{"udp", 67}, {"tcp", 45}})
c.Assert(err, gc.IsNil)
ports, err = inst1.Ports("1")
c.Assert(err, gc.IsNil)
c.Assert(ports, gc.DeepEquals, []instance.Port{{"tcp", 45}, {"udp", 67}})
ports, err = inst2.Ports("2")
c.Assert(err, gc.IsNil)
c.Assert(ports, gc.HasLen, 0)
err = inst2.OpenPorts("2", []instance.Port{{"tcp", 89}, {"tcp", 45}})
c.Assert(err, gc.IsNil)
// Check there's no crosstalk to another machine
ports, err = inst2.Ports("2")
c.Assert(err, gc.IsNil)
c.Assert(ports, gc.DeepEquals, []instance.Port{{"tcp", 45}, {"tcp", 89}})
ports, err = inst1.Ports("1")
c.Assert(err, gc.IsNil)
c.Assert(ports, gc.DeepEquals, []instance.Port{{"tcp", 45}, {"udp", 67}})
// Check that opening the same port again is ok.
oldPorts, err := inst2.Ports("2")
c.Assert(err, gc.IsNil)
err = inst2.OpenPorts("2", []instance.Port{{"tcp", 45}})
c.Assert(err, gc.IsNil)
ports, err = inst2.Ports("2")
c.Assert(err, gc.IsNil)
c.Assert(ports, gc.DeepEquals, oldPorts)
// Check that opening the same port again and another port is ok.
err = inst2.OpenPorts("2", []instance.Port{{"tcp", 45}, {"tcp", 99}})
c.Assert(err, gc.IsNil)
ports, err = inst2.Ports("2")
c.Assert(err, gc.IsNil)
c.Assert(ports, gc.DeepEquals, []instance.Port{{"tcp", 45}, {"tcp", 89}, {"tcp", 99}})
err = inst2.ClosePorts("2", []instance.Port{{"tcp", 45}, {"tcp", 99}})
c.Assert(err, gc.IsNil)
// Check that we can close ports and that there's no crosstalk.
ports, err = inst2.Ports("2")
c.Assert(err, gc.IsNil)
c.Assert(ports, gc.DeepEquals, []instance.Port{{"tcp", 89}})
ports, err = inst1.Ports("1")
c.Assert(err, gc.IsNil)
c.Assert(ports, gc.DeepEquals, []instance.Port{{"tcp", 45}, {"udp", 67}})
// Check that we can close multiple ports.
err = inst1.ClosePorts("1", []instance.Port{{"tcp", 45}, {"udp", 67}})
c.Assert(err, gc.IsNil)
ports, err = inst1.Ports("1")
c.Assert(ports, gc.HasLen, 0)
// Check that we can close ports that aren't there.
err = inst2.ClosePorts("2", []instance.Port{{"tcp", 111}, {"udp", 222}})
c.Assert(err, gc.IsNil)
ports, err = inst2.Ports("2")
c.Assert(ports, gc.DeepEquals, []instance.Port{{"tcp", 89}})
// Check errors when acting on environment.
err = t.Env.OpenPorts([]instance.Port{{"tcp", 80}})
c.Assert(err, gc.ErrorMatches, `invalid firewall mode "instance" for opening ports on environment`)
err = t.Env.ClosePorts([]instance.Port{{"tcp", 80}})
c.Assert(err, gc.ErrorMatches, `invalid firewall mode "instance" for closing ports on environment`)
_, err = t.Env.Ports()
c.Assert(err, gc.ErrorMatches, `invalid firewall mode "instance" for retrieving ports from environment`)
}
func (suite *environSuite) TestStartInstanceStartsInstance(c *gc.C) {
suite.setupFakeTools(c)
env := suite.makeEnviron()
// Create node 0: it will be used as the bootstrap node.
suite.testMAASObject.TestServer.NewNode(`{"system_id": "node0", "hostname": "host0"}`)
lshwXML, err := suite.generateHWTemplate(map[string]string{"aa:bb:cc:dd:ee:f0": "eth0"})
c.Assert(err, gc.IsNil)
suite.testMAASObject.TestServer.AddNodeDetails("node0", lshwXML)
err = bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
// The bootstrap node has been acquired and started.
operations := suite.testMAASObject.TestServer.NodeOperations()
actions, found := operations["node0"]
c.Check(found, gc.Equals, true)
c.Check(actions, gc.DeepEquals, []string{"acquire", "start"})
// Test the instance id is correctly recorded for the bootstrap node.
// Check that the state holds the id of the bootstrap machine.
stateData, err := bootstrap.LoadState(env.Storage())
c.Assert(err, gc.IsNil)
c.Assert(stateData.StateInstances, gc.HasLen, 1)
insts, err := env.AllInstances()
c.Assert(err, gc.IsNil)
c.Assert(insts, gc.HasLen, 1)
c.Check(insts[0].Id(), gc.Equals, stateData.StateInstances[0])
// Create node 1: it will be used as instance number 1.
suite.testMAASObject.TestServer.NewNode(`{"system_id": "node1", "hostname": "host1"}`)
lshwXML, err = suite.generateHWTemplate(map[string]string{"aa:bb:cc:dd:ee:f1": "eth0"})
c.Assert(err, gc.IsNil)
suite.testMAASObject.TestServer.AddNodeDetails("node1", lshwXML)
// TODO(wallyworld) - test instance metadata
instance, _ := testing.AssertStartInstance(c, env, "1")
c.Assert(err, gc.IsNil)
c.Check(instance, gc.NotNil)
// The instance number 1 has been acquired and started.
actions, found = operations["node1"]
c.Assert(found, gc.Equals, true)
c.Check(actions, gc.DeepEquals, []string{"acquire", "start"})
// The value of the "user data" parameter used when starting the node
// contains the run cmd used to write the machine information onto
// the node's filesystem.
requestValues := suite.testMAASObject.TestServer.NodeOperationRequestValues()
nodeRequestValues, found := requestValues["node1"]
c.Assert(found, gc.Equals, true)
c.Assert(len(nodeRequestValues), gc.Equals, 2)
userData := nodeRequestValues[1].Get("user_data")
decodedUserData, err := decodeUserData(userData)
c.Assert(err, gc.IsNil)
info := machineInfo{"host1"}
cloudinitRunCmd, err := info.cloudinitRunCmd()
c.Assert(err, gc.IsNil)
data, err := goyaml.Marshal(cloudinitRunCmd)
c.Assert(err, gc.IsNil)
c.Check(string(decodedUserData), gc.Matches, "(.|\n)*"+string(data)+"(\n|.)*")
// Trash the tools and try to start another instance.
envtesting.RemoveTools(c, env.Storage())
instance, _, _, err = testing.StartInstance(env, "2")
c.Check(instance, gc.IsNil)
c.Check(err, jc.Satisfies, errors.IsNotFound)
}