def __init__(self, config, activate=False): super(AuctionsDataBridge, self).__init__() self.config = config self.tenders_ids_list = [] self.activate = activate self.client = ApiClient( '', host_url=self.config_get('tenders_api_server'), api_version=self.config_get('tenders_api_version')) params = {'opt_fields': 'status,auctionPeriod', 'mode': '_all_'} if parse_version( self.config_get('tenders_api_version')) > parse_version('0.9'): params['opt_fields'] += ',lots' self.client.params.update(params) self.tz = tzlocal() self.couch_url = urljoin(self.config_get('couch_url'), self.config_get('auctions_db')) self.db = Database(self.couch_url, session=Session(retry_delays=range(10))) if self.activate: self.queue = Queue() self.scheduler = GeventScheduler() self.scheduler.add_job(self.run_systemd_cmds, 'interval', max_instances=1, minutes=2, id='run_systemd_cmds') self.scheduler.start()
def __init__(self, irc_c, config): self.config = config self.scheduler = GeventScheduler() self._scheduler_greenlet = self.scheduler.start() log_propagation_message = partial( irc_c.PRIVMSG, CONFIG.external['propagation']['logging']['channel'], ) # Scheduled full wiki update self.scheduler.add_job( Propagate.get_wiki_data, 'cron', kwargs={'reply': log_propagation_message}, **self.cron_to_kwargs( CONFIG.external['propagation']['all_articles']['often']), ) # Scheduled recent pages update self.scheduler.add_job( Propagate.get_wiki_data, 'cron', kwargs={ 'reply': log_propagation_message, 'seconds': 259200 }, **self.cron_to_kwargs( CONFIG.external['propagation']['new_articles']['often']), )
def setup_schedule_config(self, endpoint_explorer, node_address): scheduler = GeventScheduler() scheduler.add_job( lambda: notice_explorer_to_be_alive(endpoint_explorer, node_address), 'interval', minutes=30) scheduler.start()
def create_scheduler(self): self.scheduler = GeventScheduler( job_defaults={ 'coalesce': False, 'max_instances': max_instances } )
def __init__(self, name='defaultController', workflows_path=core.config.paths.workflows_path): """Initializes a Controller object. Args: name (str, optional): Name for the controller. workflows_path (str, optional): Path to the workflows. """ self.name = name self.workflows = {} self.workflow_status = {} self.load_all_workflows_from_directory(path=workflows_path) self.instances = {} self.tree = None self.scheduler = GeventScheduler() self.scheduler.add_listener(self.__scheduler_listener(), EVENT_SCHEDULER_START | EVENT_SCHEDULER_SHUTDOWN | EVENT_SCHEDULER_PAUSED | EVENT_SCHEDULER_RESUMED | EVENT_JOB_ADDED | EVENT_JOB_REMOVED | EVENT_JOB_EXECUTED | EVENT_JOB_ERROR) self.ancestry = [self.name] def workflow_completed_callback(sender, **kwargs): self.__workflow_completed_callback(sender, **kwargs) callbacks.WorkflowShutdown.connect(workflow_completed_callback)
def run(self): """Start apscheduler tasks""" jobstores = {'mongo': MongoDBJobStore()} executors = { 'default': ThreadPoolExecutor(self.poolsize), 'processpool': ProcessPoolExecutor(self.procsize) } job_defaults = {'coalesce': False, 'max_instances': 3} scheduler = GeventScheduler() scheduler.configure(jobstores=jobstores, executors=executors, job_defaults=job_defaults, timezone=utc) scheduler.add_job(self.job_worker, 'interval', seconds=0.001) green_let = scheduler.start() print('Ctrl+{0} to exit.'.format('Break' if os.name == 'nt' else 'C')) # Execution will block here util Ctrl+C (Ctrl+Break on Windows). try: green_let.join() except (KeyboardInterrupt, SystemExit): pass
def setup_schedule_config(self, endpoint_explorer, discoverable, node_address, raiden_instance): scheduler = GeventScheduler() scheduler.add_job(lambda: notice_explorer_to_be_alive( endpoint_explorer, discoverable, node_address, raiden_instance), 'interval', minutes=30) scheduler.start()
def __init__(self): self.scheduler = GeventScheduler() self.scheduler.add_listener(self.__scheduler_listener(), EVENT_SCHEDULER_START | EVENT_SCHEDULER_SHUTDOWN | EVENT_SCHEDULER_PAUSED | EVENT_SCHEDULER_RESUMED | EVENT_JOB_ADDED | EVENT_JOB_REMOVED | EVENT_JOB_EXECUTED | EVENT_JOB_ERROR) self.id = 'controller' self.app = None
def nsGevent(ns, *args, **kw): ns.V("/sys/scheduler", GeventScheduler()) s = nsGet(ns, "/sys/scheduler").value nsSchedulerIntervalJob(ns, 60, "/dev/time", nsGeventTick) g = s.start() nsProcAlloc(ns, "scheduler", g, scheduler=s) glist = nsGet(ns, "/sys/greenlets").value glist.append(g) return True
def __init__(self, scheduler=None): if scheduler is None: try: from apscheduler.schedulers.gevent import GeventScheduler self._scheduler = GeventScheduler() except ImportError: self._scheduler = BackgroundScheduler() else: self._scheduler = scheduler
def GeventScheduler_test(): sched = GeventScheduler() sched.add_job(tick, 'interval', seconds=3) g = sched.start() print('Press Ctrl+{0} to exit'.format('Break' if os.name == 'nt' else 'C')) try: g.join() except (KeyboardInterrupt, SystemExit): pass
def deactivate_player(self, player): player.active = False scheduler = GeventScheduler() timeout_date = datetime.now() + timedelta(seconds=PLAYER_TIMEOUT) scheduler.add_job(self.delete_player, 'date', run_date=timeout_date, args=[player]) g = scheduler.start() g.join()
def __init__(self, socketio): self.__socketio = socketio self.__jobs = {} self.__tiles = {} self.__cache = {} executors = { 'default': {'type': 'threadpool', 'max_workers': 20} } self.__scheduler = GeventScheduler(executors=executors)
def __init__(self, name, producers=1, interval=5, delay=0, scheduler=None, *args, **kwargs): self.interval = self._parse_interval(interval) self.delay = delay self.producers = producers self.scheduler = scheduler if not self.scheduler: self.scheduler = GeventScheduler()
def _init_scheduler(self, producers=1, interval=5, delay=0, scheduler=None, interval_grace_time=None, *args, **kwargs): self.interval = self._parse_interval(interval) self.delay = delay self.producers = producers self.scheduler = scheduler if not self.scheduler: self.scheduler = GeventScheduler( job_defaults={'misfire_grace_time': interval_grace_time})
def register_schedule(minutes=0): minutes = minutes or 60 scheduler = GeventScheduler() func = ansible_inventory_patrol name = func.__name__ job_id = '5db150f3e3f7e0677091329f' if scheduler.state != 1: scheduler.start() job = scheduler.get_job(job_id=job_id) if not job: scheduler.add_job(func=func, trigger='interval', minutes=minutes, name=name, id=job_id)
def watch(): scheduler = GeventScheduler() for web in watchweb.get_watch_webs(): s = int(web[watchweb.INTERVAL_SECONDS]) scheduler.add_job(check_web, 'interval', seconds=s,kwargs=web) g = scheduler.start() # g is the greenlet that runs the scheduler loop print('Press Ctrl+{0} to exit'.format('Break' if os.name == 'nt' else 'C')) # Execution will block here until Ctrl+C (Ctrl+Break on Windows) is pressed. try: g.join() except (KeyboardInterrupt, SystemExit): pass
def gevent_schedule(): from apscheduler.schedulers.gevent import GeventScheduler def tick(): print('Tick! The time is: %s' % datetime.now()) scheduler = GeventScheduler() scheduler.add_job(tick, 'interval', seconds=3) g = scheduler.start() # g is the greenlet that runs the scheduler loop print('Press Ctrl+{0} to exit'.format('Break' if os.name == 'nt' else 'C')) # Execution will block here until Ctrl+C (Ctrl+Break on Windows) is pressed. try: g.join() except (KeyboardInterrupt, SystemExit): pass
def __init__(self, scheduler): ''' https://apscheduler.readthedocs.io/en/latest/userguide.html?highlight=add_job Parameters ---------- scheduler: [str] 调度器,根据开发需求选择相应的调度器 'BlockingScheduler' 阻塞式调度器: 适用于只跑调度器的程序 'BackgroundScheduler' 后台调度器: 适用于非阻塞的情况,调度器会在后台独立运行 'AsyncIOScheduler' AsyncIO调度器: 适用于应用使用AsnycIO的情况 'GeventScheduler' Gevent调度器: 适用于应用通过Gevent的情况 'TornadoScheduler' Tornado调度器: 适用于构建Tornado应用 'TwistedScheduler' Twisted调度器: 适用于构建Twisted应用 'QtScheduler' Qt调度器: 适用于构建Qt应用 ''' import logging logging.basicConfig() scheduler = str(scheduler).lower() if ('blocking' in scheduler): from apscheduler.schedulers.blocking import BlockingScheduler self.scheduler = BlockingScheduler() elif ('background' in scheduler): from apscheduler.schedulers.background import BackgroundScheduler self.scheduler = BackgroundScheduler() elif ('asyncio' in scheduler): from apscheduler.schedulers.asyncio import AsyncIOScheduler self.scheduler = AsyncIOScheduler() elif ('gevent' in scheduler): from apscheduler.schedulers.gevent import GeventScheduler self.scheduler = GeventScheduler() elif ('tornado' in scheduler): from apscheduler.schedulers.tornado import TornadoScheduler self.scheduler = TornadoScheduler() elif ('twisted' in scheduler): from apscheduler.schedulers.twisted import TwistedScheduler self.scheduler = TwistedScheduler() elif ('qt' in scheduler): from apscheduler.schedulers.qt import QtScheduler self.scheduler = QtScheduler()
def __init__(self): print "init Task Manager" self.logger = logging.getLogger('dls') executors = { 'default': ThreadPoolExecutor(config.EXECUTOR_THREADS_NUMBER), 'monitor': GeventExecutor(), } self.scheduler = GeventScheduler(executors=executors) self.scheduler.start() # Map of tasks for tracking them on UI self.tasks = {} self.scheduler.add_job(self.report_progress, 'interval', seconds=config.JOB_MONITOR_INTERVAL, executor='monitor')
def __init__(self, args): #(jobstores=jobstores, executors=executors, job_defaults=job_defaults, timezone=utc) #self.sched = GeventScheduler( executors=executors) try: if args is None or (args is not None and args.use_gevent): from apscheduler.schedulers.gevent import GeventScheduler self.sched = GeventScheduler(timezone='Asia/Seoul') else: raise Exception('') except: from apscheduler.schedulers.background import BackgroundScheduler self.sched = BackgroundScheduler(timezone='Asia/Seoul') #jobstores=jobstores, 에러 pickle 직렬화 할수없다 #self.sched.configure(executors=executors, job_defaults=job_defaults, timezone='Asia/Seoul') #self.sched.configure(executors=executors, timezone='Asia/Seoul') self.sched.start() logger.debug('SCHEDULER..')
def production(*_, **settings): """Hooks exceptions and returns the Flask app.""" hook_exceptions() app.shiptoasts = ShipToasts() app.shiptoasts.initial_fill() scheduler = GeventScheduler() scheduler.add_job(app.shiptoasts.periodic_call, "interval", seconds=30) cleaner = scheduler.start() listener = gevent.Greenlet.spawn(app.shiptoasts.listen_for_updates) atexit.register(cleaner.join, timeout=2) atexit.register(listener.join, timeout=2) atexit.register(scheduler.shutdown) return app
def __init__(self, name, event_class=Event, event_kwargs=None, producers=1, interval=5, delay=0, generate_error=False, *args, **kwargs): super(EventGenerator, self).__init__(name, *args, **kwargs) self.blockdiag_config["shape"] = "flowchart.input" self.generate_error = generate_error self.interval = self._parse_interval(interval) self.delay = delay self.event_kwargs = event_kwargs or {} self.output = event_class self.producers = producers self.scheduler = GeventScheduler()
def __init__(self, name="defaultController"): self.name = name self.workflows = {} self.load_all_workflows_from_directory() self.instances = {} self.tree = None self.eventlog = [] self.schedulerStatusListener = SchedulerStatusListener(self.eventlog) self.jobStatusListener = JobStatusListener(self.eventlog) self.jobExecutionListener = JobExecutionListener(self.eventlog) self.scheduler = GeventScheduler() self.scheduler.add_listener( self.schedulerStatusListener.callback(self), EVENT_SCHEDULER_START | EVENT_SCHEDULER_SHUTDOWN | EVENT_SCHEDULER_PAUSED | EVENT_SCHEDULER_RESUMED) self.scheduler.add_listener(self.jobStatusListener.callback(self), EVENT_JOB_ADDED | EVENT_JOB_REMOVED) self.scheduler.add_listener(self.jobExecutionListener.callback(self), EVENT_JOB_EXECUTED | EVENT_JOB_ERROR) self.ancestry = [self.name]
def nsGevent(ns, *args, **kw): job_conf = {'max_instances': nsGet(ns, "/etc/maxScheduleJobs", 10)} nsMkdir(ns, "/proc") nsSet(ns, "/dev/time", time.time()) nsSet(ns, "/sys/greenlets", []) nsSet(ns, "/sys/greenlets.user", []) nsSet(ns, "/sys/greenlets.kill", False) nsSet(ns, "/sys/scheduler", GeventScheduler()) s = nsGet(ns, "/sys/scheduler") nsSchedulerIntervalJob(ns, 60, "/dev/time", nsGeventTick) g = s.start() ns = nsProcAlloc(ns, "scheduler", g, scheduler=s) glist = nsGet(ns, "/sys/greenlets") glist.append(g) nsMk(ns, "queue") f(ns, "/dev/queue/open")("shell") if nsGet(ns, "/etc/console") is True: nsDaemon(ns, "ConsoleHandler", nsConsoleDaemon, ns) if nsGet(ns, "/etc/log") is True: nsDaemon(ns, "LogHandler", nsLogDaemon, ns) return ns
def __init__(self, name): super().__init__(name) self._commands = {} # cmd_id : command # self._jobstores = {'default': SQLAlchemyJobStore(url=constants.scheduler_database_url, # tablename="jobs")} self._jobstores = {} self._executors = {} self._job_defaults = { 'max_instances': 10, 'coalesce': True, } self._triggers = {} # cmd_id : trigger self._scheduler = GeventScheduler( jobstores=self._jobstores, executors=self._executors, job_defaults=self._job_defaults, timezone=pytz.utc, # TODO: make user configurable ) self._schedulers.add(self) s_cmds = constants.internaldb.scheduler_commands.get({}) v = s_cmds.setdefault(self.identifier(), {}) if not v: constants.internaldb.scheduler_commands.set(s_cmds)
def setup_tasks(self): """ Setup all tasks that run periodically. """ self.scheduler = GeventScheduler() # Add an initial job def _job(): job.remove() self.synchronize(synchronization="startup") job = self.scheduler.add_job(_job, max_instances=1, trigger="interval", seconds=1) # Scheduler task to clean and expire the cache. cache_interval = self.config['Provider']['item cache prune interval'] self.scheduler.add_job(self.cache_manager.expire, max_instances=1, trigger="interval", minutes=cache_interval) self.scheduler.add_job(self.cache_manager.clean, max_instances=1, trigger="interval", minutes=cache_interval) # Schedule tasks to synchronize each connection. for connection in self.connections.itervalues(): self.scheduler.add_job(self.synchronize, args=([connection, "interval"]), max_instances=1, trigger="interval", minutes=connection.synchronization_interval)
def main(): scheduler = GeventScheduler() url = os.environ.get('SQLALCHEMY_DATABASE_URI', 'sqlite:///database.db') scheduler.add_jobstore('sqlalchemy', url=url) scheduler.add_job(tick, 'interval', seconds=3, id='example_job', replace_existing=True) # g is the greenlet that runs the scheduler loop. g = scheduler.start() print('Press Ctrl+{0} to exit'.format('Break' if os.name == 'nt' else 'C')) # Execution will block here until Ctrl+C (Ctrl+Break on Windows) is pressed. try: g.join() except (KeyboardInterrupt, SystemExit): pass
AUCTION_WORKER_SERVICE_AUCTION_CANCELED, AUCTION_WORKER_SERVICE_END_AUCTION, AUCTION_WORKER_SERVICE_START_AUCTION, AUCTION_WORKER_SERVICE_STOP_AUCTION_WORKER, AUCTION_WORKER_SERVICE_PREPARE_SERVER, AUCTION_WORKER_SERVICE_END_FIRST_PAUSE) from openprocurement.auction.esco.utils import (prepare_initial_bid_stage, prepare_results_stage, sorting_start_bids_by_amount, dumps, loads) from openprocurement.auction.utils import\ get_latest_bid_for_bidder, sorting_by_amount, delete_mapping LOGGER = logging.getLogger('Auction Esco') SCHEDULER = GeventScheduler(job_defaults={"misfire_grace_time": 100}, executors={'default': AuctionsExecutor()}, logger=LOGGER) SCHEDULER.timezone = TIMEZONE use(encode=dumps, decode=loads) class Auction(ESCODBServiceMixin, RequestIDServiceMixin, EscoAuditServiceMixin, ESCOBiddersServiceMixin, DateTimeServiceMixin, EscoStagesMixin, EscoPostAuctionMixin): """ESCO Auction Worker Class""" def __init__(self, tender_id, worker_defaults, auction_data={}, lot_id=None):
""" Demonstrates how to use the gevent compatible scheduler to schedule a job that executes on 3 second intervals. """ from datetime import datetime import os from apscheduler.schedulers.gevent import GeventScheduler def tick(): print('Tick! The time is: %s' % datetime.now()) if __name__ == '__main__': scheduler = GeventScheduler() scheduler.add_job(tick, 'interval', seconds=3) g = scheduler.start() # g is the greenlet that runs the scheduler loop print('Press Ctrl+{0} to exit'.format('Break' if os.name == 'nt' else 'C')) # Execution will block here until Ctrl+C (Ctrl+Break on Windows) is pressed. try: g.join() except (KeyboardInterrupt, SystemExit): pass