def _start_schedule(self, id, schedule, period):
# check if the schedule is disabled or not
if period["secs"] != 0:
if not self._scheduled_tasks.has_key(id):
self._scheduled_tasks[id] = []
val_type = self._resolve_type(schedule)
for p in self._agg_periods:
cron = CronSchedule(self._agg_periods[p])
if p == "day":
t = ScheduledCall(self._aggregate_day, id, val_type)
t.start(cron)
self._scheduled_tasks[id].append(t)
elif p == "month":
t = ScheduledCall(self._aggregate_month, id)
t.start(cron)
self._scheduled_tasks[id].append(t)
elif p == "year":
t = ScheduledCall(self._aggregate_year, id)
t.start(cron)
self._scheduled_tasks[id].append(t)
else:
self.log.warning("Unsupported period (%s)" % p)
self.log.debug("Scheduled tasks: %s" % self._scheduled_tasks)
def _init(cls,tid,initcode=True):
try:
tid=int(tid)
result=yield run_conn_fun("runQuery","select ip,svnpath,svnuser,svnpasswd,version,rule from cron_task WHERE tid=%s",(tid,))
ip,svnpath,svnuser,svnpasswd,svnversion,rule=result[0]
if initcode==True:
_defer =SubRpc().xmlrpc_init(int(tid),svnpath,int(svnversion),svnuser,svnpasswd)
set_time_out(2,_defer)
try:
yield _defer
except defer.CancelledError :
pass
else:
pass
if not cls.BUFF.has_key(tid):
pass
else:
if cls.BUFF[tid].running:
cls.BUFF[tid].stop()
schedule=CronSchedule(rule)
sc=ScheduledCall(cls._run,tid)
sc.start(schedule)
cls.BUFF[tid]=sc
defer.returnValue(True)
except Exception as e:
defer.returnValue((False,str(e)))
def xmlrpc_cron_set(self, key, cron_mode, picked_function, picked_callback,
picked_errback, stdout_callback, stderr_callback):
print "cron server _ cron set"
try:
self.xmlrpc_cron_del(key)
if self.valid_cronrule(cron_mode):
pass
else:
raise Exception("cron时间规则不符合要求")
try:
target = cloudpickle.loads(picked_function.data)
except:
traceback.print_exc()
raise Exception("目标函数picked反序列化失败!")
try:
callback = cloudpickle.loads(picked_callback.data)
except:
raise Exception("success回调函数picked反序列化失败!")
try:
errback = cloudpickle.loads(picked_errback.data)
except:
raise Exception("error回调函数picked反序列化失败!")
if stdout_callback:
try:
stdout_callback = cloudpickle.loads(stdout_callback.data)
except:
raise Exception("stdout回调函数picked反序列化失败!")
else:
stdout_callback = None
if stderr_callback:
try:
stderr_callback = cloudpickle.loads(stderr_callback.data)
except:
raise Exception("stderr回调函数picked反序列化失败!")
else:
stderr_callback = None
cron = CronSchedule(cron_mode)
_process = Process(target, [], {}, callback, errback,
stdout_callback, stderr_callback)
_task = ScheduledCall(_process.restart)
_task.start(cron)
CRON_BUFF[key] = (_task, _process)
except Exception as e:
traceback.print_exc()
return False, str(e)
else:
return True
def _load_triggers(self):
'''
This function loads all the triggers from the database.
'''
# Stop any outstanding absolute time triggers in case of a reload.
for schedule in self._absolute_time_schedule_calls:
schedule.stop()
self._absolute_time_schedule_calls = []
triggers = yield self.db.query_triggers()
for trigger in triggers:
t = Trigger(trigger[1], trigger[2], trigger[3])
# get trigger parameters
trigger_parameters = yield self.db.query_trigger_parameters(
trigger[0])
for param in trigger_parameters:
if param[0] == "cron":
t.cron = param[1]
elif param[0] == "current_value_id":
t.current_value_id = param[1]
elif param[0] == "condition":
t.condition = param[1]
elif param[0] == "condition_value":
t.condition_value = param[1]
# Handle absolute time directly, and schedule. No need to keep track of this.
if trigger[1] == "Absolute time":
c = CronSchedule(t.cron)
print c.getNextEntry()
s = ScheduledCall(f=self._absolute_time_triggered,
eventid=trigger[2],
conditions=trigger[3])
s.start(c)
self._absolute_time_schedule_calls.append(s)
continue
self._triggers.append(t)
def setUp(self):
super(SimpleTests, self).setUp()
self.sc = ScheduledCall(f=lambda: None)
