def __init__(self, coord_address, locator, cfg_manager, dont_start = False, *args, **kwargs):
super(UserProcessingServer,self).__init__(*args, **kwargs)
log.log( UserProcessingServer, log.level.Info, "Starting Core Server...")
self._stopping = False
self._cfg_manager = cfg_manager
self.config = cfg_manager
self._locator = locator
self.core_server_url = cfg_manager.get_doc_value(configuration_doc.CORE_SERVER_URL)
if cfg_manager.get_value(configuration_doc.CORE_UNIVERSAL_IDENTIFIER, 'default') == 'default' or cfg_manager.get_value(configuration_doc.CORE_UNIVERSAL_IDENTIFIER_HUMAN, 'default') == 'default':
generated = uuid.uuid1()
msg = "Property %(property)s or %(property_human)s not configured. Please establish: %(property)s = '%(uuid)s' and %(property_human)s = 'server at university X'. Otherwise, when federating the experiment it could enter in an endless loop." % {
'property' : configuration_doc.CORE_UNIVERSAL_IDENTIFIER,
'property_human' : configuration_doc.CORE_UNIVERSAL_IDENTIFIER_HUMAN,
'uuid' : generated
}
print(msg)
print(msg, file = sys.stderr)
log.log( UserProcessingServer, log.level.Error, msg)
self.core_server_universal_id = cfg_manager.get_doc_value(configuration_doc.CORE_UNIVERSAL_IDENTIFIER)
self.core_server_universal_id_human = cfg_manager.get_doc_value(configuration_doc.CORE_UNIVERSAL_IDENTIFIER_HUMAN)
#
# Create session managers
#
session_type_str = cfg_manager.get_doc_value(configuration_doc.WEBLAB_CORE_SERVER_SESSION_TYPE)
if not hasattr(SessionType, session_type_str):
raise coreExc.NotASessionTypeError( 'Not a session type: %s' % session_type_str )
session_type = getattr(SessionType, session_type_str)
session_pool_id = cfg_manager.get_doc_value(configuration_doc.WEBLAB_CORE_SERVER_SESSION_POOL_ID)
self._session_manager = SessionManager.SessionManager( cfg_manager, session_type, session_pool_id )
reservations_session_pool_id = cfg_manager.get_value(WEBLAB_CORE_SERVER_RESERVATIONS_SESSION_POOL_ID, "CoreServerReservations")
self._reservations_session_manager = SessionManager.SessionManager( cfg_manager, session_type, reservations_session_pool_id )
#
# Coordination
#
coordinator_implementation = cfg_manager.get_doc_value(configuration_doc.COORDINATOR_IMPL)
self._coordinator = coordinator_create(coordinator_implementation, self._locator, cfg_manager)
#
# Database and information storage managers
#
self._db_manager = DatabaseGateway(cfg_manager)
self.db = self._db_manager
cfg_manager.client = DbConfig(self.db.client_configuration)
cfg_manager.server = DbConfig(self.db.server_configuration)
self._commands_store = TemporalInformationStore.CommandsTemporalInformationStore()
self._temporal_information_retriever = TemporalInformationRetriever.TemporalInformationRetriever(cfg_manager, self._coordinator.initial_store, self._coordinator.finished_store, self._commands_store, self._coordinator.completed_store, self._db_manager)
self._temporal_information_retriever.start()
clean = cfg_manager.get('core_number') == 0
if clean:
self._location_retriever = LocationRetriever(cfg_manager, self._db_manager)
self._location_retriever.start()
else:
self._location_retriever = None
#
# Alive users
#
self._alive_users_collection = AliveUsersCollection.AliveUsersCollection(
self._locator, self._cfg_manager, session_type, self._reservations_session_manager, self._coordinator, self._commands_store, self._coordinator.finished_reservations_store)
# Login Manager
self._login_manager = LoginManager(self._db_manager, self)
#
# Initialize facade (comm) servers
#
self._server_route = cfg_manager.get_doc_value(configuration_doc.CORE_FACADE_SERVER_ROUTE)
self.flask_server = WebLabFlaskServer(self, cfg_manager)
self.dont_start = cfg_manager.get_value('dont_start', dont_start)
if not self.dont_start:
self.flask_server.start()
self.app = self.flask_server.app
#
# Start checking times
#
checking_time = self._cfg_manager.get_value(CHECKING_TIME_NAME, DEFAULT_CHECKING_TIME)
timer = threading.Timer(checking_time, self._renew_checker_timer)
timer.setName(counter.next_name("ups-checker-timer"))
timer.setDaemon(True)
timer.start()
_resource_manager.add_resource(timer)
def __init__(self, coord_address, locator, cfg_manager, dont_start = False, *args, **kwargs):
super(UserProcessingServer,self).__init__(*args, **kwargs)
log.log( UserProcessingServer, log.level.Info, "Starting Core Server...")
self._stopping = False
self._cfg_manager = cfg_manager
self.config = cfg_manager
self._locator = locator
self.core_server_url = cfg_manager.get_doc_value(configuration_doc.CORE_SERVER_URL)
if cfg_manager.get_value(configuration_doc.CORE_UNIVERSAL_IDENTIFIER, 'default') == 'default' or cfg_manager.get_value(configuration_doc.CORE_UNIVERSAL_IDENTIFIER_HUMAN, 'default') == 'default':
generated = uuid.uuid1()
msg = "Property %(property)s or %(property_human)s not configured. Please establish: %(property)s = '%(uuid)s' and %(property_human)s = 'server at university X'. Otherwise, when federating the experiment it could enter in an endless loop." % {
'property' : configuration_doc.CORE_UNIVERSAL_IDENTIFIER,
'property_human' : configuration_doc.CORE_UNIVERSAL_IDENTIFIER_HUMAN,
'uuid' : generated
}
print(msg)
print(msg, file = sys.stderr)
log.log( UserProcessingServer, log.level.Error, msg)
self.core_server_universal_id = cfg_manager.get_doc_value(configuration_doc.CORE_UNIVERSAL_IDENTIFIER)
self.core_server_universal_id_human = cfg_manager.get_doc_value(configuration_doc.CORE_UNIVERSAL_IDENTIFIER_HUMAN)
#
# Create session managers
#
session_type_str = cfg_manager.get_doc_value(configuration_doc.WEBLAB_CORE_SERVER_SESSION_TYPE)
if not hasattr(SessionType, session_type_str):
raise coreExc.NotASessionTypeError( 'Not a session type: %s' % session_type_str )
session_type = getattr(SessionType, session_type_str)
session_pool_id = cfg_manager.get_doc_value(configuration_doc.WEBLAB_CORE_SERVER_SESSION_POOL_ID)
self._session_manager = SessionManager.SessionManager( cfg_manager, session_type, session_pool_id )
reservations_session_pool_id = cfg_manager.get_value(WEBLAB_CORE_SERVER_RESERVATIONS_SESSION_POOL_ID, "CoreServerReservations")
self._reservations_session_manager = SessionManager.SessionManager( cfg_manager, session_type, reservations_session_pool_id )
#
# Coordination
#
coordinator_implementation = cfg_manager.get_doc_value(configuration_doc.COORDINATOR_IMPL)
self._coordinator = coordinator_create(coordinator_implementation, self._locator, cfg_manager)
#
# Database and information storage managers
#
self._db_manager = DatabaseGateway(cfg_manager)
self.db = self._db_manager
cfg_manager.client = DbConfig(self.db.client_configuration)
cfg_manager.server = DbConfig(self.db.server_configuration)
self._commands_store = TemporalInformationStore.CommandsTemporalInformationStore()
self._temporal_information_retriever = TemporalInformationRetriever.TemporalInformationRetriever(cfg_manager, self._coordinator.initial_store, self._coordinator.finished_store, self._commands_store, self._coordinator.completed_store, self._db_manager)
self._temporal_information_retriever.start()
clean = cfg_manager.get('core_number') == 0
if clean:
self._location_retriever = LocationRetriever(cfg_manager, self._db_manager)
self._location_retriever.start()
else:
self._location_retriever = None
#
# Alive users
#
self._alive_users_collection = AliveUsersCollection.AliveUsersCollection(
self._locator, self._cfg_manager, session_type, self._reservations_session_manager, self._coordinator, self._commands_store, self._coordinator.finished_reservations_store)
# Login Manager
self._login_manager = LoginManager(self._db_manager, self)
#
# Initialize facade (comm) servers
#
self._server_route = cfg_manager.get_doc_value(configuration_doc.CORE_FACADE_SERVER_ROUTE)
self.flask_server = WebLabFlaskServer(self, cfg_manager)
self.babel = self.flask_server.babel
self.dont_start = cfg_manager.get_value('dont_start', dont_start)
if not self.dont_start:
self.flask_server.start()
self.app = self.flask_server.app
#
# Start checking times
#
checking_time = self._cfg_manager.get_value(CHECKING_TIME_NAME, DEFAULT_CHECKING_TIME)
timer = threading.Timer(checking_time, self._renew_checker_timer)
timer.setName(counter.next_name("ups-checker-timer"))
timer.setDaemon(True)
timer.start()
_resource_manager.add_resource(timer)
class UserProcessingServer(object):
"""
The UserProcessingServer will receive client requests, which will be forwarded
to an appropriate UserProcessor for the specified session identifier.
"""
def __init__(self, coord_address, locator, cfg_manager, dont_start = False, *args, **kwargs):
super(UserProcessingServer,self).__init__(*args, **kwargs)
log.log( UserProcessingServer, log.level.Info, "Starting Core Server...")
self._stopping = False
self._cfg_manager = cfg_manager
self.config = cfg_manager
self._locator = locator
self.core_server_url = cfg_manager.get_doc_value(configuration_doc.CORE_SERVER_URL)
if cfg_manager.get_value(configuration_doc.CORE_UNIVERSAL_IDENTIFIER, 'default') == 'default' or cfg_manager.get_value(configuration_doc.CORE_UNIVERSAL_IDENTIFIER_HUMAN, 'default') == 'default':
generated = uuid.uuid1()
msg = "Property %(property)s or %(property_human)s not configured. Please establish: %(property)s = '%(uuid)s' and %(property_human)s = 'server at university X'. Otherwise, when federating the experiment it could enter in an endless loop." % {
'property' : configuration_doc.CORE_UNIVERSAL_IDENTIFIER,
'property_human' : configuration_doc.CORE_UNIVERSAL_IDENTIFIER_HUMAN,
'uuid' : generated
}
print(msg)
print(msg, file = sys.stderr)
log.log( UserProcessingServer, log.level.Error, msg)
self.core_server_universal_id = cfg_manager.get_doc_value(configuration_doc.CORE_UNIVERSAL_IDENTIFIER)
self.core_server_universal_id_human = cfg_manager.get_doc_value(configuration_doc.CORE_UNIVERSAL_IDENTIFIER_HUMAN)
#
# Create session managers
#
session_type_str = cfg_manager.get_doc_value(configuration_doc.WEBLAB_CORE_SERVER_SESSION_TYPE)
if not hasattr(SessionType, session_type_str):
raise coreExc.NotASessionTypeError( 'Not a session type: %s' % session_type_str )
session_type = getattr(SessionType, session_type_str)
session_pool_id = cfg_manager.get_doc_value(configuration_doc.WEBLAB_CORE_SERVER_SESSION_POOL_ID)
self._session_manager = SessionManager.SessionManager( cfg_manager, session_type, session_pool_id )
reservations_session_pool_id = cfg_manager.get_value(WEBLAB_CORE_SERVER_RESERVATIONS_SESSION_POOL_ID, "CoreServerReservations")
self._reservations_session_manager = SessionManager.SessionManager( cfg_manager, session_type, reservations_session_pool_id )
#
# Coordination
#
coordinator_implementation = cfg_manager.get_doc_value(configuration_doc.COORDINATOR_IMPL)
self._coordinator = coordinator_create(coordinator_implementation, self._locator, cfg_manager)
#
# Database and information storage managers
#
self._db_manager = DatabaseGateway(cfg_manager)
self.db = self._db_manager
cfg_manager.client = DbConfig(self.db.client_configuration)
cfg_manager.server = DbConfig(self.db.server_configuration)
self._commands_store = TemporalInformationStore.CommandsTemporalInformationStore()
self._temporal_information_retriever = TemporalInformationRetriever.TemporalInformationRetriever(cfg_manager, self._coordinator.initial_store, self._coordinator.finished_store, self._commands_store, self._coordinator.completed_store, self._db_manager)
self._temporal_information_retriever.start()
clean = cfg_manager.get('core_number') == 0
if clean:
self._location_retriever = LocationRetriever(cfg_manager, self._db_manager)
self._location_retriever.start()
else:
self._location_retriever = None
#
# Alive users
#
self._alive_users_collection = AliveUsersCollection.AliveUsersCollection(
self._locator, self._cfg_manager, session_type, self._reservations_session_manager, self._coordinator, self._commands_store, self._coordinator.finished_reservations_store)
# Login Manager
self._login_manager = LoginManager(self._db_manager, self)
#
# Initialize facade (comm) servers
#
self._server_route = cfg_manager.get_doc_value(configuration_doc.CORE_FACADE_SERVER_ROUTE)
self.flask_server = WebLabFlaskServer(self, cfg_manager)
self.dont_start = cfg_manager.get_value('dont_start', dont_start)
if not self.dont_start:
self.flask_server.start()
self.app = self.flask_server.app
#
# Start checking times
#
checking_time = self._cfg_manager.get_value(CHECKING_TIME_NAME, DEFAULT_CHECKING_TIME)
timer = threading.Timer(checking_time, self._renew_checker_timer)
timer.setName(counter.next_name("ups-checker-timer"))
timer.setDaemon(True)
timer.start()
_resource_manager.add_resource(timer)
def stop(self):
""" Stops all the servers and threads """
self._stopping = True
self._temporal_information_retriever.stop()
self._coordinator.stop()
if self._location_retriever is not None:
self._location_retriever.stop()
if hasattr(super(UserProcessingServer, self), 'stop'):
super(UserProcessingServer, self).stop()
if not self.dont_start:
self.flask_server.stop()
def _load_user(self, session):
return UserProcessor.UserProcessor(self._locator, session, self._cfg_manager, self._coordinator, self._db_manager, self._commands_store)
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)
def _check_reservation_not_expired_and_poll(self, reservation_processor, check_expired = True):
if check_expired and reservation_processor.is_expired():
reservation_processor.finish()
reservation_id = reservation_processor.get_reservation_id()
raise coreExc.NoCurrentReservationError( 'Current user (identified by reservation %r) does not have any experiment assigned' % reservation_id )
try:
reservation_processor.poll()
except coreExc.NoCurrentReservationError:
if check_expired:
raise
reservation_processor.update_latest_timestamp()
# It's already locked, we just update that this user is still among us
self._reservations_session_manager.modify_session(
reservation_processor.get_reservation_session_id(),
reservation_processor.get_session()
)
@threaded(_resource_manager)
def _purge_expired_users(self, expired_users):
for expired_reservation in expired_users:
if self._stopping:
return
try:
expired_session = self._reservations_session_manager.get_session_locking(expired_reservation)
try:
reservation_processor = self._load_reservation(expired_session)
reservation_processor.finish()
finally:
self._reservations_session_manager.modify_session_unlocking(expired_reservation, expired_session)
except Exception as e:
log.log( UserProcessingServer, log.level.Error,
"Exception freeing experiment of %s: %s" % (expired_reservation, e))
log.log_exc( UserProcessingServer, log.level.Warning)
def _renew_checker_timer(self):
checking_time = self._cfg_manager.get_value(CHECKING_TIME_NAME, DEFAULT_CHECKING_TIME)
while not self._stopping:
expired_users = self._alive_users_collection.check_expired_users()
if len(expired_users) > 0:
self._purge_expired_users(expired_users)
time.sleep(checking_time)
# # # # # # # # # # # #
# Session operations #
# # # # # # # # # # # #
def _reserve_session(self, db_session_id):
session_id = self._session_manager.create_session()
initial_session = {
'db_session_id' : db_session_id,
'session_id' : session_id,
'latest_timestamp' : 0 # epoch
}
user_processor = self._load_user(initial_session)
user_processor.get_user_information()
user_processor.update_latest_timestamp()
self._session_manager.modify_session(session_id,initial_session)
return session_id, self._server_route
class UserProcessingServer(object):
"""
The UserProcessingServer will receive client requests, which will be forwarded
to an appropriate UserProcessor for the specified session identifier.
"""
def __init__(self, coord_address, locator, cfg_manager, dont_start = False, *args, **kwargs):
super(UserProcessingServer,self).__init__(*args, **kwargs)
log.log( UserProcessingServer, log.level.Info, "Starting Core Server...")
self._stopping = False
self._cfg_manager = cfg_manager
self.config = cfg_manager
self._locator = locator
self.core_server_url = cfg_manager.get_doc_value(configuration_doc.CORE_SERVER_URL)
if cfg_manager.get_value(configuration_doc.CORE_UNIVERSAL_IDENTIFIER, 'default') == 'default' or cfg_manager.get_value(configuration_doc.CORE_UNIVERSAL_IDENTIFIER_HUMAN, 'default') == 'default':
generated = uuid.uuid1()
msg = "Property %(property)s or %(property_human)s not configured. Please establish: %(property)s = '%(uuid)s' and %(property_human)s = 'server at university X'. Otherwise, when federating the experiment it could enter in an endless loop." % {
'property' : configuration_doc.CORE_UNIVERSAL_IDENTIFIER,
'property_human' : configuration_doc.CORE_UNIVERSAL_IDENTIFIER_HUMAN,
'uuid' : generated
}
print(msg)
print(msg, file = sys.stderr)
log.log( UserProcessingServer, log.level.Error, msg)
self.core_server_universal_id = cfg_manager.get_doc_value(configuration_doc.CORE_UNIVERSAL_IDENTIFIER)
self.core_server_universal_id_human = cfg_manager.get_doc_value(configuration_doc.CORE_UNIVERSAL_IDENTIFIER_HUMAN)
#
# Create session managers
#
session_type_str = cfg_manager.get_doc_value(configuration_doc.WEBLAB_CORE_SERVER_SESSION_TYPE)
if not hasattr(SessionType, session_type_str):
raise coreExc.NotASessionTypeError( 'Not a session type: %s' % session_type_str )
session_type = getattr(SessionType, session_type_str)
session_pool_id = cfg_manager.get_doc_value(configuration_doc.WEBLAB_CORE_SERVER_SESSION_POOL_ID)
self._session_manager = SessionManager.SessionManager( cfg_manager, session_type, session_pool_id )
reservations_session_pool_id = cfg_manager.get_value(WEBLAB_CORE_SERVER_RESERVATIONS_SESSION_POOL_ID, "CoreServerReservations")
self._reservations_session_manager = SessionManager.SessionManager( cfg_manager, session_type, reservations_session_pool_id )
#
# Coordination
#
coordinator_implementation = cfg_manager.get_doc_value(configuration_doc.COORDINATOR_IMPL)
self._coordinator = coordinator_create(coordinator_implementation, self._locator, cfg_manager)
#
# Database and information storage managers
#
self._db_manager = DatabaseGateway(cfg_manager)
self.db = self._db_manager
cfg_manager.client = DbConfig(self.db.client_configuration)
cfg_manager.server = DbConfig(self.db.server_configuration)
self._commands_store = TemporalInformationStore.CommandsTemporalInformationStore()
self._temporal_information_retriever = TemporalInformationRetriever.TemporalInformationRetriever(cfg_manager, self._coordinator.initial_store, self._coordinator.finished_store, self._commands_store, self._coordinator.completed_store, self._db_manager)
self._temporal_information_retriever.start()
clean = cfg_manager.get('core_number') == 0
if clean:
self._location_retriever = LocationRetriever(cfg_manager, self._db_manager)
self._location_retriever.start()
else:
self._location_retriever = None
#
# Alive users
#
self._alive_users_collection = AliveUsersCollection.AliveUsersCollection(
self._locator, self._cfg_manager, session_type, self._reservations_session_manager, self._coordinator, self._commands_store, self._coordinator.finished_reservations_store)
# Login Manager
self._login_manager = LoginManager(self._db_manager, self)
#
# Initialize facade (comm) servers
#
self._server_route = cfg_manager.get_doc_value(configuration_doc.CORE_FACADE_SERVER_ROUTE)
self.flask_server = WebLabFlaskServer(self, cfg_manager)
self.babel = self.flask_server.babel
self.dont_start = cfg_manager.get_value('dont_start', dont_start)
if not self.dont_start:
self.flask_server.start()
self.app = self.flask_server.app
#
# Start checking times
#
checking_time = self._cfg_manager.get_value(CHECKING_TIME_NAME, DEFAULT_CHECKING_TIME)
timer = threading.Timer(checking_time, self._renew_checker_timer)
timer.setName(counter.next_name("ups-checker-timer"))
timer.setDaemon(True)
timer.start()
_resource_manager.add_resource(timer)
def stop(self):
""" Stops all the servers and threads """
self._stopping = True
self._temporal_information_retriever.stop()
self._coordinator.stop()
if self._location_retriever is not None:
self._location_retriever.stop()
if hasattr(super(UserProcessingServer, self), 'stop'):
super(UserProcessingServer, self).stop()
if not self.dont_start:
self.flask_server.stop()
def _load_user(self, session):
return UserProcessor.UserProcessor(self._locator, session, self._cfg_manager, self._coordinator, self._db_manager, self._commands_store)
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)
def _check_reservation_not_expired_and_poll(self, reservation_processor, check_expired = True):
if check_expired and reservation_processor.is_expired():
reservation_processor.finish()
reservation_id = reservation_processor.get_reservation_id()
raise coreExc.NoCurrentReservationError( 'Current user (identified by reservation %r) does not have any experiment assigned' % reservation_id )
try:
reservation_processor.poll()
except coreExc.NoCurrentReservationError:
if check_expired:
raise
reservation_processor.update_latest_timestamp()
# It's already locked, we just update that this user is still among us
self._reservations_session_manager.modify_session(
reservation_processor.get_reservation_session_id(),
reservation_processor.get_session()
)
@threaded(_resource_manager)
def _purge_expired_users(self, expired_users):
for expired_reservation in expired_users:
if self._stopping:
return
try:
expired_session = self._reservations_session_manager.get_session_locking(expired_reservation)
try:
reservation_processor = self._load_reservation(expired_session)
reservation_processor.finish()
finally:
self._reservations_session_manager.modify_session_unlocking(expired_reservation, expired_session)
except Exception as e:
log.log( UserProcessingServer, log.level.Error,
"Exception freeing experiment of %s: %s" % (expired_reservation, e))
log.log_exc( UserProcessingServer, log.level.Warning)
def _renew_checker_timer(self):
checking_time = self._cfg_manager.get_value(CHECKING_TIME_NAME, DEFAULT_CHECKING_TIME)
while not self._stopping:
expired_users = self._alive_users_collection.check_expired_users()
if len(expired_users) > 0:
self._purge_expired_users(expired_users)
time.sleep(checking_time)
# # # # # # # # # # # #
# Session operations #
# # # # # # # # # # # #
def _reserve_session(self, db_session_id):
session_id = self._session_manager.create_session()
initial_session = {
'db_session_id' : db_session_id,
'session_id' : session_id,
'latest_timestamp' : 0 # epoch
}
user_processor = self._load_user(initial_session)
user_processor.get_user_information()
user_processor.update_latest_timestamp()
self._session_manager.modify_session(session_id,initial_session)
return session_id, self._server_route
