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)