func (t *localServerSuite) TestStartInstanceDistributionParams(c *gc.C) { env := t.Prepare(c) err := bootstrap.Bootstrap(envtesting.BootstrapContext(c), env, bootstrap.BootstrapParams{}) c.Assert(err, jc.ErrorIsNil) mock := mockAvailabilityZoneAllocations{ result: []common.AvailabilityZoneInstances{{ZoneName: "az1"}}, } t.PatchValue(ec2.AvailabilityZoneAllocations, mock.AvailabilityZoneAllocations) // no distribution group specified testing.AssertStartInstance(c, env, "1") c.Assert(mock.group, gc.HasLen, 0) // distribution group specified: ensure it's passed through to AvailabilityZone. expectedInstances := []instance.Id{"i-0", "i-1"} params := environs.StartInstanceParams{ DistributionGroup: func() ([]instance.Id, error) { return expectedInstances, nil }, } _, err = testing.StartInstanceWithParams(env, "1", params, nil) c.Assert(err, jc.ErrorIsNil) c.Assert(mock.group, gc.DeepEquals, expectedInstances) }
func (s *environSuite) TestStartInstanceDistributionParams(c *gc.C) { env := s.bootstrap(c) var mock mockAvailabilityZoneAllocations s.PatchValue(&availabilityZoneAllocations, mock.AvailabilityZoneAllocations) // no distribution group specified s.newNode(c, "node1", "host1", nil) s.addSubnet(c, 1, 1, "node1") testing.AssertStartInstance(c, env, s.controllerUUID, "1") c.Assert(mock.group, gc.HasLen, 0) // distribution group specified: ensure it's passed through to AvailabilityZone. s.newNode(c, "node2", "host2", nil) s.addSubnet(c, 2, 2, "node2") expectedInstances := []instance.Id{"i-0", "i-1"} params := environs.StartInstanceParams{ ControllerUUID: s.controllerUUID, DistributionGroup: func() ([]instance.Id, error) { return expectedInstances, nil }, } _, err := testing.StartInstanceWithParams(env, "1", params) c.Assert(err, jc.ErrorIsNil) c.Assert(mock.group, gc.DeepEquals, expectedInstances) }
func (t *localServerSuite) bootstrapAndStartWithParams(c *gc.C, params environs.StartInstanceParams) error { env := t.Prepare(c) err := bootstrap.Bootstrap(envtesting.BootstrapContext(c), env, bootstrap.BootstrapParams{}) c.Assert(err, jc.ErrorIsNil) _, err = testing.StartInstanceWithParams(env, "1", params, nil) return err }
func (suite *maas2EnvironSuite) TestStartInstanceParams(c *gc.C) { var env *maasEnviron suite.injectController(&fakeController{ allocateMachineArgsCheck: func(args gomaasapi.AllocateMachineArgs) { c.Assert(args, gc.DeepEquals, gomaasapi.AllocateMachineArgs{ AgentName: env.ecfg().maasAgentName(), Zone: "foo", MinMemory: 8192, }) }, allocateMachine: newFakeMachine("Bruce Sterling", arch.HostArch(), ""), allocateMachineMatches: gomaasapi.ConstraintMatches{ Storage: map[string][]gomaasapi.BlockDevice{}, }, zones: []gomaasapi.Zone{&fakeZone{name: "foo"}}, }) suite.setupFakeTools(c) env = suite.makeEnviron(c, nil) params := environs.StartInstanceParams{ Placement: "zone=foo", Constraints: constraints.MustParse("mem=8G"), } result, err := testing.StartInstanceWithParams(env, "1", params) c.Assert(err, jc.ErrorIsNil) c.Assert(result.Instance.Id(), gc.Equals, instance.Id("Bruce Sterling")) }
func (s *environSuite) TestStartInstanceUnmetConstraints(c *gc.C) { env := s.bootstrap(c) s.newNode(c, "thenode1", "host1", nil) s.addSubnet(c, 1, 1, "thenode1") params := environs.StartInstanceParams{ControllerUUID: s.controllerUUID, Constraints: constraints.MustParse("mem=8G")} _, err := testing.StartInstanceWithParams(env, "1", params) c.Assert(err, gc.ErrorMatches, "cannot run instances:.* 409.*") }
func (suite *maas2EnvironSuite) TestStartInstance(c *gc.C) { env := suite.injectControllerWithSpacesAndCheck(c, nil, gomaasapi.AllocateMachineArgs{}) params := environs.StartInstanceParams{} result, err := testing.StartInstanceWithParams(env, "1", params) c.Assert(err, jc.ErrorIsNil) c.Assert(result.Instance.Id(), gc.Equals, instance.Id("Bruce Sterling")) }
func (s *environSuite) testStartInstanceAvailZone(c *gc.C, zone string) (instance.Instance, error) { env := s.bootstrap(c) params := environs.StartInstanceParams{ControllerUUID: s.controllerUUID, Placement: "zone=" + zone} result, err := testing.StartInstanceWithParams(env, "1", params) if err != nil { return nil, err } return result.Instance, nil }
func (t *localServerSuite) testStartInstanceAvailZone(c *gc.C, zone string) (instance.Instance, error) { env := t.Prepare(c) envtesting.UploadFakeTools(c, env.Storage()) err := bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{}) c.Assert(err, gc.IsNil) params := environs.StartInstanceParams{Placement: "zone=" + zone} inst, _, _, err := testing.StartInstanceWithParams(env, "1", params, nil) return inst, err }
func (s *environSuite) TestStartInstanceConstraints(c *gc.C) { env := s.bootstrap(c) s.newNode(c, "thenode1", "host1", nil) s.addSubnet(c, 1, 1, "thenode1") s.newNode(c, "thenode2", "host2", map[string]interface{}{"memory": 8192}) s.addSubnet(c, 2, 2, "thenode2") params := environs.StartInstanceParams{ControllerUUID: s.controllerUUID, Constraints: constraints.MustParse("mem=8G")} result, err := testing.StartInstanceWithParams(env, "1", params) c.Assert(err, jc.ErrorIsNil) c.Assert(*result.Hardware.Mem, gc.Equals, uint64(8192)) }
func (t *localServerSuite) testStartInstanceAvailZone(c *gc.C, zone string) (instance.Instance, error) { env := t.Prepare(c) err := bootstrap.Bootstrap(envtesting.BootstrapContext(c), env, bootstrap.BootstrapParams{}) c.Assert(err, jc.ErrorIsNil) params := environs.StartInstanceParams{Placement: "zone=" + zone} result, err := testing.StartInstanceWithParams(env, "1", params, nil) if err != nil { return nil, err } return result.Instance, nil }
func (s *environSuite) TestStartInstanceStorage(c *gc.C) { env := s.bootstrap(c) s.newNode(c, "thenode1", "host1", map[string]interface{}{ "memory": 8192, "physicalblockdevice_set": nodeStorageAttrs, "constraint_map": storageConstraintAttrs, }) s.addSubnet(c, 1, 1, "thenode1") params := environs.StartInstanceParams{ControllerUUID: s.controllerUUID, Volumes: []storage.VolumeParams{ {Tag: names.NewVolumeTag("1"), Size: 2000000}, {Tag: names.NewVolumeTag("3"), Size: 2000000}, }} result, err := testing.StartInstanceWithParams(env, "1", params) c.Assert(err, jc.ErrorIsNil) c.Check(result.Volumes, jc.DeepEquals, []storage.Volume{ { names.NewVolumeTag("1"), storage.VolumeInfo{ Size: 238475, VolumeId: "volume-1", HardwareId: "id_for_sda", }, }, { names.NewVolumeTag("3"), storage.VolumeInfo{ Size: 238475, VolumeId: "volume-3", HardwareId: "", }, }, }) c.Assert(result.VolumeAttachments, jc.DeepEquals, []storage.VolumeAttachment{ { names.NewVolumeTag("1"), names.NewMachineTag("1"), storage.VolumeAttachmentInfo{ DeviceName: "", ReadOnly: false, }, }, { names.NewVolumeTag("3"), names.NewMachineTag("1"), storage.VolumeAttachmentInfo{ DeviceName: "sdc", ReadOnly: false, }, }, }) }
func (t *localServerSuite) TestSpaceConstraintsNoPlacement(c *gc.C) { env := t.prepareAndBootstrap(c) subIDs := t.addTestingSubnets(c) // Shoule work because zone is not specified so we can resolve the constraints params := environs.StartInstanceParams{ Constraints: constraints.MustParse("spaces=aaaaaaaaaa"), SubnetsToZones: map[network.Id][]string{ subIDs[0]: []string{"test-available"}, subIDs[1]: []string{"zone3"}, }, } _, err := testing.StartInstanceWithParams(env, "1", params, nil) c.Assert(err, jc.ErrorIsNil) }
func (t *localServerSuite) TestSpaceConstraintsSpaceInPlacementZone(c *gc.C) { env := t.prepareAndBootstrap(c) subIDs := t.addTestingSubnets(c) // Should work - test-available is in SubnetsToZones and in myspace. params := environs.StartInstanceParams{ Placement: "zone=test-available", Constraints: constraints.MustParse("spaces=aaaaaaaaaa"), SubnetsToZones: map[network.Id][]string{ subIDs[0]: []string{"test-available"}, subIDs[1]: []string{"zone3"}, }, } _, err := testing.StartInstanceWithParams(env, "1", params, nil) c.Assert(err, jc.ErrorIsNil) }
func (t *localServerSuite) TestSpaceConstraintsNoAvailableSubnets(c *gc.C) { c.Skip("temporarily disabled") env := t.prepareAndBootstrap(c) subIDs := t.addTestingSubnets(c) // We requested a space, but there are no subnets in SubnetsToZones, so we can't resolve // the constraints params := environs.StartInstanceParams{ Constraints: constraints.MustParse("spaces=aaaaaaaaaa"), SubnetsToZones: map[network.Id][]string{ subIDs[0]: []string{""}, }, } _, err := testing.StartInstanceWithParams(env, "1", params, nil) c.Assert(err, gc.ErrorMatches, `unable to resolve constraints: space and/or subnet unavailable in zones \[test-available\]`) }
func (s *environSuite) TestStartInstanceUnsupportedStorage(c *gc.C) { env := s.bootstrap(c) s.newNode(c, "thenode1", "host1", map[string]interface{}{ "memory": 8192, }) s.addSubnet(c, 1, 1, "thenode1") params := environs.StartInstanceParams{Volumes: []storage.VolumeParams{ {Tag: names.NewVolumeTag("1"), Size: 2000000}, {Tag: names.NewVolumeTag("3"), Size: 2000000}, }} _, err := testing.StartInstanceWithParams(env, "1", params) c.Assert(err, gc.ErrorMatches, "requested 2 storage volumes. 0 returned.") operations := s.testMAASObject.TestServer.NodesOperations() c.Check(operations, gc.DeepEquals, []string{"acquire", "acquire", "release"}) c.Assert(s.testMAASObject.TestServer.OwnedNodes()["node0"], jc.IsTrue) c.Assert(s.testMAASObject.TestServer.OwnedNodes()["thenode1"], jc.IsFalse) }
func (t *localServerSuite) TestSpaceConstraintsSpaceNotInPlacementZone(c *gc.C) { c.Skip("temporarily disabled") env := t.prepareAndBootstrap(c) subIDs := t.addTestingSubnets(c) // Expect an error because zone test-available isn't in SubnetsToZones params := environs.StartInstanceParams{ Placement: "zone=test-available", Constraints: constraints.MustParse("spaces=aaaaaaaaaa"), SubnetsToZones: map[network.Id][]string{ subIDs[0]: []string{"zone2"}, subIDs[1]: []string{"zone3"}, subIDs[2]: []string{"zone4"}, }, } _, err := testing.StartInstanceWithParams(env, "1", params, nil) c.Assert(err, gc.ErrorMatches, `unable to resolve constraints: space and/or subnet unavailable in zones \[test-available\]`) }
func (s *environSuite) TestStartInstanceDistributionErrors(c *gc.C) { env := s.bootstrap(c) mock := mockAvailabilityZoneAllocations{ err: errors.New("AvailabilityZoneAllocations failed"), } s.PatchValue(&availabilityZoneAllocations, mock.AvailabilityZoneAllocations) _, _, _, err := testing.StartInstance(env, "1") c.Assert(err, gc.ErrorMatches, "cannot get availability zone allocations: AvailabilityZoneAllocations failed") mock.err = nil dgErr := errors.New("DistributionGroup failed") params := environs.StartInstanceParams{ DistributionGroup: func() ([]instance.Id, error) { return nil, dgErr }, } _, err = testing.StartInstanceWithParams(env, "1", params) c.Assert(err, gc.ErrorMatches, "cannot get distribution group: DistributionGroup failed") }
func (t *localServerSuite) TestStartInstanceDistributionErrors(c *gc.C) { env := t.Prepare(c) err := bootstrap.Bootstrap(envtesting.BootstrapContext(c), env, bootstrap.BootstrapParams{}) c.Assert(err, jc.ErrorIsNil) mock := mockAvailabilityZoneAllocations{ err: fmt.Errorf("AvailabilityZoneAllocations failed"), } t.PatchValue(ec2.AvailabilityZoneAllocations, mock.AvailabilityZoneAllocations) _, _, _, err = testing.StartInstance(env, "1") c.Assert(errors.Cause(err), gc.Equals, mock.err) mock.err = nil dgErr := fmt.Errorf("DistributionGroup failed") params := environs.StartInstanceParams{ DistributionGroup: func() ([]instance.Id, error) { return nil, dgErr }, } _, err = testing.StartInstanceWithParams(env, "1", params, nil) c.Assert(errors.Cause(err), gc.Equals, dgErr) }
func (t *localServerSuite) TestStartInstanceDistributionErrors(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) mock := mockBestAvailabilityZoneAllocations{ err: fmt.Errorf("BestAvailabilityZoneAllocations failed"), } t.PatchValue(openstack.BestAvailabilityZoneAllocations, mock.BestAvailabilityZoneAllocations) _, _, _, err = testing.StartInstance(env, "1") c.Assert(err, gc.Equals, mock.err) mock.err = nil dgErr := fmt.Errorf("DistributionGroup failed") params := environs.StartInstanceParams{ DistributionGroup: func() ([]instance.Id, error) { return nil, dgErr }, } _, _, _, err = testing.StartInstanceWithParams(env, "1", params, nil) c.Assert(err, gc.Equals, dgErr) }
func (t *localServerSuite) TestStartInstanceDistributionParams(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) var mock mockAvailabilityZoneAllocations t.PatchValue(openstack.AvailabilityZoneAllocations, mock.AvailabilityZoneAllocations) // no distribution group specified testing.AssertStartInstance(c, env, "1") c.Assert(mock.group, gc.HasLen, 0) // distribution group specified: ensure it's passed through to AvailabilityZone. expectedInstances := []instance.Id{"i-0", "i-1"} params := environs.StartInstanceParams{ DistributionGroup: func() ([]instance.Id, error) { return expectedInstances, nil }, } _, _, _, err = testing.StartInstanceWithParams(env, "1", params, nil) c.Assert(err, gc.IsNil) c.Assert(mock.group, gc.DeepEquals, expectedInstances) }
func (suite *maas2EnvironSuite) TestStartInstanceNetworkInterfaces(c *gc.C) { vlan0 := fakeVLAN{ id: 5001, vid: 0, mtu: 1500, } vlan50 := fakeVLAN{ id: 5004, vid: 50, mtu: 1500, } subnetPXE := fakeSubnet{ id: 3, space: "default", vlan: vlan0, gateway: "10.20.19.2", cidr: "10.20.19.0/24", dnsServers: []string{"10.20.19.2", "10.20.19.3"}, } exampleInterfaces := []gomaasapi.Interface{ &fakeInterface{ id: 91, name: "eth0", type_: "physical", enabled: true, macAddress: "52:54:00:70:9b:fe", vlan: vlan0, links: []gomaasapi.Link{ &fakeLink{ id: 436, subnet: &subnetPXE, ipAddress: "10.20.19.103", mode: "static", }, &fakeLink{ id: 437, subnet: &subnetPXE, ipAddress: "10.20.19.104", mode: "static", }, }, parents: []string{}, children: []string{"eth0.100", "eth0.250", "eth0.50"}, }, &fakeInterface{ id: 150, name: "eth0.50", type_: "vlan", enabled: true, macAddress: "52:54:00:70:9b:fe", vlan: vlan50, links: []gomaasapi.Link{ &fakeLink{ id: 517, subnet: &fakeSubnet{ id: 5, space: "admin", vlan: vlan50, gateway: "10.50.19.2", cidr: "10.50.19.0/24", dnsServers: []string{}, }, ipAddress: "10.50.19.103", mode: "static", }, }, parents: []string{"eth0"}, children: []string{}, }, } var env *maasEnviron machine := newFakeMachine("Bruce Sterling", arch.HostArch(), "") machine.interfaceSet = exampleInterfaces controller := &fakeController{ allocateMachine: machine, allocateMachineMatches: gomaasapi.ConstraintMatches{ Storage: map[string][]gomaasapi.BlockDevice{}, }, } suite.injectController(controller) suite.setupFakeTools(c) env = suite.makeEnviron(c, nil) params := environs.StartInstanceParams{} result, err := testing.StartInstanceWithParams(env, "1", params) c.Assert(err, jc.ErrorIsNil) expected := []network.InterfaceInfo{{ DeviceIndex: 0, MACAddress: "52:54:00:70:9b:fe", CIDR: "10.20.19.0/24", ProviderId: "91", ProviderSubnetId: "3", AvailabilityZones: nil, VLANTag: 0, ProviderVLANId: "5001", ProviderAddressId: "436", InterfaceName: "eth0", InterfaceType: "ethernet", Disabled: false, NoAutoStart: false, ConfigType: "static", Address: network.NewAddressOnSpace("default", "10.20.19.103"), DNSServers: network.NewAddressesOnSpace("default", "10.20.19.2", "10.20.19.3"), DNSSearchDomains: nil, MTU: 1500, GatewayAddress: network.NewAddressOnSpace("default", "10.20.19.2"), }, { DeviceIndex: 0, MACAddress: "52:54:00:70:9b:fe", CIDR: "10.20.19.0/24", ProviderId: "91", ProviderSubnetId: "3", AvailabilityZones: nil, VLANTag: 0, ProviderVLANId: "5001", ProviderAddressId: "437", InterfaceName: "eth0", InterfaceType: "ethernet", Disabled: false, NoAutoStart: false, ConfigType: "static", Address: network.NewAddressOnSpace("default", "10.20.19.104"), DNSServers: network.NewAddressesOnSpace("default", "10.20.19.2", "10.20.19.3"), DNSSearchDomains: nil, MTU: 1500, GatewayAddress: network.NewAddressOnSpace("default", "10.20.19.2"), }, { DeviceIndex: 1, MACAddress: "52:54:00:70:9b:fe", CIDR: "10.50.19.0/24", ProviderId: "150", ProviderSubnetId: "5", AvailabilityZones: nil, VLANTag: 50, ProviderVLANId: "5004", ProviderAddressId: "517", InterfaceName: "eth0.50", ParentInterfaceName: "eth0", InterfaceType: "802.1q", Disabled: false, NoAutoStart: false, ConfigType: "static", Address: network.NewAddressOnSpace("admin", "10.50.19.103"), DNSServers: nil, DNSSearchDomains: nil, MTU: 1500, GatewayAddress: network.NewAddressOnSpace("admin", "10.50.19.2"), }, } c.Assert(result.NetworkInfo, jc.DeepEquals, expected) }