Python schedule Examples

Example #1

File: sitemap.py Project: katrinleinweber/doaj

        # first prepare a job record
        job = models.BackgroundJob()
        job.user = username
        job.action = cls.__action__
        return job

    @classmethod
    def submit(cls, background_job):
        """
        Submit the specified BackgroundJob to the background queue

        :param background_job: the BackgroundJob instance
        :return:
        """
        background_job.save()
        generate_sitemap.schedule(args=(background_job.id,), delay=10)

@main_queue.periodic_task(schedule("sitemap"))
@write_required(script=True)
def scheduled_sitemap():
    user = app.config.get("SYSTEM_USERNAME")
    job = SitemapBackgroundTask.prepare(user)
    SitemapBackgroundTask.submit(job)

@main_queue.task()
@write_required(script=True)
def generate_sitemap(job_id):
    job = models.BackgroundJob.pull(job_id)
    task = SitemapBackgroundTask(job)
    BackgroundApi.execute(task)

Example #2

File: check_latest_es_backup.py Project: DOAJ/doaj

        job.user = username
        job.action = cls.__action__
        return job

    @classmethod
    def submit(cls, background_job):
        """
        Submit the specified BackgroundJob to the background queue

        :param background_job: the BackgroundJob instance
        :return:
        """
        background_job.save()
        check_latest_es_backup.schedule(args=(background_job.id,), delay=10)


@main_queue.periodic_task(schedule("check_latest_es_backup"))
@write_required(script=True)
def scheduled_check_latest_es_backup():
    user = app.config.get("SYSTEM_USERNAME")
    job = CheckLatestESBackupBackgroundTask.prepare(user)
    CheckLatestESBackupBackgroundTask.submit(job)


@main_queue.task()
@write_required(script=True)
def check_latest_es_backup(job_id):
    job = models.BackgroundJob.pull(job_id)
    task = CheckLatestESBackupBackgroundTask(job)
    BackgroundApi.execute(task)

Example #3

File: prune_es_backups.py Project: DOAJ/doaj

        job.user = username
        job.action = cls.__action__
        return job

    @classmethod
    def submit(cls, background_job):
        """
        Submit the specified BackgroundJob to the background queue

        :param background_job: the BackgroundJob instance
        :return:
        """
        background_job.save()
        prune_es_backups.schedule(args=(background_job.id,), delay=10)


@long_running.periodic_task(schedule("prune_es_backups"))
@write_required(script=True)
def scheduled_prune_es_backups():
    user = app.config.get("SYSTEM_USERNAME")
    job = PruneESBackupsBackgroundTask.prepare(user)
    PruneESBackupsBackgroundTask.submit(job)


@long_running.task()
@write_required(script=True)
def prune_es_backups(job_id):
    job = models.BackgroundJob.pull(job_id)
    task = PruneESBackupsBackgroundTask(job)
    BackgroundApi.execute(task)

Example #4

        # first prepare a job record
        job = models.BackgroundJob()
        job.user = username
        job.action = cls.__action__
        return job

    @classmethod
    def submit(cls, background_job):
        """
        Submit the specified BackgroundJob to the background queue
        :param background_job: the BackgroundJob instance
        """
        background_job.save()
        async_workflow_notifications.schedule(args=(background_job.id, ),
                                              delay=10)


@main_queue.periodic_task(schedule("async_workflow_notifications"))
def scheduled_async_workflow_notifications():
    user = app.config.get("SYSTEM_USERNAME")
    job = AsyncWorkflowBackgroundTask.prepare(user)
    AsyncWorkflowBackgroundTask.submit(job)


@main_queue.task()
def async_workflow_notifications(job_id):
    job = models.BackgroundJob.pull(job_id)
    task = AsyncWorkflowBackgroundTask(job)
    BackgroundApi.execute(task)

Example #5

File: reporting.py Project: DOAJ/doaj

        return job

    @classmethod
    def submit(cls, background_job):
        """
        Submit the specified BackgroundJob to the background queue

        :param background_job: the BackgroundJob instance
        :return:
        """
        background_job.save()
        run_reports.schedule(args=(background_job.id,), delay=10)


