def test_kill_closes_connections(rabbit_manager, rabbit_config,
mock_container):
container = mock_container
container.shared_extensions = {}
container.config = rabbit_config
container.max_workers = 1
container.spawn_managed_thread = spawn_managed_thread
queue_consumer = QueueConsumer().bind(container)
queue_consumer.setup()
class Handler(object):
queue = ham_queue
def handle_message(self, body, message):
pass # pragma: no cover
queue_consumer.register_provider(Handler())
queue_consumer.start()
# kill should close all connections
queue_consumer.kill()
# no connections should remain for our vhost
vhost = rabbit_config['vhost']
@retry
def check_connections_closed():
connections = get_rabbit_connections(vhost, rabbit_manager)
if connections: # pragma: no cover
for connection in connections:
assert connection['vhost'] != vhost
check_connections_closed()
def test_kill_closes_connections(rabbit_manager, rabbit_config):
container = Mock()
container.config = rabbit_config
container.max_workers = 1
container.spawn_managed_thread = spawn_thread
queue_consumer = QueueConsumer()
queue_consumer.bind("queue_consumer", container)
class Handler(object):
queue = ham_queue
def handle_message(self, body, message):
pass
queue_consumer.register_provider(Handler())
queue_consumer.start()
# kill should close all connections
queue_consumer.kill()
# no connections should remain for our vhost
vhost = rabbit_config['vhost']
connections = get_rabbit_connections(vhost, rabbit_manager)
if connections:
for connection in connections:
assert connection['vhost'] != vhost
def test_reconnect_on_socket_error():
container = Mock()
container.config = {AMQP_URI_CONFIG_KEY: None}
container.max_workers = 1
container.spawn_managed_thread = spawn_thread
connection_revived = Mock()
queue_consumer = QueueConsumer()
queue_consumer.on_connection_revived = connection_revived
queue_consumer.bind("queue_consumer", container)
handler = MessageHandler()
queue_consumer.register_provider(handler)
queue_consumer.start()
with patch.object(Connection, 'drain_events',
autospec=True) as drain_events:
drain_events.side_effect = socket.error('test-error')
def check_reconnected():
assert connection_revived.call_count > 1
assert_stops_raising(check_reconnected)
def test_kill_closes_connections(rabbit_manager, rabbit_config):
container = Mock()
container.config = rabbit_config
container.max_workers = 1
container.spawn_managed_thread = spawn_thread
queue_consumer = QueueConsumer()
queue_consumer.bind("queue_consumer", container)
class Handler(object):
queue = ham_queue
def handle_message(self, body, message):
pass
queue_consumer.register_provider(Handler())
queue_consumer.start()
# kill should close all connections
queue_consumer.kill()
# no connections should remain for our vhost
vhost = rabbit_config['vhost']
connections = get_rabbit_connections(vhost, rabbit_manager)
if connections:
for connection in connections:
assert connection['vhost'] != vhost
def test_kill_closes_connections(rabbit_manager, rabbit_config, mock_container):
container = mock_container
container.shared_extensions = {}
container.config = rabbit_config
container.max_workers = 1
container.spawn_managed_thread = spawn_managed_thread
queue_consumer = QueueConsumer().bind(container)
queue_consumer.setup()
class Handler(object):
queue = ham_queue
def handle_message(self, body, message):
pass # pragma: no cover
queue_consumer.register_provider(Handler())
queue_consumer.start()
# kill should close all connections
queue_consumer.kill()
# no connections should remain for our vhost
vhost = rabbit_config["vhost"]
connections = get_rabbit_connections(vhost, rabbit_manager)
if connections: # pragma: no cover
for connection in connections:
assert connection["vhost"] != vhost
def test_reconnect_on_socket_error():
container = Mock()
container.config = {AMQP_URI_CONFIG_KEY: None}
container.max_workers = 1
container.spawn_managed_thread = spawn_thread
connection_revived = Mock()
queue_consumer = QueueConsumer()
queue_consumer.on_connection_revived = connection_revived
queue_consumer.bind("queue_consumer", container)
handler = MessageHandler()
queue_consumer.register_provider(handler)
queue_consumer.start()
with patch.object(
Connection, 'drain_events', autospec=True) as drain_events:
drain_events.side_effect = socket.error('test-error')
def check_reconnected():
assert connection_revived.call_count > 1
assert_stops_raising(check_reconnected)
class ReplyListener(SharedExtension):
queue_consumer = QueueConsumer()
def __init__(self, **kwargs):
self._reply_events = {}
super(ReplyListener, self).__init__(**kwargs)
def setup(self):
service_uuid = uuid.uuid4() # TODO: give srv_ctx a uuid?
service_name = self.container.service_name
queue_name = RPC_REPLY_QUEUE_TEMPLATE.format(
service_name, service_uuid)
self.routing_key = str(service_uuid)
exchange = get_rpc_exchange(self.container.config)
self.queue = Queue(
queue_name,
exchange=exchange,
routing_key=self.routing_key,
auto_delete=True,
exclusive=True,
)
self.queue_consumer.register_provider(self)
def stop(self):
self.queue_consumer.unregister_provider(self)
super(ReplyListener, self).stop()
def get_reply_event(self, correlation_id):
reply_event = Event()
self._reply_events[correlation_id] = reply_event
return reply_event
def on_consume_ready(self):
# This is called on re-connection, and is the best hook for detecting
# disconnections. If we have any pending reply events, we were
# disconnected, and may have lost replies (since reply queues auto
# delete).
for event in self._reply_events.values():
event.send_exception(
RpcConnectionError('Disconnected while waiting for reply')
)
self._reply_events.clear()
def handle_message(self, body, message):
self.queue_consumer.ack_message(message)
correlation_id = message.properties.get('correlation_id')
client_event = self._reply_events.pop(correlation_id, None)
if client_event is not None:
client_event.send(body)
else:
_log.debug("Unknown correlation id: %s", correlation_id)
def test_reentrant_start_stops():
container = Mock()
container.config = {AMQP_URI_CONFIG_KEY: 'memory://'}
container.max_workers = 3
container.spawn_managed_thread = spawn_thread
queue_consumer = QueueConsumer()
queue_consumer.bind("queue_consumer", container)
queue_consumer.start()
gt = queue_consumer._gt
# nothing should happen as the consumer has already been started
queue_consumer.start()
assert gt is queue_consumer._gt
queue_consumer.kill()
def test_reentrant_start_stops(rabbit_config):
container = Mock()
container.config = rabbit_config
container.max_workers = 3
container.spawn_managed_thread = spawn_thread
queue_consumer = QueueConsumer()
queue_consumer.bind("queue_consumer", container)
queue_consumer.start()
gt = queue_consumer._gt
# nothing should happen as the consumer has already been started
queue_consumer.start()
assert gt is queue_consumer._gt
queue_consumer.kill()
def test_reentrant_start_stops(rabbit_config):
container = Mock()
container.config = rabbit_config
container.max_workers = 3
container.spawn_managed_thread = spawn_thread
queue_consumer = QueueConsumer()
queue_consumer.bind("queue_consumer", container)
queue_consumer.start()
gt = queue_consumer._gt
# nothing should happen as the consumer has already been started
queue_consumer.start()
assert gt is queue_consumer._gt
queue_consumer.kill()
def test_reentrant_start_stops():
container = Mock()
container.config = {AMQP_URI_CONFIG_KEY: 'memory://'}
container.max_workers = 3
container.spawn_managed_thread = spawn_thread
queue_consumer = QueueConsumer()
queue_consumer.bind("queue_consumer", container)
queue_consumer.start()
gt = queue_consumer._gt
# nothing should happen as the consumer has already been started
queue_consumer.start()
assert gt is queue_consumer._gt
queue_consumer.kill()
def test_lifecycle(rabbit_manager, rabbit_config):
container = Mock()
container.config = rabbit_config
container.max_workers = 3
container.spawn_managed_thread.side_effect = spawn_thread
queue_consumer = QueueConsumer()
queue_consumer.bind("queue_consumer", container)
handler = MessageHandler()
queue_consumer.register_provider(handler)
queue_consumer.start()
# making sure the QueueConsumer uses the container to spawn threads
container.spawn_managed_thread.assert_called_once_with(ANY, protected=True)
vhost = rabbit_config['vhost']
rabbit_manager.publish(vhost, 'spam', '', 'shrub')
message = handler.wait()
gt = eventlet.spawn(queue_consumer.unregister_provider, handler)
# wait for the handler to be removed
with eventlet.Timeout(TIMEOUT):
while len(queue_consumer._consumers):
eventlet.sleep()
# remove_consumer has to wait for all messages to be acked
assert not gt.dead
# the consumer should have stopped and not accept any new messages
rabbit_manager.publish(vhost, 'spam', '', 'ni')
# this should cause the consumer to finish shutting down
queue_consumer.ack_message(message)
with eventlet.Timeout(TIMEOUT):
gt.wait()
# there should be a message left on the queue
messages = rabbit_manager.get_messages(vhost, 'ham')
assert ['ni'] == [msg['payload'] for msg in messages]
def test_reentrant_start_stops(mock_container):
container = mock_container
container.shared_extensions = {}
container.config = {AMQP_URI_CONFIG_KEY: "memory://"}
container.max_workers = 3
container.spawn_managed_thread = spawn_managed_thread
queue_consumer = QueueConsumer().bind(container)
queue_consumer.setup()
queue_consumer.start()
gt = queue_consumer._gt
# nothing should happen as the consumer has already been started
queue_consumer.start()
assert gt is queue_consumer._gt
queue_consumer.kill()
class ReplyListener(SharedExtension):
queue_consumer = QueueConsumer()
def __init__(self, **kwargs):
self._reply_events = {}
super(ReplyListener, self).__init__(**kwargs)
def setup(self):
reply_queue_uuid = uuid.uuid4()
service_name = self.container.service_name
queue_name = RPC_REPLY_QUEUE_TEMPLATE.format(
service_name, reply_queue_uuid)
self.routing_key = str(reply_queue_uuid)
exchange = get_rpc_exchange(self.container.config)
self.queue = Queue(
queue_name,
exchange=exchange,
routing_key=self.routing_key,
queue_arguments={
'x-expires': RPC_REPLY_QUEUE_TTL
}
)
self.queue_consumer.register_provider(self)
def stop(self):
self.queue_consumer.unregister_provider(self)
super(ReplyListener, self).stop()
def get_reply_event(self, correlation_id):
reply_event = Event()
self._reply_events[correlation_id] = reply_event
return reply_event
def handle_message(self, body, message):
self.queue_consumer.ack_message(message)
correlation_id = message.properties.get('correlation_id')
client_event = self._reply_events.pop(correlation_id, None)
if client_event is not None:
client_event.send(body)
else:
_log.debug("Unknown correlation id: %s", correlation_id)
def test_on_consume_error_kills_consumer(mock_container):
container = mock_container
container.shared_extensions = {}
container.config = {AMQP_URI_CONFIG_KEY: 'memory://'}
container.max_workers = 1
container.spawn_managed_thread = spawn_managed_thread
queue_consumer = QueueConsumer().bind(container)
queue_consumer.setup()
handler = MessageHandler()
queue_consumer.register_provider(handler)
with patch.object(queue_consumer, 'on_consume_ready') as on_consume_ready:
on_consume_ready.side_effect = Exception('err')
queue_consumer.start()
with pytest.raises(Exception):
queue_consumer._gt.wait()
def test_on_consume_error_kills_consumer():
container = Mock()
container.config = {AMQP_URI_CONFIG_KEY: None}
container.max_workers = 1
container.spawn_managed_thread = spawn_thread
queue_consumer = QueueConsumer()
queue_consumer.bind("queue_consumer", container)
handler = MessageHandler()
queue_consumer.register_provider(handler)
with patch.object(queue_consumer, 'on_consume_ready') as on_consume_ready:
on_consume_ready.side_effect = Exception('err')
queue_consumer.start()
with pytest.raises(Exception):
queue_consumer._gt.wait()
class Rpc(NamekoRpc, HeaderEncoder):
rpc_consumer = RpcConsumer()
queue_consumer = QueueConsumer()
backoff_publisher = BackoffPublisher()
def __init__(self, *args, **kwargs):
expected_exceptions = expect_backoff_exception(
kwargs.pop('expected_exceptions', ()))
super(Rpc, self).__init__(*args,
expected_exceptions=expected_exceptions,
**kwargs)
def handle_result(self, message, worker_ctx, result, exc_info):
if exc_info is not None:
exc = exc_info[1]
if isinstance(exc, Backoff):
# add call stack and modify the current entry to show backoff
message.headers[CALL_ID_STACK_HEADER_KEY] = (
worker_ctx.call_id_stack)
message.headers[CALL_ID_STACK_HEADER_KEY][-1] += ".backoff"
# when redelivering, copy the original routing key to a new
# header so that we can still find the provider for the message
if RPC_METHOD_ID_HEADER_KEY not in message.headers:
message.headers[RPC_METHOD_ID_HEADER_KEY] = (
message.delivery_info['routing_key'])
target_queue = "rpc-{}".format(self.container.service_name)
try:
self.backoff_publisher.republish(exc, message,
target_queue)
self.queue_consumer.ack_message(message)
return result, exc_info
except Backoff.Expired:
exc_info = sys.exc_info()
result = None
return super(Rpc, self).handle_result(message,
worker_ctx,
result=result,
exc_info=exc_info)
def test_kill_closes_connections(rabbit_manager, rabbit_config):
container = Mock()
container.config = rabbit_config
container.max_workers = 1
container.spawn_managed_thread = spawn_thread
queue_consumer = QueueConsumer()
queue_consumer.bind("queue_consumer", container)
class Handler(object):
queue = ham_queue
def handle_message(self, body, message):
pass
queue_consumer.register_provider(Handler())
queue_consumer.start()
# kill should close all connections
queue_consumer.kill(Exception('test-kill'))
connections = rabbit_manager.get_connections()
assert connections is None
def test_error_stops_consumer_thread():
container = Mock()
container.config = {AMQP_URI_CONFIG_KEY: 'memory://'}
container.max_workers = 3
container.spawn_managed_thread = spawn_thread
queue_consumer = QueueConsumer()
queue_consumer.bind("queue_consumer", container)
handler = MessageHandler()
queue_consumer.register_provider(handler)
with eventlet.Timeout(TIMEOUT):
with patch.object(Connection, 'drain_events',
autospec=True) as drain_events:
drain_events.side_effect = Exception('test')
queue_consumer.start()
with pytest.raises(Exception) as exc_info:
queue_consumer._gt.wait()
assert exc_info.value.args == ('test', )
def test_on_consume_error_kills_consumer(mock_container):
container = mock_container
container.shared_extensions = {}
container.config = {AMQP_URI_CONFIG_KEY: "memory://"}
container.max_workers = 1
container.spawn_managed_thread = spawn_managed_thread
queue_consumer = QueueConsumer().bind(container)
queue_consumer.setup()
handler = MessageHandler()
queue_consumer.register_provider(handler)
with patch.object(queue_consumer, "on_consume_ready") as on_consume_ready:
on_consume_ready.side_effect = Exception("err")
queue_consumer.start()
with pytest.raises(Exception):
queue_consumer._gt.wait()
def test_on_consume_error_kills_consumer():
container = Mock()
container.config = {AMQP_URI_CONFIG_KEY: None}
container.max_workers = 1
container.spawn_managed_thread = spawn_thread
queue_consumer = QueueConsumer()
queue_consumer.bind("queue_consumer", container)
handler = MessageHandler()
queue_consumer.register_provider(handler)
with patch.object(queue_consumer, 'on_consume_ready') as on_consume_ready:
on_consume_ready.side_effect = Exception('err')
queue_consumer.start()
with pytest.raises(Exception):
queue_consumer._gt.wait()
def test_error_stops_consumer_thread():
container = Mock()
container.config = {AMQP_URI_CONFIG_KEY: None}
container.max_workers = 3
container.spawn_managed_thread = spawn_thread
queue_consumer = QueueConsumer()
queue_consumer.bind("queue_consumer", container)
handler = MessageHandler()
queue_consumer.register_provider(handler)
with eventlet.Timeout(TIMEOUT):
with patch.object(
Connection, 'drain_events', autospec=True) as drain_events:
drain_events.side_effect = Exception('test')
queue_consumer.start()
with pytest.raises(Exception) as exc_info:
queue_consumer._gt.wait()
assert exc_info.value.args == ('test',)
def test_error_stops_consumer_thread(mock_container):
container = mock_container
container.shared_extensions = {}
container.config = {AMQP_URI_CONFIG_KEY: "memory://"}
container.max_workers = 3
container.spawn_managed_thread = spawn_managed_thread
queue_consumer = QueueConsumer().bind(container)
queue_consumer.setup()
handler = MessageHandler()
queue_consumer.register_provider(handler)
with eventlet.Timeout(TIMEOUT):
with patch.object(Connection, "drain_events", autospec=True) as drain_events:
drain_events.side_effect = Exception("test")
queue_consumer.start()
with pytest.raises(Exception) as exc_info:
queue_consumer._gt.wait()
assert exc_info.value.args == ("test",)
def test_reconnect_on_socket_error(rabbit_config, mock_container):
container = mock_container
container.shared_extensions = {}
container.config = rabbit_config
container.max_workers = 1
container.spawn_managed_thread = spawn_managed_thread
connection_revived = Mock()
queue_consumer = QueueConsumer().bind(container)
queue_consumer.setup()
queue_consumer.on_connection_revived = connection_revived
handler = MessageHandler()
queue_consumer.register_provider(handler)
queue_consumer.start()
with patch.object(
Connection, 'drain_events', autospec=True) as drain_events:
drain_events.side_effect = socket.error('test-error')
def check_reconnected():
assert connection_revived.call_count > 1
assert_stops_raising(check_reconnected)
queue_consumer.unregister_provider(handler)
queue_consumer.stop()
def test_lifecycle(rabbit_manager, rabbit_config, mock_container):
container = mock_container
container.shared_extensions = {}
container.config = rabbit_config
container.max_workers = 3
container.spawn_managed_thread.side_effect = spawn_managed_thread
content_type = "application/data"
container.accept = [content_type]
queue_consumer = QueueConsumer().bind(container)
handler = MessageHandler()
queue_consumer.register_provider(handler)
queue_consumer.setup()
queue_consumer.start()
# making sure the QueueConsumer uses the container to spawn threads
container.spawn_managed_thread.assert_called_once_with(ANY)
vhost = rabbit_config["vhost"]
rabbit_manager.publish(vhost, "spam", "", "shrub", properties=dict(content_type=content_type))
message = handler.wait()
gt = eventlet.spawn(queue_consumer.unregister_provider, handler)
# wait for the handler to be removed
with eventlet.Timeout(TIMEOUT):
while len(queue_consumer._consumers):
eventlet.sleep()
# remove_consumer has to wait for all messages to be acked
assert not gt.dead
# the consumer should have stopped and not accept any new messages
rabbit_manager.publish(vhost, "spam", "", "ni")
# this should cause the consumer to finish shutting down
queue_consumer.ack_message(message)
with eventlet.Timeout(TIMEOUT):
gt.wait()
# there should be a message left on the queue
messages = rabbit_manager.get_messages(vhost, "ham")
assert ["ni"] == [msg["payload"] for msg in messages]
queue_consumer.kill()
def test_prefetch_count(rabbit_manager, rabbit_config):
container = Mock()
container.config = rabbit_config
container.max_workers = 1
container.spawn_managed_thread = spawn_thread
queue_consumer1 = QueueConsumer()
queue_consumer1.bind("queue_consumer", container)
queue_consumer2 = QueueConsumer()
queue_consumer2.bind("queue_consumer", container)
consumer_continue = Event()
class Handler1(object):
queue = ham_queue
def handle_message(self, body, message):
consumer_continue.wait()
queue_consumer1.ack_message(message)
messages = []
class Handler2(object):
queue = ham_queue
def handle_message(self, body, message):
messages.append(body)
queue_consumer2.ack_message(message)
handler1 = Handler1()
handler2 = Handler2()
queue_consumer1.register_provider(handler1)
queue_consumer2.register_provider(handler2)
queue_consumer1.start()
queue_consumer2.start()
vhost = rabbit_config['vhost']
# the first consumer only has a prefetch_count of 1 and will only
# consume 1 message and wait in handler1()
rabbit_manager.publish(vhost, 'spam', '', 'ham')
# the next message will go to handler2() no matter of any prefetch_count
rabbit_manager.publish(vhost, 'spam', '', 'eggs')
# the third message is only going to handler2 because the first consumer
# has a prefetch_count of 1 and thus is unable to deal with another message
# until having ACKed the first one
rabbit_manager.publish(vhost, 'spam', '', 'bacon')
with eventlet.Timeout(TIMEOUT):
while len(messages) < 2:
eventlet.sleep()
# allow the waiting consumer to ack its message
consumer_continue.send(None)
assert messages == ['eggs', 'bacon']
queue_consumer1.unregister_provider(handler1)
queue_consumer2.unregister_provider(handler2)
queue_consumer1.kill()
queue_consumer2.kill()
def test_reconnect_on_socket_error(rabbit_config, mock_container):
container = mock_container
container.shared_extensions = {}
container.config = rabbit_config
container.max_workers = 1
container.spawn_managed_thread = spawn_managed_thread
connection_revived = Mock()
queue_consumer = QueueConsumer().bind(container)
queue_consumer.setup()
queue_consumer.on_connection_revived = connection_revived
handler = MessageHandler()
queue_consumer.register_provider(handler)
queue_consumer.start()
with patch.object(Connection, "drain_events", autospec=True) as drain_events:
drain_events.side_effect = socket.error("test-error")
def check_reconnected():
assert connection_revived.call_count > 1
assert_stops_raising(check_reconnected)
queue_consumer.unregister_provider(handler)
queue_consumer.stop()
def test_prefetch_count(rabbit_manager, rabbit_config):
container = Mock()
container.config = rabbit_config
container.max_workers = 1
container.spawn_managed_thread = spawn_thread
queue_consumer1 = QueueConsumer()
queue_consumer1.bind("queue_consumer", container)
queue_consumer2 = QueueConsumer()
queue_consumer2.bind("queue_consumer", container)
consumer_continue = Event()
class Handler1(object):
queue = ham_queue
def handle_message(self, body, message):
consumer_continue.wait()
queue_consumer1.ack_message(message)
messages = []
class Handler2(object):
queue = ham_queue
def handle_message(self, body, message):
messages.append(body)
queue_consumer2.ack_message(message)
handler1 = Handler1()
handler2 = Handler2()
queue_consumer1.register_provider(handler1)
queue_consumer2.register_provider(handler2)
queue_consumer1.start()
queue_consumer2.start()
vhost = rabbit_config['vhost']
# the first consumer only has a prefetch_count of 1 and will only
# consume 1 message and wait in handler1()
rabbit_manager.publish(vhost, 'spam', '', 'ham')
# the next message will go to handler2() no matter of any prefetch_count
rabbit_manager.publish(vhost, 'spam', '', 'eggs')
# the third message is only going to handler2 because the first consumer
# has a prefetch_count of 1 and thus is unable to deal with another message
# until having ACKed the first one
rabbit_manager.publish(vhost, 'spam', '', 'bacon')
with eventlet.Timeout(TIMEOUT):
while len(messages) < 2:
eventlet.sleep()
# allow the waiting consumer to ack its message
consumer_continue.send(None)
assert messages == ['eggs', 'bacon']
queue_consumer1.unregister_provider(handler1)
queue_consumer2.unregister_provider(handler2)
queue_consumer1.kill()
queue_consumer2.kill()
def test_lifecycle(rabbit_manager, rabbit_config, mock_container):
container = mock_container
container.shared_extensions = {}
container.config = rabbit_config
container.max_workers = 3
container.spawn_managed_thread.side_effect = spawn_managed_thread
content_type = 'application/data'
container.accept = [content_type]
queue_consumer = QueueConsumer().bind(container)
handler = MessageHandler()
queue_consumer.register_provider(handler)
queue_consumer.setup()
queue_consumer.start()
# making sure the QueueConsumer uses the container to spawn threads
container.spawn_managed_thread.assert_called_once_with(ANY)
vhost = rabbit_config['vhost']
rabbit_manager.publish(vhost, 'spam', '', 'shrub',
properties=dict(content_type=content_type))
message = handler.wait()
gt = eventlet.spawn(queue_consumer.unregister_provider, handler)
# wait for the handler to be removed
with eventlet.Timeout(TIMEOUT):
while len(queue_consumer._consumers):
eventlet.sleep()
# remove_consumer has to wait for all messages to be acked
assert not gt.dead
# the consumer should have stopped and not accept any new messages
rabbit_manager.publish(vhost, 'spam', '', 'ni')
# this should cause the consumer to finish shutting down
queue_consumer.ack_message(message)
with eventlet.Timeout(TIMEOUT):
gt.wait()
# there should be a message left on the queue
messages = rabbit_manager.get_messages(vhost, 'ham')
assert ['ni'] == [msg['payload'] for msg in messages]
queue_consumer.kill()
class RpcConsumer(SharedExtension, ProviderCollector):
queue_consumer = QueueConsumer()
def __init__(self):
self._unregistering_providers = set()
self._unregistered_from_queue_consumer = Event()
self.queue = None
super(RpcConsumer, self).__init__()
def setup(self):
if self.queue is None:
service_name = self.container.service_name
queue_name = RPC_QUEUE_TEMPLATE.format(service_name)
routing_key = '{}.*'.format(service_name)
exchange = get_rpc_exchange(self.container.config)
self.queue = Queue(queue_name,
exchange=exchange,
routing_key=routing_key,
durable=True)
self.queue_consumer.register_provider(self)
self._registered = True
def stop(self):
""" Stop the RpcConsumer.
The RpcConsumer ordinary unregisters from the QueueConsumer when the
last Rpc subclass unregisters from it. If no providers were registered,
we should unregister from the QueueConsumer as soon as we're asked
to stop.
"""
if not self._providers_registered:
self.queue_consumer.unregister_provider(self)
self._unregistered_from_queue_consumer.send(True)
def unregister_provider(self, provider):
""" Unregister a provider.
Blocks until this RpcConsumer is unregistered from its QueueConsumer,
which only happens when all providers have asked to unregister.
"""
self._unregistering_providers.add(provider)
remaining_providers = self._providers - self._unregistering_providers
if not remaining_providers:
_log.debug('unregistering from queueconsumer %s', self)
self.queue_consumer.unregister_provider(self)
_log.debug('unregistered from queueconsumer %s', self)
self._unregistered_from_queue_consumer.send(True)
_log.debug('waiting for unregister from queue consumer %s', self)
self._unregistered_from_queue_consumer.wait()
super(RpcConsumer, self).unregister_provider(provider)
def get_provider_for_method(self, routing_key):
service_name = self.container.service_name
for provider in self._providers:
key = '{}.{}'.format(service_name, provider.method_name)
if key == routing_key:
return provider
else:
method_name = routing_key.split(".")[-1]
raise MethodNotFound(method_name)
def handle_message(self, body, message):
routing_key = message.delivery_info['routing_key']
try:
provider = self.get_provider_for_method(routing_key)
provider.handle_message(body, message)
except Exception:
exc_info = sys.exc_info()
self.handle_result(message, None, exc_info)
def handle_result(self, message, result, exc_info):
responder = Responder(self.container.config, message)
result, exc_info = responder.send_response(result, exc_info)
self.queue_consumer.ack_message(message)
return result, exc_info
def requeue_message(self, message):
self.queue_consumer.requeue_message(message)
