def get_experiment_uses_by_id(reservation_ids=None): if isinstance(reservation_ids, basestring): reservation_ids = [{ 'id': reservation_id } for reservation_id in reservation_ids.split(',')] return weblab_api.ctx.user_processor.get_experiment_uses_by_id([ SessionId(reservation_id['id']) for reservation_id in reservation_ids ])
def logout(): server_instance = weblab_api.ctx.server_instance if not weblab_api.ctx.session_id: raise coreExc.SessionNotFoundError( "User Processing Server session not found") session_id = SessionId(weblab_api.ctx.session_id) if server_instance._session_manager.has_session(session_id): session = server_instance._session_manager.get_session(session_id) user_processor = server_instance._load_user(session) reservation_id = session.get('reservation_id') if reservation_id is not None and not user_processor.is_access_forward_enabled( ): # # If "is_access_forward_enabled", the user (or more commonly, entity) can log out without # finishing his current reservation # # Furthermore, whenever booking is supported, this whole idea should be taken out. Even # with queues it might not make sense, depending on the particular type of experiment. # try: reservation_session = server_instance._reservations_session_manager.get_session( SessionId(reservation_id)) reservation_processor = server_instance._load_reservation( reservation_session) reservation_processor.finish() except SessionNotFoundError: pass try: server_instance._alive_users_collection.remove_user( reservation_id) except SessionNotFoundError: pass user_processor.logout() user_processor.update_latest_timestamp() server_instance._session_manager.delete_session(session_id) return {} else: raise coreExc.SessionNotFoundError( "User Processing Server session not found")
def __init__(self, status, reservation_id): """ __init__(status, reservation_id) status is Reservation.WAITING, Reservation.CONFIRMED, etc. reservation_id is the reservation identifier, used to interact with the experiment """ super(Reservation,self).__init__() self.status = status self.reservation_id = SessionId(reservation_id)
def setUp(self): # Initialize the experiment for testing. # We set the archimedes_real_device setting to False so that # it doesn't attempt to contact the real ip. self.cfg_manager = ConfigurationManager() self.cfg_manager._set_value("archimedes_real_device", False) self.cfg_manager._set_value("archimedes_instances", { "default": "http://localhost:8000", "second": "http://localhost:8001" }) self.experiment = Archimedes(None, None, self.cfg_manager) self.lab_session_id = SessionId('my-session-id')
def finish_reservation(self, reservation_id): session = self.session_maker() try: reservation = session.query(ExternalWebLabDeustoReservation).filter_by(local_reservation_id = reservation_id).first() if reservation is not None: remote_reservation_id = reservation.remote_reservation_id serialized_cookies = reservation.cookies else: log.log(ExternalWebLabDeustoScheduler, log.level.Info, "Not finishing reservation %s since somebody already did it" % reservation_id) return finally: session.close() cookies = pickle.loads(str(serialized_cookies)) client = self._create_client(cookies) client.finished_experiment(SessionId(remote_reservation_id)) try: client.get_reservation_status(SessionId(remote_reservation_id)) except: # TODO: Actually check that the reservation was expired pass # Expired reservation else: now = self.time_provider.get_datetime() self.post_reservation_data_manager.create(reservation_id, now, now + self.expiration_delta, json.dumps("''")) session = self.session_maker() try: reservation = session.query(ExternalWebLabDeustoReservation).filter_by(local_reservation_id = reservation_id).first() if reservation is not None: try: session.delete(reservation) session.commit() except StaleDataError: log.log(ExternalWebLabDeustoScheduler, log.level.Info, "Could not remove reservation_id %s from ExternalWebLabDeustoReservation since somebody already did it" % reservation_id) else: log.log(ExternalWebLabDeustoScheduler, log.level.Info, "Not deleting reservation %s from ExternalWebLabDeustoReservation since somebody already did it" % reservation_id) return finally: session.close()
def get_experiment_uses_by_id(self, reservation_ids): db_session_id = self._session['db_session_id'] experiment_uses = self._db_manager.get_experiment_uses_by_id( db_session_id, [ SessionId(reservation_id.id.split(';')[0]) for reservation_id in reservation_ids ]) results = [] cancelled_results = [] for pos, (experiment_use, reservation_id) in enumerate( zip(experiment_uses, reservation_ids)): result = self._process_use(experiment_use, reservation_id) results.append(result) if result.is_cancelled(): cancelled_results.append((pos, reservation_id)) if len(cancelled_results) > 0: # Sometimes, the system recognizes as cancelled a reservation which was removed # between the moment we asked for results and the moment we stored the results. # Just in case, we check again those results tentatively_cancelled_experiment_uses = self._db_manager.get_experiment_uses_by_id( db_session_id, [ SessionId(reservation_id.id.split(';')[0]) for pos, reservation_id in cancelled_results ]) for (pos, reservation_id), tentatively_cancelled_use in zip( cancelled_results, tentatively_cancelled_experiment_uses): # Only process the use if the use is now not None if tentatively_cancelled_use is not None: tentatively_cancelled_result = self._process_use( tentatively_cancelled_use, reservation_id) if not tentatively_cancelled_result.is_cancelled(): # If it is not cancelled anymore, then we replace the previous value results[pos] = tentatively_cancelled_result return results
def reserve_experiment(experiment_id=None, client_initial_data=None, consumer_data=None): server = weblab_api.ctx.server_instance client_address = weblab_api.ctx.client_address # core_server_universal_id should be copied experiment_id = ExperimentId(experiment_id['exp_name'], experiment_id['cat_name']) status = weblab_api.ctx.user_processor.reserve_experiment( experiment_id, client_initial_data, consumer_data, client_address, server.core_server_universal_id) if status == 'replicated': return Reservation.NullReservation() reservation_id = status.reservation_id.split(';')[0] reservation_session_id = SessionId(reservation_id) server._alive_users_collection.add_user(reservation_session_id) session_id = server._reservations_session_manager.create_session( reservation_id) initial_session = { 'session_polling': (time.time(), ReservationProcessor.EXPIRATION_TIME_NOT_SET), 'latest_timestamp': 0, 'experiment_id': experiment_id, 'creator_session_id': weblab_api.ctx. user_session['session_id'], # Useful for monitor; should not be used 'reservation_id': reservation_session_id, 'federated': False, } reservation_processor = server._load_reservation(initial_session) reservation_processor.update_latest_timestamp() if status.status == WebLabSchedulingStatus.WebLabSchedulingStatus.RESERVED_LOCAL: reservation_processor.process_reserved_status(status) if status.status == WebLabSchedulingStatus.WebLabSchedulingStatus.RESERVED_REMOTE: reservation_processor.process_reserved_remote_status(status) server._reservations_session_manager.modify_session( session_id, initial_session) return Reservation.Reservation.translate_reservation(status)
def finish_reservation(self, reservation_id): redis_client = self.redis_maker() reservation_str = redis_client.hget( self.external_weblabdeusto_reservations, reservation_id) if reservation_str is not None: reservation = json.loads(reservation_str) remote_reservation_id = reservation['remote_reservation_id'] serialized_cookies = reservation['cookies'] else: log.log( ExternalWebLabDeustoScheduler, log.level.Info, "Not finishing reservation %s since somebody already did it" % reservation_id) return cookies = pickle.loads(str(serialized_cookies)) client = self._create_client(cookies) client.finished_experiment(SessionId(remote_reservation_id)) try: client.get_reservation_status(SessionId(remote_reservation_id)) except: # TODO: Actually check that the reservation was expired pass # Expired reservation else: now = self.time_provider.get_datetime() self.post_reservation_data_manager.create( reservation_id, now, now + self.expiration_delta, json.dumps("''")) result = redis_client.hdel(self.external_weblabdeusto_reservations, reservation_id) if not result: log.log( ExternalWebLabDeustoScheduler, log.level.Info, "Not deleting reservation %s from ExternalWebLabDeustoReservation since somebody already did it" % reservation_id) return
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 finish_reservation(self, reservation_id): reservation_id = reservation_id.split(';')[0] if self.reservations_manager.initialize_deletion(reservation_id): self.finished_reservations_store.put(SessionId(reservation_id)) try: aggregator = self._get_scheduler_aggregator_per_reservation( reservation_id) aggregator.finish_reservation(reservation_id) # The reservations_manager must remove the session once (not once per scheduler) self._delete_reservation(reservation_id) except CoordExc.ExpiredSessionError: log.log( AbstractCoordinator, log.level.Info, "Ignore finish_reservation(%r), given that it had already expired" % reservation_id) finally: self.reservations_manager.clean_deletion(reservation_id)
def setUp(self): from voodoo.configuration import ConfigurationManager from voodoo.sessions.session_id import SessionId self.cfg_manager = ConfigurationManager() self.cfg_manager.append_module(configuration_module) self.cfg_manager._set_value("webcam", "http://localhost") self.cfg_manager._set_value("weblab_xilinx_experiment_xilinx_device", "FPGA") self.cfg_manager._set_value("xilinx_max_use_time", "3600") self.cfg_manager._set_value("xilinx_bit_allowed", False) UdXilinxCommandSenders._SerialPort = FakeSerialPort UdXilinxCommandSenders._HttpDevice = FakeHttpDevice self.experiment = UdXilinxExperiment.UdXilinxExperiment( None, None, self.cfg_manager) self.lab_session_id = SessionId('my-session-id')
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 run(self): """ run() Handles file uploading. It will extract the required parameters FILE_SENT, FILE_INFO, SESSION_ID, and the optional parameter IS_ASYNC, and call either send_file or send_async_file depending on this last one. @return HTML defined above, with the success or failure response. """ try: file_info, file_sent, session_id, is_async = self._check_arguments() file_content = Util.serialize(file_sent) sid = SessionId(session_id) if(not is_async): result = self.server.send_file(sid, file_content, file_info) else: result = self.server.send_async_file(sid, file_content, file_info) except FileUploadError as fue: code, message = fue.args return FAULT_HTML_TEMPLATE % { 'THE_FAULT_CODE' : code, 'THE_FAULT_MESSAGE' : message } except Exception as e: message = e.args[0] return FAULT_HTML_TEMPLATE % { 'THE_FAULT_CODE' : PYTHON_GENERAL_EXCEPTION_CODE, 'THE_FAULT_MESSAGE' : message } else: if not is_async: resultstr = result.commandstring else: resultstr = result print "[DBG] Returning result from file upload: " + resultstr return SUCCESS_HTML_TEMPLATE % { 'RESULT' : resultstr }
def wrapper(*args, **kwargs): server = weblab_api.ctx.server_instance if weblab_api.ctx.session_id is None: raise coreExc.SessionNotFoundError("Core Users session not found") session_id = SessionId(weblab_api.ctx.session_id) try: session = server._session_manager.get_session_locking(session_id) except SessionNotFoundError: raise coreExc.SessionNotFoundError("Core Users session not found") try: weblab_api.ctx.user_session = session weblab_api.ctx.user_processor = server._load_user(session) try: return func(*args, **kwargs) finally: weblab_api.ctx.user_processor.update_latest_timestamp() finally: server._session_manager.modify_session_unlocking(session_id, session)
def setUp(self): from voodoo.configuration import ConfigurationManager from voodoo.sessions.session_id import SessionId self.cfg_manager = ConfigurationManager() self.cfg_manager.append_module(configuration_module) self.cfg_manager._set_value("webcam", "http://localhost") # For later. self.cfg_manager._set_value("weblab_xilinx_experiment_xilinx_device", "FPGA") UdXilinxCommandSenders._SerialPort = FakeSerialPort UdXilinxCommandSenders._HttpDevice = FakeHttpDevice self.experiment = UdXilinxExperiment.UdXilinxExperiment( None, None, self.cfg_manager) self.configjson = self.experiment.do_start_experiment() self.lab_session_id = SessionId('my-session-id')
def run(self): experiment_id_str = self.get_argument(EXPERIMENT_ID) if experiment_id_str is None: return "%s argument is missing" % EXPERIMENT_ID session_id_str = self.get_argument(SESSION_ID) if session_id_str is None: return "%s argument is missing" % EXPERIMENT_ID experiment_id = ExperimentId.parse(experiment_id_str) session_id = SessionId(session_id_str) address = RemoteFacadeContext.get_context().get_ip_address() client_address = ClientAddress.ClientAddress(address) try: reservation_id = self.server.reserve_experiment( session_id, experiment_id, "{}", "{}", client_address) except Exception: return HTML_ERROR_TEMPLATE new_location = "../../client/federated.html#reservation_id=%s" % reservation_id.reservation_id.id self.set_status(302) self.add_other_header('Location', new_location) return """<html><body><a href="%s">Click here</a></body></html>""" % new_location
from voodoo.configuration import ConfigurationManager from voodoo.sessions.session_id import SessionId cfg_manager = ConfigurationManager() try: cfg_manager.append_path( "../../../launch/sample/main_machine/main_instance/experiment_fpga/server_config.py" ) except: cfg_manager.append_path( "../launch/sample/main_machine/main_instance/experiment_fpga/server_config.py" ) experiment = ElevatorExperiment(None, None, cfg_manager) lab_session_id = SessionId('my-session-id') experiment.do_start_experiment() experiment._max_use_time = 10 print experiment.do_send_command_to_device("REPORT_USE_TIME_LEFT") print experiment.do_send_command_to_device("STATE") print experiment.do_send_command_to_device("STATE") print experiment.do_should_finish() print experiment.do_send_command_to_device("STATE") print experiment.do_should_finish() if __name__ == "__main__": from voodoo.configuration import ConfigurationManager from voodoo.sessions.session_id import SessionId cfg_manager = ConfigurationManager()
def get_experiment_use_by_id(self, reservation_id): experiment_uses = self._db_manager.get_experiment_uses_by_id(self.username, [SessionId(reservation_id.id.split(';')[0])]) experiment_use = experiment_uses[0] return self._process_use(experiment_use, reservation_id)
def _process(self): redis_client = self.redis_maker() pending_results = [] for reservation_id in redis_client.hkeys( self.external_weblabdeusto_pending): pending_result_str = redis_client.hget( self.external_weblabdeusto_pending, reservation_id) if pending_result_str is not None: pending_result = json.loads(pending_result_str) pending_result['reservation_id'] = reservation_id pending_results.append(pending_result) if len(pending_results) > 0: try: session_id, client = self.create_client_func(None) except urllib2.URLError: # Remote server is down, try later return remote_reservation_ids = [ SessionId(pending_result['remote_reservation_id']) for pending_result in pending_results ] results = client.get_experiment_uses_by_id(session_id, remote_reservation_ids) for pending_result, result in zip(pending_results, results): if result.is_alive(): continue username = pending_result['username'] try: request_info = pickle.loads( pending_result['serialized_request_info'].encode( 'utf-8')) except Exception as e: log.log( ResultsRetriever, log.level.Critical, "Probably serialized_request_info was truncated in %s" % pending_result) log.log_exc(ResultsRetriever, log.level.Error) request_info = {'error': 'could not be stored: %s' % e} reservation_id = pending_result['reservation_id'] remote_reservation_id = pending_result['remote_reservation_id'] if not redis_client.hdel(self.external_weblabdeusto_pending, reservation_id): log.log( ResultsRetriever, log.level.Info, "Pending reservation %r not found. Assuming it is managed by other thread" % pending_result) continue if result.is_finished(): use = result.experiment_use use.experiment_id = ExperimentId.parse( pending_result['experiment_id_str']) use.remote_reservation_id = remote_reservation_id use.reservation_id = reservation_id for key in [key for key in request_info]: if not isinstance(request_info[key], (basestring, numbers.Number)): request_info.pop(key) use.request_info = request_info callback = lambda: self.post_reservation_data_manager.delete( reservation_id) self.completed_store.put(username, use, callback) else: log.log( ResultsRetriever, log.level.Info, "Reservation id %s was cancelled and therefore not stored" % reservation_id)
VDC+6V_1 VDC+6V_1_1 </circuitlist></circuit><multimeter id="1"><dmm_function value="dc current"></dmm_function><dmm_resolution value="3.5"></dmm_resolution><dmm_range value="-1"></dmm_range><dmm_autozero value="1"></dmm_autozero></multimeter><functiongenerator id="1"><fg_waveform value="sine"></fg_waveform><fg_frequency value="1000"></fg_frequency><fg_amplitude value="0.5"></fg_amplitude><fg_offset value="0"></fg_offset></functiongenerator><oscilloscope id="1"><horizontal><horz_samplerate value="500"></horz_samplerate><horz_refpos value="50"></horz_refpos><horz_recordlength value="500"></horz_recordlength></horizontal><channels><channel number="1"><chan_enabled value="1"></chan_enabled><chan_coupling value="dc"></chan_coupling><chan_range value="1"></chan_range><chan_offset value="0"></chan_offset><chan_attenuation value="1"></chan_attenuation></channel><channel number="2"><chan_enabled value="1"></chan_enabled><chan_coupling value="dc"></chan_coupling><chan_range value="1"></chan_range><chan_offset value="0"></chan_offset><chan_attenuation value="1"></chan_attenuation></channel></channels><trigger><trig_source value="channel 1"></trig_source><trig_slope value="positive"></trig_slope><trig_coupling value="dc"></trig_coupling><trig_level value="0"></trig_level><trig_mode value="autolevel"></trig_mode><trig_timeout value="1"></trig_timeout><trig_delay value="0"></trig_delay></trigger><measurements><measurement number="1"><meas_channel value="channel 1"></meas_channel><meas_selection value="none"></meas_selection></measurement><measurement number="2"><meas_channel value="channel 1"></meas_channel><meas_selection value="none"></meas_selection></measurement><measurement number="3"><meas_channel value="channel 1"></meas_channel><meas_selection value="none"></meas_selection></measurement></measurements><osc_autoscale value="0"></osc_autoscale></oscilloscope><dcpower id="1"><dc_outputs><dc_output channel="6V+"><dc_voltage value="2.5"></dc_voltage><dc_current value="0.5"></dc_current></dc_output><dc_output channel="25V+"><dc_voltage value="0"></dc_voltage><dc_current value="0.5"></dc_current></dc_output><dc_output channel="25V-"><dc_voltage value="0"></dc_voltage><dc_current value="0.5"></dc_current></dc_output></dc_outputs></dcpower></request></protocol>""" from voodoo.configuration import ConfigurationManager from voodoo.sessions.session_id import SessionId cfg_manager = ConfigurationManager() try: cfg_manager.append_path( "../../launch/sample/main_machine/main_instance/experiment_testvisir/server_config.py" ) except: cfg_manager.append_path( "../launch/sample/main_machine/main_instance/experiment_testvisir/server_config.py" ) experiment = VisirExperiment(None, None, cfg_manager) lab_session_id = SessionId('sess1') experiment.do_start_experiment(lab_session_id) login_response = json.loads( experiment.do_send_command_to_device(lab_session_id, "login")) sessionkey = login_response['sessionkey'] request = regular_request % sessionkey experiment.do_send_command_to_device(lab_session_id, request) time.sleep(1) lab_session_id2 = SessionId('sess2') experiment.do_start_experiment(lab_session_id2) login_response2 = json.loads( experiment.do_send_command_to_device(lab_session_id2, "login"))
def get_multiple_reservation_status(reservation_ids, timeout): server = weblab_api.ctx.server_instance status = {} t0 = time.time() if timeout > 0: random.shuffle(reservation_ids) for reservation_id in reservation_ids: if timeout > 0 and time.time() > (t0 + timeout): break current_reservation_id = SessionId(reservation_id.split(';')[0]) try: session = server._reservations_session_manager.get_session( current_reservation_id) except (SessionNotFoundError, coreExc.NoCurrentReservationError): status[reservation_id] = { 'success': False, 'reason': "session-not-found", 'reason-human': "reservation id not found", } continue except Exception as err: status[reservation_id] = { 'success': False, 'reason': "error-checking-reservation-1", 'reason-human': str(err), } traceback.print_exc() continue try: weblab_api.ctx.reservation_session = session reservation_processor = server._load_reservation(session) try: status[reservation_id] = reservation_processor.get_status() except Exception as err: status[reservation_id] = { 'success': False, 'reason': "error-checking-reservation-2", 'reason-human': str(err), } traceback.print_exc() continue except (SessionNotFoundError, coreExc.NoCurrentReservationError): status[reservation_id] = { 'success': False, 'reason': "session-not-found", 'reason-human': "reservation id not found", } continue except Exception as err2: status[reservation_id] = { 'success': False, 'reason': "error-checking-reservation-3", 'reason-human': str(err2), } traceback.print_exc() continue tf = time.time() return dict(status=status, time=tf - t0)
def login(self, username, password): session_holder = self._login_call('login', username=username, password=password) return SessionId(session_holder['id'])
def get_reservation_id(ups_session_id): ups = _find_ups() sid = SessionId(ups_session_id) session = ups._session_manager.get_session(sid) return session.get('reservation_id')
def _process(self): session = self.session_maker() try: pending_results = [ pending_result.to_dto() for pending_result in session.query( ExternalWebLabDeustoReservationPendingResults).filter_by( resource_type_name=self.resource_type_name, server_route=self.server_route).all() ] finally: session.close() if len(pending_results) > 0: try: session_id, client = self.create_client_func(None) except urllib2.URLError: # Remote server is down, try later return remote_reservation_ids = [ SessionId(pending_result.remote_reservation_id) for pending_result in pending_results ] results = client.get_experiment_uses_by_id(session_id, remote_reservation_ids) for pending_result, result in zip(pending_results, results): if result.is_alive(): continue username = pending_result.username try: request_info = pickle.loads( pending_result.serialized_request_info.encode('utf-8')) except Exception as e: log.log( ResultsRetriever, log.level.Critical, "Probably serialized_request_info was truncated in %s" % pending_result) log.log_exc(ResultsRetriever, log.level.Error) request_info = {'error': 'could not be stored: %s' % e} reservation_id = pending_result.reservation_id remote_reservation_id = pending_result.remote_reservation_id session = self.session_maker() try: db_pending_result = session.query( ExternalWebLabDeustoReservationPendingResults ).filter_by(id=pending_result.id).first() if db_pending_result is not None: session.delete(db_pending_result) session.commit() else: log.log( ResultsRetriever, log.level.Info, "Pending reservation %r not found. Assuming it is managed by other thread" % pending_result) continue except (IntegrityError, ConcurrentModificationError, StaleDataError): log.log( ResultsRetriever, log.level.Info, "Pending reservation %r deletion failed. Assuming it is managed by other thread" % pending_result) log.log_exc(ResultsRetriever, log.level.Debug) # Somebody else is already handling this continue finally: session.close() if result.is_finished(): use = result.experiment_use use.experiment_id = ExperimentId.parse( pending_result.experiment_id_str) use.remote_reservation_id = remote_reservation_id use.reservation_id = reservation_id for key in [key for key in request_info]: if not isinstance(request_info[key], (basestring, numbers.Number)): request_info.pop(key) use.request_info = request_info callback = lambda: self.post_reservation_data_manager.delete( reservation_id) self.completed_store.put(username, use, callback) else: log.log( ResultsRetriever, log.level.Info, "Reservation id %s was cancelled and therefore not stored" % reservation_id)
def kickout_from_ups(session_id): ups = _find_ups() sid = SessionId(session_id) ups._alive_users_collection.remove_user(sid.id) ups._session_manager.delete_session(sid)
def run(self): """ run() If there is a GET argument named %(reservation_id)s, it will take it and resend it as a POST argument. If it was passed through the history, then it will be again sent as a POST argument. Finally, if it is received as a POST argument, it will generate a redirect to the client, using the proper current structure. """ % { 'reservation_id': RESERVATION_ID } # If it is passed as a GET argument, send it as POST reservation_id = self.get_GET_argument(RESERVATION_ID) if reservation_id is not None: return REDIRECT_CODE % { 'reason': 'GET performed', 'reservation_id': urllib.unquote(reservation_id) } # If it is passed as History (i.e. it was not passed by GET neither POST), # pass it as a POST argument reservation_id = self.get_POST_argument(RESERVATION_ID) if reservation_id is None: return LABEL_CODE reservation_id = urllib.unquote(reservation_id) if self.req.server_route is not None: # If the request should not go to the current server if reservation_id.find('.') >= 0 and not reservation_id.endswith( self.req.server_route): if reservation_id.find(';') >= 0: partial_reservation_id = reservation_id.split(';')[1] else: partial_reservation_id = reservation_id self.req.weblab_cookie = 'weblabsessionid=%s' % partial_reservation_id self.req.login_weblab_cookie = 'loginweblabsessionid=%s' % partial_reservation_id return REDIRECT_CODE % { 'reason': 'reservation_id %s does not end in server_route %s' % (reservation_id, self.req.server_route), 'reservation_id': reservation_id } if reservation_id.find(';') >= 0: partial_reservation_id = reservation_id.split(';')[1] else: partial_reservation_id = reservation_id self.req.weblab_cookie = 'weblabsessionid=%s' % partial_reservation_id self.req.login_weblab_cookie = 'loginweblabsessionid=%s' % partial_reservation_id # Finally, if it was passed as a POST argument, generate the proper client address reservation_session_id = SessionId(reservation_id.split(';')[0]) try: experiment_id = self.server.get_reservation_info( reservation_session_id) except SessionNotFoundError: return ERROR_CODE % reservation_id client_address = "../../client/index.html#exp.name=%(exp_name)s&exp.category=%(exp_cat)s&reservation_id=%(reservation_id)s&header.visible=false&page=experiment" % { 'reservation_id': reservation_id, 'exp_name': experiment_id.exp_name, 'exp_cat': experiment_id.cat_name } format_parameter = self.get_POST_argument(FORMAT_PARAMETER) if format_parameter is not None and format_parameter == 'text': return client_address return FINAL_REDIRECT % {'URL': client_address}
def get_experiment_use_by_id(reservation_id = None): return weblab_api.ctx.user_processor.get_experiment_use_by_id(SessionId(reservation_id['id']))
def __init__(self, reservation_id, time, initial_configuration, url, remote_reservation_id): super(ConfirmedReservation,self).__init__(Reservation.CONFIRMED, reservation_id) self.time = time self.initial_configuration = initial_configuration self.url = url self.remote_reservation_id = SessionId(remote_reservation_id)