@main_queue.periodic_task(schedule("reporting"))
@write_required(script=True)
def scheduled_reports():
    user = app.config.get("SYSTEM_USERNAME")
    mail = bool(app.config.get("REPORTS_EMAIL_TO", False))                          # Send email if recipient configured
    outdir = app.config.get("REPORTS_BASE_DIR")
    outdir = os.path.join(outdir, dates.today())
    job = ReportingBackgroundTask.prepare(user, outdir=outdir, email=mail)
    ReportingBackgroundTask.submit(job)


@main_queue.task()
@write_required(script=True)
def run_reports(job_id):
    job = models.BackgroundJob.pull(job_id)
    task = ReportingBackgroundTask(job)

Example #6

File: article_cleanup_sync.py Project: DOAJ/doaj

        job.params = params
        if prepall:
            job.add_audit_message("'prepall' arg set. 'unchanged' articles will also have their indexes refreshed.")
        return job

    @classmethod
    def submit(cls, background_job):
        """
        Submit the specified BackgroundJob to the background queue

        :param background_job: the BackgroundJob instance
        :return:
        """
        background_job.save()
        article_cleanup_sync.schedule(args=(background_job.id,), delay=10)


@long_running.periodic_task(schedule("article_cleanup_sync"))
@write_required(script=True)
def scheduled_article_cleanup_sync():
    user = app.config.get("SYSTEM_USERNAME")
    job = ArticleCleanupSyncBackgroundTask.prepare(user)
    ArticleCleanupSyncBackgroundTask.submit(job)

@long_running.task()
@write_required(script=True)
def article_cleanup_sync(job_id):
    job = models.BackgroundJob.pull(job_id)
    task = ArticleCleanupSyncBackgroundTask(job)
    BackgroundApi.execute(task)

Example #7

File: public_data_dump.py Project: DOAJ/doaj

        job.action = cls.__action__
        job.params = params
        return job

    @classmethod
    def submit(cls, background_job):
        """
        Submit the specified BackgroundJob to the background queue

        :param background_job: the BackgroundJob instance
        :return:
        """
        background_job.save()
        public_data_dump.schedule(args=(background_job.id,), delay=10)


@long_running.periodic_task(schedule("public_data_dump"))
@write_required(script=True)
def scheduled_public_data_dump():
    user = app.config.get("SYSTEM_USERNAME")
    job = PublicDataDumpBackgroundTask.prepare(user, clean=True, prune=True, types="all")
    PublicDataDumpBackgroundTask.submit(job)


@long_running.task()
@write_required(script=True)
def public_data_dump(job_id):
    job = models.BackgroundJob.pull(job_id)
    task = PublicDataDumpBackgroundTask(job)
    BackgroundApi.execute(task)

Example #8

File: check_latest_es_backup.py Project: mauromsl/doaj

        job.user = username
        job.action = cls.__action__
        return job

    @classmethod
    def submit(cls, background_job):
        """
        Submit the specified BackgroundJob to the background queue

        :param background_job: the BackgroundJob instance
        :return:
        """
        background_job.save()
        check_latest_es_backup.schedule(args=(background_job.id, ), delay=10)


@main_queue.periodic_task(schedule("check_latest_es_backup"))
@write_required(script=True)
def scheduled_check_latest_es_backup():
    user = app.config.get("SYSTEM_USERNAME")
    job = CheckLatestESBackupBackgroundTask.prepare(user)
    CheckLatestESBackupBackgroundTask.submit(job)


@main_queue.task()
@write_required(script=True)
def check_latest_es_backup(job_id):
    job = models.BackgroundJob.pull(job_id)
    task = CheckLatestESBackupBackgroundTask(job)
    BackgroundApi.execute(task)

Example #9

        job.user = username
        job.action = cls.__action__
        return job

    @classmethod
    def submit(cls, background_job):
        """
        Submit the specified BackgroundJob to the background queue

        :param background_job: the BackgroundJob instance
        :return:
        """
        background_job.save()
        request_es_backup.schedule(args=(background_job.id,), delay=10)


@main_queue.periodic_task(schedule("request_es_backup"))
@write_required(script=True)
def scheduled_request_es_backup():
    user = app.config.get("SYSTEM_USERNAME")
    job = RequestESBackupBackgroundTask.prepare(user)
    RequestESBackupBackgroundTask.submit(job)


@main_queue.task()
@write_required(script=True)
def request_es_backup(job_id):
    job = models.BackgroundJob.pull(job_id)
    task = RequestESBackupBackgroundTask(job)
    BackgroundApi.execute(task)

