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
