def _initialize(self): # Manages a RDB engine and a metadata instance for this repository. # Both are global objects that should only be created once per process # (for each RDB repository), hence we use a global object manager. if not is_engine_initialized(self.name): engine = self.__make_engine() set_engine(self.name, engine) # Bind the engine to the session factory and the metadata. self.session_factory.configure(bind=engine) else: engine = get_engine(self.name) if not is_metadata_initialized(self.name): md_fac = self._config["metadata_factory"] if self._config.get("messaging_enable", False): # Wrap the metadata callback to also call the mapping # function for system entities. reset_on_start = self._config.get("messaging_reset_on_start", False) def wrapper(engine, reset_on_start=reset_on_start): metadata = md_fac(engine) map_system_entities(engine, metadata, reset_on_start) return metadata metadata = wrapper(engine) else: metadata = md_fac(engine) set_metadata(self.name, metadata) else: metadata = get_metadata(self.name) metadata.bind = engine
def _initialize(self): # Manages a RDB engine and a metadata instance for this repository. # Both are global objects that should only be created once per process # (for each RDB repository), hence we use a global object manager. if not is_engine_initialized(self.name): engine = self.__make_engine() set_engine(self.name, engine) # Bind the engine to the session factory and the metadata. self.session_factory.configure(bind=engine) else: engine = get_engine(self.name) if not is_metadata_initialized(self.name): md_fac = self._config['metadata_factory'] if self._config.get('messaging_enable', False): # Wrap the metadata callback to also call the mapping # function for system entities. reset_on_start = \ self._config.get('messaging_reset_on_start', False) def wrapper(engine, reset_on_start=reset_on_start): metadata = md_fac(engine) map_system_entities(engine, metadata, reset_on_start) return metadata metadata = wrapper(engine) else: metadata = md_fac(engine) set_metadata(self.name, metadata) else: metadata = get_metadata(self.name) metadata.bind = engine
def test_rdb_engine_manager(self): key = 'test' self.assert_false(is_engine_initialized(key)) eng = create_engine('sqlite://') set_engine(key, eng) self.assert_raises(ValueError, set_engine, key, eng) self.assert_true(is_engine_initialized(key)) self.assert_true(get_engine(key) is eng) reset_engines() self.assert_false(is_engine_initialized(key))
def __exit__(self, ext_type, value, tb): # Roll back the outer transaction and close the connection. self.__session.close() self.__transaction.rollback() self.__connection.close() # Remove the session we created. Session.remove() # Restore flags. Session.configure(autoflush=self.__old_autoflush_flag, bind=get_engine(self.__engine_name)) self.__repo.join_transaction = self.__old_join_transaction_flag
def __enter__(self): # We set up an outer transaction that allows us to roll back all # changes (including commits) the unittest may want to make. engine = get_engine(self.__engine_name) self.__connection = engine.connect() self.__transaction = self.__connection.begin() # Configure the autoflush behavior of the session. self.__old_autoflush_flag = Session.autoflush # pylint:disable=E1101 Session.remove() Session.configure(autoflush=self.__autoflush) # Throw out the Zope transaction manager for testing. Session.configure(extension=None) # Create a new session for the tests. self.__session = Session(bind=self.__connection) return self.__session
def _initialize(self): if not is_engine_initialized(self.name): engine = self.__make_engine() set_engine(self.name, engine) else: engine = get_engine(self.name) db_name = self._config['db_name'] self.__db = operator.getitem(engine, db_name) if db_name == 'test': # Reset the test database. for coll_name in \ self.__db.collection_names(include_system_collections=False): self.__db.drop_collection(coll_name) # Set up the class registry. for rc in self.registered_resources: ent_cls = get_entity_class(rc) if not MongoClassRegistry.is_registered(ent_cls): MongoClassRegistry.register(ent_cls, self.__db)
def setup_thelma(thelma_settings): # Create source DB session. src_db_string = "postgresql+psycopg2://%s:%s@%s:%s/%s" \ % (DB_USER, DB_PWD, SOURCE_DB_HOST, SOURCE_DB_PORT, SOURCE_DB_NAME) src_engine = create_engine(src_db_string) src_session_maker = sessionmaker(bind=src_engine) src_sess = src_session_maker() # Initialize TheLMA and create target DB session. reg = Registry('thelma') config = create_config(thelma_settings, registry=reg) config.setup_registry(settings=thelma_settings) config.begin() config.load_zcml('configure.zcml') repo_mgr = config.get_registered_utility(IRepositoryManager) repo_mgr.initialize_all() tgt_engine = get_engine(REPOSITORY_TYPES.RDB) tgt_session_maker = sessionmaker(bind=tgt_engine) tgt_sess = tgt_session_maker() return src_sess, tgt_sess
def __enter__(self): # We set up an outer transaction that allows us to roll back all # changes (including commits) the unittest may want to make. engine = get_engine(self.__engine_name) self.__connection = engine.connect() self.__transaction = self.__connection.begin() reg = get_current_registry() repo_mgr = reg.getUtility(IRepositoryManager) self.__repo = repo_mgr.get(self.__engine_name) # Configure the autoflush behavior of the session. if Session.registry.has(): self.__old_autoflush_flag = Session.autoflush # pylint:disable=E1101 else: self.__old_autoflush_flag = self.__autoflush Session.remove() Session.configure(autoflush=self.__autoflush) # Create a new session for the tests. Session.configure(bind=self.__connection) self.__old_join_transaction_flag = self.__repo.join_transaction self.__repo.join_transaction = False self.__session = self.__repo.session_factory() return self.__session
def _make_session_factory(self): engine = get_engine(self.name) query_class = self.__check_query_class(engine) return RdbSessionFactory(self, query_class)