def reject(self, delivery_tag, requeue=False):
"""
Rejects a message using the delivery tag.
Should be called by the EP layer.
"""
log.debug("RecvChannel.reject: %s", delivery_tag)
self._ensure_amq_chan()
blocking_cb(self._amq_chan.basic_reject, 'callback', delivery_tag, requeue=requeue)
def _destroy_queue(self):
"""
You should only call this if you want to delete the queue. Even so, you must know you are
the only one on it - there appears to be no mechanic for determining if anyone else is listening.
"""
assert self._recv_name and isinstance(self._recv_name, tuple) and self._recv_name[1]
self._ensure_amq_chan()
log.info("Destroying listener for queue %s", self._recv_name)
blocking_cb(self._amq_chan.queue_delete, 'callback', queue=self._recv_name[1])
def _destroy_binding(self):
"""
Deletes the binding from the listening queue.
"""
assert self._recv_name and isinstance(self._recv_name, tuple) and self._recv_name[1] and self._recv_binding
self._ensure_amq_chan()
blocking_cb(self._amq_chan.queue_unbind, 'callback', queue=self._recv_name[1],
exchange=self._recv_name[0],
routing_key=self._recv_binding)
def _bind(self, binding):
log.debug("RecvChannel._bind: %s", binding)
assert self._recv_name and self._recv_name[1]
self._ensure_amq_chan()
queue = self._recv_name[1]
blocking_cb(self._amq_chan.queue_bind, 'callback',
queue=queue,
exchange=self._recv_name[0],
routing_key=binding)
self._recv_binding = binding
def _new_transport(self, ch_number=None):
"""
Creates a new AMQPTransport with an underlying Pika channel.
"""
amq_chan = blocking_cb(self.client.channel,
'on_open_callback',
channel_number=ch_number)
if amq_chan is None:
log.error(
"AMQCHAN IS NONE THIS SHOULD NEVER HAPPEN, chan number requested: %s",
ch_number)
from pyon.container.cc import Container
if Container.instance is not None:
Container.instance.fail_fast(
"AMQCHAN IS NONE, messaging has failed", True)
raise StandardError(
"AMQCHAN IS NONE THIS SHOULD NEVER HAPPEN, chan number requested: %s"
% ch_number)
transport = AMQPTransport(amq_chan)
# return the pending in collection (lets this number be assigned again later)
self.client._pending.remove(transport.channel_number)
# by default, everything should have a prefetch count of 1 (configurable)
# this can be overridden by the channel get_n related methods
transport.qos_impl(prefetch_count=CFG.get_safe(
'container.messaging.endpoint.prefetch_count', 1))
return transport
def _new_channel(self, ch_type, ch_number=None, **kwargs):
"""
Creates a pyon Channel based on the passed in type, and activates it for use.
"""
chan = ch_type(**kwargs)
amq_chan = blocking_cb(self.client.channel, 'on_open_callback', channel_number=ch_number)
chan.on_channel_open(amq_chan)
return chan
def stop_consume(self):
"""
Stops consuming messages.
If the queue has auto_delete, this will delete it.
"""
log.debug("RecvChannel.stop_consume")
if not self._consuming:
raise ChannelError("Not consuming")
if self._queue_auto_delete:
log.debug("Autodelete is on, this will destroy this queue: %s", self._recv_name[1])
self._ensure_amq_chan()
blocking_cb(self._amq_chan.basic_cancel, 'callback', self._consumer_tag)
self._consuming = False
def _new_channel(self, ch_type, ch_number=None, **kwargs):
"""
Creates a pyon Channel based on the passed in type, and activates it for use.
"""
chan = ch_type(**kwargs)
amq_chan = blocking_cb(self.client.channel,
'on_open_callback',
channel_number=ch_number)
chan.on_channel_open(amq_chan)
return chan
def _get_channel(self, node):
"""
Get a raw channel to be used by all the ensure_exists methods.
"""
assert self.container
# @TODO: needs lock, but so do all these methods
if not self._chan:
self._chan = blocking_cb(node.client.channel, 'on_open_callback')
return self._chan
def _declare_exchange_point(self, xp):
"""
Performs an AMQP exchange declare.
@param xp The name of the exchange to use.
@TODO: this really shouldn't exist, messaging layer should not make this declaration. it will be provided.
perhaps push into an ion layer derivation to help bootstrapping / getting started fast.
"""
self._exchange = xp
assert self._exchange
self._ensure_amq_chan()
# EXCHANGE INTERACTION HERE - use async method to wait for it to finish
log.debug("Exchange declare: %s, TYPE %s, DUR %s AD %s", self._exchange, self._exchange_type,
self._exchange_durable, self._exchange_auto_delete)
blocking_cb(self._amq_chan.exchange_declare, 'callback', exchange=self._exchange,
type=self._exchange_type,
durable=self._exchange_durable,
auto_delete=self._exchange_auto_delete)
def _get_channel(self, node):
"""
Get a raw channel to be used by all the ensure_exists methods.
"""
assert self.container
# @TODO: needs lock, but so do all these methods
if not self._chan:
self._chan = blocking_cb(node.client.channel, 'on_open_callback')
return self._chan
def _new_transport(self, ch_number=None):
"""
Creates a new AMQPTransport with an underlying Pika channel.
"""
amq_chan = blocking_cb(self.client.channel, 'on_open_callback', channel_number=ch_number)
if amq_chan is None:
log.error("AMQCHAN IS NONE THIS SHOULD NEVER HAPPEN, chan number requested: %s", ch_number)
import traceback
traceback.print_stack()
raise StandardError("AMQCHAN IS NONE THIS SHOULD NEVER HAPPEN, chan number requested: %s" % ch_number)
transport = AMQPTransport(amq_chan)
return transport
def _new_channel(self, ch_type, ch_number=None, **kwargs):
"""
Creates a pyon Channel based on the passed in type, and activates it for use.
"""
chan = ch_type(**kwargs)
amq_chan = blocking_cb(self.client.channel, 'on_open_callback', channel_number=ch_number)
if amq_chan is None:
log.error("AMQCHAN IS NONE THIS SHOULD NEVER HAPPEN, chan number requested: %s", ch_number)
import traceback
traceback.print_stack()
raise StandardError("AMQCHAN IS NONE THIS SHOULD NEVER HAPPEN, chan number requested: %s" % ch_number)
chan.on_channel_open(amq_chan)
return chan
def _get_channel(self, node):
"""
Get a raw channel to be used by all the ensure_exists methods.
"""
assert self.container
# @TODO: needs lock, but so do all these methods
if not self._chan or (self._chan and self._chan.closing is not None):
# if you want to play with node internals, you have to play nice with the node.. needs the lock!
with node._lock:
self._chan = blocking_cb(node.client.channel, 'on_open_callback')
return self._chan
def _new_transport(self, ch_number=None):
"""
Creates a new AMQPTransport with an underlying Pika channel.
"""
amq_chan = blocking_cb(self.client.channel, 'on_open_callback', channel_number=ch_number)
if amq_chan is None:
log.error("AMQCHAN IS NONE THIS SHOULD NEVER HAPPEN, chan number requested: %s", ch_number)
traceback.print_stack()
from pyon.container.cc import Container
if Container.instance is not None:
Container.instance.fail_fast("AMQCHAN IS NONE, messaging has failed", True)
raise StandardError("AMQCHAN IS NONE THIS SHOULD NEVER HAPPEN, chan number requested: %s" % ch_number)
transport = AMQPTransport(amq_chan)
return transport
def _new_transport(self, ch_number=None):
"""
Creates a new AMQPTransport with an underlying Pika channel.
"""
amq_chan = blocking_cb(self.client.channel, 'on_open_callback', channel_number=ch_number)
if amq_chan is None:
log.error("AMQCHAN IS NONE THIS SHOULD NEVER HAPPEN, chan number requested: %s", ch_number)
from pyon.container.cc import Container
if Container.instance is not None:
Container.instance.fail_fast("AMQCHAN IS NONE, messaging has failed", True)
raise StandardError("AMQCHAN IS NONE THIS SHOULD NEVER HAPPEN, chan number requested: %s" % ch_number)
transport = AMQPTransport(amq_chan)
# by default, everything should have a prefetch count of 1 (configurable)
# this can be overridden by the channel get_n related methods
transport.qos_impl(prefetch_count=CFG.get_safe('container.messaging.endpoint.prefetch_count', 1))
return transport
def _new_channel(self, ch_type, ch_number=None, **kwargs):
"""
Creates a pyon Channel based on the passed in type, and activates it for use.
"""
chan = ch_type(**kwargs)
amq_chan = blocking_cb(self.client.channel,
'on_open_callback',
channel_number=ch_number)
if amq_chan is None:
log.error(
"AMQCHAN IS NONE THIS SHOULD NEVER HAPPEN, chan number requested: %s",
ch_number)
import traceback
traceback.print_stack()
raise StandardError(
"AMQCHAN IS NONE THIS SHOULD NEVER HAPPEN, chan number requested: %s"
% ch_number)
chan.on_channel_open(amq_chan)
return chan
def _declare_queue(self, queue):
# prepend xp name in the queue for anti-clobbering
if queue:
log.debug('Auto-prepending sysname to queue name for anti-clobbering')
queue = ".".join([self._recv_name[0], queue])
self._ensure_amq_chan()
log.debug("RecvChannel._declare_queue: %s", queue)
frame = blocking_cb(self._amq_chan.queue_declare, 'callback',
queue=queue or '',
auto_delete=self._queue_auto_delete,
durable=self._queue_durable)
# if the queue was anon, save it
#if queue is None:
# always save the new recv_name - we may have created a new one
self._recv_name = (self._recv_name[0], frame.method.queue)
return self._recv_name[1]
def test_blocking(self):
a, b, c, misc = blocking_cb(self.i_call_callbacks, cb_arg='cb')
self.assertEqual((a, b, c, misc), (1, 2, 3, {'foo': 'bar'}))
def test_blocking(self):
a, b, c, misc = blocking_cb(self.i_call_callbacks, cb_arg="cb")
self.assertEqual((a, b, c, misc), (1, 2, 3, {"foo": "bar"}))
def test_blocking(self):
a, b, c, misc = blocking_cb(self.i_call_callbacks, cb_arg='cb')
self.assertEqual((a, b, c, misc), (1, 2, 3, {'foo': 'bar'}))
