def main(): # Clean logger.info("Clean memcached before init") memcached_host, memcached_port = get_memcached_config() mem_nfv = MemcachedNFV(memcached_host, memcached_port) mem_nfv.clean_memcached() mem_nfv.disconnect() # Init server list init_server_cached_list_api() # Scheduler for get statistic data_config = read_config_json_file(NFV_CONFIG_PATH) interval = int(data_config['interval']) executors = { 'default': { 'type': 'threadpool', 'max_workers': 20 }, 'processpool': ProcessPoolExecutor(max_workers=5) } job_defaults = {'coalesce': False, 'max_instances': 3} scheduler = BlockingScheduler() scheduler.configure(executors=executors, job_defaults=job_defaults) scheduler.add_job(scheduler_get_statistic_job, 'interval', seconds=interval) scheduler.start()
def __init__(self, onTime, offTime): self.onTime = onTime self.offTime = offTime self.updateInterval = 6 self.webPush = False self.relayStatesA = [] self.relayStatesD = {} logging.basicConfig() #Call fetchUpdate every 6 hours print('initting AIHome...scheduling job') sched = BlockingScheduler() @sched.scheduled_job('interval', hours=1) def timed_job(): print( 'This job runs every 6 hrs. timed_job gets called or something else' ) #call fetchUpdate() self.fetchUpdate() #RUNS AT DAY&TIME SPECIIFIED########################### #@sched.scheduled_job('cron', day_of_week='mon-fri', hour=12) #def scheduled_job(): # print('This job is run every weekday at 12pm.') ####################################################### sched.configure() #options_from_ini_file sched.start()
def main(): scheduler = BlockingScheduler() scheduler.configure(job_defaults=dict(max_instances=1, coalesce=True)) # scheduler.add_job(refresh_job, 'interval', minutes=1) scheduler.add_job(refresh_job, 'cron', day_of_week=1, hour=4, minute=30) scheduler.add_job(case_status_job, 'cron', day_of_week=1, hour=16) scheduler.add_job(smart_job, 'cron', day_of_week=3, hour=0) scheduler.add_job(smart_date_job, 'cron', day_of_week=5, hour=8) scheduler.start()
def run_scheduler(): log = LogHelper("scheduler") log.info("scheduler start") scheduler = BlockingScheduler(logger=log) scheduler.add_job(run_proxy_fetch, 'interval', minutes=4, id="proxy_fetch", name="proxy采集") scheduler.add_job(run_proxy_check, 'interval', minutes=2, id="proxy_check", name="proxy检查") executors = { 'default': {'type': 'threadpool', 'max_workers': 20}, 'processpool': ProcessPoolExecutor(max_workers=4) } job_defaults = { 'coalesce': False, 'max_instances': 10 } scheduler.configure(executors=executors, job_defaults=job_defaults) scheduler.start()
class SchedulerManager: def __init__(self): if config.ENVIRONMENT == "test": self.scheduler = BackgroundScheduler() else: self.scheduler = BlockingScheduler() def init(self, websites, func): self.scheduler.configure(timezone="utc") for website in websites: self.scheduler.add_job( func, "interval", seconds=website.get("interval"), id=website.get("url"), kwargs={"url": website.get("url"), "regexp_rules": website.get("regexp_rules")}, ) self.scheduler.start() def get_jobs(self): return self.scheduler.get_jobs()
data.next_run_at = datetime.datetime.now() + datetime.timedelta(hours=4) d = data.next_run_at writeDatefile(data) sched.add_job(main, trigger='date', id='cron_main_at_%s' % (d.isoformat()), run_date=data.next_run_at) def start(): sched.start() executors = { 'default': {'type': 'threadpool', 'max_workers': 20}, 'processpool': ProcessPoolExecutor(max_workers=5) } sched.configure(executors=executors) if __name__ == "__main__": t = threading.Thread(target=start, args=()) t.start() next_run_at = readDatefile('next_run_at') if Config.getboolean("bot", "startonstartup"): next_run_at = datetime.datetime.now() + datetime.timedelta(seconds=1) elif next_run_at == None: next_run_at = datetime.datetime.now() + datetime.timedelta(seconds=5) elif datetime.datetime.now() > next_run_at: next_run_at = datetime.datetime.now() + datetime.timedelta(seconds=5) else: nextAt = next_run_at - datetime.datetime.now() next_run_at = datetime.datetime.now( ) + datetime.timedelta(seconds=nextAt.total_seconds()) sched.add_job(main, trigger='date', id='cron_main_at_%s' %
def periodic_task_one(): print('periodic_task_one on {}'.format(datetime.now())) with ThreadPoolExecutor(max_workers=100) as executor: future_dict = {} for i in range(0, 20): future = executor.submit(task_one, i, i * 10, i * 100) future_dict[future] = i for f in as_completed(future_dict): LOG.info('Index: {}, result: {}'.format(str(future_dict[f]), str(f.result()))) def periodic_task_two(): LOG.info('periodic_task_two on {}'.format(datetime.now())) def periodic_task_three(): LOG.info('periodic_task_three on {}'.format(datetime.now())) executors = {'default': ProcessPoolExecutor(max_workers=3)} scheduler = BlockingScheduler() scheduler.configure(executors=executors) scheduler.add_job(periodic_task_one, 'interval', seconds=2) scheduler.add_job(periodic_task_two, 'interval', seconds=5) scheduler.add_job(periodic_task_three, 'interval', seconds=10)
from pytz import utc from apscheduler.schedulers.blocking import BlockingScheduler from application import tweetry_manager scheduler = BlockingScheduler() scheduler.configure(timezone=utc) #Scheduled to run everyday at 12:00am UTC @scheduler.scheduled_job('cron', hour=0) def cron_job(): print(f'Scheduler: Tweeting: { tweetry_manager.tweet_final_quote() }') tweetry_manager.create_new_tweetry() print('Scheduler: A new tweetry has been created.') scheduler.start()
# apsched = BackgroundScheduler() # apsched.configure({'apscheduler.timezone': 'UTC'}) # # apsched.add_job(schedule_task.run_detect_gap,'cron', day_of_week='mon-fri', hour=20, minute=30) # # apsched.add_job(schedule_task.run_get_data_candidate, 'cron', day_of_week='mon-fri', hour=21, minute=00) # # apsched.add_job(schedule_task.run_get_news_gap,'cron', day_of_week='mon-fri', hour=21, minute=10) # # apsched.add_job(schedule_task.sync_s3,'cron', day_of_week='mon-fri', hour=21, minute=30) # apsched.add_job(daily_update,'cron', day_of_week='mon-fri', hour=20, minute=15) # apsched.add_job(test,'cron', day_of_week='mon-fri', hour=3, minute=52) # # For testing # # # #apsched.add_cron_job(schedule_task.run_detect_gap, day_of_week='mon-sun', hour=23, minute=17) # # # apsched.add_cron_job(schedule_task.run_get_data_candidate, day_of_week='mon-fri', hour=23, minute=48) # #apsched.add_cron_job(schedule_task.sync_s3, day_of_week='mon-sun', hour=3, minute=41) # apsched.start() # print("started!") sched = BlockingScheduler() sched.configure({'apscheduler.timezone': 'UTC'}) @sched.scheduled_job('cron', day_of_week='mon-fri', hour=20, minute=30) def scheduled_job(): print("Start updating") daily_update() print("Done") sched.start()
logging.getLogger('apscheduler').setLevel(logging.INFO) # 스케줄러 생성 # - Foreground로 실행 scheduler = BlockingScheduler() # # 스케줄러 설정 scheduler.configure( # 저장소 설정 jobstores={"default": MemoryJobStore()}, # 실행자 설정 executors={ "default": ThreadPoolExecutor(20), "processpool": ProcessPoolExecutor(5) }, # JOB 기본설정 job_defaults={ "coalesce": False, # 기본값은 True이며, Scheduler에 의해 작업이 여러번 실행되야하는 경우 통합하여 한번만 실행. "max_instances": 3 }, # Timezone 설정 timezone=get_localzone(), # "Asia/Seoul" daemon=True) # JOB Task 생성 # - 입력받은 텍스트를 출력 def execute(text): print(text)
class JobScheduler(object): def __init__(self, every=30, unit='second'): self.mongo = mongopool.get() self.cursor = self.mongo.get_database('apscheduler').get_collection( 'jobs') self.every = every self.unit = unit self.scheduler = BlockingScheduler(logger=logger) self.scheduler.configure(jobstores=jobstores, executors=executors, job_defaults=job_defaults, timezone=pytz.timezone('Asia/Saigon')) self._set_trigger(every, unit) def _set_trigger(self, every, unit): now = datetime.now().astimezone(pytz.timezone('Asia/Saigon')) if unit == 'second': self.trigger = CronTrigger(second='*/{}'.format(every), start_date=now) elif unit == 'minute': self.trigger = CronTrigger(minute='*/{}'.format(every), start_date=now) elif unit == 'hour': self.trigger = CronTrigger(hour='*/{}'.format(every), start_date=now) elif unit == 'day': self.trigger = CronTrigger(day='*/{}'.format(every), start_date=now) else: raise Exception(message='Unknown time unit') def add_jobstore(self, jobstore, alias): self.scheduler.add_jobstore(jobstore, alias) def add_executor(self, executor, alias): self.scheduler.add_executor(executor, alias) def add_job(self, job_fn, id='id1', name='job1', jobstore='default', executor='default', args=None, kwargs=None): now = datetime.now().astimezone(pytz.timezone('Asia/Saigon')) history = list(self.cursor.find({'_id': id})) if history: #TODO: process missing jobs self.cursor.delete_one({'_id': id}) next_run_time = self.trigger.get_next_fire_time(None, now) if kwargs: kwargs['run_time'] = next_run_time else: kwargs = {'run_time': next_run_time} self.scheduler.add_job(job_fn, trigger=self.trigger, next_run_time=next_run_time, id=id, name=name, jobstore=jobstore, executor=executor, args=args, kwargs=kwargs) def remove_job(self, id, jobstore='default'): self.scheduler.remove_job(job_id=id, jobstore=jobstore) def callback(self, callback_fn, mark=EVENT_ALL): self.scheduler.add_listener(callback_fn) def start(self): mongopool.put(self.mongo) self.scheduler.start() def shutdown(self): self.scheduler.shutdown() self.scheduler.scheduled_job
import telebot #import config import dm_function from apscheduler.schedulers.blocking import BlockingScheduler from pytz import timezone bot_token = #ask me for it openW_api = #ask me for it #Bochum lon and lat lat = '51' lon = '7' bot = telebot.TeleBot(bot_token) #TODO: get the id from new starts chat_id = -355590034 #for the 'Daymmon-group' in Bochum #TODO: get times from the host device cest = timezone('Europe/Berlin') sched = BlockingScheduler() sched.configure(timezone=cest) @sched.scheduled_job('cron', day_of_week='mon-sun', hour=8) def scheduled_job(): out_message1 = dm_function.daymoon() if out_message1 != '--': out_message2 = dm_function.weather(openW_api, lon, lat) if out_message2 != '--': bot.send_message(chat_id, out_message1+out_message2) sched.start()
import os import datetime from apscheduler.schedulers.blocking import BlockingScheduler scheduler = BlockingScheduler() @scheduler.scheduled_job('interval', minutes=1, start_date=datetime.datetime.now() + datetime.timedelta(0,3)) def run_eval(): command = 'export CUDA_VISIBLE_DEVICES=0; ' \ '/usr/bin/python ' \ 'bts_eval.py ' \ '--encoder densenet161_bts ' \ '--dataset kitti ' \ '--data_path ../../dataset/kitti_dataset/ ' \ '--gt_path ../../dataset/kitti_dataset/data_depth_annotated/ ' \ '--filenames_file ../train_test_inputs/eigen_test_files_with_gt.txt ' \ '--input_height 352 ' \ '--input_width 1216 ' \ '--garg_crop ' \ '--max_depth 80 ' \ '--max_depth_eval 80 ' \ '--output_directory ./models/eval-eigen/ ' \ '--model_name bts_eigen_v0_0_1 ' \ '--checkpoint_path ./models/bts_eigen_v0_0_1/ ' \ '--do_kb_crop ' print('Executing: %s' % command) os.system(command) print('Finished: %s' % datetime.datetime.now()) scheduler.configure() scheduler.start()
jobstores = { 'default': MemoryJobStore() } executors = { 'default': {'type': 'threadpool', 'max_workers': 5}, } job_defaults = { 'coalesce': True, 'max_instances': 3 } scheduler = BlockingScheduler() # .. do something else here, maybe add jobs etc. scheduler.configure(jobstores=jobstores, executors=executors, job_defaults=job_defaults, timezone=utc) def minutes(count): return count * 60 def hours(count): return count * minutes(60) def days(count): return count * hours(24) def flatten_series_by_url(): with app.app_context(): api_handlers_admin.flatten_series_by_url(None, admin_override=True) def consolidate_rrl_items(): with app.app_context(): api_handlers_admin.consolidate_rrl_items(None, admin_override=True)
sys.exit(1) image9 = os.getenv('IMAGE9', None) if image9 is None: print('IMAGE9 as environment variable.') sys.exit(1) line_bot_api = LineBotApi(channel_access_token) parser = WebhookParser(channel_secret) # simulate day my_date = date.today() # Start the scheduler sched = BlockingScheduler() sched.configure(timezone=timezone('Asia/Hong_Kong')) @sched.scheduled_job('cron', hour=5) def checkAndSend(): global my_date date_string = my_date.strftime('%Y-%m-%d') print(date_string) image_link = None text_msg = date_string + ':無' s = date(2017, 7, 25) if (my_date - s).days % 14 == 0: image_link = image1 text_msg = date_string + '要打齊天大聖囉'
for station in velib_stations: tag = get_tag(station) bike_nb = station["nbBike"] ebike_nb = station["nbEbike"] free_dock_nb = station["nbFreeDock"] + station["nbFreeEDock"] dock_nb = station["nbDock"] + station["nbEDock"] statsd.gauge("velib.regular_bikes", bike_nb, tags=tag) statsd.gauge("velib.electric_bikes", ebike_nb, tags=tag) statsd.gauge("velib.free_docks", free_dock_nb, tags=tag) statsd.gauge("velib.total_docks", dock_nb, tags=tag) statsd.service_check( "velib.station_state", get_state(station), tags=tag, message=station["station"]["state"], ) logger.info( "Found {} ebike(s), {} bike(s), {} free dock(s) on {} dock(s). The station is {}" .format(ebike_nb, bike_nb, free_dock_nb, dock_nb, station["station"]["state"]), extra={"station": get_station_name(station)}, ) if __name__ == "__main__": sched = BlockingScheduler() sched.configure(timezone=utc) sched.add_job(get_velibs, "cron", second="0") sched.start()
stream_handler = logging.StreamHandler() logger.addHandler(file_handler) logger.addHandler(stream_handler) mysql_url = 'mysql+mysqldb://' + settings.DATABASES['default']['USER'] + ':' + \ settings.DATABASES['default']['PASSWORD'] + '@' + \ settings.DATABASES['default']['HOST'] + '/' + \ settings.DATABASES['default']['NAME'] __configure = { 'apscheduler.standalone': True, 'apscheduler.jobstores.sqlalchemy_store.class': SQLAlchemyJobStore, 'apscheduler.jobstores.sqlalchemy_store.engine': create_engine(mysql_url, pool_pre_ping=True) } scheduler = BlockingScheduler(timezone=settings.TIME_ZONE) scheduler.configure(__configure) api_url = 'https://api.github.com/repos/' PATTERN = r"!\[(\w*|\s|\w+( \w+)*)\]\(([^,:!]*|\/[^,:!]*\.\w+|\w*.\w*)\)" def db_auto_reconnect(func): """Auto reconnect db when mysql has gone away.""" @wraps(func) def wrapper(*args, **kwagrs): try: connection.connection.ping() except Exception: connection.close() return func(*args, **kwagrs) return wrapper
def run_providers(): scheduler = BlockingScheduler() scheduler.configure( executors={ "admin": {"type": "processpool", "max_workers": 1}, "providers": {"type": "processpool", "max_workers": 2}, }, job_defaults={ "misfire_grace_time": 3 * 60, "coalesce": True, # Reschedule a single job if it failed 3 minutes ago "max_instances": 1, # Only 1 job instance executing concurrently }, ) # Admin jobs scheduler.add_job( "admin_stations:delete_stations", args=(60, ""), trigger="cron", hour="3", executor="admin", ) scheduler.add_job( "admin_clusters:save_clusters", args=(50,), trigger="cron", hour="4", executor="admin", ) providers_jobs = [ ("providers.borntofly:borntofly", 5), ("providers.ffvl:ffvl", 5), ("providers.fluggruppe_aletsch:fluggruppe_aletsch", 5), ("providers.holfuy:holfuy", 5), ("providers.iweathar:iweathar", 5), ("providers.metar_noaa:metar_noaa", 10), ("providers.meteoswiss_opendata:meteoswiss", 5), ("providers.pdcs:pdcs", 5), ("providers.pioupiou:pioupiou", 5), ("providers.romma:romma", 5), ("providers.slf:slf", 5), ("providers.thunerwetter:thunerwetter", 5), ("providers.windline:windline", 5), ("providers.windspots:windspots", 5), ("providers.yvbeach:yvbeach", 5), ("providers.zermatt:zermatt", 5), ] def schedule_jobs(jobs: List) -> int: job_index = 0 if jobs: for minute in range(0, 5): for second in range(0, 60, 15): func = jobs[job_index][0] interval = jobs[job_index][1] scheduler.add_job( func, trigger="cron", minute=f"{minute}-59/{interval}", second=second, executor="providers", ) job_index += 1 if job_index > len(jobs) - 1: return job_index - 1 return job_index - 1 last_job_index = schedule_jobs(providers_jobs) if last_job_index != len(providers_jobs) - 1: raise RuntimeError("Some jobs are not scheduled") scheduler.start()
else: pump_Stop dt = datetime.timedelta(365) # light cycle (12 hour schedule) using apscheduler let's specific sections of the code run at set time intervals, useful for different cycles sched = BlockingScheduler() @sched.scheduled_job('cron', day_of_week='mon-sun', hour=12) def scheduled_job(): return sched.configure(options_from_ini_file) sched.start() # pin selction for the pump io.setmode(ioBCM) io.setup(4, io.OUT) while True: io.output(4, 0) time.sleep(0, 30) io.output(4, 1) time.sleep(0, 30) # pin selction for the lights io.setmode(ioBCM)
def scheduler(): sched = BlockingScheduler() sched.configure(timezone='Asia/Seoul') sched.add_job(fetch_cryptocompare, 'interval', minutes=1) #매 분마다 돌리기 sched.start()
from apscheduler.schedulers.blocking import BlockingScheduler from controller import Controller from settings import * if __name__ == "__main__": scheduler = BlockingScheduler() scheduler.configure(**SCHEDULER) controller = Controller() controller.init_scheduler(scheduler) controller.run()
scheduler.add_job(job1, 'interval', seconds=5, id='job1') # 每隔5秒运行一次job2 scheduler.add_job(job2, 'cron', second='*/5', id='job2') # ###################使用装饰器添加任务################# # 每隔5秒运行一次job3 @scheduler.scheduled_job('interval', seconds=5, id='job3') def job3(): print 'job3 is running, Now is %s' % current_time() # 每隔5秒运行一次job4 @scheduler.scheduled_job('cron', second='*/5', id='job4') def job4(): print 'job4 is running, Now is %s' % current_time() executors = { 'processpool': ProcessPoolExecutor(5), 'default': ThreadPoolExecutor(20) } job_defaults = { 'coalesce': False, 'max_instances': 5 } scheduler.configure(executors=executors, job_defaults=job_defaults) scheduler.start()
from util import flatten_history jobstores = {'default': MemoryJobStore()} executors = { 'default': { 'type': 'threadpool', 'max_workers': 5 }, } job_defaults = {'coalesce': True, 'max_instances': 3} scheduler = BlockingScheduler() # .. do something else here, maybe add jobs etc. scheduler.configure(jobstores=jobstores, executors=executors, job_defaults=job_defaults, timezone=utc) def minutes(count): return count * 60 def hours(count): return count * minutes(60) def days(count): return count * hours(24)
from apscheduler.schedulers.blocking import BlockingScheduler from rq import Queue from worker import conn from client_tracker import update_daemon q = Queue(connection=conn) sched = BlockingScheduler() sched.configure(timezone="America/Denver") @sched.scheduled_job("cron", day_of_week="sun", hour=0, minute="01") def scheduled_job(): print("Starting the update process") q.enqueue(update_daemon.start) sched.start()
def get_date_string(date_object): return rfc3339.rfc3339(date_object) # Function to be run by Scheduler def callable_func(): fullTextQuery() def shutdown(exit_code): rootLogger.info('Shutting Down') if player_process: try: player_process.kill() except: rootLogger.warning('failed to terminate player_process') scheduler.shutdown(wait=False) exit(exit_code) if __name__ == '__main__': auth() # Run scheduler service scheduler = BlockingScheduler() scheduler.configure(timezone='UTC') scheduler.add_job(callable_func, 'interval', seconds=10, max_instances=1) try: scheduler.start() except (KeyboardInterrupt, SystemExit): shutdown(0)
#!/usr/bin/env python # -*- coding: utf-8 -*- # FileName : apscheduler.py # Author : wuqingfeng@ import time import logging from apscheduler.schedulers.blocking import BlockingScheduler def run_test(): print "I am running now..." time.sleep(10) print "I am end now!" if __name__ == '__main__': logging.basicConfig() logging.getLogger('apscheduler').setLevel(logging.DEBUG) scheduler = BlockingScheduler() scheduler.configure(logger=logging) scheduler.add_job(func=run_test, args=(), trigger='interval', jobstore='default', replace_existing=True, seconds=20) try: scheduler.start() except (KeyboardInterrupt, SystemExit): scheduler.shutdown()