def watchlist(request): #Handle file upload global location if 'import' in request.POST: form = DocumentForm(request.POST, request.FILES) if form.is_valid(): newdoc = Document(docfile = request.FILES['docfile']) newdoc.save() location = newdoc.path() # Redirect to the document list after POST return HttpResponseRedirect(reverse('scraper.views.watchlist')) else: form = DocumentForm() # An empty, unbound form if 'match' in request.POST: call_command('readfile', location) sched = Scheduler(standalone = True) def match_sched(): call_command('readfile', location) sched.add_interval_job(match_sched, seconds = 20, max_instances = 1000) sched.start() # Load documents for the list page documents = Document.objects.all() # Render list page with the documents and the form return render_to_response( 'scraper/index2.0.html', {'documents': documents, 'form' : form}, context_instance = RequestContext(request) )
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 schedule(): logging.info("[+]shivascheduler.py: INSIDE SCHEDULER") sched = Scheduler() duration = server.shivaconf.getint('analyzer', 'schedulertime') sched.add_interval_job(resetcounter, minutes=duration) sched.start() logging.info("Shiva scheduler, which dumps data into maindb, resets global counter and sends data on hpfeeds, started at %s and would execute every %d minutes " % (datetime.datetime.now(), duration))
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')
class TrackerManager(object): '''Manages process information collection for multiple processes''' LOG = logging.getLogger('pt.tracker_manager') def __init__(self, interval): TrackerManager.LOG.debug( "Initializing TrackerManager with interval = %s", interval) self.listeners = [] self.probes = [] self.scheduler = Scheduler() self.scheduler.add_interval_job(self.tracking_job, seconds=interval) self.scheduler.start() def add_listener(self, listener): '''Add listener that will receive metrics''' self.listeners.append(listener) def add_probes(self, probes): '''Add probe that will collect metrics''' self.probes.extend(probes) def tracking_job(self): '''a job that monitors''' results = [] for probe in self.probes: results.extend(probe()) self.submit(results) def submit(self, results): '''publish results to listeners''' for listener in self.listeners: listener.submit(results)
def start_scheduler(event): sched = Scheduler() sched.start() sched.add_interval_job(manage_queue, kwargs={'settings': event.app.registry.settings}, seconds=2)
def schedule(file_name, n_jobs, frequency): '''Schedule the scraper to execute every hour and shut it down after a certain number of jos have been run''' # Create a default logger basicConfig() # Run the first job scrape(file_name) # Instantiate the scheduler sched = Scheduler() # Start it sched.start() # Schedule the function sched.add_interval_job(scrape, args=[file_name], minutes=frequency, misfire_grace_time=60) # Wait to run n_jobs (assuming 1 job per hour, which is 3600 seconds) sleep(n_jobs * 3600) # Shutdown the scheduler sched.shutdown()
def main(): log.info("BLI Monitor starting...") #check_pid() bli = BLIMonitor() spot = SpotMonitor() sched = Scheduler(daemonic=False) #sched.add_listener(err_listener, events.EVENT_ALL) sched.add_interval_job(lambda: bli.check(), seconds=3) sched.add_interval_job(lambda: spot.check(), seconds=3) sched.add_listener( err_listener, events.EVENT_JOB_ERROR | events.EVENT_JOB_EXECUTED | events.EVENT_JOB_MISSED) sched.start() log.info("started") """ while 1: time.sleep(2) monitor.check() """ pass
class IntegrationTestBase(object): def setup(self): self.jobstore = self.make_jobstore() self.scheduler = Scheduler() self.scheduler.add_jobstore(self.jobstore, 'persistent') self.scheduler.start() def test_overlapping_runs(self): # Makes sure that "increment" is only ran once, since it will still be # running when the next appointed time hits. vals = [0] self.scheduler.add_interval_job(increment, jobstore='persistent', seconds=1, args=[vals, 2]) sleep(2.5) eq_(vals, [1]) def test_max_instances(self): vals = [0] events = [] self.scheduler.add_listener(events.append, EVENT_JOB_EXECUTED | EVENT_JOB_MISSED) self.scheduler.add_interval_job(increment, jobstore='persistent', seconds=0.3, max_instances=2, max_runs=4, args=[vals, 1]) sleep(2.4) eq_(vals, [2]) eq_(len(events), 4) eq_(events[0].code, EVENT_JOB_MISSED) eq_(events[1].code, EVENT_JOB_MISSED) eq_(events[2].code, EVENT_JOB_EXECUTED) eq_(events[3].code, EVENT_JOB_EXECUTED)
def app(global_config, **settings): """ This function returns a WSGI application. It is usually called by the PasteDeploy framework during ``paster serve``. """ zcml_file = settings.get('configure_zcml', 'configure.zcml') db_string = settings.get('db_string') if db_string is None: raise ValueError("No 'db_string' value in application configuration.") initialize_sql(db_string) config = Configurator(root_factory=get_root, settings=settings) config.begin() config.load_zcml(zcml_file) config.end() # Ugly hack to configure the MapperExtension with the settings. removal_extension.path = settings.get('upload_directory') scheduler = Scheduler() # Send out queued mails from eportfolio.utilities.mail_delivery import trigger_queued_delivery scheduler.add_interval_job(trigger_queued_delivery, seconds=30) scheduler.start() return config.make_wsgi_app()
class IsItWar(Plugin): def __init__(self, skype): super(IsItWar, self).__init__(skype) self.falseMessages =["The world is still safe, Russia has not declared war yet", "http://suptg.thisisnotatrueending.com/archive/29138254/images/1388285593271.jpg", "http://www.meh.ro/original/2010_03/meh.ro3771.jpg", "http://d24w6bsrhbeh9d.cloudfront.net/photo/arpBmWp_700b_v1.jpg", "http://d24w6bsrhbeh9d.cloudfront.net/photo/aXb2VAv_700b.jpg", "http://d24w6bsrhbeh9d.cloudfront.net/photo/aLKXd6v_700b.jpg"] self.sched = Scheduler() self.sched.start() self.sched.add_interval_job(self.is_it_war, minutes=10) self.command = "isitwaryet" def message_received(self, args, status, msg): res = urllib.urlopen("http://www.bbc.co.uk/news") text = res.read() if "declares war" in text.lower(): msg.Chat.SendMessage("Brace your selves, mother Russia is coming") else: msg.Chat.SendMessage(choice(self.falseMessages)) def is_it_war(self): print "checking if war" res = urllib.urlopen("http://www.bbc.co.uk") text = res.read() if "declares war" in text.lower(): chat = self.skype.Chat("#stigrk85/$jvlomax;b43a0c90a2592b9b") chat.SendMessage("Brace yourself, Mother Russia is coming") def help(self, msg): msg.Chat.SendMessage("usage: @isitwaryet\nWill tell you if Russia has declared war")
def app(global_config, **settings): """ This function returns a WSGI application. It is usually called by the PasteDeploy framework during ``paster serve``. """ zcml_file = settings.get('configure_zcml', 'configure.zcml') db_string = settings.get('db_string') if db_string is None: raise ValueError("No 'db_string' value in application configuration.") initialize_sql(db_string) config = Configurator(root_factory=get_root, settings=settings) config.begin() config.load_zcml(zcml_file) config.end() # Ugly hack to configure the MapperExtension with the settings. removal_extension.path = settings.get('upload_directory') scheduler = Scheduler() # Send out queued mails from eportfolio.utilities.mail_delivery import trigger_queued_delivery scheduler.add_interval_job(trigger_queued_delivery, seconds=30) scheduler.start() return config.make_wsgi_app()
def watchlist(request): #Handle file upload global location if 'import' in request.POST: form = DocumentForm(request.POST, request.FILES) if form.is_valid(): newdoc = Document(docfile=request.FILES['docfile']) newdoc.save() location = newdoc.path() # Redirect to the document list after POST return HttpResponseRedirect(reverse('scraper.views.watchlist')) else: form = DocumentForm() # An empty, unbound form if 'match' in request.POST: call_command('readfile', location) sched = Scheduler(standalone=True) def match_sched(): call_command('readfile', location) sched.add_interval_job(match_sched, seconds=20, max_instances=1000) sched.start() # Load documents for the list page documents = Document.objects.all() # Render list page with the documents and the form return render_to_response('scraper/index2.0.html', { 'documents': documents, 'form': form }, context_instance=RequestContext(request))
def schedule(self): sched = Scheduler() sched.add_interval_job(self.resetcounter, minutes=self.duration) sched.start() logging.info( "Artemis scheduler, which resets global counter and sends data on hpfeeds, started at %s, executes every %d minutes " % (datetime.datetime.now(), self.duration))
def schedule(file_name, n_jobs, frequency): '''Schedule the scraper to execute every hour and shut it down after a certain number of jos have been run''' # Create a default logger basicConfig() # Run the first job scrape(file_name) # Instantiate the scheduler sched = Scheduler() # Start it sched.start() # Schedule the function sched.add_interval_job(scrape, args=[file_name], minutes=frequency, misfire_grace_time=60) # Wait to run n_jobs (assuming 1 job per hour, which is 3600 seconds) sleep(n_jobs * 3600) # Shutdown the scheduler sched.shutdown()
def main(): config_file = "config.xml" xml = ET.parse(config_file) HOST_NAME = xml.find('host_name').text DB_NAME = xml.find('db_name').text DISPLAY_ADDR = xml.find("display_addr").text DISPLAY_PORT = int(xml.find('display_port').text) ENDPOINT = xml.find("endpoint").text SECONDS = int(xml.find("seconds").text) USERNAME = xml.find("username").text PASSWORD = xml.find("password").text HOST = 'http://'+ USERNAME+ ':'+ PASSWORD + '@'+ HOST_NAME print "starting ..." #print HOST, DB_NAME, DISPLAY_ADDR, DISPLAY_PORT #readData(HOST, DB_NAME, DISPLAY_ADDR, DISPLAY_PORT) display = LedDisplay(HOST, DB_NAME, DISPLAY_ADDR, DISPLAY_PORT, ENDPOINT) # Start the scheduler sched = Scheduler() sched.add_interval_job(display.query, seconds=SECONDS ) sched.start() try: while True: time.sleep(0.1) except KeyboardInterrupt: print "terminating" sched.shutdown()
def startScheduler(): schedule = Scheduler() schedule.add_interval_job(doCleanUp, days=1) schedule.start() print 'Scheduler has started.' while True: time.sleep(5)
class IntegrationTestBase(object): def setup(self): self.jobstore = self.make_jobstore() self.scheduler = Scheduler() self.scheduler.add_jobstore(self.jobstore, 'persistent') self.scheduler.start() def test_overlapping_runs(self): # Makes sure that "increment" is only ran once, since it will still be # running when the next appointed time hits. vals = [0] self.scheduler.add_interval_job(increment, jobstore='persistent', seconds=1, args=[vals, 2]) sleep(2.5) eq_(vals, [1]) def test_max_instances(self): vals = [0] events = [] self.scheduler.add_listener(events.append, EVENT_JOB_EXECUTED | EVENT_JOB_MISSED) self.scheduler.add_interval_job(increment, jobstore='persistent', seconds=0.3, max_instances=2, max_runs=4, args=[vals, 1]) sleep(2.4) eq_(vals, [2]) eq_(len(events), 4) eq_(events[0].code, EVENT_JOB_MISSED) eq_(events[1].code, EVENT_JOB_MISSED) eq_(events[2].code, EVENT_JOB_EXECUTED) eq_(events[3].code, EVENT_JOB_EXECUTED)
def main(): log.info( "BLI Monitor starting..." ) #check_pid() bli = BLIMonitor() spot = SpotMonitor() sched = Scheduler(daemonic = False) #sched.add_listener(err_listener, events.EVENT_ALL) sched.add_interval_job(lambda:bli.check(), seconds=3) sched.add_interval_job(lambda:spot.check(), seconds=3) sched.add_listener(err_listener, events.EVENT_JOB_ERROR | events.EVENT_JOB_EXECUTED| events.EVENT_JOB_MISSED) sched.start() log.info( "started" ) """ while 1: time.sleep(2) monitor.check() """ pass
class ClientScheduler(Observable): def __init__(self): global DeviceClientInstance self.scheduler = Scheduler() self.scheduler.start() self.wifi_job = WifiActiveCampaignCron.run self.bt_job = BluetoothActiveCampaignCron.run self.log_job = LogRotation.run self.status_job = StatusAPI.run # Schedule Status API self.addSecondSchedule(self.status_job, newschedule_secs=15) # Schedule Wi-Fi Job self.addMinuteSchedule(self.wifi_job, newschedule_mins=1) # Schedule BT Job self.addMinuteSchedule(self.bt_job, newschedule_mins=1) # Schedule Log Rotation Job, rotation doesn't always happen when this job runs self.addMinuteSchedule(self.log_job, newschedule_mins=1) def addMinuteSchedule(self, job, newschedule_mins): self.scheduler.add_interval_job(job, minutes=newschedule_mins) def addSecondSchedule(self, job, newschedule_secs): self.scheduler.add_interval_job(job, seconds=newschedule_secs)
def __init__(self): logging.basicConfig(filename=str(app.config['CONFIG']['logfile']),level=logging.INFO) sched = Scheduler(daemon=True) sched.start() sched.add_interval_job(lambda: self.fetch_report_by_interval(), hours=int(app.config['CONFIG']['scheduler']['hourly_interval'])) while True: pass
def initialize(): apsched = Scheduler() apsched.start() apsched.add_interval_job(syncFacebookEvents, seconds=10) print "added job 1" apsched.add_interval_job(syncSharedEvents, seconds=10) print "added job 2"
def schedule(): sched = Scheduler() duration = server.shivaconf.getint('analyzer', 'schedulertime') sched.add_interval_job(resetcounter, minutes=duration) sched.start() logging.info( "Shiva scheduler, which dumps data into maindb, resets global counter and sends data on hpfeeds, started at %s and would execute every %d minutes " % (datetime.datetime.now(), duration))
class ScheduledLoad(): def __init__(self, store): self.loader = Loader(store) self.sched = Scheduler() self.sched.start() def load(self): self.sched.add_interval_job(self.loader.load_all, minutes=5)
def run_scheduler(app): scheduler = Scheduler() expire_wrapper = lambda: expire_sessions(app) scheduler.add_interval_job(expire_wrapper, seconds=EXPIRE_SESSION_EVERY) scheduler.start() print "APScheduler started successfully"
def start_scheduled_jobs(): sched = Scheduler() sched.start() # add scheduler jobs below if app.config.get('IS_PRODUCTION'): sched.add_interval_job(sqldump_job, days=1)
class AdvancedPythonScheduler(object): def __init__(self): self.scheduler = Scheduler() self.scheduler.start() def schedule_interval_task(self, action, weeks=0, days=0, hours=0, minutes=0, seconds=0): self.scheduler.add_interval_job(action, weeks, days, hours, minutes, seconds)
def runScheduler(self, interval, periodicMovingWindow): self.currentPlatform.logger.info("Started Scheduler.") sched = Scheduler() sched.add_interval_job(self.scheduledJob1, minutes=interval) sched.start() while True: pass self.logger.info("Finished Scheduler.")
def dev_server(): trainer = Process(target=train_classifier, args=[classifier]) trainer.start() sched = Scheduler() sched.start() sched.add_interval_job(dump_classifier, args=[classifier], hours=1) app.run(debug=True)
def bootstrap(self): """Bootstraps the static inventory writer background job""" self.write_static_inventory() logging.basicConfig() interval = self.config['interval'] sched = Scheduler() sched.start() sched.add_interval_job(self.write_static_inventory, seconds=interval)
def runScheduler(self, interval, periodicMovingWindow): self.currentPlatform.logger.info("Started Scheduler.") sched = Scheduler() sched.add_interval_job(self.scheduledJob1, minutes=interval) sched.start() while True: pass self.logger.info("Finished Scheduler.")
def bootstrap(self): """Bootstraps the static inventory writer background job""" self.rm_sitemap_files(Source.STATIC_FILE_PATH) self.write_static_inventory() logging.basicConfig() interval = self.config['interval'] sched = Scheduler() sched.start() sched.add_interval_job(self.write_static_inventory, seconds=interval)
def scheduleEmailListener(username,password,response_subject,automated_response): logging.basicConfig() scheduler=Scheduler() scheduler.start() scheduler.add_interval_job(respondToEmails,minutes=1,args=[username,password,response_subject,automated_response]) mongo.deleteEntry("fields","main",{}) mongo.addEntry("fields","main",{"email":username,"password":password}) atexit.register(lambda:scheduler.shutdown(wait=False)) return scheduler
class Application(object): def __init__(self): self.books = [] self.logger = logging.getLogger(__name__) self.scheduler = Scheduler() self.scheduler.add_interval_job(self.process_book_list, seconds=30) self.store = AmazonStore() self.notifier = NotifyMyAndroid(bookworm.NOTIFICATION_KEY) self.load() def load(self): if os.path.exists('books.dat'): with open('books.dat', 'rb') as f: self.books = pickle.load(f) self.logger.debug('Loaded {0} books'.format(len(self.books))) def save(self): if(len(self.books) > 0 ): with open('books.dat', 'wb') as f: self.logger.debug('Saving books') pickle.dump(self.books, f, -1) def start(self): self.logger.info('Starting application') self.scheduler.start() def stop(self): self.logger.info('Stopping application') self.save() self.scheduler.shutdown() def process_book_list(self): self.logger.info('Processing book list') for book in self.books: self.logger.debug('Updating price for {0}'.format(book.title)) latestPrice = self.store.get_book_price(book.isbn) self.logger.debug('latest: {0}, saved: {1}'.format(latestPrice, book.current_price)) if latestPrice != None and latestPrice != book.current_price: if latestPrice < book.current_price: self.logger.debug('Found a lower price!') self.notifier.send_notification(self.build_notification_message(latestPrice, book.title, self.store.get_product_url(book.isbn)), 'Price Update') book.current_price = latestPrice def build_notification_message(self, price, title, productUrl): return (u'{0} is now £{1}\n{2}'.format(title, price, productUrl)) def get_resolver(self): return self.store.get_book_details def register_new_book(self, book): self.books.append(book)
def watch_remote_git(self): ''' Monitor a remote git repository by polling at a set interval. ''' sched = Scheduler() sched.start() sched.add_interval_job(sync_remote_git, seconds=30, args=[self.repo, self.config]) self._watch()
def bootstrap(self): """Bootstraps the static inventory writer background job""" self.rm_sitemap_files(Source.STATIC_FILE_PATH) self.write_static_inventory() logging.basicConfig() interval = self.config['interval'] sched = Scheduler() sched.start() sched.add_interval_job(self.write_static_inventory, seconds=interval)
def schedule(): """Schedule a timer before the counter of relayed emails is reset.""" sched = Scheduler() duration = utils.settings.data["relay"]["schedulertime"] sched.add_interval_job(resetcounter, minutes=duration) sched.start() logging.info( "[+] (salmonscheduler.py) - Salmon scheduler started at %s and will execute every %d minutes " % (datetime.datetime.now(), duration) )
def main(): global exit_flag sched = Scheduler() sched.start() sched.add_interval_job(run_once, minutes=FREQUENCE_MINUTES) while True: if exit_flag: exit() time.sleep(10)
def __init__(self, profile): self.q = Queue.Queue() self.profile = profile self.notifiers = [ self.NotificationClient(self.handleEmailNotifications, None), ] sched = Scheduler() sched.start() sched.add_interval_job(self.gather, seconds=30)
def __init__(self, profile): self.q = Queue.Queue() self.profile = profile self.notifiers = [ self.NotificationClient(self.handleEmailNotifications, None), ] sched = Scheduler() sched.start() sched.add_interval_job(self.gather, seconds=30)
class HeartBeat(Singleton): def __init__(self): self.scheduler = Scheduler() credentials = pika.PlainCredentials('inspur', 'inspur') flag, rabbitmq_ip = utils.getRabbitmqIp() # 这里可以连接远程IP,请记得打开远程端口 parameters = pika.ConnectionParameters(rabbitmq_ip, 5672, '/', credentials) self.connection = pika.BlockingConnection(parameters) self.channel = self.connection.channel() """ heartbeat task """ def agentHeartBeat(self): logger.debug("agent heart beat begin!") self.scheduler.add_interval_job(self.heartBeatWithServer, seconds=3) self.scheduler.start() print('Press Ctrl+{0} to exit'.format('Break' if os.name == 'nt' else 'C')) try: while True: if not utils.httpdstate: sys.exit(0) except KeyboardInterrupt: self.scheduler.shutdown() finally: self.connection.close() def heartBeatWithServer(self): agentInfo = {'type': constr.NODE_STATUS, 'token': constr.NODE_TOKEN} flag, agentid = utils.getAgentId() if not (flag and agentid): return agentInfo['id'] = agentid logger.debug("node hb info : {}".format(str(agentInfo))) try: self.channel.basic_publish(exchange='exchangeTest', routing_key='heartBeatKey', body=json.dumps(agentInfo)) except Exception, e: logger.error("heartbeat exception: {}".format(e.message)) credentials = pika.PlainCredentials('inspur', 'inspur') flag, rabbitmq_ip = utils.getRabbitmqIp() # 这里可以连接远程IP,请记得打开远程端口 parameters = pika.ConnectionParameters(rabbitmq_ip, 5672, '/', credentials) self.connection = pika.BlockingConnection(parameters) self.channel = self.connection.channel() pass return True
def main(): logging.basicConfig() sched = Scheduler(standalone=True) latitude = 39.49 longitude = -87.31 w = ContentWeather(latitude, longitude) c = ContentCountdown(31, 5, 2014, 11, 00) contentToDisplay = [w, c] contentProvider = ContentProvider(contentToDisplay) sched.add_interval_job(updateContent, args=[contentProvider], seconds=30) sched.start()
def server(): trainer = Process(target=train_classifier, args=[classifier]) trainer.start() sched = Scheduler() sched.start() sched.add_interval_job(dump_classifier, args=[classifier], hours=1) http_server = HTTPServer(WSGIContainer(app)) http_server.listen(5000) IOLoop.instance().start()
def main(): logging.basicConfig() sched = Scheduler(standalone=True) latitude = 39.49 longitude = -87.31 w = ContentWeather(latitude, longitude) c = ContentCountdown(31,5,2014,11,00) contentToDisplay = [w, c] contentProvider = ContentProvider(contentToDisplay) sched.add_interval_job(updateContent, args = [contentProvider], seconds = 30) sched.start()
def __init__(self, profile): self.q = Queue.Queue() self.profile = profile self.notifiers = [] if 'gmail_address' in profile and 'gmail_password' in profile: self.notifiers.append(self.NotificationClient(self.handleEmailNotifications, None)) sched = Scheduler() sched.start() sched.add_interval_job(self.gather, seconds=30)
def main(): in_daemon_mode = conf.alarm_send_in_daemon_mode if not in_daemon_mode: check() else: from apscheduler.scheduler import Scheduler minuteScheduler = Scheduler() sleep_seconds = 60 # just 60 seconds minuteScheduler.add_interval_job(check, seconds=sleep_seconds) minuteScheduler.start() while 1: time.sleep(9999) minuteScheduler.shutdown()
def run(self): scheduler = Scheduler() if self.config["SCHEDULE"].get("packages") is not None: scheduler.add_interval_job(self.processor.process, **self.config["SCHEDULE"]["packages"]) scheduler.start() try: while True: time.sleep(999) except KeyboardInterrupt: logger.info("Shutting down Carrier...") scheduler.shutdown(wait=False)
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()
def __init__(self, profile): self._logger = logging.getLogger(__name__) self.q = Queue.Queue() self.profile = profile self.notifiers = [] 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') sched = Scheduler() sched.start() sched.add_interval_job(self.gather, seconds=30)
class Timer: def __init__(self, fieldCanvas, field): #self.sched = BackgroundScheduler() self.sched = Scheduler() self.sched.start() self.timerValue = 0 self.fieldCanvas = fieldCanvas self.field = field def updateTimerValue(self): self.timerValue += 1 minutes = "0" + str(int(self.timerValue/60)) if int(self.timerValue/60) < 9 else str(int(self.timerValue/60)) secondes = "0" + str(self.timerValue%60) if self.timerValue%60 < 9 else str(self.timerValue%60) timerString = minutes + ":" + secondes self.fieldCanvas.itemconfigure(self.field ,text=timerString) def getTimer(self): return self.timerValue def startTimer(self): #job = self.sched.add_job(self.updateTimerValue, 'interval', seconds = 1) job = self.sched.add_interval_job(self.updateTimerValue, seconds = 1) pass def stopTimer(self): try: model.user.setScore(self.getTimer()) self.sched.shutdown(wait=False) except Exception as e: #print(e) pass
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()
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
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 WebCheckScheduler(object): def __init__(self, app, dbservice): self.dbservice = dbservice self.sched = None self.url_check = URLCheck() notificator_email = app.config['NOTIFICATOR_EMAIL'] notificator_user = app.config['NOTIFICATOR_USER'] notificator_password = app.config['NOTIFICATOR_PASSWORD'] notificator_mail_server = app.config['NOTIFICATOR_MAIL_SERVER'] self.notificator_email_to = app.config['NOTIFICATOR_EMAIL_TO'] self.mail_sender = MailSender(notificator_email, notificator_user, notificator_password, notificator_mail_server) def main_job(self): websites = self.dbservice.query_db('SELECT * FROM sites') if len(websites) != 0: for website in websites: url = website['url'] webid = website['id'] status_code = self.url_check.get_url_status(url) last_check = datetime.now().strftime('%Y-%m-%d %H:%M:%S') self.dbservice.execute_db('UPDATE sites SET last_check=?, status_code=? WHERE id=?', [last_check, status_code, webid]) if status_code != '200': title = "Notification : " + url message = "Web site is offline..." self.mail_sender.send_message(self.notificator_email_to, title, message) self.dbservice.execute_db('UPDATE dbutil SET db_code=? WHERE id=?', [1, 1]) def change_interval(self, interval_seconds): self.sched.shutdown() self.start(interval_seconds) def start(self, interval_seconds): self.sched = Scheduler() self.sched.start() self.sched.add_interval_job(self.main_job, seconds = interval_seconds)