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()
'''
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])
class DataLogger:
"""
In this class the different systems are initialiased:
- logger and its handlers
- local configuration
- connection with internet
If there is no connection with the internet:
- A timed job is created that controls internet connection.
- Logging of data is started with local configuration.
- If the internet connection is started, and the online\
configuration differs, the old wrongly logged data will be removed.
If there is connection with the internet and the server is working:
- Check if the online configuration differs from the local one. If so,\
the configuration will be updated.
- Logging of data is started.
- Sending of data is started.
- A timed job is created that checks if the online configuration is\
updated
- The management of leds is started.
"""
def __init__(self):
try:
# initiate logger
self.logger = logging.getLogger()
self.logger.setLevel(logging.DEBUG)
self.log_send_store_handler = LogSendStoreHandler(LOG_LOCATION)
formatter = logging.Formatter(
'%(asctime)s - %(levelname)s - %(name)s - %(message)s')
self.log_send_store_handler.setFormatter(formatter)
self.logger.addHandler(self.log_send_store_handler)
self.logger.info('Initialising system...')
job_info_filter = JobInfoFilter()
logging.getLogger('apscheduler.scheduler').addFilter(
job_info_filter)
logging.getLogger('apscheduler.threadpool').addFilter(
job_info_filter)
# load local configuration
self.conf_man = ConfigurationManager(CONFIG_LOCATION)
self.log_send_store_handler.update_configuration()
self.scheduler = Scheduler()
self.scheduler.start()
self.packet_manager = PacketManager(self.scheduler)
# initiate network connection
self.connection = ConnectionManager()
# add scheduler and connection to log handler
self.log_send_store_handler.update_configuration(
scheduler=self.scheduler,
connection=self.connection)
# try to connect
connected_to_internet = self.connection.check_internet_connection()
connected_to_server = self.connection.check_server_connection()
if connected_to_internet and connected_to_server:
self.load_online_configuration_and_initiate_sending_data()
self.packet_manager.update_time()
self.packet_manager.initiate_send_packets(self.connection)
else:
'''
if there is no connection:
keep checking for a connection
temporarily use offline timer and modbus slave
configuration
'''
if connected_to_internet:
self.packet_manager.update_time()
self.wait_for_connection_to_load_configuration()
# initiate sensor timers
self.read_sensor_scheduler = ReadSensorScheduler(
self.scheduler,
self.packet_manager)
self.led_manager = LedManager(self.scheduler)
self.led_manager.update_led(PinName.powered, LedState.on)
self.set_up_led_manager_calls()
# sleep 2 seconds to intialise led of log handler
sleep(1)
self.logger.info('Initialisation complete')
while True:
sleep(10)
self.logger.debug('Alive and kicking')
if self.logger.level is logging.DEBUG:
scheduler_jobs = self.scheduler.get_jobs()
if len(scheduler_jobs) > 1:
self.logger.debug('Current scheduler jobs:')
for index, job in enumerate(scheduler_jobs):
self.logger.debug(' Job {0}: {1} {2}'.format(
index,
job.name,
job.next_run_time))
else:
self.logger.debug('No running scheduler jobs')
except Exception as e:
self.logger.error(e)
raise
self.log_send_store_handler.send_logs_job()
def load_online_configuration_and_initiate_sending_data(self):
# check online configuration
try:
online_checksum = self.connection.get_configuration_checksum()
self.logger.info("Checking online configuration..")
if self.conf_man.is_online_configuration_different(online_checksum):
self.logger.info(
'Online configuration is new, updating configuration..')
online_configuration = self.connection.get_configuration()
self.conf_man.validate_json_configuration(online_configuration)
self.conf_man.save_configuration_local(
online_checksum,
online_configuration)
self.packet_manager.remove_all_packets_from_memory()
# update systems that make use of the configuration
self.log_send_store_handler.update_configuration(
scheduler=self.scheduler,
connection=self.connection)
self.connection.update_configuration()
try:
self.read_sensor_scheduler.update_configuration()
except:
pass
self.packet_manager.update_configuration()
except:
self.logger.warning('Problem updating configuration')
raise
try: # try to remove job
self.scheduler.unschedule_func(
self.load_online_configuration_and_initiate_sending_data)
except:
pass
# periodically check changes in configuration
self.scheduler.add_interval_job(
self.load_online_configuration_and_initiate_sending_data,
seconds=configuration.get_time_interval_to_check_online_config())
self.packet_manager.initiate_send_packets(self.connection)
def wait_for_connection_to_load_configuration(self):
if not self.connection.is_connected():
# no internet connection, start job to check connection
self.scheduler.add_interval_job(self.try_to_connect_to_internet,
seconds=CHECK_CONNECTION_INTERVAL)
else:
self.packet_manager.update_time()
if not self.connection.check_server_connection():
# no connection with server, start job to check connection
self.scheduler.add_interval_job(
self.try_to_load_online_configuration,
seconds=CHECK_CONNECTION_INTERVAL)
def try_to_connect_to_internet(self):
if self.connection.check_internet_connection():
self.scheduler.unschedule_func(self.try_to_connect_to_internet)
self.packet_manager.update_time()
if not self.connection.check_server_connection():
# no connection with server, start job to check connection
self.scheduler.add_interval_job(
self.try_to_load_online_configuration,
seconds=CHECK_CONNECTION_INTERVAL)
else:
self.load_online_configuration_and_initiate_sending_data()
def try_to_load_online_configuration(self):
if self.connection.check_server_connection():
self.load_online_configuration_and_initiate_sending_data()
self.scheduler.unschedule_func(
self.try_to_load_online_configuration)
def set_up_led_manager_calls(self):
sensor_led_call = LedCall(self.led_manager, PinName.readingsensor)
connected_led_call = LedCall(self.led_manager, PinName.connected)
logging_led_call = LedCall(self.led_manager, PinName.logging)
self.read_sensor_scheduler.set_led_call(sensor_led_call)
self.connection.set_led_call(connected_led_call)
self.log_send_store_handler.set_led_call(logging_led_call)
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 SchedulerContainer( DaemonContainer ):
def __init__(self, environment):
super(Scheduler, self).__init__(environment)
gconfig = environment.get("gconfig", {})
options = environment.get("options", {})
self.scheduler = Scheduler(gconfig, **options)
def on_start(self):
self.scheduler.start()
def on_stop(self):
self.scheduler.stop()
def unschedule_func(self, func):
self.scheduler.unschedule_func(func)
def unschedule_job(self, job):
self.scheduler.unschedule_job(job)
def add_interval_job(self, func, weeks=0, days=0, hours=0, minutes=0, seconds=0, start_date=None, args=None, kwargs=None, **options):
return self.scheduler.add_interval_job(func=func,
weeks=weeks,
days=days,
hours=hours,
minutes=minutes,
seconds=seconds,
start_date=start_date,
args=args,
kwargs=kwargs,
**options)
def add_cron_job(self, func, year=None, month=None, day=None, week=None, day_of_week=None, hour=None, minute=None, second=None, start_date=None, args=None, kwargs=None, **options):
return self.scheduler.add_cron_job(func=func,
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,
**options)
def add_date_job(self, func, date, args=None, kwargs=None, **options):
return self.scheduler.add_date_job(func=func,
date=date,
args=args,
kwargs=kwargs,
**options)
def get_jobs(self):
return self.scheduler.get_jobs()
def add_job(self, trigger, func, args, kwargs, jobstore='default', **options):
return self.scheduler.add_job(trigger=trigger,
func=func,
args=args,
kwargs=kwargs,
jobstore=jobstore,
**options)
def add_listener(self, callback, mask):
self.scheduler.add_listener(callback, mask)
def remove_listener(self, callback):
self.scheduler.remove_listener(callback)
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()
'''
