def test_reject_sender_sync(self):
cond = Condition("reject", "Smells weird", {"aroma": "fishy"})
error = self._test_reject_sender_sync(cond)
assert error.name == "reject"
assert error.description == "Smells weird"
assert error.info["aroma"] == "fishy"
def message_received(self, receiver_link, message, handle):
LOG.debug("message received callback")
global reply_senders
# extract to reply-to, correlation id
reply_to = message.reply_to
if not reply_to or reply_to not in reply_senders:
LOG.error("sender for reply-to not found, reply-to=%s",
str(reply_to))
info = Condition("not-found",
"Bad reply-to address: %s" % str(reply_to))
self._link.message_rejected(handle, info)
else:
my_sender = reply_senders[reply_to]
correlation_id = message.correlation_id
method_map = message.body
if (not isinstance(method_map, dict)
or 'method' not in method_map):
LOG.error("no method given, map=%s", str(method_map))
info = Condition("invalid-field",
"no method given, map=%s" % str(method_map))
self._link.message_rejected(handle, info)
else:
response = Message()
response.address = reply_to
response.subject = message.subject
response.correlation_id = correlation_id
response.body = {"response": method_map}
print("RPC request received, msg=%s" % str(method_map))
print(" to address=%s" % str(message.address))
print(" replying to=%s" % str(reply_to))
link = my_sender.sender_link
# @todo send timeouts
# link.send( response, my_sender,
# message, time.time() + 5.0)
link.send(response, my_sender, message)
self._link.message_accepted(handle)
if self._link.capacity == 0:
LOG.debug("increasing credit...")
self._link.add_capacity(5)
def test_receiver_close_cond_sync(self):
sender, receiver = self._setup_receiver_sync()
sl_handler = sender.user_context
cond = Condition("meh", "blah", {"dog": "cat"})
receiver.close(cond)
self.process_connections()
assert sl_handler.remote_closed_ct == 1
assert sl_handler.remote_closed_error
r_cond = sl_handler.remote_closed_error
assert r_cond.name == "meh"
assert r_cond.description == "blah"
assert r_cond.info.get("dog") == "cat"
def test_sender_close_cond_sync(self):
sender, receiver = self._setup_sender_sync()
rl_handler = receiver.user_context
cond = Condition("bad", "hate you", {"yo-mama": "wears army boots"})
sender.close(cond)
self.process_connections()
assert rl_handler.remote_closed_ct == 1
assert rl_handler.remote_closed_error
r_cond = rl_handler.remote_closed_error
assert r_cond.name == "bad"
assert r_cond.description == "hate you"
assert r_cond.info.get("yo-mama") == "wears army boots"
def check_timeout(self):
expired = []
for dlv in self.deliveries:
if self.deliveries[dlv].elapsed() >= SenderHandler.TIMEOUT:
expired.append(dlv)
for dlv in expired:
dlv_event = self.deliveries.pop(dlv)
dlv.update(Delivery.RELEASED)
dlv.settle()
dlv_event.complete(Delivery.RELEASED, Condition("timeout",\
description="Send not complete after %d seconds. ref %s" % (SenderHandler.TIMEOUT, self.client.remote_container)))
self.on_sendable(None)
def __call__(self, link, handle, status, info):
super(SendDoneCallback, self).__call__(link, handle, status,
info)
if self.count == 1:
# verify that we can safely close ourself, even if there is
# a send that has not completed:
assert status == pyngus.SenderLink.ACCEPTED
cond = Condition("indigestion", "old sushi",
{"smoked eel": "yummy"})
link.close(cond)
else:
# the unsent message is aborted prior
# to invoking closed callback:
assert status == pyngus.SenderLink.ABORTED
sl_handler = link.user_context
assert sl_handler.closed_ct == 0
def test_send_rejected(self):
cb = common.DeliveryCallback()
sender, receiver = self._setup_sender_sync()
rl_handler = receiver.user_context
msg = Message()
msg.body = "Hi"
sender.send(msg, cb, "my-handle")
receiver.add_capacity(1)
self.process_connections()
assert rl_handler.message_received_ct == 1
msg2, handle = rl_handler.received_messages[0]
cond = Condition("itchy", "Needs scratching", {"bath": True})
receiver.message_rejected(handle, cond)
self.process_connections()
assert cb.link == sender
assert cb.handle == "my-handle"
assert cb.status == pyngus.SenderLink.REJECTED
r_cond = cb.info.get("condition")
assert r_cond and r_cond.name == "itchy"
def test_reject_receiver_async(self):
rc_handler = common.ConnCallback()
s_conn = self.container1.create_connection("s_conn")
r_conn = self.container2.create_connection("r_conn", rc_handler)
s_conn.open()
r_conn.open()
sl_handler = common.SenderCallback()
sender = s_conn.create_sender("source-addr", "target-addr", sl_handler,
"my-name")
sender.open()
common.process_connections(s_conn, r_conn)
assert sl_handler.remote_closed_ct == 0
assert rc_handler.receiver_requested_ct == 1
args = rc_handler.receiver_requested_args[0]
cond = Condition("reject", "Smells funny", {"aroma": "wet dog"})
r_conn.reject_receiver(args.link_handle, cond)
common.process_connections(s_conn, r_conn)
assert sl_handler.remote_closed_ct == 1
assert sl_handler.remote_closed_error.name == "reject"
def test_reject_sender_async(self):
sc_handler = common.ConnCallback()
s_conn = self.container1.create_connection("s_conn", sc_handler)
r_conn = self.container2.create_connection("r_conn")
rl_handler = common.ReceiverCallback()
receiver = r_conn.create_receiver("tgt_addr", "src_addr", rl_handler,
"name")
s_conn.open()
r_conn.open()
receiver.open()
common.process_connections(s_conn, r_conn)
assert rl_handler.remote_closed_ct == 0
assert sc_handler.sender_requested_ct == 1
args = sc_handler.sender_requested_args[0]
cond = Condition("reject", "Smells weird", {"aroma": "eggs"})
s_conn.reject_sender(args.link_handle, cond)
common.process_connections(s_conn, r_conn)
assert rl_handler.remote_closed_ct == 1
error = rl_handler.remote_closed_error
assert error.name == "reject"
def test_reject_receiver_sync(self):
cond = Condition("reject", "Smells funny", {"aroma": "bananas"})
error = self._test_reject_receiver_sync(cond)
assert error.name == "reject"
assert error.description == "Smells funny"
assert error.info["aroma"] == "bananas"
def on_message(self, event):
event.delivery.local.condition = Condition(self.error_name,
self.error_description)
self.reject(event.delivery)