def test_reserve_disk(self, constraint_value, placement_id, expected):
disk_id = "disk_id_1"
disk_flavor = "disk_flavor_1"
def reserve_disk_validate(vm, disks):
assert_that(vm is None)
assert isinstance(disks, list)
assert_that(len(disks) is 1)
disk = disks[0]
assert isinstance(disk, HostDisk)
assert_that(disk.id, equal_to(disk_id))
assert_that(disk.flavor.name, equal_to(disk_flavor))
reserve_constraints = disk.constraints
if reserve_constraints:
assert isinstance(reserve_constraints, list)
assert_that(len(reserve_constraints) is 1)
reserve_constraint = reserve_constraints[0]
assert_that(
reserve_constraint.type is ResourceConstraintType.DATASTORE
)
assert_that(reserve_constraint.values, equal_to([
expected,
]))
reserve_placement = disk.placement
if reserve_placement:
assert_that(
reserve_placement.type is ResourcePlacementType.DISK)
assert_that(reserve_placement.resource_id, equal_to(disk_id))
assert_that(reserve_placement.container_id, equal_to(expected))
return "reservation_id"
handler = HostHandler(MagicMock())
mocked_reserve = MagicMock()
mocked_reserve.side_effect = reserve_disk_validate
handler.hypervisor.placement_manager = MagicMock()
handler.hypervisor.placement_manager.reserve = mocked_reserve
constraints = None
placement_list = None
if constraint_value:
constraint = ResourceConstraint()
constraint.values = [constraint_value]
constraint.type = ResourceConstraintType.DATASTORE
constraints = [constraint]
if placement_id:
placement = ResourcePlacement()
placement.type = ResourcePlacementType.DISK
placement.container_id = placement_id
placement.resource_id = disk_id
placement_list = ResourcePlacementList([placement])
flavor_info = Flavor(name=disk_flavor,
cost=[QuotaLineItem("a", "b", 1)])
disk = Disk(id=disk_id,
flavor=disk_flavor,
persistent=True,
new_disk=True,
capacity_gb=2,
flavor_info=flavor_info,
resource_constraints=constraints)
request = ReserveRequest()
request.generation = 1
request.resource = Resource(vm=None,
disks=[disk],
placement_list=placement_list)
response = handler.reserve(request)
assert_that(response.result, equal_to(ReserveResultCode.OK))
def to_thrift(self):
thrift_list = \
[entry.to_thrift() for entry in self.placements]
return ResourcePlacementList(thrift_list)
def test_reserve_vm(self):
disk_ids = ["disk_id_1", "disk_id_2", "disk_id_3"]
datastore_ids = ["datastore_1", "datastore_2", "datastore_3"]
disk_flavor = "disk_flavor_1"
networks = ["net_1", "net_2"]
vm_flavor = "vm_flavor_1"
vm_id = "vm_id_1"
def reserve_vm_validate(vm, disks):
assert_that(vm)
assert_that(not disks)
assert_that(vm.id, equal_to(vm_id))
# Check VM placement
vm_placement = vm.placement
assert_that(vm_placement is not None)
assert_that(vm_placement.type is ResourcePlacementType.VM)
assert_that(vm_placement.resource_id, equal_to(vm_id))
assert_that(vm_placement.container_id, equal_to(datastore_ids[0]))
# Check VM networks
vm_networks = vm.networks
assert_that(vm_networks is not None)
assert_that(set(networks), equal_to(set(vm_networks)))
disks = vm.disks
assert_that(len(disks) is 3)
disk_index = 0
for vm_disk in disks:
assert_that(vm_disk.id, equal_to(disk_ids[disk_index]))
assert_that(vm_disk.placement is not None)
disk_placement = vm_disk.placement
assert_that(disk_placement.type is ResourcePlacementType.DISK)
assert_that(disk_placement.resource_id, equal_to(vm_disk.id))
assert_that(disk_placement.container_id,
equal_to(datastore_ids[disk_index]))
disk_index += 1
return "reservation_id"
handler = HostHandler(MagicMock())
mocked_reserve = MagicMock()
mocked_reserve.side_effect = reserve_vm_validate
handler.hypervisor.placement_manager = MagicMock()
handler.hypervisor.placement_manager.reserve = mocked_reserve
placements = []
# Add VM placement info
placement = ResourcePlacement()
placement.type = ResourcePlacementType.VM
placement.resource_id = vm_id
placement.container_id = datastore_ids[0]
placements.append(placement)
# Add Network placement info : net_1
placement = ResourcePlacement()
placement.type = ResourcePlacementType.NETWORK
placement.resource_id = vm_id
placement.container_id = networks[0]
placements.append(placement)
# Add Network placement info : net_2
placement = ResourcePlacement()
placement.type = ResourcePlacementType.NETWORK
placement.resource_id = vm_id
placement.container_id = networks[1]
placements.append(placement)
# Add disks placement info
index = 0
for disk_id in disk_ids:
placement = ResourcePlacement()
placement.type = ResourcePlacementType.DISK
placement.container_id = datastore_ids[index]
index += 1
placement.resource_id = disk_id
placements.append(placement)
placement_list = ResourcePlacementList(placements)
disk_flavor_info = Flavor(name=disk_flavor,
cost=[QuotaLineItem("size", "1", 1)])
disks = []
for disk_id in disk_ids:
disk = Disk(id=disk_id,
flavor=disk_flavor,
persistent=True,
new_disk=True,
capacity_gb=2,
flavor_info=disk_flavor_info)
disks.append(disk)
vm_flavor_info = Flavor(name=vm_flavor,
cost=[QuotaLineItem("cpu", "1", 5)])
vm = Vm(vm_id, vm_flavor, State.STOPPED, None, None, disks,
vm_flavor_info)
request = ReserveRequest()
request.generation = 1
request.resource = Resource(vm=vm,
disks=None,
placement_list=placement_list)
response = handler.reserve(request)
assert_that(response.result, equal_to(ReserveResultCode.OK))
# test reserve under entering-maintenance-mode and maintenance mode
state = common.services.get(ServiceName.MODE)
state.set_mode(MODE.ENTERING_MAINTENANCE)
request = MagicMock()
response = handler.reserve(request)
assert_that(response.result,
equal_to(ReserveResultCode.OPERATION_NOT_ALLOWED))
state.set_mode(MODE.MAINTENANCE)
response = handler.reserve(request)
assert_that(response.result,
equal_to(ReserveResultCode.OPERATION_NOT_ALLOWED))