class IntegrationTestBase(object):
def setup(self):
self.jobstore = self.make_jobstore()
self.scheduler = Scheduler()
self.scheduler.add_jobstore(self.jobstore, 'persistent')
self.scheduler.start()
def test_overlapping_runs(self):
# Makes sure that "increment" is only ran once, since it will still be
# running when the next appointed time hits.
vals = [0]
self.scheduler.add_interval_job(increment, jobstore='persistent',
seconds=1, args=[vals, 2])
sleep(2.5)
eq_(vals, [1])
def test_max_instances(self):
vals = [0]
events = []
self.scheduler.add_listener(events.append,
EVENT_JOB_EXECUTED | EVENT_JOB_MISSED)
self.scheduler.add_interval_job(increment, jobstore='persistent',
seconds=0.3, max_instances=2, max_runs=4, args=[vals, 1])
sleep(2.4)
eq_(vals, [2])
eq_(len(events), 4)
eq_(events[0].code, EVENT_JOB_MISSED)
eq_(events[1].code, EVENT_JOB_MISSED)
eq_(events[2].code, EVENT_JOB_EXECUTED)
eq_(events[3].code, EVENT_JOB_EXECUTED)
class BlueprintHandler:
setter_blacklist = []
getter_blacklist = []
def __init__(self, blueprint, testing=False, testing_count=10):
self.blueprint = blueprint
self.testing = testing
self.testing_count = testing_count
self.scheduler = Scheduler()
def do_step(self):
print "stepping"
try:
# Fetch any outstanding events from the engine process and execute in simulator
while not self.local_queue.empty():
action = self.local_queue.get()
try:
self.blueprint.interface.set(action[0], float(action[1]))
print "Received action:", action
except exceptions.ValueError:
print "Value '" + str(action[1]) + "' is not convertable to float"
points = self.blueprint.interface.get_getters()
self.blueprint.step(stepcount=int(1 / 0.1))
g = {}
for point in points:
if point in BlueprintHandler.getter_blacklist:
continue
g[point] = self.blueprint.interface.get(point)
for k in g.keys():
m = Measurement()
m.bid = self.blueprint.building.buildingID
m.timestamp = datetime.utcnow().replace(tzinfo=utc)
m.uuid = k
m.val = g[k]
m.save()
except:
# print 'error: ', sys.exc_info()
print "trace: ", traceback.print_exc()
def init_scheduler(self):
schedule_store = RAMJobStore()
# Write data every 15 seconds.
job_second = self.scheduler.add_interval_job(self.do_step, 0, 0, 0, 0, 15)
schedule_store.add_job(job_second)
self.scheduler.add_jobstore(schedule_store, "Simulator scheduler", quiet=False)
def start(self, queue=None):
self.local_queue = queue
self.init_scheduler()
self.scheduler.start()
def stop(self):
self.scheduler.shutdown()
def add_job(self, command, hour, minute, sec=0):
logger.info("2. scheduler adding job command: %s at %s:%s:%s" % (
command, hour, minute, sec
))
sched = Scheduler(standalone=True)
#make a db file
shelve.open(
os.path.join(
os.path.dirname(__file__),
'example.db'
)
)
sched.add_jobstore(ShelveJobStore('example.db'), 'shelve')
exec_time = datetime(
date.today().year,
date.today().month,
date.today().day,
int(hour),
int(minute),
int(sec)
)
#test
#exec_time = datetime.now() + timedelta(seconds=5)
sched.add_date_job(
job,
exec_time,
name='alarm',
jobstore='shelve',
args=[command]
)
sched.start()
class IntegrationTestBase(object):
def setup(self):
self.jobstore = self.make_jobstore()
self.scheduler = Scheduler()
self.scheduler.add_jobstore(self.jobstore, 'persistent')
self.scheduler.start()
def test_overlapping_runs(self):
# Makes sure that "increment" is only ran once, since it will still be
# running when the next appointed time hits.
vals = [0]
self.scheduler.add_interval_job(increment, jobstore='persistent', seconds=1, args=[vals, 2])
sleep(2.5)
eq_(vals, [1])
def test_max_instances(self):
vals = [0]
events = []
self.scheduler.add_listener(events.append, EVENT_JOB_EXECUTED | EVENT_JOB_MISSED)
self.scheduler.add_interval_job(increment, jobstore='persistent', seconds=0.3, max_instances=2, max_runs=4,
args=[vals, 1])
sleep(2.4)
eq_(vals, [2])
eq_(len(events), 4)
eq_(events[0].code, EVENT_JOB_MISSED)
eq_(events[1].code, EVENT_JOB_MISSED)
eq_(events[2].code, EVENT_JOB_EXECUTED)
eq_(events[3].code, EVENT_JOB_EXECUTED)
class Sheduler:
def __init__(self):
self.scheduler = Scheduler(standalone=True)
self.scheduler.add_jobstore(MongoDBJobStore('mesjobs'),
'MongoDB')
def start(self):
print('Starting the sheduler')
try:
self.scheduler.start()
except (KeyboardInterrupt, SystemExit):
pass
def start( config={} ):
# params init
mongo_host = config.get('host', SETTING['host'])
mongo_port = config.get('port', SETTING['port'])
db = pymongo.Connection(mongo_host, mongo_port)
store = MongoDBJobStore(connection=db)
# create schedudler and run
scheduler = Scheduler(daemonic=False)
scheduler.start()
scheduler.add_jobstore(store, 'mongo')
# add cron jobs
scheduler.add_cron_job(monitor_cron_job, hour='0-23', minute="0", second="0", jobstore='mongo')
def restart_file_schedule():
scheduler = Scheduler(daemonic = False)
scheduler.print_jobs()
#scheduler.remove_jobstore('file',close=True)
#scheduler.shutdown(wait=False)
scheduler.add_jobstore(ShelveJobStore('/tmp/db_schedule'), 'file')
scheduler.start()
print 'success!'
scheduler.print_jobs()
def main():
sched = Scheduler()
# mysql_engine = create_engine('mysql://root:@localhost:3306/fengine?charset=utf8',encoding = "utf-8",echo =True)
mysql_engine = get_db_engine()
sched.daemonic = False
print "Starting index engine......"
job_store = SQLAlchemyJobStore(engine=mysql_engine)
sched.add_jobstore(job_store, 'default')
list_spider_job(sched) #将Spider的任务加入队列
scan_engine_job(sched) #将主索引服务加入任务队列
# sched.add_cron_job(scan_loan_items_job,hour='*', minute='*', second='5')
#将索引Job加入到调度系统，按照每5分钟的频率启动
# engine_name = 'engine.py'
# python_loc = os.path.join(os.getcwd(), engine_name)
# sched.add_interval_job(python_job_func, seconds =5, name = engine_name, args = [python_loc])
# list_spider_job(sched)
sched.start()
def main():
sched = Scheduler()
# mysql_engine = create_engine('mysql://root:@localhost:3306/fengine?charset=utf8',encoding = "utf-8",echo =True)
mysql_engine = get_db_engine()
sched.daemonic = False
print "Starting index engine......"
job_store = SQLAlchemyJobStore(engine = mysql_engine)
sched.add_jobstore(job_store, 'default')
list_spider_job(sched) #将Spider的任务加入队列
scan_engine_job(sched) #将主索引服务加入任务队列
# sched.add_cron_job(scan_loan_items_job,hour='*', minute='*', second='5')
#将索引Job加入到调度系统，按照每5分钟的频率启动
# engine_name = 'engine.py'
# python_loc = os.path.join(os.getcwd(), engine_name)
# sched.add_interval_job(python_job_func, seconds =5, name = engine_name, args = [python_loc])
# list_spider_job(sched)
sched.start()
def start(config={}):
# params init
mongo_host = config.get('host', SETTING['host'])
mongo_port = config.get('port', SETTING['port'])
db = pymongo.Connection(mongo_host, mongo_port)
store = MongoDBJobStore(connection=db)
# create schedudler and run
scheduler = Scheduler(daemonic=False)
scheduler.start()
scheduler.add_jobstore(store, 'mongo')
# add cron jobs
scheduler.add_cron_job(monitor_cron_job,
hour='0-23',
minute="0",
second="0",
jobstore='mongo')
class MyScheduler:
EVENTS = {
'1': 'EVENT_SCHEDULER_START',
'2': 'EVENT_SCHEDULER_SHUTDOWN',
'3': 'EVENT_JOBSTORE_ADDED',
'4': 'EVENT_JOBSTORE_REMOVED',
'5': 'EVENT_JOBSTORE_JOB_ADDED',
'32': 'EVENT_JOBSTORE_JOB_REMOVED',
'64': 'EVENT_JOB_EXECUTED',
'128': 'EVENT_JOB_ERROR',
'256': 'EVENT_JOB_MISSED'
}
def __init__(self, db_path='sqlite:///scheduler.db'):
self.scheduler = Scheduler()
self.scheduler.add_jobstore(SQLAlchemyJobStore(url=db_path), 'default')
def start(self):
self.scheduler.start()
def add_job(self, job, date, args):
job = self.scheduler.add_date_job(job, date, args)
print job
def jobs(self):
return self.scheduler.get_jobs()
def remove_job(self, notfication_id):
jobs = self.jobs()
for job in jobs:
if int(job.args[0]) == int(notfication_id):
self.scheduler.unschedule_job(job)
return True
return False
def shutdown(self):
self.scheduler.shutdown()
def start_schedule():
#if __name__ == '__main__':
scheduler_pl = Scheduler(daemonic = False)
scheduler_pl.print_jobs()
scheduler_pl.shutdown()
scheduler_pl.add_jobstore(ShelveJobStore('/tmp/db_pl_schedule'), 'file')
v_current_jobs = scheduler_pl.get_jobs()
print v_current_jobs
if v_current_jobs: # 如果job存在的话,先请客
scheduler_pl.unschedule_func(upload_processlist)
scheduler_pl.add_interval_job(upload_processlist, minutes=1)
scheduler_pl.start()
print 'success!'
scheduler_pl.print_jobs()
'''
from apscheduler.util import convert_to_datetime, timedelta_seconds
import sys
from datetime import *
import time
from apscheduler.scheduler import Scheduler
from apscheduler.jobstores.sqlalchemy_store import SQLAlchemyJobStore
import subprocess,os
from cron.models import Job_Info
from django.db import transaction
from django.views.generic import ListView
from tool.database import SQLITE_ADDRESS
scheduler=Scheduler()
scheduler.daemonic=False
scheduler.add_jobstore(SQLAlchemyJobStore(SQLITE_ADDRESS),'schedulerjobs')
scheduler.start()
class IndexView(View):
#template_name = 'cron_index.html'
def get(self,request,*args,**kwargs):
return render_to_response('cron_index.html')
indexView = IndexView.as_view()
class ListJobView(ListView):
paginate_by = 5
context_object_name = 'instances'
queryset = Job_Info.objects.all()
template_name = 'job_list.html'
listjobView = ListJobView.as_view()
class EventScheduler():
logging.basicConfig()
"""Class to scheduler regular events in a similar manner to cron."""
__mysql_url = 'mysql+pymysql://powermonitor:%s@localhost/powermonitor' \
% str(base64.b64decode(bytes('cDB3M3JtMG4xdDBy')))
'''This determines the number of seconds after the designated run time that the job is still allowed to be run.
If jobs are not being run, try increasing this in increments of 1.'''
__GRACE_PERIOD = 31536000 # Amazing grace! Time in seconds before the job is considered misfired. Currently a year
__COALESCE = True # Force the job to only run once instead of retrying multiple times
'''If there is a problem with thread concurrency, play around with these values. You'd think with all these threads
in the pool that the filter would get clogged up!'''
__threadpool_corethreads = 0 # Maximum number of persistent threads in the pool
__threadpool_maxthreads = 20 # Maximum number of total threads in the pool
__threadpool_keepalive = 1 # Seconds to keep non-core worker threads in the pool
def __init__(self, start=True):
try:
config = {
'apscheduler.daemon': True,
'apscheduler.standalone': False,
'apscheduler.threadpool.core_threads':
self.__threadpool_corethreads,
'apscheduler.threadpool.max_threads':
self.__threadpool_maxthreads,
'apscheduler.threadpool.keepalive':
self.__threadpool_keepalive,
'apscheduler.coalesce': self.__COALESCE
}
self.__sched = Scheduler(config)
'''Add the SQLAlchemy job store as the default. This was surprisingly far less tedious than getting the
shelve job store working.'''
self.__sched.add_jobstore(
SQLAlchemyJobStore(url=self.__mysql_url, tablename='SCHEDULE'),
'default')
atexit.register(lambda: self.__sched.shutdown(wait=False)
) # Stop the scheduler when the program exits
if start:
self.__sched.start()
except KeyError:
logging.warning('An error occurred starting the scheduler.')
def start_scheduler(self):
self.__sched.start()
def add_cron_event(self,
func,
name,
year=None,
month=None,
week=None,
day=None,
day_of_week=None,
hour=None,
minute=None,
second=None,
start_date=None,
*args,
**kwargs):
"""Add a cron like event to the schedule. Each job must be given a name in case it needs to be removed.
The following expressions can be used in each field:
Expression Field Description
* any Fire on every value
*/a any Fire on every 'a' values, starting from the minimum
a-b any Fire on any value in the 'a-b' range (a must be smaller than b
a-b/c any Fire every 'c' values within the 'a-b' range
xth y day Fire on the x -th occurrence of weekday y within the month
last x day Fire on the last occurrence of weekday 'x' within the month
last day Fire on the last day within the month
x,y,z any Fire on any matching expression; can combine any number of any of the above expressions
If you want to add **options to the event, use kwargs (keyword arguments dictionary)"""
if self.__sched is not None:
event_exists = False
if self.__find_event(name) is not None:
event_exists = True
if not event_exists:
self.__sched.add_cron_job(
func=func,
name=name,
year=year,
month=month,
day=day,
week=week,
day_of_week=day_of_week,
hour=hour,
minute=minute,
second=second,
start_date=start_date,
args=args,
kwargs=kwargs,
misfire_grace_time=self.__GRACE_PERIOD)
logging.info('New cron event added')
else:
'''Every event needs a unique name so we can keep track of the little bastards. And please use
descriptive names so that they can be properly identified in the job schedule.'''
logging.warning('add_cron_event: Event already exists')
raise EventExistsError('A job with name %s already exists' %
name)
else:
raise SchedulerNotFoundError(
'add_cron_event: Scheduler does not exist. It may have not started.'
)
def __find_event(self, event_name):
if self.__sched is not None:
events = self.__sched.get_jobs()
for event in events:
if event.name == event_name:
return event
else:
return None
else:
logging.warning(
'__find_event: Scheduler does not exist. It may have not started.'
)
raise SchedulerNotFoundError(
'Scheduler does not exist. It may have not started.')
def add_onceoff_event(self, func, name, date, args=None):
"""Add a once off event to the schedule. The job is executed once at the specified date and time.
Date/time format: YYYY-MM-DD HH:MM:SS"""
if self.__sched is not None:
try:
if args is None: # If there are no arguments to be passed to the function
self.__sched.add_date_job(
func=func,
name=name,
date=date,
misfire_grace_time=self.__GRACE_PERIOD)
else: # If there are arguments to be passed to the function
self.__sched.add_date_job(
func=func,
name=name,
date=date,
arge=args,
misfire_grace_time=self.__GRACE_PERIOD)
except ValueError:
'''If the event is in the past, it will not run. This program is not capable of manipulating
space and time. Try import __time_travel__'''
raise EventWontRunError(
'The event will not run: Event time has expired.')
logging.info('New once off event added')
else:
logging.warning(
'add_onceoff_event: Scheduler does not exist. It may have not started.'
)
raise SchedulerNotFoundError(
'Scheduler does not exist. It may have not started.')
def remove_event(self, event_name):
"""Remove the event 'event_name' from the schedule."""
if self.__sched is not None:
removed = False
event = self.__find_event(event_name=event_name)
if event is not None: # If the event exists, remove it
self.__sched.unschedule_job(event)
removed = True
if not removed:
'''Raise an error so that it can be handled correctly'''
logging.warning('remove_event: Event not found for removal.')
raise EventNotFoundError('Event not found for removal: %s' %
event_name)
else:
raise SchedulerNotFoundError(
'remove_event: Scheduler does not exist. It may have not started.'
)
def get_jobs(self):
"""Get the list of events currently in the job store."""
if self.__sched is not None:
return self.__sched.get_jobs()
else:
raise SchedulerNotFoundError(
'get_events: Scheduler does not exist. It may have not started.'
)
def get_job_names(self):
"""
Get the names of all the jobs in the job store
:return: list
"""
jobs = self.get_jobs()
job_list = []
if jobs:
for job in jobs:
job_list.append(job.name)
return job_list
def get_scheduler(self):
"""Returns the Scheduler object. Rather add functionality to this class than call this method."""
if self.__sched is not None:
return self.__sched
else:
raise SchedulerNotFoundError(
'get_scheduler: Scheduler does not exist. It may have not started.'
)
from datetime import datetime, timedelta
from apscheduler.scheduler import Scheduler
from apscheduler.jobstores.sqlalchemy_store import SQLAlchemyJobStore
from sqlalchemy import create_engine
import logging
logging.basicConfig()
def alarm(time):
print('Alarm! This alarm was scheduled at %s.' % time)
if __name__ == '__main__':
engine = create_engine('sqlite:///example3.db')
scheduler = Scheduler(standalone=True)
scheduler.add_jobstore(SQLAlchemyJobStore(engine=engine), 'shelve')
alarm_time = datetime.now() + timedelta(seconds=100)
scheduler.add_cron_job(alarm,
jobstore='shelve', second="*",minute="1")
print('To clear the alarms, delete the example.db file.')
print('Press Ctrl+C to exit')
try:
scheduler.start()
except (KeyboardInterrupt, SystemExit):
pass
This example demonstrates the use of persistent job stores.
On each run, it adds a new alarm that fires after ten seconds.
You can exit the program, restart it and observe that any previous alarms that have not fired yet are still active.
"""
from datetime import datetime, timedelta
from apscheduler.scheduler import Scheduler
from apscheduler.jobstores.shelve_store import ShelveJobStore
def alarm(time):
print('Alarm! This alarm was scheduled at %s.' % time)
if __name__ == '__main__':
scheduler = Scheduler(standalone=True)
scheduler.add_jobstore(ShelveJobStore('example.db'), 'shelve')
alarm_time = datetime.now() + timedelta(seconds=10)
scheduler.add_date_job(alarm,
alarm_time,
name='alarm',
jobstore='shelve',
args=[datetime.now()])
print('To clear the alarms, delete the example.db file.')
print('Press Ctrl+C to exit')
try:
scheduler.start()
except (KeyboardInterrupt, SystemExit):
pass
class EventScheduler():
"""Class to scheduler regular events in a similar manner to cron."""
__mysql_url = 'mysql+pymysql://powermonitor:%s@localhost/powermonitor' \
% str(base64.b64decode(bytes('cDB3M3JtMG4xdDBy')))
'''This determines the number of seconds after the designated run time that the job is still allowed to be run.
If jobs are not being run, try increasing this in increments of 1.'''
__GRACE_PERIOD = 31536000 # Amazing grace! Time in seconds before the job is considered misfired. Currently a year
__COALESCE = True # Force the job to only run once instead of retrying multiple times
'''If there is a problem with thread concurrency, play around with these values. You'd think with all these threads
in the pool that the filter would get clogged up!'''
__threadpool_corethreads = 0 # Maximum number of persistent threads in the pool
__threadpool_maxthreads = 20 # Maximum number of total threads in the pool
__threadpool_keepalive = 1 # Seconds to keep non-core worker threads in the pool
def __init__(self, start=True):
try:
config = {'apscheduler.daemon': True, 'apscheduler.standalone': False,
'apscheduler.threadpool.core_threads': self.__threadpool_corethreads,
'apscheduler.threadpool.max_threads': self.__threadpool_maxthreads,
'apscheduler.threadpool.keepalive': self.__threadpool_keepalive,
'apscheduler.coalesce': self.__COALESCE}
self.__sched = Scheduler(config)
'''Add the SQLAlchemy job store as the default. This was surprisingly far less tedious than getting the
shelve job store working.'''
self.__sched.add_jobstore(SQLAlchemyJobStore(url=self.__mysql_url, tablename='SCHEDULE'), 'default')
atexit.register(lambda: self.__sched.shutdown(wait=False)) # Stop the scheduler when the program exits
if start:
self.__sched.start()
except KeyError:
logging.warning('An error occurred starting the scheduler.')
def start_scheduler(self):
self.__sched.start()
def add_cron_event(self, func, name, year=None, month=None, week=None, day=None,
day_of_week=None, hour=None, minute=None, second=None, start_date=None, *args,
**kwargs):
"""Add a cron like event to the schedule. Each job must be given a name in case it needs to be removed.
The following expressions can be used in each field:
Expression Field Description
* any Fire on every value
*/a any Fire on every 'a' values, starting from the minimum
a-b any Fire on any value in the 'a-b' range (a must be smaller than b
a-b/c any Fire every 'c' values within the 'a-b' range
xth y day Fire on the x -th occurrence of weekday y within the month
last x day Fire on the last occurrence of weekday 'x' within the month
last day Fire on the last day within the month
x,y,z any Fire on any matching expression; can combine any number of any of the above expressions
If you want to add **options to the event, use kwargs (keyword arguments dictionary)"""
if self.__sched is not None:
event_exists = False
if self.__find_event(name) is not None:
event_exists = True
if not event_exists:
self.__sched.add_cron_job(func=func, name=name, year=year, month=month, day=day, week=week,
day_of_week=day_of_week, hour=hour, minute=minute, second=second,
start_date=start_date, args=args, kwargs=kwargs,
misfire_grace_time=self.__GRACE_PERIOD)
logging.info('New cron event added')
else:
'''Every event needs a unique name so we can keep track of the little bastards. And please use
descriptive names so that they can be properly identified in the job schedule.'''
logging.warning('add_cron_event: Event already exists')
raise EventExistsError('A job with name %s already exists' % name)
else:
raise SchedulerNotFoundError('add_cron_event: Scheduler does not exist. It may have not started.')
def __find_event(self, event_name):
if self.__sched is not None:
events = self.__sched.get_jobs()
for event in events:
if event.name == event_name:
return event
else:
return None
else:
logging.warning('__find_event: Scheduler does not exist. It may have not started.')
raise SchedulerNotFoundError('Scheduler does not exist. It may have not started.')
def add_onceoff_event(self, func, name, date, args=None):
"""Add a once off event to the schedule. The job is executed once at the specified date and time.
Date/time format: YYYY-MM-DD HH:MM:SS"""
if self.__sched is not None:
try:
if args is None: # If there are no arguments to be passed to the function
self.__sched.add_date_job(func=func, name=name, date=date,
misfire_grace_time=self.__GRACE_PERIOD)
else: # If there are arguments to be passed to the function
self.__sched.add_date_job(func=func, name=name, date=date, arge=args,
misfire_grace_time=self.__GRACE_PERIOD)
except ValueError:
'''If the event is in the past, it will not run. This program is not capable of manipulating
space and time. Try import __time_travel__'''
raise EventWontRunError('The event will not run: Event time has expired.')
logging.info('New once off event added')
else:
logging.warning('add_onceoff_event: Scheduler does not exist. It may have not started.')
raise SchedulerNotFoundError('Scheduler does not exist. It may have not started.')
def remove_event(self, event_name):
"""Remove the event 'event_name' from the schedule."""
if self.__sched is not None:
removed = False
event = self.__find_event(event_name=event_name)
if event is not None: # If the event exists, remove it
self.__sched.unschedule_job(event)
removed = True
if not removed:
'''Raise an error so that it can be handled correctly'''
logging.warning('remove_event: Event not found for removal.')
raise EventNotFoundError('Event not found for removal: %s' % event_name)
else:
raise SchedulerNotFoundError('remove_event: Scheduler does not exist. It may have not started.')
def get_jobs(self):
"""Get the list of events currently in the job store."""
if self.__sched is not None:
return self.__sched.get_jobs()
else:
raise SchedulerNotFoundError('get_events: Scheduler does not exist. It may have not started.')
def get_job_names(self):
"""
Get the names of all the jobs in the job store
:return: list
"""
jobs = self.get_jobs()
job_list = []
if jobs:
for job in jobs:
job_list.append(job.name)
return job_list
def get_scheduler(self):
"""Returns the Scheduler object. Rather add functionality to this class than call this method."""
if self.__sched is not None:
return self.__sched
else:
raise SchedulerNotFoundError('get_scheduler: Scheduler does not exist. It may have not started.')
def start_schedule():
#if __name__ == '__main__':
os_user = config.OS_USER
os_password = config.OS_APPS_PASSWD
scheduler = Scheduler(daemonic = False)
scheduler.print_jobs()
#scheduler.remove_jobstore('file',close=True)
#scheduler.shutdown(wait=False)
scheduler.shutdown()
#scheduler.unschedule_func(backup)
scheduler.add_jobstore(ShelveJobStore('/tmp/db_schedule'), 'file')
v_current_jobs = scheduler.get_jobs()
print v_current_jobs
if v_current_jobs: # 如果job存在的话,先请客
scheduler.unschedule_func(backup)
#scheduler = Scheduler(standalone=True)
#scheduler = Scheduler(daemon=True)
#连接配置中心库，获取数据库备份周期等信息
db = Connection('/tmp/mysql3306.sock',
config.DB_NAME,
config.DB_USER,
config.DB_PASSWD,
time_zone='+8:00')
v_sql = r"""SELECT a.instance_id,b.ip,b.port,a.backup_interval_type,a.backup_start_time from mysql_ins_bak_setup a,tag b where
a.instance_id=b.id """
print v_sql
bak_server_list = db.query(v_sql)
if bak_server_list: # 有server需要配置
i=0
# 把还没有开始的调度任务，置为手工结束 backup_result_type=4
v_manual_end_sql = 'update mysql_ins_bak_log set backup_result_type=4 where backup_result_type=0'
db.execute(v_manual_end_sql)
for bak_server in bak_server_list:
instance_id = bak_server['instance_id']
from_host = bak_server['ip']
#print from_host
mysql_port = bak_server['port']
backup_interval_type = bak_server['backup_interval_type']
backup_start_time = bak_server['backup_start_time']
str_start_date= time.strftime("%Y-%m-%d") + ' ' + backup_start_time
print str_start_date
if backup_interval_type == 1: # every day
#内存jobstore
#scheduler.add_interval_job(backup, days=1, start_date=str_start_date, args=[from_host, mysql_port, os_user, os_password])
#文件jobstore jobstore='file'
scheduler.add_interval_job(backup, days=1, start_date=str_start_date, args=[from_host, mysql_port, os_user, os_password], jobstore='file')
#scheduler.add_interval_job(backup, days=1, start_date='2014-07-18 18:17:01', args=[from_host, mysql_port, os_user, os_password])
elif backup_interval_type == 2: # every week
scheduler.add_interval_job(backup, weeks=1, start_date=str_start_date, args=[from_host, mysql_port, os_user, os_password])
elif backup_interval_type == 3: # every hour
scheduler.add_interval_job(backup, hours=1, start_date=str_start_date, args=[from_host, mysql_port, os_user, os_password])
# 开始在数据库记录备份的调度任务状态 0:调度任务已启动，实际备份还没有开始
v_sche_start_sql = """insert into mysql_ins_bak_log(instance_id,backup_result_type)
values(%d,0)""" % (instance_id)
db.execute(v_sche_start_sql)
i=i+1
db.close()
if bak_server_list: # 有server需要配置
scheduler.start()
print 'success!'
scheduler.print_jobs()
'''
from apscheduler.scheduler import Scheduler from apscheduler.jobstores.sqlalchemy_store import SQLAlchemyJobStore import datetime from time import sleep JOBS_DATABASE = "postgresql://*****:*****@localhost/test_jobs" # Start the scheduler sched = Scheduler() sched.add_jobstore(SQLAlchemyJobStore(url=JOBS_DATABASE, tablename='apscheduler_jobs'), 'default') sched.start() def print_reservation_id(reservation_id): print "====> Reservation id is " + str(reservation_id) if __name__ == '__main__': print "====> Printing jobs..." print sched.print_jobs() now = datetime.datetime.now() start_time = now + datetime.timedelta(seconds=3) later = now + datetime.timedelta(seconds=10) print "====> now is " + str(now) print "====> start_time is " + str(start_time) print "====> later is " + str(later) reservation_id = 1
jobs = 0
last_check = 0
try:
last_check = int(pydis.get("cron_last_run"))
except TypeError:
pass
pydis.set("cron_last_run", int(time()))
for job in db.jobqueue.select().where(db.jobqueue.ts >= last_check):
jobs += 1
t = threading.Thread(target=self.run, args=(job, ))
t.start()
threads.append(t)
[t.join() for t in threads]
# Started %d jobs" % jobs
cjob = Jobs()
sched = Scheduler(daemonic=False)
sched.add_jobstore(ShelveJobStore('./cron.jobs'), 'file')
sched.add_interval_job(cjob.start, seconds=10)
sched.start()
pydis.set("cron_next_run", sched.get_jobs()[0].next_run_time)
and event.job.name != 'remove_events'):
if (event.retval == True):
set_status(event.job.name, 5)
logger.info("Event #" + str(event.job.name) +
" completed successfully")
elif (event.retval == False):
set_status(event.job.name, 4)
logger.error("Event #" + str(event.job.name) + " had an error")
if event.exception:
print event.exception
logger.fatal("Event #" + str(event.job.name) + ' - job crashed :(')
#start the scheduler
sched = Scheduler()
sched.add_jobstore(WriteBackShelveJobStore('jobstore.db'), 'shelve')
sched.start()
sched.add_listener(my_listener, EVENT_JOB_EXECUTED | EVENT_JOB_ERROR)
process_events()
# Process events list every 10 seconds
sched.add_interval_job(process_events, seconds=10)
# Remove completed events from db every minute
sched.add_interval_job(remove_events, minutes=1)
print "Dispatcher started..."
try:
def my_listener(event):
if (event.job.name != 'process_events' and event.job.name != 'remove_events'):
if (event.retval == True):
set_status(event.job.name, 5)
logger.info("Event #" + str(event.job.name) + " completed successfully")
elif (event.retval == False):
set_status(event.job.name, 4)
logger.error("Event #" + str(event.job.name) + " had an error")
if event.exception:
print event.exception
logger.fatal("Event #" + str(event.job.name) + ' - job crashed :(')
#start the scheduler
sched = Scheduler()
sched.add_jobstore(WriteBackShelveJobStore('jobstore.db'), 'shelve')
sched.start()
sched.add_listener(my_listener, EVENT_JOB_EXECUTED | EVENT_JOB_ERROR)
process_events()
# Process events list every 10 seconds
sched.add_interval_job(process_events, seconds=10)
# Remove completed events from db every minute
sched.add_interval_job(remove_events, minutes=1)
print "Dispatcher started..."
# Set default values
for key in DEFAULT_CONFIG.keys():
config_set_default(key, DEFAULT_CONFIG[key])
# Executor
from executor_raspberry import ExecutorRaspberry
executor = ExecutorRaspberry(panServoId=config_get("pan_servo"),
tiltServoId=config_get("tilt_servo"))
# Scheduler
from apscheduler.scheduler import Scheduler
from apscheduler.jobstores.shelve_store import ShelveJobStore
import atexit
sched = Scheduler(daemon=True)
sched.add_jobstore(ShelveJobStore('sched.db'), 'file')
atexit.register(lambda: sched.shutdown(wait=False))
sched.start()
# Logging
import logging
import sys
ch = logging.StreamHandler(sys.stdout)
ch.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
ch.setFormatter(formatter)
root = logging.getLogger()
root.addHandler(ch)
# pull out the delimiter
delimiter = app.config["MESSAGING"]["incoming_delimiter"]
# mongoengine connection
connect(app.config["MONGO"]["db_name"], host=app.config["MONGO"]["host"], port=int(app.config["MONGO"]["port"]))
# start the logger
logging.basicConfig(
filename=app.config["LOG_FILE"], level=logging.DEBUG, format="%(levelname)s[%(asctime)s]: %(message)s"
)
# start the job scheduler with persistent store
scheduler = Scheduler()
scheduler.add_jobstore(
MongoDBJobStore(
database=app.config["MONGO"]["db_name"], host=app.config["MONGO"]["host"], port=int(app.config["MONGO"]["port"])
)
)
scheduler.start()
""" twilio endpoints
"""
@app.route("/api/1/sms/incoming", methods=["POST"])
def incoming_sms():
""" twilio posts data here when a text message is received
see http://www.twilio.com/docs/api/twiml/sms/twilio_request
"""
if flask.request.form["AccountSid"] != app.config["TWILIO"]["account_sid"]:
from datetime import datetime, timedelta
import sys
import time
from apscheduler.scheduler import Scheduler
from apscheduler.jobstores.shelve_store import ShelveJobStore
def alarm(time):
sys.stdout.write('Alarm! This alarm was scheduled at %s.\n' % time)
if __name__ == '__main__':
scheduler = Scheduler()
scheduler.add_jobstore(ShelveJobStore('example.db'), 'shelve')
alarm_time = datetime.now() + timedelta(minutes=1)
scheduler.add_date_job(alarm, alarm_time, name='alarm',
jobstore='shelve', args=[datetime.now()])
sys.stdout.write('To clear the alarms, delete the example.db file.\n')
sys.stdout.write('Press Ctrl+C to exit\n')
scheduler.start()
try:
# This is here to prevent the main thread from exiting so that the
# scheduler has time to work -- this is rarely necessary in real world
# applications
time.sleep(9999)
finally:
# Shut down the scheduler so that the job store gets closed properly
scheduler.shutdown()
from apscheduler.scheduler import Scheduler
from apscheduler.jobstores.sqlalchemy_store import SQLAlchemyJobStore
import datetime
from time import sleep
JOBS_DATABASE = "postgresql://*****:*****@localhost/test_jobs"
# Start the scheduler
sched = Scheduler()
sched.add_jobstore(
SQLAlchemyJobStore(url=JOBS_DATABASE, tablename='apscheduler_jobs'),
'default')
sched.start()
def print_reservation_id(reservation_id):
print "====> Reservation id is " + str(reservation_id)
if __name__ == '__main__':
print "====> Printing jobs..."
print sched.print_jobs()
now = datetime.datetime.now()
start_time = now + datetime.timedelta(seconds=3)
later = now + datetime.timedelta(seconds=10)
print "====> now is " + str(now)
print "====> start_time is " + str(start_time)
print "====> later is " + str(later)
# Set default values
for key in DEFAULT_CONFIG.keys():
config_set_default(key, DEFAULT_CONFIG[key])
# Executor
from executor_raspberry import ExecutorRaspberry
executor = ExecutorRaspberry(
panServoId=config_get("pan_servo"),
tiltServoId=config_get("tilt_servo"))
# Scheduler
from apscheduler.scheduler import Scheduler
from apscheduler.jobstores.shelve_store import ShelveJobStore
import atexit
sched = Scheduler(daemon=True)
sched.add_jobstore(ShelveJobStore('sched.db'), 'file')
atexit.register(lambda: sched.shutdown(wait=False))
sched.start()
# Logging
import logging
import sys
ch = logging.StreamHandler(sys.stdout)
ch.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
ch.setFormatter(formatter)
root = logging.getLogger()
root.addHandler(ch)
class Application(tornado.web.Application):
def __init__(self, debug):
handlers = [
(r"/?", RootHandler),
(r"/login/?", LoginHandler),
(r"/signup/?", CreateUserHandler),
(r"/logout/?", LogoutHandler),
(r"/ws/?", WebsocketHandler),
(r"/test/?", testHandler),
(r"/developer", DeveloperRegistrationHandler),
(r"/submitForm", FormHandler),
(r"/adminForm", AdminHandler),
#### oAuth 2.0 Handlers
(r"/login/oauth/authorize/?", AuthorizeHandler),
(r"/login/oauth/access_token", AccessTokenHandler),
#### API Handlers
(r"/api/email/config/create?", CreateEmailConfigHandler),
(r"/api/email/config/list?", GetEmailConfigHandler),
(r"/api/osData/?", OsHandler),
(r"/api/networkData/?", NetworkHandler),
(r"/api/summaryData/?", SummaryHandler),
(r"/api/global/graphs/severity?", GetPackageSeverityOverTimeHandler),
#(r"/api/patchData/?", PatchHandler),
(r"/api/graphData/?", GraphHandler),
(r"/api/logger/modifyLogging?", LoggingModifyerHandler),
(r"/api/logger/getParams?", LoggingListerHandler),
(r"/api/nodes.json/?", NodesHandler),
(r"/api/tags.json/?", TagsHandler),
(r"/api/patches.json/?", PatchesHandler),
(r"/api/severity.json/?", SeverityHandler),
(r"/api/scheduler/list.json/?", SchedulerListerHandler),
(r"/api/scheduler/add?", SchedulerAddHandler),
(r"/api/scheduler/recurrent/add?", SchedulerAddRecurrentJobHandler),
(r"/api/scheduler/remove?", SchedulerRemoveHandler),
(r"/api/timeblocker/list.json/?", TimeBlockerListerHandler),
(r"/api/timeblocker/add?", TimeBlockerAddHandler),
(r"/api/timeblocker/remove?", TimeBlockerRemoverHandler),
(r"/api/timeblocker/toggler?", TimeBlockerTogglerHandler),
(r"/api/tagging/listByTag.json/?", TagListerByTagHandler),
(r"/api/tagging/listByNode.json/?", TagListerByNodeHandler),
(r"/api/tagging/addTag?", TagAddHandler),
(r"/api/tagging/addTagPerNode?", TagAddPerNodeHandler),
(r"/api/tagging/removeTagPerNode?", TagRemovePerNodeHandler),
(r"/api/tagging/removeTag?", TagRemoveHandler),
(r"/api/tagging/tagStats?", GetTagStatsHandler),
(r"/api/tagging/graphs/severity?", GetTagPackageSeverityOverTimeHandler),
(r"/api/transactions/getTransactions?", GetTransactionsHandler),
(r"/api/transactions/search?", SearchTransactionsHandler),
(r"/api/package/getDependecies?", GetDependenciesHandler),
(r"/api/package/searchByPatch?", SearchPatchHandler),
(r"/api/package/getTagsByTpId?", GetTagsPerTpIdHandler),
(r"/api/node/modifyDisplayName?", ModifyDisplayNameHandler),
(r"/api/node/modifyHostName?", ModifyHostNameHandler),
(r"/api/node/delete?", NodeRemoverHandler),
(r"/api/node/cleanData?", NodeCleanerHandler),
(r"/api/node/wol?", NodeWolHandler),
(r"/api/node/graphs/severity?", GetNodePackageSeverityOverTimeHandler),
(r"/api/ssl/nodeToggler?", NodeTogglerHandler),
(r"/api/ssl/list.json/?", SslHandler),
(r"/api/acl/create?", AclCreateHandler),
(r"/api/acl/modify?", AclModifyHandler),
(r"/api/acl/delete?", AclDeleteHandler),
(r"/api/user/?", UserHandler),
(r"/api/users/list?", ListUserHandler),
(r"/api/users/create?", CreateUserHandler),
(r"/api/users/delete?", DeleteUserHandler),
(r"/api/users/toggleGroup?", ModifyUserFromGroupHandler),
(r"/api/groups/list?", ListGroupHandler),
(r"/api/groups/create?", CreateGroupHandler),
(r"/api/groups/delete?", DeleteGroupHandler),
(r"/api/virtual/node/snapshots/list?", GetNodeSnapshotsHandler),
(r"/api/virtual/node/snapshots/create?", CreateSnapshotHandler),
(r"/api/virtual/node/snapshots/revert?", RevertSnapshotHandler),
(r"/api/virtual/node/snapshots/remove?", RemoveSnapshotHandler),
(r"/api/virtual/node/snapshots/removeAll?", RemoveAllSnapshotsHandler),
(r"/api/vmware/config/create?", CreateVmwareConfigHandler),
(r"/api/vmware/config/list?", GetVmwareConfigHandler),
(r"/api/virtual/node/info?", GetNodeVmInfoHandler),
(r"/api/virtual/node/poweron?", PowerOnVmHandler),
(r"/api/virtual/node/shutdown?", ShutdownVmHandler),
(r"/api/virtual/node/reboot?", RebootVmHandler),
(r"/api/vendors/?", ApiHandler), # Returns all vendors
(r"/api/vendors/?(\w+)/?", ApiHandler), # Returns vendor with products and respected vulnerabilities.
(r"/api/vendors/?(\w+)/?(\w+)/?", ApiHandler), # Returns specific product from respected vendor with vulnerabilities.
#### File system access whitelist
(r"/css/(.*?)", tornado.web.StaticFileHandler, {"path": "wwwstatic/css"}),
(r"/font/(.*?)", tornado.web.StaticFileHandler, {"path": "wwwstatic/font"}),
(r"/img/(.*?)", tornado.web.StaticFileHandler, {"path": "wwwstatic/img"}),
(r"/js/(.*?)", tornado.web.StaticFileHandler, {"path": "wwwstatic/js"})
]
template_path = "/opt/TopPatch/tp/templates"
static_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "wwwstatic" )
#ui_modules = { 'Header', HeaderModule }
settings = {
"cookie_secret": base64.b64encode(uuid.uuid4().bytes + uuid.uuid4().bytes),
"login_url": "/login",
}
self.db = init_engine()
Session = create_session(self.db)
self.session = Session
self.scheduler = Scheduler()
self.scheduler.add_jobstore(SQLAlchemyJobStore(engine=self.db, tablename="tp_scheduler"), "toppatch")
self.scheduler.start()
self.session = validate_session(self.session)
self.account_manager = AccountManager(self.session)
self.tokens = TokenManager(self.session)
tornado.web.Application.__init__(self, handlers, template_path=template_path, static_path=static_path, debug=debug, **settings)
def log_request(self, handler):
logging.config.fileConfig('/opt/TopPatch/conf/logging.config')
log = logging.getLogger('rvweb')
log_method = log.debug
if handler.get_status() <= 299:
log_method = log.info
elif handler.get_status() <= 399 and \
handler.get_status() >= 300:
log_method = log.warn
elif handler.get_status() <= 499 and \
handler.get_status() >= 400:
log_method = log.error
elif handler.get_status() <= 599 and \
handler.get_status() >= 500:
log_method = log.error
request_time = 1000.0 * handler.request.request_time()
log_message = '%d %s %.2fms' % (handler.get_status(), handler._request_summary(), request_time)
log_method(log_message)
class TestOfflineScheduler(object):
def setup(self):
self.scheduler = Scheduler()
def teardown(self):
if self.scheduler.running:
self.scheduler.shutdown()
@raises(KeyError)
def test_jobstore_twice(self):
self.scheduler.add_jobstore(RAMJobStore(), 'dummy')
self.scheduler.add_jobstore(RAMJobStore(), 'dummy')
def test_add_tentative_job(self):
job = self.scheduler.add_date_job(lambda: None,
datetime(2200, 7, 24),
jobstore='dummy')
assert isinstance(job, Job)
eq_(self.scheduler.get_jobs(), [])
def test_configure_jobstore(self):
conf = {
'apscheduler.jobstore.ramstore.class':
'apscheduler.jobstores.ram_store:RAMJobStore'
}
self.scheduler.configure(conf)
self.scheduler.remove_jobstore('ramstore')
def test_shutdown_offline(self):
self.scheduler.shutdown()
def test_configure_no_prefix(self):
global_options = {'misfire_grace_time': '2', 'daemonic': 'false'}
self.scheduler.configure(global_options)
eq_(self.scheduler.misfire_grace_time, 1)
eq_(self.scheduler.daemonic, True)
def test_configure_prefix(self):
global_options = {
'apscheduler.misfire_grace_time': 2,
'apscheduler.daemonic': False
}
self.scheduler.configure(global_options)
eq_(self.scheduler.misfire_grace_time, 2)
eq_(self.scheduler.daemonic, False)
def test_add_listener(self):
val = []
self.scheduler.add_listener(val.append)
event = SchedulerEvent(EVENT_SCHEDULER_START)
self.scheduler._notify_listeners(event)
eq_(len(val), 1)
eq_(val[0], event)
event = SchedulerEvent(EVENT_SCHEDULER_SHUTDOWN)
self.scheduler._notify_listeners(event)
eq_(len(val), 2)
eq_(val[1], event)
self.scheduler.remove_listener(val.append)
self.scheduler._notify_listeners(event)
eq_(len(val), 2)
def test_pending_jobs(self):
# Tests that pending jobs are properly added to the jobs list when
# the scheduler is started (and not before!)
self.scheduler.add_date_job(lambda: None, datetime(9999, 9, 9))
eq_(self.scheduler.get_jobs(), [])
self.scheduler.start()
jobs = self.scheduler.get_jobs()
eq_(len(jobs), 1)
from datetime import datetime, timedelta
from apscheduler.scheduler import Scheduler
from apscheduler.jobstores.sqlalchemy_store import SQLAlchemyJobStore
def alarm(time):
print('Alarm! This alarm was scheduled at %s.' % time)
if __name__ == '__main__':
scheduler = Scheduler(standalone=True)
scheduler.add_jobstore(SQLAlchemyJobStore('sqlite:///cron.db'), 'job123')
alarm_time = datetime.now() + timedelta(seconds=10)
scheduler.add_date_job(alarm, alarm_time, name='alarm',
jobstore='job123', args=[datetime.now()])
print('To clear the alarms, delete the example.db file.')
print('Press Ctrl+d to exit')
try:
scheduler.start()
except (KeyboardInterrupt, SystemExit):
pass
class TestJobExecution(object):
def setup(self):
self.scheduler = Scheduler(threadpool=FakeThreadPool())
self.scheduler.add_jobstore(RAMJobStore(), 'default')
# Make the scheduler think it's running
self.scheduler._thread = FakeThread()
self.logstream = StringIO()
self.loghandler = StreamHandler(self.logstream)
self.loghandler.setLevel(ERROR)
scheduler.logger.addHandler(self.loghandler)
def teardown(self):
scheduler.logger.removeHandler(self.loghandler)
if scheduler.datetime == FakeDateTime:
scheduler.datetime = datetime
FakeDateTime._now = original_now
@raises(TypeError)
def test_noncallable(self):
date = datetime.now() + timedelta(days=1)
self.scheduler.add_date_job('wontwork', date)
def test_job_name(self):
def my_job():
pass
job = self.scheduler.add_interval_job(my_job,
start_date=datetime(2010, 5, 19))
eq_(
repr(job), '<Job (name=my_job, '
'trigger=<IntervalTrigger (interval=datetime.timedelta(0, 1), '
'start_date=datetime.datetime(2010, 5, 19, 0, 0))>)>')
def test_schedule_object(self):
# Tests that any callable object is accepted (and not just functions)
class A:
def __init__(self):
self.val = 0
def __call__(self):
self.val += 1
a = A()
job = self.scheduler.add_interval_job(a, seconds=1)
self.scheduler._process_jobs(job.next_run_time)
self.scheduler._process_jobs(job.next_run_time)
eq_(a.val, 2)
def test_schedule_method(self):
# Tests that bound methods can be scheduled (at least with RAMJobStore)
class A:
def __init__(self):
self.val = 0
def method(self):
self.val += 1
a = A()
job = self.scheduler.add_interval_job(a.method, seconds=1)
self.scheduler._process_jobs(job.next_run_time)
self.scheduler._process_jobs(job.next_run_time)
eq_(a.val, 2)
def test_unschedule_job(self):
def increment():
vals[0] += 1
vals = [0]
job = self.scheduler.add_cron_job(increment)
self.scheduler._process_jobs(job.next_run_time)
eq_(vals[0], 1)
self.scheduler.unschedule_job(job)
self.scheduler._process_jobs(job.next_run_time)
eq_(vals[0], 1)
def test_unschedule_func(self):
def increment():
vals[0] += 1
def increment2():
vals[0] += 1
vals = [0]
job1 = self.scheduler.add_cron_job(increment)
job2 = self.scheduler.add_cron_job(increment2)
job3 = self.scheduler.add_cron_job(increment)
eq_(self.scheduler.get_jobs(), [job1, job2, job3])
self.scheduler.unschedule_func(increment)
eq_(self.scheduler.get_jobs(), [job2])
@raises(KeyError)
def test_unschedule_func_notfound(self):
self.scheduler.unschedule_func(copy)
def test_job_finished(self):
def increment():
vals[0] += 1
vals = [0]
job = self.scheduler.add_interval_job(increment, max_runs=1)
self.scheduler._process_jobs(job.next_run_time)
eq_(vals, [1])
assert job not in self.scheduler.get_jobs()
def test_job_exception(self):
def failure():
raise DummyException
job = self.scheduler.add_date_job(failure, datetime(9999, 9, 9))
self.scheduler._process_jobs(job.next_run_time)
assert 'DummyException' in self.logstream.getvalue()
def test_misfire_grace_time(self):
self.scheduler.misfire_grace_time = 3
job = self.scheduler.add_interval_job(lambda: None, seconds=1)
eq_(job.misfire_grace_time, 3)
job = self.scheduler.add_interval_job(lambda: None,
seconds=1,
misfire_grace_time=2)
eq_(job.misfire_grace_time, 2)
def test_coalesce_on(self):
# Makes sure that the job is only executed once when it is scheduled
# to be executed twice in a row
def increment():
vals[0] += 1
vals = [0]
events = []
scheduler.datetime = FakeDateTime
self.scheduler.add_listener(events.append,
EVENT_JOB_EXECUTED | EVENT_JOB_MISSED)
job = self.scheduler.add_interval_job(increment,
seconds=1,
start_date=FakeDateTime.now(),
coalesce=True,
misfire_grace_time=2)
# Turn the clock 14 seconds forward
FakeDateTime._now += timedelta(seconds=2)
self.scheduler._process_jobs(FakeDateTime.now())
eq_(job.runs, 1)
eq_(len(events), 1)
eq_(events[0].code, EVENT_JOB_EXECUTED)
eq_(vals, [1])
def test_coalesce_off(self):
# Makes sure that every scheduled run for the job is executed even
# when they are in the past (but still within misfire_grace_time)
def increment():
vals[0] += 1
vals = [0]
events = []
scheduler.datetime = FakeDateTime
self.scheduler.add_listener(events.append,
EVENT_JOB_EXECUTED | EVENT_JOB_MISSED)
job = self.scheduler.add_interval_job(increment,
seconds=1,
start_date=FakeDateTime.now(),
coalesce=False,
misfire_grace_time=2)
# Turn the clock 2 seconds forward
FakeDateTime._now += timedelta(seconds=2)
self.scheduler._process_jobs(FakeDateTime.now())
eq_(job.runs, 3)
eq_(len(events), 3)
eq_(events[0].code, EVENT_JOB_EXECUTED)
eq_(events[1].code, EVENT_JOB_EXECUTED)
eq_(events[2].code, EVENT_JOB_EXECUTED)
eq_(vals, [3])
def test_interval(self):
def increment(amount):
vals[0] += amount
vals[1] += 1
vals = [0, 0]
job = self.scheduler.add_interval_job(increment, seconds=1, args=[2])
self.scheduler._process_jobs(job.next_run_time)
self.scheduler._process_jobs(job.next_run_time)
eq_(vals, [4, 2])
def test_interval_schedule(self):
@self.scheduler.interval_schedule(seconds=1)
def increment():
vals[0] += 1
vals = [0]
start = increment.job.next_run_time
self.scheduler._process_jobs(start)
self.scheduler._process_jobs(start + timedelta(seconds=1))
eq_(vals, [2])
def test_cron(self):
def increment(amount):
vals[0] += amount
vals[1] += 1
vals = [0, 0]
job = self.scheduler.add_cron_job(increment, args=[3])
start = job.next_run_time
self.scheduler._process_jobs(start)
eq_(vals, [3, 1])
self.scheduler._process_jobs(start + timedelta(seconds=1))
eq_(vals, [6, 2])
self.scheduler._process_jobs(start + timedelta(seconds=2))
eq_(vals, [9, 3])
def test_cron_schedule_1(self):
@self.scheduler.cron_schedule()
def increment():
vals[0] += 1
vals = [0]
start = increment.job.next_run_time
self.scheduler._process_jobs(start)
self.scheduler._process_jobs(start + timedelta(seconds=1))
eq_(vals[0], 2)
def test_cron_schedule_2(self):
@self.scheduler.cron_schedule(minute='*')
def increment():
vals[0] += 1
vals = [0]
start = increment.job.next_run_time
next_run = start + timedelta(seconds=60)
eq_(increment.job.get_run_times(next_run), [start, next_run])
self.scheduler._process_jobs(start)
self.scheduler._process_jobs(next_run)
eq_(vals[0], 2)
def test_date(self):
def append_val(value):
vals.append(value)
vals = []
date = datetime.now() + timedelta(seconds=1)
self.scheduler.add_date_job(append_val, date, kwargs={'value': 'test'})
self.scheduler._process_jobs(date)
eq_(vals, ['test'])
def test_print_jobs(self):
out = StringIO()
self.scheduler.print_jobs(out)
expected = 'Jobstore default:%s'\
' No scheduled jobs%s' % (os.linesep, os.linesep)
eq_(out.getvalue(), expected)
self.scheduler.add_date_job(copy, datetime(2200, 5, 19))
out = StringIO()
self.scheduler.print_jobs(out)
expected = 'Jobstore default:%s '\
'copy (trigger: date[2200-05-19 00:00:00], '\
'next run at: 2200-05-19 00:00:00)%s' % (os.linesep, os.linesep)
eq_(out.getvalue(), expected)
def test_jobstore(self):
self.scheduler.add_jobstore(RAMJobStore(), 'dummy')
job = self.scheduler.add_date_job(lambda: None,
datetime(2200, 7, 24),
jobstore='dummy')
eq_(self.scheduler.get_jobs(), [job])
self.scheduler.remove_jobstore('dummy')
eq_(self.scheduler.get_jobs(), [])
@raises(KeyError)
def test_remove_nonexistent_jobstore(self):
self.scheduler.remove_jobstore('dummy2')
def test_job_next_run_time(self):
# Tests against bug #5
def increment():
vars[0] += 1
vars = [0]
scheduler.datetime = FakeDateTime
job = self.scheduler.add_interval_job(increment,
seconds=1,
misfire_grace_time=3,
start_date=FakeDateTime.now())
start = job.next_run_time
self.scheduler._process_jobs(start)
eq_(vars, [1])
self.scheduler._process_jobs(start)
eq_(vars, [1])
self.scheduler._process_jobs(start + timedelta(seconds=1))
eq_(vars, [2])
上面通过装饰器定义了cron job，可以通过函数scheduler.add_cron_job添加，用装饰器更方便。Scheduler构造函数中传入daemonic参数，表示执行线程是非守护的，在Schduler的文档中推荐使用非守护线程
在添加job时还有一个比较重要的参数max_instances，指定一个job的并发实例数，默认值是1。默认情况下，如果一个job准备执行，但是该job的前一个实例尚未执行完，则后一个job会失败，可以通过这个参数来改变这种情况。
APScheduler提供了jobstore用于存储job的执行信息，默认使用的是RAMJobStore，还提供了SQLAlchemyJobStore、ShelveJobStore和MongoDBJobStore。APScheduler允许同时使用多个jobstore，通过别名（alias）区分，在添加job时需要指定具体的jobstore的别名，否则使用的是别名是default的jobstore，即RAMJobStore。下面以MongoDBJobStore举例说明。
[python] view plain copy print?
import pymongo
from apscheduler.scheduler import Scheduler
from apscheduler.jobstores.mongodb_store import MongoDBJobStore
import time
sched = Scheduler(daemonic = False)
mongo = pymongo.Connection(host='127.0.0.1', port=27017)
store = MongoDBJobStore(connection=mongo)
sched.add_jobstore(store, 'mongo') # 别名是mongo
@sched.cron_schedule(second='*', day_of_week='0-4', hour='9-12,13-15', jobstore='mongo') # 向别名为mongo的jobstore添加job
def job():
print 'a job'
time.sleep(1)
sched.start()
注意start必须在添加job动作之后调用，否则会抛错。默认会把job信息保存在apscheduler数据库下的jobs表：
[plain] view plain copy print?
> db.jobs.findOne()
{
"_id" : ObjectId("502202d1443c1557fa8b8d66"),
"runs" : 20,
"name" : "job",
"misfire_grace_time" : 1,
class TestJobExecution(object):
def setup(self):
self.scheduler = Scheduler(threadpool=FakeThreadPool())
self.scheduler.add_jobstore(RAMJobStore(), "default")
# Make the scheduler think it's running
self.scheduler._thread = FakeThread()
self.logstream = StringIO()
self.loghandler = StreamHandler(self.logstream)
self.loghandler.setLevel(ERROR)
scheduler.logger.addHandler(self.loghandler)
def teardown(self):
scheduler.logger.removeHandler(self.loghandler)
if scheduler.datetime == FakeDateTime:
scheduler.datetime = datetime
FakeDateTime._now = original_now
def test_job_name(self):
def my_job():
pass
job = self.scheduler.add_interval_job(my_job, start_date=datetime(2010, 5, 19))
eq_(
repr(job),
"<Job (name=my_job, trigger=<IntervalTrigger (interval=datetime.timedelta(0, 1), "
"start_date=datetime.datetime(2010, 5, 19, 0, 0))>)>",
)
def test_schedule_object(self):
# Tests that any callable object is accepted (and not just functions)
class A:
def __init__(self):
self.val = 0
def __call__(self):
self.val += 1
a = A()
job = self.scheduler.add_interval_job(a, seconds=1)
self.scheduler._process_jobs(job.next_run_time)
self.scheduler._process_jobs(job.next_run_time)
eq_(a.val, 2)
def test_schedule_method(self):
# Tests that bound methods can be scheduled (at least with RAMJobStore)
class A:
def __init__(self):
self.val = 0
def method(self):
self.val += 1
a = A()
job = self.scheduler.add_interval_job(a.method, seconds=1)
self.scheduler._process_jobs(job.next_run_time)
self.scheduler._process_jobs(job.next_run_time)
eq_(a.val, 2)
def test_unschedule_job(self):
def increment():
vals[0] += 1
vals = [0]
job = self.scheduler.add_cron_job(increment)
self.scheduler._process_jobs(job.next_run_time)
eq_(vals[0], 1)
self.scheduler.unschedule_job(job)
self.scheduler._process_jobs(job.next_run_time)
eq_(vals[0], 1)
def test_unschedule_func(self):
def increment():
vals[0] += 1
def increment2():
vals[0] += 1
vals = [0]
job1 = self.scheduler.add_cron_job(increment)
job2 = self.scheduler.add_cron_job(increment2)
job3 = self.scheduler.add_cron_job(increment)
eq_(self.scheduler.get_jobs(), [job1, job2, job3])
self.scheduler.unschedule_func(increment)
eq_(self.scheduler.get_jobs(), [job2])
@raises(KeyError)
def test_unschedule_func_notfound(self):
self.scheduler.unschedule_func(copy)
def test_job_finished(self):
def increment():
vals[0] += 1
vals = [0]
job = self.scheduler.add_interval_job(increment, max_runs=1)
self.scheduler._process_jobs(job.next_run_time)
eq_(vals, [1])
assert job not in self.scheduler.get_jobs()
def test_job_exception(self):
def failure():
raise DummyException
job = self.scheduler.add_date_job(failure, datetime(9999, 9, 9))
self.scheduler._process_jobs(job.next_run_time)
assert "DummyException" in self.logstream.getvalue()
def test_misfire_grace_time(self):
self.scheduler.misfire_grace_time = 3
job = self.scheduler.add_interval_job(lambda: None, seconds=1)
eq_(job.misfire_grace_time, 3)
job = self.scheduler.add_interval_job(lambda: None, seconds=1, misfire_grace_time=2)
eq_(job.misfire_grace_time, 2)
def test_coalesce_on(self):
# Makes sure that the job is only executed once when it is scheduled
# to be executed twice in a row
def increment():
vals[0] += 1
vals = [0]
events = []
scheduler.datetime = FakeDateTime
self.scheduler.add_listener(events.append, EVENT_JOB_EXECUTED | EVENT_JOB_MISSED)
job = self.scheduler.add_interval_job(
increment, seconds=1, start_date=FakeDateTime.now(), coalesce=True, misfire_grace_time=2
)
# Turn the clock 14 seconds forward
FakeDateTime._now += timedelta(seconds=2)
self.scheduler._process_jobs(FakeDateTime.now())
eq_(job.runs, 1)
eq_(len(events), 1)
eq_(events[0].code, EVENT_JOB_EXECUTED)
eq_(vals, [1])
def test_coalesce_off(self):
# Makes sure that every scheduled run for the job is executed even
# when they are in the past (but still within misfire_grace_time)
def increment():
vals[0] += 1
vals = [0]
events = []
scheduler.datetime = FakeDateTime
self.scheduler.add_listener(events.append, EVENT_JOB_EXECUTED | EVENT_JOB_MISSED)
job = self.scheduler.add_interval_job(
increment, seconds=1, start_date=FakeDateTime.now(), coalesce=False, misfire_grace_time=2
)
# Turn the clock 2 seconds forward
FakeDateTime._now += timedelta(seconds=2)
self.scheduler._process_jobs(FakeDateTime.now())
eq_(job.runs, 3)
eq_(len(events), 3)
eq_(events[0].code, EVENT_JOB_EXECUTED)
eq_(events[1].code, EVENT_JOB_EXECUTED)
eq_(events[2].code, EVENT_JOB_EXECUTED)
eq_(vals, [3])
def test_interval(self):
def increment(amount):
vals[0] += amount
vals[1] += 1
vals = [0, 0]
job = self.scheduler.add_interval_job(increment, seconds=1, args=[2])
self.scheduler._process_jobs(job.next_run_time)
self.scheduler._process_jobs(job.next_run_time)
eq_(vals, [4, 2])
def test_interval_schedule(self):
@self.scheduler.interval_schedule(seconds=1)
def increment():
vals[0] += 1
vals = [0]
start = increment.job.next_run_time
self.scheduler._process_jobs(start)
self.scheduler._process_jobs(start + timedelta(seconds=1))
eq_(vals, [2])
def test_cron(self):
def increment(amount):
vals[0] += amount
vals[1] += 1
vals = [0, 0]
job = self.scheduler.add_cron_job(increment, args=[3])
start = job.next_run_time
self.scheduler._process_jobs(start)
eq_(vals, [3, 1])
self.scheduler._process_jobs(start + timedelta(seconds=1))
eq_(vals, [6, 2])
self.scheduler._process_jobs(start + timedelta(seconds=2))
eq_(vals, [9, 3])
def test_cron_schedule_1(self):
@self.scheduler.cron_schedule()
def increment():
vals[0] += 1
vals = [0]
start = increment.job.next_run_time
self.scheduler._process_jobs(start)
self.scheduler._process_jobs(start + timedelta(seconds=1))
eq_(vals[0], 2)
def test_cron_schedule_2(self):
@self.scheduler.cron_schedule(minute="*")
def increment():
vals[0] += 1
vals = [0]
start = increment.job.next_run_time
next_run = start + timedelta(seconds=60)
eq_(increment.job.get_run_times(next_run), [start, next_run])
self.scheduler._process_jobs(start)
self.scheduler._process_jobs(next_run)
eq_(vals[0], 2)
def test_date(self):
def append_val(value):
vals.append(value)
vals = []
date = datetime.now() + timedelta(seconds=1)
self.scheduler.add_date_job(append_val, date, kwargs={"value": "test"})
self.scheduler._process_jobs(date)
eq_(vals, ["test"])
def test_print_jobs(self):
out = StringIO()
self.scheduler.print_jobs(out)
expected = "Jobstore default:%s" " No scheduled jobs%s" % (os.linesep, os.linesep)
eq_(out.getvalue(), expected)
self.scheduler.add_date_job(copy, datetime(2200, 5, 19))
out = StringIO()
self.scheduler.print_jobs(out)
expected = (
"Jobstore default:%s "
"copy (trigger: date[2200-05-19 00:00:00], "
"next run at: 2200-05-19 00:00:00)%s" % (os.linesep, os.linesep)
)
eq_(out.getvalue(), expected)
def test_jobstore(self):
self.scheduler.add_jobstore(RAMJobStore(), "dummy")
job = self.scheduler.add_date_job(lambda: None, datetime(2200, 7, 24), jobstore="dummy")
eq_(self.scheduler.get_jobs(), [job])
self.scheduler.remove_jobstore("dummy")
eq_(self.scheduler.get_jobs(), [])
@raises(KeyError)
def test_remove_nonexistent_jobstore(self):
self.scheduler.remove_jobstore("dummy2")
def test_job_next_run_time(self):
# Tests against bug #5
def increment():
vars[0] += 1
vars = [0]
scheduler.datetime = FakeDateTime
job = self.scheduler.add_interval_job(increment, seconds=1, misfire_grace_time=3, start_date=FakeDateTime.now())
start = job.next_run_time
self.scheduler._process_jobs(start)
eq_(vars, [1])
self.scheduler._process_jobs(start)
eq_(vars, [1])
self.scheduler._process_jobs(start + timedelta(seconds=1))
eq_(vars, [2])
class TestOfflineScheduler(object):
def setup(self):
self.scheduler = Scheduler()
def teardown(self):
if self.scheduler.running:
self.scheduler.shutdown()
@raises(KeyError)
def test_jobstore_twice(self):
self.scheduler.add_jobstore(RAMJobStore(), "dummy")
self.scheduler.add_jobstore(RAMJobStore(), "dummy")
def test_add_tentative_job(self):
job = self.scheduler.add_date_job(lambda: None, datetime(2200, 7, 24), jobstore="dummy")
assert isinstance(job, Job)
eq_(self.scheduler.get_jobs(), [])
def test_add_job_by_reference(self):
job = self.scheduler.add_date_job("copy:copy", datetime(2200, 7, 24))
eq_(job.func, copy)
eq_(job.func_ref, "copy:copy")
def test_configure_jobstore(self):
conf = {"apscheduler.jobstore.ramstore.class": "apscheduler.jobstores.ram_store:RAMJobStore"}
self.scheduler.configure(conf)
self.scheduler.remove_jobstore("ramstore")
def test_shutdown_offline(self):
self.scheduler.shutdown()
def test_configure_no_prefix(self):
global_options = {"misfire_grace_time": "2", "daemonic": "false"}
self.scheduler.configure(global_options)
eq_(self.scheduler.misfire_grace_time, 1)
eq_(self.scheduler.daemonic, True)
def test_configure_prefix(self):
global_options = {"apscheduler.misfire_grace_time": 2, "apscheduler.daemonic": False}
self.scheduler.configure(global_options)
eq_(self.scheduler.misfire_grace_time, 2)
eq_(self.scheduler.daemonic, False)
def test_add_listener(self):
val = []
self.scheduler.add_listener(val.append)
event = SchedulerEvent(EVENT_SCHEDULER_START)
self.scheduler._notify_listeners(event)
eq_(len(val), 1)
eq_(val[0], event)
event = SchedulerEvent(EVENT_SCHEDULER_SHUTDOWN)
self.scheduler._notify_listeners(event)
eq_(len(val), 2)
eq_(val[1], event)
self.scheduler.remove_listener(val.append)
self.scheduler._notify_listeners(event)
eq_(len(val), 2)
def test_pending_jobs(self):
# Tests that pending jobs are properly added to the jobs list when
# the scheduler is started (and not before!)
self.scheduler.add_date_job(lambda: None, datetime(9999, 9, 9))
eq_(self.scheduler.get_jobs(), [])
self.scheduler.start()
jobs = self.scheduler.get_jobs()
eq_(len(jobs), 1)
from boto.provider import Provider
from apscheduler.scheduler import Scheduler
from apscheduler.jobstores.shelve_store import ShelveJobStore
from shove import Shove
import logging
SHOVE_BUCKET = 'my-bucket'
class ShoveJobStore(ShelveJobStore):
def __init__(self, path):
self.jobs = []
self.path = path
self.store = Shove(path, optimize=False)
class S3JobStore(ShoveJobStore):
def __init__(self, access_key, secret_key, bucket, prefix='job_'):
self.prefix = prefix if prefix[-1] == '/' else (prefix + '/')
path = 's3://{}:{}@{}'.format(access_key, secret_key, bucket)
super(S3JobStore, self).__init__(path)
logging.basicConfig()
PROVIDER = Provider('aws')
JOB_STORE = S3JobStore(PROVIDER.get_access_key(), PROVIDER.get_secret_key(),
SHOVE_BUCKET)
SCHEDULER = Scheduler(misfire_grace_time=1000)
SCHEDULER.add_jobstore(JOB_STORE, 's3')
webackup = Flask('modules',
static_folder="static",
template_folder='templates')
webackup.config.from_object(__name__)
Bootstrap(webackup)
# instantiate the db wrapper
db = Database(webackup)
# instatiate the login
login_manager = LoginManager()
login_manager.setup_app(webackup)
# initiate scheduler
sched = Scheduler()
sched.add_jobstore(ShelveJobStore('data/scheduler.db'), 'default')
sched.start()
""" Registering the blueprint controller """
dirs = os.listdir(APP_DIR)
for module in dirs:
""" Blueprints """
try:
if module.startswith('__'): continue
webackup.register_blueprint(
import_string(APP_DIR + '.' + module + '.controller.register'))
except ImportError, e:
pass
dirs = os.listdir(APP_DIR + '/source')
for module in dirs:
""" Blueprints """
