def task_schedule(self):
scheduler = BlockingScheduler()
try:
scheduler.add_job(self._get_task, 'interval', seconds=30)
scheduler.start()
except Exception as e:
print(e)
def run(self):
setup_logging()
log = logging.getLogger('hermes_cms.service.runner')
while True:
try:
config = Registry().get(self.config_file)
# pylint: disable=broad-except
except Exception as e:
log.exception(e)
module_name = config['jobs'][self.name]['module_name']
class_name = config['jobs'][self.name]['class_name']
mod = __import__(module_name, fromlist=[class_name])
service_class = getattr(mod, class_name)
job_class = service_class(self.name, self.region, config)
seconds = int(config['jobs'][self.name]['frequency'])
scheduler = BlockingScheduler()
scheduler.add_job(job_class.do_action, IntervalTrigger(seconds=seconds))
log.info('Starting Scheduled job %s', self.name)
scheduler.start()
class PeriodGather(object):
def __init__(self, db):
self.__db = db
self.__scheduler = BlockingScheduler()
self.__scheduler.add_job(self.gather, 'cron', day_of_week='mon-fri', hour=16, minute=30)
def start(self):
self.__scheduler.start()
def gather(self):
_logger.info('period gather stock basic and history data, begin.....')
try:
StockBasicCollector(self.__db).collect()
stock_list = self.__get_stock_list()
for stock in stock_list:
HistDataCollector(stock, self.__db).collect()
except Exception as e:
_logger.exception(e)
_logger.info('period gather stock basic and history data, end.....')
def __get_stock_list(self):
collection = Collection(Constants.BASIC_COLLECTION, self.__db)
stock_infos = collection.find()
stock_list = []
for stock_info in stock_infos:
stock_list.append(stock_info['code'])
return stock_list
def stop(self):
if self.__scheduler:
self.__scheduler.shutdown()
class TalosCollectorCron(object):
"""docstring for talosCollectorCron"""
def __init__(self, redis_conn,config_path):
super(TalosCollectorCron, self).__init__()
self.redis_conn = redis_conn
self.config_path = config_path
self.scheduler = BlockingScheduler()
json_config = open(config_path, 'r')
# print json_config.read()
self.jsons = json.loads(json_config.read())
def myjob(self,c):
# 获取日期
# 获取HOST信息
# analyzer
if c['enable']:
tmp = os.popen(c['cmd']).readlines()
data = {}
data['content'] = tmp
data['analyzer'] = c['analyzer']
data['host'] = socket.gethostname()
data['date'] = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
data['param'] = c['param']
r.publish('talos:q:cmd',json.dumps(data))
def start(self):
for c in self.jsons:
cron = c['time'].split(' ')
job = self.scheduler.add_job(self.myjob,args=[c],trigger='cron', year=cron[5], month=cron[4], day=cron[3], hour=cron[2], minute=cron[1], second=cron[0])
print 'TalosCollectorCron Start..'
self.scheduler.start()
class BGPTableDownload(basesinfonierspout.BaseSinfonierSpout):
def __init__(self):
basesinfonierspout.BaseSinfonierSpout().__init__()
def useropen(self):
self.interval = int(self.getParam("frequency"))
self.sched = BlockingScheduler()
self.sched.add_job(self.job, "interval", seconds=self.interval, id="bgptable")
self.sched.start()
def usernextTuple(self):
pass
def job(self):
query = "http://bgp.potaroo.net/v6/as2.0/bgptable.txt"
self.log(query)
headers = {
"User-Agent" : "Mozilla/5.0 (Windows NT 6.2; WOW64; rv:20.0) Gecko/20100101 Firefox/20.0"
}
r = requests.get(query, headers=headers)
self.emit()
def test5():
"""定时执行任务，关闭调度器"""
sched = BlockingScheduler()
sched.add_job(my_job, 'date',run_date=datetime(2016, 8, 16, 12, 34,5), args=('123',),seconds=1, id='my_job_id')
# add_job的第二个参数是trigger，它管理着作业的调度方式。它可以为date, interval或者cron。
sched.start()
print('定时任务')
def test1():
"""定时执行任务"""
start_time = time.time()
sched = BlockingScheduler()
sched.add_job(my_job, 'interval', args=('123',),seconds=1, id='my_job_id') # 每隔1秒执行一次my_job函数,args为函数my_job的输入参数；id:可省略；
sched.start() # 程序运行到这里，并不往后运行，除非把任务都完成，但ctrl+C 可以终止
print('运行不到这里')
def main(argv): if len(argv) > 1: #initialize some variables pass scheduler = BlockingScheduler() scheduler.add_job(link, "interval", hours=1, id="link_job") scheduler.start()
class CrawlScheduler(object):
def __init__(self, crawler):
self.crawler = crawler
self.scheduler = BlockingScheduler()
def start(self):
logging.info('=============================================')
logging.info('[{0}] Start crawling from Instagram...'.format(datetime.datetime.now()))
crawling_start_time = time.time()
self.crawler.crawl()
crawling_end_time = time.time()
time_spent = int(crawling_end_time - crawling_start_time)
logging.info('Time spent: {0}min {1}s'.format(time_spent / 60, time_spent % 60))
logging.info('=============================================')
@staticmethod
def get_nearest_start_time():
nearest_start_timestamp = long(time.time() / (60 * 15) + 1) * 60 * 15
return datetime.datetime.fromtimestamp(nearest_start_timestamp)
def start_scheduler(self, should_continue=False):
# Config logging and alarm.
logging.basicConfig(filename=self.crawler.get_crawl_log(), level=logging.DEBUG)
scheduler_start_time = self.get_nearest_start_time()
redis_client.set(self.crawler.get_redis_end_time_key(), str(scheduler_start_time))
if not should_continue:
redis_client.set(self.crawler.get_redis_start_time_key(),
str(scheduler_start_time - datetime.timedelta(minutes=14, seconds=59)))
self.scheduler.add_job(self.start, 'interval', start_date=scheduler_start_time, minutes=15, misfire_grace_time=600)
self.scheduler.start()
def go_sched(): sched = BlockingScheduler(jobstores=jobstores, executors=executors, job_defaults=job_defaults) startTime = datetime.datetime.now()+datetime.timedelta(seconds=10) scheduleJobs(sched, startTime) sched.start()
class PeriodicRetrievalManager(RetrievalManager):
"""
Manages the periodic retrieval of updates.
"""
def __init__(self, retrieval_period: TimeDeltaInSecondsT, update_mapper: UpdateMapper,
logger: Logger=PythonLoggingLogger()):
"""
Constructor.
:param retrieval_period: the period that dictates the frequency at which data is retrieved
:param update_mapper: the object through which updates can be retrieved from the source
:param logger: log recorder
"""
super().__init__(update_mapper, logger)
self._retrieval_period = retrieval_period
self._running = False
self._state_lock = Lock()
self._updates_since = None # type: datetime
self._scheduler = BlockingScheduler()
self._scheduler.add_job(self._do_periodic_retrieval, "interval", seconds=self._retrieval_period, coalesce=True,
max_instances=1, next_run_time=datetime.now())
def run(self, updates_since: datetime=datetime.min):
self._updates_since = localise_to_utc(updates_since)
with self._state_lock:
if self._running:
raise RuntimeError("Already running")
self._running = True
self._scheduler.start()
def start(self, updates_since: datetime=datetime.min):
"""
Starts the periodic retriever in a new thread. Cannot start if already running.
:param updates_since: the time from which to get updates from (defaults to getting all updates).
"""
Thread(target=self.run, args=(updates_since, )).start()
def stop(self):
"""
Stops the periodic retriever.
"""
with self._state_lock:
if self._running:
self._scheduler.shutdown(wait=False)
self._running = False
logging.debug("Stopped periodic retrieval manger")
def _do_periodic_retrieval(self):
assert self._updates_since is not None
updates = self._do_retrieval(self._updates_since)
if len(updates) > 0:
# Next time, get all updates since the most recent that was received last time
self._updates_since = updates.get_most_recent()[0].timestamp
else:
# Get all updates since same time in future (not going to move since time forward to simplify things - there
# is no risk of getting duplicates as no updates in range queried previously). Therefore not changing
# `self._updates_since`.
pass
class schedulecontrol:
def __init__(self):
self.scheduler = BackgroundScheduler()
self.oncescheduler=BlockingScheduler()
self.scheduler.start()
def start(self):
self.oncescheduler.start()
def addschedule(self,event=None, day_of_week='0-7', hour='11',minute='57' ,second='0',id='',type='cron',run_date='',args=None):
if id=='':
id=str(time.strftime("%Y-%m-%d %X", time.localtime()));
if type=='date':
if run_date=='':
self.oncescheduler.add_job(event, args=args)
else:
self.oncescheduler.add_job(event, 'date', run_date=run_date, args=args)
elif type=='back':
self.oncescheduler.add_job(event,type, day_of_week=day_of_week, hour=hour,minute=minute ,second=second,id=id)
else:
self.scheduler.add_job(event, type, day_of_week=day_of_week, hour=hour, minute=minute, second=second, id=id)
def removeschedule(self,id):
self.scheduler.remove_job(id)
def run():
sched = BlockingScheduler()
sched.add_job(main.run, "cron", hour="7,11,17")
try:
sched.start()
except KeyboardInterrupt:
pass
def task_schedule(self):
scheduler = BlockingScheduler()
try:
scheduler.add_job(self._get_task, 'cron', day='1-31', hour=self.sche_time[0],
minute=self.sche_time[1], second=self.sche_time[2])
scheduler.start()
except Exception as e:
print(e)
def main():
"""Run tick() at the interval of every ten seconds."""
scheduler = BlockingScheduler(timezone=utc)
scheduler.add_job(tick, 'interval', seconds=10)
try:
scheduler.start()
except (KeyboardInterrupt, SystemExit):
pass
def cronjob():
scheduler = BlockingScheduler()
print "*******"
scheduler.add_job(checkupdate,'cron', second='0', hour='2',minute='0')
try:
scheduler.start()
except (KeyboardInterrupt, SystemExit):
scheduler.shutdown()
def startCrawlerTask():
from apscheduler.schedulers.blocking import BlockingScheduler
scheduler = BlockingScheduler()
scheduler.add_job(crawlerTask, 'cron', second='0',minute='15', hour='8')
print('Press Ctrl+{0} to exit'.format('Break' if os.name == 'nt' else 'C'))
try:
scheduler.start()
except (KeyboardInterrupt, SystemExit):
scheduler.shutdown()
def main():
sched = BlockingScheduler()
sched.add_job(spider.spider(), 'interval', seconds=21600)
print 'Press Ctrl+{0} to exit'.format('Break' if os.name == 'nt' else 'C')
try:
sched.start()
except (KeyboardInterrupt, SystemExit):
pass
def main():
scheduler = BlockingScheduler()
scheduler.add_job(kick_off_script, 'interval', seconds=60)
print('Press Ctrl+C to exit')
try:
scheduler.start()
except (KeyboardInterrupt, SystemExit):
pass
def run(self):
scheduler = BlockingScheduler()
cron_jobs = [NotificationJob(), TransferJob()]
for cron_job in cron_jobs:
trigger = cron_job.trigger()
scheduler.add_job(cron_job.run, **trigger )
logger.info('running CronJobTaskRunner')
scheduler.start()
def schedule_task():
sched = BlockingScheduler()
@sched.scheduled_job('interval', hours=1)
def timed_job():
notifications = session.query(Notification).all()
for n in notifications:
send_text(n)
print("ran job")
sched.start()
def schedJobs(funcToRun):
logging.basicConfig()
scheduler = BlockingScheduler()
datenow = datetime.datetime.now()
print("main scheduler started for jobs @" + str(datenow))
# rs = scheduler.add_job(subtwo, 'interval', id="MainTaskid", name="maintask", start_date=datetime.datetime.now(), seconds=3, jobstore='default')
rs = scheduler.add_job(funcToRun, trigger="interval", id="mainSchedJobID", name="mainSchedJob", jobstore='default', executor='default', replace_existing=False, minutes=mainSchedJobsInterval)
print("Running Tasks")
scheduler.start()
def run(self):
self.setup_logging()
scheduler = BlockingScheduler()
weather = Weather(scheduler, zip=self._args['zip'], station=self._args['station'])
dimmer = Dimmer(scheduler)
display = Display(weather, dimmer)
display.start()
scheduler.start()
def test7():
"""定时执行任务，通过ctrl+c终止"""
scheduler = BlockingScheduler()
scheduler.add_job(tick, 'interval', seconds=1)
print('Press Ctrl+{0} to exit'.format('Break' if os.name == 'nt' else 'C'))
try:
scheduler.start(paused=False) # 后面的并没有执行,若参数paused为真,则并不执行
except (KeyboardInterrupt, SystemExit):
pass
print('ok')
def main():
ceilometer = create_ceilomenter_client()
resources = ceilometer.resources.list()
for i in resources:
# print '\n'
print i.resource_id
# Run this job in certian time, with parameter 'text'
sched = BlockingScheduler()
sched.add_job(my_job, 'interval', seconds=5, args=['test'])
sched.start()
def bob_job():
me, password = email_login()
sched = BlockingScheduler()
@sched.scheduled_job('cron', day_of_week='mon,tue,wed,thu,fri', hour=17)
def scheduled_job():
job.run(me, password)
sched.start()
def startschedule():
scheduler = BlockingScheduler()
scheduler.add_job(test,'cron', second='*/3', hour='*')
scheduler.add_job(dotraveljobs,'cron', second='*/3', hour='*')
scheduler.add_job(doindexjobs,'cron', second='*/3', hour='*')
scheduler.add_job(docontentjobs,'cron', second='*/3', hour='*')
try:
scheduler.start()
except (KeyboardInterrupt, SystemExit):
scheduler.shutdown()
def main():
repo_slugs = ['start-jsk/jsk_apc']
gh_repos_handler = GitHubReposHandler(repo_slugs)
scheduler = BlockingScheduler(logger=logger)
scheduler.add_job(gh_repos_handler.send_empty_pr,
trigger='interval', minutes=5)
scheduler.add_job(gh_repos_handler.close_ci_success_empty_pr,
trigger='interval', minutes=5)
scheduler.print_jobs()
scheduler.start()
def main(generate_once, minutes):
generate()
if not generate_once:
print('Starting schedule, every {} minutes'.format(minutes))
scheduler = BlockingScheduler()
scheduler.add_job(generate, 'interval', minutes=1)
try:
scheduler.start()
except (KeyboardInterrupt, SystemExit):
pass
def main(): scheduler = BlockingScheduler() routine = Routine() job = scheduler.add_job(routine.check_fresh_dd, 'interval', minutes=1) try: scheduler.start() except (KeyboardInterrupt, SystemExit): pass # if __name__ == "__main__": # main()
# @Author : Fcvane
# @Param :
# @File : 8.py
# coding=utf-8
"""
Demonstrates how to use the background scheduler to schedule a job that executes on 3 second
intervals.
"""
from datetime import datetime
import os
from apscheduler.schedulers.blocking import BlockingScheduler
def tick():
print('Tick! The time is: %s' % datetime.now())
if __name__ == '__main__':
scheduler = BlockingScheduler()
scheduler.add_job(tick, 'date', run_date='2018-08-06 17:00:05')
print('Press Ctrl+{0} to exit'.format('Break' if os.name == 'nt' else 'C'))
try:
scheduler.start() # 采用的是阻塞的方式，只有一个线程专职做调度的任务
except (KeyboardInterrupt, SystemExit):
# Not strictly necessary if daemonic mode is enabled but should be done if possible
scheduler.shutdown()
print('Exit The Job!')
def plantaskdsfsdfsafdsafsd(self,
func,
targger="cron",
args=None,
year=None,
month=None,
week="*",
day_of_week='*',
day=None,
hour=None,
minute=None,
second='0'):
"""添加定时器任务、计划任务
func 函数名
args 函数参数 例：(1,)
year 年
month 月
day 日
hour 几点
minute 几分
second 几秒
"""
BlockingSchedulers = BlockingScheduler()
if targger == 'cron':
BlockingSchedulers.add_job(func,
targger,
args=args,
year=year,
month=month,
week=week,
day_of_week=day_of_week,
day=day,
hour=hour,
minute=minute,
second=second)
elif targger == 'interval':
if day:
BlockingSchedulers.add_job(func,
targger,
args=args,
days=int(day))
elif hour:
BlockingSchedulers.add_job(func,
targger,
args=args,
hours=int(hour))
elif minute:
BlockingSchedulers.add_job(func,
targger,
args=args,
minutes=int(minute))
elif second:
BlockingSchedulers.add_job(func,
targger,
args=args,
seconds=int(second))
try:
BlockingSchedulers.start()
except:
BlockingSchedulers.shutdown()
def run():
main()
sch = BlockingScheduler()
sch.add_job(main, 'interval', minutes=30) # 每30分钟抓取一次
sch.start()
class TiebaSign:
"""贴吧签到"""
JOB_STORE_ERROR_RETRY = 'error_retry'
"""失败重试"""
def __init__(self):
self.config_file = 'ignore/sign.conf'
self.log_file = 'ignore/sign.log'
self.lock_file = 'ignore/sign.lock'
self.logger: logging = None
self.scheduler: BlockingScheduler = None
self.sign_url = ''
"""签到地址"""
self.sign_hour = ''
"""签到触发小时，用于配置 add_job cron 对应的 hour 参数"""
self.error_retry_times = 0
"""错误重试次数"""
self.max_error_retry_times = 5
"""最大重试次数"""
def init_logger(self):
if self.logger is None:
self.logger = self.get_logger(self.log_file)
@staticmethod
def get_logger(file):
file_handler = logging.FileHandler(file, encoding='utf-8')
fmt = '%(asctime)s %(message)s'
date_fmt = "%Y-%m-%d %H:%M:%S"
formatter = logging.Formatter(fmt=fmt, datefmt=date_fmt)
file_handler.setFormatter(formatter)
logger = logging.getLogger('sign')
logger.addHandler(file_handler)
logger.setLevel(logging.INFO)
return logger
def init_config(self):
"""初始化配置"""
config = configparser.ConfigParser()
config.read(self.config_file)
if 'sign' in config:
sign = config['sign']
if 'sign_url' in sign:
self.sign_url = sign['sign_url']
if 'sign_hour' in sign:
self.sign_hour = sign['sign_hour']
def check_lock(self):
"""
检查锁
如果存在，更新时间
如果不存在，停止任务
"""
if os.path.exists(self.lock_file):
self.write_lock()
else:
# 文件不存在，停止程序
if self.scheduler is not None:
self.scheduler.shutdown(wait=False)
self.log(f'{self.lock_file} 不存在，停止任务')
exit(1)
def write_lock(self):
"""更新锁文件记录的时间"""
with open(self.lock_file, 'w') as f:
message = time.strftime('Now is %Y%m%d %H:%M:%S %z.')
if self.scheduler:
jobs = self.scheduler.get_jobs()
if jobs:
for job in jobs:
message += f'\n{job}'
f.write(message)
def sign(self):
"""签到"""
error_message = '' # 成功时为空，失败时为错误信息
try:
result = requests.get(self.sign_url)
result = result.json()
sign_message = self.get_sign_message(result)
if sign_message:
self.log('请求结果:' + sign_message)
if not self.check_sign_message(sign_message):
error_message = sign_message # 记为错误
else:
error_message = str(result) # 记为错误
except Exception as e:
error_message = str(e)
if not error_message:
self.error_retry_times = 0 # 成功置 0
else:
# 先移除
self.scheduler.remove_all_jobs(TiebaSign.JOB_STORE_ERROR_RETRY)
self.error_retry_times += 1 # 失败 +1
if self.error_retry_times > self.max_error_retry_times:
self.log(
f'已经失败 {self.error_retry_times} 次，不再重试:{error_message}')
self.error_retry_times = 0
else:
self.log(
f'请求失败了，10 分钟后第 {self.error_retry_times} 重试:{error_message}'
)
run_date = datetime.datetime.now() + datetime.timedelta(
minutes=10)
self.scheduler.add_job(
self.sign,
trigger='date',
run_date=run_date,
jobstore=TiebaSign.JOB_STORE_ERROR_RETRY)
def check_sign_message(self, sign_message: str) -> bool:
"""检查签到结果是否成功"""
if not sign_message:
return False
# [签到]论坛帐号 1/1/1+0,[回贴]用户 1/1/1+0
# [签到]论坛帐号 1/1/0+1，百度帐号 6/6/6,[回贴]用户 1/1/0+1,百度帐号 3/3/0+3
# [签到]论坛帐号 1/1/0+0,[回贴]用户 1/1/0+1,百度帐号 3/3/0+3
all_match = re.findall(r'\[(.+?)\].+?(\d+)/(\d+)/(\d+)\+(\d+)',
sign_message)
if not all_match:
return False
for m in all_match:
name, all_count, need_count, pre_success, cur_success = m
if int(need_count) != int(pre_success) + int(cur_success):
self.log(f'{name} 未完全成功，认为失败')
return False
return True
@staticmethod
def get_sign_message(result):
"""
获取返回结果的签到信息
用于减少 log 字数
"""
if result and isinstance(result, dict):
if 'code' not in result.keys():
return ''
if result['code'] != 200:
return ''
if 'data' not in result.keys():
return ''
data = result['data']
if data and isinstance(data, dict):
if 'signMessage' in data.keys():
return data['signMessage']
def start(self):
"""启动"""
self.init_logger()
self.init_config()
if not self.sign_url:
self.log(f'未在 {self.config_file} 中 [sign] 内配置 sign_url')
exit(1)
if not self.sign_hour:
self.log(f'未在 {self.config_file} 中 [sign] 内配置 sign_hour')
exit(1)
# 首次写入锁
self.write_lock()
# 服务器上时区不一致，手动指定
timezone = pytz.timezone('Asia/Shanghai')
self.scheduler = BlockingScheduler(timezone=timezone)
self.scheduler.add_jobstore('memory', TiebaSign.JOB_STORE_ERROR_RETRY)
# 每分钟触发一次
self.scheduler.add_job(self.check_lock, trigger='cron', second='0')
# 早 6 点一次，晚 10 点一次
self.scheduler.add_job(self.sign, trigger='cron', hour=self.sign_hour)
self.scheduler._logger = self.logger
self.log('开始运行')
try:
self.scheduler.start()
except KeyboardInterrupt:
self.log('按键中断')
except SystemExit:
self.log('异常退出')
def log(self, text):
now = time.strftime('%Y%m%d %H:%M:%S %z')
print(f'[{now}] {text}')
self.logger.info(text)
def dojob():
job()
scheduler = BlockingScheduler()
scheduler.add_job(job, 'interval', seconds=3600, id='test_job1')
# scheduler.add_job(spacejob(), 'interval', seconds=3600, id='test_job2')
scheduler.start()
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
class WorkInfoCollector :
def __init__(self, cfg) :
self.cfg = cfg
self.WORKINFO_REPO = {}
self._initConfig()
def _initConfig(self) :
self.systemName = self.cfg.get('MODULE_CONF', 'TACS_SYSTEM_NAME')
self.workInfoBaseDir = self.cfg.get('MODULE_CONF', 'TACS_WORKINFO_RAW')
self.auditLogTempDir = self.cfg.get('MODULE_CONF', 'TACS_AUDITLOG_TEMP')
self.auditLogBaseDir = self.cfg.get('MODULE_CONF', 'TACS_AUDITLOG_PATH')
self.receivedWorkCode = self.cfg.get('MODULE_CONF', 'RECEIVED_WORK_CODE')
self.tangoWmWorkInfoUrl = self.cfg.get('MODULE_CONF', 'TANGO_WM_WORKINFO_URL')
self.tangoWmEqpInfoUrl = self.cfg.get('MODULE_CONF', 'TANGO_WM_EQPINFO_URL')
self.xAuthToken = self.cfg.get('MODULE_CONF', 'TANGO_WM_X_AUTH_TOKEN')
self.host = self.cfg.get('MODULE_CONF', 'TANGO_WM_SFTP_HOST')
self.port = int(self.cfg.get('MODULE_CONF', 'TANGO_WM_SFTP_PORT'))
self.user = self.cfg.get('MODULE_CONF', 'TANGO_WM_SFTP_USER')
self.passwd = self.cfg.get('MODULE_CONF', 'TANGO_WM_SFTP_PASSWD')
self.scheduleInterval = self.cfg.get('MODULE_CONF', 'SCHEDULE_INTERVAL_MIN')
self.stdoutSleepTime = int(self.cfg.get('MODULE_CONF', 'STDOUT_SLEEP_TIME'))
self.headers = {'x-auth-token' : self.xAuthToken, 'Content-Type' : 'application/json; charset=utf-8'}
self.migration = False
self.errFilePath = self.cfg.get('MODULE_CONF', 'ERROR_FILE_PATH')
self.searchStartDate = None
self.searchEndDate = None
self.migrationProcFlag = False
def _executeMigration(self, searchStartDate, searchEndDate) :
__LOG__.Trace('migration process start. searchStartDate({}), searchEndDate({})'.format(searchStartDate, searchEndDate))
try :
searchStartDateObj = datetime.strptime(searchStartDate, '%Y%m%d%H%M%S')
searchEndDateObj = datetime.strptime(searchEndDate, '%Y%m%d%H%M%S')
if searchStartDateObj > searchEndDateObj :
__LOG__.Trace('searchStartDate({}) bigger than searchEndDate({})'.format(searchStartDate, searchEndDate))
print '[ERROR] searchStartDate({}) bigger than searchEndDate({})'.format(searchStartDate, searchEndDate)
else :
# request workInfo
workIdList = self._lookupWorkInfo(searchStartDate, searchEndDate, True)
# request eqpInfo by workId
self._lookupEqpInfo(workIdList)
except Exception as ex :
__LOG__.Trace('workInfo migration failed. {}'.format(ex))
def _executeScheduler(self) :
try :
__LOG__.Trace('scheduler process start')
# request workInfo
workIdList = self._lookupWorkInfo()
# request eqpInfo by workId
self._lookupEqpInfo(workIdList)
except :
__LOG__.Exception()
def _stdout(self, msg) :
sys.stdout.write('stdout' + msg + '\n')
sys.stdout.flush()
__LOG__.Trace('stdout: %s' % msg)
def createDateFile(self, fileName) :
self._mkdirs(self.errFilePath)
fullFilePath = os.path.join(self.errFilePath, fileName)
if not os.path.exists(fullFilePath) :
__LOG__.Trace( 'Tango-WM Request Fail File Create : {}'.format(fullFilePath) )
with open(fullFilePath, 'w') as dateFile :
dateFile.write('')
def _lookupWorkInfo(self, fromDate = None, toDate = None, migration = False) :
self.searchStartDate = fromDate
self.searchEndDate = toDate
if not migration :
searchEndDateObj = datetime.now()
#searchStartDateObj = datetime(searchEndDateObj.year, searchEndDateObj.month, searchEndDateObj.day, searchEndDateObj.hour, (searchEndDateObj.minute - int(self.scheduleInterval)))
searchStartDateObj = searchEndDateObj - timedelta(minutes=1)
self.searchStartDate = searchStartDateObj.strftime('%Y%m%d%H%M')
self.searchEndDate = searchEndDateObj.strftime('%Y%m%d%H%M')
__LOG__.Trace('lookup workInfo from({}) ~ to({})'.format(self.searchStartDate, self.searchEndDate))
url = self.tangoWmWorkInfoUrl.format(self.systemName, self.searchStartDate, self.searchEndDate)
__LOG__.Trace('request workInfo url: {}'.format(url))
rawDict = self._requestGet(url)
return self._loadWorkInfo(rawDict)
def _lookupEqpInfo(self, workIdList) :
if not workIdList :
__LOG__.Trace('workIdList is empty')
else :
logDictList = list()
yyyyMMdd = None
eventDate = None
for oneWorkId in workIdList :
url = self.tangoWmEqpInfoUrl.format(self.systemName, oneWorkId)
__LOG__.Trace('request eqpInfo url: {}'.format(url))
rawDict = self._requestGet(url)
logDict, yyyyMMdd, eventDate = self._loadEqpInfo(oneWorkId, rawDict, logDictList)
logDictList.append(logDict)
if rawDict :
self._writeTacsHistoryFile(yyyyMMdd, eventDate, logDictList)
else :
__LOG__.Trace('eqpInfo Dict is None {}'.format(rawDict))
def _requestGet(self, url, verify = False) :
rawDict = None
response = None
# fromReRequestDate, toReRequestDate = self.readDateFile().split(',')
try :
response = requests.get(url = url, headers = self.headers, verify = verify)
if response != None and response.status_code == 200 :
# if not self.migrationProcFlag and not migration and fromReRequestDate != '0' and toReRequestDate != '0' :
# self.migrationProcFlag = True
# proc = subprocess.Popen(['sh', self.migrationPath, fromReRequestDate, toReRequestDate], stdout=subprocess.PIPE)
# migrationResult, err = proc.communicate()
# if 'ERROR' in migrationResult :
# __LOG__.Trace('!!! Exception !!! migration Error : \n %s' % migrationResult)
# else :
# self.updateDateFile()
# self.migrationProcFlag = False
#jsonText = response.text.decode('string_escape')
#__LOG__.Trace('raw response.text: {}'.format(jsonText))
#__LOG__.Trace('replace response.text: {}'.format(jsonText.replace('\\\\\\"', '\\\"')))
#__LOG__.Trace('replace response.text: {}'.format(jsonText))
#tmpDict = json.loads(response.text)
#__LOG__.Trace('tmpDict: {}'.format(tmpDict))
#__LOG__.Trace('tmpDict.dumps: {}'.format(json.dumps(tmpDict, ensure_ascii=False)))
rawDict = response.json()
#rawDict = json.loads(jsonText)
else :
__LOG__.Trace('!!! Exception !!! requestGet failed. statusCode: {}'.format(response.status_code))
self.createDateFile('{}_{}'.format(self.searchStartDate, self.searchEndDate))
pass
except :
__LOG__.Exception()
self.createDateFile('{}_{}'.format(self.searchStartDate, self.searchEndDate))
pass
return rawDict
def _loadWorkInfo(self, rawDict) :
if rawDict :
__LOG__.Trace('workInfo rawData: {}'.format(rawDict))
workIdList = []
if type(rawDict['workInfo']) is list :
for oneWorkInfo in rawDict['workInfo'] :
workId = oneWorkInfo['workId']
__LOG__.Trace('workId: {}'.format(workId))
if workId is None or not workId :
__LOG__.Trace('invalid workId({})'.format(workId))
continue
workIdList.append(workId)
wrapper = {}
wrapper['workInfo'] = oneWorkInfo
workEvntDate = datetime.now().strftime('%Y%m%d%H%M%S')
wrapper['workInfo']['workEvntDate'] = workEvntDate
self.WORKINFO_REPO[workId] = wrapper
__LOG__.Trace('WORKINFO_REPO: {}'.format(self.WORKINFO_REPO))
else :
__LOG__.Trace('Unsupported type: {}'.format(type(rawDict['workInfo'])))
pass
return workIdList
else :
__LOG__.Trace('workInfo rawData is None')
return None
def _loadEqpInfo(self, oneWorkId, rawDict, logDictList) :
logDict = dict()
yyyyMMdd = None
eventDate = None
if rawDict :
__LOG__.Trace('eqpInfo rawData: {}'.format(rawDict))
if 'eqpInfo' in rawDict and type(rawDict['eqpInfo']) is list :
scriptFileList = []
wrapper = self.WORKINFO_REPO[oneWorkId]
if wrapper :
wrapper['eqpInfo'] = rawDict['eqpInfo']
for oneEqpInfoDict in rawDict['eqpInfo'] :
if 'scriptInfo' in oneEqpInfoDict :
scriptInfoList = oneEqpInfoDict['scriptInfo']
if scriptInfoList :
for oneScriptInfoDict in scriptInfoList :
filePathname = oneScriptInfoDict['atchdPathFileNm']
if filePathname :
remoteFilepath, remoteFilename = os.path.split(filePathname)
__LOG__.Trace('remoteFilepath({}), remoteFilename({})'.format(remoteFilepath, remoteFilename))
scriptFileDict = {}
scriptFileDict['remoteFilepath'] = remoteFilepath
scriptFileDict['remoteFilename'] = remoteFilename
scriptFileList.append(scriptFileDict)
else :
__LOG__.Trace('workId({})/eqpNm({}) atchdPathFileNm({}) is invalid'.format(oneWorkId, oneEqpInfoDict['eqpNm'], filePathname))
pass
else :
__LOG__.Trace('workId({})/eqpNm({}) scriptInfoList({}) is invalid'.format(oneWorkId, oneEqpInfoDict['eqpNm'], scriptInfoList))
else :
__LOG__.Trace('workId({})/eqpNm({}) scriptInfo does not exist in eqpInfo'.format(oneWorkId, oneEqpInfoDict['eqpNm']))
pass
else :
__LOG__.Trace('no registered workId({}) in WORKINFO_REPO'.format(oneWorkId))
return
__LOG__.Trace('scriptFileList: {}'.format(scriptFileList))
eventDate = wrapper['workInfo']['workEvntDate']
yyyyMMdd = datetime.strptime(eventDate, '%Y%m%d%H%M%S').strftime('%Y%m%d')
__LOG__.Trace('eventDate({}), yyyyMMdd({})'.format(eventDate, yyyyMMdd))
self._getScriptFiles(yyyyMMdd, oneWorkId, scriptFileList)
logDict = self._writeTangoWorkFile(yyyyMMdd, eventDate, oneWorkId, wrapper)
self._removeCompleteWorkInfo(oneWorkId)
else :
__LOG__.Trace('Unsupported type: {}'.format('eqpInfo' in rawDict if type(rawDict['eqpInfo']) else None ))
pass
else :
__LOG__.Trace('workId({}), eqpInfo rawData is None'.format(oneWorkId))
pass
return logDict, yyyyMMdd, eventDate
def _getScriptFiles(self, yyyyMMdd, workId, scriptFileList) :
if not scriptFileList :
__LOG__.Trace('scriptFileList({}) is empty'.format(scriptFileList))
return
try :
tacsWorkInfoPath = os.path.join(self.workInfoBaseDir, yyyyMMdd, workId)
self._mkdirs(tacsWorkInfoPath)
sftpClient = SFTPClient.SftpClient(self.host, self.port, self.user, self.passwd)
for oneScriptFileDict in scriptFileList :
remoteFilepath = oneScriptFileDict['remoteFilepath']
remoteFilename = oneScriptFileDict['remoteFilename']
sftpClient.download(remoteFilepath, remoteFilename, tacsWorkInfoPath)
__LOG__.Trace('scriptFile from({}) -> to({}) download succeed'.format(os.path.join(remoteFilepath, remoteFilename), os.path.join(tacsWorkInfoPath, remoteFilename)))
sftpClient.close()
except Exception as ex :
__LOG__.Trace('scriptFile download proccess failed {}'.format(ex))
self.createDateFile('{}_{}'.format(self.searchStartDate, self.searchEndDate))
self._removeCompleteWorkInfo(workId)
raise ex
def _writeTangoWorkFile(self, yyyyMMdd, eventDate, workId, wrapper) :
logDict = {}
try :
tacsWorkInfoPath = os.path.join(self.workInfoBaseDir, yyyyMMdd, workId)
self._mkdirs(tacsWorkInfoPath)
contents = json.dumps(wrapper, ensure_ascii=False)
__LOG__.Trace('contents: {}'.format(contents))
createFilePath = os.path.join(tacsWorkInfoPath, '{}_{}_META.json'.format(eventDate, workId))
self._createFile(createFilePath, contents)
logDict['tacsLnkgRst'] = 'OK'
__LOG__.Trace(self.migration)
if self.migration :
__LOG__.Trace( ['mf','30000', 'put', 'dbl', 'stdoutfile://{}'.format(createFilePath)] )
subprocess.call(['mf', '30000', 'put,dbl,stdoutfile://{}'.format(createFilePath)])
else :
time.sleep(self.stdoutSleepTime)
self._stdout('file://{}'.format(createFilePath))
except Exception as ex :
__LOG__.Trace('workFile write process failed {}'.format(ex))
logDict['tacsLnkgRst'] = 'FAIL'
logDict['tacsLnkgRsn'] = ex.args
self._removeCompleteWorkInfo(workId)
raise ex
finally :
logDict['evntTypCd'] = self.receivedWorkCode
logDict['evntDate'] = eventDate
logDict['workId'] = workId
logDict['lnkgEqpIp'] = ''
return logDict
# self._writeTacsHistoryFile(yyyyMMdd, eventDate, logDict)
def _writeTacsHistoryFile(self, yyyyMMdd, eventDate, logDictList) :
if logDictList :
__LOG__.Trace('received workInfo history: {}'.format(logDictList))
try :
tacsHistoryTempPath = os.path.join(self.auditLogTempDir, 'AUDIT_{}'.format(self.receivedWorkCode))
self._mkdirs(tacsHistoryTempPath)
contentList = list()
for oneLogDict in logDictList :
content = json.dumps(oneLogDict, ensure_ascii=False)
contentList.append(content)
contents = '\n'.join(contentList)
__LOG__.Trace('contents: {}'.format(contents))
tacsHistoryFilename = self._getTacsHistoryFilename(yyyyMMdd, eventDate)
__LOG__.Trace('tacsHistoryFilename: {}'.format(tacsHistoryFilename))
self._createFile(os.path.join(tacsHistoryTempPath, tacsHistoryFilename), contents)
tacsHistoryPath = os.path.join(self.auditLogBaseDir, 'AUDIT_{}'.format(self.receivedWorkCode))
self._mkdirs(tacsHistoryPath)
shutil.move(os.path.join(tacsHistoryTempPath, tacsHistoryFilename), os.path.join(tacsHistoryPath, tacsHistoryFilename))
__LOG__.Trace('tacsHistory file move from {} -> to {} succeed'.format(os.path.join(tacsHistoryTempPath, tacsHistoryFilename), os.path.join(tacsHistoryPath, tacsHistoryFilename)))
except Exception as ex :
__LOG__.Trace('tacsHistory {} load process failed {}'.format(logDict, ex))
else :
__LOG__.Trace('received workInfo history({}) is invalid'.format(logDict))
def _mkdirs(self, directory) :
__LOG__.Trace('{} isExists: {}'.format(directory, os.path.exists(directory)))
if not os.path.exists(directory) :
__LOG__.Trace('create directories {}'.format(directory))
os.makedirs(directory)
def _createFile(self, filePath, contents) :
f = None
try :
f = open(filePath, 'w')
f.write(contents)
__LOG__.Trace('{} file is created'.format(filePath))
except Exception as ex :
__LOG__.Trace('{} to file process failed {}'.format(contents, ex))
raise ex
finally :
if f :
f.close()
def _getTacsHistoryFilename(self, yyyyMMdd, eventDate) :
HHmm = datetime.strptime(eventDate, '%Y%m%d%H%M%S').strftime('%H%M')
tacsHistoryFilename = '{}_{}_{}.audit'.format(yyyyMMdd, HHmm, uuid.uuid4())
return tacsHistoryFilename
def _removeCompleteWorkInfo(self, workId) :
if workId in self.WORKINFO_REPO :
del self.WORKINFO_REPO[workId]
__LOG__.Trace('workId({}), WORKINFO_REPO: {}'.format(workId, self.WORKINFO_REPO))
def shutdown(self) :
try :
if self.scheduler :
#self.scheduler.remove_job('workInfo_scheduler')
self.scheduler.shutdown()
__LOG__.Trace('schduler is terminated')
else :
_LOG__.Trace('scheduler is None')
except Exception as ex :
__LOG__.Trace('shutdown failed {}'.format(ex))
def run(self, searchStartDate = None, searchEndDate = None, migration = False) :
if not migration :
self.scheduler = BlockingScheduler()
self.scheduler.add_job(self._executeScheduler, 'cron', minute='*/{}'.format(self.scheduleInterval), second='0', id='workInfo_scheduler', max_instances=2)
self.scheduler.start()
else :
self._executeMigration(searchStartDate, searchEndDate)
__LOG__.Trace('migration proccess done')
def run():
channels_update
scheduler = BlockingScheduler()
scheduler.add_job(channels_update, 'interval', hours=1)
scheduler.start()
def main():
""" main function """
parser = argparse.ArgumentParser()
parser.add_argument("-g", "--graph", action="store_true", default=False)
parser.add_argument("-j", "--json", action="store_true", default=False)
parser.add_argument("-t", "--test", action="store_true", default=False)
parser.add_argument("-i", "--interval")
argcomplete.autocomplete(parser)
args = parser.parse_args()
interval = args.interval if args.interval else str(config.main.interval)
drain = str2bool(config.main.drain)
test_string = "(test)" if args.test else "(live)"
setproctitle.setproctitle("greencandle-backend_{0}{1}".format(
interval, test_string))
minute = {
"3m": "0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57",
"5m": "0,5,10,15,20,25,30,35,40,45,50,55",
"15m": "0,15,30,45",
"30m": "0,30",
"1h": "0",
"2h": "0",
"3h": "0",
"4h": "0",
}
hour = {
"3m": "*",
"5m": "*",
"15m": "*",
"30m": "*",
"1h": "*",
"2h": "0,2,4,6,8,10,12,14,16,18,20,22",
"3h": "0,3,6,9,12,15,18,21",
"4h": "0,4,8,12,16,20"
}
sched = BlockingScheduler()
@GET_EXCEPTIONS
@sched.scheduled_job('interval', seconds=int(config.main.check_interval))
def get_price():
LOGGER.info("Starting Price check")
prod_int_check(interval, args.test)
LOGGER.info("Finished Price check")
@GET_EXCEPTIONS
@sched.scheduled_job('interval', minutes=30)
def get_graph():
for pair in config.main.pairs.split():
LOGGER.info("Creating graph for %s" % pair)
volume = 'vol' in config.main.indicators
graph = Graph(test=False,
pair=pair,
interval=config.main.interval,
volume=volume)
graph.get_data()
graph.create_graph('/data/graphs/')
graph.get_screenshot()
graph.resize_screenshot()
@GET_EXCEPTIONS
@sched.scheduled_job('interval', seconds=60)
def keepalive():
Path('/var/run/greencandle').touch()
@GET_EXCEPTIONS
@sched.scheduled_job('cron',
minute=minute[interval],
hour=hour[interval],
second="30")
def prod_run():
LOGGER.info("Starting prod run")
prod_loop(interval, test_trade=args.test)
LOGGER.info("Finished prod run")
LOGGER.info("Starting initial prod run")
prod_initial(interval) # initial run, before scheduling begins
LOGGER.info("Finished initial prod run")
prod_run()
try:
sched.start()
except KeyboardInterrupt:
LOGGER.warning("\nExiting on user command...")
sys.exit(1)
import os
from apscheduler.schedulers.blocking import BlockingScheduler
import sys
import datetime
from datetime import date, datetime, timedelta
import time
import calendar
from services import delete,push,backuptemperture
if __name__ == '__main__':
service = BlockingScheduler(timezone="Asia/Taipei")
service.add_job(backuptemperture.run,'cron',hour=0,minute=0)
service.add_job(delete.run,'cron',hour=16,minute=48)
service.add_job(push.push,'cron',day_of_week='mon-fri',hour=16,minute=50)
try:
service.start()
except (KeyboardInterrupt, SystemExit):
pass
from apscheduler.schedulers.blocking import BlockingScheduler
from main import *
import logging
from datetime import datetime
if __name__ == '__main__':
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
downloader = Downloader()
analyser = Analyser()
scheduler = BlockingScheduler(logger=logger)
scheduler.add_job(downloader.run,
'interval',
seconds=30,
next_run_time=datetime.now())
scheduler.add_job(analyser.run,
'interval',
seconds=30,
next_run_time=datetime.now())
try:
scheduler.start()
except (KeyboardInterrupt, SystemExit):
pass
return msg
def getdouying():
try:
INFO('check douying')
stampTime = int(time.time())
msgDict = douying(stampTime, int(interval_delay))
if msgDict:
bot.send_group_msg_async(group_id=QQqun,
message=msgDict,
auto_escape=False)
time.sleep(0.1)
except:
WARN('error when douying')
finally:
pass
try:
sched.add_job(getdouying,
'interval',
seconds=interval_delay,
misfire_grace_time=interval_delay,
coalesce=True,
max_instances=15)
except Exception as e:
WARN('error when start thread')
# 开始调度任务
sched.start()
def startScheduler():
scheduler = BlockingScheduler()
scheduler.add_job(scraperScheduler, 'interval', hours=0.5)
scheduler.start()
def dojob():
# 创建调度器：BlockingScheduler
scheduler = BlockingScheduler()
# 添加任务,时间间隔90S
scheduler.add_job(task, 'interval', seconds=120, id='test_job1')
scheduler.start()
query_results = list(collection.find({"date": date}))
to_be_collected = [result["contest_name"] for result in query_results]
logging.info(to_be_collected)
return to_be_collected
def edit_collect_file(contest_name: str) -> None:
with open("collect.json") as f:
collect = json.load(f)
collect["sheets"][0]["tabName"] = contest_name
collect["sheets"][0]["contests"][0]["link"] = contest_name
with open("collect.json", "w") as f:
json.dump(collect, f, indent=4)
@SCHED.scheduled_job("cron", id="collect_labs", hour=0, minute=0)
def collect_labs() -> None:
logging.info("Collecting")
contests = get_to_be_collected()
if not contests:
send_message("There aren't any contests to collect today.")
for contest in contests:
edit_collect_file(contest)
main()
send_message(f"Contest: {contest} succesfully collected.")
SCHED.start()
def run_cron_jobs(self) -> None:
"""Runs the web scraper every morning."""
schedule = BlockingScheduler()
schedule.add_job(main, 'cron', day_of_week='0-6', hour='8')
schedule.start()
def start_task_():
scheduler = BlockingScheduler()
scheduler.add_job(parse_and_send_sms, 'interval',
seconds=60) #seconds=60
scheduler.start()
second=second)
date = datetime.now() + timedelta(days=1)
date_string = date.strftime("%Y-%m-%d")
dt = date_string + " " + time
return dt
# 一次性任务，创建后，只会运行一次
def job_once(self, scheduler, function_name):
print("execute job : job_once")
date_time = self.job_random_time()
print(date_time)
scheduler.add_job(function_name, 'date', run_date=date_time)
print(scheduler.print_jobs())
if __name__ == '__main__':
obj = DispatchHelper()
cnbeta = CrawCnbeta()
solidot = CrawSolidot()
# 定义BlockingScheduler
blockingScheduler = BlockingScheduler()
blockingScheduler.add_job(obj.job_once,
'interval',
days=1,
args=[blockingScheduler, cnbeta.exec_cnbeta])
blockingScheduler.add_job(obj.job_once,
'interval',
days=1,
args=[blockingScheduler, solidot.exec_solidot])
blockingScheduler.start()
from apscheduler.schedulers.blocking import BlockingScheduler
from build import set_all_scripts_on_fire
sche = BlockingScheduler()
@sche.scheduled_job('interval', minutes=8)
def timed_job():
set_all_scripts_on_fire()
sche.start()
class SpiderStarter:
def __init__(self):
self.scheduler = BlockingScheduler()
self.stock_analyzer = None
#初始化数据缓存:每日更新
def stock_days_cache_task(self):
print 'stock_days_cache start....'
self.stock_analyzer = StockAnalyzer()
print 'stock_days_cache end....'
#股票列表更新:每个交易日9：25更新股票列表
def stock_list_inc_spider_task(self):
print 'stock_list_inc_spider start....'
list_spider = StockListIncSpider()
list_spider.get_stock_list()
print 'stock_list_inc_spider end....'
#股票日交易列表:每个交易日15：10更新交易数据
def stock_day_inc_spider_task(self):
print 'stock_day_inc_spider start....'
day_inc_spider = StockDayIncSpider(None, is_persist=True)
day_inc_spider.get_allstocks_day()
print 'stock_day_inc_spider end....'
def stock_day_realtime_spider_task(self):
print 'stock_day_realtime_spider start....'
if self.stock_analyzer is None:
self.stock_analyzer = StockAnalyzer()
spider = StockDayIncSpider(self.stock_analyzer)
spider.get_allstocks_day()
print 'stock_day_realtime_spider end....'
def start(self):
try:
self.scheduler.add_job(self.stock_days_cache_task,
'cron',
minute='0',
day_of_week='0-4',
hour='9',
id='stock_days_cache')
self.scheduler.add_job(self.stock_list_inc_spider_task,
'cron',
minute='25',
day_of_week='0-4',
hour='9')
self.scheduler.add_job(self.stock_day_inc_spider_task,
id='stock_day_inc_spider',
minute='10',
day_of_week='0-4',
hour='15')
self.scheduler.add_job(self.stock_day_realtime_spider_task,
'cron',
second='*/1',
day_of_week='0-4',
hour='9-12,13-22',
max_instances=1,
id='stock_day_realtime_spider')
self.scheduler.start()
except Exception, e:
print e
def scheduleTask():
times = 0
# 创建调度器：BlockingScheduler
scheduler = BlockingScheduler()
scheduler.add_job(task, 'interval', seconds=60, id='task1')
scheduler.start()
def scheduler():
sched = BlockingScheduler()
sched.configure(timezone='Asia/Seoul')
sched.add_job(fetch_cryptocompare, 'interval', minutes=1) #매 분마다 돌리기
sched.start()
def add(self):
for d in range(100, 110):
self.t.__class__.cache.add(d)
time.sleep(randint(1, 3))
print d, len(self.t.__class__.cache)
if __name__ == '__main__':
from apscheduler.jobstores.memory import MemoryJobStore
from apscheduler.schedulers.blocking import BlockingScheduler
from apscheduler.executors.pool import ThreadPoolExecutor
jobstores = {'default': MemoryJobStore()}
# using ThreadPoolExecutor as default other than ProcessPoolExecutor(not work) to executors
executors = {
'default': ThreadPoolExecutor(4),
}
job_defaults = {'coalesce': False, 'max_instances': 1}
app = BlockingScheduler(jobstores=jobstores,
executors=executors,
job_defaults=job_defaults)
def task():
print len(CacheTest.cache)
app.add_job(task, 'interval', seconds=2)
app.start()
def clock() -> None:
set_tag("pcapi.app_type", "clock")
scheduler = BlockingScheduler()
utils.activate_sentry(scheduler)
scheduler.add_job(synchronize_allocine_stocks, "cron", day="*", hour="23")
scheduler.add_job(synchronize_provider_api, "cron", day="*", hour="1")
scheduler.add_job(pc_remote_import_beneficiaries,
"cron",
day="*",
hour="21",
minute="50")
scheduler.add_job(pc_remote_import_beneficiaries_from_old_dms,
"cron",
day="*",
hour="20",
minute="50")
scheduler.add_job(pc_import_beneficiaries_from_dms_v3, "cron", hour="*")
scheduler.add_job(pc_import_beneficiaries_from_dms_v4,
"cron",
hour="*",
minute="20")
scheduler.add_job(update_booking_used, "cron", day="*", hour="0")
scheduler.add_job(
pc_handle_expired_bookings,
"cron",
day="*",
hour="5",
)
scheduler.add_job(
pc_notify_soon_to_be_expired_individual_bookings,
"cron",
day="*",
hour="5",
minute="30",
)
scheduler.add_job(pc_notify_newly_eligible_users,
"cron",
day="*",
hour="3")
scheduler.add_job(pc_clean_expired_tokens, "cron", day="*", hour="2")
scheduler.add_job(pc_check_stock_quantity_consistency,
"cron",
day="*",
hour="1")
scheduler.add_job(pc_send_tomorrow_events_notifications,
"cron",
day="*",
hour="16")
scheduler.add_job(pc_clean_past_draft_offers, "cron", day="*", hour="20")
scheduler.add_job(pc_send_withdrawal_terms_to_offerers_validated_yesterday,
"cron",
day="*",
hour="6")
scheduler.add_job(pc_recredit_underage_users, "cron", day="*", hour="0")
scheduler.start()
def wrapper():
scheduler = BlockingScheduler()
scheduler.add_job(func, args[0], hours=kwargs['hour'])
scheduler.start()
return func(args=args, kwargs=kwargs)
def aps():
sched = BlockingScheduler()
sched.add_job(getaqi, 'interval', days=1)
sched.start()
def run():
scheduler = BlockingScheduler()
scheduler.add_job(doValid, 'interval', minutes=30)
scheduler.start()
from apscheduler.schedulers.blocking import BlockingScheduler
import urllib3
# 宣告一個排程
sched = BlockingScheduler()
# 定義排程 : 在周一至周五，每 20 分鐘就做一次 def scheduled_jog()
@sched.scheduled_job('cron', day_of_week='mon-fri', minute='*/20')
def scheduled_job():
url = "https://fitnessbot-prd.herokuapp.com/"
connect = urllib3.request.urlopen(url)
sched.start() # 啟動排程
def job():
sched = BlockingScheduler()
sched.add_job(get, 'interval', hours=1, misfire_grace_time=300)
sched.start()
pass
compulsory_service_id = compulsory_service.get('serviceId')
if compulsory_service_id not in user_service_set:
service_name = compulsory_service.get('service')
service_json = {'tenant': tenant_id, 'service': service_name}
pykube_util.deploy(service_json)
print('deployed compulsory service %s successfully' % service_name)
json_to_add = {
'serviceId': compulsory_service_id,
'service': service_name,
'service_started': True,
"active": True
}
add_doc(tenant_id, json_to_add)
# read_services()
if __name__ == '__main__':
print('Starting kube scheduler')
SCHEDULER_INTERVAL = constatnts.SCHEDULER_INTERVAL
executors = {'default': ThreadPoolExecutor()}
app_scheduler = BlockingScheduler(executors=executors, timezone=utc)
app_scheduler.add_job(read_services,
'interval',
seconds=SCHEDULER_INTERVAL,
id='kubernetes deployment scheduler')
app_scheduler.start()