def setUp(self): self.mocker = mocker.Mocker() self.lab_mock = self.mocker.mock() self.locator = FakeLocator( lab = self.lab_mock ) self.db = FakeDatabase() self.cfg_manager = ConfigurationManager.ConfigurationManager() self.cfg_manager.append_module(configuration_module) self.cfg_manager._set_value(COORDINATOR_LABORATORY_SERVERS, { 'server:laboratoryserver@labmachine' : { 'inst1|ud-dummy|Dummy experiments' : 'res_inst@res_type' } }) self.commands_store = TemporalInformationStore.CommandsTemporalInformationStore() self.coordinator = coordinator_create(SQLALCHEMY, self.locator, self.cfg_manager, ConfirmerClass = FakeConfirmer) self.coordinator._clean() self.coordinator.add_experiment_instance_id("server:laboratoryserver@labmachine", ExperimentInstanceId('inst','ud-dummy','Dummy experiments'), Resource("res_type", "res_inst")) self.processor = UserProcessor.UserProcessor( self.locator, { 'db_session_id' : ValidDatabaseSessionId('my_db_session_id') }, self.cfg_manager, self.coordinator, self.db, self.commands_store )
def setUp(self): self.coord_address = CoordAddress.translate( "server0:instance0@machine0" ) self.cfg_manager = ConfigurationManager.ConfigurationManager() self.cfg_manager.append_module(configuration_module) self.cfg_manager._set_value(CoordinationConfigurationParser.COORDINATOR_LABORATORY_SERVERS, { 'server:laboratoryserver@labmachine' : { 'inst|ud-dummy|Dummy experiments' : 'dummy1@dummy boards' } } ) self.cfg_manager._set_value("core_number", 0) self.mocker = mocker.Mocker() self.lab_mock = self.mocker.mock() self.locator = FakeLocator(self.lab_mock) # Clean the database coordinator = coordinator_create(SQLALCHEMY, self.locator, self.cfg_manager) coordinator._clean() coordinator.stop() # External server generation self.ups = WrappedUPS( self.coord_address, self.locator, self.cfg_manager ) self.ups._db_manager._delete_all_uses()
def setUp(self): self.mocker = mocker.Mocker() self.lab_mock = self.mocker.mock() self.locator = FakeLocator(lab=self.lab_mock) self.db = FakeDatabase() self.cfg_manager = ConfigurationManager.ConfigurationManager() self.cfg_manager.append_module(configuration_module) self.cfg_manager._set_value( COORDINATOR_LABORATORY_SERVERS, { 'server:laboratoryserver@labmachine': { 'inst1|ud-dummy|Dummy experiments': 'res_inst@res_type' } }) self.commands_store = TemporalInformationStore.CommandsTemporalInformationStore( ) self.coordinator = coordinator_create(SQLALCHEMY, self.locator, self.cfg_manager, ConfirmerClass=FakeConfirmer) self.coordinator._clean() self.coordinator.add_experiment_instance_id( "server:laboratoryserver@labmachine", ExperimentInstanceId('inst', 'ud-dummy', 'Dummy experiments'), Resource("res_type", "res_inst")) self.processor = UserProcessor.UserProcessor( self.locator, {'db_session_id': ValidDatabaseSessionId('my_db_session_id')}, self.cfg_manager, self.coordinator, self.db, self.commands_store)
def setUp(self): self.maxDiff = 2000 def _find_server(server_type, name): return self.ups self._find_server_backup = methods._find_server methods._find_server = _find_server self.locator = FakeLocator() 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' } }) # With this one we clean everything before creating the UPS self.coordinator = coordinator_create(SQLALCHEMY, self.locator, self.cfg_manager, ConfirmerClass = ConfirmerMock) self.coordinator._clean() self.coord_address = CoordAddress.translate( "server0:instance0@machine0" ) self.ups = UserProcessingServer.UserProcessingServer( self.coord_address, self.locator, self.cfg_manager ) self.ups._coordinator.stop() self.ups._coordinator = self.coordinator self.coordinator.add_experiment_instance_id("server:laboratoryserver@labmachine", ExperimentInstanceId('inst','ud-dummy','Dummy experiments'), Resource("res_type", "res_inst"))
def generate_core_server(self, cfg_manager, protocols): ups_coord_address = CoordAddress.CoordAddress.translate_address( "ups1:WL_SERVER1@WL_MACHINE1") locator = self.generate_locator() generated_ups = ServerSkel.factory( cfg_manager, protocols, weblab_exported_methods.UserProcessing) class RealUserProcessingServer( UserProcessingServer.UserProcessingServer, generated_ups): def __init__(self, coord_address, locator, cfg_manager, *args, **kargs): UserProcessingServer.UserProcessingServer.__init__( self, coord_address, locator, cfg_manager, *args, **kargs) coordinator = coordinator_create(SQLALCHEMY, self.locator, self.cfg_manager) coordinator._clean() coordinator.stop() real_core_server = RealUserProcessingServer( ups_coord_address, locator, cfg_manager, Direct=(ups_coord_address.address, ), SOAP=('', 10126)) real_core_server.start() core_client = locator.get_server(ServerType.UserProcessing, None) return core_client, real_core_server
def setUp(self): self.maxDiff = 2000 def _find_server(server_type, name): return self.ups self._find_server_backup = methods._find_server methods._find_server = _find_server self.locator = FakeLocator() 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' } }) # With this one we clean everything before creating the UPS self.coordinator = coordinator_create(SQLALCHEMY, self.locator, self.cfg_manager, ConfirmerClass = ConfirmerMock) self.coordinator._clean() self.coord_address = CoordAddress.CoordAddress.translate_address( "server0:instance0@machine0" ) self.ups = UserProcessingServer.UserProcessingServer( self.coord_address, self.locator, self.cfg_manager ) self.ups._coordinator.stop() self.ups._coordinator = self.coordinator self.coordinator.add_experiment_instance_id("server:laboratoryserver@labmachine", ExperimentInstanceId('inst','ud-dummy','Dummy experiments'), Resource("res_type", "res_inst"))
def setUp(self): self.coord_address = CoordAddress.CoordAddress.translate_address( "server0:instance0@machine0" ) self.cfg_manager = ConfigurationManager.ConfigurationManager() self.cfg_manager.append_module(configuration_module) self.cfg_manager._set_value(CoordinationConfigurationParser.COORDINATOR_LABORATORY_SERVERS, { 'server:laboratoryserver@labmachine' : { 'inst|ud-dummy|Dummy experiments' : 'dummy1@dummy boards' } } ) self.mocker = mocker.Mocker() self.lab_mock = self.mocker.mock() self.locator = FakeLocator(self.lab_mock) # Clean the database coordinator = coordinator_create(SQLALCHEMY, self.locator, self.cfg_manager) coordinator._clean() coordinator.stop() # External server generation self.ups = WrappedUPS( self.coord_address, self.locator, self.cfg_manager ) self.ups._db_manager._gateway._delete_all_uses()
def setUp(self): self.coord_address = CoordAddress.translate( "server0:instance0@machine0") self.mock_locator = self.mocker.mock() self.cfg_manager = ConfigurationManager.ConfigurationManager() self.cfg_manager.append_module(configuration_module) self.cfg_manager._set_value(COORDINATOR_LABORATORY_SERVERS, { u'lab1:inst@machine' : { 'inst1|exp1|cat1' : 'res_inst@res_type' }, }) self.coordinator = coordinator_create(SQLALCHEMY, self.mock_locator, self.cfg_manager) self.coordinator._clean() self.confirmer = self.coordinator.confirmer self.lab_address = u"lab1:inst@machine" self.coordinator.add_experiment_instance_id(self.lab_address, ExperimentInstanceId('inst1', 'exp1','cat1'), Resource("res_type", "res_inst"))
def setUp(self): self.coord_address = CoordAddress.CoordAddress.translate_address( "server0:instance0@machine0") self.mock_locator = MockLocator() self.locator = EasyLocator.EasyLocator( self.coord_address, self.mock_locator ) self.cfg_manager = ConfigurationManager.ConfigurationManager() self.cfg_manager.append_module(configuration_module) self.cfg_manager._set_value(COORDINATOR_LABORATORY_SERVERS, { u'lab1:inst@machine' : { 'inst1|exp1|cat1' : 'res_inst@res_type' }, }) self.coordinator = coordinator_create(SQLALCHEMY, self.locator, self.cfg_manager) self.coordinator._clean() self.confirmer = self.coordinator.confirmer self.lab_address = u"lab1:inst@machine" self.coordinator.add_experiment_instance_id(self.lab_address, ExperimentInstanceId('inst1', 'exp1','cat1'), Resource("res_type", "res_inst"))
def generate_core_server(self, cfg_manager, protocols): ups_coord_address = CoordAddress.CoordAddress.translate_address("ups1:WL_SERVER1@WL_MACHINE1") locator = self.generate_locator() generated_ups = ServerSkel.factory( cfg_manager, protocols, weblab_exported_methods.UserProcessing ) class RealUserProcessingServer(UserProcessingServer.UserProcessingServer,generated_ups): def __init__(self, coord_address, locator, cfg_manager, *args,**kargs): UserProcessingServer.UserProcessingServer.__init__( self, coord_address, locator, cfg_manager, *args, **kargs ) coordinator = coordinator_create(SQLALCHEMY, self.locator, self.cfg_manager) coordinator._clean() coordinator.stop() real_core_server = RealUserProcessingServer( ups_coord_address, locator, cfg_manager, Direct = (ups_coord_address.address,), SOAP = ('',10126) ) real_core_server.start() core_client = locator.get_server(ServerType.UserProcessing, None) return core_client, real_core_server
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 >> sys.stderr, msg 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._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() # # 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)
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._locator = locator self.core_server_url = cfg_manager.get_doc_value(configuration_doc.CORE_SERVER_URL) if cfg_manager.get_value(WEBLAB_CORE_SERVER_UNIVERSAL_IDENTIFIER, 'default') == 'default' or cfg_manager.get_value(WEBLAB_CORE_SERVER_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' : WEBLAB_CORE_SERVER_UNIVERSAL_IDENTIFIER, 'property_human' : WEBLAB_CORE_SERVER_UNIVERSAL_IDENTIFIER_HUMAN, 'uuid' : generated } print msg print >> sys.stderr, msg log.log( UserProcessingServer, log.level.Error, msg) self.core_server_universal_id = cfg_manager.get_value(WEBLAB_CORE_SERVER_UNIVERSAL_IDENTIFIER, DEFAULT_WEBLAB_CORE_SERVER_UNIVERSAL_IDENTIFIER) self.core_server_universal_id_human = cfg_manager.get_value(WEBLAB_CORE_SERVER_UNIVERSAL_IDENTIFIER_HUMAN, DEFAULT_WEBLAB_CORE_SERVER_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_value(WEBLAB_CORE_SERVER_SESSION_POOL_ID, "UserProcessingServer") 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_value(WEBLAB_CORE_SERVER_COORDINATION_IMPLEMENTATION, SQLALCHEMY) self._coordinator = coordinator_create(coordinator_implementation, self._locator, cfg_manager) # # Database and information storage managers # self._db_manager = DatabaseManager.UserProcessingDatabaseManager(cfg_manager) 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() # # 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) # # Initialize facade (comm) servers # self._server_route = cfg_manager.get_value(UserProcessingFacadeServer.USER_PROCESSING_FACADE_SERVER_ROUTE, UserProcessingFacadeServer.DEFAULT_USER_PROCESSING_SERVER_ROUTE) self._facade_servers = [] if not dont_start: for FacadeClass in self.FACADE_SERVERS: facade_server = FacadeClass(self, cfg_manager) self._facade_servers.append(facade_server) facade_server.start() # # Start checking times # self._initialize_checker_timer()
def __init__(self, coord_address, locator, cfg_manager, *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._locator = locator if cfg_manager.get_value(WEBLAB_CORE_SERVER_UNIVERSAL_IDENTIFIER, 'default') == 'default' or cfg_manager.get_value(WEBLAB_CORE_SERVER_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' : WEBLAB_CORE_SERVER_UNIVERSAL_IDENTIFIER, 'property_human' : WEBLAB_CORE_SERVER_UNIVERSAL_IDENTIFIER_HUMAN, 'uuid' : generated } print msg print >> sys.stderr, msg log.log( UserProcessingServer, log.level.Error, msg) self.core_server_universal_id = cfg_manager.get_value(WEBLAB_CORE_SERVER_UNIVERSAL_IDENTIFIER, DEFAULT_WEBLAB_CORE_SERVER_UNIVERSAL_IDENTIFIER) self.core_server_universal_id_human = cfg_manager.get_value(WEBLAB_CORE_SERVER_UNIVERSAL_IDENTIFIER_HUMAN, DEFAULT_WEBLAB_CORE_SERVER_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_value(WEBLAB_CORE_SERVER_SESSION_POOL_ID, "UserProcessingServer") 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_value(WEBLAB_CORE_SERVER_COORDINATION_IMPLEMENTATION, SQLALCHEMY) self._coordinator = coordinator_create(coordinator_implementation, self._locator, cfg_manager) # # Database and information storage managers # self._db_manager = DatabaseManager.UserProcessingDatabaseManager(cfg_manager) 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() # # 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) # # Initialize facade (comm) servers # self._server_route = cfg_manager.get_value(UserProcessingFacadeServer.USER_PROCESSING_FACADE_SERVER_ROUTE, UserProcessingFacadeServer.DEFAULT_USER_PROCESSING_SERVER_ROUTE) self._facade_servers = [] for FacadeClass in self.FACADE_SERVERS: facade_server = FacadeClass(self, cfg_manager) self._facade_servers.append(facade_server) facade_server.start() # # Start checking times # self._initialize_checker_timer()