- from coprs import db

- from coprs.logic import coprs_logic, packages_logic, actions_logic

- from commands.rawhide_to_release import RawhideToReleaseCommand

- 

- 

- class BackendRawhideToReleaseCommand(RawhideToReleaseCommand):

- 

-     "Copy backend data of the latest successful rawhide builds into a new chroot"

- 

-     def run(self, rawhide_chroot, dest_chroot):

-         for copr in coprs_logic.CoprsLogic.get_all():

-             if not self.has_rawhide(copr):

-                 continue

- 

-             data = {"copr": copr.name,

-                     "user": copr.owner_name,

-                     "rawhide_chroot": rawhide_chroot,

-                     "dest_chroot": dest_chroot,

-                     "builds": []}

- 

-             for package in packages_logic.PackagesLogic.get_all(copr.id):

-                 last_build = package.last_build(successful=True)

-                 if last_build:

-                     data["builds"].append(last_build.result_dir)

- 

-             if len(data["builds"]):

-                 actions_logic.ActionsLogic.send_rawhide_to_release(data)

-                 print("Created copy action from {}/{} to {}/{}"

-                       .format(copr.full_name, rawhide_chroot, copr.full_name, dest_chroot))

- 

-         db.session.commit()

- from flask_script import Command

- class CleanExpiredProjectsCommand(Command):

-     # pylint: disable=method-hidden

-     def run(self):

-         with db_session_scope():

-             ComplexLogic.delete_expired_projects()

- from flask_script import Command

- class DeleteOldBuilds(Command):

- 

-     # pylint: disable=method-hidden

-     def run(self):

-         with db_session_scope():

-             BuildsLogic.clean_old_builds()

- from flask_script import Command

- class DeleteOrphansCommand(Command):

- 

-     def run(self):

-         BuildsLogic.delete_orphaned_builds()

-         PackagesLogic.delete_orphaned_packages()

- from flask_script import Command, Option

- class DeleteOutdatedChrootsCommand(Command):

-     option_list = [

-         Option("--dry-run", action="store_true",

-                help="Do not actually remove any data, but rather print information on stdout"),

-     ]

- 

-     def run(self, dry_run):

-         deleter = DryRunDeleter() if dry_run else Deleter()

- 

-         chroots = coprs_logic.CoprChrootsLogic \

-             .filter_outdated_to_be_deleted(coprs_logic.CoprChrootsLogic.get_multiple())

-         for i, chroot in enumerate(chroots, start=1):

-             # This command will possibly delete a lot of chroots and can be a performance issue when committing

-             # all at once. We are going to commit every x actions to avoid that.

-             if i % 1000 == 0:

-                 deleter.commit()

-             deleter.delete(chroot)

-         deleter.commit()

- from flask_script import Command, Option

- class FailBuildCommand(Command):

- 

-     option_list = [Option("build_id")]

- 

-     def run(self, build_id, **kwargs):

-         try:

-             builds_logic.BuildsLogic.mark_as_failed(build_id)

-             print("Marking non-finished chroots of build {} as failed".format(build_id))

-             db.session.commit()

-         except (sqlalchemy.exc.DataError, sqlalchemy.orm.exc.NoResultFound) as e:

-             print("Error: No such build {}".format(build_id))

-             return 1

- from flask_script import Command

- 

- class GetAdminsCommand(Command):

- 

-     def run(self, **kwargs):

-         for u in models.User.query.filter(models.User.admin == True).all():

-             print(u.username)

- from flask_script import Command, Option

- class NotifyOutdatedChrootsCommand(Command):

-     option_list = [

-         Option("--dry-run", action="store_true",

-                help="Do not actually notify the people, but rather print information on stdout"),

-         Option("-e", "--email", action="append", dest="email_filter",

-                help="Notify only "),

-         Option("-a", "--all", action="store_true",

-                help="Notify all (even the recently notified) relevant people"),

-     ]

- 

-     def run(self, dry_run, email_filter, all):

-         self.email_filter = email_filter

-         self.all = all

- 

-         if not dry_run:

-             self.dev_instance_warning()

- 

-         notifier = DryRunNotifier() if dry_run else Notifier()

-         outdated = coprs_logic.CoprChrootsLogic.filter_outdated(coprs_logic.CoprChrootsLogic.get_multiple())

-         for user, chroots in self.get_user_chroots_map(outdated).items():

-             chroots = self.filter_chroots([chroot for chroot in chroots])

-             if not chroots:

-                 continue

-             chroots.sort(key=lambda x: x.copr.full_name)

-             notifier.notify(user, chroots)

-             notifier.store_timestamp(chroots)

-     def get_user_chroots_map(self, chroots):

-         user_chroot_map = {}

-         for chroot in chroots:

-             for admin in coprs_logic.CoprPermissionsLogic.get_admins_for_copr(chroot.copr):

-                 if self.email_filter and admin.mail not in self.email_filter:

-                     continue

-                 if admin not in user_chroot_map:

-                     user_chroot_map[admin] = []

-                 user_chroot_map[admin].append(chroot)

