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