class LightManager(object):
def __init__(self):
self.setterZones = [LightSetter(zone.mode, zone.pinout, description=zone.description) for zone in zones]
self.defaultSetterZone = self.setterZones[0]
self.scheduler = BackgroundScheduler()
self.scheduler.start()
def setLights(self, color, zone=None):
if not zone:
self.defaultSetterZone.setLights(color)
elif int(zone) in range(len(self.setterZones)):
self.setterZones[int(zone)].setLights(color)
else:
raise InvalidZoneException
def setEvent(self, secondsUntilEvent, color, zone=None):
eventTime = datetime.now()+timedelta(seconds=secondsUntilEvent)
eventId = str(hash((eventTime, color)))
self.scheduler.add_job(self.setLights, args=(color,zone), next_run_time=eventTime, id=eventId)
return eventId
def cancelEvent(self, eventId):
self.scheduler.remove_job(eventId)
def getZoneInfo(self):
return {str(i): {'type': zone.mode, 'description': zone.description} for i, zone in zip(range(len(self.setterZones)), self.setterZones)}
def main():
plugin_list= cf.sections()
print plugin_list
notif = pynsca.NSCANotifier(cf.monitor_server, password=cf.nsca_pass)
plugin_scheduler = BackgroundScheduler()
try:
for svc_name in plugin_list:
if str(svc_name) == 'defaults': pass
else:
logging.info("%s loading" % str(svc_name))
cmd=cf.g(svc_name,"check")
if cmd is None:
logging.error("%s check not exists" % svc_name)
sys.exit(2)
plugin_interval = cf.g(svc_name,"interval")
if plugin_interval is None:
continue
plugin_scheduler.add_job(func=check_execute,args=[cmd,svc_name,notif],trigger='interval',seconds = plugin_interval, id = svc_name)
logging.info("%s loaded" %str(svc_name))
plugin_scheduler.start()
while True:
time.sleep(2)
except Exception,e:
logging.info("Agent boot up error: %s" % str(e))
sys.exit(1)
def start(self):
if self.config.webui['enable']:
scheduler = BackgroundScheduler(
logger=logging.getLogger('schedule'))
logging.info("Using Background Scheduler")
else:
scheduler = BlockingScheduler(logger=logging.getLogger('schedule'))
logging.info("Using Blocking Scheduler")
scheduler.add_job(lambda: self.fetch(),
'cron', minute=30, id='fetch')
scheduler.add_job(lambda: self.sort(),
'cron', minute=00, id='sort')
# run once at launch
self.fetch()
self.sort()
scheduler.start()
if self.config.webui['enable']:
logging.debug("Setting up WebUI")
from fetcherd.webui import WebUI
self.webui = WebUI(self, self.config)
logging.debug("Starting WebUI")
self.webui.run()
class TestPySpout(basesinfonierspout.BaseSinfonierSpout):
def __init__(self):
basesinfonierspout.BaseSinfonierSpout().__init__()
def useropen(self):
# Using deque as a queue
self.queue = deque()
self.frequency = int(self.getParam("frequency"))
# This scheduler launches self.job function every X seconds
self.sched = BackgroundScheduler()
self.sched.add_job(self.job, "interval", seconds=self.frequency, id="testpy")
self.sched.start()
def usernextTuple(self):
# If there are items in self.queue, get the first one (.popleft()), do what you want with it and emit the tuple
if self.queue:
self.addField("timestamp",self.queue.popleft())
self.emit()
def userclose(self):
pass
def job(self):
self.queue.append(str(int(time.time())))
def start():
print('cront started')
scheduler = BackgroundScheduler()
scheduler.add_job(run_daily, 'interval', days=1)
scheduler.add_job(run_sync, 'interval', minutes=5,
max_instances=1, next_run_time=datetime.now())
scheduler.start()
def main():
scheduler = Scheduler()
servermap = ServerMap()
scheduler.add_job(servermap.reload, trigger='cron', minute='*/5')
scheduler.add_job(servermap.main, trigger='cron', minute='*/1')
scheduler.start()
dashboard.run()
def schedule_notices():
sched = BackgroundScheduler()
sched.start()
trigger = CronTrigger(day_of_week='*', hour=17)
sched.add_job(send_notice, trigger)
def initialize():
"""Setting a schedule for the background process"""
with app.app_context():
print("Scheduling...")
apsched = BackgroundScheduler()
apsched.add_job(run_check, 'interval', seconds=60)
apsched.start()
def nameserver_check_scheduler(heartbeat_obj):
""" Schedule the check using the heartbeat object """
sched = BackgroundScheduler()
sched.start()
sched.add_job(heartbeat_obj.nameserver_check,
'cron',
second=("*/%s" % int(heartbeat_obj.configuration['heartbeat']['default']['interval'])))
retries_check = int(heartbeat_obj.configuration['heartbeat']['default']['init_retries'])
retry_wait = int(10)
while(retries_check != 0):
try:
heartbeat_obj.nameservers.next()
except StopIteration:
pretty_log("Heartbeat scheduler not initialized yet... Will retry %s times..." % retries_check)
pretty_log("Will retry in %s seconds" % retry_wait)
retries_check -= 1
sleep(retry_wait)
else:
pretty_log("Heartbeat scheduler initalized...")
return True
else:
pretty_log("Heartbeat scheduler error!")
return False
def mail2diaspora(config_pathname):
# configure logging
logger = logging.getLogger(__name__)
configure_logging(logging.INFO)
logger.info("Start mail2diaspora application")
config.initialize(config_pathname)
os.chdir(config.get(config.TEMP))
# cron email fetcher
scheduler = BackgroundScheduler()
scheduler.add_job(
diaspora.mail_poll, "interval", seconds=config.getInt(config.MAIL_POLLING)
)
scheduler.start()
print("Press Ctrl+{0} to exit".format("Break" if os.name == "nt" else "C"))
try:
# This is here to simulate application activity (which keeps the main thread alive).
while True:
time.sleep(2)
except (KeyboardInterrupt, SystemExit):
# Not strictly necessary if daemonic mode is enabled but should be done if possible
scheduler.shutdown()
logger.info("Stop mail2diaspora application")
def build(cube_name_list, buildType, start_time=None, end_time=None):
run_cube_job_id = '1'
check_cube_job_id = '2'
scheduler = BackgroundScheduler()
CubeWorker.job_instance_dict = {}
for cube_name in cube_name_list:
CubeWorker.job_instance_dict[cube_name] = None
CubeWorker.scheduler = scheduler
CubeWorker.run_cube_job_id = run_cube_job_id
CubeWorker.check_cube_job_id = check_cube_job_id
# start the run cube job immediately
CubeWorker.run_cube_job(buildType, start_time, end_time)
scheduler.add_job(CubeWorker.run_cube_job, 'interval', seconds=30, id=run_cube_job_id, args=[buildType, start_time, end_time])
scheduler.add_job(CubeWorker.check_cube_job, 'interval', seconds=30, id=check_cube_job_id)
scheduler.start()
while True:
if CubeWorker.all_finished():
print "all cube jobs are finished"
scheduler.remove_job(check_cube_job_id)
scheduler.remove_job(run_cube_job_id)
scheduler.shutdown()
status = CubeWorker.get_status()
print 'Build exited with status %s' % status
return status == CubeWorkerStatus.SUCCESS
time.sleep(settings.KYLIN_CHECK_STATUS_INTERVAL)
def run_scheduler():
scheduler = BackgroundScheduler()
# scheduler.add_job(func, "interval", days=1)
scheduler.add_job(check_overdue, "interval", days=1)
# scheduler.add_job(send_mail_test(), "interval", minutes=1)
scheduler.start()
print "Scheduler started!"
class RealTimeQuote(object):
def __init__(self, cf, codelist, eventEngine_):
self._codelist = codelist
logger.info("codelist:%s", self._codelist)
self._eventEngine = eventEngine_
#self._eventEngine.register(EVENT_TIMER, self.TimerCall)
self._sched = BackgroundScheduler()
def start(self):
self._sched.add_job(self.TimerCall, 'interval', seconds=3)
self._sched.start()
logger.info('RealTimeQuote start')
def stop(self):
logger.info('RealTimeQuote stop')
self._sched.shutdown()
def TimerCall(self):
'''
定时根据代码列表获取最新行情
:return:
'''
if len(self._codelist) < 1:
return
rtQuote = GetRealTimeQuote(self._codelist)
for i in range(rtQuote.shape[0]):
itQuote = rtQuote.ix[i]
if float(itQuote['amount']) <= 0.01:
continue
event = Event(type_=EVENT_MARKETDATA_CONTRACT + itQuote['code'])
event.dict_['tick'] = itQuote
self._eventEngine.put(event)
class TimerTrigger(BaseTrigger):
name = "timer"
log = logging.getLogger("zuul.Timer")
def __init__(self, trigger_config={}, sched=None, connection=None):
super(TimerTrigger, self).__init__(trigger_config, sched, connection)
self.apsched = BackgroundScheduler()
self.apsched.start()
def _onTrigger(self, pipeline_name, timespec):
for project in self.sched.layout.projects.values():
event = TriggerEvent()
event.type = "timer"
event.timespec = timespec
event.forced_pipeline = pipeline_name
event.project_name = project.name
self.log.debug("Adding event %s" % event)
self.sched.addEvent(event)
def stop(self):
self.apsched.shutdown()
def getEventFilters(self, trigger_conf):
def toList(item):
if not item:
return []
if isinstance(item, list):
return item
return [item]
efilters = []
for trigger in toList(trigger_conf):
f = EventFilter(trigger=self, types=["timer"], timespecs=toList(trigger["time"]))
efilters.append(f)
return efilters
def postConfig(self):
for job in self.apsched.get_jobs():
job.remove()
for pipeline in self.sched.layout.pipelines.values():
for ef in pipeline.manager.event_filters:
if ef.trigger != self:
continue
for timespec in ef.timespecs:
parts = timespec.split()
if len(parts) < 5 or len(parts) > 6:
self.log.error(
"Unable to parse time value '%s' " "defined in pipeline %s" % (timespec, pipeline.name)
)
continue
minute, hour, dom, month, dow = parts[:5]
if len(parts) > 5:
second = parts[5]
else:
second = None
trigger = CronTrigger(day=dom, day_of_week=dow, hour=hour, minute=minute, second=second)
self.apsched.add_job(self._onTrigger, trigger=trigger, args=(pipeline.name, timespec))
def __init__(self, profile):
self._logger = logging.getLogger(__name__)
self.q = Queue.Queue()
self.profile = profile
self.notifiers = []
self._logger.debug('Initializing Notifier...')
if 'gmail_address' in profile and 'gmail_password' in profile:
self.notifiers.append(self.NotificationClient(
self.handleEmailNotifications, None))
else:
self._logger.warning('gmail_address or gmail_password not set ' +
'in profile, Gmail notifier will not be used')
if 'ssh_auth_log' in profile:
self.notifiers.append(self.NotificationClient(
self.handleSSHAuthNotifications, None))
else:
self._logger.warning('ssh_auth_log not set,' +
'SSH login notifier will not be used')
job_defaults = {
'coalesce': True,
'max_instances': 1
}
sched = BackgroundScheduler(timezone="UTC", job_defaults=job_defaults)
sched.start()
sched.add_job(self.gather, 'interval', seconds=30)
atexit.register(lambda: sched.shutdown(wait=False))
# put the scheduler in Notifier object for reference
self._sched = sched
class Processor:
def like_wall(self):
print "Will like a wall!"
try:
news = self.user.get_news(random.randint(10,100))
print "News: ", len(news)
for n in news:
likes = n.get("likes",None)
if likes and likes["user_likes"] == 0 and likes["can_like"] == 1:
print "LIKE", n["post_id"]
self.user.like_post(n["post_id"],n["source_id"])
print "Sleeep"
time.sleep(random.uniform(0, 5))
print "Done"
except:
print "Error in like"
pass
def __init__(self , user):
self.user = user
self.shced = BackgroundScheduler()
self.shced.add_job(self.like_wall, "interval", seconds=60);
self.shced.start()
def process_message(self, message, chatid, userid):
return;
class Bot():
def __init__(self, cfg):
self.token = cfg.TOKEN_BOT
self.scheduler = BackgroundScheduler({
'apscheduler.jobstores.default': {
'type': 'sqlalchemy',
'url': cfg.POSTGRESQL_DB
},
'apscheduler.executors.default': {
'class': 'apscheduler.executors.pool:ThreadPoolExecutor',
'max_workers': '20'
},
'apscheduler.executors.processpool': {
'type': 'processpool',
'max_workers': '5'
},
'apscheduler.job_defaults.coalesce': 'false',
'apscheduler.job_defaults.max_instances': '3',
'apscheduler.timezone': 'UTC',
})
def post(self, text, channel):
url = 'https://{domain}/services/hooks/slackbot?token={token}&channel=%23{channel}'
r = requests.post(url.format(domain=cfg.TEAMDOMAIN, token=self.token, channel=channel), data=text)
def test(self, args=None):
print 'Scheduler test'
if args:
print 'job args: {0}'.format(' '.join(args))
def add_reminder(self):
self.scheduler.add_job(self.test, 'interval', minutes=1, id='job_id', jobstore='default')
def post(self, action, position = ''):
global scheduler
self.checkStartup()
if action == 'play':
runCommand('mpc play ' + position)
#Settings.set('radio', 'state', 'play')
if scheduler is None:
scheduler = BackgroundScheduler()
scheduler.add_job(self.checkStatus, 'interval', seconds=30, id='checkStatus', replace_existing=True)
scheduler.start()
elif action == 'stop':
runCommand('mpc stop')
#Settings.set('radio', 'state', 'stop')
if scheduler is not None:
scheduler.remove_job('checkStatus')
scheduler.shutdown()
scheduler = None
return {'playMode': 'stopped'}
elif action =='pause':
runCommand('mpc pause')
elif action =='next':
runCommand('mpc next')
elif action =='previous':
runCommand('mpc prev')
else:
return {'playMode': 'invalid'}
(out, err) = runCommand('mpc status')
if err:
return {'error', err}, 500
return {'playMode': Parser.parsePlayMode(out)}
def run_web():
nt.dirNameProxy.startDirObservers()
sched = BackgroundScheduler(jobstores=jobstores, executors=executors, job_defaults=job_defaults)
sched.start()
x = 60
for name, classInstance in nt.__dict__.items():
# look up all class instances in nameTools. If they have the magic attribute "NEEDS_REFRESHING",
# that means they support scheduling, so schedule the class in question.
# To support auto-refreshing, the class needs to define:
# cls.NEEDS_REFRESHING = {anything, just checked for existance}
# cls.REFRESH_INTERVAL = {number of seconds between refresh calls}
# cls.refresh() = Call to do the refresh operation. Takes no arguments.
#
if isinstance(classInstance, type) or not hasattr(classInstance, "NEEDS_REFRESHING"):
continue
sched.add_job(classInstance.refresh,
trigger='interval',
seconds=classInstance.REFRESH_INTERVAL,
start_date=datetime.datetime.now()+datetime.timedelta(seconds=20+x),
jobstore='main_jobstore')
x += 60*2.5
# It looks like cherrypy installs a ctrl+c handler, so I don't need to.
webserver_process.serverProcess()
class timer:
'''
process = timer(function, [para1,para2,...], intervalseconds)
process.run()
'''
def __init__(self, func, paras, seconds, id):
self.func = func
self.paras = paras
self.time = seconds
self.id = id
self.scheduler = None
self.setTimer()
def setTimer(self):
self.scheduler = BackgroundScheduler()
self.scheduler.add_job(self.func, 'interval', seconds=self.time, id=self.id)
def add_job(self, func, seconds, id):
self.scheduler.add_job(func, 'interval', seconds, id)
def remove_job(self, id):
self.scheduler.remove_job(id)
def run(self):
self.scheduler.start()
def startScheduler():
db.create_all()
#create default roles!
if not db.session.query(models.Role).filter(models.Role.name == "admin").first():
admin_role = models.Role(name='admin', description='Administrator Role')
user_role = models.Role(name='user', description='User Role')
db.session.add(admin_role)
db.session.add(user_role)
db.session.commit()
try:
import tzlocal
tz = tzlocal.get_localzone()
logger.info("local timezone: %s" % tz)
except:
tz = None
if not tz or tz.zone == "local":
logger.error('Local timezone name could not be determined. Scheduler will display times in UTC for any log'
'messages. To resolve this set up /etc/timezone with correct time zone name.')
tz = pytz.utc
#in debug mode this is executed twice :(
#DONT run flask in auto reload mode when testing this!
scheduler = BackgroundScheduler(logger=sched_logger, timezone=tz)
scheduler.add_job(notify.task, 'interval', seconds=config.SCAN_INTERVAL, max_instances=1,
start_date=datetime.datetime.now(tz) + datetime.timedelta(seconds=2))
scheduler.start()
sched = scheduler
def getScheduler():
"getScheduler constructs and returns a scheduler object"
#Define default background scheduler
scheduler = BackgroundScheduler()
#Define ownerJob to be scheduled
def ownerJob():
"ownerJob updates the active_owners file with owner information"
#Get current list of owners
data = DevicesAttached().getActiveOwners()
#Obtain local time and
timeStruct = time.localtime()
[year,month,day,hour,minute,second,weekDay,yearDay,isDes] = timeStruct
data["timestamp"] = "{:02d}:{:02d}:{:02d}".format(hour,minute,second)
#Save file with date name
filename = "active_owners_{:02d}_{:02d}_{:02d}.csv".format(day,month,year)
saveRow(filename,data)
#If end of a day upload log to dropbox
if ((hour == 23) and (minute > 57)):
try:
DropboxAPI().saveFile(filename)
except Exception as exception:
print str(exception)
ownerJob()
scheduler.add_job(ownerJob,'interval',minutes=2,id="owner-job")
return scheduler
def configure_scheduler_from_config(settings):
scheduler = BackgroundScheduler()
scheduler.start()
# run `purge_account` job at 0:00
scheduler.add_job(
purge_account,
id='purge_account',
name='Purge accounts which where not activated',
trigger='cron',
hour=0,
minute=0
)
# run `purge_token` job at 0:30
scheduler.add_job(
purge_token,
id='purge_token',
name='Purge expired tokens',
trigger='cron',
hour=0,
minute=30
)
scheduler.add_listener(exception_listener, EVENT_JOB_ERROR)
atexit.register(lambda: scheduler.shutdown())
def init():
scheduler = BackgroundScheduler()
scheduler.start()
scheduler.add_job(dochatcleanup, 'interval',
minutes=int(plugin.config.config('sleep')),
id='dochatcleanup', replace_existing=True)
return
class JobScheduler(object):
def __init__(self, config):
self.scheduler = BackgroundScheduler()
self.scheduler.add_job(
self.job_process,
'interval',
seconds=config['JOB_POLL_INTERVAL_SECONDS'],
max_instances=1)
self.scheduler.add_job(
self.notification_job_process,
'interval',
seconds=config['DELIVERY_POLL_INTERVAL_SECONDS'],
max_instances=1)
self.config = config
def start(self):
self.scheduler.start()
def shutdown(self):
self.scheduler.shutdown(wait=True)
def job_process(self):
process_jobs(self.config)
def notification_job_process(self):
process_notification_job(self.config)
class schedulecontrol:
def __init__(self):
self.scheduler = BackgroundScheduler()
self.oncescheduler=BlockingScheduler()
self.scheduler.start()
def start(self):
self.oncescheduler.start()
def addschedule(self,event=None, day_of_week='0-7', hour='11',minute='57' ,second='0',id='',type='cron',run_date='',args=None):
if id=='':
id=str(time.strftime("%Y-%m-%d %X", time.localtime()));
if type=='date':
if run_date=='':
self.oncescheduler.add_job(event, args=args)
else:
self.oncescheduler.add_job(event, 'date', run_date=run_date, args=args)
elif type=='back':
self.oncescheduler.add_job(event,type, day_of_week=day_of_week, hour=hour,minute=minute ,second=second,id=id)
else:
self.scheduler.add_job(event, type, day_of_week=day_of_week, hour=hour, minute=minute, second=second, id=id)
def removeschedule(self,id):
self.scheduler.remove_job(id)
def setup_tasks(self):
scheduler = BackgroundScheduler()
def remove_dead_inbound_connections():
self.remove_dead_inbound_connections()
scheduler.add_job(remove_dead_inbound_connections, CronTrigger(second='*/15'))
scheduler.start()
def test_aps_eventlet():
def showMessage():
print "Show this message"
sh = BackgroundScheduler()
sh.start()
sh.add_job(showMessage, 'interval', seconds=2, timezone=utc)
time.sleep(10)
def interval():
"""
Setup the scheduler.
"""
scheduler = BackgroundScheduler()
scheduler.add_job(tick, 'interval', seconds=10)
scheduler.start()
print('Scheduler Started')
def initialize():
Database.initialize()
session['email'] = session.get('email')
session['name'] = session.get('name')
scheduler = BackgroundScheduler()
scheduler.add_job(check_alert, "cron", day_of_week="0-4", hour="16", minute=30)
scheduler.start()
def start():
scheduler = BackgroundScheduler()
scheduler.add_job(rateApi.update_rate, 'interval', minutes=45)
scheduler.start()
class MyWindow(Gtk.Window):
def __init__(self):
Gtk.Window.__init__(self, title="Hello PyObject")
imgH, imgW = [800, 600]
self.set_default_size(imgH, imgW) # set_size_request(imgH, imgW)
self.GtkWindowType = Gtk.WindowType.TOPLEVEL
# set hiden window bar
# self.set_decorated(False)
# keyname = Gdk.keyval_name(self.key)
self.connect("key-press-event", self.on_key_press_event)
self.data_path = path.join(path.abspath(path.dirname(__file__)),
"data")
self.media_path = path.join(path.abspath(path.dirname(__file__)),
"media")
# box = Gtk.VBox()
# label = Gtk.Label("Insert text you want to search for:")
# box.add(label)
# self.entry = Gtk.Entry()
# box.add(self.entry)
self.main_area = Gtk.Stack()
self.main_area.set_transition_type(
Gtk.StackTransitionType.SLIDE_LEFT_RIGHT)
self.main_area.set_transition_duration(1000)
self.conWin1 = Gtk.Box()
self.main_area.add_titled(self.conWin1, "window1", "window1")
fixCon = Gtk.Fixed()
self.conWin1.add(fixCon)
filePath = path.join(self.media_path, "img1.jpg")
newImage = ipImage("demoImage", filePath, 800, 600)
fixCon.put(newImage, 0, 0)
# self.labelS = Gtk.Label()
# self.label_txt = """<big><i>you have choice to runn the scan directly or after setup the scanning process you want to follow on your target</i></big>"""
# self.labelS.set_markup(self.label_txt)
# self.labelS.set_line_wrap(True)
self.conWin2 = Gtk.Box()
self.main_area.add_titled(self.conWin2, "window2", "window2")
fixCon2 = Gtk.Fixed()
self.conWin2.add(fixCon2)
filePath2 = path.join(self.media_path, "img5.jpg")
newImage2 = ipImage("demoImage2", filePath2, 800, 600)
fixCon2.put(newImage2, 0, 0)
# self.our_stackSwitcher = Gtk.StackSwitcher()
# self.our_stackSwitcher.set_stack(self.main_area)
# box.add(self.our_stackSwitcher)
# box.add(self.main_area)
self.add(self.main_area)
self.show_all()
self.iScheduler = BackgroundScheduler()
exec_date = datetime.now() + timedelta(seconds=5)
print(exec_date)
self.iScheduler.add_job(self.switchClipWin, "date", run_date=exec_date)
self.iScheduler.start()
def switchClipWin(self):
print("switchClipWin")
self.main_area.set_visible_child_name("window2")
def on_key_press_event(self, widget, event):
# print("Key press on widget: ", widget)
# print(" Modifiers: ", event.state)
# print(" Key val, name: ", event.keyval, Gdk.keyval_name(event.keyval))
# check the event modifiers (can also use SHIFTMASK, etc)
ctrl = event.state & Gdk.ModifierType.CONTROL_MASK
# see if we recognise a keypress
if ctrl and event.keyval == Gdk.KEY_q:
print("Quit App")
Gtk.main_quit()
global articles # fix this later or something lol
print('updating articles...')
if scrape_new:
print('scraping new...')
run_engine()
print('loading new data...')
with open('data.json', 'rb') as file_in:
articles = json.load(file_in)
articles = sorted(articles, key=lambda x:x['neutrality'])
make_nosummary()
scheduler = BackgroundScheduler()
scheduler.add_job(func=update, trigger='cron', hour='11', minute='0')
#scheduler.start()
update(scrape_new=False)
def filter(query, articles):
results = []
for art in articles:
if query is None or query.lower() in art['title'].lower():
results.append(art)
return results
def similar(idx, articles):
results = []
sims = articles[idx]['sims']
# time.sleep(20)
if book_to_list != []:
for i in book_to_list:
content = "%s,您借用的%s已到归还时间，请及时归还给实验室管理员。" % (i['username'], i['bookname'])
msg = MIMEText(
content, _subtype='plain', _charset='utf-8')
msg['Subject'] = Header(sub, "utf-8")
msg['From'] = MAIL['user']
msg['To'] = i['usermail']
send_email(to_addr=i['usermail'], msg=msg)
scheduler = BackgroundScheduler()
scheduler.add_job(send_lend_mail, 'cron', day_of_week='mon-fri', hour=10, minute=24)
if __name__ == "__main__":
# get_books_list()
# MSG1 = MIMEText(
# '测试', _subtype='plain', _charset='utf-8')
# MSG1['Subject'] = 'test'
# MSG1['From'] = MAIL['user']
# MSG1['To'] = '*****@*****.**'
# # send_email(to_addr='*****@*****.**', msg=MSG1)
# get_books_list()
# send_lend_mail(sub='测试')
#
scheduler.start()
try:
while True:
format(newDaily.total_cases, newDaily.total_deaths,
newDaily.total_recoveries))
newDaily.calculate(previousCases, previousDeaths, previousRecoveries)
time = newDaily.date
try:
db.session.add(newDaily)
db.session.commit()
except Exception as e:
logger.error("Key already exists")
logger.error(e)
logger.info("Successfuly added to database")
#----------------TASK SCHEDULER---------------#
scheduler = BackgroundScheduler(daemon=True)
scheduler.add_job(dataAdd, 'interval', args=[db], days=1)
scheduler.start()
#---------ROUTING---------------#
@app.route('/')
def index():
data = get_covid_data()
return "Cases: {} Deaths: {} Recoveries: {}".format(
data.totalCases, data.totalDeaths, data.totalRecoveries)
@app.route('/home')
def home():
currentData = get_covid_data()
logger.debug(currentData.totalDeaths)
# This job runs once an hour
def try_and_run_trial():
# Check if behavenet model is running
proc_running = checkProcRunning('python behavenet')
print('Process currently running: ', proc_running)
if not proc_running:
# 1) Update decoding_data file with new trial
with open('../.behavenet/decoding_data.json', 'a') as f:
print('Updating JSON file for new trial ', TRIAL_TO_TRAIN)
data = json.loads(f)
data['session'] = TRIAL_TO_TRAIN
json.dump(data, f)
print('Kicking off new process...')
proc = subprocess.Popen([
'nohup python',
'behavenet/fitting/decoder_grid_search.py --data_config ~/.behavenet/decoding_data.json --model_config ~/.behavenet/decoding_ae_model.json --training_config ~/.behavenet/decoding_training.json --compute_config ~/.behavenet/decoding_compute.json > plaw_ctypes.out &2>&1'
])
print('Updating trial_count...')
TRIAL_TO_TRAIN += 1
if TRIAL_TO_TRAIN > 4:
scheduler.shutdown()
print('Adding job to scheduler')
scheduler.add_job(try_and_run_trial, 'interval', minutes=60)
print('Starting scheduler...')
scheduler.start()
def jobomatic(buggo):
#Use buggo to pass outlet instance instead of the ever changing global outlet
scheduler.remove_job(str(outlet.num)+'on')
scheduler.remove_job(str(outlet.num)+'off')
scheduler.add_job(lambda: spiffyon(buggo), 'cron'
,hour=outlet.t_on.hour
,minute=outlet.t_on.minute
,id=str(outlet.num)+'on')
scheduler.add_job(lambda: spiffyoff(buggo), 'cron'
,hour=outlet.t_off.hour
,minute=outlet.t_off.minute
,id=str(outlet.num)+'off')
def jobdummystart():
for x in range(1,6):
scheduler.add_job(do_nothing, 'cron'
,hour=20
,id=str(x)+'off')
scheduler.add_job(do_nothing, 'cron'
,hour=8
,id=str(x)+'on')
#Set up dummy jobs so it doesn't complain
#Set up interval based jobs
jobdummystart()
scheduler.add_job(checker,'interval', minutes=1)
scheduler.add_job(camerago, 'cron',hour=12)
socketio.run(app, debug="False", host='0.0.0.0')
Outlets.cleanup()
Metric="BLENDED_COST"
)
forecast = r["Total"]["Amount"][0]
print("Updated AWS Forecast cost: %s" %(forecast))
g_forecast.set(float(forecast))
print("Finished calculating costs")
return 0
@app.route('/metrics/')
def metrics():
return Response(generate_latest(), mimetype=CONTENT_TYPE_LATEST)
@app.route('/health')
def health():
return "OK"
scheduler.start()
scheduler.add_job(
func=aws_query,
trigger=IntervalTrigger(seconds=int(QUERY_PERIOD),start_date=(datetime.now() + timedelta(seconds=5))),
id='aws_query',
name='Run AWS Query',
replace_existing=True
)
# Shut down the scheduler when exiting the app
atexit.register(lambda: scheduler.shutdown())
mydb.commit()
################### LINUX ONLY ################
################# MOD_WSGI MODE ###############
shutil.rmtree('var/www/FlaskApp/bluechipApi/static/' + provider_token +
'/' + name + '')
return ('successful deleted')
except Exception:
return 'error'
finally:
mycursor.close()
mydb.close()
@app.errorhandler(404)
def page_not_found(e):
return "<h1>404</h1><p>The resource could not be found.</p>", 404
################# TASK RUNNING AT EVERY 1 MINUTE ################
scheduler = BackgroundScheduler()
job = scheduler.add_job(image_process_to_obj, 'interval', minutes=1)
scheduler.start()
#app.run()
if __name__ == "__main__":
app.run()
for i in resp:
d = {}
for j in i.keys():
if (j == "order_id" or j == "_id"):
d[j] = str(i[j])
else:
d[j] = i[j]
print(d)
details['det'].append(d)
response = jsonify(details)
response.headers.add('Access-Control-Allow-Origin', '*')
return response, 200
else:
return 405
client = pymongo.MongoClient(
"mongodb+srv://WalPoolAdmin:[email protected]/test?retryWrites=true&w=majority"
)
order_db = client.Order
cab_db = client.Cab
order_collection = order_db.OrderCollection
cab_details = cab_db.CabDetails
from apscheduler.schedulers.background import BackgroundScheduler
scheduler = BackgroundScheduler()
scheduler.add_job(update_cab_location, 'interval', seconds=10)
scheduler.start()
app.run(host='localhost', port=8000)
class Base():
def __init__(self):
self.history = History()
self.instance_list = {}
self.token_list = {}
self.scheduler = BackgroundScheduler()
self.scheduler.start()
self.scheduler.add_job(
func=self._remove_staleinstances,
trigger=IntervalTrigger(seconds=120),
id='stale_instance_remover',
name='Remove stale instances if no heartbeat in 120 seconds',
replace_existing=True
)
self.scheduler.add_job(
func=self._update_history_count,
trigger=IntervalTrigger(seconds=30),
id='update history',
name='update client and instance count every 30 seconds',
replace_existing=True
)
def _update_history_count(self):
servers = [instance.servers for instance in self.instance_list.values()]
servers = [inner for outer in servers for inner in outer]
client_num = 0
# force it being a number
for server in servers:
client_num += server.clientnum
self.history.add_client_history(client_num)
self.history.add_instance_history(len(self.instance_list))
def _remove_staleinstances(self):
for key, value in list(self.instance_list.items()):
if int(time.time()) - value.last_heartbeat > 120:
print('[_remove_staleinstances] removing stale instance {id}'.format(id=key))
del self.instance_list[key]
del self.token_list[key]
print('[_remove_staleinstances] {count} active instances'.format(count=len(self.instance_list.items())))
def get_instances(self):
return self.instance_list.values()
def get_instance_count(self):
return self.instance_list.count
def get_instance(self, id):
return self.instance_list[id]
def instance_exists(self, instance_id):
if instance_id in self.instance_list.keys():
return instance_id
else:
False
def add_instance(self, instance):
if instance.id in self.instance_list:
print('[add_instance] instance {id} already added, updating instead'.format(id=instance.id))
return self.update_instance(instance)
else:
print('[add_instance] adding instance {id}'.format(id=instance.id))
self.instance_list[instance.id] = instance
def update_instance(self, instance):
if instance.id not in self.instance_list:
print('[update_instance] instance {id} not added, adding instead'.format(id=instance.id))
return self.add_instance(instance)
else:
print('[update_instance] updating instance {id}'.format(id=instance.id))
self.instance_list[instance.id] = instance
def add_token(self, instance_id, token):
print('[add_token] adding {token} for id {id}'.format(token=token, id=instance_id))
self.token_list[instance_id] = token
def get_token(self, instance_id):
try:
return self.token_list[instance_id]
except KeyError:
return False
global FIRSTFLAG
FIRSTFLAG = False #setting the create FLAG.Creating a slave worker container as per needs
createSlave()
elif diff < 0: #no of slave is more than required slave.Scaling down
for i in range(abs(diff)):
deleteSlave() #killing extra slave containers
else:
print("NO change") #no of slaves required and present are same
resetRequestCount(
) #resetting the read request couter to zero after the 2 min time interval
# Setting a timer which calls checkRequestCount method every 2 minutes
cron = BackgroundScheduler(daemon=True)
cron.add_job(checkRequestCount, 'interval', seconds=120)
client = docker.from_env() #connecting to docker daemon
countFile = "myCount.txt"
timerStart = False #timer starts once a request is made to the orchestrator
# To get a new slave name which'll be assigned to a freshly created slave.
def slaveName():
name = ""
flag1 = False
while not flag1:
name = "slave" + str(randint(1, 10**3))
flag2 = False
for c in client.containers.list():
datasets = {}
version_datasets = requests.get(
'https://api.github.com/repos/ccodwg/Covid19CanadaArchive/commits?path=datasets.json'
).headers['last-modified']
load_data_datasets(temp_dir)
## archive file index
global archive, version_archive_index
archive = {}
version_archive_index = client(
's3', config=Config(signature_version=UNSIGNED)).get_object(
Bucket='data.opencovid.ca', Key='archive/file_index.csv'
)['ResponseMetadata']['HTTPHeaders']['last-modified']
load_data_archive_index(temp_dir)
# check for data updates
scheduler = BackgroundScheduler()
job_ts = scheduler.add_job(update_data_ts,
'interval',
minutes=5,
args=[temp_dir])
job_datasets = scheduler.add_job(update_data_datasets,
'interval',
minutes=5,
args=[temp_dir])
job_archive_index = scheduler.add_job(update_data_archive_index,
'interval',
minutes=30,
args=[temp_dir])
scheduler.start()
from datetime import datetime
import time
import os
from apscheduler.schedulers.background import BackgroundScheduler
def tick():
print('Tick! The time is: %s' % datetime.now())
if __name__ == '__main__':
scheduler = BackgroundScheduler()
scheduler.add_job(tick, 'interval', seconds=3)
scheduler.start()
print('Press Ctrl+{0} to exit'.format('Break' if os.name == 'nt' else 'C'))
try:
# This is here to simulate application activity (which keeps the main thread alive).
while True:
time.sleep(2)
except (KeyboardInterrupt, SystemExit):
# Not strictly necessary if daemonic mode is enabled but should be done if possible
scheduler.shutdown()
def start():
scheduler = BackgroundScheduler()
scheduler.add_job(BackgroundClass.power_allot_func, 'interval', minutes=1)
scheduler.add_job(BackgroundClass.device_consumption, 'interval', minutes=1)
scheduler.start()
def set_sheduler(self, args):
scheduler = BackgroundScheduler()
scheduler.add_job(self.startTest,
'date',
run_date=self.run_config['ExecTime'],
args=(args, ))
if test.time <= datetime.datetime.now():
test.time = datetime.datetime.now() + datetime.timedelta(seconds=10)
print(str(test.time))
test.state = not test.state
print(test.state)
app = Flask(__name__)
@app.route("/")
def hello():
now = datetime.datetime.now()
templateData = {'title': 'HELLO!', 'time': now}
return render_template('main.html', **templateData)
"""obj.test2 = obj.test2 * 2
return "value: " + str(obj.test2)"""
"""app.config['SECRET_KEY'] = 'secret!'"""
socketio = SocketIO(app)
if __name__ == "__main__":
obj = MyClass(1)
socketio.run(app)
sched = BackgroundScheduler(daemon=True)
sched.add_job(sensor, 'interval', seconds=5, id='my_job', args=[obj])
sched.start()
app.run(host='0.0.0.0', port=91, use_reloader=False)
def timing_background(func, timing_type='interval', seconds=2):
scheduler = BackgroundScheduler()
scheduler.daemonic = False
scheduler.add_job(func, timing_type, seconds=seconds)
scheduler.start()
"""
Copyright 2021 Ela El-Heni
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
# A3 BackgroundScheduler pour telecharger les données de la ville chaque
# jour à minuit Ce bout de code peut etre deplacé à votre guise,
# faire attention aux imports circulaires
# pip3 install appscheduler
from apscheduler.schedulers.background import BackgroundScheduler
import atexit
import manage
# set scheduler
sched = BackgroundScheduler(daemon=True)
sched.add_job(manage.data_handler(), 'cron', hour=0)
sched.start()
atexit.register(lambda: sched.shutdown())
from server.app import app
from server.api.v1.api import api
from server.controllers.cron import cron_job
from flask import Flask
from flask_restful import Api
from apscheduler.schedulers.background import BackgroundScheduler
import sys
app.register_blueprint(api.blueprint, url_prefix='/api/v1')
print("Initializing Background Scheduler")
sched = BackgroundScheduler()
sched.add_job(cron_job, trigger='interval', days=1)
sched.start()
cron_job()
class HeartbeatFormatter(object):
def __init__(self, sender, log, config=None, redis=None):
self.sender = sender
self.log = log
self.config = config or forge.get_config()
self.datastore = forge.get_datastore(self.config)
self.redis = redis or get_client(
host=self.config.core.redis.nonpersistent.host,
port=self.config.core.redis.nonpersistent.port,
private=False,
)
self.redis_persist = get_client(
host=self.config.core.redis.persistent.host,
port=self.config.core.redis.persistent.port,
private=False,
)
self.status_queue = CommsQueue(STATUS_QUEUE, self.redis)
self.dispatch_active_hash = Hash(DISPATCH_TASK_HASH,
self.redis_persist)
self.dispatcher_submission_queue = NamedQueue(SUBMISSION_QUEUE,
self.redis)
self.dispatcher_file_queue = NamedQueue(FILE_QUEUE, self.redis)
self.ingest_scanning = Hash('m-scanning-table', self.redis_persist)
self.ingest_unique_queue = PriorityQueue('m-unique',
self.redis_persist)
self.ingest_queue = NamedQueue(INGEST_QUEUE_NAME, self.redis_persist)
self.alert_queue = NamedQueue(ALERT_QUEUE_NAME, self.redis_persist)
constants = forge.get_constants(self.config)
self.c_rng = constants.PRIORITY_RANGES['critical']
self.h_rng = constants.PRIORITY_RANGES['high']
self.m_rng = constants.PRIORITY_RANGES['medium']
self.l_rng = constants.PRIORITY_RANGES['low']
self.c_s_at = self.config.core.ingester.sampling_at['critical']
self.h_s_at = self.config.core.ingester.sampling_at['high']
self.m_s_at = self.config.core.ingester.sampling_at['medium']
self.l_s_at = self.config.core.ingester.sampling_at['low']
self.to_expire = {k: 0 for k in metrics.EXPIRY_METRICS}
if self.config.core.expiry.batch_delete:
self.delete_query = f"expiry_ts:[* TO {self.datastore.ds.now}-{self.config.core.expiry.delay}" \
f"{self.datastore.ds.hour}/DAY]"
else:
self.delete_query = f"expiry_ts:[* TO {self.datastore.ds.now}-{self.config.core.expiry.delay}" \
f"{self.datastore.ds.hour}]"
self.scheduler = BackgroundScheduler(daemon=True)
self.scheduler.add_job(
self._reload_expiry_queues,
'interval',
seconds=self.config.core.metrics.export_interval * 4)
self.scheduler.start()
def _reload_expiry_queues(self):
try:
self.log.info("Refreshing expiry queues...")
for collection_name in metrics.EXPIRY_METRICS:
try:
collection = getattr(self.datastore, collection_name)
self.to_expire[collection_name] = collection.search(
self.delete_query, rows=0, fl='id')['total']
except SearchException:
self.to_expire[collection_name] = 0
except Exception:
self.log.exception(
"Unknown exception occurred while reloading expiry queues:")
def send_heartbeat(self, m_type, m_name, m_data, instances):
if m_type == "dispatcher":
try:
msg = {
"sender": self.sender,
"msg": {
"inflight": {
"max": self.config.core.dispatcher.max_inflight,
"outstanding": self.dispatch_active_hash.length()
},
"instances": instances,
"metrics": m_data,
"queues": {
"ingest":
self.dispatcher_submission_queue.length(),
"files": self.dispatcher_file_queue.length(),
},
"component": m_name,
}
}
self.status_queue.publish(
DispatcherMessage(msg).as_primitives())
self.log.info(f"Sent dispatcher heartbeat: {msg['msg']}")
except Exception:
self.log.exception(
"An exception occurred while generating DispatcherMessage")
elif m_type == "ingester":
try:
c_q_len = self.ingest_unique_queue.count(*self.c_rng)
h_q_len = self.ingest_unique_queue.count(*self.h_rng)
m_q_len = self.ingest_unique_queue.count(*self.m_rng)
l_q_len = self.ingest_unique_queue.count(*self.l_rng)
msg = {
"sender": self.sender,
"msg": {
"instances": instances,
"metrics": m_data,
"processing": {
"inflight": self.ingest_scanning.length()
},
"processing_chance": {
"critical": 1 - drop_chance(c_q_len, self.c_s_at),
"high": 1 - drop_chance(h_q_len, self.h_s_at),
"low": 1 - drop_chance(l_q_len, self.l_s_at),
"medium": 1 - drop_chance(m_q_len, self.m_s_at)
},
"queues": {
"critical": c_q_len,
"high": h_q_len,
"ingest": self.ingest_queue.length(),
"low": l_q_len,
"medium": m_q_len
}
}
}
self.status_queue.publish(IngestMessage(msg).as_primitives())
self.log.info(f"Sent ingester heartbeat: {msg['msg']}")
except Exception:
self.log.exception(
"An exception occurred while generating IngestMessage")
elif m_type == "alerter":
try:
msg = {
"sender": self.sender,
"msg": {
"instances": instances,
"metrics": m_data,
"queues": {
"alert": self.alert_queue.length()
}
}
}
self.status_queue.publish(AlerterMessage(msg).as_primitives())
self.log.info(f"Sent alerter heartbeat: {msg['msg']}")
except Exception:
self.log.exception(
"An exception occurred while generating AlerterMessage")
elif m_type == "expiry":
try:
msg = {
"sender": self.sender,
"msg": {
"instances": instances,
"metrics": m_data,
"queues": self.to_expire
}
}
self.status_queue.publish(ExpiryMessage(msg).as_primitives())
self.log.info(f"Sent expiry heartbeat: {msg['msg']}")
except Exception:
self.log.exception(
"An exception occurred while generating ExpiryMessage")
elif m_type == "archive":
try:
msg = {
"sender": self.sender,
"msg": {
"instances": instances,
"metrics": m_data
}
}
self.status_queue.publish(ArchiveMessage(msg).as_primitives())
self.log.info(f"Sent archive heartbeat: {msg['msg']}")
except Exception:
self.log.exception(
"An exception occurred while generating ArchiveMessage")
elif m_type == "scaler":
try:
msg = {
"sender": self.sender,
"msg": {
"instances": instances,
"metrics": m_data,
}
}
self.status_queue.publish(ScalerMessage(msg).as_primitives())
self.log.info(f"Sent scaler heartbeat: {msg['msg']}")
except Exception:
self.log.exception(
"An exception occurred while generating WatcherMessage")
elif m_type == "scaler-status":
try:
msg = {
"sender": self.sender,
"msg": {
"service_name": m_name,
"metrics": m_data,
}
}
self.status_queue.publish(
ScalerStatusMessage(msg).as_primitives())
self.log.info(f"Sent scaler status heartbeat: {msg['msg']}")
except Exception:
self.log.exception(
"An exception occurred while generating WatcherMessage")
elif m_type == "service":
try:
busy, idle = get_working_and_idle(self.redis, m_name)
msg = {
"sender": self.sender,
"msg": {
"instances": len(busy) + len(idle),
"metrics": m_data,
"activity": {
'busy': len(busy),
'idle': len(idle)
},
"queue": get_service_queue(m_name,
self.redis).length(),
"service_name": m_name
}
}
self.status_queue.publish(ServiceMessage(msg).as_primitives())
self.log.info(f"Sent service heartbeat: {msg['msg']}")
except Exception:
self.log.exception(
"An exception occurred while generating ServiceMessage")
elif m_type == "watcher":
try:
msg = {
"sender": self.sender,
"msg": {
"instances":
instances,
"metrics":
m_data,
"watching":
UniquePriorityQueue(WATCHER_QUEUE,
self.redis).length(),
}
}
self.status_queue.publish(WatcherMessage(msg).as_primitives())
self.log.info(f"Sent watcher heartbeat: {msg['msg']}")
except Exception:
self.log.exception(
"An exception occurred while generating WatcherMessage")
else:
self.log.warning(
f"Skipping unknown counter: {m_name} [{m_type}] ==> {m_data}")
for month in range(1, 13):
days = monthrange(year, month)[1]
for day in range(1, days+1):
if f"{type}{country}{year}{str(month).zfill(2)}{str(day).zfill(2)}.json" in file_names:
print(f"{type}{country}{year}{month}{day} exists in S3, skipping")
else:
if not dt.datetime(year=int(year), month=int(month), day=int(day)) > dt.datetime.today():
print(f"{year}/{month}/{day}/{type}/{country}")
day = str(day).zfill(2)
month = str(month).zfill(2)
year = year
link = f"https://promo.betfair.com/betfairsp/prices/" \
f"dwbfprices{country}{type}{day}{month}{year}.csv"
scheduler.add_job(func=download_sp_from_link, id=str(hash(link)), kwargs={
'link': link, 'country': country, 'type': type,
'day': day, 'month': month, 'year': year,
'mode': 'overwrite' if not table_refreshed else 'append'},
misfire_grace_time=999999999)
table_refreshed = True
scheduler.start()
time.sleep(1)
print(f"Jobs left: {len(scheduler.get_jobs())}")
time.sleep(1)
while len(scheduler.get_jobs()) > 0:
print(f"Jobs left: {len(scheduler.get_jobs())}")
time.sleep(1)
scheduler.shutdown()
# # Run crawler
# session = boto3.session.Session(
def __init__(self):
cmd.Cmd.__init__(self)
self.trader = 'trader'
def do_s(self, args):
print('pressed s')
def do_bb(self, args):
print('pressed b')
def do_q(self, args):
exit(0)
def do_t(self, args):
global bsstart
if bsstart:
bs.pause()
else:
bs.start()
bsstart = not bsstart
def say():
print datetime.datetime.now()
bs.add_job(say, 'interval', seconds=2, id='my_job_id')
if __name__ == '__main__':
InteractiveShell().cmdloop()
return False
def confirmarDomotica():
ejecutarConsulta('confirmar')
def ejecutarDomotica():
if buscarAccionDomotica():
confirmarDomotica()
if __name__ == '__main__':
constantes.constantesLola()
logging.basicConfig(filename='./log/domotica.log', level=logging.INFO)
scheduler = BackgroundScheduler()
scheduler.add_job(ejecutarDomotica, 'interval', seconds=4)
scheduler.start()
print('Press Ctrl+{0} to exit'.format('Break' if os.name == 'nt' else 'C'))
try:
# This is here to simulate application activity (which keeps the main thread alive).
while True:
time.sleep(200)
except (KeyboardInterrupt, SystemExit):
# Not strictly necessary if daemonic mode is enabled but should be done if possible
scheduler.shutdown()
def schedule():
scheduler = BackgroundScheduler()
scheduler.add_job(process, 'interval', seconds=2)
scheduler.start()
continue
attrpropa = itemdl.find_all('a', target="_blank", class_="linkblack")
attrs = itemdl.a['href'] # 获取这个标签下第一个a属性中的href值
reply = itemdl.find('span', class_='fontblue').string
if ("viewthread" not in attrs) :
continue
props = attrs.split('=')
pid = int(props[1])
replycount = int(reply)
#print('当前帖子%d回复量:%d' % (pid, replycount))
if replycount < 2:
auto_post_thread(pid)
get_properties_from_remote()
scheduler = BackgroundScheduler()
scheduler.add_job(get_properties_from_remote, 'interval', seconds=600)
# 这里的调度任务是独立的一个线程
scheduler.start()
try:
# 其他任务是独立的线程执行
while True:
time.sleep(50)
except (KeyboardInterrupt, SystemExit):
scheduler.shutdown()
print('Exit The Job!')
#print(html)
elif event_name == 'live': # juchao_kuaixun
JuchaoLiveNewsSpider().start()
elif event_name == 'fin': # juchao_ant_finance
JuchaoFinanceSpider().start()
# 新版
elif event_name == 'his': # spy_announcement_data
JuchaoHistorySpy().start()
elif event_name == 'ref': # an_announcement_secu_ref
AnnSecuRef().daily_sync()
# 播报模块
elif event_name == 'ding':
utils.send_crawl_overview()
for data in task_info:
ap_scheduler.add_job(
func=handle,
trigger=data['trigger'],
minutes=data['time_interval'],
args=(data['task_id'], ),
name=data['task_name'],
max_instances=1,
)
ap_scheduler.start()
while True:
time.sleep(10)
for i in uL.keys(): # chat id
for j in uL[i].keys():
if uL[i][j][3] + 15 <= int(time.time()):
try:
bot.delete_message(int(i), uL[i][j][2])
except:
pass
if uL[i][j][3] + 60 <= int(time.time()):
bot.kick_chat_member(int(i), int(j), until_date=None)
bot.restrict_chat_member(int(i),
int(j),
until_date=None,
can_send_messages=True)
bot.restrict_chat_member(int(i),
int(j),
until_date=None,
can_send_messages=False)
userList[i].pop(j)
if len(userList[i]) == 0:
userList.pop(i)
if __name__ == '__main__':
scheduler = BackgroundScheduler()
scheduler.add_job(clean_list, 'interval', seconds=15)
scheduler.start()
try:
bot.polling()
except BaseException:
pass
class RoleManager:
def __init__(self, cfg, section):
h = logging.StreamHandler()
h.setFormatter(logging.Formatter('%(levelname)s:%(name)s:%(message)s'))
log = logging.getLogger('apscheduler.executors.default')
log.setLevel(logging.INFO)
log.addHandler(h)
self.section = section
self.cfg = cfg
self.conn = None
self.cursor = None
self.restAPI = RestAPI()
self.hostList = self.cfg.get('ENM_SERVER_MAPPING', 'ENM_API_SERVER_LIST').split(',')
self.initRepo()
self.scheduler = BackgroundScheduler()
#self.scheduler.add_job(self.initCommandRepo, 'cron', minute='*/{}'.format(INIT_INTERVAL), second='0', id='RoleManager')
self.scheduler.add_job(self.checkJob, 'cron', minute='*', second='0', id='RoleManager')
self.scheduler.add_job(self.checkRoleStatus, 'cron', minute='*/5', second='0', id='RoleCheckManager')
#self.scheduler.add_job(self.checkRoleStatus, 'cron', minute='*', second='0', id='RoleCheckManager')
self.scheduler.start()
__LOG__.Trace('start!')
def initRepo(self):
repoStr = getContents(os.path.join(self.cfg.get(self.section, 'DUMP_PATH'), 'schedule_dump.json'))
self.jobRepo = json.loads(repoStr)
def stdOut(self, msg):
sys.stdout.write(msg+'\n')
sys.stdout.flush()
# print(msg, file=sys.stdout)
__LOG__.Trace('OUT: %s' % msg)
def stdErr(self, msg):
sys.stderr.write('%s\n' % (msg))
sys.stderr.flush()
__LOG__.Trace('ERR: %s' % msg)
def shutdown(self):
try :
df = open(os.path.join(self.cfg.get(self.section, 'DUMP_PATH'), 'schedule_dump.json'), 'w')
df.write(json.dumps(self.jobRepo, encoding='utf-8'))
df.close()
if self.scheduler :
self.scheduler.shutdown()
__LOG__.Trace('scheduler shutdown')
else :
__LOG__.Trace('scheduler is None')
except :
__LOG__.Exception()
def disConnect(self,conn,cursor):
if cursor != None:
try : cursor.close()
except : pass
if conn != None :
try : conn.close()
except : pass
def initConnect(self):
self.conn = M6.Connection(self.IRIS, self.IRIS_ID, self.IRIS_PASS, Database='tacs')
__LOG__.Trace('IRIS Connect!')
try :
self.cursor = self.conn.cursor()
self.cursor.SetFieldSep('|^|')
self.cursor.SetRecordSep('|^-^|')
except :
__LOG__.Exception()
finally :
self.conn.commit()
def run(self, section):
__LOG__.Trace('RoleManager start!!')
#self.initConnect()
while not SHUTDOWN:
try :
strIn = sys.stdin.readline()
strLine = strIn.strip()
if strLine == '' :
self.stdErr(strIn)
else :
if os.path.exists(strLine) :
jsonStr = getContents(strLine)
#jsonStr = getContents('/home/tacs/DATA/WORKINFO/RAN_EMS/O190429000001_192.168.100.55.json')
jsonObj = json.loads(jsonStr)
__LOG__.Trace(jsonObj)
repoKey = jsonObj['workId']
self.jobRepo[repoKey] = jsonObj
except :
__LOG__.Exception()
finally :
self.stdErr(strIn)
#self.disConnect(self.conn, self.cursor)
def checkJob(self):
nDate = datetime.datetime.now()
nStr = nDate.strftime('%Y%m%d%H%M00')
gabStr = (nDate - datetime.timedelta(minutes=1)).strftime('%Y%m%d%H%M00')
__LOG__.Trace('nStr : %s' % nStr)
for key in self.jobRepo.keys() :
oneJob = self.jobRepo[key]
staDate = oneJob['workStaDate']
endDate = oneJob['workEndDate']
__LOG__.Trace('%s : %s ~ %s, ENABLED:%s' % (oneJob['workId'], staDate, endDate, 'ENABLED' in oneJob))
if 'ENABLED' not in oneJob and (staDate <= nStr and gabStr <= staDate) : self.addRole(oneJob)
elif 'ENABLED' in oneJob and endDate <= nStr : self.delRole(oneJob)
else :
if nStr < staDate or nStr < endDate : __LOG__.Trace('keep : %s' % oneJob['workId'])
else :
del self.jobRepo[oneJob['workId']]
__LOG__.Trace('delete: %s' % oneJob)
def addRole(self, jsonObj):
enmApiServer = self.cfg.get('ENM_SERVER_MAPPING', jsonObj['emsIp'])
__LOG__.Trace('addRole : %s, %s, %s' % (enmApiServer, jsonObj['workId'], jsonObj['oprrId']))
self.restAPI.changeUserRole(jsonObj['emsIp'],'ADD',jsonObj['oprrId'])
self.jobRepo[jsonObj['workId']]['ENABLED'] = True
def delRole(self, jsonObj):
enmApiServer = self.cfg.get('ENM_SERVER_MAPPING', jsonObj['emsIp'])
__LOG__.Trace('delRole : %s, %s, %s' % (enmApiServer, jsonObj['workId'], jsonObj['oprrId']))
self.restAPI.changeUserRole(jsonObj['emsIp'],'REMOVE',jsonObj['oprrId'])
del self.jobRepo[jsonObj['workId']]
def checkRoleStatus(self) :
nDate = datetime.datetime.now()
yymmdd = nDate.strftime('%Y%m%d')
hhmm = nDate.strftime('%H%M')
evntDate = nDate.strftime('%Y%m%d%H%M%S')
for oneHost in self.hostList :
result = self.checkAllUserRole(oneHost)
if len(result) > 0 :
f = open('/home/tacs/DATA2/AUDIT_LOG/AUDIT_17/%s_%s_%s.audit' % (yymmdd, hhmm, oneHost), 'a')
for oneInfo in result :
oneInfo['evntDate'] = evntDate
f.write('%s\n' % JSON.dumps(oneInfo, encoding='utf-8'))
f.close()
def getAllUser(self, host) :
uri = '/oss/idm/usermanagement/users'
result = '[]'
try :
code, result = self.restAPI.execute(host, 'GET', uri)
except :
__LOG__.Exception()
userList = json.loads(result)
return userList
def getUserRole(self, host, userId) :
if userId is None or userId == '' : return None
uri = '/oss/idm/usermanagement/users/%s/privileges' % userId
code, result = self.restAPI.execute(host, 'GET', uri)
userInfo = json.loads(result)
return userInfo
def checkAllUserRole(self, host) :
userRoleList = []
userList = self.getAllUser(host)
for oneUser in userList :
if oneUser['username'] == 'SKT_TACS' : continue
userRoleInfo = self.getUserRole(host, oneUser['username'])
for oneRole in userRoleInfo :
if ENM_WORK_ROLE == oneRole['role'] :
__LOG__.Trace('Host: %s ,User : %s, Role : %s' % (host, oneUser['username'], oneRole['role']))
nDate = datetime.datetime.now().strftime('%Y%m%d%H%M%S')
userRoleList.append({'workUserId':oneUser['username'], 'beforePriv':oneRole['role'], 'checkDate':nDate})
time.sleep(1)
currentOprrIdList = []
for key in self.jobRepo.keys() :
oneJob = self.jobRepo[key]
if 'ENABLED' in oneJob :
oprrIdList = oneJob['oprrId'].split(';')
oprrIdList = [x for x in oprrIdList if x]
currentOprrIdList = currentOprrIdList + oprrIdList
result = []
for oneUserInfo in userRoleList :
if not oneUserInfo['workUserId'] in currentOprrIdList :
result.append(oneUserInfo)
return result
class WeChatBot:
def __init__(self, user):
self.user = '******'
self.status = Status['init']
self.movie = json.load(open('m.json', 'r'))
self.movie_index = 0
self.max_movie = len(self.movie)
self.is_send_movie_list = False
self.schedule = BackgroundScheduler()
self.function = {
Status['init']: self.handle_text,
Status['weather']: self.handle_weather,
Status['schedule']: self.handle_schedule,
Status['package']: self.handle_package,
Status['movie']: self.handle_movie,
}
def entry(self, text):
self.function[self.status](text)
"""
trigger:
功能
"""
def handle_text(self, text):
if re.search(r"定时", text):
self.handle_schedule(text)
elif re.search(r"快递", text):
self.handle_package(text)
elif re.search(r"天气", text) or re.search(r"气温", text):
self.handle_weather(text)
elif re.search(r"电影", text) or re.search(r"正在热映", text) or re.search(
r"院线热映", text):
self.handle_movie(text)
elif re.search(r"功能", text):
reply = "本机器人有如下功能:[快递查询],[天气查询],[院线热映],[设定定时任务]"
send_msg(reply, self.user)
else:
reply = '机器人自动回复:' + get_response(text)
send_msg(reply, self.user)
"""
trigger:
定时
"""
def handle_schedule(self, text):
try:
temp = text.split('+')[1:]
time = temp[0]
msg = temp[1]
name = temp[2]
self.schedule.add_job(send_msg,
'date',
run_date=time,
kwargs={
"msg": msg,
"name": name
})
reply = '设置成功'
self.schedule.start()
except:
reply = "设置定时任务请输入:定时发送+时间+msg+姓名,如：定时发送+2019-2-16 21:51:00+晚上好+filehelper"
send_msg(reply, self.user)
"""
trigger:
快递
"""
def handle_package(self, text):
try:
pack_num = re.search(r"(快递)(\+)([0-9]+)", text).group(3)
reply = get_package(pack_num)
except:
reply = "查询快递请输入：快递+运单号，如：快递+12345"
send_msg(reply, self.user)
"""
trigger:
天气
今日天气，七日天气
"""
def handle_weather(self, text):
if re.search(r"今日天气", text):
try:
city_name = re.search(r"(今日天气)(\+)(.*)", text).group(3)
reply = get_forecast('今日天气', city_name)
except:
reply = '查询今日天气请输入今日天气 + 城市名，如: 今日天气 + 西安.'
elif re.search(r"七日天气", text):
try:
city_name = re.search(r"(七日天气)(\+)(.*)", text).group(3)
reply = get_forecast('七日天气', city_name)
except:
reply = '查询七日天气请输入七日天气+城市名，如:七日天气+西安'
else:
reply = '''查询今日天气请输入今日天气+城市名，如:今日天气+西安.\n查询七日天气请输入七日天气+城市名，如:七日天气+西安。'''
send_msg(reply, self.user)
"""
trigger:
电影，正在热映，院线热映
in:
\d 选择
影院:（一个电影中）查看电影院，
简介:（一个电影中）查看简介，
l 展示列表
q 退出
"""
def send_list(self):
temp = ''
if not self.is_send_movie_list:
for i, m in enumerate(self.movie):
temp += f"{i+1}.{m['name']}\n"
send_msg(temp, self.user)
self.is_send_movie_list = True
def handle_movie(self, text):
self.status = Status['movie']
self.send_list()
if text.isdigit():
try:
index = int(text) - 1
if 0 <= index < self.max_movie:
self.movie_index = index
reply1 = self.movie[index]['basic']
img = self.movie[index]['img']
send_img(img, self.user)
send_msg(reply1, self.user)
else:
send_msg("请输入正确的数字范围1～" + str(self.max_movie), self.user)
except:
send_msg("请输入合法的数字1~" + str(self.max_movie), self.user)
elif re.search(r'影院', text):
reply2 = ''
for i in self.movie[self.movie_index]['cinema']:
reply2 += i + '\n'
send_msg(reply2, self.user)
elif re.search(r'简介', text):
reply3 = self.movie[self.movie_index]['intro']
send_msg(reply3, self.user)
elif re.search(r'l', text):
self.is_send_movie_list = False
self.send_list()
elif re.search(r'q', text):
self.status = Status['init']
self.movie_index = 0
self.is_send_movie_list = False
