def test_place_storage_constraint(self):
disk = Disk(new_id(), DISK_FLAVOR, True, True, 1024)
vm = Vm(new_id(), VM_FLAVOR, State.STARTED, None)
vm.disks = [disk]
ds_map = {"datastore_id_1": (DatastoreInfo(8 * 1024, 7 * 1024),
set([]))}
manager = PMBuilder(ds_map=ds_map).build()
manager.place(vm, None)
def test_place_cpu_constraint(self):
disk1 = Disk(new_id(), DISK_FLAVOR, True, True, 1024)
disk2 = Disk(new_id(), DISK_FLAVOR, True, True, 1024)
vm = Vm(new_id(), self._vm_flavor_gb(memory_gb=1, cpu=100),
VmPowerState.STARTED, None)
vm.disks = [disk1, disk2]
manager = PMBuilder(cpu_overcommit=1).build()
manager.place(vm, None)
def get_resource(self, vm_id):
vm = self._get_vm(vm_id)
resource = Vm(vm_id)
resource.flavor = vm.fake_vm_spec.flavor
resource.state = self._power_state_to_resource_state(vm.state)
resource.datastore = vm.fake_vm_spec.datastore
resource.environment = vm.fake_vm_spec.env
return resource
def test_place_storage_constraint(self):
disk = Disk(new_id(), DISK_FLAVOR, True, True, 1024)
vm = Vm(new_id(), VM_FLAVOR, VmPowerState.STARTED, None)
vm.disks = [disk]
ds_map = {
"datastore_id_1": (DatastoreInfo(8 * 1024, 7 * 1024), set([]))
}
manager = PMBuilder(ds_map=ds_map).build()
manager.place(vm, None)
def test_place_cpu_constraint(self):
disk1 = Disk(new_id(), DISK_FLAVOR, True, True, 1024)
disk2 = Disk(new_id(), DISK_FLAVOR, True, True, 1024)
vm = Vm(new_id(),
self._vm_flavor_gb(memory_gb=1, cpu=100),
State.STARTED, None)
vm.disks = [disk1, disk2]
manager = PMBuilder(cpu_overcommit=1).build()
manager.place(vm, None)
def test_place_memory_constraint(self):
# Try to deploy a VM with 64GB memory on a system with 64GB memory
# will fail because the memory score is 0.
# Actually if memory score is less than 5 (1 - max_usage) will be
# rejected. In this case, 60GB is also rejected.
disk1 = Disk(new_id(), DISK_FLAVOR, True, True, 1024)
disk2 = Disk(new_id(), DISK_FLAVOR, True, True, 1024)
vm = Vm(new_id(), self._vm_flavor_gb(64), VmPowerState.STARTED, None)
vm.disks = [disk1, disk2]
manager = PMBuilder().build()
manager.place(vm, None)
def test_place_memory_constraint(self):
# Try to deploy a VM with 64GB memory on a system with 64GB memory
# will fail because the memory score is 0.
# Actually if memory score is less than 5 (1 - max_usage) will be
# rejected. In this case, 60GB is also rejected.
disk1 = Disk(new_id(), DISK_FLAVOR, True, True, 1024)
disk2 = Disk(new_id(), DISK_FLAVOR, True, True, 1024)
vm = Vm(new_id(), self._vm_flavor_gb(64), State.STARTED, None)
vm.disks = [disk1, disk2]
manager = PMBuilder().build()
manager.place(vm, None)
def test_place_new_with_reservations(self, disk1_capacity, disk2_capacity,
overcommit, expected):
disk1 = Disk(new_id(), DISK_FLAVOR, True, True, disk1_capacity)
disk2 = Disk(new_id(), DISK_FLAVOR, True, True, disk2_capacity)
vm = Vm(new_id(), VM_FLAVOR, VmPowerState.STOPPED, None)
vm.disks = [disk1, disk2]
manager = PMBuilder(mem_overcommit=overcommit).build()
# Disable freespace based admission control.
manager.FREESPACE_THRESHOLD = 0
manager.reserve(vm, None)
score, placement_list = manager.place(vm, None)
assert_that(score, is_(AgentPlacementScore(*expected)))
def test_place_new_with_reservations(self, disk1_capacity, disk2_capacity,
overcommit, expected):
disk1 = Disk(new_id(), DISK_FLAVOR, True, True, disk1_capacity)
disk2 = Disk(new_id(), DISK_FLAVOR, True, True, disk2_capacity)
vm = Vm(new_id(), VM_FLAVOR, State.STOPPED, None)
vm.disks = [disk1, disk2]
manager = PMBuilder(mem_overcommit=overcommit).build()
# Disable freespace based admission control.
manager.FREESPACE_THRESHOLD = 0
manager.reserve(vm, None)
score, placement_list = manager.place(vm, None)
assert_that(score, is_(AgentPlacementScore(*expected)))
def test_place_new(self, disk_capacity_1, disk_capacity_2, overcommit,
expected):
created_disk1 = Disk(new_id(), DISK_FLAVOR, True, True,
disk_capacity_1)
created_disk2 = Disk(new_id(), DISK_FLAVOR, True, True,
disk_capacity_2)
vm = Vm(new_id(), VM_FLAVOR, VmPowerState.STOPPED, None)
vm.disks = [created_disk1, created_disk2]
manager = PMBuilder(mem_overcommit=overcommit).build()
# Disable freespace based admission control.
manager.FREESPACE_THRESHOLD = 0
score, placement_list = manager.place(vm, None)
assert_that(score, is_(AgentPlacementScore(*expected)))
def test_place_new(self, disk_capacity_1, disk_capacity_2, overcommit,
expected):
created_disk1 = Disk(new_id(), DISK_FLAVOR, True, True,
disk_capacity_1)
created_disk2 = Disk(new_id(), DISK_FLAVOR, True, True,
disk_capacity_2)
vm = Vm(new_id(), VM_FLAVOR, State.STOPPED, None)
vm.disks = [created_disk1, created_disk2]
manager = PMBuilder(mem_overcommit=overcommit).build()
# Disable freespace based admission control.
manager.FREESPACE_THRESHOLD = 0
score, placement_list = manager.place(vm, None)
assert_that(score, is_(AgentPlacementScore(*expected)))
def test_place_vm_with_network_constraint(self):
host_vm_network_list = ["net_1", "net_2", "net_3", "net_4"]
manager = PMBuilder(vm_networks=host_vm_network_list).build()
# place with resource constraints that host can match, should succeed.
resource_constraints = [
ResourceConstraint(ResourceConstraintType.NETWORK,
["net_2", "net_1"]),
ResourceConstraint(ResourceConstraintType.NETWORK, ["net_4"]),
ResourceConstraint(ResourceConstraintType.NETWORK,
["net_3", "net_5"])
]
vm = Vm(new_id(), VM_FLAVOR, VmPowerState.STOPPED, None, None, None,
None, resource_constraints)
score, placement_list = manager.place(vm, None)
assert_that(len(placement_list) is 4)
assert_that(placement_list[1].resource_id, equal_to(vm.id))
# randomly pick matched resources from host.
assert_that(
placement_list[1].container_id == 'net_1'
or placement_list[1].container_id == 'net_2', True)
assert_that(placement_list[2].container_id == 'net_4', True)
assert_that(placement_list[3].container_id == 'net_3', True)
# place with resource constraints AND logic that host can not match,
# should fail.
resource_constraints = [
ResourceConstraint(ResourceConstraintType.NETWORK,
["net_2", "net_1"]),
ResourceConstraint(ResourceConstraintType.NETWORK, ["net_5"])
]
vm = Vm(new_id(), VM_FLAVOR, VmPowerState.STOPPED, None, None, None,
None, resource_constraints)
self.assertRaises(NoSuchResourceException, manager.place, vm, None)
# place with resource constraints OR logic that host can not match,
# should fail.
resource_constraints = [
ResourceConstraint(ResourceConstraintType.NETWORK,
["net_6", "net_7"])
]
vm = Vm(new_id(), VM_FLAVOR, VmPowerState.STOPPED, None, None, None,
None, resource_constraints)
self.assertRaises(NoSuchResourceException, manager.place, vm, None)
def test_place_new_with_mem_consumed(self, mem_consumed, mem_overcommit,
expected):
vm = Vm(new_id(), VM_FLAVOR, VmPowerState.STOPPED, None)
manager = PMBuilder(mem_overcommit=mem_overcommit).build()
manager._system.host_consumed_memory_mb.return_value = mem_consumed
score, placement_list = manager.place(vm, None)
assert_that(score, is_(AgentPlacementScore(*expected)))
def test_place_new_with_cpu(self, mem_overcommit, cpu_overcommit,
expected):
vm = Vm(new_id(), VM_FLAVOR, VmPowerState.STOPPED, None)
manager = PMBuilder(mem_overcommit=mem_overcommit,
cpu_overcommit=cpu_overcommit).build()
score, placement_list = manager.place(vm, None)
assert_that(score, is_(AgentPlacementScore(*expected)))
def test_place_image_disk_best_effort(self):
ds_map = {
"datastore_id_1": (DatastoreInfo(1 * 1024, 0), set([])),
"datastore_id_2": (DatastoreInfo(2 * 1024, 0), set([]))
}
manager = PMBuilder(ds_map=ds_map).build()
image = DiskImage("disk_image1", DiskImage.COPY_ON_WRITE)
# Place a image disk that is linked cloned from image. The size
# should not be included in calculation.
disk1 = Disk(new_id(), DISK_FLAVOR, False, True, 512, image)
disk2 = Disk(new_id(), DISK_FLAVOR, False, True, 2048)
disk3 = Disk(new_id(), DISK_FLAVOR, False, True, 512)
vm = Vm(new_id(), VM_FLAVOR, VmPowerState.STOPPED, None, None,
[disk1, disk2, disk3])
score, placement_list = manager.place(vm, None)
# storage score is 1. 17/10. divided by 10 which is not optimal penalty
assert_that(score.utilization, equal_to(1))
assert_that(score.transfer, equal_to(100))
assert_that(placement_list, has_length(4))
assert_that(placement_list[0].container_id, equal_to("datastore_id_2"))
assert_that(placement_list[0].resource_id, equal_to(vm.id))
assert_that(placement_list[1].container_id, equal_to("datastore_id_2"))
assert_that(placement_list[1].resource_id, equal_to(disk2.id))
assert_that(placement_list[2].container_id, equal_to("datastore_id_1"))
assert_that(placement_list[2].resource_id, equal_to(disk3.id))
assert_that(placement_list[3].container_id, equal_to("datastore_id_1"))
assert_that(placement_list[3].resource_id, equal_to(disk1.id))
def test_place_vm_existing_image_two_matching_datastores(self):
ds_map = {
"datastore_id_1": (DatastoreInfo(8 * 1024, 0), set([])),
"datastore_id_2": (DatastoreInfo(16 * 1024, 0), set([])),
"datastore_id_3": (DatastoreInfo(15 * 1024, 0), set([]))
}
ds_with_image = ["datastore_id_1", "datastore_id_2"]
manager = PMBuilder(ds_map=ds_map, ds_with_image=ds_with_image).build()
total_storage = sum(t[0].total for t in ds_map.values())
image = DiskImage("disk_image", DiskImage.COPY_ON_WRITE)
# disk1 and disk2 both take 1/100
disk1 = Disk(new_id(), DISK_FLAVOR, False, True, total_storage / 100,
image)
disk2 = Disk(new_id(), DISK_FLAVOR, False, True, total_storage / 100,
image)
vm = Vm(new_id(), self._vm_flavor_mb(1), VmPowerState.STOPPED, None,
None, [disk1, disk2])
score, placement_list = manager.place(vm, None)
# There are 2 disk of approx size 1/100 of avail space
# the score should be 98
assert_that(score, is_(AgentPlacementScore(98, 100)))
base_index = 0
assert_that(placement_list[base_index].resource_id, is_(vm.id))
assert_that(placement_list[base_index].container_id,
is_("datastore_id_2"))
base_index += 1
assert_that(placement_list[base_index].resource_id, is_(disk1.id))
assert_that(placement_list[base_index + 1].resource_id, is_(disk2.id))
assert_that(placement_list[base_index].container_id,
is_("datastore_id_2"))
assert_that(placement_list[base_index + 1].container_id,
is_("datastore_id_2"))
def test_place_large_disks_image_datastore(self):
ds_map = {"datastore_id_1": (DatastoreInfo(3 * 1024, 0), set([]))}
ds_with_image = ["datastore_id_1", "datastore_id_2"]
total_storage = sum(t[0].total for t in ds_map.values())
manager = PMBuilder(ds_map=ds_map, ds_with_image=ds_with_image).build()
# Disable freespace based admission control.
manager.FREESPACE_THRESHOLD = 0
disk1 = Disk(new_id(), DISK_FLAVOR, False, True, 1024)
disk2 = Disk(new_id(), DISK_FLAVOR, False, True, 1024)
disk_list = [disk1, disk2]
used_storage = sum(disk.capacity_gb for disk in disk_list)
vm = Vm(new_id(), VM_FLAVOR, VmPowerState.STOPPED, None, None,
disk_list)
disks = None
score, placement_list = manager.place(vm, disks)
expected_score = 100 * (total_storage - used_storage) / total_storage
assert_that(score, is_(AgentPlacementScore(expected_score, 100)))
base_index = 0
assert_that(placement_list[base_index].resource_id, is_(vm.id))
assert_that(placement_list[base_index].container_id,
is_("datastore_id_1"))
base_index += 1
assert_that(placement_list[base_index].resource_id, is_(disk1.id))
assert_that(placement_list[base_index + 1].resource_id, is_(disk2.id))
assert_that(placement_list[base_index].container_id,
is_("datastore_id_1"))
assert_that(placement_list[base_index + 1].container_id,
is_("datastore_id_1"))
def test_reserved_resources(self):
manager = PMBuilder().build()
disk = Disk(new_id(), DISK_FLAVOR, True, True, 1024)
vm = Vm(new_id(), VM_FLAVOR, VmPowerState.STARTED)
reservations = []
for _ in range(3):
reservations.append(manager.reserve(vm, [disk]))
assert_that(manager._storage_reserved(),
equal_to(disk.capacity_gb * len(reservations)))
assert_that(
manager._memory_reserved(),
equal_to(manager._vm_memory_mb(vm) * len(reservations)))
for rid in reservations:
manager.remove_disk_reservation(rid)
manager.remove_vm_reservation(rid)
assert_that(manager._storage_reserved(), equal_to(0))
assert_that(manager._memory_reserved(), equal_to(0))
# test that reserve sums as expected if vm or disks is None
rid = manager.reserve(vm, None)
assert_that(manager._storage_reserved(), equal_to(0))
assert_that(manager._memory_reserved(),
equal_to(manager._vm_memory_mb(vm)))
manager.remove_vm_reservation(rid)
rid = manager.reserve(None, [disk])
assert_that(manager._storage_reserved(), equal_to(disk.capacity_gb))
assert_that(manager._memory_reserved(), equal_to(0))
manager.remove_disk_reservation(rid)
def test_place_vm_no_disks(self):
manager = PMBuilder().build()
vm = Vm(new_id(), VM_FLAVOR, VmPowerState.STOPPED, None, None, None)
score, placement_list = manager.place(vm, None)
assert_that(score, is_(AgentPlacementScore(97, 100)))
assert_that(len(placement_list) is 1)
assert_that(placement_list[0].resource_id, equal_to(vm.id))
assert_that(placement_list[0].container_id, equal_to('datastore_id_1'))
def test_place_vm_non_existing_image(self, image_size, expected):
manager = PMBuilder(ds_with_image=[], image_size=image_size).build()
image = DiskImage("disk_image", DiskImage.COPY_ON_WRITE)
disk = Disk(new_id(), DISK_FLAVOR, False, True, 1024, image)
vm = Vm(new_id(), VM_FLAVOR, VmPowerState.STOPPED, None, None, [disk])
score, placement_list = manager.place(vm, None)
# Image size is 2GB, 50% of 1GB, so transfer score is
assert_that(score.transfer, is_(expected))
assert_that(placement_list, has_length(2)) # vm and disk
def test_placement_vm_on_image_datastore(self, use_image_ds, use_vm):
ds_map = {
"datastore_id_1": (DatastoreInfo(7 * 1024, 0), set([])),
"datastore_id_2": (DatastoreInfo(8 * 1024, 0), set([])),
"image_datastore": (DatastoreInfo(16 * 1024, 0), set([]))
}
manager = PMBuilder(im_ds_for_vm=use_image_ds,
image_ds="image_datastore",
ds_map=ds_map).build()
image = DiskImage("disk_image", DiskImage.FULL_COPY)
disk1 = Disk(new_id(), DISK_FLAVOR, False, True, 7 * 1024, image)
disk2 = Disk(new_id(), DISK_FLAVOR, False, True, 7 * 1024, image)
disk3 = Disk(new_id(), DISK_FLAVOR, False, True, 7 * 1024, image)
disk4 = Disk(new_id(), DISK_FLAVOR, False, True, 7 * 1024, image)
disk_list = [disk1, disk2, disk3, disk4]
if use_vm:
vm = Vm(new_id(), VM_FLAVOR, State.STOPPED, None, None, disk_list)
disks = None
else:
vm = None
disks = disk_list
if not use_image_ds:
self.assertRaises(NotEnoughDatastoreCapacityException,
manager.place, vm, disks)
else:
(score, placement_list) = manager.place(vm, disks)
container_ids = [item.container_id for item in placement_list]
resource_ids = [item.resource_id for item in placement_list]
if use_vm:
assert_that(
container_ids,
contains(
"image_datastore", # vm
"image_datastore", # 16T, 8T, 7T
"image_datastore", # 9T, 8T, 7T
"datastore_id_2", # 2T, 8T, 7T
"datastore_id_1")) # 2T, 1T, 7T
assert_that(
resource_ids,
contains(vm.id, disk1.id, disk2.id, disk3.id, disk4.id))
else:
assert_that(
container_ids,
contains(
"image_datastore", # 16T, 8T, 7T
"image_datastore", # 9T, 8T, 7T
"datastore_id_2", # 2T, 8T, 7T
"datastore_id_1")) # 2T, 1T, 7T
assert_that(resource_ids,
contains(disk1.id, disk2.id, disk3.id, disk4.id))
def _get_resource_from_vmcache(self, vmcache):
"""Translate to vm resource from vm cache
"""
vm_resource = Vm(vmcache.name)
vm_resource.flavor = Flavor("default") # TODO
vm_resource.disks = []
for disk in vmcache.disks:
disk_id = os.path.splitext(os.path.basename(disk))[0]
datastore_name = self._get_datastore_name_from_ds_path(disk)
datastore_uuid = self._get_datastore_uuid(datastore_name)
if datastore_uuid:
disk_resource = Disk(disk_id, Flavor("default"), False,
False, -1, None, datastore_uuid)
vm_resource.disks.append(disk_resource)
vm_resource.state = vmcache.power_state
datastore_name = self._get_datastore_name_from_ds_path(vmcache.path)
vm_resource.datastore = self._get_datastore_uuid(datastore_name)
return vm_resource
def test_place_large_disks(self, use_vm):
ds_map = {
"datastore_id_1": (DatastoreInfo(1 * 1024, 0), set([])),
"datastore_id_2": (DatastoreInfo(2 * 1024, 0), set([])),
"datastore_id_3": (DatastoreInfo(3 * 1024, 0), set([]))
}
ds_with_image = ["datastore_id_3"]
total_storage = sum(t[0].total for t in ds_map.values())
manager = PMBuilder(ds_map=ds_map, ds_with_image=ds_with_image).build()
image = DiskImage("disk_image", DiskImage.FULL_COPY)
disk1 = Disk(new_id(), DISK_FLAVOR, False, True, 1024, image)
disk2 = Disk(new_id(), DISK_FLAVOR, False, True, 1024, image)
disk3 = Disk(new_id(), DISK_FLAVOR, False, True, 1024, image)
disk4 = Disk(new_id(), DISK_FLAVOR, False, True, 1024, image)
disk_list = [disk1, disk2, disk3, disk4]
used_storage = sum(disk.capacity_gb for disk in disk_list)
if use_vm:
vm = Vm(new_id(), VM_FLAVOR, State.STOPPED, None, None, disk_list)
disks = None
else:
vm = None
disks = disk_list
score, placement_list = manager.place(vm, disks)
# optimal placement cannot be achieved,
# divide the expected score by NOT_OPTIMAL_DIVIDE_FACTOR
expected_score = 100 * (total_storage - used_storage) / \
total_storage / PlacementManager.NOT_OPTIMAL_DIVIDE_FACTOR
assert_that(score, is_(AgentPlacementScore(expected_score, 100)))
base_index = 0
if vm:
assert_that(placement_list[base_index].resource_id, is_(vm.id))
assert_that(placement_list[base_index].container_id,
is_("datastore_id_3"))
base_index += 1
assert_that(placement_list[base_index].resource_id, is_(disk1.id))
assert_that(placement_list[base_index + 1].resource_id, is_(disk2.id))
assert_that(placement_list[base_index + 2].resource_id, is_(disk3.id))
assert_that(placement_list[base_index + 3].resource_id, is_(disk4.id))
assert_that(placement_list[base_index].container_id,
is_("datastore_id_3"))
assert_that(placement_list[base_index + 1].container_id,
is_("datastore_id_3"))
assert_that(placement_list[base_index + 2].container_id,
is_("datastore_id_3"))
assert_that(placement_list[base_index + 3].container_id,
is_("datastore_id_2"))
def get_resource(self, vm_id):
vm = self._get_vm(vm_id)
resource = Vm(vm_id)
resource.flavor = vm.fake_vm_spec.flavor
resource.state = self._power_state_to_resource_state(vm.state)
resource.datastore = vm.fake_vm_spec.datastore
resource.environment = vm.fake_vm_spec.env
return resource
def test_place_image_disk_not_included(self):
ds_map = {"datastore_id_1": (DatastoreInfo(1 * 1024, 0), set([]))}
manager = PMBuilder(ds_map=ds_map).build()
image = DiskImage("disk_image1", DiskImage.COPY_ON_WRITE)
# Place a image disk that is linked cloned from image. The size
# should not be included in calculation.
disk = Disk(new_id(), DISK_FLAVOR, False, True, 2048, image)
vm = Vm(new_id(), VM_FLAVOR, State.STOPPED, None, None, [disk])
score, placement_list = manager.place(vm, None)
assert_that(score.utilization, equal_to(97))
assert_that(score.transfer, equal_to(100))
assert_that(placement_list, has_length(2))
assert_that(placement_list[0].container_id, equal_to("datastore_id_1"))
assert_that(placement_list[0].resource_id, equal_to(vm.id))
assert_that(placement_list[1].container_id, equal_to("datastore_id_1"))
assert_that(placement_list[1].resource_id, equal_to(disk.id))
# Try the same place with constraints
constraint = ResourceConstraint(ResourceConstraintType.DATASTORE,
["datastore_id_1"])
disk = Disk(new_id(),
DISK_FLAVOR,
False,
True,
2048,
image,
constraints=[constraint])
vm = Vm(new_id(), VM_FLAVOR, State.STOPPED, None, None, [disk])
score, placement_list = manager.place(vm, None)
assert_that(score.utilization, equal_to(97))
assert_that(score.transfer, equal_to(100))
assert_that(placement_list, has_length(2))
assert_that(placement_list[0].container_id, equal_to("datastore_id_1"))
assert_that(placement_list[0].resource_id, equal_to(vm.id))
assert_that(placement_list[1].container_id, equal_to("datastore_id_1"))
assert_that(placement_list[1].resource_id, equal_to(disk.id))
def test_place_vm_in_no_image_datastore(self):
ds_map = {
"datastore_id_1": (DatastoreInfo(8 * 1024, 0), set([])),
"datastore_id_2": (DatastoreInfo(8 * 1024, 0), set([])),
"datastore_id_3": (DatastoreInfo(16 * 1024, 0), set([]))
}
ds_with_image = ["datastore_id_1", "datastore_id_2"]
manager = PMBuilder(ds_map=ds_map,
ds_with_image=ds_with_image,
image_size=100 * 1024 * 1024).build()
total_storage = sum(t[0].total for t in ds_map.values())
image = DiskImage("disk_image", DiskImage.COPY_ON_WRITE)
# disk1 and disk2 both take 1/100
disk1 = Disk(new_id(), DISK_FLAVOR, False, True, total_storage / 100,
image)
disk2 = Disk(new_id(), DISK_FLAVOR, False, True, total_storage / 100)
vm = Vm(new_id(), self._vm_flavor_mb(1), VmPowerState.STOPPED, None,
None, [disk1, disk2])
score, placement_list = manager.place(vm, None)
# disk1 and disk2 both take 1% space, so utilization score is 98
# image takes 100MB, which is 10% of 1GB, so transfer score is 90
assert_that(score, is_(AgentPlacementScore(98, 90)))
assert_that(placement_list, has_length(3))
for placement in placement_list:
assert_that(placement.container_id, is_("datastore_id_3"))
# no other datastores except only image datastore available,
# and use_image_datastore_for_vms:False, thus should fail.
ds_map = {"image_datastore": (DatastoreInfo(8 * 1024, 0), set())}
manager = PMBuilder(ds_map=ds_map, im_ds_for_vm=False).build()
# vm with disks
self.assertRaises(NoSuchResourceException, manager.place, vm, None)
# vm without disks
vm = Vm(new_id(), VM_FLAVOR, VmPowerState.STOPPED)
self.assertRaises(NoSuchResourceException, manager.place, vm, None)
def test_place_disks_with_threshold(self, threshold, expected):
ds_map = {"datastore_id_1": (DatastoreInfo(1 * 1024, 0), set([]))}
manager = PMBuilder(ds_map=ds_map).build()
manager.FREESPACE_THRESHOLD = threshold
disk1 = Disk(new_id(), DISK_FLAVOR, False, True, 512, None)
disk_list = [disk1]
vm = Vm(new_id(), VM_FLAVOR, VmPowerState.STOPPED, None, None,
disk_list)
disks = None
score, placement_list = manager.place(vm, disks)
# optimal placement cannot be achieved,
# divide the expected score by NOT_OPTIMAL_DIVIDE_FACTOR
assert_that(score, is_(AgentPlacementScore(expected, 100)))
def test_place_vm_with_virtual_network_constraint(self):
manager = PMBuilder().build()
# place with resource constraints that come back in placement_list.
resource_constraints = [
ResourceConstraint(ResourceConstraintType.VIRTUAL_NETWORK,
["virtual_net"])
]
vm = Vm(new_id(), VM_FLAVOR, VmPowerState.STOPPED, None, None, None,
None, resource_constraints)
score, placement_list = manager.place(vm, None)
assert_that(len(placement_list) is 2)
assert_that(placement_list[1].resource_id, equal_to(vm.id))
assert_that(placement_list[1].container_id == 'virtual_net', True)
def test_place_vm_fail_disk_too_large(self):
ds_map = {
"datastore_id_1": (DatastoreInfo(1 * 1024, 0), set([])),
"datastore_id_2": (DatastoreInfo(2 * 1024, 0), set([])),
"datastore_id_3": (DatastoreInfo(3 * 1024, 0), set([]))
}
ds_with_image = ["datastore_id_1", "datastore_id_2"]
manager = PMBuilder(ds_map=ds_map, ds_with_image=ds_with_image).build()
disk1 = Disk(new_id(), DISK_FLAVOR, False, True, 2 * 1024)
disk2 = Disk(new_id(), DISK_FLAVOR, False, True, 2 * 1024)
disk3 = Disk(new_id(), DISK_FLAVOR, False, True, 2 * 1024)
disk4 = Disk(new_id(), DISK_FLAVOR, False, True, 2 * 1024)
disk_list = [disk1, disk2, disk3, disk4]
vm = Vm(new_id(), VM_FLAVOR, VmPowerState.STOPPED, None, None,
disk_list)
disks = None
manager.place(vm, disks)
def _get_resource_from_vmcache(self, vmcache):
"""Translate to vm resource from vm cache
"""
vm_resource = Vm(vmcache.name)
vm_resource.flavor = Flavor("default") # TODO
vm_resource.disks = []
for disk in vmcache.disks:
disk_id = os.path.splitext(os.path.basename(disk))[0]
datastore_name = self._get_datastore_name_from_ds_path(disk)
datastore_uuid = self._get_datastore_uuid(datastore_name)
if datastore_uuid:
disk_resource = Disk(disk_id, Flavor("default"), False, False,
-1, None, datastore_uuid)
vm_resource.disks.append(disk_resource)
vm_resource.state = vmcache.power_state
datastore_name = self._get_datastore_name_from_ds_path(vmcache.path)
vm_resource.datastore = self._get_datastore_uuid(datastore_name)
return vm_resource
def test_empty_disk_place(self, overcommit, vm_memory, expected):
vm = Vm(new_id(), self._vm_flavor_gb(vm_memory), VmPowerState.STOPPED,
None)
manager = PMBuilder(mem_overcommit=overcommit).build()
score, placement_list = manager.place(vm, None)
assert_that(score, is_(AgentPlacementScore(*expected)))
