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) }