def get(self, queue='', no_ack=False, to_dict=False, auto_decode=True):
"""Fetch a single message.
:param str queue: Queue name
:param bool no_ack: No acknowledgement needed
:param bool to_dict: Should incoming messages be converted to a
dictionary before delivery.
:param bool auto_decode: Auto-decode strings when possible.
:raises AMQPInvalidArgument: Invalid Parameters
:raises AMQPChannelError: Raises if the channel encountered an error.
:raises AMQPConnectionError: Raises if the connection
encountered an error.
:returns: Returns a single message, as long as there is a message in
the queue. If no message is available, returns None.
:rtype: amqpstorm.Message,dict,None
"""
if not compatibility.is_string(queue):
raise AMQPInvalidArgument('queue should be a string')
elif not isinstance(no_ack, bool):
raise AMQPInvalidArgument('no_ack should be a boolean')
elif self._channel.consumer_tags:
raise AMQPChannelError("Cannot call 'get' when channel is "
"set to consume")
get_frame = specification.Basic.Get(queue=queue, no_ack=no_ack)
with self._channel.lock and self._channel.rpc.lock:
message = self._get_message(get_frame, auto_decode=auto_decode)
if message and to_dict:
return message.to_dict()
return message
def process_data_events(self, to_tuple=True):
"""Consume inbound messages.
This is only required when consuming messages. All other
events are automatically handled in the background.
:param bool to_tuple: Should incoming messages be converted to a
tuple before delivery.
:raises AMQPChannelError: Raises if the channel encountered an error.
:raises AMQPConnectionError: Raises if the connection
encountered an error.
:return:
"""
# print("process_data_events")
if not self.consumer_callback:
raise AMQPChannelError('no consumer_callback defined')
for message in self.build_inbound_messages(break_on_empty=True):
if self._die.value != 0:
return
if not to_tuple:
# noinspection PyCallingNonCallable
self.consumer_callback(message)
continue
# noinspection PyCallingNonCallable
self.consumer_callback(*message.to_tuple())
sleep(IDLE_WAIT)
def process_data_events(self, to_tuple=False, auto_decode=True):
"""Consume inbound messages.
:param bool to_tuple: Should incoming messages be converted to a
tuple before delivery.
:param bool auto_decode: Auto-decode strings when possible.
:raises AMQPChannelError: Raises if the channel encountered an error.
:raises AMQPConnectionError: Raises if the connection
encountered an error.
:return:
"""
if not self.consumer_callback:
raise AMQPChannelError('no consumer_callback defined')
for message in self.build_inbound_messages(break_on_empty=True,
to_tuple=to_tuple,
auto_decode=auto_decode):
if self._die.value != 0:
return
if to_tuple:
# noinspection PyCallingNonCallable
self.consumer_callback(*message)
continue
# noinspection PyCallingNonCallable
self.consumer_callback(message)
sleep(IDLE_WAIT)
def _close_channel(self, frame_in):
"""Close Channel.
:param specification.Channel.Close frame_in: Channel Close frame.
:return:
"""
if frame_in.reply_code != 200:
reply_text = try_utf8_decode(frame_in.reply_text)
message = (
'Channel %d was closed by remote server: %s' %
(
self._channel_id,
reply_text
)
)
exception = AMQPChannelError(message,
reply_code=frame_in.reply_code)
self.exceptions.append(exception)
self.set_state(self.CLOSED)
if self._connection.is_open:
try:
self._connection.write_frame(
self.channel_id, specification.Channel.CloseOk()
)
except AMQPConnectionError:
pass
self.close()
def add_consumer_tag(self, tag):
"""Add a Consumer tag.
:param str tag: Consumer tag.
:return:
"""
if not is_string(tag):
raise AMQPChannelError('consumer tag needs to be a string')
if tag not in self._consumer_tags:
self._consumer_tags.append(tag)
def test_channel_with_statement_when_failing(self):
connection = FakeConnection()
try:
with Channel(0, connection, 360) as channel:
channel.exceptions.append(AMQPChannelError('error'))
channel.check_for_errors()
except AMQPChannelError as why:
self.assertIsInstance(why, AMQPChannelError)
self.assertEqual(self.get_last_log(),
'Closing channel due to an unhandled exception: '
'error')
def _raise_rpc_timeout_error(self, uuid):
"""Gather information and raise an Rpc exception.
:param str uuid: Rpc Identifier.
:return:
"""
requests = []
for key, value in self._request.items():
if value == uuid:
requests.append(key)
self.remove(uuid)
message = ('rpc requests %s (%s) took too long' %
(uuid, ', '.join(requests)))
raise AMQPChannelError(message)
def _close_channel(self, frame_in):
"""Close Channel.
:param specification.Channel.Close frame_in: Channel Close frame.
:return:
"""
self.set_state(self.CLOSED)
self.remove_consumer_tag()
if self._inbound:
del self._inbound[:]
self.exceptions.append(
AMQPChannelError(
'Channel %d was closed by remote server: %s' %
(self._channel_id, try_utf8_decode(frame_in.reply_text)),
reply_code=frame_in.reply_code))
def _close_channel(self, frame_in):
"""Close Channel.
:param specification.Channel.Close frame_in: Amqp frame.
:return:
"""
self.set_state(self.CLOSED)
if frame_in.reply_code != 200:
reply_text = try_utf8_decode(frame_in.reply_text)
message = ('Channel %d was closed by remote server: %s' %
(self._channel_id, reply_text))
exception = AMQPChannelError(message,
reply_code=frame_in.reply_code)
self.exceptions.append(exception)
self.close()
def _close_channel(self, frame_in):
"""Close Channel.
:param pamqp_spec.Channel.Close frame_in: Amqp frame.
:return:
"""
self.remove_consumer_tag()
if frame_in.reply_code != 200:
reply_text = try_utf8_decode(frame_in.reply_text)
message = 'Channel %d was closed by remote server: %s' % \
(self._channel_id, reply_text)
exception = AMQPChannelError(message,
reply_code=frame_in.reply_code)
self.exceptions.append(exception)
del self._inbound[:]
self.set_state(self.CLOSED)
def check_for_errors(self, ):
"""Check connection and channel for errors.
:raises AMQPChannelError: Raises if the channel encountered an error.
:raises AMQPConnectionError: Raises if the connection
encountered an error.
:return:
"""
try:
self._connection.check_for_errors()
except AMQPConnectionError:
self.set_state(self.CLOSED)
raise
self.check_for_exceptions()
if self.is_closed:
raise AMQPChannelError('channel was closed')
def test_channel_close_gracefully_with_queued_error(self):
def on_close_ok(_, frame_out):
if isinstance(frame_out, specification.Basic.Cancel):
raise AMQPChannelError('travis-ci')
channel.rpc.on_frame(specification.Channel.CloseOk())
channel = Channel(0, FakeConnection(on_write=on_close_ok), 360)
# Set up Fake Channel.
channel._inbound = [1, 2, 3]
channel.set_state(channel.OPEN)
channel._consumer_tags = ['1', '2', '3']
channel.exceptions.append(AMQPChannelError('travis-ci'))
# Close Channel.
channel.close()
self.assertEqual(channel._inbound, [])
self.assertEqual(channel._consumer_tags, [])
self.assertEqual(channel._state, channel.CLOSED)
self.assertTrue(channel.exceptions)
def check_for_errors(self):
"""Check connection and channel for errors.
:raises AMQPChannelError: Raises if the channel encountered an error.
:raises AMQPConnectionError: Raises if the connection
encountered an error.
:return:
"""
if self._connection.exceptions or self._connection.is_closed:
self.set_state(self.CLOSED)
why = AMQPConnectionError('connection was closed')
if self._connection.exceptions:
why = self._connection.exceptions[0]
raise why
if self.exceptions:
exception = self.exceptions[0]
if self.is_open:
self.exceptions.pop(0)
raise exception
if self.is_closed:
raise AMQPChannelError('channel was closed')
def process_data_events(self, to_tuple=False, auto_decode=True):
"""Consume inbound messages.
:param bool to_tuple: Should incoming messages be converted to a
tuple before delivery.
:param bool auto_decode: Auto-decode strings when possible.
:raises AMQPChannelError: Raises if the channel encountered an error.
:raises AMQPConnectionError: Raises if the connection
encountered an error.
:return:
"""
if not self._consumer_callbacks:
raise AMQPChannelError('no consumer callback defined')
for message in self.build_inbound_messages(break_on_empty=True,
auto_decode=auto_decode):
consumer_tag = message._method.get('consumer_tag')
if to_tuple:
# noinspection PyCallingNonCallable
self._consumer_callbacks[consumer_tag](*message.to_tuple())
continue
# noinspection PyCallingNonCallable
self._consumer_callbacks[consumer_tag](message)
def check_for_errors(self):
raise AMQPChannelError('travis-ci')
def on_close_ok(_, frame_out):
if isinstance(frame_out, specification.Basic.Cancel):
raise AMQPChannelError('travis-ci')
channel.rpc.on_frame(specification.Channel.CloseOk())
def on_close_ok(_, frame_out):
if isinstance(frame_out, commands.Basic.Cancel):
raise AMQPChannelError('travis-ci')
channel.rpc.on_frame(commands.Channel.CloseOk())