Example #10

        return job

    @classmethod
    def submit(cls, background_job):
        """
        Submit the specified BackgroundJob to the background queue

        :param background_job: the BackgroundJob instance
        :return:
        """
        background_job.save()
        run_reports.schedule(args=(background_job.id, ), delay=10)


@main_queue.periodic_task(schedule("reporting"))
@write_required(script=True)
def scheduled_reports():
    user = app.config.get("SYSTEM_USERNAME")
    mail = bool(app.config.get("REPORTS_EMAIL_TO",
                               False))  # Send email if recipient configured
    outdir = app.config.get("REPORTS_BASE_DIR")
    outdir = os.path.join(outdir, dates.today())
    job = ReportingBackgroundTask.prepare(user, outdir=outdir, email=mail)
    ReportingBackgroundTask.submit(job)


@main_queue.task()
@write_required(script=True)
def run_reports(job_id):
    job = models.BackgroundJob.pull(job_id)

Example #11

File: async_workflow_notifications.py Project: DOAJ/doaj

            raise BackgroundException("Email has been disabled in config. Set ENABLE_EMAIL to True to run this task.")

        # first prepare a job record
        job = models.BackgroundJob()
        job.user = username
        job.action = cls.__action__
        return job

    @classmethod
    def submit(cls, background_job):
        """
        Submit the specified BackgroundJob to the background queue
        :param background_job: the BackgroundJob instance
        """
        background_job.save()
        async_workflow_notifications.schedule(args=(background_job.id,), delay=10)


@main_queue.periodic_task(schedule("async_workflow_notifications"))
def scheduled_async_workflow_notifications():
    user = app.config.get("SYSTEM_USERNAME")
    job = AsyncWorkflowBackgroundTask.prepare(user)
    AsyncWorkflowBackgroundTask.submit(job)


@main_queue.task()
def async_workflow_notifications(job_id):
    job = models.BackgroundJob.pull(job_id)
    task = AsyncWorkflowBackgroundTask(job)
    BackgroundApi.execute(task)

Example #12

File: article_cleanup_sync.py Project: katrinleinweber/doaj

                "'prepall' arg set. 'unchanged' articles will also have their indexes refreshed."
            )
        return job

    @classmethod
    def submit(cls, background_job):
        """
        Submit the specified BackgroundJob to the background queue

        :param background_job: the BackgroundJob instance
        :return:
        """
        background_job.save()
        article_cleanup_sync.schedule(args=(background_job.id, ), delay=10)


@long_running.periodic_task(schedule("article_cleanup_sync"))
@write_required(script=True)
def scheduled_article_cleanup_sync():
    user = app.config.get("SYSTEM_USERNAME")
    job = ArticleCleanupSyncBackgroundTask.prepare(user)
    ArticleCleanupSyncBackgroundTask.submit(job)


@long_running.task()
@write_required(script=True)
def article_cleanup_sync(job_id):
    job = models.BackgroundJob.pull(job_id)
    task = ArticleCleanupSyncBackgroundTask(job)
    BackgroundApi.execute(task)

Example #13

        job.user = username
        job.action = cls.__action__
        return job

    @classmethod
    def submit(cls, background_job):
        """
        Submit the specified BackgroundJob to the background queue

        :param background_job: the BackgroundJob instance
        :return:
        """
        background_job.save()
        prune_es_backups.schedule(args=(background_job.id, ), delay=10)


@long_running.periodic_task(schedule("prune_es_backups"))
@write_required(script=True)
def scheduled_prune_es_backups():
    user = app.config.get("SYSTEM_USERNAME")
    job = PruneESBackupsBackgroundTask.prepare(user)
    PruneESBackupsBackgroundTask.submit(job)


@long_running.task()
@write_required(script=True)
def prune_es_backups(job_id):
    job = models.BackgroundJob.pull(job_id)
    task = PruneESBackupsBackgroundTask(job)
    BackgroundApi.execute(task)

Example #14

File: read_news.py Project: DOAJ/doaj

        job.user = username
        job.action = cls.__action__
        return job

    @classmethod
    def submit(cls, background_job):
        """
        Submit the specified BackgroundJob to the background queue

        :param background_job: the BackgroundJob instance
        :return:
        """
        background_job.save()
        read_news.schedule(args=(background_job.id,), delay=10)
        # fixme: schedule() could raise a huey.exceptions.QueueWriteException and not reach redis- would that be logged?


