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 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 rollback(name):
"""
Rolls back migration
"""
migrator = Router(db, logger=LOGGER)
migrator.migrate_dir = os.path.join(base_dir, 'application', 'migrations')
migrator.rollback(name)
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 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)
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)
def test_migrations(app_before_init_db):
"""The database migrations complete successfully."""
app, conf_obj = app_before_init_db
dbp.connect()
if conf_obj.database.engine == "PostgresqlDatabase":
dbp.execute_sql("DROP SCHEMA public CASCADE;")
dbp.execute_sql("CREATE SCHEMA public;")
dbp.execute_sql("GRANT ALL ON SCHEMA public TO public;")
router = Router(dbp, migrate_dir="migrations", ignore=["basemodel"])
router.run()
applied_migrations = list(router.done)
applied_migrations.reverse()
# Shut up a warning in rollback that we can't do anything about.
logging.getLogger("peewee_migrate").warn = Mock()
# Make sure new rollbacks work. The existing ones are what they are.
for m in applied_migrations:
if m == "029_message_read":
break
router.rollback(m)
dbp.close()
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)
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 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 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 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 get_router():
database.connect()
logger = logging.getLogger('migration')
logger.setLevel(logging.DEBUG)
return Router(database,
migrate_dir='migrations',
ignore=['basemodel'],
logger=logger)
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 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 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 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 __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 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 get_router():
database.connect()
logger = logging.getLogger("migration")
logger.setLevel(logging.DEBUG)
return Router(database,
migrate_dir="migrations",
ignore=["basemodel"],
logger=logger)
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 __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 makemigrations(auto=False):
"""database makemigrations
:param auto: auto=True, run all unapplied migrations
"""
router = Router(db, ignore='basemodel')
if auto:
router.create(auto=models)
else:
router.create()
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 create():
database = db.database
database.connect()
router = Router(database)
# Create migration
# router.create(name=BaseModel.sub_models())
router.create(auto=db)
# Run all unapplied migrations
router.run()
def run(path):
items.db.connect()
router = Router(items.db,
ignore="basemodel",
migrate_dir=path,
migrate_table='toolsmigrate')
router.create(auto=items)
router.run()
items.db.close()
def migrate():
database = PostgresqlDatabase(
database='postgres',
user='******',
host='127.0.0.1',
port='5432',
# password='******'
)
router = Router(database)
router.run()
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 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 run(path):
db_items_module.db.connect()
# migrate_table: 迁移表的名称
router = Router(db_items_module.db,
ignore="basemodel",
migrate_dir=path,
migrate_table='toolsmigrate')
router.create(auto=db_items_module)
router.run()
db_items_module.db.close()