def test_end_date(self, timezone): """Tests that the interval trigger won't return any datetimes past the set end time.""" start_date = timezone.localize(datetime(2014, 5, 26)) trigger = IntervalTrigger(minutes=5, start_date=start_date, end_date=datetime(2014, 5, 26, 0, 7), timezone=timezone) assert trigger.get_next_fire_time(None, start_date + timedelta(minutes=2)) == \ start_date.replace(minute=5) assert trigger.get_next_fire_time(None, start_date + timedelta(minutes=6)) is None
def test_dst_change(self): """ Making sure that IntervalTrigger works during the ambiguous "fall-back" DST period. Note that you should explicitly compare datetimes as strings to avoid the internal datetime comparison which would test for equality in the UTC timezone. """ eastern = pytz.timezone('US/Eastern') start_date = datetime(2013, 3, 1) # Start within EDT trigger = IntervalTrigger(hours=1, start_date=start_date, timezone=eastern) datetime_edt = eastern.localize(datetime(2013, 3, 10, 1, 5), is_dst=False) correct_next_date = eastern.localize(datetime(2013, 3, 10, 3), is_dst=True) assert str(trigger.get_next_fire_time(None, datetime_edt)) == str(correct_next_date) datetime_est = eastern.localize(datetime(2013, 11, 3, 1, 5), is_dst=True) correct_next_date = eastern.localize(datetime(2013, 11, 3, 1), is_dst=False) assert str(trigger.get_next_fire_time(None, datetime_est)) == str(correct_next_date)
def manage_master_daemons(self): if ((len(self.master_jobs) == 0) and self.config.is_master()): # set scheduled jobs for master device slave_data_collection = self.scheduler.add_job( func = self.pull_and_publish_data, trigger = IntervalTrigger(seconds=2), id = 'Slave_Data_Pull', name = 'Slave_Data_Pull', replace_existing = True) self.master_jobs.append(slave_data_collection) # register cron job cleanup to atexit atexit.register(self.cleanup_master_jobs) elif((len(self.master_jobs) > 0) and not self.config.is_master()): self.cleanup_master_jobs
def main(): """Creates schleduler, fills it up with tasks and runs it""" init_logging() scheduler = BlockingScheduler() for job_info in JOBS: job_name, interval = job_info.split(':') job = import_job(job_name) if job: LOGGER.info('Adding job: %s, cadence each %s minutes', job_name, interval) scheduler.add_job(job.run, IntervalTrigger(minutes=int(interval))) else: LOGGER.error('Couldn\'t find job data for job: %s', job_name) scheduler.start()
async def start_fetch_wall(self, job_data: tuple): user_id, wall_id, to_chat_id, timeout, fetch_count = job_data await self._setup_user_cache(user_id, wall_id, to_chat_id) self.scheduler.add_job( self.fetch_public_wall, IntervalTrigger(minutes=timeout), args=( wall_id, fetch_count, ), name="vk_fetch_wall", id=f"{user_id}:{wall_id}:{to_chat_id}", replace_existing=True, next_run_time=datetime.now(), )
def test_pickle(self, timezone): """Test that the trigger is pickleable.""" trigger = IntervalTrigger(weeks=2, days=6, minutes=13, seconds=2, start_date=date(2016, 4, 3), timezone=timezone, jitter=12) data = pickle.dumps(trigger, 2) trigger2 = pickle.loads(data) for attr in IntervalTrigger.__slots__: assert getattr(trigger2, attr) == getattr(trigger, attr)
def initScheduler(): MyLogger.logMsg("init scheduler" + str(os.getpid())) if os.getpid() == 10: MyLogger.logMsg("up starting") scheduler = BackgroundScheduler() scheduler.start() scheduler.add_job(func=startNotifier, trigger=IntervalTrigger( hours=24, start_date='2017-05-04 08:40:00', timezone='Asia/Calcutta'), id='notifiying_job_morning', name='Notifiy at 0840AM', replace_existing=True) scheduler.add_job(func=startNotifier, trigger=IntervalTrigger( hours=24, start_date='2017-05-04 13:52:00', timezone='Asia/Calcutta'), id='notifiying_job_noon', name='Notifiy at 0152PM', replace_existing=True) # Shut down the scheduler when exiting the app atexit.register(lambda: scheduler.shutdown())
def schedule_job(function, name, hours=0, minutes=0): """ Start scheduled job if starting or restarting headphones. Reschedule job if Interval Settings have changed. Remove job if if Interval Settings changed to 0 """ job = SCHED.get_job(name) if job: if hours == 0 and minutes == 0: SCHED.remove_job(name) logger.info("Removed background task: %s", name) elif job.trigger.interval != datetime.timedelta(hours=hours, minutes=minutes): SCHED.reschedule_job(name, trigger=IntervalTrigger(hours=hours, minutes=minutes)) logger.info("Re-scheduled background task: %s", name) elif hours > 0 or minutes > 0: SCHED.add_job(function, id=name, trigger=IntervalTrigger(hours=hours, minutes=minutes)) logger.info("Scheduled background task: %s", name)
def construct_trigger(trigger_args): trigger_type = trigger_args['type'] trigger_args = trigger_args['args'] try: if trigger_type == 'date': return DateTrigger(**trigger_args) elif trigger_type == 'interval': return IntervalTrigger(**trigger_args) elif trigger_type == 'cron': return CronTrigger(**trigger_args) else: raise InvalidTriggerArgs( 'Invalid scheduler type {0} with args {1}.'.format(trigger_type, trigger_args)) except (KeyError, ValueError, TypeError): raise InvalidTriggerArgs('Invalid scheduler arguments')
def __init__(self): self.history = self._load_persistence() self._update_history_count(True) self.instance_list = {} self.token_list = {} self.scheduler = BackgroundScheduler() self.scheduler.start() self.scheduler.add_job( func=self._remove_staleinstances, trigger=IntervalTrigger(seconds=300), id='stale_instance_remover', name='Remove stale instances if no heartbeat in 5 minutes', replace_existing=True) self.scheduler.add_job( func=self._update_history_count, trigger=IntervalTrigger(seconds=30), id='update history', name='update client and instance count every 30 seconds', replace_existing=True) self.scheduler.add_job(func=self._persist, trigger=IntervalTrigger(seconds=15), id='persist history', name='persists the history to disk', replace_existing=True)
def before_first_request(): # Load record keeping config settings load_record_conf() # First data point on hours scale. Having this point helps JS build charts in the first hour of running. record_metrics('hours') # Schedule recording of metrics for charting. # https://stackoverflow.com/questions/21214270/scheduling-a-function-to-run-every-hour-on-flask scheduler = BackgroundScheduler() scheduler.start() # Job intervals below may be adjusted to display functionality. However, code assumes the values shown in comments at the end of the lines. scheduler.add_job( func=record_metrics, args=["hours"], trigger=IntervalTrigger(hours=1), # hours=1 (May use other values for testing.) id='hourly_metrics', name='Records current metrics on an hourly scope', replace_existing=True) scheduler.add_job( func=record_metrics, args=["days"], trigger=IntervalTrigger(days=1), # days=1 id='daily_metrics', name='Records current metrics on a daily scope', replace_existing=True) scheduler.add_job( func=record_metrics, args=["weeks"], trigger=IntervalTrigger(weeks=1), # weeks=1 id='weekly_metrics', name='Records current metrics on a weekly scope', replace_existing=True) # Shut down the scheduler when exiting the app atexit.register(lambda: scheduler.shutdown())
def rss_trigger(times: int, rss: RSS_class.rss): # 制作一个“time分钟/次”触发器 trigger = IntervalTrigger(minutes=times, jitter=10) job_defaults = {'max_instances': 10} # 添加任务 scheduler.add_job( func=check_update, # 要添加任务的函数,不要带参数 trigger=trigger, # 触发器 args=(rss, ), # 函数的参数列表,注意:只有一个值时,不能省略末尾的逗号 id=rss.name, # kwargs=None, misfire_grace_time=60, # 允许的误差时间,建议不要省略 # jobstore='default', # 任务储存库,在下一小节中说明 job_defaults=job_defaults, )
def update_cron(self, cron_job_id, project_id, cron_info): if not isinstance(cron_job_id, str): raise TypeError('cron_id must be str') if not isinstance(project_id, str): raise TypeError('project_id must be str') if not isinstance(cron_info, dict): raise TypeError('cron_info must be dict') trigger_type = cron_info.get('triggerType') interval = cron_info.get('interval') run_date = cron_info.get('runDate') test_suite_id_list = cron_info.get('testSuiteIdList') include_forbidden = cron_info.get('includeForbidden') test_env_id = cron_info.get('testEnvId') always_send_mail = cron_info.get('alwaysSendMail') alarm_mail_group_list = cron_info.get('alarmMailGroupList') try: if trigger_type == 'interval' and int(interval) > 0: self.scheduler.modify_job(job_id=cron_job_id, trigger=IntervalTrigger(seconds=interval)) elif trigger_type == 'date': # TODO 判断run_date类型 self.scheduler.modify_job(job_id=cron_job_id, trigger=DateTrigger(run_date=run_date)) else: raise TypeError('更新定时任务触发器失败!') if run_date: cron = Cron(test_suite_id_list=test_suite_id_list, project_id=project_id, test_env_id=test_env_id, include_forbidden=include_forbidden, always_send_mail=always_send_mail, alarm_mail_group_list=alarm_mail_group_list, trigger_type=trigger_type, # 更新定时器时,此参数并没有真正起到作用, 仅修改展示字段 run_date=run_date) # 更新定时器时,此参数并没有起到作用, 仅修改展示字段 else: cron = Cron(test_suite_id_list=test_suite_id_list, project_id=project_id, include_forbidden=include_forbidden, test_env_id=test_env_id, always_send_mail=always_send_mail, alarm_mail_group_list=alarm_mail_group_list, trigger_type=trigger_type, # 更新定时器时,此参数并没有起到作用, 仅修改展示字段 seconds=interval) # 更新定时器时,此参数并没有起到作用, 仅修改展示字段 # 玄学,更改job的时候必须改args,不能改func self.scheduler.modify_job(job_id=cron_job_id, coalesce=True, args=[cron]) except BaseException as e: raise TypeError('更新定时任务失败: %s' % e)
def logindeck(): result = {} json_data = request.json # if (is_admin()): deck = Deck.query.filter_by(id=json_data['deckid']).first() if (deck == None): result['status'] = -1 result['msg'] = 'Deck is not exist.' else: driver = create_driver() login_code = login_tweetdeck(driver, deck.name, deck.password)['code'] Deck.query.filter_by(id=json_data['deckid']).update( {"login_code": login_code}) db.session.commit() if (login_code < 0): driver.quit() result['msg'] = 'Unable to login to twitter.' result['status'] = -2 else: if (login_code == 0): result['status'] = 0 result['msg'] = 'Please input verification code.' else: profiles = (db.session.query( Profile.id, Profile.minutes, Link.deckid).join(Link)).filter_by(deckid=deck.id).all() for profile in profiles: scheduler.add_job( func=auto_rt, kwargs={ 'profile_id': profile.id, 'driver': driver }, trigger=IntervalTrigger(minutes=profile.minutes), # trigger=IntervalTrigger(minutes=1) id='retweet_%s' % (profile.id), replace_existing=False, misfire_grace_time=app.config['MISFIRE_GRACE_TIME']) Profile.query.filter_by(id=profile.id).update( {"run_status": 1}) db.session.commit() result['msg'] = "Succefully Logged Deck." result['status'] = 1 adddriver(deck.name, driver) # else: # result['status'] = -1 # result['msg'] = 'Please login now.' return jsonify({'result': result})
def delcache_trigger(): # 制作一个“time分钟/次”触发器 trigger = IntervalTrigger( days=config.DELCACHE, #minutes=1, jitter=10) # 添加任务 scheduler.add_job( func=del_img, # 要添加任务的函数,不要带参数 trigger=trigger, # 触发器 args=(1, ), # 函数的参数列表,注意:只有一个值时,不能省略末尾的逗号 id='DELCACHE', # kwargs=None, misfire_grace_time=60, # 允许的误差时间,建议不要省略 # jobstore='default', # 任务储存库,在下一小节中说明 )
def reschedule_job(id, minutes): if id == 'actors' and minutes < 2: print("ERRO! Intervalo mínimo é 2 minutos!") return elif id == 'relations' and minutes < 10: print("ERRO! Intervalo mínimo é 10 minutos!") return elif minutes < 2: print("ERRO! Intervalo mínimo é 2 minutos!") return try: scheduler.reschedule_job(job_id=id, trigger=IntervalTrigger(minutes=minutes)) print("Intervalo de " + id + " modificado para " + str(minutes)) except Exception as e: print(e)
def get_trigger(self, task): """Get loop interval trigger""" if not self.marker_interface.providedBy(task): raise Exception( _("Task is not configured for loop-style scheduling!")) info = self.schema(task, None) if info is None: return None return IntervalTrigger( weeks=info.weeks, days=info.days, hours=info.hours, minutes=info.minutes, seconds=info.seconds, start_date=tztime(date_to_datetime(info.start_date)), end_date=tztime(date_to_datetime(info.end_date)))
def start_scheduler(): global scheduler, loop interval = int(APP_CONFIG.get('download.interval', 1800)) loop = asyncio.new_event_loop() scheduler = AsyncIOScheduler(event_loop=loop) t1 = datetime.now() + timedelta(seconds=1) int_trigger = IntervalTrigger(seconds=interval) date_trigger = DateTrigger(run_date=t1) urls = (APP_CONFIG['download.root_path'], ) # add for down at server start scheduler.add_job(download, trigger=date_trigger, args=(loop, False, urls)) scheduler.add_job(download, trigger=int_trigger, args=(loop, False, urls)) scheduler.start() asyncio.set_event_loop(loop) loop.run_forever()
def resume_torrent(scheduler, counter: Counter): # scheduler.get_jobs()[0].trigger.interval.total_seconds()//60 api = QbittrentClient() print(arrow.now().format(), '登陆了Qbittrent...') api.login() has_error = api.resume_torrent() api.logout() if has_error: api.sent_to_server_chan() counter.time_reset() else: counter.time_multiplicate() # scheduler.modify_job('resume_torrent', minutes=counter.interval_minutes) scheduler.reschedule_job( 'resume_torrent', trigger=IntervalTrigger(minutes=counter.interval_minutes))
def jobs( self ) -> Iterable[Tuple[IntervalTrigger, Callable[[], Iterable[Dict[str, Any]]]]]: if not any([self.setting.get(s, True) for s in self.rss.keys()]): return tuple() sub_groups = self.setting.get("notify_groups", []) sub_users = self.setting.get("notify_privates", []) if not (sub_groups or sub_users): return tuple() interval = self.setting.get("news_interval_minutes", 30) trigger = IntervalTrigger(minutes=interval, start_date=datetime.datetime.now() + datetime.timedelta(seconds=60)) job = (trigger, self.send_news_async) return (job, )
def get_rescheduler(): timer = BlockingScheduler() time_spec = { 'seconds': cfg.CONF.scheduler.rescheduling_interval, 'timezone': aps_utils.astimezone('UTC') } timer.add_job(recover_delayed_executions, trigger=IntervalTrigger(**time_spec), max_instances=1, misfire_grace_time=60, next_run_time=date_utils.get_datetime_utc_now(), replace_existing=True) return timer
def _db_to_job(self, row): if row['trigger_type'] == 'date': trigger = DateTrigger(run_date=row['run_date']) if row['trigger_type'] == 'cron': keys = row['crontab'].split(',')[1] values = row['crontab'].split(',')[0].split(' ') cronMapRev = {v: k for k, v in cronMap.items()} crontab = {cronMapRev[k]: values[i] for i, k in enumerate(keys)} trigger = CronTrigger(**crontab) if row['trigger_type'] == 'interval': trigger = IntervalTrigger(seconds=row['interval']) job = Job.__new__(Job) job.__setstate__({ 'id': row['id'], 'name': row['name'], 'func': row['func'], 'args': json.loads(row['args']) if row['args'] else [], 'kwargs': json.loads(row['kwargs']) if row['kwargs'] else {}, 'version': 1, 'trigger': trigger, 'executor': row['executor'], 'start_date': row['start_date'], 'end_date': row['end_date'], 'next_run_time': utc_timestamp_to_datetime(row['next_run_time'].timestamp()), 'coalesce': row['coalesce'], 'misfire_grace_time': row['misfire_grace_time'], 'max_instances': row['max_instances'], 'jobstore': self, }) job._scheduler = self._scheduler job._jobstore_alias = self._alias return job
def main(): args = parse_args() if args.debug: logger.setLevel(logging.DEBUG) scheme = 'https' if args.secure else 'http' status_url = '{}://{}:{}{}'.format(scheme, args.ip, args.port, args.status_path) health_url = '{}://{}:{}{}'.format(scheme, args.ip, args.port, args.health_path) eureka = EurekaClient(args.name, args.port, args.ip, eureka_url=args.eureka, instance_id=args.instance_id, status_page_url=status_url, health_check_url=health_url) loop = asyncio.get_event_loop() loop.run_until_complete(eureka.register()) logger.info('Registered with eureka as %s', eureka.instance_id) scheduler = AsyncIOScheduler({'event_loop': loop}) @scheduler.scheduled_job(IntervalTrigger(seconds=args.interval)) async def renew_lease(): try: logger.debug('Attempting to renew the lease...') await eureka.renew() logger.info('Lease renewed') except EurekaException as e: if e.status == HTTPStatus.NOT_FOUND: logger.info('Lease expired, re-registering.') await eureka.register() return logger.error('Error performing renewal: %s', e) scheduler.start() try: logger.info('Running') with contextlib.suppress(KeyboardInterrupt): loop.run_forever() finally: scheduler.shutdown() loop.run_until_complete(eureka.deregister()) loop.close()
def __init__( self, client: AsyncClient, store, room_id: str, reminder_text: str, start_time: Optional[datetime] = None, timezone: Optional[str] = None, recurse_timedelta: Optional[timedelta] = None, cron_tab: Optional[str] = None, target_user: Optional[str] = None, alarm: bool = False, ): self.client = client self.store = store self.room_id = room_id self.timezone = timezone self.start_time = start_time self.reminder_text = reminder_text self.cron_tab = cron_tab self.recurse_timedelta = recurse_timedelta self.target_user = target_user self.alarm = alarm # Schedule the reminder # Determine how the reminder is triggered if cron_tab: # Set up a cron trigger trigger = CronTrigger.from_crontab(cron_tab, timezone=timezone) elif recurse_timedelta: # Use an interval trigger (runs multiple times) trigger = IntervalTrigger( # timedelta.seconds does NOT give you the timedelta converted to seconds # Use a method from apscheduler instead seconds=int(timedelta_seconds(recurse_timedelta)), start_date=start_time, timezone=timezone, ) else: # Use a date trigger (runs only once) trigger = DateTrigger(run_date=start_time, timezone=timezone) # Note down the job for later manipulation self.job = SCHEDULER.add_job(self._fire, trigger=trigger) self.alarm_job = None
def _run_forever(reader: Reader, loader: Loader, recognizer: Recognizer, updater: Updater): urls, images = Queue(300), Queue(300) for _ in range(15): Thread(target=_load_images, args=(loader, urls, images), daemon=True).start() Thread(target=_recognize_images, args=(recognizer, updater, images), daemon=True).start() scheduler = BlockingScheduler() scheduler.add_job(_read_urls, IntervalTrigger(seconds=15), (reader, urls)) try: scheduler.start() except KeyboardInterrupt: scheduler.shutdown() urls.join() images.join()
def test_compute_run_times(self): expected_times = [ self.RUNTIME + timedelta(seconds=1), self.RUNTIME + timedelta(seconds=2) ] self.job.trigger = IntervalTrigger(timedelta(seconds=1), self.RUNTIME) self.job.compute_next_run_time(expected_times[0]) eq_(self.job.next_run_time, expected_times[0]) run_times = self.job.get_run_times(self.RUNTIME) eq_(run_times, []) run_times = self.job.get_run_times(expected_times[0]) eq_(run_times, [expected_times[0]]) run_times = self.job.get_run_times(expected_times[1]) eq_(run_times, expected_times)
def push_metrics(self, observer): self._get_metrics_from_prometheus( observer) # Initial run for metric collection # Scheduler schedules a background job that needs to be run regularly scheduler = BackgroundScheduler() scheduler.start() scheduler.add_job( func=lambda: self._get_metrics_from_prometheus( observer ), # Run this function every 5 minutes to poll for new metric data trigger=IntervalTrigger(seconds=self.trigger_interval_secs), id='update_metric_data', name='Ticker to collect new data from prometheus', replace_existing=True) atexit.register(lambda: scheduler.shutdown() ) # Shut down the scheduler when exiting the app
def init(): """ Wrapper initialization function Initially parse the data and store it in the data cache variable. Set up timed background daemon to refresh the data at a given interval. """ scheduler.start() scheduler.add_job( func=refresh_data, trigger=IntervalTrigger(days=1), id="refresh_data_job", name="pull data from course academic timetable", replace_existing=True, ) atexit.register(lambda: scheduler.shutdown()) # delay launching the app until there is some data available refresh_data()
def verifydeck(): result = {} json_data = request.json deck = Deck.query.filter_by(id=json_data['deckid']).first() if (deck == None): result['status'] = -1 result['msg'] = 'Deck does not existed.' else: driver = getdriver(deck.name) if (driver != None): login_code = verify_tweetdeck(deck.id, driver, json_data['code'])['code'] if (login_code == 1): Deck.query.filter_by(id=json_data['deckid']).update( {"login_code": login_code}) profiles = (db.session.query( Profile.id, Profile.minutes, Link.deckid).join(Link)).filter_by(deckid=deck.id).all() for profile in profiles: scheduler.add_job( func=auto_rt, kwargs={ 'profile_id': profile.id, 'driver': driver }, trigger=IntervalTrigger(minutes=profile.minutes), # trigger=IntervalTrigger(minutes=1), id='retweet_%s' % (profile.id), replace_existing=False, misfire_grace_time=app.config['MISFIRE_GRACE_TIME']) Profile.query.filter_by(id=profile.id).update( {"run_status": 1}) db.session.commit() result['status'] = 1 result['msg'] = 'Success Verify Deck Account' elif (login_code == 0): result['status'] = 0 result[ 'msg'] = 'Cannot login to tweetdeck. Please check your password.' else: result['status'] = 0 result['msg'] = 'Failed verification.' else: result['status'] = -1 result['msg'] = 'Driver is not available.' return jsonify({'result': result})
def init_commands(args): if not args.only_web: upd_int = config.check_release_interval.value or config.check_release_interval.default upd_id = services.Scheduler.generic.add_command(meta_cmd.CheckUpdate(), IntervalTrigger(minutes=upd_int)) log.i("Initiating background", meta_cmd.CheckUpdate.__name__) services.Scheduler.generic.start_command(upd_id, push=True) log.i("Initiating background thumbnail", io_cmd.CacheCleaner.__name__) thumb_id = services.TaskService.generic.add_command(io_cmd.CacheCleaner()) constants.task_command.thumbnail_cleaner = services.TaskService.generic.start_command( thumb_id, constants.dir_thumbs, size=config.auto_thumb_clean_size.value, silent=True) log.i("Initiating background temp", io_cmd.CacheCleaner.__name__) temp_id = services.TaskService.generic.add_command(io_cmd.CacheCleaner()) constants.task_command.temp_cleaner = services.TaskService.generic.start_command( temp_id, constants.dir_temp, size=config.auto_temp_clean_size.value, silent=True)
def init(frequency, debug): logger.debug("Starting scheduler...") scheduler = BackgroundScheduler() scheduler.start() rabbitmq = RabbitMQ(os.getenv('RABBITMQ_SERVICE_NAME', 'rabbitmq')) scheduler.add_job(func=lambda: rabbitmq.log_metrics(), trigger=IntervalTrigger(seconds=int(frequency)), id='rabbit_metrics', name='Print queue stats for all RabbitMQ queues.', replace_existing=True) if not debug: logging.getLogger('apscheduler').setLevel(logging.ERROR) atexit.register(lambda: scheduler.shutdown())
def initialize_scheduler(): """ Start the scheduled background tasks. Because this method can be called multiple times, the old tasks will be first removed. """ from headphones import updater, searcher, librarysync, postprocessor, \ torrentfinished with SCHED_LOCK: # Remove all jobs first, because this method is also invoked when the # settings are saved. count = len(SCHED.get_jobs()) if count > 0: logger.debug("Current number of background tasks: %d", count) SCHED.shutdown() SCHED.remove_all_jobs() # Regular jobs if CONFIG.UPDATE_DB_INTERVAL > 0: SCHED.add_job( updater.dbUpdate, trigger=IntervalTrigger(hours=CONFIG.UPDATE_DB_INTERVAL)) if CONFIG.SEARCH_INTERVAL > 0: SCHED.add_job( searcher.searchforalbum, trigger=IntervalTrigger(minutes=CONFIG.SEARCH_INTERVAL)) if CONFIG.LIBRARYSCAN_INTERVAL > 0: SCHED.add_job( librarysync.libraryScan, trigger=IntervalTrigger(hours=CONFIG.LIBRARYSCAN_INTERVAL)) if CONFIG.DOWNLOAD_SCAN_INTERVAL > 0: SCHED.add_job( postprocessor.checkFolder, trigger=IntervalTrigger(minutes=CONFIG.DOWNLOAD_SCAN_INTERVAL)) # Update check if CONFIG.CHECK_GITHUB: SCHED.add_job( versioncheck.checkGithub, trigger=IntervalTrigger(minutes=CONFIG.CHECK_GITHUB_INTERVAL)) # Remove Torrent + data if Post Processed and finished Seeding if CONFIG.TORRENT_REMOVAL_INTERVAL > 0: SCHED.add_job(torrentfinished.checkTorrentFinished, trigger=IntervalTrigger( minutes=CONFIG.TORRENT_REMOVAL_INTERVAL)) # Start scheduler logger.info("(Re-)Scheduled %d background tasks", len(SCHED.get_jobs())) SCHED.start()
def test_no_start_date(self, timezone): trigger = IntervalTrigger(seconds=2, timezone=timezone) now = datetime.now(timezone) assert (trigger.get_next_fire_time(None, now) - now) <= timedelta(seconds=2)