@main_queue.periodic_task(schedule("read_news"))
@write_required(script=True)
def scheduled_read_news():
    user = app.config.get("SYSTEM_USERNAME")
    job = ReadNewsBackgroundTask.prepare(user)
    ReadNewsBackgroundTask.submit(job)

@main_queue.task()
@write_required(script=True)
def read_news(job_id):
    job = models.BackgroundJob.pull(job_id)
    task = ReadNewsBackgroundTask(job)
    BackgroundApi.execute(task)

Example #15

        job.user = username
        job.action = cls.__action__
        return job

    @classmethod
    def submit(cls, background_job):
        """
        Submit the specified BackgroundJob to the background queue

        :param background_job: the BackgroundJob instance
        :return:
        """
        background_job.save()
        journal_csv.schedule(args=(background_job.id, ), delay=10)


@main_queue.periodic_task(schedule("journal_csv"))
@write_required(script=True)
def scheduled_journal_csv():
    user = app.config.get("SYSTEM_USERNAME")
    job = JournalCSVBackgroundTask.prepare(user)
    JournalCSVBackgroundTask.submit(job)


@main_queue.task()
@write_required(script=True)
def journal_csv(job_id):
    job = models.BackgroundJob.pull(job_id)
    task = JournalCSVBackgroundTask(job)
    BackgroundApi.execute(task)

Example #16

File: public_data_dump.py Project: mauromsl/doaj

        job.params = params
        return job

    @classmethod
    def submit(cls, background_job):
        """
        Submit the specified BackgroundJob to the background queue

        :param background_job: the BackgroundJob instance
        :return:
        """
        background_job.save()
        public_data_dump.schedule(args=(background_job.id, ), delay=10)


@long_running.periodic_task(schedule("public_data_dump"))
@write_required(script=True)
def scheduled_public_data_dump():
    user = app.config.get("SYSTEM_USERNAME")
    job = PublicDataDumpBackgroundTask.prepare(user,
                                               clean=False,
                                               prune=True,
                                               types="all")
    PublicDataDumpBackgroundTask.submit(job)


@long_running.task()
@write_required(script=True)
def public_data_dump(job_id):
    job = models.BackgroundJob.pull(job_id)
    task = PublicDataDumpBackgroundTask(job)

Example #17

File: read_news.py Project: katrinleinweber/doaj

        job.action = cls.__action__
        return job

    @classmethod
    def submit(cls, background_job):
        """
        Submit the specified BackgroundJob to the background queue

        :param background_job: the BackgroundJob instance
        :return:
        """
        background_job.save()
        read_news.schedule(args=(background_job.id, ), delay=10)
        # fixme: schedule() could raise a huey.exceptions.QueueWriteException and not reach redis- would that be logged?


@main_queue.periodic_task(schedule("read_news"))
@write_required(script=True)
def scheduled_read_news():
    user = app.config.get("SYSTEM_USERNAME")
    job = ReadNewsBackgroundTask.prepare(user)
    ReadNewsBackgroundTask.submit(job)


@main_queue.task()
@write_required(script=True)
def read_news(job_id):
    job = models.BackgroundJob.pull(job_id)
    task = ReadNewsBackgroundTask(job)
    BackgroundApi.execute(task)

Example #18

File: journal_csv.py Project: DOAJ/doaj

        job.user = username
        job.action = cls.__action__
        return job

    @classmethod
    def submit(cls, background_job):
        """
        Submit the specified BackgroundJob to the background queue

        :param background_job: the BackgroundJob instance
        :return:
        """
        background_job.save()
        journal_csv.schedule(args=(background_job.id,), delay=10)


@main_queue.periodic_task(schedule("journal_csv"))
@write_required(script=True)
def scheduled_journal_csv():
    user = app.config.get("SYSTEM_USERNAME")
    job = JournalCSVBackgroundTask.prepare(user)
    JournalCSVBackgroundTask.submit(job)


@main_queue.task()
@write_required(script=True)
def journal_csv(job_id):
    job = models.BackgroundJob.pull(job_id)
    task = JournalCSVBackgroundTask(job)
    BackgroundApi.execute(task)