def get_table(self, exchange):
key = self.keyprefix_queue % exchange
with self.conn_or_acquire() as client:
values = client.smembers(key)
if not values:
raise InconsistencyError(NO_ROUTE_ERROR.format(exchange, key))
return [tuple(bytes_to_str(val).split(self.sep)) for val in values]
def get_table(self, exchange):
key = self.keyprefix_queue % exchange
values = self._avail_client.smembers(key)
if not values:
raise InconsistencyError(
'Queue list empty or key does not exist: {0!r}'.format(key))
return [tuple(val.split(self.sep)) for val in values]
def get_table(self, exchange):
key = self.keyprefix_queue % exchange
exists, values = self.pipeline().exists(key).smembers(key).execute()
if not exists:
raise InconsistencyError(
"Queue list empty or key does not exist: %r" %
(self.keyprefix_queue % exchange))
return [tuple(val.split(self.sep)) for val in values]
def get_table(self, exchange):
key = self.keyprefix_queue % exchange
with self.conn_or_acquire() as client:
values = client.smembers(key)
if not values:
raise InconsistencyError(
'Queue list empty or key does not exist: %r' %
(self.keyprefix_queue % exchange))
return [tuple(val.split(self.sep)) for val in values]
def test_publish_reply_ignores_InconsistencyError(self):
mailbox = pidbox.Mailbox('test_reply__collect')(self.connection)
with patch('kombu.pidbox.Producer') as Producer:
producer = Producer.return_value = Mock(name='producer')
producer.publish.side_effect = InconsistencyError()
mailbox._publish_reply(
{'foo': 'bar'}, mailbox.reply_exchange, mailbox.oid, 'foo',
)
producer.publish.assert_called()
def _lookup(self, exchange, routing_key, default=None):
"""Find all queues matching `routing_key` for the given `exchange`.
Returns:
str: queue name -- must return the string `default`
if no queues matched.
"""
pattern = ''
result = []
if default is None:
default = self.deadletter_queue
if not exchange: # anon exchange
return [routing_key or default]
queue = routing_key
redis_key = self.keyprefix_queue % exchange
try:
queue_bind = self.sep.join([
routing_key or '',
pattern,
queue or '',
])
with self.conn_or_acquire() as client:
if not client.scard(redis_key):
pass # Do not check if its a member because set is empty
elif client.sismember(redis_key, queue_bind):
result = [queue]
except KeyError:
pass
if not result:
if default is not None:
warnings.warn(
UndeliverableWarning(
UNDELIVERABLE_FMT.format(exchange=exchange,
routing_key=routing_key)), )
self._new_queue(default)
result = [default]
else:
raise InconsistencyError(
NO_ROUTE_ERROR.format(exchange, redis_key))
return result