def connect(self, forever=False):
name = self.name
while True:
try:
connection = SelectConnection(self.parameters,
self.on_connected)
log.debug('%s connected', name)
except Exception:
if not forever:
raise
log.warning('%s cannot connect', name, exc_info=True)
time.sleep(10)
continue
try:
connection.ioloop.start()
finally:
try:
connection.close()
connection.ioloop.start() # allow connection to close
except Exception:
pass
if not forever:
break
def test_handling(self):
envelope = create_envelope()
handler = Handler(envelope)
self.assertEqual(handler.envelope, envelope)
handler.initialize(key='value', key2='value2')
handler.pre_handle()
self.assertRaises(NotImplementedError, handler.handle)
handler.post_handle()
envelope = create_envelope()
consumer = Consumer('localhost', 'test')
mock_connection = SelectConnection()
mock_channel = Channel(mock_connection, 10, None)
consumer.connection = mock_connection
consumer.channel = mock_channel
handler = MessageHandler(consumer, envelope)
self.assertEqual(handler.envelope, envelope)
self.assertEqual(handler.consumer, consumer)
self.assertEqual(handler.channel, mock_channel)
handler.initialize(key='value', key2='value2')
handler.pre_handle()
self.assertRaises(NotImplementedError, handler.handle)
handler.post_handle()
msg = 'some message'
with self.assertRaises(AbortHandling) as cm:
handler.abort(reason=msg)
self.assertEqual(cm.exception.reason, msg)
with self.assertRaises(SkipHandling) as cm:
handler.skip(reason=msg)
self.assertEqual(cm.exception.reason, msg)
with self.assertRaises(HandlingError) as cm:
handler.error(error_msg=msg)
self.assertEqual(cm.exception.error_msg, msg)
def test_retry_policy(self):
envelope = create_envelope()
consumer = create_consumer()
mock_connection = SelectConnection()
mock_channel = Channel(mock_connection, 10, None)
consumer.connection = mock_connection
consumer.channel = mock_channel
retry_policy = RetryPolicy()
self.assertRaises(NotImplementedError,
retry_policy.retry,
envelope=envelope)
def __init__(self, queue, request):
self.queue = queue
self.response = None
self.channel = None
self.request = request
self.corrId = str(uuid.uuid4())
self.callBackQueue = None
self.connection = None
parameters = pika.ConnectionParameters(host='127.0.0.1')
self.connection = SelectConnection(parameters,
self.on_response_connected)
self.connection.ioloop.start()
def test_fixed_delay_limited_retries_policy(self):
consumer = create_consumer()
mock_connection = SelectConnection()
mock_channel = Channel(mock_connection, 10, None)
consumer.connection = mock_connection
consumer.channel = mock_channel
retry_policy = FixedDelayLimitedRetriesPolicy(consumer,
delay=10,
retries_limit=7,
retry_queue_suffix='s')
self.assertEqual(isinstance(retry_policy, LimitedRetriesPolicy), True)
self.assertEqual(retry_policy.retry_delays, tuple([10] * 7))
self.assertEqual(retry_policy.retry_queue_suffix, 's')
def test_fixed_delay_unlimited_retries_policy(self):
consumer = create_consumer()
mock_connection = SelectConnection()
mock_channel = Channel(mock_connection, 10, None)
consumer.connection = mock_connection
consumer.channel = mock_channel
retry_policy = FixedDelayUnlimitedRetriesPolicy(consumer,
10,
retry_queue_suffix='h')
self.assertEqual(isinstance(retry_policy, UnlimitedRetriesPolicy),
True)
self.assertEqual(retry_policy.initial_delay, 10)
self.assertEqual(retry_policy.max_delay, 10)
self.assertEqual(retry_policy.delay_incremented_by, 0)
self.assertEqual(retry_policy.retry_queue_suffix, 'h')
def post_init(self):
try:
LOGGER.info('Opening a connection')
self.connection = SelectConnection(
parameters=settings.pika_parameters,
on_open_callback=self.on_connection_open)
try:
LOGGER.info('Starting ioloop')
self.connection.ioloop.start()
except KeyboardInterrupt:
# Gracefully close the connection
self.connection.close()
# Loop until we're fully closed, will stop on its own
self.connection.ioloop.start()
except:
(etype, eobj, etb) = sys.exc_info()
print traceback.format_exception(etype, eobj, etb)
def connect(self):
if self.connecting:
return
self.connecting = True
credentials = pika.PlainCredentials('guest', 'guest')
params = pika.ConnectionParameters(host="hackinista.com",
port=5672,
virtual_host="/",
credentials=credentials)
host = (len(sys.argv) > 1) and sys.argv[1] or '127.0.0.1'
try:
self.connection = SelectConnection(params, self.on_connected)
except:
# self.L.critical("Error connecting to rabbitmq on host =
# "+self.host);
sys.exit(-1)
def test_consumer_restart(self):
consumer = create_consumer()
consumer.connection = SelectConnection()
consumer.connection.ioloop.stop = MagicMock()
consumer.connection.ioloop.start = MagicMock()
# Mock add_timeout
consumer.connection.add_timeout = MagicMock()
def add_timeout_side_effect(delay, callback):
self.assertEqual(delay, 0)
self.assertEqual(callback, consumer._stop_consuming)
consumer.connection.add_timeout.side_effect = add_timeout_side_effect
consumer.restart()
consumer.connection.add_timeout.assert_called_once()
def test_consumer_reconnect(self):
consumer = create_consumer()
consumer.connection = SelectConnection()
consumer._connect = MagicMock()
def connect_side_effect():
return consumer.connection
consumer._connect.side_effect = connect_side_effect
consumer.connection.ioloop.stop = MagicMock()
consumer.connection.ioloop.start = MagicMock()
consumer._reconnect()
consumer._connect.assert_called_once()
consumer.connection.ioloop.stop.assert_called_once()
consumer.connection.ioloop.start.assert_called_once()
def start(self):
# parameters require for the AMQP connection: user name and password...
credentials = PlainCredentials(
RabbitMQConfiguration().getRabbitMQProperty(
"gameLogicServerUserName"),
RabbitMQConfiguration().getRabbitMQProperty(
"gameLogicServerUserName"))
parameters = pika.ConnectionParameters(
host=RabbitMQConfiguration().getRabbitMQProperty(
"gameLogicServerBrokerHost"),
virtual_host=self.state.vhost,
credentials=credentials)
# instantiate a connection
connection = SelectConnection(parameters=parameters,
on_open_callback=self.on_connected)
# required behavior on close
connection.add_on_close_callback(self.on_close)
# start the connection
connection.ioloop.start()
def post_init(self):
# 初始化分发任务类dispatcher
# 通过异步的方式 打开rabbitMQ的连接，并新建channel，声明exchange，声明queue，绑定exchange和queue，然后运行run方法，之前运行ioloop
self.dispatcher = Dispatcher(self.options)
try:
LOGGER.info('Opening a pika connection')
self.connection = SelectConnection(
parameters=settings.pika_parameters,
on_open_callback=self.on_connection_open,
on_open_error_callback=self.on_connection_open_error)
try:
LOGGER.info('Starting ioloop')
self.connection.ioloop.start()
except KeyboardInterrupt:
# Gracefully close the connection
self.connection.close()
# Loop until we're fully closed, will stop on its own
self.connection.ioloop.start()
except:
(etype, eobj, etb) = sys.exc_info()
print traceback.format_exception(etype, eobj, etb)
def run(self):
""" Run thread"""
threading.Thread.run(self)
try:
# get amqp connection params
#self.mqConnection = self.serviceContext.get_object("mqConnection")
parameters = self.server.serviceContext.get_object(
"amqpServer_connection_pars")
# Step #1: Connect to RabbitMQ
self.server.mqConnection = SelectConnection(
parameters, self.on_connected)
self.server.mqConnection.ioloop.start()
#channel.start_consuming()
except Exception as ex:
# Gracefully close the connection
if self.server.mqConnection != None:
self.server.mqConnection.close()
# Loop until we're fully closed, will stop on its own
#connection.ioloop.start()
self.server.logger.error(traceback.format_exc())
def post_init(self):
#初始化 新建RabbitMQ 队列和exchange并绑定（2个）
LOGGER.info('Initializing a FeedProcessor')
#self.feedprocessor.post_init()
LOGGER.info('Initializing a FeedProcessor completed')
try:
LOGGER.info('Opening a connection')
#self.dispatcher = Dispatcher(self.options)
self.connection = SelectConnection(
parameters=settings.pika_parameters,
on_open_callback=self.on_connection_open)
try:
LOGGER.info('Starting ioloop')
self.connection.ioloop.start()
except KeyboardInterrupt:
# Gracefully close the connection
self.connection.close()
# Loop until we're fully closed, will stop on its own
self.connection.ioloop.start()
except:
(etype, eobj, etb) = sys.exc_info()
print traceback.format_exception(etype, eobj, etb)
def test_consumer_auto_reconnect_error(self):
consumer = create_consumer()
consumer.connection = SelectConnection()
consumer.connection.ioloop.stop = MagicMock()
consumer.connection.ioloop.start = MagicMock()
# Mock add_timeout
consumer.connection.add_timeout = MagicMock()
def add_timeout_side_effect(delay, callback):
self.assertEqual(delay, consumer.auto_reconnect_delay)
self.assertEqual(callback, consumer._reconnect)
consumer.connection.add_timeout.side_effect = add_timeout_side_effect
# Simulate reconnection failute
consumer._on_open_connection_error(consumer.connection, Exception())
consumer.connection.add_timeout.assert_called_once()
# Test shutdown on reconnection failure
consumer.auto_reconnect = False
consumer._on_open_connection_error(consumer.connection, Exception())
consumer.connection.ioloop.stop.assert_called_once()
def test_rule_router(self):
consumer = create_consumer()
mock_connection = SelectConnection()
mock_channel = Channel(mock_connection, 10, None)
consumer.connection = mock_connection
consumer.channel = mock_channel
with self.assertRaises(AssertionError):
RuleRouter(consumer, 'None rule object')
router = RuleRouter(consumer)
self.assertEqual(router.consumer, consumer)
envelope = create_envelope()
self.assertIsNone(router.find_handler(envelope))
default_rule = Rule(AnyMatches(), MessageHandler, None)
router.set_default_rule(default_rule)
self.assertIsNotNone(router.find_handler(envelope))
handler = router.find_handler(envelope)
self.assertEqual(isinstance(handler, Handler), True)
router.set_default_rule(None)
self.assertIsNone(router.find_handler(envelope))
router = RuleRouter(consumer, default_rule)
self.assertIsNotNone(router.find_handler(envelope))
class CustomHandler(MessageHandler):
def initialize(self, arg1, arg2, **kwargs):
super(CustomHandler, self).initialize(**kwargs)
self.arg1 = arg1
self.arg2 = arg2
message_type_matcher = MessageTypeMatches(r'message_a')
rule = Rule(message_type_matcher, CustomHandler, {
'arg1': 1,
'arg2': 2
})
router.add_rule(rule)
envelope.properties.type = 'message_a'
handler = router.find_handler(envelope)
self.assertEqual(isinstance(handler, CustomHandler), True)
self.assertEqual(handler.arg1, 1)
self.assertEqual(handler.arg2, 2)
self.assertEqual(handler.consumer, consumer)
router.set_default_rule(default_rule)
handler = router.find_handler(envelope)
self.assertEqual(isinstance(handler, CustomHandler), True)
envelope = create_envelope()
handler = router.find_handler(envelope)
self.assertEqual(isinstance(handler, Handler), True)
# test subrouting
default_subrouter_rule = Rule(message_type_matcher, CustomHandler, {
'arg1': 1,
'arg2': 2
})
subrouter = RuleRouter(consumer, default_subrouter_rule)
# default rule for main router is the subrouter
main_default_rule = Rule(AnyMatches(), subrouter, None)
main_router = RuleRouter(consumer, main_default_rule)
handler = main_router.find_handler(envelope)
self.assertIsNone(handler)
envelope.properties.type = 'message_a'
handler = main_router.find_handler(envelope)
self.assertEqual(isinstance(handler, CustomHandler), True)
self.assertEqual(handler.arg1, 1)
self.assertEqual(handler.arg2, 2)
self.assertEqual(handler.consumer, consumer)
def connect(self):
SelectPoller.TIMEOUT = float(self.poller_delay)
return SelectConnection(self.parameters, self.on_connection_open,
stop_ioloop_on_close=False)
def test_limited_retries_policy(self):
envelope = create_envelope()
consumer = create_consumer()
mock_connection = SelectConnection()
mock_channel = Channel(mock_connection, 10, None)
consumer.connection = mock_connection
consumer.channel = mock_channel
retry_policy = LimitedRetriesPolicy(consumer=consumer,
retry_delays=(1, 5, 10, 50,
5 * 60),
retry_queue_suffix='r')
mock_channel.queue_declare = MagicMock()
mock_channel.basic_publish = MagicMock()
mock_channel.basic_ack = MagicMock()
mock_channel.basic_reject = MagicMock()
retry_policy.retry(envelope)
mock_channel.queue_declare.assert_called_with(
callback=None,
queue='{}.{}.{}'.format(consumer.queue_name,
retry_policy.retry_queue_suffix, 1000),
durable=consumer.durable,
nowait=True,
arguments={
'x-dead-letter-exchange': '',
'x-dead-letter-routing-key': consumer.queue_name,
'x-message-ttl': 1000,
'x-expires': retry_policy.min_retry_queue_ttl
})
mock_channel.basic_publish.assert_called_with(
exchange='',
routing_key='{}.{}.{}'.format(consumer.queue_name,
retry_policy.retry_queue_suffix,
1000),
properties=envelope.properties,
body=envelope.payload)
mock_channel.basic_ack.assert_called_with(envelope.delivery_tag)
self.assertEqual(
envelope.get_header('x-original-delivery-info'), {
'consumer_tag': envelope.consumer_tag,
'delivery_tag': envelope.delivery_tag,
'redelivered': envelope.redelivered,
'exchange': envelope.exchange,
'routing_key': envelope.routing_key
})
envelope.set_header('x-death', [{
'queue': consumer.queue_name,
'count': 1
}, {
'queue':
'{}.{}.{}'.format(consumer.queue_name,
retry_policy.retry_queue_suffix, 10000),
'count':
3
}, {
'queue': 'some-queue',
'count': 1
}])
retry_policy.retry(envelope)
delay = 5 * 60
retry_queue_name = '{}.{}.{}'.format(consumer.queue_name,
retry_policy.retry_queue_suffix,
delay * 1000)
mock_channel.queue_declare.assert_called_with(
callback=None,
queue=retry_queue_name,
durable=consumer.durable,
nowait=True,
arguments={
'x-dead-letter-exchange': '',
'x-dead-letter-routing-key': consumer.queue_name,
'x-message-ttl': delay * 1000,
'x-expires': delay * 2 * 1000
})
mock_channel.basic_publish.assert_called_with(
exchange='',
routing_key=retry_queue_name,
properties=envelope.properties,
body=envelope.payload)
mock_channel.basic_ack.assert_called_with(envelope.delivery_tag)
self.assertEqual(
envelope.get_header('x-original-delivery-info'), {
'consumer_tag': envelope.consumer_tag,
'delivery_tag': envelope.delivery_tag,
'redelivered': envelope.redelivered,
'exchange': envelope.exchange,
'routing_key': envelope.routing_key
})
envelope.set_header('x-death', [{
'queue': consumer.queue_name,
'count': 1
}, {
'queue':
'{}.{}.{}'.format(consumer.queue_name,
retry_policy.retry_queue_suffix, 10000),
'count':
4
}, {
'queue': 'some-queue',
'count': 1
}])
retry_policy.retry(envelope)
mock_channel.basic_reject.assert_called_with(envelope.delivery_tag,
requeue=False)
envelope.set_header('x-death', [{
'queue': consumer.queue_name,
'count': 1
}, {
'queue':
'{}.{}.{}'.format(consumer.queue_name,
retry_policy.retry_queue_suffix, 10000),
'count':
46
}, {
'queue': 'some-queue',
'count': 1
}])
retry_policy.retry(envelope)
mock_channel.basic_reject.assert_called_with(envelope.delivery_tag,
requeue=False)
def on_queue_declared(frame):
print "demo_receive: Queue Declared"
channel.basic_consume(handle_delivery, queue='test')
def handle_delivery(channel, method_frame, header_frame, body):
print "Basic.Deliver %s delivery-tag %i: %s" %\
(header_frame.content_type,
method_frame.delivery_tag,
body)
channel.basic_ack(delivery_tag=method_frame.delivery_tag)
if __name__ == '__main__':
# Connect to RabbitMQ
host = (len(sys.argv) > 1) and sys.argv[1] or '127.0.0.1'
connection = SelectConnection(ConnectionParameters(host), on_connected)
# Loop until CTRL-C
try:
# Start our blocking loop
connection.ioloop.start()
except KeyboardInterrupt:
# Close the connection
connection.close()
# Loop until the conneciton is closed
connection.ioloop.start()
def test_consumer_start_up_process(self):
consumer = create_consumer()
envelope = create_envelope()
consumer.connection = SelectConnection()
mock_channel = Channel(consumer.connection, 10, None)
# Mock exchange_declare
mock_channel.exchange_declare = MagicMock()
def on_exchange_declareok(callback, exchange, exchange_type, durable,
auto_delete, internal, arguments):
self.assertEqual(exchange, 'exchange1')
self.assertEqual(exchange_type, 'topic')
self.assertEqual(durable, False)
self.assertEqual(auto_delete, False)
self.assertEqual(internal, False)
self.assertEqual(arguments, None)
callback(None)
mock_channel.exchange_declare.side_effect = on_exchange_declareok
# Mock queue_declare
mock_channel.queue_declare = MagicMock()
def on_consumer_queue_declareok(callback, queue, durable, exclusive,
arguments):
self.assertEqual(queue, consumer.queue_name)
self.assertEqual(durable, consumer.durable)
self.assertEqual(exclusive, consumer.exclusive)
self.assertEqual(arguments,
{'x-dead-letter-exchange': consumer.dlx_name})
callback(None)
mock_channel.queue_declare.side_effect = on_consumer_queue_declareok
# Mock queue_bind
mock_channel.queue_bind = MagicMock()
def on_bindok(callback, queue, exchange, routing_key):
self.assertEqual(queue, consumer.queue_name)
self.assertEqual(routing_key, 'key1')
callback(None)
mock_channel.queue_bind.side_effect = on_bindok
mock_channel.add_on_close_callback = MagicMock()
# Mock basic_consume
mock_channel.basic_consume = MagicMock()
def on_message(callback, queue):
self.assertEqual(queue, consumer.queue_name)
mock_channel.basic_reject = MagicMock()
callback(mock_channel, envelope.delivery_info, envelope.properties,
envelope.payload)
mock_channel.basic_consume.side_effect = on_message
# connection.channel method used to open a new channel
# mock method is used to return the created mock_channel
consumer.connection.channel = MagicMock()
def on_channel_open(on_open_callback):
on_open_callback(mock_channel)
consumer.connection.channel.side_effect = on_channel_open
consumer.connection.ioloop.start = MagicMock()
consumer.connection.ioloop.stop = MagicMock()
consumer.add_exchange_bind(exchange_name='exchange1',
routing_key='key1',
declare_exchange=True,
declare_kwargs={'type': 'topic'})
consumer.add_exchange_bind(exchange_name='exchange1',
routing_key='key1')
# Initiate open connection manually
consumer._on_connection_open(None)
mock_channel.add_on_close_callback.assert_called_once()
mock_channel.queue_declare.assert_called_once()
mock_channel.basic_reject.assert_called_once()
mock_channel.queue_declare.assert_called_once()
queue_bind_count = len(mock_channel.queue_bind.call_args_list)
self.assertEqual(queue_bind_count, 2)
mock_channel.basic_consume.assert_called_once()
# Stopping consumer
# Mock add_timeout
consumer.connection.add_timeout = MagicMock()
def add_timeout_side_effect(delay, callback):
callback()
consumer.connection.add_timeout.side_effect = add_timeout_side_effect
# Mock basic_cancel
consumer.channel.basic_cancel = MagicMock()
def on_cancelok(callback, consumer_tag):
callback(None)
consumer.channel.basic_cancel.side_effect = on_cancelok
# Mock channel close
consumer.channel.close = MagicMock()
def channel_close_side_effect():
consumer._on_channel_closed(consumer.channel, '', '')
consumer.channel.close.side_effect = channel_close_side_effect
# Mock connection close
consumer.connection.close = MagicMock()
def on_connection_closed():
consumer._on_connection_closed(consumer.connection, '', '')
consumer.connection.close.side_effect = on_connection_closed
# Simulate stop
consumer.stop()
consumer.connection.add_timeout.assert_called_once()
consumer.connection.close.assert_called_once()
self.assertIsNone(consumer.channel)
consumer.connection.ioloop.stop.assert_called_once()
ssl_options = {}
# Uncomment this to test client certs, change to your cert paths
# Uses certs as generated from http://www.rabbitmq.com/ssl.html
ssl_options = {
"ca_certs": "/etc/rabbitmq/new/server/chain.pem",
"certfile": "/etc/rabbitmq/new/client/cert.pem",
"keyfile": "/etc/rabbitmq/new/client/key.pem",
"cert_reqs": CERT_REQUIRED
}
# Connect to RabbitMQ
host = (len(sys.argv) > 1) and sys.argv[1] or '127.0.0.1'
parameters = ConnectionParameters(host,
5671,
ssl=True,
ssl_options=ssl_options)
connection = SelectConnection(parameters, on_connected)
# Loop until CTRL-C
try:
# Start our blocking loop
connection.ioloop.start()
except KeyboardInterrupt:
# Close the connection
connection.close()
# Loop until the conneciton is closed
connection.ioloop.start()
def test_consumer(self):
amqp_url = r'amqp://*****:*****@localhost:5672/%2f'
queue_name = 'queue1'
durable = True
exclusive = True
dlx_name = 'dead_exchange'
auto_reconnect = True
auto_reconnect_delay = 10
consumer = Consumer(amqp_url=amqp_url,
queue_name=queue_name,
durable=durable,
exclusive=exclusive,
dlx_name=dlx_name,
auto_reconnect=auto_reconnect,
auto_reconnect_delay=auto_reconnect_delay)
self.assertEqual(consumer.amqp_url, amqp_url)
self.assertEqual(consumer.queue_name, queue_name)
self.assertEqual(consumer.durable, durable)
self.assertEqual(consumer.exclusive, exclusive)
self.assertEqual(consumer.dlx_name, dlx_name)
self.assertEqual(consumer.auto_reconnect, auto_reconnect)
self.assertEqual(consumer.auto_reconnect_delay, auto_reconnect_delay)
# Test abort
with self.assertRaises(AbortHandling) as cm:
consumer.abort('some reason')
self.assertEqual(cm.exception.reason, 'some reason')
# Test skip
with self.assertRaises(SkipHandling) as cm:
consumer.skip('some reason')
self.assertEqual(cm.exception.reason, 'some reason')
# Test error
with self.assertRaises(HandlingError) as cm:
consumer.error('some error')
self.assertEqual(cm.exception.error_msg, 'some error')
# Test bind to exchange
exchange_name = 'exchange1'
routing_key = 'some_routing_key'
declare_exchange = True
declare_kwargs = {'type': 'topic'}
consumer.add_exchange_bind(exchange_name=exchange_name,
routing_key=routing_key,
declare_exchange=declare_exchange,
declare_kwargs=declare_kwargs)
self.assertEqual(
consumer._exchange_binds[0],
((exchange_name, routing_key, declare_exchange, declare_kwargs)))
with self.assertRaises(AssertionError) as cm:
consumer.add_exchange_bind(exchange_name=exchange_name,
routing_key=routing_key,
declare_exchange=declare_exchange,
declare_kwargs=None)
with self.assertRaises(AssertionError) as cm:
consumer.add_exchange_bind(exchange_name=exchange_name,
routing_key=routing_key,
declare_exchange=declare_exchange,
declare_kwargs={})
# Test add handler
consumer.add_handler('some_pattern', Handler, None)
self.assertEqual(len(consumer.rules), 2)
self.assertEqual(
isinstance(consumer.rules[-2].matcher, MessageTypeMatches), True)
self.assertEqual(consumer.rules[-2].matcher.message_type_pattern,
'some_pattern')
consumer.add_handler(AnyMatches(), Handler, None)
self.assertEqual(len(consumer.rules), 3)
self.assertEqual(isinstance(consumer.rules[-2].matcher, AnyMatches),
True)
# Test set default handler
consumer.set_default_handler(Handler)
self.assertEqual(isinstance(consumer.rules[-1].matcher, AnyMatches),
True)
consumer.set_default_handler(None)
self.assertEqual(isinstance(consumer.rules[-1].matcher, NoneMatches),
True)
# Test set/unset policy
policy = FixedDelayLimitedRetriesPolicy(consumer=consumer,
delay=5,
retries_limit=15)
consumer.set_retry_policy(policy)
self.assertEqual(consumer._retry_policy, policy)
self.assertRaises(AssertionError, consumer.set_retry_policy,
'non policy object')
consumer.unset_retry_policy()
self.assertIsNone(consumer._retry_policy)
# Test handling message
envelope = create_envelope()
# Create fresh consumer
consumer = create_consumer()
mock_connection = SelectConnection()
mock_channel = Channel(mock_connection, 10, None)
mock_channel.basic_nack = MagicMock()
mock_channel.basic_reject = MagicMock()
consumer.channel = mock_channel
# Test no handler, should reject message
consumer._on_message(mock_channel, envelope.delivery_info,
envelope.properties, envelope.payload)
consumer.channel.basic_reject.assert_called_with(envelope.delivery_tag,
requeue=False)
# Test positive message handling
consumer.channel.basic_ack = MagicMock()
pre_handle_mock = MagicMock()
handle_mock = MagicMock()
post_handle_mock = MagicMock()
class SuccessHandler(Handler):
def __init__(self, envelope, **kwargs):
super(SuccessHandler, self).__init__(envelope, **kwargs)
self.pre_handle = pre_handle_mock
self.handle = handle_mock
self.post_handle = post_handle_mock
consumer.add_handler(AnyMatches(), SuccessHandler)
consumer._on_message(mock_channel, envelope.delivery_info,
envelope.properties, envelope.payload)
pre_handle_mock.assert_called_once()
handle_mock.assert_called_once()
post_handle_mock.assert_called_once()
consumer.channel.basic_ack.assert_called_with(envelope.delivery_tag)
# Test skip message handling
# Create fresh consumer
consumer = create_consumer()
mock_connection = SelectConnection()
mock_channel = Channel(mock_connection, 10, None)
mock_channel.basic_nack = MagicMock()
mock_channel.basic_reject = MagicMock()
consumer.channel = mock_channel
consumer.channel.basic_ack = MagicMock()
pre_handle_mock = MagicMock()
handle_mock = MagicMock()
post_handle_mock = MagicMock()
class SkipHandler(MessageHandler):
def __init__(self, consumer, envelope, **kwargs):
super(SkipHandler, self).__init__(consumer, envelope, **kwargs)
self.handle = handle_mock
self.post_handle = post_handle_mock
def pre_handle(self):
self.skip(reason='some reason')
consumer.add_handler(AnyMatches(), SkipHandler)
consumer._on_message(mock_channel, envelope.delivery_info,
envelope.properties, envelope.payload)
handle_mock.assert_not_called()
post_handle_mock.assert_not_called()
consumer.channel.basic_ack.assert_called_with(envelope.delivery_tag)
# Test abort message handling
# Create fresh consumer
consumer = create_consumer()
mock_connection = SelectConnection()
mock_channel = Channel(mock_connection, 10, None)
mock_channel.basic_nack = MagicMock()
mock_channel.basic_reject = MagicMock()
consumer.channel = mock_channel
consumer.channel.basic_ack = MagicMock()
pre_handle_mock = MagicMock()
handle_mock = MagicMock()
post_handle_mock = MagicMock()
class AbortHandler(MessageHandler):
def __init__(self, consumer, envelope, **kwargs):
super(AbortHandler, self).__init__(consumer, envelope,
**kwargs)
self.handle = handle_mock
self.post_handle = post_handle_mock
def pre_handle(self):
self.abort(reason='some reason')
consumer.add_handler(AnyMatches(), AbortHandler)
consumer._on_message(mock_channel, envelope.delivery_info,
envelope.properties, envelope.payload)
handle_mock.assert_not_called()
post_handle_mock.assert_not_called()
consumer.channel.basic_reject.assert_called_with(envelope.delivery_tag,
requeue=False)
consumer.channel.basic_ack.assert_not_called()
# Test error message handling
# Create fresh consumer
consumer = create_consumer()
mock_connection = SelectConnection()
mock_channel = Channel(mock_connection, 10, None)
mock_channel.basic_nack = MagicMock()
mock_channel.basic_reject = MagicMock()
consumer.channel = mock_channel
consumer.channel.basic_ack = MagicMock()
pre_handle_mock = MagicMock()
handle_mock = MagicMock()
post_handle_mock = MagicMock()
class ErrorHandler(MessageHandler):
def __init__(self, consumer, envelope, **kwargs):
super(ErrorHandler, self).__init__(consumer, envelope,
**kwargs)
self.handle = handle_mock
self.post_handle = post_handle_mock
def pre_handle(self):
self.error(error_msg='some reason')
consumer.add_handler(AnyMatches(), ErrorHandler)
consumer._on_message(mock_channel, envelope.delivery_info,
envelope.properties, envelope.payload)
handle_mock.assert_not_called()
post_handle_mock.assert_not_called()
consumer.channel.basic_reject.assert_called_with(envelope.delivery_tag,
requeue=False)
consumer.channel.basic_ack.assert_not_called()
# Test error message handling with retry policy
# Create fresh consumer
consumer = create_consumer()
mock_connection = SelectConnection()
mock_channel = Channel(mock_connection, 10, None)
mock_channel.basic_nack = MagicMock()
mock_channel.basic_reject = MagicMock()
consumer.channel = mock_channel
consumer.channel.basic_ack = MagicMock()
pre_handle_mock = MagicMock()
handle_mock = MagicMock()
post_handle_mock = MagicMock()
retry_policy = RetryPolicy()
retry_policy.retry = MagicMock()
consumer.set_retry_policy(retry_policy)
consumer.add_handler(AnyMatches(), ErrorHandler)
consumer._on_message(mock_channel, envelope.delivery_info,
envelope.properties, envelope.payload)
handle_mock.assert_not_called()
post_handle_mock.assert_not_called()
consumer.channel.basic_reject.assert_not_called()
consumer.channel.basic_ack.assert_not_called()
retry_policy.retry.assert_called_once()
# Test error message handling; general exception
# Create fresh consumer
consumer = create_consumer()
mock_connection = SelectConnection()
mock_channel = Channel(mock_connection, 10, None)
mock_channel.basic_nack = MagicMock()
mock_channel.basic_reject = MagicMock()
consumer.channel = mock_channel
consumer.channel.basic_ack = MagicMock()
pre_handle_mock = MagicMock()
handle_mock = MagicMock()
post_handle_mock = MagicMock()
class ExceHandler(MessageHandler):
def __init__(self, consumer, envelope, **kwargs):
super(ExceHandler, self).__init__(consumer, envelope, **kwargs)
self.handle = handle_mock
self.post_handle = post_handle_mock
def pre_handle(self):
raise Exception()
consumer.add_handler(AnyMatches(), ExceHandler)
consumer._on_message(mock_channel, envelope.delivery_info,
envelope.properties, envelope.payload)
handle_mock.assert_not_called()
post_handle_mock.assert_not_called()
consumer.channel.basic_reject.assert_called_with(envelope.delivery_tag,
requeue=False)
consumer.channel.basic_ack.assert_not_called()
# Test error message handling; general exception with retry policy
# Create fresh consumer
consumer = create_consumer()
mock_connection = SelectConnection()
mock_channel = Channel(mock_connection, 10, None)
mock_channel.basic_nack = MagicMock()
mock_channel.basic_reject = MagicMock()
consumer.channel = mock_channel
consumer.channel.basic_ack = MagicMock()
pre_handle_mock = MagicMock()
handle_mock = MagicMock()
post_handle_mock = MagicMock()
retry_policy = RetryPolicy()
retry_policy.retry = MagicMock()
consumer.set_retry_policy(retry_policy)
consumer.add_handler(AnyMatches(), ExceHandler)
consumer._on_message(mock_channel, envelope.delivery_info,
envelope.properties, envelope.payload)
handle_mock.assert_not_called()
post_handle_mock.assert_not_called()
consumer.channel.basic_reject.assert_not_called()
consumer.channel.basic_ack.assert_not_called()
retry_policy.retry.assert_called_once()
# Should handle AMQPConnectionError
consumer = create_consumer()
mock_connection = SelectConnection()
mock_channel = Channel(mock_connection, 10, None)
mock_channel.basic_nack = MagicMock()
mock_channel.basic_reject = MagicMock()
consumer.channel = mock_channel
consumer.channel.basic_ack = MagicMock()
pre_handle_mock = MagicMock()
handle_mock = MagicMock()
post_handle_mock = MagicMock()
class AMQPConnectionErrorHandler(MessageHandler):
def __init__(self, consumer, envelope, **kwargs):
super(AMQPConnectionErrorHandler,
self).__init__(consumer, envelope, **kwargs)
self.handle = handle_mock
self.post_handle = post_handle_mock
def pre_handle(self):
raise AMQPConnectionError()
consumer.add_handler(AnyMatches(), AMQPConnectionErrorHandler)
consumer._on_message(mock_channel, envelope.delivery_info,
envelope.properties, envelope.payload)
handle_mock.assert_not_called()
post_handle_mock.assert_not_called()
consumer.channel.basic_reject.assert_not_called()
consumer.channel.basic_ack.assert_not_called()
# Should handle AMQPChannelError
consumer = create_consumer()
mock_connection = SelectConnection()
mock_channel = Channel(mock_connection, 10, None)
mock_channel.basic_nack = MagicMock()
mock_channel.basic_reject = MagicMock()
consumer.channel = mock_channel
consumer.channel.basic_ack = MagicMock()
pre_handle_mock = MagicMock()
handle_mock = MagicMock()
post_handle_mock = MagicMock()
class AMQPChannelErrorHandler(MessageHandler):
def __init__(self, consumer, envelope, **kwargs):
super(AMQPChannelErrorHandler,
self).__init__(consumer, envelope, **kwargs)
self.handle = handle_mock
self.post_handle = post_handle_mock
def pre_handle(self):
raise AMQPChannelError()
consumer.add_handler(AnyMatches(), AMQPChannelErrorHandler)
consumer._on_message(mock_channel, envelope.delivery_info,
envelope.properties, envelope.payload)
handle_mock.assert_not_called()
post_handle_mock.assert_not_called()
consumer.channel.basic_reject.assert_not_called()
consumer.channel.basic_ack.assert_not_called()
def _start(self):
self.conn = SelectConnection(self.conn_params, self._on_connected)
self.conn.ioloop.start()
def connect(self):
SelectPoller.TIMEOUT = .1
self.connection = SelectConnection(self.parameters, self.on_connected)
self.connection.ioloop.start()
