def __init__(self, timer=None):
self.timer = Schedule() if timer is None else timer
self.readers = {}
self.writers = {}
self.on_init = []
self.on_close = []
self.on_task = []
class Hub(object):
READ, WRITE, ERR = READ, WRITE, ERR
def __init__(self, timer=None):
self.fdmap = {}
self.poller = poll()
self.timer = Schedule() if timer is None else timer
def __enter__(self):
return self
def __exit__(self, *exc_info):
return self.close()
def fire_timers(self, min_delay=1, max_delay=10, max_timers=10):
delay = None
if self.timer._queue:
for i in xrange(max_timers):
delay, entry = self.scheduler.next()
if entry is None:
break
self.timer.apply_entry(entry)
return min(max(delay, min_delay), max_delay)
def add(self, fd, callback, flags):
self.poller.register(fd, flags)
try:
fileno = fd.fileno()
except AttributeError:
fileno = fd
self.fdmap[fileno] = callback
def add_reader(self, fd, callback):
return self.add(fd, callback, READ | ERR)
def add_writer(self, fd, callback):
return self.add(fd, callback, WRITE)
def update_readers(self, *maps):
[self.add_reader(*x) for row in maps for x in row.iteritems()]
def update_writers(self, *maps):
[self.add_writer(*x) for row in maps for x in row.iteritems()]
def remove(self, fd):
try:
self.poller.unregister(fd)
except (KeyError, OSError):
pass
def close(self):
[self.remove(fd) for fd in self.fdmap.keys()]
self.poller.close()
@cached_property
def scheduler(self):
return iter(self.timer)
def __init__(self, timer=None):
self.readers = {}
self.writers = {}
self.timer = Schedule() if timer is None else timer
self.on_init = []
self.on_close = []
self.on_task = []
def __init__(self, timer=None):
self.timer = Schedule() if timer is None else timer
self.readers = {}
self.writers = {}
self.on_init = []
self.on_close = []
self.on_task = []
self.consolidate = set()
self.consolidate_callback = None
def create(self, w):
if w.use_eventloop:
# does not use dedicated timer thread.
w.timer = Schedule(max_interval=10.0)
else:
if not w.timer_cls:
# Default Timer is set by the pool, as e.g. eventlet
# needs a custom implementation.
w.timer_cls = w.pool_cls.Timer
w.timer = self.instantiate(w.timer_cls,
max_interval=w.timer_precision,
on_timer_error=self.on_timer_error,
on_timer_tick=self.on_timer_tick)
class Hub(object):
"""Event loop object.
:keyword timer: Specify custom :class:`~celery.utils.timer2.Schedule`.
"""
#: Flag set if reading from an fd will not block.
READ = READ
#: Flag set if writing to an fd will not block.
WRITE = WRITE
#: Flag set on error, and the fd should be read from asap.
ERR = ERR
#: List of callbacks to be called when the loop is initialized,
#: applied with the hub instance as sole argument.
on_init = None
#: List of callbacks to be called when the loop is exiting,
#: applied with the hub instance as sole argument.
on_close = None
#: List of callbacks to be called when a task is received.
#: Takes no arguments.
on_task = None
def __init__(self, timer=None):
self.timer = Schedule() if timer is None else timer
self.readers = {}
self.writers = {}
self.on_init = []
self.on_close = []
self.on_task = []
def start(self):
"""Called by StartStopComponent at worker startup."""
self.poller = eventio.poll()
def stop(self):
"""Called by StartStopComponent at worker shutdown."""
self.poller.close()
def init(self):
for callback in self.on_init:
callback(self)
def fire_timers(self, min_delay=1, max_delay=10, max_timers=10):
delay = None
if self.timer._queue:
for i in xrange(max_timers):
delay, entry = next(self.scheduler)
if entry is None:
break
self.timer.apply_entry(entry)
return min(max(delay, min_delay), max_delay)
def add(self, fd, callback, flags):
self.poller.register(fd, flags)
if not isinstance(fd, int):
fd = fd.fileno()
if flags & READ:
self.readers[fd] = callback
if flags & WRITE:
self.writers[fd] = callback
def add_reader(self, fd, callback):
return self.add(fd, callback, READ | ERR)
def add_writer(self, fd, callback):
return self.add(fd, callback, WRITE)
def update_readers(self, map):
[self.add_reader(*x) for x in map.iteritems()]
def update_writers(self, map):
[self.add_writer(*x) for x in map.iteritems()]
def _unregister(self, fd):
try:
self.poller.unregister(fd)
except (KeyError, OSError):
pass
def remove(self, fd):
fileno = fd.fileno() if not isinstance(fd, int) else fd
self.readers.pop(fileno, None)
self.writers.pop(fileno, None)
self._unregister(fd)
def __enter__(self):
self.init()
return self
def close(self, *args):
[self._unregister(fd) for fd in self.readers]
self.readers.clear()
[self._unregister(fd) for fd in self.writers]
self.writers.clear()
for callback in self.on_close:
callback(self)
__exit__ = close
@cached_property
def scheduler(self):
return iter(self.timer)
def create(self, w):
w.timer = Schedule(max_interval=10)
hub = w.hub = Hub(w.timer)
return hub
def create(self, w):
w.timer = Schedule(max_interval=10)
w.hub = hub.Hub(w.timer)
return w.hub
def __init__(self, timer=None):
self.fdmap = {}
self.poller = poll()
self.timer = Schedule() if timer is None else timer
class Hub(object):
READ, WRITE, ERR = READ, WRITE, ERR
def __init__(self, timer=None):
self.readers = {}
self.writers = {}
self.timer = Schedule() if timer is None else timer
self.on_init = []
self.on_close = []
self.on_task = []
def start(self):
self.poller = poll()
def stop(self):
self.poller.close()
def __enter__(self):
self.init()
return self
def __exit__(self, *exc_info):
return self.close()
def init(self):
for callback in self.on_init:
callback(self)
def fire_timers(self, min_delay=1, max_delay=10, max_timers=10):
delay = None
if self.timer._queue:
for i in xrange(max_timers):
delay, entry = self.scheduler.next()
if entry is None:
break
self.timer.apply_entry(entry)
return min(max(delay, min_delay), max_delay)
def add(self, fd, callback, flags):
self.poller.register(fd, flags)
if not isinstance(fd, int):
fd = fd.fileno()
if flags & READ:
self.readers[fd] = callback
if flags & WRITE:
self.writers[fd] = callback
def add_reader(self, fd, callback):
return self.add(fd, callback, READ | ERR)
def add_writer(self, fd, callback):
return self.add(fd, callback, WRITE)
def update_readers(self, map):
[self.add_reader(*x) for x in map.iteritems()]
def update_writers(self, map):
[self.add_writer(*x) for x in map.iteritems()]
def remove(self, fd):
try:
self.poller.unregister(fd)
except (KeyError, OSError):
pass
def close(self):
[self.remove(fd) for fd in self.readers.keys()]
[self.remove(fd) for fd in self.writers.keys()]
for callback in self.on_close:
callback(self)
@cached_property
def scheduler(self):
return iter(self.timer)
class Hub(object):
"""Event loop object.
:keyword timer: Specify custom :class:`~celery.utils.timer2.Schedule`.
"""
#: Flag set if reading from an fd will not block.
READ = READ
#: Flag set if writing to an fd will not block.
WRITE = WRITE
#: Flag set on error, and the fd should be read from asap.
ERR = ERR
#: List of callbacks to be called when the loop is initialized,
#: applied with the hub instance as sole argument.
on_init = None
#: List of callbacks to be called when the loop is exiting,
#: applied with the hub instance as sole argument.
on_close = None
#: List of callbacks to be called when a task is received.
#: Takes no arguments.
on_task = None
def __init__(self, timer=None):
self.timer = Schedule() if timer is None else timer
self.readers = {}
self.writers = {}
self.on_init = []
self.on_close = []
self.on_task = []
def start(self):
"""Called by StartStopComponent at worker startup."""
self.poller = eventio.poll()
def stop(self):
"""Called by StartStopComponent at worker shutdown."""
self.poller.close()
def init(self):
for callback in self.on_init:
callback(self)
def fire_timers(self, min_delay=1, max_delay=10, max_timers=10):
delay = None
if self.timer._queue:
for i in xrange(max_timers):
delay, entry = self.scheduler.next()
if entry is None:
break
self.timer.apply_entry(entry)
return min(max(delay, min_delay), max_delay)
def add(self, fd, callback, flags):
self.poller.register(fd, flags)
if not isinstance(fd, int):
fd = fd.fileno()
if flags & READ:
self.readers[fd] = callback
if flags & WRITE:
self.writers[fd] = callback
def add_reader(self, fd, callback):
return self.add(fd, callback, READ | ERR)
def add_writer(self, fd, callback):
return self.add(fd, callback, WRITE)
def update_readers(self, map):
[self.add_reader(*x) for x in map.iteritems()]
def update_writers(self, map):
[self.add_writer(*x) for x in map.iteritems()]
def _unregister(self, fd):
try:
self.poller.unregister(fd)
except (KeyError, OSError):
pass
def remove(self, fd):
fileno = fd.fileno() if not isinstance(fd, int) else fd
self.readers.pop(fileno, None)
self.writers.pop(fileno, None)
self._unregister(fd)
def __enter__(self):
self.init()
return self
def close(self, *args):
[self._unregister(fd) for fd in self.readers]
self.readers.clear()
[self._unregister(fd) for fd in self.writers]
self.writers.clear()
for callback in self.on_close:
callback(self)
__exit__ = close
@cached_property
def scheduler(self):
return iter(self.timer)
