def __init__(self,
topic,
exchange_name,
type_handlers,
on_wait=None,
**kwargs):
self._topic = topic
self._exchange_name = exchange_name
self._on_wait = on_wait
self._running = threading_utils.Event()
self._dispatcher = dispatcher.TypeDispatcher(type_handlers)
self._dispatcher.add_requeue_filter(
# NOTE(skudriashev): Process all incoming messages only if proxy is
# running, otherwise requeue them.
lambda data, message: not self.is_running)
url = kwargs.get('url')
transport = kwargs.get('transport')
transport_opts = kwargs.get('transport_options')
self._drain_events_timeout = DRAIN_EVENTS_PERIOD
if transport == 'memory' and transport_opts:
polling_interval = transport_opts.get('polling_interval')
if polling_interval is not None:
self._drain_events_timeout = polling_interval
# create connection
self._conn = kombu.Connection(url,
transport=transport,
transport_options=transport_opts)
# create exchange
self._exchange = kombu.Exchange(name=self._exchange_name,
durable=False,
auto_delete=True)
def test_on_requeue_message(self):
d = dispatcher.TypeDispatcher()
d.requeue_filters.append(lambda data, message: True)
msg = mock_acked_message()
d.on_message("", msg)
self.assertTrue(msg.requeue.called)
self.assertFalse(msg.acknowledged)
def test_failed_ack(self):
on_hello = mock.MagicMock()
handlers = {'hello': dispatcher.Handler(on_hello)}
d = dispatcher.TypeDispatcher(type_handlers=handlers)
msg = mock_acked_message(ack_ok=False, properties={'type': 'hello'})
d.on_message("", msg)
self.assertTrue(msg.ack_log_error.called)
self.assertFalse(msg.acknowledged)
self.assertFalse(on_hello.called)
def test_on_message(self):
on_hello = mock.MagicMock()
handlers = {'hello': on_hello}
d = dispatcher.TypeDispatcher(handlers)
msg = mock_acked_message(properties={'type': 'hello'})
d.on_message("", msg)
self.assertTrue(on_hello.called)
self.assertTrue(msg.ack_log_error.called)
self.assertTrue(msg.acknowledged)
def __init__(self,
topic,
exchange,
type_handlers=None,
on_wait=None,
url=None,
transport=None,
transport_options=None,
retry_options=None):
self._topic = topic
self._exchange_name = exchange
self._on_wait = on_wait
self._running = threading.Event()
self._dispatcher = dispatcher.TypeDispatcher(
# NOTE(skudriashev): Process all incoming messages only if proxy is
# running, otherwise requeue them.
requeue_filters=[lambda data, message: not self.is_running],
type_handlers=type_handlers)
ensure_options = self.DEFAULT_RETRY_OPTIONS.copy()
if retry_options is not None:
# Override the defaults with any user provided values...
for k in set(six.iterkeys(ensure_options)):
if k in retry_options:
# Ensure that the right type is passed in...
val = retry_options[k]
if k in self._RETRY_INT_OPTS:
tmp_val = int(val)
else:
tmp_val = float(val)
if tmp_val < 0:
raise ValueError("Expected value greater or equal to"
" zero for 'retry_options' %s; got"
" %s instead" % (k, val))
ensure_options[k] = tmp_val
self._ensure_options = ensure_options
self._drain_events_timeout = DRAIN_EVENTS_PERIOD
if transport == 'memory' and transport_options:
polling_interval = transport_options.get('polling_interval')
if polling_interval is not None:
self._drain_events_timeout = polling_interval
# create connection
self._conn = kombu.Connection(url,
transport=transport,
transport_options=transport_options)
# create exchange
self._exchange = kombu.Exchange(name=self._exchange_name,
durable=False,
auto_delete=True)
def test_on_rejected_message(self):
d = dispatcher.TypeDispatcher()
msg = mock_acked_message(properties={'type': 'hello'})
d.on_message("", msg)
self.assertTrue(msg.reject_log_error.called)
self.assertFalse(msg.acknowledged)
def test_creation(self):
on_hello = mock.MagicMock()
handlers = {'hello': dispatcher.Handler(on_hello)}
dispatcher.TypeDispatcher(type_handlers=handlers)
def test_creation(self):
on_hello = mock.MagicMock()
handlers = {'hello': on_hello}
dispatcher.TypeDispatcher(handlers)