-         return user_chroot_map

- 

-     def filter_chroots(self, chroots):

-         if self.all:

-             return chroots

- 

-         filtered = []

-         for chroot in chroots:

-             if not chroot.delete_notify:

-                 filtered.append(chroot)

- 

-             # Skip the chroot if was notified in less than `n` days

-             now = datetime.datetime.now()

-             if (now - chroot.delete_notify).days >= 80:

-                 filtered.append(chroot)

- 

-         return filtered

- 

-     def dev_instance_warning(self):

-         if app.config["ENV"] != "production" and not self.email_filter:

-             sys.stderr.write("I will not let you send emails to all Copr users from the dev instance!\n")

-             sys.stderr.write("Please use this command with -e myself@foo.bar\n")

-             sys.exit(1)

- from flask_script import Command

- class UpdateGraphsDataCommand(Command):

- 

-     def run(self):

-         builds_logic.BuildsLogic.get_task_graph_data('10min')

-         builds_logic.BuildsLogic.get_small_graph_data('30min')

-         builds_logic.BuildsLogic.get_task_graph_data('24h')

- from flask_script import Command

- 

- class RemoveGraphsDataCommand(Command):

-     """

-     Removes old cached graph data that is no longer used.

-     """

- 

-     def run(self):

-         curr_time = int(time.time())

-         models.BuildsStatistics.query.filter(or_(

-             and_(models.BuildsStatistics.time < curr_time - 91 * 86400,

-                  models.BuildsStatistics.stat_type == '24h'),

-             and_(models.BuildsStatistics.time < curr_time - 87000,

-                  models.BuildsStatistics.stat_type == '30min'),

-             and_(models.BuildsStatistics.time < curr_time - 87000,

-                  models.BuildsStatistics.stat_type == '10min')

-         )).delete()

-         db.session.commit()

- 

- 

- commands_old = {

-     # Other

-     "get_admins": "GetAdminsCommand",

-     "fail_build": "FailBuildCommand",

-     "update_graphs": "UpdateGraphsDataCommand",

-     "vacuum_graphs": "RemoveGraphsDataCommand",

-     "notify_outdated_chroots": "NotifyOutdatedChrootsCommand",

-     "delete_outdated_chroots": "DeleteOutdatedChrootsCommand",

-     "clean_expired_projects": "CleanExpiredProjectsCommand",

-     "clean_old_builds": "DeleteOldBuilds",

-     "delete_orphans": "DeleteOrphansCommand",

- }

- 

- manager = Manager(app)

- for cmdname, clsname in commands_old.items():

-     module = importlib.import_module("commands.{0}".format(cmdname))

-     cls = getattr(module, clsname)

-     manager.add_command(cmdname, cls())

- 

-     # General commands

-     app.cli.add_command(commands.test.test, "test")

- 

-     # Database commands

-     app.cli.add_command(commands.create_sqlite_file.create_sqlite_file_command, "create_sqlite_file")

-     app.cli.add_command(commands.create_db.create_db, "create_db")

-     app.cli.add_command(commands.drop_db.drop_db, "drop_db")

- 

-     # Chroot commands

-     app.cli.add_command(commands.create_chroot.create_chroot_command, "create_chroot")

-     app.cli.add_command(commands.alter_chroot.alter_chroot, "alter_chroot")

-     app.cli.add_command(commands.display_chroots.display_chroots, "display_chroots")

-     app.cli.add_command(commands.drop_chroot.drop_chroot, "drop_chroot")

-     app.cli.add_command(commands.branch_fedora.branch_fedora, "branch_fedora")

-     app.cli.add_command(commands.comment_chroot.comment_chroot, "comment_chroot")

- 

-     # User commands

-     app.cli.add_command(commands.alter_user.alter_user, "alter_user")

-     app.cli.add_command(commands.add_user.add_user, "add_user")

-     app.cli.add_command(commands.dump_user.dump_user, "dump_user")

- 

-     # Whooshee indexes

-     app.cli.add_command(commands.update_indexes.update_indexes, "update_indexes")

-     app.cli.add_command(commands.update_indexes_quick.update_indexes_quick, "update_indexes_quick")

-     app.cli.add_command(commands.update_indexes_required.update_indexes_required, "update_indexes_required")

- 

- 

-     # Other

-     #TODO

-     app.cli.add_command(commands.rawhide_to_release.rawhide_to_release, "rawhide_to_release")

-     # This is just temporary while migrating to flask script,

-     # values in arrays are already migrated parameters.

-     # Else part will be removed once migration is complete.

-     if sys.argv[1] in [

-         'test', 'create_sqlite_file', 'create_db', 'drop_db',

-         'create_chroot', 'alter_chroot', 'display_chroots', 'drop_chroot',

-         'branch_fedora', 'comment_chroot', 'rawhide_to_release',

- 	    'alter_user', 'add_user', 'dump_user', 'update_indexes',

- 	    'update_indexes_quick', 'update_indexes_required']:

-         app.cli()

-     else:

-         manager.run()