def reset(self):
debug('Resetting active actors')
for actor in values(self.registry):
if actor.consumer:
ignore_errors(self.connection, actor.consumer.cancel)
actor.connection = self.connection
self._start_actor_consumer(actor)
def reset(self):
debug('Resetting active actors')
for actor in values(self.registry):
if actor.consumer:
ignore_errors(self.connection, actor.consumer.cancel)
actor.connection = self.connection
self._start_actor_consumer(actor)
def close(self):
for fd in values(self._chan_to_sock):
try:
self.poller.unregister(fd)
except (KeyError, ValueError):
pass
self._channels.clear()
self._fd_to_chan.clear()
self._chan_to_sock.clear()
def close(self):
for fd in values(self._chan_to_sock):
try:
self.poller.unregister(fd)
except (KeyError, ValueError):
pass
self._channels.clear()
self._fd_to_chan.clear()
self._chan_to_sock.clear()
def periodic(self):
workers = self.state.workers
dirty = set()
for worker in values(workers):
if not worker.alive:
dirty.add(worker)
self.on_node_lost(worker)
for worker in dirty:
workers.pop(worker.hostname, None)
def periodic(self):
workers = self.state.workers
dirty = set()
for worker in values(workers):
if not worker.alive:
dirty.add(worker)
self.on_node_lost(worker)
for worker in dirty:
workers.pop(worker.hostname, None)
def __enter__(self):
# The __warningregistry__'s need to be in a pristine state for tests
# to work properly.
warnings.resetwarnings()
for v in values(sys.modules):
if getattr(v, '__warningregistry__', None):
v.__warningregistry__ = {}
self.warnings_manager = warnings.catch_warnings(record=True)
self.warnings = self.warnings_manager.__enter__()
warnings.simplefilter('always', self.expected)
return self
def __enter__(self):
# The __warningregistry__'s need to be in a pristine state for tests
# to work properly.
warnings.resetwarnings()
for v in values(sys.modules):
if getattr(v, '__warningregistry__', None):
v.__warningregistry__ = {}
self.warnings_manager = warnings.catch_warnings(record=True)
self.warnings = self.warnings_manager.__enter__()
warnings.simplefilter('always', self.expected)
return self
def _collect(self, connection):
if connection is not None:
for channel in values(connection.channels):
channel.connection = None
try:
os.close(connection.fileno())
except OSError:
pass
connection.channels.clear()
connection.callbacks.clear()
self.client.drain_events = None
self.client = None
def _collect(self, connection):
if connection is not None:
for channel in values(connection.channels):
channel.connection = None
try:
os.close(connection.fileno())
except OSError:
pass
connection.channels.clear()
connection.callbacks.clear()
self.client.drain_events = None
self.client = None
def _shutdown(self, cancel=True, close=True, clear=True):
try:
for actor in values(self.registry):
if actor and actor.consumer:
if cancel:
ignore_errors(self.connection,
actor.consumer.cancel)
if close and actor.consumer.channel:
ignore_errors(self.connection,
actor.consumer.channel.close)
finally:
if clear:
self.registry.clear()
def _shutdown(self, cancel=True, close=True, clear=True):
try:
for actor in values(self.registry):
if actor and actor.consumer:
if cancel:
ignore_errors(self.connection,
actor.consumer.cancel)
if close and actor.consumer.channel:
ignore_errors(self.connection,
actor.consumer.channel.close)
finally:
if clear:
self.registry.clear()
def iter_open_logger_fds():
seen = set()
loggers = list(values(logging.Logger.manager.loggerDict)) + [logging.getLogger(None)]
for logger in loggers:
try:
for handler in logger.handlers:
try:
if handler not in seen: # pragma: no cover
yield handler.stream
seen.add(handler)
except AttributeError:
pass
except AttributeError: # PlaceHolder does not have handlers
pass
def iter_open_logger_fds():
seen = set()
loggers = logging.Logger.manager.loggerDict
for logger in values(logging.Logger.manager.loggerDict):
try:
for handler in logger.handlers:
try:
if handler not in seen:
yield handler.stream
seen.add(handler)
except AttributeError:
pass
except AttributeError: # PlaceHolder does not have handlers
pass
def iter_open_logger_fds():
seen = set()
loggers = (list(values(logging.Logger.manager.loggerDict)) +
[logging.getLogger(None)])
for l in loggers:
try:
for handler in l.handlers:
try:
if handler not in seen: # pragma: no cover
yield handler.stream
seen.add(handler)
except AttributeError:
pass
except AttributeError: # PlaceHolder does not have handlers
pass
def start(self, c):
info("mingle: searching for neighbors")
I = c.app.control.inspect(timeout=1.0, connection=c.connection)
replies = I.hello(c.hostname, revoked._data) or {}
replies.pop(c.hostname, None)
if replies:
info("mingle: sync with %s nodes", len([reply for reply, value in items(replies) if value]))
for reply in values(replies):
if reply:
try:
other_clock, other_revoked = MINGLE_GET_FIELDS(reply)
except KeyError: # reply from pre-3.1 worker
pass
else:
c.app.clock.adjust(other_clock)
revoked.update(other_revoked)
info("mingle: sync complete")
else:
info("mingle: all alone")
def start(self, c):
info('mingle: searching for neighbors')
I = c.app.control.inspect(timeout=1.0, connection=c.connection)
replies = I.hello(c.hostname, revoked._data) or {}
replies.pop(c.hostname, None)
if replies:
info('mingle: sync with %s nodes',
len([reply for reply, value in items(replies) if value]))
for reply in values(replies):
if reply:
try:
other_clock, other_revoked = MINGLE_GET_FIELDS(reply)
except KeyError: # reply from pre-3.1 worker
pass
else:
c.app.clock.adjust(other_clock)
revoked.update(other_revoked)
info('mingle: sync complete')
else:
info('mingle: all alone')
def close(self):
super(Channel, self).close()
for queue in values(self.queues):
queue.empty()
self.queues = {}
def _put_fanout(self, exchange, message, **kwargs):
for queue in values(self.queues):
queue.put(message)
