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.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)
