def setUp(self):
self.wi_five = WSS.WaitingInstancesQueueStatus("reservation_id", 5)
self.wi_four = WSS.WaitingInstancesQueueStatus("reservation_id", 4)
self.w_five = WSS.WaitingQueueStatus("reservation_id", 5)
self.w_four = WSS.WaitingQueueStatus("reservation_id", 4)
self.wc1 = WSS.WaitingConfirmationQueueStatus(
"reservation_id", 'http://www.weblab.deusto.es/weblab/client/...')
self.wc2 = WSS.WaitingConfirmationQueueStatus(
"reservation_id", 'http://www.weblab.deusto.es/weblab/client/...')
self.res1 = WSS.LocalReservedStatus(
"reservation_id", "coord_address1", "lab_session_id1", {}, 50,
None, datetime.datetime.now(), datetime.datetime.now(), True, 50,
'http://www.weblab.deusto.es/weblab/client/foo')
self.res2 = WSS.LocalReservedStatus(
"reservation_id", "coord_address2", "lab_session_id2", {}, 60,
"foo", datetime.datetime.now(), datetime.datetime.now(), True, 50,
'http://www.weblab.deusto.es/weblab/client/foo')
self.post1 = WSS.PostReservationStatus("reservation_id", True, "foo1",
"bar")
self.post2 = WSS.PostReservationStatus("reservation_id", True, "foo2",
"bar")
def reserve_experiment(self, reservation_id, experiment_id, time, priority,
initialization_in_accounting, client_initial_data,
request_info):
if not 'operation' in client_initial_data:
raise Exception(
"Invalid client_initial_data. If you are using iLab, you should reserve it through /weblab/web/ilab/, or use the same scheme"
)
client = self._create_client()
if client_initial_data['operation'] == 'get_lab_configuration':
config = client.get_lab_configuration()
return WSS.PostReservationStatus(reservation_id, True, config, '')
elif client_initial_data['operation'] == 'submit':
# TODO!!!
remote_experiment_id = random.randint(1000000, 200000000)
session = self.session_maker()
try:
reservation = ILabBatchReservation(reservation_id,
self.lab_server_url,
remote_experiment_id)
session.add(reservation)
session.commit()
finally:
session.close()
# submit(self, experiment_id, experiment_specification, user_group, priority_hint)
experiment_specification = client_initial_data['payload']
accepted, warnings, error, est_runtime, lab_exp_id, min_time_to_live, queue_length, wait = client.submit(
remote_experiment_id, experiment_specification,
"weblab-deusto", 0)
# TODO: do something with the arguments :-)
return WSS.WaitingQueueStatus(reservation_id, queue_length)
else:
raise Exception("Invalid operation in client_initial_data")
def get_reservation_status(self, reservation_id):
session = self.session_maker()
try:
reservation = session.query(ILabBatchReservation).filter_by(
local_reservation_id=reservation_id,
lab_server_url=self.lab_server_url).first()
if reservation is None:
# TODO
raise Exception("reservation not stored in local database")
remote_experiment_id = reservation.remote_experiment_id
finally:
session.close()
# public class StorageStatus
# public const int BATCH_QUEUED = 1; // if waiting in the execution queue
# public const int BATCH_RUNNING = 2; //if currently running
# public const int BATCH_TERMINATED = 3; // if terminated normally
# public const int BATCH_TERMINATED_ERROR = 4; // if terminated with errors (this includes cancellation by user in mid-execution)
# public const int BATCH_CANCELLED = 5; // if cancelled by user before execution had begun
# public const int BATCH_UNKNOWN = 6; // if unknown labExperimentID.
# public const int BATCH_NOT_VALID = 7; // Assigned by Service Broker if experiment is not valid (done in submit call)
client = self._create_client()
code, queue_length, est_wait, est_rt, est_rem_rt, min_to_live = client.get_experiment_status(
remote_experiment_id)
# TODO do something with the rest of the variables
if code == 1:
return WSS.WaitingQueueStatus(reservation_id, queue_length)
elif code == 2:
return WSS.WaitingConfirmationQueueStatus(reservation_id,
self.core_server_url)
elif code == 3:
code, results, xmlResultExtension, xmlBlobExtension, warnings, error = client.retrieve_result(
remote_experiment_id)
response = json.dumps({
'code': code,
'results': results,
'xmlResults': xmlResultExtension,
})
return WSS.PostReservationStatus(reservation_id, True, response,
'')
else:
return WSS.PostReservationStatus(
reservation_id, True,
"ERROR: WebLab-Deusto can't handle status code %s at this point"
% code, '')
def get_reservation_status(self, reservation_id):
reservation_found = False
max_iterations = 15
while not reservation_found and max_iterations >= 0:
session = self.session_maker()
try:
reservation = session.query(
ExternalWebLabDeustoReservation).filter_by(
local_reservation_id=reservation_id).first()
if reservation is None:
pending_result = session.query(
ExternalWebLabDeustoReservationPendingResults
).filter_by(resource_type_name=self.resource_type_name,
server_route=self.core_server_route,
reservation_id=reservation_id).first()
if pending_result is None:
# reservation not yet stored in local database
pass
else:
return WSS.PostReservationStatus(
reservation_id, False, '', '')
else:
reservation_found = True
remote_reservation_id = reservation.remote_reservation_id
serialized_cookies = reservation.cookies
finally:
session.close()
# Introduce a delay to let the system store the reservation in the local database
if not reservation_found:
time_mod.sleep(0.1)
max_iterations -= 1
if not reservation_found:
return WSS.PostReservationStatus(reservation_id, False, '', '')
cookies = pickle.loads(str(serialized_cookies))
client = self._create_client(cookies)
reservation = client.get_reservation_status(
SessionId(remote_reservation_id))
return self._convert_reservation_to_status(reservation, reservation_id,
remote_reservation_id)
def test_translate_reservation_post_reservation(self):
status = WSS.PostReservationStatus('foo', True, "{ }", "{}")
reservation = Reservation.translate_reservation(status)
self.assertEquals(Reservation.POST_RESERVATION, reservation.status)
self.assertEquals('foo', reservation.reservation_id.id)
self.assertEquals('{ }', reservation.initial_data)
self.assertEquals('{}', reservation.end_data)
self.assertTrue(reservation.finished)
self.assertEquals(status, reservation.to_status())
def get_reservation_status(self, reservation_id):
reservation_found = False
max_iterations = 15
while not reservation_found and max_iterations >= 0:
client = self.redis_maker()
reservation_str = client.hget(
self.external_weblabdeusto_reservations, reservation_id)
if reservation_str is None:
external_weblabdeusto_pending_results = self.EXTERNAL_WEBLABDEUSTO_PENDING_RESULTS % (
self.resource_type_name, self.core_server_route)
pending_result = client.hget(
external_weblabdeusto_pending_results, reservation_id)
if pending_result is None:
# reservation not yet stored in local database
pass
else:
return WSS.PostReservationStatus(reservation_id, False, '',
'')
else:
reservation = json.loads(reservation_str)
reservation_found = True
remote_reservation_id = reservation['remote_reservation_id']
serialized_cookies = reservation['cookies']
# Introduce a delay to let the system store the reservation in the local database
if not reservation_found:
time_mod.sleep(0.1)
max_iterations -= 1
if not reservation_found:
return WSS.PostReservationStatus(reservation_id, False, '', '')
cookies = pickle.loads(str(serialized_cookies))
client = self._create_client(cookies)
reservation = client.get_reservation_status(
SessionId(remote_reservation_id))
return self._convert_reservation_to_status(reservation, reservation_id,
remote_reservation_id)
def find(self, reservation_id):
client = self._redis_maker()
weblab_post_reservation = WEBLAB_POST_RESERVATION % reservation_id
post_reservation_data_str = client.get(weblab_post_reservation)
if post_reservation_data_str is None:
return None
post_reservation_data = json.loads(post_reservation_data_str)
return WSS.PostReservationStatus(reservation_id,
post_reservation_data[FINISHED],
post_reservation_data[INITIAL_DATA],
post_reservation_data.get(END_DATA))
def find(self, reservation_id):
session = self._session_maker()
try:
reservation = session.query(PostReservationRetrievedData).filter(
PostReservationRetrievedData.reservation_id ==
reservation_id).first()
if reservation is None:
return None
return WSS.PostReservationStatus(reservation_id,
reservation.finished,
reservation.initial_data,
reservation.end_data)
finally:
session.close()
def test_str_post_reservation(self):
post = WSS.PostReservationStatus("reservation_id", True, "foo1", "bar")
str(post)
def to_status(self):
return WSS.PostReservationStatus(self.reservation_id, self.finished, self.initial_data, self.end_data)