def test_constraint_place_engine_conflicting_constraints(self):
""" constraint place engine should fail if multiple constraints conflict
"""
# Create constraint place engine
image_datastore = "ds1"
image_datastores = [{"name": image_datastore, "used_for_vms": True}]
option = PlacementOption(1, 1, image_datastores)
ds_map = {
image_datastore: DatastoreInfo(10, 0),
"ds2": DatastoreInfo(20, 0)
}
ds_mgr = self.create_datastore_manager(ds_map, image_datastores)
engine = ConstraintDiskPlaceEngine(ds_mgr, option)
ds = engine.placeable_datastores()
selector = DatastoreSelector.init_datastore_selector(ds_mgr, ds)
# Try place
constraints = [
ResourceConstraint(ResourceConstraintType.DATASTORE, ["ds1"]),
ResourceConstraint(ResourceConstraintType.DATASTORE, ["ds2"])
]
disk = Disk(disk_id="ds1", capacity_gb=1)
place_result = engine.place(DisksPlacement([disk], selector),
constraints)
# Verify place result
assert_that(place_result.result,
equal_to(PlaceResultCode.NO_SUCH_RESOURCE))
def test_constraint_place_engine_no_constraints(self):
""" constraint place engine should not handle placement with no constraints
"""
# Create constraint place engine
image_datastore = "ds1"
image_datastores = [{"name": image_datastore, "used_for_vms": True}]
option = PlacementOption(1, 1, image_datastores)
ds_map = {
image_datastore: DatastoreInfo(10, 0),
"ds2": DatastoreInfo(20, 0),
"ds3": DatastoreInfo(30, 0)
}
ds_mgr = self.create_datastore_manager(ds_map, image_datastore)
engine = ConstraintDiskPlaceEngine(ds_mgr, option)
ds = engine.placeable_datastores()
selector = DatastoreSelector.init_datastore_selector(ds_mgr, ds)
# Try place
disks = [
Disk(disk_id="disk1", capacity_gb=1),
Disk(disk_id="disk2", capacity_gb=1),
Disk(capacity_gb=1),
]
disks_placement = DisksPlacement(disks, selector)
place_result = engine.place(disks_placement, [])
# Verify place result
assert_that(place_result.result, equal_to(PlaceResultCode.OK))
# Verify unplaced list
disks_placement = place_result.disks_placement
assert_that(disks_placement.placement_list, has_length(0))
assert_that(disks_placement.disks, has_length(3))
def __init__(self, hypervisor, option):
self._logger = logging.getLogger(__name__)
self._hypervisor = hypervisor
self._option = option
self._reserved_vms = {}
self._reserved_disks = {}
self._diskutil = DiskUtil()
self._vm_manager = hypervisor.vm_manager
self._image_manager = hypervisor.image_manager
self._datastore_manager = hypervisor.datastore_manager
self._system = hypervisor.system
self._optimal_placement = OptimalPlaceEngine(self._datastore_manager,
option)
self._best_effort_placement = BestEffortPlaceEngine(
self._datastore_manager, option)
self._constrainted_placement = ConstraintDiskPlaceEngine(
self._datastore_manager, option)
def test_constraint_place_engine_cannot_fit(self):
# Create constraint place engine
image_datastore = "ds1"
image_datastores = [{"name": image_datastore, "used_for_vms": True}]
option = PlacementOption(1, 1, image_datastores)
ds_map = {image_datastore: DatastoreInfo(5, 0)}
ds_mgr = self.create_datastore_manager(ds_map, image_datastore)
engine = ConstraintDiskPlaceEngine(ds_mgr, option)
ds = engine.placeable_datastores()
selector = DatastoreSelector.init_datastore_selector(ds_mgr, ds)
# Try place
constraint = ResourceConstraint(ResourceConstraintType.DATASTORE,
["ds1"])
disk = Disk(disk_id="ds1", capacity_gb=6)
place_result = engine.place(DisksPlacement([disk], selector),
[constraint])
# Verify place result
assert_that(place_result.result,
equal_to(PlaceResultCode.NOT_ENOUGH_DATASTORE_CAPACITY))
def test_constraint_place_engine(self, ds_constraint):
# Create constraint place engine
image_datastore = "ds1"
image_datastores = [{"name": image_datastore, "used_for_vms": True}]
option = PlacementOption(1, 1, image_datastores)
ds_map = {
image_datastore: DatastoreInfo(10, 0),
"ds2": DatastoreInfo(20, 0),
"ds3": DatastoreInfo(30, 0)
}
ds_mgr = self.create_datastore_manager(ds_map, image_datastore)
engine = ConstraintDiskPlaceEngine(ds_mgr, option)
ds = engine.placeable_datastores()
selector = DatastoreSelector.init_datastore_selector(ds_mgr, ds)
# Try place
constraint = ResourceConstraint(ResourceConstraintType.DATASTORE,
[ds_constraint])
disks = [
Disk(disk_id="disk1", capacity_gb=1),
Disk(disk_id="disk2", capacity_gb=1),
Disk(capacity_gb=1),
]
disks_placement = DisksPlacement(disks, selector)
place_result = engine.place(disks_placement, [constraint])
# Verify place result
assert_that(place_result.result, equal_to(PlaceResultCode.OK))
# Verify placement list and unplaced list
disks_placement = place_result.disks_placement
assert_that(disks_placement.placement_list, has_length(3))
assert_that(disks_placement.disks, has_length(0))
assert_that([
d.resource_id
for d in disks_placement.placement_list if d.resource_id
], contains_inanyorder("disk1", "disk2"))
for placement in disks_placement.placement_list:
assert_that(placement.type, equal_to(AgentResourcePlacement.DISK))
assert_that(placement.container_id, equal_to(constraint.values[0]))
