def async_db(request):
"""
Фикстура для асинхронного взаимодействия с базой PostgreSQL через PeeWee ORM
"""
# Создание базы
process = Popen(['createdb', TEST_DB])
process.communicate()
db.allow_sync = True
# Миграции
migrator = Router(db)
migrator.migrate_dir = os.path.join(base_dir, 'application', 'migrations')
migrator.run()
db.allow_sync = False
def teardown():
terminate_sql = ("SELECT pg_terminate_backend(pg_stat_activity.pid) "
"FROM pg_stat_activity "
"WHERE pg_stat_activity.datname = '%s' "
"AND pid <> pg_backend_pid();" % TEST_DB)
process = Popen(['psql', '-c', terminate_sql])
process.communicate()
process = Popen(['dropdb', TEST_DB])
process.communicate()
request.addfinalizer(teardown)
return db
def makemigrations(name='auto'):
"""
Makes migrations
"""
migrator = Router(db, logger=LOGGER)
migrator.migrate_dir = os.path.join(base_dir, 'application', 'migrations')
migrator.create(name=name, auto='project.application.models')
def migrate(name=None):
"""
Runs migrations
"""
migrator = Router(db, logger=LOGGER)
migrator.migrate_dir = os.path.join(base_dir, 'application', 'migrations')
migrator.run(name=name)
async def main():
load_modules(os.getcwd())
db.connect()
router = Router(db)
router.run()
mailer = Mailer(token=BOT_API_TOKEN, update_frequency=UPDATE_FREQUENCY)
await start_bot_jobs(mailer)
class Migrations(object):
"""
Migrations
Handle all migrations during application start.
"""
def __init__(self, config):
# Based on configuration, select database to connect to.
if config['TYPE'] == 'SQLITE':
# Create SQLite directory if not exists
db_file_directory = os.path.dirname(config['FILE'])
if not os.path.exists(db_file_directory):
os.makedirs(db_file_directory)
database = SqliteDatabase(config['FILE'])
self.router = Router(database=database,
migrate_dir=config['MIGRATIONS_DIR'])
def run_all(self):
"""
Run all new migrations.
Migrations that have already been run will be ignored.
:return:
"""
self.router.run()
def rollback(name):
"""
Rolls back migration
"""
migrator = Router(db, logger=LOGGER)
migrator.migrate_dir = os.path.join(base_dir, 'application', 'migrations')
migrator.rollback(name)
def create_migrations(name):
database = load_plugin("chain.plugins.database")
router = Router(database.db,
migrate_dir="chain/plugins/database/migrations")
# Create migration
router.create(name, auto="chain.plugins.database.models")
def app():
flask_app = create_app(configs['testing'])
router = Router(flask_app.db.database)
router.run()
yield flask_app
flask_app.db.close_db('')
current_path = os.path.dirname(__file__)
os.remove('{}/../test.db'.format(current_path))
def migrate(self):
from peewee_migrate import Router
with self._db() as db, db.atomic():
router = Router(db,
migrate_table=self.migrate_table,
migrate_dir=self.migrate_dir)
router.run()
def migrate():
database = load_plugin("chain.plugins.database")
migrate_dir = os.path.join(os.getcwd(), "chain", "plugins", "database",
"migrations")
router = Router(database.db, migrate_dir=migrate_dir)
router.run()
def apply_migrations():
# type: () -> None
logger.info('Applying migrations')
# Run all unapplied migrations
db = Database.get_db()
gateway_src = os.path.abspath(os.path.join(__file__, '..'))
router = Router(db,
migrate_dir=os.path.join(gateway_src, 'migrations/orm'))
router.run()
def run_migrations(collection_old_db_path):
# TODO: write tests for this
migrations_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)),
"database/migrations")
directory = os.path.dirname(collection_old_db_path)
router = Router(
SqliteDatabase(os.path.join(directory, 'collection_new.sqlite3')),
migrations_dir)
router.run()
def migrate(self, _):
"""Migrates database schema."""
from peewee_migrate import Router
with self._db('cardinal') as db, db.atomic():
router = Router(db,
migrate_table=self.migrate_table,
migrate_dir=self.migrate_dir)
router.run()
def rollback(self):
from peewee_migrate import Router
with self._db() as db, db.atomic():
router = Router(db,
migrate_table=self.migrate_table,
migrate_dir=self.migrate_dir)
if router.done:
router.rollback(router.done[-1])
def __init__(self, config):
# Based on configuration, select database to connect to.
if config['TYPE'] == 'SQLITE':
# Create SQLite directory if not exists
db_file_directory = os.path.dirname(config['FILE'])
if not os.path.exists(db_file_directory):
os.makedirs(db_file_directory)
database = SqliteDatabase(config['FILE'])
self.router = Router(database)
def rollback(self, _):
"""Rollbacks a latest migration."""
from peewee_migrate import Router
with self._db('cardinal') as db, db.atomic():
router = Router(db,
migrate_table=self.migrate_table,
migrate_dir=self.migrate_dir)
if router.done:
router.rollback(router.done[-1])
def __init__(self, app: typing.Union[str, apistar.App, apistar.ASyncApp]):
"""
Create a database manager from API Star application.
:param app: API Star application.
:return: Manager instance.
"""
self.app = self.get_app(app) if isinstance(app, str) else app
self.component = self.get_database_component(self.app)
self.router = Router(self.component.database)
def setup_db():
# init db
models.database.init(host=settings.DB_HOST,
database=DB_NAME,
user=settings.DB_USER,
password=settings.DB_PASSWORD)
# run migrations
router = Router(models.database)
router.run()
def migrate():
database = PostgresqlDatabase(
database='postgres',
user='******',
host='127.0.0.1',
port='5432',
# password='******'
)
router = Router(database)
router.run()
def create_migrations(name):
database = PostgresqlDatabase(
database='postgres',
user='******',
host='127.0.0.1',
port='5432',
# password='******'
)
router = Router(database)
# Create migration
router.create(name, auto='models')
def init_database(self):
migrate_db = SqliteExtDatabase(self.config.database.path)
# Run migrations
del (logging.getLogger('peewee_migrate').handlers[:])
router = Router(migrate_db)
router.run()
migrate_db.close()
self.db = SqliteQueueDatabase(self.config.database.path)
models = [Event]
self.db.bind(models)
def rollback():
try:
router = Router(models.database, ignore=[models.MyModel])
if not router.done:
logging.warning("没有migrate记录，无法回滚")
sys.exit(-1)
name = router.done[-1]
router.rollback(name)
clean(name)
except:
logging.exception("rollback失败")
sys.exit(-1)
def register_migration(app):
from peewee_migrate import Router
project_root = app.config.get('PROJECT_ROOT', '')
migrate_dir = f'{project_root}/migrations'
router = Router(
app.db.database,
migrate_dir=f'{migrate_dir}/main',
)
@migration.command()
def list():
print('=== MAIN ===')
for migration in router.done:
print(migration)
@migration.command()
@click.argument('name')
def create(name):
app_name = app.config.get('NAME', '')
router.create(name, f'{app_name}.models')
@migration.command()
def run():
router.run()
app.cli.add_command(migration)
def register_migration(app):
router = Router(
app.db.database,
migrate_dir=f'{DEFAULT_MIGRATE_DIR}/main',
)
# logs_router = Router(
# app.logdb.database,
# migrate_dir=f'{DEFAULT_MIGRATE_DIR}/logs',
# )
@migration.command()
def list():
print('=== MAIN ===')
for migration in router.done:
print(migration)
# print('=== LOGS ===')
# for migration in logs_router.done:
# print(migration)
@migration.command()
@click.argument('name')
def create(name):
router.create(name, 'freenit.models')
# @migration.command()
# @click.argument('name')
# def logs_create(name):
# logs_router.create(name, f'{app_name}.logging')
@migration.command()
def run():
router.run()
# logs_router.run()
app.cli.add_command(migration)
def migrate_tables():
from peewee_migrate import Router
router = Router(db)
# Create migration
router.create('migration_name', auto=True)
# Run migration/migrations
router.run('migration_name')
# Run all unapplied migrations
router.run()
def app():
config = configs['testing']
flask_app = create_app(config)
router = Router(
flask_app.db.database,
migrate_dir=f'{DEFAULT_MIGRATE_DIR}',
)
# log_router = Router(
# flask_app.logdb.database,
# migrate_dir=f'{DEFAULT_MIGRATE_DIR}/logs',
# )
router.run()
# log_router.run()
yield flask_app
flask_app.db.close_db('')
# flask_app.logdb.close_db('')
current_path = os.path.dirname(__file__)
def __init__(self, config):
unmanic_logging = unlogger.UnmanicLogger.__call__()
self.logger = unmanic_logging.get_logger(__class__.__name__)
# Based on configuration, select database to connect to.
if config['TYPE'] == 'SQLITE':
# Create SQLite directory if not exists
db_file_directory = os.path.dirname(config['FILE'])
if not os.path.exists(db_file_directory):
os.makedirs(db_file_directory)
self.database = SqliteDatabase(config['FILE'])
self.router = Router(database=self.database,
migrate_table='migratehistory_{}'.format(
config.get('MIGRATIONS_HISTORY_VERSION')),
migrate_dir=config.get('MIGRATIONS_DIR'),
logger=self.logger)
def get_router():
database.connect()
logger = logging.getLogger("migration")
logger.setLevel(logging.DEBUG)
return Router(database,
migrate_dir="migrations",
ignore=["basemodel"],
logger=logger)
def get_router():
database.connect()
logger = logging.getLogger('migration')
logger.setLevel(logging.DEBUG)
return Router(database,
migrate_dir='migrations',
ignore=['basemodel'],
logger=logger)
def init_database(self):
# Migrate DB location
old_db_path = os.path.join(CLIPS_DIR, "frigate.db")
if not os.path.isfile(
self.config.database.path) and os.path.isfile(old_db_path):
os.rename(old_db_path, self.config.database.path)
# Migrate DB schema
migrate_db = SqliteExtDatabase(self.config.database.path)
# Run migrations
del logging.getLogger("peewee_migrate").handlers[:]
router = Router(migrate_db)
router.run()
migrate_db.close()
self.db = SqliteQueueDatabase(self.config.database.path)
models = [Event, Recordings]
self.db.bind(models)