def _populate_database( cls, settings: plaster_pastedeploy.ConfigDict, add_test_data: bool ) -> None: engine = get_engine(settings) session_factory = get_session_factory(engine) app_config = CFG(settings) print("- Populate database with default data -") with transaction.manager: dbsession = get_tm_session(session_factory, transaction.manager) try: fixtures = [BaseFixture] fixtures_loader = FixturesLoader(dbsession, app_config) fixtures_loader.loads(fixtures) transaction.commit() if add_test_data: app_config.configure_filedepot() fixtures = [ContentFixture] fixtures_loader.loads(fixtures) transaction.commit() print("Database initialized.") except IntegrityError as exc: transaction.abort() print('Database initialization failed') raise DatabaseInitializationFailed( 'Warning, there was a problem when adding default data' ', it may have already been added.' ) from exc
def connect_database(self, create_tables: bool = False) -> None: self.engine = get_engine(self.app_config) if create_tables: DeclarativeBase.metadata.create_all(self.engine) self.session_factory = get_session_factory(self.engine) self.session = get_tm_session(self.session_factory, transaction.manager)
def _create_schema( cls, settings: plaster_pastedeploy.ConfigDict ) -> None: print("- Create Schemas of databases -") engine = get_engine(settings) DeclarativeBase.metadata.create_all(engine)
def take_action(self, parsed_args: argparse.Namespace) -> None: super(DeleteDBCommand, self).take_action(parsed_args) config_uri = parsed_args.config_file # setup_logging(config_uri) settings = get_appsettings(config_uri) settings.update(settings.global_conf) if 'sqlalchemy.url' not in settings or not settings['sqlalchemy.url']: raise InvalidSettingFile('Wrong or empty sqlalchemy database url,' 'check config file') engine = get_engine(settings) app_config = CFG(settings) app_config.configure_filedepot() if parsed_args.force: print('Database deletion begin.') DeclarativeBase.metadata.drop_all(engine) print('Database deletion done.') try: print('Cleaning depot begin.') depot = DepotManager.get() depot_files = depot.list() for file_ in depot_files: depot.delete(file_) print('Cleaning depot done.') except FileNotFoundError: print( 'Warning! Can delete depots file, is depot path correctly' ' configured?' ) else: raise ForceArgumentNeeded( 'Warning, You should use --force if you really want to' ' delete database.' )
def take_action(self, parsed_args: argparse.Namespace) -> None: super(DeleteDBCommand, self).take_action(parsed_args) config_uri = parsed_args.config_file # setup_logging(config_uri) settings = get_appsettings(config_uri) settings.update(settings.global_conf) app_config = CFG(settings) app_config.configure_filedepot() engine = get_engine(app_config) if parsed_args.force: print("Database deletion begin.") DeclarativeBase.metadata.drop_all(engine) print("Database deletion done.") try: print("Cleaning depot begin.") depot = DepotManager.get() depot_files = depot.list() for file_ in depot_files: try: depot.delete(file_) # TODO - G.M - 2019-05-09 - better handling of specific exception here except Exception as exc: traceback.print_exc() print("Something goes wrong during deletion of {}".format(file_)) raise exc print("Cleaning depot done.") except FileNotFoundError: print("Warning! Can delete depots file, is depot path correctly" " configured?") else: raise ForceArgumentNeeded( "Warning, You should use --force if you really want to" " delete database." )
def __init__(self, application, config): super().__init__(application, config) self._application = application self.settings = config['tracim_settings'] self.engine = get_engine(self.settings) self.session_factory = get_scoped_session_factory(self.engine) self.app_config = CFG(self.settings) self.app_config.configure_filedepot()
def __init__(self, application, config): super().__init__(application, config) self._application = application self.settings = config["tracim_settings"] self.app_config = CFG(self.settings) self.app_config.configure_filedepot() self.plugin_manager = init_plugin_manager(self.app_config) self.engine = get_engine(self.app_config) self.session_factory = get_session_factory(self.engine)
def work(self, *args, **kwargs): app_config = initialize_config_from_environment() _engines.push(get_engine(app_config)) _configs.push(app_config) try: super().work(*args, **kwargs) finally: _engines.pop() _configs.pop()
def engine(config, app_config): init_models(config, app_config) from tracim_backend.models.setup_models import get_engine if app_config.SQLALCHEMY__URL.startswith("sqlite"): isolation_level = "SERIALIZABLE" else: isolation_level = "READ_COMMITTED" engine = get_engine(app_config, isolation_level=isolation_level) yield engine engine.dispose()
def setUp(self) -> None: self._set_logger() logger.debug(self, "Setup Test...") self.settings = plaster.get_settings(self.config_uri, self.config_section) self.config = testing.setUp(settings=self.settings) DepotManager._clear() DepotManager.configure( "test", {"depot.backend": "depot.io.memory.MemoryFileStorage"}) settings = self.config.get_settings() self.app_config = CFG(settings) init_models(self.config, self.app_config) from tracim_backend.models.setup_models import ( get_engine, get_session_factory, get_tm_session, ) self.engine = get_engine(self.app_config) self.session_factory = get_session_factory(self.engine) self.init_database() self.session = get_tm_session(self.session_factory, transaction.manager)
def init_database(self) -> None: self.engine = get_engine(self.app_config)
def _create_schema(cls, app_config: CFG) -> None: print("- Create Schemas of databases -") engine = get_engine(app_config) DeclarativeBase.metadata.create_all(engine)
def take_action(self, parsed_args: argparse.Namespace) -> None: super(UpdateNamingConventionsV1ToV2Command, self).take_action(parsed_args) config_uri = parsed_args.config_file settings = get_appsettings(config_uri) settings.update(settings.global_conf) app_config = CFG(settings) app_config.configure_filedepot() engine = get_engine(app_config) inspector = reflection.Inspector.from_engine(engine) v1_unique_convention = re.compile(r"uk__(\w+)__(\w+)") v1_foreign_key_convention = re.compile(r"fk__(\w+)__(\w+)__(\w+)") v1_primary_key_convention = re.compile(r"pk__(\w+)") if not engine.dialect.name.startswith("postgresql"): raise ValueError( "This command is only supported on PostgreSQL databases") with engine.begin(): for table_name in inspector.get_table_names(): if table_name == "migrate_version": continue for unique_constraint in inspector.get_unique_constraints( table_name): match = v1_unique_convention.search( unique_constraint["name"]) if match: new_name = "uq__{}__{}".format(match.group(1), match.group(2)) engine.execute( "ALTER TABLE {} RENAME CONSTRAINT {} TO {}".format( table_name, unique_constraint["name"], new_name)) for foreign_key in inspector.get_foreign_keys(table_name): match = v1_foreign_key_convention.search( foreign_key["name"]) # special cases for content_revisions and revision_read_status if foreign_key[ "name"] == "fk__content_revisions__owner_id": new_name = "fk_content_revisions_owner_id_users" engine.execute( "ALTER TABLE {} RENAME CONSTRAINT {} TO {}".format( table_name, foreign_key["name"], new_name)) elif foreign_key[ "name"] == "revision_read_status_revision_id_fkey": new_name = "fk_revision_read_status_revision_id_content_revisions" engine.execute( "ALTER TABLE {} RENAME CONSTRAINT {} TO {}".format( table_name, foreign_key["name"], new_name)) elif foreign_key[ "name"] == "revision_read_status_user_id_fkey": new_name = "fk_revision_read_status_user_id_users" engine.execute( "ALTER TABLE {} RENAME CONSTRAINT {} TO {}".format( table_name, foreign_key["name"], new_name)) elif match: new_name = "fk_{}_{}_{}".format( match.group(1), match.group(2), match.group(3)) engine.execute( "ALTER TABLE {} RENAME CONSTRAINT {} TO {}".format( table_name, foreign_key["name"], new_name)) primary_key = inspector.get_pk_constraint(table_name) if primary_key: match = v1_primary_key_convention.search( primary_key["name"]) if primary_key["name"] == "pk__users__user_id": engine.execute( "ALTER INDEX {} RENAME TO pk_users".format( primary_key["name"])) elif primary_key[ "name"] == "pk__content_revisions__revision_id": engine.execute( "ALTER INDEX {} RENAME TO pk_content_revisions". format(primary_key["name"])) elif primary_key[ "name"] == "pk__user_workspace__user_id__workspace_id": engine.execute( "ALTER INDEX {} RENAME TO pk_user_workspace". format(primary_key["name"])) elif primary_key["name"] == "pk__workspace__workspace_id": engine.execute( "ALTER INDEX {} RENAME TO pk_workspaces".format( primary_key["name"])) elif primary_key["name"] == "revision_read_status_pkey": engine.execute( "ALTER INDEX {} RENAME TO pk_revision_read_status". format(primary_key["name"])) elif match: new_name = "pk_{}".format(match.group(1)) engine.execute("ALTER INDEX {} RENAME TO {}".format( primary_key["name"], new_name))
def init_database(self, settings: typing.Dict[str, typing.Any]) -> None: self.engine = get_engine(settings)