def run_cron_cleanup(settings):
'''
Read cron scheduling entries and schedule
'''
cron_time = {}
year = settings.get("extract.cleanup.schedule.cron.year")
month = settings.get("extract.cleanup.schedule.cron.month")
day = settings.get("extract.cleanup.schedule.cron.day")
week = settings.get("extract.cleanup.schedule.cron.week")
day_of_week = settings.get("extract.cleanup.schedule.cron.day_of_week")
hour = settings.get("extract.cleanup.schedule.cron.hour")
minute = settings.get("extract.cleanup.schedule.cron.minute")
second = settings.get("extract.cleanup.schedule.cron.second")
if year is not None:
cron_time['year'] = year
if month is not None:
cron_time['month'] = month
if day is not None:
cron_time['day'] = day
if week is not None:
cron_time['week'] = week
if day_of_week is not None:
cron_time['day_of_week'] = day_of_week
if hour is not None:
cron_time['hour'] = hour
if minute is not None:
cron_time['minute'] = minute
if second is not None:
cron_time['second'] = second
if len(cron_time) > 0:
sched = Scheduler()
sched.start()
sched.add_cron_job(delete_stats, **cron_time)
def pre_eva_start(self, conf):
# Load all jobs
self.invoke('pre_scheduler_load_jobs')
sched = APScheduler()
conf['scheduler']['scheduler'] = sched
for job_name in conf['scheduler']['jobs']:
job = conf['scheduler']['jobs'][job_name]
if job.get('type') == 'date':
# datetime is a datetime string in this case
# ie: '2012-11-06 14:25:10.8880'
sched.add_date_job(job['func'], job['datetime'], args=[conf])
elif job.get('type') == 'interval':
sched.add_interval_job(job['func'],
seconds=job['interval'].get('seconds', 0),
minutes=job['interval'].get('minutes', 0),
hours=job['interval'].get('hours', 0),
days=job['interval'].get('days', 0),
weeks=job['interval'].get('weeks', 0),
start_date=job['interval'].get('start_date'),
args=[conf])
elif job.get('type') == 'cron':
sched.add_cron_job(job['func'],
second=job['interval'].get('second'),
minute=job['interval'].get('minute'),
hour=job['interval'].get('hour'),
day=job['interval'].get('day'),
week=job['interval'].get('week'),
month=job['interval'].get('month'),
year=job['interval'].get('year'),
day_of_week=job['interval'].get('day_of_week'),
args=[conf])
sched.start()
self.invoke('post_scheduler_load_jobs')
def callback(): # Start the scheduler sched = Scheduler() sched.start() alarmMonth = userentermonth.get() print len(alarmMonth) #DEBUG print alarmMonth #DEBUG alarmDay = userenterday.get() print len(alarmDay) #DEBUG print alarmDay #DEBUG alarmYear = userenteryear.get() print len(alarmYear) #DEBUG print alarmYear #DEBUG alarmHour = userenterhour.get() print len(alarmHour) #DEBUG print alarmHour #DEBUG alarmMinute = userenterminute.get() print len(alarmMinute) #DEBUG print alarmMinute #DEBUG # alarmMonth = 5 # alarmDay = 1 # alarmHour = 5 # alarmMinute = 30 # add values in here to set lighting variables so that they remain static # Schedules job_function for specific date and time sched.add_cron_job(AlarmOn, year=alarmYear, month=alarmMonth, day=alarmDay, hour=alarmHour, minute=alarmMinute) lbl.configure(text="Alarm Set!")
def handle(self, *args, **options):
sched = Scheduler()
sched.start()
from twilio.rest import TwilioRestClient
account_sid = "AC6fe90756ae4096c5bf790984038a3f32"
auth_token = "97e8833ee3553bc4d9d16e86f1865d32"
client = TwilioRestClient(account_sid, auth_token)
for user in user_list:
user_schedule = Schedule.objects.all().filter(user=user)
for schedule in user_schedule:
day_of_week = schedule.day_of_week
hour = schedule.hour
minute = schedule.minute
user_message = schedule.message
print 'BEFORE:' + str(user_message)
def timed_job(msg):
print 'AFTER' + str(msg)
sched.add_cron_job(lambda: timed_job(user_message), second='0-60')
#sched.start()
print 'test'
while True:
pass
class Wikipedia(Plugin):
def __init__(self, skype):
super(Wikipedia, self).__init__(skype)
self.daily_channels = ["#stigrk85/$jvlomax;b43a0c90a2592b9b"]
self.sched = Scheduler()
self.sched.start()
self.command = "wikipedia"
self.sched.add_cron_job(self.dailyWikipedia, hour=18, minute=0, day_of_week="mon-sun")
def message_received(self, args, status, msg):
if (len(args) == 1 and args[0] == "random") or not args:
url = self.fetch_randWiki()
msg.Chat.SendMessage(url)
else:
try:
page = wiki.wikipedia.page(" ".join(args))
if page.url:
msg.Chat.SendMessage(urllib.unquote(page.url))
else:
msg.Chat.SendMessage("Could not find any results for {}".format(" ".join(args)))
except wiki.exceptions.DisambiguationError:
msg.Chat.SendMessage("Your search is disambiguous")
except wiki.exceptions.PageError:
msg.Chat.SendMessage("Could not find any results for {}".format(" ".join(args)))
def fetch_randWiki(self):
r = requests.get("http://en.wikipedia.org/wiki/Special:Random")
return r.url
def dailyWikipedia(self):
for channel in self.daily_channels:
chat = self.skype.Chat(channel)
chat.SendMessage("Dagens random wikipedia: " + self.fetch_randWiki())
def main(config_file):
info = load_config(config_file)
day_of_week = info['days']
hour = info['hour']
minute = info['minute']
config = {
'apscheduler.jobstores.file.class': info['scheduler-config']['class'],
'apscheduler.jobstores.file.path': info['scheduler-config']['path']
}
sched = Scheduler(config)
sched.add_cron_job(run_scraper,
day_of_week=day_of_week,
hour=hour,
minute=minute)
sched.add_cron_job(check_archive, day='first')
sched.start()
print('Press Ctrl+{0} to exit'.format('C'))
try:
# This is here to simulate application activity (which keeps the main thread alive).
while True:
time.sleep(2)
except (KeyboardInterrupt, SystemExit):
sched.shutdown(
) # Not strictly necessary if daemonic mode is enabled but should be done if possibleisched.start()
class SimpleScheduler:
def __init__(self):
self._sched = Scheduler()
self._sched.start()
self._jobs = {}
def schedule(self, job):
if job.name in self._jobs:
logger.warn("Already have job with name: %s" % job.name)
return False
try:
self._sched.add_cron_job(job._execute_and_store, **job.schedule)
except TypeError:
logger.error("Invalid schedule for job with name: %s" % job.name +
" schedule: %s" % job.schedule)
self._jobs[job.name] = job
return True
def schedules(self):
return {job.name: job.schedule for job in self._jobs.values()}
def execute(self, name):
return self._sched.add_date_job(self._jobs[name]._execute_and_store,
datetime.now() + timedelta(seconds=1))
def load(self):
sched = Scheduler()
sched.daemonic = False
# Schedules job_function to be run on the third Friday
# of June, July, August, November and December at 00:00, 01:00, 02:00 and 03:00
sched.add_cron_job(self.job_function, second='*/3')
sched.start()
class Ddate():
''' Scheduling class to post ddate each morning. '''
def __init__(self, connection, target):
''' Set irc details, initialise scheduler, set daily task,
and grab the current date. '''
self.con = connection
self.target = target
self.sched = Scheduler()
self.sched.start()
self.fetch_ddate()
# scheduler for 0915 (server is gmt+1)
self.sched.add_cron_job(self.change_ddate, hour=10, minute=15)
def change_ddate(self):
''' update ddate and announce to channel. '''
self.fetch_ddate()
self.post_ddate()
def fetch_ddate(self):
''' fetch ddate from shell.'''
date = check_output(['ddate'])
# trim `today is ` and `\n`
self.ddate = date[9:-2]
def post_ddate(self):
''' post date to connection/channel supplied on startup. '''
self.con.send_msg(self.target, self.ddate)
def __del__(self):
''' Kill scheduler on close. '''
self.sched.shutdown()
def main(standalone=True):
env.configure("conf.ini")
'''
transfer History Detail for the first time
when program is executed
'''
if env.config.get("transfer_hist_detail_on_loading") and env.config.get("transfer_hist_detail_on_loading") == "1":
transferHistDetails(env.config.get("DB_FILE"), env.config.get("STOREID"),
env.config.get("FTP_HOME"), env.config.get("FTP_HOST"),
env.config.get("FTP_PORT"), env.config.get("FTP_USERNAME"),
env.config.get("FTP_PASSWORD"))
'''
create the scheduler for two job:
1. check the client's alive
2. transfer details to server
'''
scheduler = Scheduler(standalone=standalone)
scheduler.add_interval_job(sync,
minutes=int(env.config.get("sync_interval")),
args=(env.config.get("DB_FILE"), env.config.get("STOREID"),
env.config.get("PROGNAME"), env.config.get("PROG"),
env.config.get("FTP_HOME"), env.config.get("FTP_HOST"),env.config.get("FTP_PORT"),
env.config.get("FTP_USERNAME"),env.config.get("FTP_PASSWORD")))
scheduler.add_cron_job(transferFluxDetailsByStatus,
day_of_week=env.config.get("upload_day_of_week"), hour=env.config.get("upload_hour"), minute=env.config.get("upload_minute"),
args=(env.config.get("DB_FILE"), env.config.get("STOREID"),
env.config.get("FTP_HOME"), env.config.get("FTP_HOST"),env.config.get("FTP_PORT"),
env.config.get("FTP_USERNAME"),env.config.get("FTP_PASSWORD"),
0))
scheduler.start()
def main(config_file):
info = load_config(config_file)
day_of_week = info['days']
hour = info['hour']
minute = info['minute']
config = {
'apscheduler.jobstores.file.class': info['scheduler-config']['class'],
'apscheduler.jobstores.file.path': info['scheduler-config']['path']
}
sched = Scheduler(config)
sched.add_cron_job(run_scraper, day_of_week=day_of_week, hour=hour, minute=minute)
sched.add_cron_job(check_archive, day='first')
sched.start()
print('Press Ctrl+{0} to exit'.format('C'))
try:
# This is here to simulate application activity (which keeps the main thread alive).
while True:
time.sleep(2)
except (KeyboardInterrupt, SystemExit):
sched.shutdown() # Not strictly necessary if daemonic mode is enabled but should be done if possibleisched.start()
class FreshPots(BotPlugin):
pots = [
'http://i.imgur.com/Q2b54vc.jpg',
'http://i.imgur.com/SYsdsew.jpg',
'http://i.imgur.com/caIbQMh.png',
'http://i.imgur.com/MCwiikl.jpg',
'http://i.imgur.com/g4sFHwz.jpg',
'http://i.imgur.com/vnuJQ4S.gif',
'http://i.imgur.com/cm3Y6jX.jpg',
'http://i.imgur.com/ZcKZTFU.jpg',
'http://i.imgur.com/4mEaNIp.jpg',
'http://i.imgur.com/gDukRFu.png',
'http://i.imgur.com/1MDO9fV.png',
'http://i.imgur.com/U5cFX3M.jpg'
]
def activate(self):
super(FreshPots, self).activate()
self.sched = Scheduler(coalesce=True)
self.sched.start()
self.sched.add_cron_job(
self.fresh_pots,
kwargs={'message': 'fresh pots time'},
day_of_week='mon-fri',
hour=11)
self.sched.add_cron_job(
self.fresh_pots,
kwargs={'message': 'fresh pots time'},
day_of_week='mon-fri',
hour=15)
logging.info(self.sched.get_jobs())
def callback_message(self, conn, mess):
body = mess.getBody().lower()
if body.find('coffee') != -1 or body.find('fresh pots') != -1:
self.fresh_pots(mess.getFrom())
def fresh_pots(self, channel='#cloudant-bristol', message=None):
if message:
self.send(
channel,
message,
message_type='groupchat'
)
self.send(
channel,
choice(self.pots),
message_type='groupchat'
)
self.check()
def check(self):
for job in self.sched:
delta = job.next_run_time - datetime.now()
hour_delta = timedelta(seconds=3600)
if delta < hour_delta:
job.compute_next_run_time(datetime.now() + hour_delta)
def daemon():
worker_minutes = cfg.get("job.switch_cfg_persistence", "run_on_minutes")
logger.info("Starting persistence-control daemon...")
logger.info("The persistence-control worker will run on minutes '%s'..." % worker_minutes)
sched = Scheduler()
sched.add_cron_job(worker, minute=worker_minutes)
sched.start()
signal.pause()
def tasks(hour):
"""run tasks, keep it running for crawler"""
sched = Scheduler(standalone=True)
# http://pythonhosted.org/APScheduler/modules/scheduler.html
sched.add_cron_job(douban_spider_task, hour=int(hour))
sched.start()
info = 'start tasks at' + datetime.datetime.now().strftime('%y-%m-%d %H:%M:%S')
spider_task_log.log_info(info)
class Main(Daemon):
"""
do some things
"""
def __init__(self, pidfile, cfgfile):
Daemon.__init__(self, pidfile)
self.jobs = {}
self.immediately = False
self.scheduler = Scheduler(daemonic=False)
self.logger = logging.getLogger(self.__class__.__name__)
if os.path.exists(cfgfile):
with open(cfgfile, 'rt') as f:
config = yaml.load(f.read())
for k1 in config.keys():
if k1 == 'version':
pass
if k1 == 'immediately':
self.immediately = config[k1]
elif k1 == 'taobao':
self.jobs[k1] = config[k1]
self.jobs[k1]['id'] = None
if 'chktime' in self.jobs[k1].keys():
self.jobs[k1]['btime'] = time.strptime(self.jobs[k1]['chktime'].split('-')[0], '%H:%M')
self.jobs[k1]['etime'] = time.strptime(self.jobs[k1]['chktime'].split('-')[1], '%H:%M')
if self.jobs[k1]['btime'] >= self.jobs[k1]['etime']:
raise ValueError('"chktime" is illegal')
else:
raise ValueError('There is no "chktime" be found in configure.')
else:
pass
else:
self.logger.error('{0} not found'.format(cfgfile))
def job_main(self):
st_beg = self.jobs['taobao']['btime']
st_end = self.jobs['taobao']['etime']
dt_beg = datetime.now().replace(hour=st_beg.tm_hour, minute=st_beg.tm_min)
dt_end = datetime.now().replace(hour=st_end.tm_hour, minute=st_end.tm_min)
td_rnd = dt_end - dt_beg
dt_rnd = dt_beg + timedelta(seconds=randint(1, td_rnd.days * 86400 + td_rnd.seconds - 1))
if dt_rnd <= datetime.now():
dt_rnd += timedelta(days=1)
self.jobs['taobao']['id'] = self.scheduler.add_date_job(lambda: self.job_taobao(), dt_rnd)
def job_taobao(self):
for v in self.jobs['taobao']['account']:
taobao = Taobao(v['username'], v['password'])
if taobao.login():
taobao.checkin()
def run(self):
if self.immediately:
self.job_taobao()
self.immediately = False
self.scheduler.add_cron_job(lambda: self.job_main(), hour='0', minute='1')
self.scheduler.start()
stopevent.wait()
self.scheduler.shutdown()
def handle(self, *args, **options): sched = Scheduler(daemonic=True) sched.add_cron_job(job_function, minute='*') sched.configure() try: sched.start() except (KeyboardInterrupt, SystemExit): pass print sched.print_jobs()
def main():
fpid = os.fork()
if fpid != 0:
# Running as daemon now. PID is fpid
sys.exit(0)
sched = Scheduler()
sched.add_cron_job(report, minute='*/10')
sched.start()
signal.pause()
def daemon():
worker_minutes = cfg.get("job.switch_cfg_persistence", "run_on_minutes")
logger.info("Starting persistence-control daemon...")
logger.info("The persistence-control worker will run on minutes '%s'..." %
worker_minutes)
sched = Scheduler()
sched.add_cron_job(worker, minute=worker_minutes)
sched.start()
signal.pause()
def start_schedules(config):
sched = Scheduler()
config.scheduler = sched
sched.start()
for repo in config.repositories:
for branch in repo.branches:
if branch.schedule:
sched.add_cron_job(tester(config, repo, branch),
**branch.schedule)
def start_schedules(config) :
sched = Scheduler()
config.scheduler = sched
sched.start()
for repo in config.repositories :
for branch in repo.branches :
if branch.schedule :
sched.add_cron_job(tester(config,repo,branch),
**branch.schedule)
class EventStream(object):
def __init__(self):
self.clients = {}
self.next_id = 1
self.functions = []
self._scheduler = Scheduler()
self._scheduler.start()
def register(self, func, **kwargs):
self.functions.append(func)
self._scheduler.add_cron_job(func, **kwargs)
def post(self, widget_id, client_id=None, **kwargs):
# Create message
message = kwargs
message.update({
'id': widget_id,
'updatedAt': int(time.time() + 300)
})
# Queue for clients to send
clients = self.clients.items()
if client_id:
clients = [(client_id, self.clients[client_id])]
for cid, client in clients:
client['messages'][client['next_mid']] = message
client['next_mid'] += 1
Logr.debug("Message posted, queued to be sent to %s clients" % len(self.clients))
def read(self):
client_id = self.next_id
self.next_id += 1
self.clients[client_id] = {
'next_mid': 1,
'messages': {}
}
for func in self.functions:
func(client_id=client_id)
while client_id in self.clients:
sent = []
for mid, message in self.clients[client_id]['messages'].items():
Logr.debug("Sent message: %s" % message)
yield "data: %s\n\n" % json.dumps(message)
sent.append(mid)
# Remove sent messages
for mid in sent:
self.clients[client_id]['messages'].pop(mid)
time.sleep(5)
class Controller():
def __init__(self):
self.configList = []
self.scheduler = Scheduler()
self.scheduler.start()
self.uploadConfigList()
self.mqttClient = mqtt.Client(mqttClientName)
self.mqttClient.on_connect = onConnect
self.mqttClient.on_disconnect = onDisconnect
self.mqttClient.on_log = onLog
self.mqttClient.on_publish = onPublish
self.mqttClient.on_message = onMessage
self.mqttClient.connect(mqttBrokerHost)
self.mqttClient.loop_start()
def stop(self):
self.scheduler.shutdown()
self.mqttClient.loop_stop()
self.mqttClient.disconnect()
def uploadConfigList(self):
tableRows = None
try:
tableRows = getTableRows(scheduleTable)
except sqlite3.Error as err:
logger.error('SQLite: error: ' + str(err))
self.configList.clear()
for row in tableRows:
config = Config(topic=row[0],
weekday=row[1],
hour=row[2],
minute=row[3],
second=row[4])
logger.info('Uploaded config list with: ' + str(config.topic) +
' ' + str(config.weekday) + ' ' + str(config.hour) +
' ' + str(config.minute) + ' ' + str(config.second))
self.configList.append(config)
self.updateScheduler()
def updateScheduler(self):
for config in self.configList:
self.scheduler.add_cron_job(func=self.requestUpdate,
args=[config.topic],
day_of_week=config.weekday,
hour=config.hour,
minute=config.minute,
second=config.second)
def requestUpdate(self, mqttTopic):
self.mqttClient.publish(mqttTopic, mqttUpdateTrigger, int(mqttQos))
def run(self):
print "Start scheduler @ {dt}".format(dt=datetime.utcnow())
# Start the scheduler
sched = Scheduler(daemonic=False)
sched.start()
#sched.add_cron_job(self.job_function, second="*/2", max_instances=6)
seconds = 5
sched.add_cron_job(self.job_function, second="*/%d" % seconds, max_instances=6)
def tasks(hour):
'''run tasks, keep it running for spider'''
import logging
logging.basicConfig()
sched = Scheduler(standalone=True)
# http://pythonhosted.org/APScheduler/modules/scheduler.html
sched.add_cron_job(douban_spider_task, hour=int(hour))
# sched.add_interval_job(douban_spider_task, seconds=10)
print 'start tasks at', datetime.datetime.now()
sched.start()
def tasks(hour):
'''run tasks, keep it running for spider'''
import logging
logging.basicConfig()
sched = Scheduler(standalone=True)
# http://pythonhosted.org/APScheduler/modules/scheduler.html
sched.add_cron_job(douban_spider_task, hour=int(hour))
# sched.add_interval_job(douban_spider_task, seconds=10)
print 'start tasks at', datetime.datetime.now()
sched.start()
def handle(self, *args, **options):
scheduler = Scheduler(daemonic=False)
logger.info("started the scheduler")
scheduler.add_cron_job(send_reminders,
hour=settings.SCHEDULER_HOUR,
minute=settings.SCHEDULER_MINUTES)
scheduler.add_cron_job(send_deactivate_email,
hour=settings.SCHEDULER_HOUR,
minute=settings.SCHEDULER_MINUTES)
scheduler.start()
class ScheduleThread(threading.Thread):
def __init__(self):
super(ScheduleThread, self).__init__()
self.sched = Scheduler()
def run(self):
self.sched.start()
def addschedule(self, **d):
self.sched.add_cron_job(**d)
def checkCron(self):
def fun():
pass
sche = Scheduler()
try:
sche.add_cron_job(fun, **self.toDictByDateTime())
return True
except:
return False
finally:
del sche
def main():
fpid = os.fork()
if fpid != 0:
# Running as daemon now. PID is fpid
sys.exit(0)
parse_snmp()
parse()
sched = Scheduler()
sched.add_cron_job(parse, minute='*/2')
sched.add_cron_job(parse_snmp, minute='*/1')
sched.start()
signal.pause()
class evExecuter:
def __init__(self):
self.executer = Scheduler()
self.executer.start()
def addEvt(self, func, hr):
self.executer.add_cron_job(func,
year='*',
month='*',
day='*',
hour='*',
minute='*',
second='0')
def run():
tasks = get_tasks()
scheduler = Scheduler(standalone=True)
print "执行任务:"
for k, v in tasks.iteritems():
t = v()
print "%s: %s" % (t.desc, t.cron)
scheduler.add_cron_job(t, **t.cron)
try:
scheduler.start()
except (KeyboardInterrupt, SystemExit):
print "exit ..."
def download_user_info_scheduler():
"""
Create and prepare scheduler for downloading xml data from url.
"""
scheduler = Scheduler()
scheduler.start()
# backup Schedule to run once every 4 hours
day_of_week = app.config.get('cron_day_of_week_pattern', '*')
hour = app.config.get('cron_hour_pattern', '*/4')
minute = app.config.get('cron_minutes_pattern', '0')
scheduler.add_cron_job(download_users_information, day_of_week=day_of_week,
hour=hour, minute=minute)
def daemon():
try:
from setproctitle import setproctitle
except ImportError:
pass
else:
setproctitle("netl2api [netl2server:http-daemon/job/switch-cfg-persistence]")
logger.info("Starting persistence-control daemon...")
logger.info("The persistence-control worker will run on minutes '%s'..." % worker_minutes)
sched = Scheduler()
sched.add_cron_job(worker, minute=worker_minutes)
sched.start()
signal.pause()
class TimeScheduler:
instance = None
def __init__(self):
'''
'''
@staticmethod
def getInstance():
if TimeScheduler.instance is None:
TimeScheduler.instance = TimeScheduler()
return TimeScheduler.instance
def init(self,threadpool = None):
if threadpool is None :
self.sched = Scheduler({'apscheduler.threadpool.core_threads':1,
'apscheduler.threadpool.max_threads':1,
'apscheduler.threadpool.keepalive':1})
else:
self.sched = Scheduler({'apscheduler.threadpool':threadpool})
self.sched.daemonic = False
def registerCronExp(self,handler,year=None, month=None, day=None, hour=None, minute=None, second=None,
start_date=None):
return self.sched.add_cron_job(handler.execute,year, month, day, None,None,
hour, minute, second,None)
def registerCron(self, handler ,year=None, month=None, day=None, week=None,
day_of_week=None, hour=None, minute=None, second=None,
start_date=None):
return self.sched.add_cron_job(handler.execute,year=None, month=None, day=None, week=None,
day_of_week=None, hour=None, minute=None, second=None,
start_date=None)
'''
register interval task
'''
def registerInterval(self, handler,weeks=0, days=0, hours=0, minutes=0,
seconds=0, start_date=None):
return self.sched.add_interval_job(handler.execute,weeks,days,hours, minutes,
seconds,start_date)
def registerDate(self, handler,date):
return self.sched.add_date_job(handler.execute,date)
def unregister(self,job):
self.sched.unschedule_job(job)
def start(self):
self.sched.start()
def init_sched():
global g_sched
global g_old_appdata
g_old_appdata = []
config = {'apscheduler.threadpool.core_threads':1,'apscheduler.threadpool.max_threads':1}
g_sched = Scheduler(gconfig=config)
g_sched.add_listener(listener_missed_job, apscheduler.events.EVENT_JOB_MISSED)
g_sched.start()
update_jobs()
g_sched.add_cron_job(update_jobs, name='update_jobs',
minute='*', hour='*', day='*', month='*', day_of_week='*', year='*')
def createTask( listTask ):
"""
创建并开始文件提取任务
"""
for dic in listTask:
pfID = str(dic["pfid"])
groupID = str(dic["groupid"])
configPath = dic["configpath"]
logSource = dic["logsource"]
Protocol = dic["protocol"]
Port = dic["port"]
userName = dic["username"]
userPass = dic["userpass"]
fPath = dic["fpath"]
Files = dic["files"]
oneTime = dic["onetime"]
schedStart = dic["schedstart"]
schedEnd = dic["schedend"]
schedTime = dic["schedtime"]
schedCron = dic["schedcron"]
argus = [ int(pfID), int(groupID), configPath, logSource, Protocol, Port, userName, userPass, fPath, Files ]
sched = Scheduler()
if oneTime.upper() == 'Y': # 只执行一次
if schedStart == None:
schedStart = datetime.datetime.now() + datetime.timedelta( seconds = 2 ) # 延时两秒
sched.add_date_job( taskFunc, schedStart, name='Job'+pfID, args=argus )
elif schedTime != None:
( sWeeks, sDays, sHours, sMinutes, sSeconds ) = scheduletime.fmtSchedTime( schedTime )
if schedStart == None: # interval_job 在start_date为None时默认从当前算起，过一个设定的时间间隔第一次执行任务
schedStart = datetime.datetime.now() + datetime.timedelta( seconds = 2 ) - datetime.timedelta( seconds = sSeconds, \
minutes = sMinutes, hours = sHours, days = sDays, weeks = sWeeks )
sched.add_interval_job( taskFunc, weeks=sWeeks, days=sDays, hours=sHours, minutes=sMinutes, seconds=sSeconds, \
start_date=schedStart, name='Job'+pfID, args=argus )
elif schedCron != None:
( cSecond, cMinute, cHour, cDay, cDayofWeek, cWeek, cMonth, cYear ) = scheduletime.frmSchedCron( schedCron )
sched.add_cron_job( taskFunc, year=cYear, month=cMonth, week=cWeek, day_of_week=cDayofWeek, day=cDay, \
hour=cHour, minute=cMinute, second=cSecond, start_date=schedStart, name='Job'+pfID, args=argus )
sched.add_listener( taskListener, events.EVENT_JOB_EXECUTED | events.EVENT_JOB_ERROR )
# 保存计划任务的截止时间
dicJob['T'+pfID] = oneTime.upper()
dicJob['Job'+pfID] = schedEnd
dicTask['Task'+pfID] = sched
dicTask['Task'+pfID].start()
class Scheduler(Plugin):
crons = {}
intervals = {}
started = False
def __init__(self):
addEvent("schedule.cron", self.cron)
addEvent("schedule.interval", self.interval)
addEvent("schedule.remove", self.remove)
self.sched = Sched(misfire_grace_time=60)
self.sched.start()
self.started = True
def remove(self, identifier):
for cron_type in ["intervals", "crons"]:
try:
self.sched.unschedule_job(getattr(self, cron_type)[identifier]["job"])
log.debug("%s unscheduled %s", (cron_type.capitalize(), identifier))
except:
pass
def doShutdown(self):
self.stop()
return super(Scheduler, self).doShutdown()
def stop(self):
if self.started:
log.debug("Stopping scheduler")
self.sched.shutdown()
log.debug("Scheduler stopped")
self.started = False
def cron(self, identifier="", handle=None, day="*", hour="*", minute="*"):
log.info('Scheduling "%s", cron: day = %s, hour = %s, minute = %s', (identifier, day, hour, minute))
self.remove(identifier)
self.crons[identifier] = {
"handle": handle,
"day": day,
"hour": hour,
"minute": minute,
"job": self.sched.add_cron_job(handle, day=day, hour=hour, minute=minute),
}
def interval(self, identifier="", handle=None, hours=0, minutes=0, seconds=0):
log.info(
"Scheduling %s, interval: hours = %s, minutes = %s, seconds = %s", (identifier, hours, minutes, seconds)
)
self.remove(identifier)
self.intervals[identifier] = {
"handle": handle,
"hours": hours,
"minutes": minutes,
"seconds": seconds,
"job": self.sched.add_interval_job(handle, hours=hours, minutes=minutes, seconds=seconds),
}
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 createTask(listTask):
"""
创建并开始计划任务
"""
for dic in listTask:
taskID = str(dic["schedid"])
searchCond = dic["searchcond"].replace(DELIMITER, " ")
searchStart = dic["searchstart"]
searchEnd = dic["searchend"]
schedStart = dic["schedstart"]
schedEnd = dic["schedend"]
schedTime = dic["schedtime"]
schedCron = dic["schedcron"]
warnOrNot = dic["warnornot"]
warnCondOp = dic["warncondop"]
warnCondVal = dic["warncondval"]
warnLevel = dic["warnlevel"]
saveResult = dic["saveresult"]
argus = [
int(taskID), searchCond, searchStart, searchEnd, warnOrNot,
warnCondOp, warnCondVal, warnLevel, saveResult
]
sched = Scheduler()
if schedTime != None:
(sWeeks, sDays, sHours, sMinutes,
sSeconds) = scheduletime.fmtSchedTime(schedTime)
if schedStart == None: # interval_job 在start_date为None时默认从当前算起，过一个设定的时间间隔第一次执行任务
schedStart = datetime.datetime.now() + datetime.timedelta( seconds = 2 ) - datetime.timedelta( seconds = sSeconds, \
minutes = sMinutes, hours = sHours, days = sDays, weeks = sWeeks )
sched.add_interval_job( taskFunc, weeks=sWeeks, days=sDays, hours=sHours, minutes=sMinutes, seconds=sSeconds, \
start_date=schedStart, name='Job'+taskID, args=argus )
elif schedCron != None:
(cSecond, cMinute, cHour, cDay, cDayofWeek, cWeek, cMonth,
cYear) = scheduletime.frmSchedCron(schedCron)
sched.add_cron_job( taskFunc, year=cYear, month=cMonth, week=cWeek, day_of_week=cDayofWeek, day=cDay, \
hour=cHour, minute=cMinute, second=cSecond, start_date=schedStart, name='Job'+taskID, args=argus )
sched.add_listener(taskListener,
events.EVENT_JOB_EXECUTED | events.EVENT_JOB_ERROR)
# 保存计划任务的截止时间
dicJob['Job' + taskID] = schedEnd
dicTask['Task' + taskID] = sched
dicTask['Task' + taskID].start()
class Scheduler(Plugin):
crons = {}
intervals = {}
started = False
def __init__(self):
addEvent('schedule.cron', self.cron)
addEvent('schedule.interval', self.interval)
addEvent('schedule.start', self.start)
addEvent('schedule.restart', self.start)
addEvent('app.load', self.start)
addEvent('app.shutdown', self.stop)
self.sched = Sched(misfire_grace_time=60)
def remove(self, identifier):
for type in ['interval', 'cron']:
try:
self.sched.unschedule_job(
getattr(self, type)[identifier]['job'])
log.debug('%s unscheduled %s' %
(type.capitalize(), identifier))
except:
pass
def start(self):
# Stop all running
self.stop()
# Crons
for identifier in self.crons:
try:
self.remove(identifier)
cron = self.crons[identifier]
job = self.sched.add_cron_job(cron['handle'],
day=cron['day'],
hour=cron['hour'],
minute=cron['minute'])
cron['job'] = job
except ValueError, e:
log.error("Failed adding cronjob: %s" % e)
# Intervals
for identifier in self.intervals:
try:
self.remove(identifier)
interval = self.intervals[identifier]
job = self.sched.add_interval_job(interval['handle'],
hours=interval['hours'],
minutes=interval['minutes'],
seconds=interval['seconds'],
repeat=interval['repeat'])
interval['job'] = job
except ValueError, e:
log.error("Failed adding interval cronjob: %s" % e)
class MetaDataGenerationScheduler():
def __init__(self, updateIntervalSeconds=30):
self.interval = updateIntervalSeconds
config = {'apscheduler.daemonic': False}
self.sched = Scheduler(config)
# initialize these per instance.
self.repo_timestamps = {}
self.jobs = {}
repo_timestamps = {} #dictionary with jobName (=reponame) : last scheduler modification timestamp (float)
jobs = {} #dictionary with jobName (=reponame) : jobHandle
configService = RepoConfigService()
static_root_dir = configService.getStaticRepoDir()
sched = None
interval = None
def start(self):
self.update_program_config() #read configs, schedule jobs
# schedule an update as a job
self.sched.add_interval_job(self.update_program_config, seconds=self.interval)
# schedule cleanup cache
self.sched.add_cron_job(self.cleanupCacheDir, hour = 23, minute = 17, second = 20)
self.sched.start()
def createrepo_with_optional_cleanup_job(self, *argList):
monitor = JobMonitorer()
monitor.job_starts()
repoDir = argList[0]
reponame = argList[1]
rpm_max_keep = argList[2]
didCleanUp=False
try:
if rpm_max_keep != None:
didCleanUp=True
self.configService.doCleanup(repoDir, rpm_max_keep)
logging.info("job RpmCleanup on "+reponame+" took "+str(monitor.get_execution_time_until_now_seconds())+" seconds")
self.configService.doCreateRepo(repoDir, reponame)
monitor.job_finishes()
logging.info(monitor.get_pretty_job_summary("createrepo on "+reponame+" (cleanup included : "+str(didCleanUp)+")"))
except Exception, ex:
logging.error(traceback.format_exc())
class MetaDataGenerationScheduler():
def __init__(self, updateIntervalSeconds=30):
self.interval = updateIntervalSeconds
config = {'apscheduler.daemonic': False}
self.sched = Scheduler(config)
# initialize these per instance.
self.repo_timestamps = {}
self.jobs = {}
repo_timestamps = {} #dictionary with jobName (=reponame) : last scheduler modification timestamp (float)
jobs = {} #dictionary with jobName (=reponame) : jobHandle
configService = RepoConfigService()
static_root_dir = configService.getStaticRepoDir()
sched = None
interval = None
def start(self):
self.update_program_config() #read configs, schedule jobs
# schedule an update as a job
self.sched.add_interval_job(self.update_program_config, seconds=self.interval)
# schedule cleanup cache
self.sched.add_cron_job(self.cleanupCacheDir, hour = 23, minute = 17, second = 20)
self.sched.start()
def createrepo_with_optional_cleanup_job(self, *argList):
monitor = JobMonitorer()
monitor.job_starts()
repoDir = argList[0]
reponame = argList[1]
rpm_max_keep = argList[2]
didCleanUp=False
try:
if rpm_max_keep != None:
didCleanUp=True
self.configService.doCleanup(reponame, repoDir, rpm_max_keep)
logging.info("job RpmCleanup on "+reponame+" took "+str(monitor.get_execution_time_until_now_seconds())+" seconds")
self.configService.doCreateRepo(repoDir, reponame)
monitor.job_finishes()
logging.info(monitor.get_pretty_job_summary("createrepo on "+reponame+" (cleanup included : "+str(didCleanUp)+")"))
except Exception, ex:
logging.error(traceback.format_exc())
class Scheduler(Plugin):
crons = {}
intervals = {}
started = False
def __init__(self):
addEvent('schedule.cron', self.cron)
addEvent('schedule.interval', self.interval)
addEvent('schedule.remove', self.remove)
self.sched = Sched(misfire_grace_time = 60)
self.sched.start()
self.started = True
def remove(self, identifier):
for cron_type in ['intervals', 'crons']:
try:
self.sched.unschedule_job(getattr(self, cron_type)[identifier]['job'])
log.debug('%s unscheduled %s', (cron_type.capitalize(), identifier))
except:
pass
def doShutdown(self):
super(Scheduler, self).doShutdown()
self.stop()
def stop(self):
if self.started:
log.debug('Stopping scheduler')
self.sched.shutdown()
log.debug('Scheduler stopped')
self.started = False
def cron(self, identifier = '', handle = None, day = '*', hour = '*', minute = '*'):
log.info('Scheduling "%s", cron: day = %s, hour = %s, minute = %s', (identifier, day, hour, minute))
self.remove(identifier)
self.crons[identifier] = {
'handle': handle,
'day': day,
'hour': hour,
'minute': minute,
'job': self.sched.add_cron_job(handle, day = day, hour = hour, minute = minute)
}
def interval(self, identifier = '', handle = None, hours = 0, minutes = 0, seconds = 0):
log.info('Scheduling %s, interval: hours = %s, minutes = %s, seconds = %s', (identifier, hours, minutes, seconds))
self.remove(identifier)
self.intervals[identifier] = {
'handle': handle,
'hours': hours,
'minutes': minutes,
'seconds': seconds,
'job': self.sched.add_interval_job(handle, hours = hours, minutes = minutes, seconds = seconds)
}
class LuxLogger():
def __init__(self, cron_seconds, output, serialport):
self.sched = Scheduler()
self.sched.start()
self.log_queue = Queue()
self.incoming = SerialPort(serialport, self.log_queue, TIMEOUT)
self.parser = Parser()
self.saver = Persistence(output, self.log_queue, self.parser)
self.saver.start()
self.cron_seconds = cron_seconds
def go(self):
try:
logging.debug("starting the cron based scheduler")
self.sched.add_cron_job(self.incoming.getData,
second=self.cron_seconds)
except Exception, err:
logging.error(err)
def run_scheduler(jobs):
# Set up scheduler
sched = Scheduler()
for cron_spec, argv in jobs:
# Convert cron style spec inot apscheduler spec
spec = parse_cron_spec(cron_spec)
method = process_wrapper(argv)
sched.add_cron_job(method, **spec)
# Run scheduler
sched.start()
# Infinatly sleep
while (True):
time.sleep(15.0)
def handle(self, *args, **options):
scheduler = Scheduler(daemonic=False)
logger.info("started the scheduler")
scheduler.add_cron_job(send_reminders,
hour=settings.SCHEDULER_HOUR,
minute=settings.SCHEDULER_MINUTES)
scheduler.add_cron_job(send_time_based_reminder_email,
hour=settings.SCHEDULER_HOUR,
minute=settings.SCHEDULER_MINUTES)
scheduler.add_cron_job(deactivate_poll_questionnaire,
hour=settings.SCHEDULER_HOUR,
minute=settings.SCHEDULER_MINUTES)
scheduler.add_cron_job(deactivate_expired_trial_account,
hour=settings.SCHEDULER_HOUR,
minute=settings.SCHEDULER_MINUTES + 1)
scheduler.add_cron_job(update_all_views,
hour=settings.SCHEDULER_HOUR,
minute=settings.SCHEDULER_MINUTES)
scheduler.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')
def run_cron_job(settings, prefix, job):
'''
Runs a cron job
:param dict settings: configuration for the application
:param string prefix: the prefix to prepend to properties
:param job: reference to the function to run as a cron job
'''
enabled = to_bool(settings.get(prefix + "enable", 'False'))
if enabled:
new_prefix = prefix + 'schedule.cron.'
cron_time = {}
year = settings.get(new_prefix + "year")
month = settings.get(new_prefix + "month")
day = settings.get(new_prefix + "day")
week = settings.get(new_prefix + "week")
day_of_week = settings.get(new_prefix + "day_of_week")
hour = settings.get(new_prefix + "hour")
minute = settings.get(new_prefix + "minute")
second = settings.get(new_prefix + "second")
if year is not None:
cron_time['year'] = year
if month is not None:
cron_time['month'] = month
if day is not None:
cron_time['day'] = day
if week is not None:
cron_time['week'] = week
if day_of_week is not None:
cron_time['day_of_week'] = day_of_week
if hour is not None:
cron_time['hour'] = hour
if minute is not None:
cron_time['minute'] = minute
if second is not None:
cron_time['second'] = second
if len(cron_time) > 0:
sched = Scheduler()
sched.start()
sched.add_cron_job(job, args=[settings], **cron_time)
class ActivityScheduler(baseRunner.BaseRunner):
def __init__(self):
super(ActivityScheduler, self).__init__()
# set logging options as defined in config file
logConf = self.config._sections["logging"]
# remove default __name__ item
del logConf["__name__"]
logConf["level"] = int(logConf["level"])
logConf["filename"] = join(dirname(__file__), logConf["filename"])
logging.basicConfig(**logConf)
# initialize scheduler
self.scheduler = Scheduler()
self.scheduler.start()
# create initial schedule
if not self.scheduler.get_jobs():
self.createSchedule()
# main loop
while True:
try:
time.sleep(10)
except KeyboardInterrupt:
logging.info("Shutting down..")
self.scheduler.shutdown()
break
def createSchedule(self):
logging.info("Schedule requests..")
schedules = self.config._sections["schedule"]
# remove default __name__ item
del schedules["__name__"]
for methodName, schedule in schedules.items():
# schedule handler requests (wrapper method gets called with
# cron-like notation and the method name)
# name parameter is given for logging/debugging purposes only
self.scheduler.add_cron_job(self.wrap, *schedule.split(), \
args=[methodName], misfire_grace_time=120, name=methodName)
def entry():
parser = argparse.ArgumentParser(prog='simplecoin rpc client scheduler')
parser.add_argument('-l',
'--log-level',
choices=['DEBUG', 'INFO', 'WARN', 'ERROR'],
default='INFO')
parser.add_argument('-cl', '--config-location', default='/config.yml')
args = parser.parse_args()
# Setup logging
root = logging.getLogger()
hdlr = logging.StreamHandler()
formatter = logging.Formatter(
'%(asctime)s [%(name)s] [%(levelname)s] %(message)s')
hdlr.setFormatter(formatter)
root.addHandler(hdlr)
root.setLevel(getattr(logging, args.log_level))
# Setup yaml configs
# =========================================================================
cfg = yaml.load(open(os_root + args.config_location))
# Setup our CoinRPCs + SCRPCClients
coin_rpc = {}
sc_rpc = {}
for curr_cfg in cfg['currencies']:
if not curr_cfg['enabled']:
continue
cc = curr_cfg['currency_code']
coin_rpc[cc] = CoinRPC(curr_cfg, logger=logger)
curr_cfg.update(cfg['sc_rpc_client'])
sc_rpc[cc] = SCRPCClient(curr_cfg, coin_rpc[cc], logger=logger)
pm = PayoutManager(logger, sc_rpc, coin_rpc)
sched = Scheduler(standalone=True)
logger.info("=" * 80)
logger.info("SimpleCoin cron scheduler starting up...")
setproctitle.setproctitle("simplecoin_scheduler")
# All these tasks actually change the database, and shouldn't
# be run by the staging server
sched.add_cron_job(pm.pull_payouts, minute='*/1')
sched.add_cron_job(pm.send_payout, hour='23')
sched.add_cron_job(pm.associate_all_payouts, hour='0')
sched.add_cron_job(pm.confirm_payouts, hour='1')
sched.start()
def run(start_type = None):
global postdata
conf = sys_config.SysConfig(configFile)
# 进程号文件名
pidFile = conf.getConfig("datastats", "pidFile")
if start_type == None:
if os.path.exists(pidFile):
os.remove(pidFile)
pFile = open(pidFile, "w")
pFile.write(str(os.getpid()))
pFile.close()
# 生成postdata对象
postdata = postgrestats.PostgresData(configFile)
argus = [ postdata ]
sched = Scheduler(standalone = True)
sched.add_cron_job(funcNoon, year=cron_noon[0], month=cron_noon[1], \
week=cron_noon[2], day_of_week=cron_noon[3], day=cron_noon[4], \
hour=cron_noon[5], minute=cron_noon[6], second=cron_noon[7], args=argus)
sched.add_cron_job(funcHour, year=cron_hour[0], month=cron_hour[1], \
week=cron_hour[2], day_of_week=cron_hour[3], day=cron_hour[4], \
hour=cron_hour[5], minute=cron_hour[6], second=cron_hour[7], args=argus)
sched.add_cron_job(funcMidnight, year=cron_midnight[0], month=cron_midnight[1], \
week=cron_midnight[2], day_of_week=cron_midnight[3], day=cron_midnight[4], \
hour=cron_midnight[5], minute=cron_midnight[6], second=cron_midnight[7], args=argus)
# 自定义dashboard统计服务
sched.add_cron_job(stats_dashboard.stats_dashboard, year=cron_dashboard[0], month=cron_dashboard[1], \
week=cron_dashboard[2], day_of_week=cron_dashboard[3], day=cron_dashboard[4], \
hour=cron_dashboard[5], minute=cron_dashboard[6], second=cron_dashboard[7], args=argus)
# 每隔几分钟（默认5分钟）检查是否需要删除原始pcap文件
interval_chkdevice = conf.getConfig("datastats", "intervalCheckDevice")
if interval_chkdevice == None:
interval_chkdevice = 5
else:
interval_chkdevice = int(interval_chkdevice)
sched.add_interval_job(chkdevice.checkDevice, weeks=0, days=0, hours=0, minutes=interval_chkdevice, seconds=0, args=argus)
try:
sched.start()
except (KeyboardInterrupt, SystemExit):
pass
def init_sched():
global g_sched
global g_old_appdata
g_old_appdata = []
config = {
'apscheduler.threadpool.core_threads': 1,
'apscheduler.threadpool.max_threads': 1
}
g_sched = Scheduler(gconfig=config)
g_sched.add_listener(listener_missed_job,
apscheduler.events.EVENT_JOB_MISSED)
g_sched.start()
update_jobs()
g_sched.add_cron_job(update_jobs,
name='update_jobs',
minute='*',
hour='*',
day='*',
month='*',
day_of_week='*',
year='*')
def main():
sched = Scheduler()
#sched = BlockingScheduler()
sched.start()
sched.add_cron_job(bookTKB, hour=3, minute=50)
sched.add_cron_job(bookTKB, hour=15, minute=50)
sched.add_cron_job(bookTKB, hour=8, minute=57)
#sched.add_cron_job(bookTKB, hour=16, minute=50)
#sched.add_job(bookTKB, 'cron', hour=3, minute=55)
#sched.add_job(bookTKB, 'cron', hour=15, minute=55)
#sched.add_job(bookTKB, 'cron', hour=8, minute=12)
logging.warning('running...')
port = int(os.environ.get('PORT', 5000))
app.run(host='0.0.0.0', port=port)
class bakCron(object):
def __init__(self):
self.sched = Scheduler()
self.sched.daemonic = False
self.sched.start()
self.assign_jobs()
self.assign_monitor()
def get_fileconfig(self):
'''
获取配置文件的路径，此路径在软件安装时指定目录。
'''
policyfile = os.path.dirname(nsccdbbak.__file__) + "/conf/Policy.conf"
serverfile = os.path.dirname(nsccdbbak.__file__) + "/conf/Server.conf"
policys = []
PolicyConfig = ConfigParser.ConfigParser(allow_no_value=True)
PolicyConfig.read(policyfile)
for section in PolicyConfig.sections():
dictTmp = {}
colon = section.find(':')
key, value = section[:colon], section[colon + 1:]
dictTmp[key] = value
for key, value in PolicyConfig.items(section):
if 'pass' in key:
dictTmp[key] = base64.decodestring(value)
else:
dictTmp[key] = value
policys.append(dictTmp.copy())
dictTmp.clear()
servers = []
ServerConfig = ConfigParser.ConfigParser(allow_no_value=True)
ServerConfig.read(serverfile)
for section in ServerConfig.sections():
dictTmp = {}
colon = section.find(':')
key, value = section[:colon], section[colon + 1:]
dictTmp[key] = value
for key, value in ServerConfig.items(section):
if 'pass' in key:
dictTmp[key] = base64.decodestring(value)
else:
dictTmp[key] = value
servers.append(dictTmp.copy())
dictTmp.clear()
return policys, servers
def assign_jobs(self):
'''
读取配置文件，获得针对不同数据库的备份策略，设定备份线程。
'''
(policys, servers) = self.get_fileconfig()
for dictTmp in policys:
if dictTmp['flag'] == '1':
for dict in servers:
if dict['server'] == dictTmp['server']:
serverInfo = dict
for key in dictTmp.keys():
if dictTmp[key] == '':
dictTmp[key] = None
glob_bak_name = 'glob_bak_' + dictTmp['server']
print[serverInfo, dictTmp['bakcon']]
self.sched.add_cron_job(self.glob_bak,
args=[serverInfo, dictTmp['bakcon']],
month=dictTmp['globmonth'],
day=dictTmp['globday'],
day_of_week=dictTmp['globweekday'],
hour=dictTmp['globhour'],
minute=dictTmp['globminute'],
second='*/3',
name=glob_bak_name)
incr_bak_name = 'incr_bak_' + dictTmp['server']
self.sched.add_cron_job(self.incr_bak,
month=dictTmp['incmonth'],
day=dictTmp['incday'],
day_of_week=dictTmp['incweekday'],
hour=dictTmp['inchour'],
minute=dictTmp['incminute'],
name=incr_bak_name)
print self.sched.get_jobs()
print 'assign jobs finished!'
def assign_monitor(self):
'''
设定文件监控线程。
'''
self.sched.add_interval_job(self.monitorfile, name='monitorDaemon')
print self.sched.get_jobs()
print 'assign monitor finished'
def filechange(self, monitor, file1, file2, evt_type):
'''
备份策略文件发生变化时，撤销计划列表中除文件监控以外的所有计划，然后重新设定备份线程。
'''
if evt_type == gio.FILE_MONITOR_EVENT_CHANGED:
print 'file changed'
for job in self.sched.get_jobs():
print job
if job.name != 'monitorDaemon':
self.sched.unschedule_job(job)
self.assign_jobs()
def monitorfile(self):
'''
启动文件监控线程，并设定多线程运行环境。
'''
gfile = gio.File(self.filepath)
monitor = gfile.monitor_file(gio.FILE_MONITOR_NONE, None)
monitor.connect("changed", self.filechange)
gobject.threads_init()
gml = gobject.MainLoop()
gml.run()
def glob_bak(self, serConf, bakcontainer):
'''
负责执行一次全局备份，将备份文件上传至云存储。
'''
timestr = time.strftime(r"%Y-%m-%d_%H-%M-%S", time.localtime())
print timestr
conndb = ConnDatabase(serConf)
connStor = ConnStorage(serConf)
(result, bakfilepath) = conndb.conn.glob_bak()
if result:
connStor.upload_file(bakcontainer, bakfilepath)
else:
print 'global backup error!'
def incr_bak(self, serConf, bakcontainer):
'''
负责执行一次增量备份，将备份文件上传至云存储。
'''
conndb = ConnDatabase(serConf)
connStor = ConnStorage(serConf)
(result, bakfilepath) = conndb.conn.incr_bak()
if result:
connStor.upload_file(bakcontainer, bakfilepath)
else:
print 'increase backup error!'
# calculate our events from the auto_state_events list, need to find a better way of doing this, maybe a config file.
for event in auto_state_events:
app.logger.info("Processing scheduled event : %s" %
event['event_name'])
start_hour = event['event_start_time'].split(':')[0]
start_minute = event['event_start_time'].split(':')[1]
start_second = event['event_start_time'].split(':')[2]
start_time = datetime.strptime(event['event_start_time'], time_format)
end_time = datetime.strptime(event['event_end_time'], time_format)
event_duration = (end_time - start_time).seconds
sched.add_cron_job(led_chain.auto_transition,
hour=start_hour,
minute=start_minute,
second=start_second,
name=event['event_name'],
kwargs={
'state': event['event_state'],
'transition_duration':
event['transition_duration']
},
misfire_grace_time=event_duration)
app.logger.debug("Startup job list contains : %s" % sched.get_jobs())
try:
app.run(host='0.0.0.0',
port=int(app_config.get("general", "web_port")),
use_reloader=False)
except KeyboardInterrupt:
app.logger.warning("Caught keyboard interupt. Shutting down ...")
class Scheduler(object):
schedulr = None
aps3 = True
def __init__(self):
#####
# ApScheduler version detection
try:
# APScheduler 3.x implementation
from apscheduler.schedulers.background import BackgroundScheduler
self.schedulr = BackgroundScheduler()
self.aps3 = True
except ImportError:
# APScheduler 2.x implementation
from apscheduler.scheduler import Scheduler
self.schedulr = Scheduler()
self.aps3 = False
def start(self):
return self.schedulr.start()
def get_job(self, name):
if self.aps3:
return self.schedulr.get_job(name)
else:
jobs = self.schedulr.get_jobs()
for job in jobs:
if job.name == name:
return job
return None
def add_job(self, func, trigger, args=None, kwargs=None, id=None, **trigger_args):
if self.aps3:
return self.schedulr.add_job(func, trigger, id=id, args=args, kwargs=kwargs, **trigger_args)
else:
if trigger is 'date':
run_date = trigger_args['run_date'] # by intention: to raise if not set!
del trigger_args['run_date']
return self.schedulr.add_date_job(func, run_date, name=id, args=args, kwargs=kwargs)
elif trigger is 'interval':
# only partially implemented!!
seconds = 0
minutes = 0
hours = 0
if 'seconds' in trigger_args:
seconds = trigger_args.get('seconds', 0)
del trigger_args['seconds']
if 'minutes' in trigger_args:
minutes = trigger_args.get('minutes', 0)
del trigger_args['minutes']
if 'hours' in trigger_args:
hours = trigger_args.get('hours', 0)
del trigger_args['hours']
return self.schedulr.add_interval_job(func, name=id,
hours=hours, minutes=minutes, seconds=seconds,
args=args, kwargs=kwargs)
elif trigger is 'cron':
# only partially implemented!!
second = 0
minute = 0
hour = 0
if 'second' in trigger_args:
second = trigger_args.get('second', 0)
del trigger_args['second']
if 'minute' in trigger_args:
minute = trigger_args.get('minute', 0)
del trigger_args['minute']
if 'hour' in trigger_args:
hour = trigger_args.get('hour', 0)
del trigger_args['hour']
return self.schedulr.add_cron_job(func, name=id, hour=hour, minute=minute, second=second)
else:
raise NotImplementedError
def shutdown(self):
return self.schedulr.shutdown()
# https://github.com/ralphwetzel/theonionbox/issues/19#issuecomment-263110953
def check_tz(self):
from tzlocal import get_localzone
try:
# APScheduler 3.x
from apscheduler.util import astimezone
except ImportError:
# https://github.com/ralphwetzel/theonionbox/issues/31
# APScheduler 2.x
# import six
from pytz import timezone, utc
from datetime import tzinfo
# copied here from apscheduler/util.py (version 3.4)
# copyright Alex Grönholm
# https://github.com/agronholm/apscheduler
def astimezone(obj):
"""
Interprets an object as a timezone.
:rtype: tzinfo
"""
# if isinstance(obj, six.string_types):
if isinstance(obj, (str, unicode)):
return timezone(obj)
if isinstance(obj, tzinfo):
if not hasattr(obj, 'localize') or not hasattr(obj, 'normalize'):
raise TypeError('Only timezones from the pytz library are supported')
if obj.zone == 'local':
raise ValueError(
'Unable to determine the name of the local timezone -- you must explicitly '
'specify the name of the local timezone. Please refrain from using timezones like '
'EST to prevent problems with daylight saving time. Instead, use a locale based '
'timezone name (such as Europe/Helsinki).')
return obj
if obj is not None:
raise TypeError('Expected tzinfo, got %s instead' % obj.__class__.__name__)
tz = get_localzone()
try:
res = astimezone(tz)
except ValueError as ve:
return False
return True
