def setUp(self):
self.cfg_manager = ConfigurationManager.ConfigurationManager()
self.cfg_manager.append_module(configuration_module)
self.fake_client = FakeClient()
self.fake_locator = FakeLocator(self.fake_client)
self.locator = self.fake_locator
self.experiment_instance_id = ExperimentInstanceId(
"exp_inst", "exp_name", "exp_cat")
self.experiment_instance_id_old = ExperimentInstanceId(
"exp_inst", "exp_name", "exp_cat2")
self.experiment_coord_address = CoordAddress.translate(
'myserver:myinstance@mymachine')
self.cfg_manager._set_value(
'laboratory_assigned_experiments', {
'exp_inst:exp_name@exp_cat': {
'coord_address':
'myserver:myinstance@mymachine',
'checkers': (
('WebcamIsUpAndRunningHandler', ("https://...", )),
('HostIsUpAndRunningHandler', ("hostname", 80), {}),
)
},
'exp_inst:exp_name@exp_cat2': {
'coord_address':
'myserver:myinstance@mymachine',
'checkers': (
('WebcamIsUpAndRunningHandler', ("https://...", )),
('HostIsUpAndRunningHandler', ("hostname", 80), {}),
),
},
})
self._create_lab()
def test_list_experiment_instance_ids_by_resource(self):
session = self.session_maker()
try:
exp_id1 = ExperimentInstanceId("exp1", "ud-pld", "PLD Experiments")
resource_instance1 = Resource("type1", "instance1")
self.resources_manager.add_experiment_instance_id(
"laboratory1:WL_SERVER1@WL_MACHINE1", exp_id1,
resource_instance1)
exp_id2 = ExperimentInstanceId("exp2", "ud-pld", "PLD Experiments")
self.resources_manager.add_experiment_instance_id(
"laboratory1:WL_SERVER1@WL_MACHINE1", exp_id2,
resource_instance1)
exp_id3 = ExperimentInstanceId("exp3", "ud-pld", "PLD Experiments")
resource_instance2 = Resource("type1", "instance2")
self.resources_manager.add_experiment_instance_id(
"laboratory1:WL_SERVER1@WL_MACHINE1", exp_id3,
resource_instance2)
session.commit()
finally:
session.close()
experiment_instance_ids = self.resources_manager.list_experiment_instance_ids_by_resource(
resource_instance1)
self.assertEquals(2, len(experiment_instance_ids))
self.assertTrue(
ExperimentInstanceId('exp1', 'ud-pld', 'PLD Experiments') in
experiment_instance_ids)
self.assertTrue(
ExperimentInstanceId('exp2', 'ud-pld', 'PLD Experiments') in
experiment_instance_ids)
def test_list_laboratories_addresses(self):
session = self.session_maker()
try:
exp_id1 = ExperimentInstanceId("exp1", "ud-pld", "PLD Experiments")
resource_instance1 = Resource("type1", "instance1")
self.resources_manager.add_experiment_instance_id(
"laboratory1:WL_SERVER1@WL_MACHINE1", exp_id1,
resource_instance1)
# Repeating laboratory1, but a set is returned so no problem
exp_id2 = ExperimentInstanceId("exp2", "ud-pld", "PLD Experiments")
resource_instance2 = Resource("type2", "instance1")
self.resources_manager.add_experiment_instance_id(
"laboratory1:WL_SERVER1@WL_MACHINE1", exp_id2,
resource_instance2)
exp_id3 = ExperimentInstanceId("exp3", "ud-pld", "PLD Experiments")
resource_instance3 = Resource("type2", "instance2")
self.resources_manager.add_experiment_instance_id(
"laboratory2:WL_SERVER1@WL_MACHINE1", exp_id3,
resource_instance3)
session.commit()
finally:
session.close()
addresses = self.resources_manager.list_laboratories_addresses()
self.assertEquals(2, len(addresses))
self.assertTrue("laboratory1:WL_SERVER1@WL_MACHINE1" in addresses)
self.assertEquals(2,
len(addresses["laboratory1:WL_SERVER1@WL_MACHINE1"]))
self.assertTrue(
exp_id1 in addresses["laboratory1:WL_SERVER1@WL_MACHINE1"])
self.assertTrue(
exp_id2 in addresses["laboratory1:WL_SERVER1@WL_MACHINE1"])
self.assertTrue("laboratory2:WL_SERVER1@WL_MACHINE1" in addresses)
self.assertEquals(1,
len(addresses["laboratory2:WL_SERVER1@WL_MACHINE1"]))
self.assertTrue(
exp_id3 in addresses["laboratory2:WL_SERVER1@WL_MACHINE1"])
self.assertEquals(
resource_instance1,
addresses["laboratory1:WL_SERVER1@WL_MACHINE1"][exp_id1])
self.assertEquals(
resource_instance2,
addresses["laboratory1:WL_SERVER1@WL_MACHINE1"][exp_id2])
self.assertEquals(
resource_instance3,
addresses["laboratory2:WL_SERVER1@WL_MACHINE1"][exp_id3])
def setUp(self):
locator_mock = None
self.cfg_manager = ConfigurationManager.ConfigurationManager()
self.cfg_manager.append_module(configuration_module)
self.coordinator = WrappedCoordinator(locator_mock, self.cfg_manager, ConfirmerClass = ConfirmerMock)
self.coordinator._clean()
self.coordinator.add_experiment_instance_id("lab1:inst@machine", ExperimentInstanceId('inst1', 'exp1','cat1'), Resource("res_type", "res_inst1"))
self.coordinator.add_experiment_instance_id("lab2:inst@machine", ExperimentInstanceId('inst2', 'exp2','cat1'), Resource("res_type", "res_inst2"))
self.reservations_manager = self.coordinator.reservations_manager
def test_list_experiments(self):
exp_id1 = ExperimentInstanceId("exp1", "ud-pld", "PLD Experiments")
resource_instance1 = Resource("type1", "instance1")
self.resources_manager.add_experiment_instance_id(
"laboratory1:WL_SERVER1@WL_MACHINE1", exp_id1, resource_instance1)
exp_id2 = ExperimentInstanceId("exp2", "ud-pld", "PLD Experiments")
resource_instance2 = Resource("type2", "instance1")
self.resources_manager.add_experiment_instance_id(
"laboratory1:WL_SERVER1@WL_MACHINE1", exp_id2, resource_instance2)
resources = self.resources_manager.list_experiments()
self.assertEquals(1, len(resources))
self.assertTrue(ExperimentId('ud-pld', 'PLD Experiments') in resources)
def test_remove_resource_instance_id(self):
exp_id = ExperimentInstanceId("exp1", "ud-pld", "PLD Experiments")
self.resources_manager.add_experiment_instance_id(
"laboratory1:WL_SERVER1@WL_MACHINE1", exp_id,
Resource("type", "instance"))
experiment_instances = self.resources_manager.list_experiment_instances_by_type(
exp_id.to_experiment_id())
self.assertEquals(1, len(experiment_instances))
self.resources_manager.remove_resource_instance_id(exp_id)
experiment_instances = self.resources_manager.list_experiment_instances_by_type(
exp_id.to_experiment_id())
self.assertEquals(0, len(experiment_instances))
def _clean_current_reservation(self, reservation_id):
client = self.redis_maker()
enqueue_free_experiment_args = None
if reservation_id is not None:
weblab_reservation_pqueue = WEBLAB_RESOURCE_RESERVATION_PQUEUE % (self.resource_type_name, reservation_id)
reservation_data_str = client.get(weblab_reservation_pqueue)
if reservation_data_str is not None:
downgraded = self.reservations_manager.downgrade_confirmation(reservation_id)
if downgraded:
reservation_data = json.loads(reservation_data_str)
resource_instance_str = reservation_data.get(RESOURCE_INSTANCE)
if resource_instance_str is not None:
resource_instance = Resource.parse(resource_instance_str)
weblab_resource_pqueue_instance_reservations = WEBLAB_RESOURCE_PQUEUE_INSTANCE_RESERVATIONS % (resource_instance.resource_type, resource_instance.resource_instance)
client.srem(weblab_resource_pqueue_instance_reservations, reservation_id)
# print "RELEASING AT _clean_current_reservation. SHOULD NEVER HAPPEN."
# self.resources_manager.release_resource(resource_instance)
lab_session_id = reservation_data.get(LAB_SESSION_ID)
experiment_instance_str = reservation_data.get(EXPERIMENT_INSTANCE)
experiment_instance_id = ExperimentInstanceId.parse(experiment_instance_str)
if experiment_instance_id is not None:
# If the experiment instance doesn't exist, there is no need to call the free_experiment method
lab_coord_address = reservation_data.get(LAB_COORD)
enqueue_free_experiment_args = (lab_coord_address, reservation_id, lab_session_id, experiment_instance_id)
# otherwise the student has been removed
return enqueue_free_experiment_args
def test_add_experiment_instance_id_redundant(self):
self.assertEquals([], self.resources_manager.list_resources())
exp_id = ExperimentInstanceId("exp1", "ud-pld", "PLD Experiments")
self.resources_manager.add_experiment_instance_id(
"laboratory1:WL_SERVER1@WL_MACHINE1", exp_id,
Resource("type", "instance"))
# No problem in adding twice the same
self.resources_manager.add_experiment_instance_id(
"laboratory1:WL_SERVER1@WL_MACHINE1", exp_id,
Resource("type", "instance"))
# Everything is all right
self._check_resource_added()
self._check_experiment_instance_id_added()
# However, we can't add another time the same experiment instance with a different laboratory id:
self.assertRaises(CoordExc.InvalidExperimentConfigError,
self.resources_manager.add_experiment_instance_id,
"laboratory2:WL_SERVER1@WL_MACHINE1", exp_id,
Resource("type", "instance"))
# Or the same experiment instance with a different resource instance:
self.assertRaises(CoordExc.InvalidExperimentConfigError,
self.resources_manager.add_experiment_instance_id,
"laboratory1:WL_SERVER1@WL_MACHINE1", exp_id,
Resource("type", "instance2"))
def setUp(self):
self.mocker = mocker.Mocker()
self.lab_mock = self.mocker.mock()
self.locator = FakeLocator(lab=self.lab_mock)
self.db = FakeDatabase()
self.cfg_manager = ConfigurationManager.ConfigurationManager()
self.cfg_manager.append_module(configuration_module)
self.cfg_manager._set_value(
COORDINATOR_LABORATORY_SERVERS, {
'server:laboratoryserver@labmachine': {
'inst1|ud-dummy|Dummy experiments': 'res_inst@res_type'
}
})
self.commands_store = TemporalInformationStore.CommandsTemporalInformationStore(
)
self.coordinator = coordinator_create(SQLALCHEMY,
self.locator,
self.cfg_manager,
ConfirmerClass=FakeConfirmer)
self.coordinator._clean()
self.coordinator.add_experiment_instance_id(
"server:laboratoryserver@labmachine",
ExperimentInstanceId('inst', 'ud-dummy', 'Dummy experiments'),
Resource("res_type", "res_inst"))
self.processor = UserProcessor.UserProcessor(
self.locator,
{'db_session_id': ValidDatabaseSessionId('my_db_session_id')},
self.cfg_manager, self.coordinator, self.db, self.commands_store)
def test_remove_resource_instance(self):
session = self.session_maker()
try:
exp_id = ExperimentInstanceId("exp1", "ud-pld", "PLD Experiments")
resource_instance = Resource("type", "instance")
self.resources_manager.add_experiment_instance_id(
"laboratory1:WL_SERVER1@WL_MACHINE1", exp_id,
resource_instance)
# Checking that the resources are there
experiment_instances = session.query(
CoordinatorModel.ExperimentInstance).all()
self.assertEquals(1, len(experiment_instances))
resource_instances = session.query(
CoordinatorModel.ResourceInstance).all()
self.assertEquals(1, len(resource_instances))
# Removing resource instance
self.resources_manager.remove_resource_instance(
session, resource_instance)
# Checking that the resources are not there, neither the experiment instances
resource_instances = session.query(
CoordinatorModel.ResourceInstance).all()
self.assertEquals(0, len(resource_instances))
experiment_instances = session.query(
CoordinatorModel.ExperimentInstance).all()
self.assertEquals(0, len(experiment_instances))
session.commit()
finally:
session.close()
def test_confirm_experiment(self):
lab_session_id = SessionId.SessionId("samplesession_id")
mock_laboratory = self.mocker.mock()
mock_laboratory.reserve_experiment(ExperimentInstanceId('inst1','exp1','cat1'), '"sample initial data"', mocker.ANY)
self.mocker.result((lab_session_id, None, 'server:inst@mach'))
self.mock_locator.real_mock = self.mocker.mock()
self.mock_locator.real_mock.get_server_from_coordaddress(
self.coord_address,
coord_addr(self.lab_address),
ServerType.Laboratory,
'all'
)
self.mocker.result((mock_laboratory,))
self.mocker.count(min=1,max=None)
self.mocker.replay()
status, reservation1_id = self.coordinator.reserve_experiment(ExperimentId('exp1','cat1'), 30, 5, True, 'sample initial data', DEFAULT_REQUEST_INFO, {})
now = datetime.datetime.fromtimestamp(int(time.time())) # Remove milliseconds as MySQL do
self.coordinator.confirmer._confirm_handler.join()
self.assertEquals( None, self.confirmer._confirm_handler.raised_exc )
status = self.coordinator.get_reservation_status(reservation1_id)
expected_status = WSS.LocalReservedStatus(reservation1_id, CoordAddress.CoordAddress.translate_address(self.lab_address), lab_session_id, 30, '{}', now, now, True, 30, 'http://www.weblab.deusto.es/weblab/client/adfas')
self.assertTrue(hasattr(status, 'timestamp_before'), "Unexpected status. Expected\n %s\n, but the obtained does not have timestamp_before:\n %s\n" % (status, expected_status))
self.assertTrue(status.timestamp_before >= now and status.timestamp_before <= now + datetime.timedelta(seconds=10),
"Unexpected status due to timestamp_before: %s; expected something like %s" % (status, expected_status))
self.assertTrue(status.timestamp_after >= now and status.timestamp_after <= now + datetime.timedelta(seconds=10),
"Unexpected status due to timestamp_after: %s; expected something like %s" % (status, expected_status))
status.timestamp_before = now
status.timestamp_after = now
self.assertEquals( expected_status, status )
def setUp(self):
cfg_manager = ConfigurationManager.ConfigurationManager()
cfg_manager.append_module(configuration_module)
self.fake_client = FakeClient()
self.fake_locator = FakeLocator((self.fake_client, ))
locator = EasyLocator.EasyLocator(
CoordAddress.CoordAddress('mach', 'inst', 'serv'),
self.fake_locator)
self.experiment_instance_id = ExperimentInstanceId(
"exp_inst", "exp_name", "exp_cat")
self.experiment_coord_address = CoordAddress.CoordAddress.translate_address(
'myserver:myinstance@mymachine')
cfg_manager._set_value(
'laboratory_assigned_experiments', {
'exp_inst:exp_name@exp_cat': {
'coord_address':
'myserver1:myinstance@mymachine',
'checkers': (
('WebcamIsUpAndRunningHandler', ("https://...", )),
('HostIsUpAndRunningHandler', ("hostname", 80), {}),
)
}
})
self.lab = LaboratoryServer.LaboratoryServer(None, locator,
cfg_manager)
def _clean_current_reservation(self, reservation_id):
client = self.redis_maker()
enqueue_free_experiment_args = None
if reservation_id is not None:
weblab_reservation_pqueue = WEBLAB_RESOURCE_RESERVATION_PQUEUE % (self.resource_type_name, reservation_id)
reservation_data_str = client.get(weblab_reservation_pqueue)
if reservation_data_str is not None:
downgraded = self.reservations_manager.downgrade_confirmation(reservation_id)
if downgraded:
reservation_data = json.loads(reservation_data_str)
resource_instance_str = reservation_data.get(RESOURCE_INSTANCE)
if resource_instance_str is not None:
resource_instance = Resource.parse(resource_instance_str)
weblab_resource_pqueue_instance_reservations = WEBLAB_RESOURCE_PQUEUE_INSTANCE_RESERVATIONS % (resource_instance.resource_type, resource_instance.resource_instance)
client.srem(weblab_resource_pqueue_instance_reservations, reservation_id)
self.resources_manager.release_resource(resource_instance)
lab_session_id = reservation_data.get(LAB_SESSION_ID)
experiment_instance_str = reservation_data.get(EXPERIMENT_INSTANCE)
experiment_instance_id = ExperimentInstanceId.parse(experiment_instance_str)
if experiment_instance_id is not None:
# If the experiment instance doesn't exist, there is no need to call the free_experiment method
lab_coord_address = reservation_data.get(LAB_COORD)
enqueue_free_experiment_args = (lab_coord_address, reservation_id, lab_session_id, experiment_instance_id)
# otherwise the student has been removed
return enqueue_free_experiment_args
def list_laboratories_addresses(self):
client = self._redis_maker()
laboratory_addresses = {
# laboratory_coord_address : {
# experiment_instance_id : resource_instance
# }
}
for experiment_type in client.smembers(WEBLAB_EXPERIMENT_TYPES):
experiment_id = ExperimentId.parse(experiment_type)
experiment_instance_names = client.smembers(
WEBLAB_EXPERIMENT_INSTANCES % experiment_type)
for experiment_instance_name in experiment_instance_names:
experiment_instance_id = ExperimentInstanceId(
experiment_instance_name, experiment_id.exp_name,
experiment_id.cat_name)
weblab_experiment_instance = WEBLAB_EXPERIMENT_INSTANCE % (
experiment_type, experiment_instance_name)
laboratory_address = client.hget(weblab_experiment_instance,
LAB_COORD)
resource_str = client.hget(weblab_experiment_instance,
RESOURCE_INST)
resource = Resource.parse(resource_str)
current = laboratory_addresses.get(laboratory_address, {})
current[experiment_instance_id] = resource
laboratory_addresses[laboratory_address] = current
return laboratory_addresses
def setUp(self):
self.cfg_manager = ConfigurationManager.ConfigurationManager()
self.cfg_manager.append_module(configuration_module)
self.locator = FakeLocator(FakeClient())
self.experiment_instance_id = ExperimentInstanceId(
"exp_inst", "exp_name", "exp_cat")
def test_get_resource_instance_by_experiment_instance_id_failing(self):
exp_id = ExperimentInstanceId("exp1", "ud-pld", "PLD Experiments")
self.resources_manager.add_experiment_instance_id(
"laboratory1:WL_SERVER1@WL_MACHINE1", exp_id,
Resource("type", "instance"))
exp_invalid_type = ExperimentInstanceId("exp1", "ud-pld.invalid",
"PLD Experiments")
self.assertRaises(
CoordExc.ExperimentNotFoundError, self.resources_manager.
get_resource_instance_by_experiment_instance_id, exp_invalid_type)
exp_invalid_inst = ExperimentInstanceId("exp.invalid", "ud-pld",
"PLD Experiments")
self.assertRaises(
CoordExc.ExperimentNotFoundError, self.resources_manager.
get_resource_instance_by_experiment_instance_id, exp_invalid_inst)
def list_experiment_instances_by_type(self, experiment_id):
client = self._redis_maker()
weblab_experiment_instances = WEBLAB_EXPERIMENT_INSTANCES % experiment_id.to_weblab_str(
)
return [
ExperimentInstanceId(inst, experiment_id.exp_name,
experiment_id.cat_name)
for inst in client.smembers(weblab_experiment_instances)
]
def _return_reserved(self):
self.lab_mock.reserve_experiment(
ExperimentInstanceId('inst', 'ud-dummy', 'Dummy experiments'),
"{}", mocker.ANY)
self.mocker.result((SessionId.SessionId('my_lab_session_id'), 'ok',
'servexp:inst@mach'))
self.lab_mock.resolve_experiment_address('my_lab_session_id')
self.mocker.result(CoordAddress.CoordAddress("exp", "inst", "mach"))
self.mocker.count(1, 2)
def test_get_resource_instance_by_experiment_instance_id(self):
exp_id = ExperimentInstanceId("exp1", "ud-pld", "PLD Experiments")
self.resources_manager.add_experiment_instance_id(
"laboratory1:WL_SERVER1@WL_MACHINE1", exp_id,
Resource("type", "instance"))
resource = self.resources_manager.get_resource_instance_by_experiment_instance_id(
exp_id)
expected_resource = Resource("type", "instance")
self.assertEquals(expected_resource, resource)
def test_get_resource_types_by_experiment_id_error(self):
exp_id = ExperimentInstanceId("exp1", "ud-pld", "PLD Experiments")
self.resources_manager.add_experiment_instance_id(
"laboratory1:WL_SERVER1@WL_MACHINE1", exp_id,
Resource("type", "instance"))
self.assertRaises(
CoordExc.ExperimentNotFoundError,
self.resources_manager.get_resource_types_by_experiment_id,
ExperimentId("foo", "bar"))
def setUp(self):
self.cfg_manager = ConfigurationManager.ConfigurationManager()
self.cfg_manager.append_module(configuration_module)
self.locator = EasyLocator.EasyLocator(
CoordAddress.CoordAddress('mach', 'inst', 'serv'),
FakeLocator((FakeClient(), )))
self.experiment_instance_id = ExperimentInstanceId(
"exp_inst", "exp_name", "exp_cat")
def test_free_experiment_raises_exception(self):
self.mock_locator[coord_addr(self.lab_address)]
self.mocker.throw(Exception('foo'))
self.mocker.replay()
self.confirmer.enqueue_free_experiment(
self.lab_address, '5', 'lab_session_id',
ExperimentInstanceId('inst1', 'exp1', 'cat1'))
self.confirmer._free_handler.join()
self.assertEquals(None, self.confirmer._free_handler.raised_exc)
def test_get_resource_types_by_experiment_id(self):
exp_id = ExperimentInstanceId("exp1", "ud-pld", "PLD Experiments")
self.resources_manager.add_experiment_instance_id(
"laboratory1:WL_SERVER1@WL_MACHINE1", exp_id,
Resource("type", "instance"))
exp_type_id = ExperimentId("ud-pld", "PLD Experiments")
resource_types = self.resources_manager.get_resource_types_by_experiment_id(
exp_type_id)
self.assertEquals(1, len(resource_types))
self.assertTrue(u"type" in resource_types)
def test_coordination_configuration_parser(self):
self.cfg_manager._set_value(CoordinationConfigurationParser.COORDINATOR_LABORATORY_SERVERS, {
'laboratory1:WL_SERVER1@WL_MACHINE1' : {
'exp1|ud-fpga|FPGA experiments' : 'fpga1@fpga boards',
'exp1|ud-pld|PLD experiments' : 'pld1@pld boards',
},
})
configuration = self.coordination_configuration_parser.parse_configuration()
self.assertEquals(1, len(configuration))
lab_config = configuration['laboratory1:WL_SERVER1@WL_MACHINE1']
self.assertEquals(2, len(lab_config))
exp_fpga = ExperimentInstanceId("exp1","ud-fpga","FPGA experiments")
exp_pld = ExperimentInstanceId("exp1","ud-pld","PLD experiments")
fpga_resource = lab_config[exp_fpga]
self.assertEquals(Resource("fpga boards", "fpga1"), fpga_resource)
pld_resource = lab_config[exp_pld]
self.assertEquals(Resource("pld boards", "pld1"), pld_resource)
def test_remove_resource_instance_id(self):
exp_id = ExperimentInstanceId("exp1","ud-pld","PLD Experiments")
self.resources_manager.add_experiment_instance_id("laboratory1:WL_SERVER1@WL_MACHINE1", exp_id, Resource("type", "instance"))
experiment_instances = self.resources_manager.list_experiment_instances_by_type(exp_id.to_experiment_id())
self.assertEquals(1, len(experiment_instances))
self.resources_manager.remove_resource_instance_id(exp_id)
experiment_instances = self.resources_manager.list_experiment_instances_by_type(exp_id.to_experiment_id())
self.assertEquals(0, len(experiment_instances))
def test_scheduler_reservation_associations(self):
exp_inst_id1 = ExperimentInstanceId("exp1", "ud-pld",
"PLD experiments")
exp_inst_id1b = ExperimentInstanceId("exp2", "ud-pld",
"PLD experiments")
exp_inst_id2 = ExperimentInstanceId("exp1", "ud-fpga",
"FPGA experiments")
exp_id1 = exp_inst_id1.to_experiment_id()
exp_id2 = exp_inst_id2.to_experiment_id()
self.resources_manager.add_resource(Resource("pld_local", "instance"))
self.resources_manager.add_resource(Resource("pld_remote", "instance"))
self.resources_manager.add_resource(Resource("fpga_remote",
"instance"))
self.resources_manager.add_experiment_instance_id(
"laboratory1:WL_SERVER1@WL_MACHINE1", exp_inst_id1,
Resource("pld_local", "instance"))
self.resources_manager.add_experiment_instance_id(
"laboratory1:WL_SERVER1@WL_MACHINE1", exp_inst_id1b,
Resource("pld_remote", "instance"))
self.resources_manager.add_experiment_instance_id(
"laboratory1:WL_SERVER1@WL_MACHINE1", exp_inst_id2,
Resource("fpga_remote", "instance"))
reservation1 = 'reservation1'
reservation2 = 'reservation2'
self.resources_manager.associate_scheduler_to_reservation(
reservation1, exp_id1, 'pld_local')
self.resources_manager.associate_scheduler_to_reservation(
reservation1, exp_id1, 'pld_remote')
self.resources_manager.associate_scheduler_to_reservation(
reservation2, exp_id2, 'fpga_remote')
resource_type_names = self.resources_manager.retrieve_schedulers_per_reservation(
reservation1, exp_id1)
self.assertEquals(set(('pld_local', 'pld_remote')),
set(resource_type_names))
resource_type_names = self.resources_manager.retrieve_schedulers_per_reservation(
reservation2, exp_id2)
self.assertEquals(['fpga_remote'], list(resource_type_names))
self.resources_manager.dissociate_scheduler_from_reservation(
reservation1, exp_id1, 'pld_remote')
resource_type_names = self.resources_manager.retrieve_schedulers_per_reservation(
reservation1, exp_id1)
self.assertEquals(['pld_local'], list(resource_type_names))
self.resources_manager.clean_associations_for_reservation(
reservation1, exp_id1)
resource_type_names = self.resources_manager.retrieve_schedulers_per_reservation(
reservation1, exp_id1)
self.assertEquals(0, len(resource_type_names))
def test_scheduler_reservation_associations(self):
exp_inst_id1 = ExperimentInstanceId("exp1","ud-pld", "PLD experiments")
exp_inst_id1b = ExperimentInstanceId("exp2","ud-pld", "PLD experiments")
exp_inst_id2 = ExperimentInstanceId("exp1","ud-fpga", "FPGA experiments")
exp_id1 = exp_inst_id1.to_experiment_id()
exp_id2 = exp_inst_id2.to_experiment_id()
session = self.session_maker()
try:
self.resources_manager.add_resource(session, Resource("pld_local", "instance"))
self.resources_manager.add_resource(session, Resource("pld_remote", "instance"))
self.resources_manager.add_resource(session, Resource("fpga_remote", "instance"))
session.commit()
finally:
session.close()
self.resources_manager.add_experiment_instance_id("laboratory1:WL_SERVER1@WL_MACHINE1", exp_inst_id1, Resource("pld_local", "instance"))
self.resources_manager.add_experiment_instance_id("laboratory1:WL_SERVER1@WL_MACHINE1", exp_inst_id1b, Resource("pld_remote", "instance"))
self.resources_manager.add_experiment_instance_id("laboratory1:WL_SERVER1@WL_MACHINE1", exp_inst_id2, Resource("fpga_remote", "instance"))
reservation1 = 'reservation1'
reservation2 = 'reservation2'
self.resources_manager.associate_scheduler_to_reservation(reservation1, exp_id1, 'pld_local')
self.resources_manager.associate_scheduler_to_reservation(reservation1, exp_id1, 'pld_remote')
self.resources_manager.associate_scheduler_to_reservation(reservation2, exp_id2, 'fpga_remote')
resource_type_names = self.resources_manager.retrieve_schedulers_per_reservation(reservation1, exp_id1)
self.assertEquals(set(('pld_local','pld_remote')), set(resource_type_names))
resource_type_names = self.resources_manager.retrieve_schedulers_per_reservation(reservation2, exp_id2)
self.assertEquals(['fpga_remote'], list(resource_type_names))
self.resources_manager.dissociate_scheduler_from_reservation(reservation1, exp_id1, 'pld_remote')
resource_type_names = self.resources_manager.retrieve_schedulers_per_reservation(reservation1, exp_id1)
self.assertEquals(['pld_local'], list(resource_type_names))
self.resources_manager.clean_associations_for_reservation(reservation1, exp_id1)
resource_type_names = self.resources_manager.retrieve_schedulers_per_reservation(reservation1, exp_id1)
self.assertEquals(0, len(resource_type_names))
def test_free_experiment_success(self):
mock_laboratory = self.mocker.mock()
mock_laboratory.free_experiment('lab_session_id')
self.mock_locator[coord_addr(self.lab_address)]
self.mocker.result(mock_laboratory)
self.mocker.replay()
self.confirmer.enqueue_free_experiment(
self.lab_address, '5', 'lab_session_id',
ExperimentInstanceId('inst1', 'exp1', 'cat1'))
self.confirmer._free_handler.join()
def test_add_experiment_instance_id(self):
self.assertEquals([], self.resources_manager.list_resources())
exp_id = ExperimentInstanceId("exp1", "ud-pld", "PLD Experiments")
self.resources_manager.add_experiment_instance_id(
"laboratory1:WL_SERVER1@WL_MACHINE1", exp_id,
Resource("type", "instance"))
self._check_resource_added()
self._check_experiment_instance_id_added()
def remove_resource_instance(self, resource):
client = self._redis_maker()
weblab_resource = WEBLAB_RESOURCE % resource.resource_type
if client.srem(weblab_resource, resource.resource_instance):
# else it did not exist
weblab_resource_instance_experiments = WEBLAB_RESOURCE_INSTANCE_EXPERIMENTS % (resource.resource_type, resource.resource_instance)
experiment_instances = client.smembers(weblab_resource_instance_experiments) or []
client.delete(weblab_resource_instance_experiments)
for experiment_instance in experiment_instances:
experiment_instance_id = ExperimentInstanceId.parse(experiment_instance)
self.remove_resource_instance_id(experiment_instance_id)
def list_experiment_instance_ids_by_resource(self, resource):
client = self._redis_maker()
experiment_instance_ids = []
weblab_resource_instance_experiments = WEBLAB_RESOURCE_INSTANCE_EXPERIMENTS % (resource.resource_type, resource.resource_instance)
current_members = client.smembers(weblab_resource_instance_experiments) or []
for member in current_members:
experiment_instance_id = ExperimentInstanceId.parse(member)
experiment_instance_ids.append(experiment_instance_id)
return experiment_instance_ids
def _fake_simple_lab_response(self):
self.lab_mock.reserve_experiment(
ExperimentInstanceId('inst', 'ud-dummy', 'Dummy experiments'),
"{}", mocker.ANY)
self.mocker.result((SessionId.SessionId('my_lab_session_id'), 'ok',
'servexp:inst@mach'))
self.lab_mock.resolve_experiment_address('my_lab_session_id')
self.mocker.result(CoordAddress.CoordAddress("exp", "inst", "mach"))
self.lab_mock.should_experiment_finish(
SessionId.SessionId('my_lab_session_id'))
self.mocker.result(0)
self.mocker.replay()
def list_experiment_instance_ids_by_resource(self, resource):
client = self._redis_maker()
experiment_instance_ids = []
weblab_resource_instance_experiments = WEBLAB_RESOURCE_INSTANCE_EXPERIMENTS % (resource.resource_type, resource.resource_instance)
current_members = client.smembers(weblab_resource_instance_experiments) or []
for member in current_members:
experiment_instance_id = ExperimentInstanceId.parse(member)
experiment_instance_ids.append(experiment_instance_id)
return experiment_instance_ids
def remove_resource_instance(self, resource):
client = self._redis_maker()
weblab_resource = WEBLAB_RESOURCE % resource.resource_type
if client.srem(weblab_resource, resource.resource_instance):
# else it did not exist
weblab_resource_instance_experiments = WEBLAB_RESOURCE_INSTANCE_EXPERIMENTS % (resource.resource_type, resource.resource_instance)
experiment_instances = client.smembers(weblab_resource_instance_experiments) or []
client.delete(weblab_resource_instance_experiments)
for experiment_instance in experiment_instances:
experiment_instance_id = ExperimentInstanceId.parse(experiment_instance)
self.remove_resource_instance_id(experiment_instance_id)
def list_experiment_instance_ids(self):
experiment_instance_ids = []
for category_name in self._experiments:
experiments = self._experiments[category_name]
for experiment_name in experiments:
instances = experiments[experiment_name]
for instance_name in instances:
exp_instance_id = ExperimentInstanceId(
instance_name, experiment_name, category_name)
experiment_instance_ids.append(exp_instance_id)
return experiment_instance_ids
def test_remove_resource_instance(self):
exp_id = ExperimentInstanceId("exp1","ud-pld","PLD Experiments")
resource_instance = Resource("type", "instance")
self.resources_manager.add_experiment_instance_id("laboratory1:WL_SERVER1@WL_MACHINE1", exp_id, resource_instance)
# Checking that the resources are there
experiment_instances = self.resources_manager.list_experiment_instances_by_type(exp_id.to_experiment_id())
self.assertEquals(1, len(experiment_instances))
resource_instances = self.resources_manager.list_resource_instances()
self.assertEquals(1, len(resource_instances))
# Removing resource instance
self.resources_manager.remove_resource_instance(resource_instance)
# Checking that the resources are not there, neither the experiment instances
resource_instances = self.resources_manager.list_resource_instances()
self.assertEquals(0, len(resource_instances))
experiment_instances = self.resources_manager.list_experiment_instances_by_type(exp_id.to_experiment_id())
self.assertEquals(0, len(experiment_instances))
