def _check_expired(self, reservation_session_id):
# Do not lock. If the user is doing something, the method
# would get locked here. And if the user is doing something,
# the information is stored in a transactional way, so it
# shouldn't be a problem. Anyway, it would be nice that
# after the "poll" method the UPS modified the (updated)
# session without unlocking.
reservation_session = self._session_manager.get_session(reservation_session_id)
user_processor = ReservationProcessor( self._cfg_manager, reservation_session_id, reservation_session, self._coordinator, self._locator, self._commands_store)
return user_processor.is_expired()
def _check_expired(self, reservation_session_id):
# Do not lock. If the user is doing something, the method
# would get locked here. And if the user is doing something,
# the information is stored in a transactional way, so it
# shouldn't be a problem. Anyway, it would be nice that
# after the "poll" method the UPS modified the (updated)
# session without unlocking.
reservation_session = self._session_manager.get_session(reservation_session_id)
reservation_processor = ReservationProcessor( self._cfg_manager, reservation_session_id, reservation_session, self._coordinator, self._locator, self._commands_store)
return reservation_processor.is_expired()
def create_reservation_processor(self, faking_response=False):
if faking_response:
self._fake_simple_lab_response()
status = self.user_processor.reserve_experiment(
ExperimentId('ud-dummy', 'Dummy experiments'), "{}", "{}",
ClientAddress.ClientAddress("127.0.0.1"), 'uuid')
self.reservation_processor = ReservationProcessor(
self.cfg_manager,
SessionId.SessionId(status.reservation_id.split(';')[0]), {
'session_polling':
(time.time(), ReservationProcessor.EXPIRATION_TIME_NOT_SET),
'latest_timestamp':
0,
'experiment_id':
ExperimentId('ud-dummy', 'Dummy experiments'),
'creator_session_id':
'',
'reservation_id':
SessionId.SessionId(status.reservation_id.split(';')[0]),
}, self.coordinator, self.locator, self.commands_store)
def create_reservation_processor(self, faking_response = False):
if faking_response:
self._fake_simple_lab_response()
status = self.user_processor.reserve_experiment( ExperimentId('ud-dummy', 'Dummy experiments'), "{}", "{}", "127.0.0.1", 'uuid')
self.reservation_processor = ReservationProcessor(
self.cfg_manager,
SessionId.SessionId(status.reservation_id.split(';')[0]),
{
'session_polling' : (time.time(), ReservationProcessor.EXPIRATION_TIME_NOT_SET),
'latest_timestamp' : 0,
'experiment_id' : ExperimentId('ud-dummy', 'Dummy experiments'),
'creator_session_id' : '',
'reservation_id' : SessionId.SessionId(status.reservation_id.split(';')[0]),
},
self.coordinator,
self.locator,
self.commands_store
)
class ReservationProcessorTestCase(unittest.TestCase):
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' : {
'inst|ud-dummy|Dummy experiments' : 'res_inst@res_type'
}
})
self.commands_store = TemporalInformationStore.CommandsTemporalInformationStore()
self.coordinator = coordinator_create(SQLALCHEMY, self.locator, self.cfg_manager)
self.coordinator._clean()
self.coordinator.add_experiment_instance_id("server:laboratoryserver@labmachine", ExperimentInstanceId('inst','ud-dummy','Dummy experiments'), Resource("res_type", "res_inst"))
self.user_processor = UserProcessor.UserProcessor(
self.locator,
{
'db_session_id' : ValidDatabaseSessionId('my_db_session_id')
},
self.cfg_manager,
self.coordinator,
self.db,
self.commands_store
)
def create_reservation_processor(self, faking_response = False):
if faking_response:
self._fake_simple_lab_response()
status = self.user_processor.reserve_experiment( ExperimentId('ud-dummy', 'Dummy experiments'), "{}", "{}", "127.0.0.1", 'uuid')
self.reservation_processor = ReservationProcessor(
self.cfg_manager,
SessionId.SessionId(status.reservation_id.split(';')[0]),
{
'session_polling' : (time.time(), ReservationProcessor.EXPIRATION_TIME_NOT_SET),
'latest_timestamp' : 0,
'experiment_id' : ExperimentId('ud-dummy', 'Dummy experiments'),
'creator_session_id' : '',
'reservation_id' : SessionId.SessionId(status.reservation_id.split(';')[0]),
},
self.coordinator,
self.locator,
self.commands_store
)
def tearDown(self):
self.coordinator.stop()
def test_get_info(self):
self.create_reservation_processor(True)
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
reservation_info = self.reservation_processor.get_info()
self.assertEquals('ud-dummy', reservation_info.exp_name)
self.assertEquals('Dummy experiments', reservation_info.cat_name)
def test_is_polling(self):
self.create_reservation_processor(True)
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.assertTrue( self.reservation_processor.is_polling() )
self.reservation_processor.finish()
self.assertFalse( self.reservation_processor.is_polling() )
def test_is_expired_didnt_expire(self):
self.create_reservation_processor(True)
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.assertFalse( self.reservation_processor.is_expired() )
self.reservation_processor.finish()
self.assertTrue( self.reservation_processor.is_expired() )
def test_is_expired_expired_without_expiration_time_set(self):
time_mock = self.mocker.mock()
time_mock.time()
poll_time = self.cfg_manager.get_value(EXPERIMENT_POLL_TIME)
added = poll_time + 5
self.mocker.result(time.time() + added)
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.time_module = time_mock
self.assertTrue( self.reservation_processor.is_expired() )
def test_is_expired_expired_due_to_expiration_time(self):
self._return_reserved()
poll_time = self.cfg_manager.get_value(EXPERIMENT_POLL_TIME)
added = poll_time - 5 # for example
self.db.experiments_allowed[0].time_allowed = poll_time - 10
self.assertTrue( added > 0 )
time_mock = self.mocker.mock()
time_mock.time()
self.mocker.result(time.time() + added)
self.mocker.replay()
#
# Reserve the experiment
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
reservation_status = self.reservation_processor.get_status()
self.assertTrue( isinstance(reservation_status, Reservation.ConfirmedReservation) )
self.reservation_processor.time_module = time_mock
self.assertTrue( self.reservation_processor.is_expired() )
def test_finished_experiment_ok(self):
self.create_reservation_processor(True)
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.finish()
def test_finished_experiment_coordinator_error(self):
self.create_reservation_processor(True)
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
# Force the coordinator to fail when invoking finish_reservation
self.coordinator.finish_reservation = lambda *args: 10 / 0
self.assertRaises(
coreExc.FailedToFreeReservationError,
self.reservation_processor.finish)
def test_send_async_file_ok(self):
file_content = "SAMPLE CONTENT"
lab_response = Command.Command("LAB RESPONSE")
file_info = 'program'
self._return_reserved()
self.lab_mock.send_async_file(SessionId.SessionId('my_lab_session_id'), file_content, file_info)
self.mocker.result(lab_response)
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse( self.reservation_processor.is_expired() )
response = self.reservation_processor.send_async_file(file_content, file_info)
self.assertEquals(lab_response, response)
self.assertFalse( self.reservation_processor.is_expired() )
self.reservation_processor.finish()
self.assertEquals( self.reservation_processor.get_status().status, Reservation.Reservation.POST_RESERVATION )
def test_send_file_ok(self):
file_content = "SAMPLE CONTENT"
lab_response = Command.Command("LAB RESPONSE")
file_info = 'program'
self._return_reserved()
self.lab_mock.send_file(SessionId.SessionId('my_lab_session_id'), file_content, file_info)
self.mocker.result(lab_response)
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse( self.reservation_processor.is_expired() )
response = self.reservation_processor.send_file(file_content, file_info)
self.assertEquals(lab_response, response)
self.assertFalse( self.reservation_processor.is_expired() )
self.reservation_processor.finish()
self.assertEquals( self.reservation_processor.get_status().status, Reservation.Reservation.POST_RESERVATION )
def test_send_file_session_not_found_in_lab(self):
self._return_reserved()
file_content = "SAMPLE CONTENT"
file_info = "program"
self.lab_mock.send_file(SessionId.SessionId('my_lab_session_id'), file_content, file_info)
self.mocker.throw(
LaboratoryErrors.SessionNotFoundInLaboratoryServerError("problem@laboratory")
)
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse( self.reservation_processor.is_expired() )
self.assertRaises(
coreExc.NoCurrentReservationError,
self.reservation_processor.send_file,
file_content,
file_info
)
self.assertEquals( self.reservation_processor.get_status().status, Reservation.Reservation.POST_RESERVATION )
def test_send_async_file_session_not_found_in_lab(self):
self._return_reserved()
file_content = "SAMPLE CONTENT"
file_info = "program"
self.lab_mock.send_async_file(SessionId.SessionId('my_lab_session_id'), file_content, file_info)
self.mocker.throw(
LaboratoryErrors.SessionNotFoundInLaboratoryServerError("problem@laboratory")
)
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse( self.reservation_processor.is_expired() )
self.assertRaises(
coreExc.NoCurrentReservationError,
self.reservation_processor.send_async_file,
file_content,
file_info
)
self.assertEquals( self.reservation_processor.get_status().status, Reservation.Reservation.POST_RESERVATION )
def test_send_async_file_failed_to_send(self):
self._return_reserved()
file_content = "SAMPLE CONTENT"
file_info = "program"
self.lab_mock.send_async_file(SessionId.SessionId('my_lab_session_id'), file_content, file_info)
self.mocker.throw(
LaboratoryErrors.FailedToInteractError("problem@laboratory")
)
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse( self.reservation_processor.is_expired() )
self.assertRaises(
coreExc.FailedToInteractError,
self.reservation_processor.send_async_file,
file_content,
file_info
)
self.assertEquals( self.reservation_processor.get_status().status, Reservation.Reservation.POST_RESERVATION )
def test_send_file_failed_to_send(self):
self._return_reserved()
file_content = "SAMPLE CONTENT"
file_info = "program"
self.lab_mock.send_file(SessionId.SessionId('my_lab_session_id'), file_content, file_info)
self.mocker.throw(
LaboratoryErrors.FailedToInteractError("problem@laboratory")
)
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse( self.reservation_processor.is_expired() )
self.assertRaises(
coreExc.FailedToInteractError,
self.reservation_processor.send_file,
file_content,
file_info
)
self.assertEquals( self.reservation_processor.get_status().status, Reservation.Reservation.POST_RESERVATION )
def test_send_async_command_ok(self):
self._return_reserved()
command = Command.Command("Your command")
lab_response = Command.Command("LAB RESPONSE")
self.lab_mock.send_async_command(SessionId.SessionId('my_lab_session_id'), command)
self.mocker.result(lab_response)
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse( self.reservation_processor.is_expired() )
response = self.reservation_processor.send_async_command(command)
self.assertEquals(lab_response, response)
self.assertFalse( self.reservation_processor.is_expired() )
self.reservation_processor.finish()
self.assertEquals( self.reservation_processor.get_status().status, Reservation.Reservation.POST_RESERVATION )
def test_send_command_ok(self):
self._return_reserved()
command = Command.Command("Your command")
lab_response = Command.Command("LAB RESPONSE")
self.lab_mock.send_command(SessionId.SessionId('my_lab_session_id'), command)
self.mocker.result(lab_response)
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse( self.reservation_processor.is_expired() )
response = self.reservation_processor.send_command(command)
self.assertEquals(lab_response, response)
self.assertFalse( self.reservation_processor.is_expired() )
self.reservation_processor.finish()
self.assertEquals( self.reservation_processor.get_status().status, Reservation.Reservation.POST_RESERVATION )
def test_send_command_session_not_found_in_lab(self):
self._return_reserved()
command = Command.Command("Your command")
self.lab_mock.send_command(SessionId.SessionId('my_lab_session_id'), command)
self.mocker.throw(
LaboratoryErrors.SessionNotFoundInLaboratoryServerError("problem@laboratory")
)
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse( self.reservation_processor.is_expired() )
self.assertRaises(
coreExc.NoCurrentReservationError,
self.reservation_processor.send_command,
command
)
self.assertEquals( self.reservation_processor.get_status().status, Reservation.Reservation.POST_RESERVATION )
def test_send_async_command_session_not_found_in_lab(self):
self._return_reserved()
command = Command.Command("Your command")
self.lab_mock.send_async_command(SessionId.SessionId('my_lab_session_id'), command)
self.mocker.throw(
LaboratoryErrors.SessionNotFoundInLaboratoryServerError("problem@laboratory")
)
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse( self.reservation_processor.is_expired() )
self.assertRaises(
coreExc.NoCurrentReservationError,
self.reservation_processor.send_async_command,
command
)
self.assertEquals( self.reservation_processor.get_status().status, Reservation.Reservation.POST_RESERVATION )
def test_send_async_command_failed_to_send(self):
self._return_reserved()
command = Command.Command("Your command")
self.lab_mock.send_async_command(SessionId.SessionId('my_lab_session_id'), command)
self.mocker.throw(
LaboratoryErrors.FailedToInteractError("problem@laboratory")
)
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse( self.reservation_processor.is_expired() )
self.assertRaises(
coreExc.FailedToInteractError,
self.reservation_processor.send_async_command,
command
)
self.assertEquals( self.reservation_processor.get_status().status, Reservation.Reservation.POST_RESERVATION )
def test_send_command_failed_to_send(self):
self._return_reserved()
command = Command.Command("Your command")
self.lab_mock.send_command(SessionId.SessionId('my_lab_session_id'), command)
self.mocker.throw(
LaboratoryErrors.FailedToInteractError("problem@laboratory")
)
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse( self.reservation_processor.is_expired() )
self.assertRaises(
coreExc.FailedToInteractError,
self.reservation_processor.send_command,
command
)
self.assertEquals( self.reservation_processor.get_status().status, Reservation.Reservation.POST_RESERVATION )
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', { 'address' : 'servexp:inst@mach' }))
self.lab_mock.resolve_experiment_address('my_lab_session_id')
self.mocker.result(CoordAddress("exp","inst","mach"))
self.lab_mock.should_experiment_finish(SessionId.SessionId('my_lab_session_id'))
self.mocker.result(0)
self.mocker.replay()
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', { 'address' : 'servexp:inst@mach' }))
self.lab_mock.resolve_experiment_address('my_lab_session_id')
self.mocker.result(CoordAddress("exp","inst","mach"))
self.mocker.count(1,2)
class ReservationProcessorTestCase(unittest.TestCase):
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': {
'inst|ud-dummy|Dummy experiments': 'res_inst@res_type'
}
})
self.commands_store = TemporalInformationStore.CommandsTemporalInformationStore(
)
self.coordinator = coordinator_create(SQLALCHEMY, self.locator,
self.cfg_manager)
self.coordinator._clean()
self.coordinator.add_experiment_instance_id(
"server:laboratoryserver@labmachine",
ExperimentInstanceId('inst', 'ud-dummy', 'Dummy experiments'),
Resource("res_type", "res_inst"))
self.user_processor = UserProcessor.UserProcessor(
self.locator, {
'db_session_id':
DbSession.ValidDatabaseSessionId('my_db_session_id')
}, self.cfg_manager, self.coordinator, self.db,
self.commands_store)
def create_reservation_processor(self, faking_response=False):
if faking_response:
self._fake_simple_lab_response()
status = self.user_processor.reserve_experiment(
ExperimentId('ud-dummy', 'Dummy experiments'), "{}", "{}",
ClientAddress.ClientAddress("127.0.0.1"), 'uuid')
self.reservation_processor = ReservationProcessor(
self.cfg_manager,
SessionId.SessionId(status.reservation_id.split(';')[0]), {
'session_polling':
(time.time(), ReservationProcessor.EXPIRATION_TIME_NOT_SET),
'latest_timestamp':
0,
'experiment_id':
ExperimentId('ud-dummy', 'Dummy experiments'),
'creator_session_id':
'',
'reservation_id':
SessionId.SessionId(status.reservation_id.split(';')[0]),
}, self.coordinator, self.locator, self.commands_store)
def tearDown(self):
self.coordinator.stop()
def test_get_info(self):
self.create_reservation_processor(True)
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
reservation_info = self.reservation_processor.get_info()
self.assertEquals('ud-dummy', reservation_info.exp_name)
self.assertEquals('Dummy experiments', reservation_info.cat_name)
def test_is_polling(self):
self.create_reservation_processor(True)
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.assertTrue(self.reservation_processor.is_polling())
self.reservation_processor.finish()
self.assertFalse(self.reservation_processor.is_polling())
def test_is_expired_didnt_expire(self):
self.create_reservation_processor(True)
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.assertFalse(self.reservation_processor.is_expired())
self.reservation_processor.finish()
self.assertTrue(self.reservation_processor.is_expired())
def test_is_expired_expired_without_expiration_time_set(self):
time_mock = self.mocker.mock()
time_mock.time()
poll_time = self.cfg_manager.get_value(
UserProcessor.EXPERIMENT_POLL_TIME)
added = poll_time + 5
self.mocker.result(time.time() + added)
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.time_module = time_mock
self.assertTrue(self.reservation_processor.is_expired())
def test_is_expired_expired_due_to_expiration_time(self):
self._return_reserved()
poll_time = self.cfg_manager.get_value(
UserProcessor.EXPERIMENT_POLL_TIME)
added = poll_time - 5 # for example
self.db.experiments_allowed[0].time_allowed = poll_time - 10
self.assertTrue(added > 0)
time_mock = self.mocker.mock()
time_mock.time()
self.mocker.result(time.time() + added)
self.mocker.replay()
#
# Reserve the experiment
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
reservation_status = self.reservation_processor.get_status()
self.assertTrue(
isinstance(reservation_status, Reservation.ConfirmedReservation))
self.reservation_processor.time_module = time_mock
self.assertTrue(self.reservation_processor.is_expired())
def test_finished_experiment_ok(self):
self.create_reservation_processor(True)
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.finish()
def test_finished_experiment_coordinator_error(self):
self.create_reservation_processor(True)
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
# Force the coordinator to fail when invoking finish_reservation
self.coordinator.finish_reservation = lambda *args: 10 / 0
self.assertRaises(coreExc.FailedToFreeReservationError,
self.reservation_processor.finish)
def test_send_async_file_ok(self):
file_content = "SAMPLE CONTENT"
lab_response = Command.Command("LAB RESPONSE")
file_info = 'program'
self._return_reserved()
self.lab_mock.send_async_file(SessionId.SessionId('my_lab_session_id'),
file_content, file_info)
self.mocker.result(lab_response)
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse(self.reservation_processor.is_expired())
response = self.reservation_processor.send_async_file(
file_content, file_info)
self.assertEquals(lab_response, response)
self.assertFalse(self.reservation_processor.is_expired())
self.reservation_processor.finish()
self.assertEquals(self.reservation_processor.get_status().status,
Reservation.Reservation.POST_RESERVATION)
def test_send_file_ok(self):
file_content = "SAMPLE CONTENT"
lab_response = Command.Command("LAB RESPONSE")
file_info = 'program'
self._return_reserved()
self.lab_mock.send_file(SessionId.SessionId('my_lab_session_id'),
file_content, file_info)
self.mocker.result(lab_response)
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse(self.reservation_processor.is_expired())
response = self.reservation_processor.send_file(
file_content, file_info)
self.assertEquals(lab_response, response)
self.assertFalse(self.reservation_processor.is_expired())
self.reservation_processor.finish()
self.assertEquals(self.reservation_processor.get_status().status,
Reservation.Reservation.POST_RESERVATION)
def test_send_file_session_not_found_in_lab(self):
self._return_reserved()
file_content = "SAMPLE CONTENT"
file_info = "program"
self.lab_mock.send_file(SessionId.SessionId('my_lab_session_id'),
file_content, file_info)
self.mocker.throw(
LaboratoryErrors.SessionNotFoundInLaboratoryServerError(
"problem@laboratory"))
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse(self.reservation_processor.is_expired())
self.assertRaises(coreExc.NoCurrentReservationError,
self.reservation_processor.send_file, file_content,
file_info)
self.assertEquals(self.reservation_processor.get_status().status,
Reservation.Reservation.POST_RESERVATION)
def test_send_async_file_session_not_found_in_lab(self):
self._return_reserved()
file_content = "SAMPLE CONTENT"
file_info = "program"
self.lab_mock.send_async_file(SessionId.SessionId('my_lab_session_id'),
file_content, file_info)
self.mocker.throw(
LaboratoryErrors.SessionNotFoundInLaboratoryServerError(
"problem@laboratory"))
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse(self.reservation_processor.is_expired())
self.assertRaises(coreExc.NoCurrentReservationError,
self.reservation_processor.send_async_file,
file_content, file_info)
self.assertEquals(self.reservation_processor.get_status().status,
Reservation.Reservation.POST_RESERVATION)
def test_send_async_file_failed_to_send(self):
self._return_reserved()
file_content = "SAMPLE CONTENT"
file_info = "program"
self.lab_mock.send_async_file(SessionId.SessionId('my_lab_session_id'),
file_content, file_info)
self.mocker.throw(
LaboratoryErrors.FailedToInteractError("problem@laboratory"))
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse(self.reservation_processor.is_expired())
self.assertRaises(coreExc.FailedToInteractError,
self.reservation_processor.send_async_file,
file_content, file_info)
self.assertEquals(self.reservation_processor.get_status().status,
Reservation.Reservation.POST_RESERVATION)
def test_send_file_failed_to_send(self):
self._return_reserved()
file_content = "SAMPLE CONTENT"
file_info = "program"
self.lab_mock.send_file(SessionId.SessionId('my_lab_session_id'),
file_content, file_info)
self.mocker.throw(
LaboratoryErrors.FailedToInteractError("problem@laboratory"))
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse(self.reservation_processor.is_expired())
self.assertRaises(coreExc.FailedToInteractError,
self.reservation_processor.send_file, file_content,
file_info)
self.assertEquals(self.reservation_processor.get_status().status,
Reservation.Reservation.POST_RESERVATION)
def test_send_async_command_ok(self):
self._return_reserved()
command = Command.Command("Your command")
lab_response = Command.Command("LAB RESPONSE")
self.lab_mock.send_async_command(
SessionId.SessionId('my_lab_session_id'), command)
self.mocker.result(lab_response)
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse(self.reservation_processor.is_expired())
response = self.reservation_processor.send_async_command(command)
self.assertEquals(lab_response, response)
self.assertFalse(self.reservation_processor.is_expired())
self.reservation_processor.finish()
self.assertEquals(self.reservation_processor.get_status().status,
Reservation.Reservation.POST_RESERVATION)
def test_send_command_ok(self):
self._return_reserved()
command = Command.Command("Your command")
lab_response = Command.Command("LAB RESPONSE")
self.lab_mock.send_command(SessionId.SessionId('my_lab_session_id'),
command)
self.mocker.result(lab_response)
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse(self.reservation_processor.is_expired())
response = self.reservation_processor.send_command(command)
self.assertEquals(lab_response, response)
self.assertFalse(self.reservation_processor.is_expired())
self.reservation_processor.finish()
self.assertEquals(self.reservation_processor.get_status().status,
Reservation.Reservation.POST_RESERVATION)
def test_send_command_session_not_found_in_lab(self):
self._return_reserved()
command = Command.Command("Your command")
self.lab_mock.send_command(SessionId.SessionId('my_lab_session_id'),
command)
self.mocker.throw(
LaboratoryErrors.SessionNotFoundInLaboratoryServerError(
"problem@laboratory"))
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse(self.reservation_processor.is_expired())
self.assertRaises(coreExc.NoCurrentReservationError,
self.reservation_processor.send_command, command)
self.assertEquals(self.reservation_processor.get_status().status,
Reservation.Reservation.POST_RESERVATION)
def test_send_async_command_session_not_found_in_lab(self):
self._return_reserved()
command = Command.Command("Your command")
self.lab_mock.send_async_command(
SessionId.SessionId('my_lab_session_id'), command)
self.mocker.throw(
LaboratoryErrors.SessionNotFoundInLaboratoryServerError(
"problem@laboratory"))
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse(self.reservation_processor.is_expired())
self.assertRaises(coreExc.NoCurrentReservationError,
self.reservation_processor.send_async_command,
command)
self.assertEquals(self.reservation_processor.get_status().status,
Reservation.Reservation.POST_RESERVATION)
def test_send_async_command_failed_to_send(self):
self._return_reserved()
command = Command.Command("Your command")
self.lab_mock.send_async_command(
SessionId.SessionId('my_lab_session_id'), command)
self.mocker.throw(
LaboratoryErrors.FailedToInteractError("problem@laboratory"))
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse(self.reservation_processor.is_expired())
self.assertRaises(coreExc.FailedToInteractError,
self.reservation_processor.send_async_command,
command)
self.assertEquals(self.reservation_processor.get_status().status,
Reservation.Reservation.POST_RESERVATION)
def test_send_command_failed_to_send(self):
self._return_reserved()
command = Command.Command("Your command")
self.lab_mock.send_command(SessionId.SessionId('my_lab_session_id'),
command)
self.mocker.throw(
LaboratoryErrors.FailedToInteractError("problem@laboratory"))
self.mocker.replay()
self.create_reservation_processor()
self.coordinator.confirmer._confirm_handler.join(10)
self.assertFalse(self.coordinator.confirmer._confirm_handler.isAlive())
self.reservation_processor.get_status()
self.assertFalse(self.reservation_processor.is_expired())
self.assertRaises(coreExc.FailedToInteractError,
self.reservation_processor.send_command, command)
self.assertEquals(self.reservation_processor.get_status().status,
Reservation.Reservation.POST_RESERVATION)
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 _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 _load_reservation(self, session):
reservation_id = session['reservation_id']
return ReservationProcessor(self._cfg_manager, reservation_id, session, self._coordinator, self._locator, self._commands_store)
