def relay_event(issuer, key, namespace, queuename, event):
# TODO can do this faster by persisting something? Maybe the Messenger? How to do that with celery threading?
messenger = Messenger()
message = Message()
message.address = "amqps://{issuer}:{key}@{namespace}.servicebus.windows.net/{queuename}".format(
issuer = issuer,
key = urllib.quote(key, ""),
namespace = namespace,
queuename = queuename)
message.properties = {}
# TODO align with Service Bus / Service Tool team
message.properties[u"DefineProject"] = event['project']
del event['project']
message.properties[u"EventCategory"] = event['category']
del event['category']
if 'ticket' in event:
message.properties[u"Ticket"] = event['ticket']
del event['ticket']
message.properties[u"Actor"] = event['author']
del event['author']
message.body = event
messenger.put(message)
messenger.send()
def on_link_local_open(self, event):
msg = Message()
msg.properties = {u"opcode": "route"}
msg.body = (self.address, (self.host, self.port, self.redirect_target), None)
if self.policy:
msg.body += (self.policy,)
msg.send(event.link)
if self.agent:
msg.body = (self.agent, (self.host, self.port, None), None)
msg.send(event.link)
def on_link_remote_open(self, event):
msg = Message()
msg.properties = {u"opcode": "route"}
msg.body = (self.address, (self.host, self.port, self.redirect_target),
None)
if self.policy:
msg.body += (self.policy, )
self.sender.send(msg)
if self.agent:
msg.body = (self.agent, (self.host, self.port, None), None)
self.sender.send(msg)
def test_08a_test_strip_message_annotations_out_timeout(self):
addr = self.router.addresses[3]+"/strip_message_annotations_out_timeout/1"
M1 = self.messenger()
M2 = self.messenger()
M1.start()
M2.start()
M2.timeout = 0.5
M2.subscribe(addr)
ingress_message = Message()
ingress_message.address = addr
ingress_message.body = {'message': 'Hello World!'}
ingress_message_annotations = {'x-opt-qd.ingress': '0/QDR', 'x-opt-qd.trace': ['0/QDR']}
ingress_message.annotations = ingress_message_annotations
#Put and send the message
M1.put(ingress_message)
M1.send()
timed_out = False
try:
# Receive the message, this should timeout because the router thinks that this message has looped.
M2.recv(1)
except Timeout:
timed_out = True
self.assertTrue(timed_out)
M1.stop()
M2.stop()
def test_08a_test_strip_message_annotations_both_custom(self):
addr = self.router.addresses[2]+"/strip_message_annotations_both/1"
M1 = self.messenger()
M2 = self.messenger()
M1.start()
M2.start()
M2.subscribe(addr)
ingress_message = Message()
ingress_message.address = addr
ingress_message.body = {'message': 'Hello World!'}
# Only annotations with prefix "x-opt-qd." will be stripped
ingress_message_annotations = {'stay': 'humble', 'x-opt-qd': 'work'}
ingress_message.annotations = ingress_message_annotations
#Put and send the message
M1.put(ingress_message)
M1.send()
# Receive the message
M2.recv(1)
egress_message = Message()
M2.get(egress_message)
self.assertEqual(egress_message.annotations, ingress_message_annotations)
M1.stop()
M2.stop()
def test_simple_pre_settled(self):
addr = self.routers[0].addresses[4]+"/test/1"
M1 = self.messenger()
M2 = self.messenger()
M1.start()
M2.start()
M2.subscribe(addr)
tm = Message()
rm = Message()
tm.address = addr
for i in range(100):
tm.body = {'number': i}
M1.put(tm)
M1.send()
for i in range(100):
M2.recv(1)
M2.get(rm)
self.assertEqual(i, rm.body['number'])
M1.stop()
M2.stop()
def zaqar_to_proton(message):
"""Convert a message retrieved from storage to a Proton message"""
msg = Message()
msg.ttl = message.get('ttl')
msg.body = message.get('body')
# NOTE(vkmc) This won't work for now - there is no 'amqp10' field yet
if message.get('amqp10'):
msg.priority = message.get('amqp10').get('priority')
msg.first_acquirer = message.get('amqp10').get('first_acquirer')
msg.delivery_count = message.get('amqp10').get('delivery_count')
msg.id = message.get('amqp10').get('id'),
msg.user_id = message.get('amqp10').get('user_id')
msg.address = message.get('amqp10').get('address')
msg.subject = message.get('amqp10').get('subject')
msg.reply_to = message.get('amqp10').get('reply_to')
msg.correlation_id = message.get('amqp10').get('correlation_id')
msg.content_type = message.get('amqp10').get('content_type')
msg.content_encoding = message.get('amqp10').get('content_encoding')
msg.expiry_time = message.get('amqp10').get('expiry_time')
msg.creation_time = message.get('amqp10').get('creation_time'),
msg.group_id = message.get('amqp10').get('group_id')
msg.group_sequence = message.get('amqp10').get('group_sequence')
msg.reply_to_group_id = message.get('amqp10').get('reply_to_group_id')
msg.format = message.get('amqp10').get('format')
return msg
def test_16_delivery_annotations(self):
addr = "amqp:/delivery_annotations.1"
M1 = self.messenger()
M2 = self.messenger()
M1.route("amqp:/*", self.routers[0].addresses[0]+"/$1")
M2.route("amqp:/*", self.routers[1].addresses[0]+"/$1")
M1.start()
M2.start()
M2.subscribe(addr)
tm = Message()
rm = Message()
self.routers[0].wait_address("delivery_annotations.1", 0, 1)
tm.annotations = {'a1': 'a1', 'b1': 'b2'}
tm.address = addr
tm.instructions = {'work': 'hard', 'stay': 'humble'}
tm.body = {'number': 38}
M1.put(tm)
M1.send()
M2.recv(1)
M2.get(rm)
self.assertEqual(38, rm.body['number'])
M1.stop()
M2.stop()
def test_08a_test_strip_message_annotations_both_custom(self):
addr = self.router.addresses[2] + "/strip_message_annotations_both/1"
M1 = self.messenger()
M2 = self.messenger()
M1.start()
M2.start()
M2.subscribe(addr)
ingress_message = Message()
ingress_message.address = addr
ingress_message.body = {'message': 'Hello World!'}
# Only annotations with prefix "x-opt-qd." will be stripped
ingress_message_annotations = {'stay': 'humble', 'x-opt-qd': 'work'}
ingress_message.annotations = ingress_message_annotations
#Put and send the message
M1.put(ingress_message)
M1.send()
# Receive the message
M2.recv(1)
egress_message = Message()
M2.get(egress_message)
self.assertEqual(egress_message.annotations,
ingress_message_annotations)
M1.stop()
M2.stop()
def test_simple_pre_settled(self):
if not is_ipv6_enabled():
return self.skipTest("Skipping test..IPV6 not enabled")
addr = self.routers[0].addresses[4] + "/test/1"
M1 = self.messenger()
M2 = self.messenger()
M1.start()
M2.start()
M2.subscribe(addr)
tm = Message()
rm = Message()
tm.address = addr
for i in range(100):
tm.body = {'number': i}
M1.put(tm)
M1.send()
for i in range(100):
M2.recv(1)
M2.get(rm)
self.assertEqual(i, rm.body['number'])
M1.stop()
M2.stop()
def test_01_pre_settled(self):
addr = "amqp:/pre_settled.1"
M1 = self.messenger()
M2 = self.messenger()
M1.route("amqp:/*", self.routers[0].addresses[0]+"/$1")
M2.route("amqp:/*", self.routers[1].addresses[0]+"/$1")
M2.subscribe(addr)
tm = Message()
rm = Message()
self.routers[0].wait_address("pre_settled.1", 0, 1)
tm.address = addr
for i in range(100):
tm.body = {'number': i}
M1.put(tm)
M1.send()
for i in range(100):
M2.recv(1)
M2.get(rm)
self.assertEqual(i, rm.body['number'])
M1.stop()
M2.stop()
def test_03_propagated_disposition(self):
addr = "amqp:/unsettled/2"
M1 = self.messenger()
M2 = self.messenger()
M1.route("amqp:/*", self.routers[0].addresses[0]+"/$1")
M2.route("amqp:/*", self.routers[1].addresses[0]+"/$1")
M1.outgoing_window = 5
M2.incoming_window = 5
M1.start()
M2.start()
M2.subscribe(addr)
self.routers[0].wait_address("unsettled/2", 0, 1)
tm = Message()
rm = Message()
tm.address = addr
tm.body = {'number': 0}
##
## Test ACCEPT
##
tx_tracker = M1.put(tm)
M1.send(0)
M2.recv(1)
rx_tracker = M2.get(rm)
self.assertEqual(0, rm.body['number'])
self.assertEqual(PENDING, M1.status(tx_tracker))
M2.accept(rx_tracker)
M2.settle(rx_tracker)
M2.flush()
M1.flush()
self.assertEqual(ACCEPTED, M1.status(tx_tracker))
##
## Test REJECT
##
tx_tracker = M1.put(tm)
M1.send(0)
M2.recv(1)
rx_tracker = M2.get(rm)
self.assertEqual(0, rm.body['number'])
self.assertEqual(PENDING, M1.status(tx_tracker))
M2.reject(rx_tracker)
M2.settle(rx_tracker)
M2.flush()
M1.flush()
self.assertEqual(REJECTED, M1.status(tx_tracker))
M1.stop()
M2.stop()
def test_02b_disp_to_closed_connection(self):
addr = self.address+"/pre_settled/2"
M1 = self.messenger()
M2 = self.messenger()
M1.outgoing_window = 5
M2.incoming_window = 5
M1.start()
M2.start()
M2.subscribe(addr)
tm = Message()
rm = Message()
tm.address = addr
for i in range(2):
tm.body = {'number': i}
M1.put(tm)
M1.send(0)
M1.stop()
for i in range(2):
M2.recv(1)
trk = M2.get(rm)
M2.accept(trk)
M2.settle(trk)
self.assertEqual(i, rm.body['number'])
M2.stop()
def test_02b_disp_to_closed_connection(self):
addr = self.address + "/pre_settled/2"
M1 = self.messenger()
M2 = self.messenger()
M1.outgoing_window = 5
M2.incoming_window = 5
M1.start()
M2.start()
M2.subscribe(addr)
tm = Message()
rm = Message()
tm.address = addr
for i in range(2):
tm.body = {'number': i}
M1.put(tm)
M1.send(0)
M1.stop()
for i in range(2):
M2.recv(1)
trk = M2.get(rm)
M2.accept(trk)
M2.settle(trk)
self.assertEqual(i, rm.body['number'])
M2.stop()
def test_13_to_override(self):
addr = self.address + "/toov/1"
M1 = self.messenger()
M2 = self.messenger()
M1.start()
M2.start()
M2.subscribe(addr)
tm = Message()
rm = Message()
tm.address = addr
##
## Pre-existing TO
##
tm.annotations = {'x-opt-qd.to': 'toov/1'}
for i in range(10):
tm.body = {'number': i}
M1.put(tm)
M1.send()
for i in range(10):
M2.recv(1)
M2.get(rm)
self.assertEqual(i, rm.body['number'])
ma = rm.annotations
self.assertEqual(ma.__class__, dict)
self.assertEqual(ma['x-opt-qd.to'], 'toov/1')
M1.stop()
M2.stop()
def test_03_propagated_disposition(self):
addr = "amqp:/unsettled/2"
M1 = self.messenger()
M2 = self.messenger()
M1.route("amqp:/*", self.routers[0].addresses[0] + "/$1")
M2.route("amqp:/*", self.routers[1].addresses[0] + "/$1")
M1.outgoing_window = 5
M2.incoming_window = 5
M1.start()
M2.start()
M2.subscribe(addr)
self.routers[0].wait_address("unsettled/2", 0, 1)
tm = Message()
rm = Message()
tm.address = addr
tm.body = {'number': 0}
##
## Test ACCEPT
##
tx_tracker = M1.put(tm)
M1.send(0)
M2.recv(1)
rx_tracker = M2.get(rm)
self.assertEqual(0, rm.body['number'])
self.assertEqual(PENDING, M1.status(tx_tracker))
M2.accept(rx_tracker)
M2.settle(rx_tracker)
M2.flush()
M1.flush()
self.assertEqual(ACCEPTED, M1.status(tx_tracker))
##
## Test REJECT
##
tx_tracker = M1.put(tm)
M1.send(0)
M2.recv(1)
rx_tracker = M2.get(rm)
self.assertEqual(0, rm.body['number'])
self.assertEqual(PENDING, M1.status(tx_tracker))
M2.reject(rx_tracker)
M2.settle(rx_tracker)
M2.flush()
M1.flush()
self.assertEqual(REJECTED, M1.status(tx_tracker))
M1.stop()
M2.stop()
def test_01_pre_settled(self):
addr = self.address + "/pre_settled/1"
M1 = self.messenger()
M2 = self.messenger()
M1.start()
M2.start()
M2.subscribe(addr)
tm = Message()
rm = Message()
tm.address = addr
for i in range(100):
tm.body = {'number': i}
M1.put(tm)
M1.send()
for i in range(100):
M2.recv(1)
M2.get(rm)
self.assertEqual(i, rm.body['number'])
M1.stop()
M2.stop()
def on_sendable(self, event):
print(15)
body = {"attributeNames": ['name', 'role', 'name']}
properties = {
"operation": 'QUERY',
'type': 'org.amqp.management',
'name': "self",
'entityType': 'org.apache.qpid.dispatch.listener'
}
address = '/$management'
# reply_to = "receiver.remote.attach.source.address"
# reply_to = "myManagement"
reply_to = "/"
print('reply_to ', reply_to)
while event.sender.credit and self.sent < self.total:
msg = Message(id=(self.sent + 1))
msg.body = body
msg.properties = properties
msg.address = address
msg.reply_to = reply_to
event.sender.send(msg)
self.sent += 1
# event.sender.detach()
event.sender.close()
print('sent')
def test_02c_sender_settles_first(self):
addr = self.address + "/settled/senderfirst/1"
M1 = self.messenger()
M2 = self.messenger()
M1.outgoing_window = 5
M2.incoming_window = 5
M1.start()
M2.start()
M2.subscribe(addr)
tm = Message()
rm = Message()
tm.address = addr
tm.body = {'number': 0}
ttrk = M1.put(tm)
M1.send(0)
M1.settle(ttrk)
M1.flush()
M2.flush()
M2.recv(1)
rtrk = M2.get(rm)
M2.accept(rtrk)
M2.settle(rtrk)
self.assertEqual(0, rm.body['number'])
M1.flush()
M2.flush()
M1.stop()
M2.stop()
def test_abort(self):
"""Issue several operations, then close before processing I/O."""
c1_events = common.ConnCallback()
c2_events = common.ConnCallback()
c1 = self.container1.create_connection("c1", c1_events)
c2 = self.container2.create_connection("c2", c2_events)
# create sender & receiver, send msg,
# and grant credit prior to opening c2:
c1.open()
s1_handler = common.SenderCallback()
sender = c1.create_sender("my-source", "req-target",
event_handler=s1_handler)
sender.open()
msg = Message()
msg.body = "Hi"
sender.send(msg)
r1_handler = common.ReceiverCallback()
receiver = c1.create_receiver("my-target", "req-source",
event_handler=r1_handler)
receiver.add_capacity(1)
receiver.open()
c1.close()
c2.open()
common.process_connections(c1, c2)
assert c2_events.remote_closed_ct
c2.close()
common.process_connections(c1, c2)
assert c1_events.closed_ct
assert c2_events.closed_ct
def test_01_pre_settled(self):
addr = "amqp:/pre_settled.1"
M1 = self.messenger()
M2 = self.messenger()
M1.route("amqp:/*", self.routers[0].addresses[0] + "/$1")
M2.route("amqp:/*", self.routers[1].addresses[0] + "/$1")
M2.subscribe(addr)
tm = Message()
rm = Message()
self.routers[0].wait_address("pre_settled.1", 0, 1)
tm.address = addr
for i in range(100):
tm.body = {'number': i}
M1.put(tm)
M1.send()
for i in range(100):
M2.recv(1)
M2.get(rm)
self.assertEqual(i, rm.body['number'])
M1.stop()
M2.stop()
def test_abort(self):
"""Issue several operations, then close before processing I/O."""
c1_events = common.ConnCallback()
c2_events = common.ConnCallback()
c1 = self.container1.create_connection("c1", c1_events)
c2 = self.container2.create_connection("c2", c2_events)
# create sender & receiver, send msg,
# and grant credit prior to opening c2:
c1.open()
s1_handler = common.SenderCallback()
sender = c1.create_sender("my-source",
"req-target",
event_handler=s1_handler)
sender.open()
msg = Message()
msg.body = "Hi"
sender.send(msg)
r1_handler = common.ReceiverCallback()
receiver = c1.create_receiver("my-target",
"req-source",
event_handler=r1_handler)
receiver.add_capacity(1)
receiver.open()
c1.close()
c2.open()
common.process_connections(c1, c2)
assert c2_events.remote_closed_ct
c2.close()
common.process_connections(c1, c2)
assert c1_events.closed_ct
assert c2_events.closed_ct
def test_16_delivery_annotations(self):
addr = "amqp:/delivery_annotations.1"
M1 = self.messenger()
M2 = self.messenger()
M1.route("amqp:/*", self.routers[0].addresses[0] + "/$1")
M2.route("amqp:/*", self.routers[1].addresses[0] + "/$1")
M1.start()
M2.start()
M2.subscribe(addr)
tm = Message()
rm = Message()
self.routers[0].wait_address("delivery_annotations.1", 0, 1)
tm.annotations = {'a1': 'a1', 'b1': 'b2'}
tm.address = addr
tm.instructions = {'work': 'hard', 'stay': 'humble'}
tm.body = {'number': 38}
M1.put(tm)
M1.send()
M2.recv(1)
M2.get(rm)
self.assertEqual(38, rm.body['number'])
M1.stop()
M2.stop()
def test_send_abort(self):
sl_handler = common.SenderCallback()
cb = common.DeliveryCallback()
sender = self.conn1.create_sender("saddr", "taddr",
sl_handler)
msg = Message()
msg.body = "Hi"
sender.send(msg, cb, None)
sender.open()
sender.close()
self.process_connections()
assert self.conn2_handler.receiver_requested_ct == 1
args = self.conn2_handler.receiver_requested_args[0]
rl_handler = common.ReceiverCallback()
receiver1 = self.conn2.accept_receiver(args.link_handle,
event_handler=rl_handler)
receiver1.open()
self.process_connections()
assert rl_handler.remote_closed_ct
receiver1.close()
self.process_connections()
assert sl_handler.closed_ct
assert sl_handler.active_ct == 0
assert cb.count
assert cb.status == pyngus.SenderLink.ABORTED
def test_08a_test_strip_message_annotations_out(self):
addr = self.router.addresses[3]+"/strip_message_annotations_out/1"
M1 = self.messenger()
M2 = self.messenger()
M1.start()
M2.start()
M2.subscribe(addr)
ingress_message = Message()
ingress_message.address = addr
ingress_message.body = {'message': 'Hello World!'}
#Put and send the message
M1.put(ingress_message)
M1.send()
# Receive the message
M2.recv(1)
egress_message = Message()
M2.get(egress_message)
self.assertEqual(egress_message.annotations, None)
M1.stop()
M2.stop()
def test_13_to_override(self):
addr = self.address+"/toov/1"
M1 = self.messenger()
M2 = self.messenger()
M1.start()
M2.start()
M2.subscribe(addr)
tm = Message()
rm = Message()
tm.address = addr
##
## Pre-existing TO
##
tm.annotations = {'x-opt-qd.to': 'toov/1'}
for i in range(10):
tm.body = {'number': i}
M1.put(tm)
M1.send()
for i in range(10):
M2.recv(1)
M2.get(rm)
self.assertEqual(i, rm.body['number'])
ma = rm.annotations
self.assertEqual(ma.__class__, dict)
self.assertEqual(ma['x-opt-qd.to'], 'toov/1')
M1.stop()
M2.stop()
def test_08a_test_strip_message_annotations_out(self):
addr = self.router.addresses[3] + "/strip_message_annotations_out/1"
M1 = self.messenger()
M2 = self.messenger()
M1.start()
M2.start()
M2.subscribe(addr)
ingress_message = Message()
ingress_message.address = addr
ingress_message.body = {'message': 'Hello World!'}
#Put and send the message
M1.put(ingress_message)
M1.send()
# Receive the message
M2.recv(1)
egress_message = Message()
M2.get(egress_message)
self.assertEqual(egress_message.annotations, None)
M1.stop()
M2.stop()
def test_02a_multicast_unsettled(self):
addr = "amqp:/multicast.2"
M1 = self.messenger()
M2 = self.messenger()
M3 = self.messenger()
M4 = self.messenger()
M1.route("amqp:/*", self.routers[0].addresses[0]+"/$1")
M2.route("amqp:/*", self.routers[1].addresses[0]+"/$1")
M3.route("amqp:/*", self.routers[0].addresses[0]+"/$1")
M4.route("amqp:/*", self.routers[1].addresses[0]+"/$1")
M1.outgoing_window = 5
M2.incoming_window = 5
M3.incoming_window = 5
M4.incoming_window = 5
M1.start()
M2.start()
M3.start()
M4.start()
M2.subscribe(addr)
M3.subscribe(addr)
M4.subscribe(addr)
self.routers[0].wait_address("multicast.2", 1, 1)
tm = Message()
rm = Message()
tm.address = addr
for i in range(2):
tm.body = {'number': i}
M1.put(tm)
M1.send(0)
for i in range(2):
M2.recv(1)
trk = M2.get(rm)
M2.accept(trk)
M2.settle(trk)
self.assertEqual(i, rm.body['number'])
M3.recv(1)
trk = M3.get(rm)
M3.accept(trk)
M3.settle(trk)
self.assertEqual(i, rm.body['number'])
M4.recv(1)
trk = M4.get(rm)
M4.accept(trk)
M4.settle(trk)
self.assertEqual(i, rm.body['number'])
M1.stop()
M2.stop()
M3.stop()
M4.stop()
def test_02a_multicast_unsettled(self):
addr = "amqp:/multicast.2"
M1 = self.messenger()
M2 = self.messenger()
M3 = self.messenger()
M4 = self.messenger()
M1.route("amqp:/*", self.routers[0].addresses[0] + "/$1")
M2.route("amqp:/*", self.routers[1].addresses[0] + "/$1")
M3.route("amqp:/*", self.routers[0].addresses[0] + "/$1")
M4.route("amqp:/*", self.routers[1].addresses[0] + "/$1")
M1.outgoing_window = 5
M2.incoming_window = 5
M3.incoming_window = 5
M4.incoming_window = 5
M1.start()
M2.start()
M3.start()
M4.start()
M2.subscribe(addr)
M3.subscribe(addr)
M4.subscribe(addr)
self.routers[0].wait_address("multicast.2", 1, 1)
tm = Message()
rm = Message()
tm.address = addr
for i in range(2):
tm.body = {'number': i}
M1.put(tm)
M1.send(0)
for i in range(2):
M2.recv(1)
trk = M2.get(rm)
M2.accept(trk)
M2.settle(trk)
self.assertEqual(i, rm.body['number'])
M3.recv(1)
trk = M3.get(rm)
M3.accept(trk)
M3.settle(trk)
self.assertEqual(i, rm.body['number'])
M4.recv(1)
trk = M4.get(rm)
M4.accept(trk)
M4.settle(trk)
self.assertEqual(i, rm.body['number'])
M1.stop()
M2.stop()
M3.stop()
M4.stop()
def _request_msg(self, properties, body=None):
"""
Create a management request message
"""
req = Message()
req.properties = properties
req.body = body or {}
return req
def on_sendable(self, event):
while event.sender.credit and self.sent < self.total:
msg = Message(id=(self.sent + 1))
msg.body = self.sent
# msg.address = address
# msg.reply_to = reply_to
event.sender.send(msg)
self.sent += 1
def test_10_semantics_multicast(self):
addr = "amqp:/multicast.1"
M1 = self.messenger()
M2 = self.messenger()
M3 = self.messenger()
M4 = self.messenger()
M1.route("amqp:/*", self.routers[0].addresses[0]+"/$1")
M2.route("amqp:/*", self.routers[1].addresses[0]+"/$1")
M3.route("amqp:/*", self.routers[0].addresses[0]+"/$1")
M4.route("amqp:/*", self.routers[1].addresses[0]+"/$1")
M1.start()
M2.start()
M3.start()
M4.start()
M2.subscribe(addr)
M3.subscribe(addr)
M4.subscribe(addr)
self.routers[0].wait_address("multicast.1", 1, 1)
tm = Message()
rm = Message()
tm.address = addr
for i in range(100):
tm.body = {'number': i}
M1.put(tm)
M1.send()
for i in range(100):
try:
M2.recv(1)
M2.get(rm)
self.assertEqual(i, rm.body['number'])
except:
print "M2 at", i
try:
M3.recv(1)
M3.get(rm)
self.assertEqual(i, rm.body['number'])
except:
print "M3 at", i
try:
M4.recv(1)
M4.get(rm)
self.assertEqual(i, rm.body['number'])
except:
print "M4 at", i
M1.stop()
M2.stop()
M3.stop()
M4.stop()
def test_00_discard(self):
addr = self.routers[0].addresses[0]+"/discard/1"
M1 = self.messenger()
tm = Message()
tm.address = addr
for i in range(100):
tm.body = {'number': i}
M1.put(tm)
M1.send()
def test_10_semantics_multicast(self):
addr = "amqp:/multicast.1"
M1 = self.messenger()
M2 = self.messenger()
M3 = self.messenger()
M4 = self.messenger()
M1.route("amqp:/*", self.routers[0].addresses[0] + "/$1")
M2.route("amqp:/*", self.routers[1].addresses[0] + "/$1")
M3.route("amqp:/*", self.routers[0].addresses[0] + "/$1")
M4.route("amqp:/*", self.routers[1].addresses[0] + "/$1")
M1.start()
M2.start()
M3.start()
M4.start()
M2.subscribe(addr)
M3.subscribe(addr)
M4.subscribe(addr)
self.routers[0].wait_address("multicast.1", 1, 1)
tm = Message()
rm = Message()
tm.address = addr
for i in range(100):
tm.body = {'number': i}
M1.put(tm)
M1.send()
for i in range(100):
try:
M2.recv(1)
M2.get(rm)
self.assertEqual(i, rm.body['number'])
except:
print "M2 at", i
try:
M3.recv(1)
M3.get(rm)
self.assertEqual(i, rm.body['number'])
except:
print "M3 at", i
try:
M4.recv(1)
M4.get(rm)
self.assertEqual(i, rm.body['number'])
except:
print "M4 at", i
M1.stop()
M2.stop()
M3.stop()
M4.stop()
def test_send_expired_no_callback(self):
sender, receiver = self._setup_receiver_sync()
rl_handler = receiver.user_context
msg = Message()
msg.body = "Hi"
sender.send(msg, deadline=10)
assert sender.pending == 1
self.process_connections(timestamp=12)
assert rl_handler.message_received_ct == 0
assert sender.pending == 0
def test_send_expired_no_callback(self):
sender, receiver = self._setup_receiver_sync()
rl_handler = receiver.user_context
msg = Message()
msg.body = "Hi"
sender.send(msg, deadline=10)
assert sender.pending == 1
self.process_connections(timestamp=12)
assert rl_handler.message_received_ct == 0
assert sender.pending == 0
def departures_today_handler(self,
icao24: str,
context: Optional[Any] = None) -> Message:
departures = self._get_departures_today(icao24)
message = Message()
message.content_type = 'application/json'
message.body = json.dumps(departures)
return message
def arrivals_today_handler(self,
icao24: str,
context: Optional[Any] = None) -> Message:
arrivals = self._get_arrivals_today(icao24)
message = Message()
message.content_type = 'application/json'
message.body = json.dumps(arrivals)
return message
def test_02a_multicast_unsettled(self):
addr = self.address+"/multicast.unsettled.1"
M1 = self.messenger()
M2 = self.messenger()
M3 = self.messenger()
M4 = self.messenger()
M1.outgoing_window = 5
M2.incoming_window = 5
M3.incoming_window = 5
M4.incoming_window = 5
M1.start()
M2.start()
M3.start()
M4.start()
M2.subscribe(addr)
M3.subscribe(addr)
M4.subscribe(addr)
tm = Message()
rm = Message()
tm.address = addr
for i in range(2):
tm.body = {'number': i}
M1.put(tm)
M1.send(0)
for i in range(2):
M2.recv(1)
trk = M2.get(rm)
M2.accept(trk)
M2.settle(trk)
self.assertEqual(i, rm.body['number'])
M3.recv(1)
trk = M3.get(rm)
M3.accept(trk)
M3.settle(trk)
self.assertEqual(i, rm.body['number'])
M4.recv(1)
trk = M4.get(rm)
M4.accept(trk)
M4.settle(trk)
self.assertEqual(i, rm.body['number'])
M1.stop()
M2.stop()
M3.stop()
M4.stop()
def test_02a_multicast_unsettled(self):
addr = self.address+"/multicast.unsettled.1"
M1 = self.messenger()
M2 = self.messenger()
M3 = self.messenger()
M4 = self.messenger()
M1.outgoing_window = 5
M2.incoming_window = 5
M3.incoming_window = 5
M4.incoming_window = 5
M1.start()
M2.start()
M3.start()
M4.start()
M2.subscribe(addr)
M3.subscribe(addr)
M4.subscribe(addr)
tm = Message()
rm = Message()
tm.address = addr
for i in range(2):
tm.body = {'number': i}
M1.put(tm)
M1.send(0)
for i in range(2):
M2.recv(1)
trk = M2.get(rm)
M2.accept(trk)
M2.settle(trk)
self.assertEqual(i, rm.body['number'])
M3.recv(1)
trk = M3.get(rm)
M3.accept(trk)
M3.settle(trk)
self.assertEqual(i, rm.body['number'])
M4.recv(1)
trk = M4.get(rm)
M4.accept(trk)
M4.settle(trk)
self.assertEqual(i, rm.body['number'])
M1.stop()
M2.stop()
M3.stop()
M4.stop()
def test_send_presettled(self):
sender, receiver = self._setup_sender_sync()
rl_handler = receiver.user_context
msg = Message()
msg.body = "Hi"
sender.send(msg)
receiver.add_capacity(1)
self.process_connections()
assert rl_handler.message_received_ct == 1
msg2, handle = rl_handler.received_messages[0]
assert msg2.body == "Hi"
receiver.message_accepted(handle)
def test_05_three_ack(self):
addr = "amqp:/three_ack/1"
M1 = self.messenger()
M2 = self.messenger()
M1.route("amqp:/*", self.routers[0].addresses[0] + "/$1")
M2.route("amqp:/*", self.routers[1].addresses[0] + "/$1")
M1.outgoing_window = 5
M2.incoming_window = 5
M1.start()
M2.start()
M2.subscribe(addr)
self.routers[0].wait_address("three_ack/1", 0, 1)
tm = Message()
rm = Message()
tm.address = addr
tm.body = {'number': 200}
tx_tracker = M1.put(tm)
M1.send(0)
M2.recv(1)
rx_tracker = M2.get(rm)
self.assertEqual(200, rm.body['number'])
self.assertEqual(PENDING, M1.status(tx_tracker))
M2.accept(rx_tracker)
M2.flush()
M1.flush()
self.assertEqual(ACCEPTED, M1.status(tx_tracker))
M1.settle(tx_tracker)
M1.flush()
M2.flush()
##
## We need a way to verify on M2 (receiver) that the tracker has been
## settled on the M1 (sender). [ See PROTON-395 ]
##
M2.settle(rx_tracker)
M2.flush()
M1.flush()
M1.stop()
M2.stop()
def test_05_three_ack(self):
addr = "amqp:/three_ack/1"
M1 = self.messenger()
M2 = self.messenger()
M1.route("amqp:/*", self.routers[0].addresses[0]+"/$1")
M2.route("amqp:/*", self.routers[1].addresses[0]+"/$1")
M1.outgoing_window = 5
M2.incoming_window = 5
M1.start()
M2.start()
M2.subscribe(addr)
self.routers[0].wait_address("three_ack/1", 0, 1)
tm = Message()
rm = Message()
tm.address = addr
tm.body = {'number': 200}
tx_tracker = M1.put(tm)
M1.send(0)
M2.recv(1)
rx_tracker = M2.get(rm)
self.assertEqual(200, rm.body['number'])
self.assertEqual(PENDING, M1.status(tx_tracker))
M2.accept(rx_tracker)
M2.flush()
M1.flush()
self.assertEqual(ACCEPTED, M1.status(tx_tracker))
M1.settle(tx_tracker)
M1.flush()
M2.flush()
##
## We need a way to verify on M2 (receiver) that the tracker has been
## settled on the M1 (sender). [ See PROTON-395 ]
##
M2.settle(rx_tracker)
M2.flush()
M1.flush()
M1.stop()
M2.stop()
def test_send_presettled(self):
sender, receiver = self._setup_sender_sync()
rl_handler = receiver.user_context
msg = Message()
msg.body = "Hi"
sender.send(msg)
receiver.add_capacity(1)
self.process_connections()
assert rl_handler.message_received_ct == 1
msg2, handle = rl_handler.received_messages[0]
assert msg2.body == "Hi"
receiver.message_accepted(handle)
def test_send_close_on_ack(self):
"""Verify that the sender can close itself when delivery complete."""
class SendDoneCallback(common.DeliveryCallback):
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
sender, receiver = self._setup_sender_sync()
rl_handler = receiver.user_context
sl_handler = sender.user_context
receiver.add_capacity(1)
msg = Message()
msg.body = "Hi"
cb = SendDoneCallback()
sender.send(msg, cb, "my-handle")
# no credit - this one won't get sent:
sender.send(msg, cb, "my-handle")
self.process_connections()
assert sender.active
assert rl_handler.message_received_ct == 1
msg2, handle = rl_handler.received_messages[0]
receiver.message_accepted(handle)
self.process_connections()
assert not sender.active
assert not sender.closed
# pending messages are aborted when close completes:
assert cb.count == 1
assert sl_handler.closed_ct == 0
receiver.close()
self.process_connections()
assert sender.closed
assert sl_handler.closed_ct
assert cb.count == 2
# last callback should be abort:
cond = cb.info.get('condition')
assert cond
assert cond.name == "indigestion"
assert cb.status == pyngus.SenderLink.ABORTED
def test_send_close_on_ack(self):
"""Verify that the sender can close itself when delivery complete."""
class SendDoneCallback(common.DeliveryCallback):
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
sender, receiver = self._setup_sender_sync()
rl_handler = receiver.user_context
sl_handler = sender.user_context
receiver.add_capacity(1)
msg = Message()
msg.body = "Hi"
cb = SendDoneCallback()
sender.send(msg, cb, "my-handle")
# no credit - this one won't get sent:
sender.send(msg, cb, "my-handle")
self.process_connections()
assert sender.active
assert rl_handler.message_received_ct == 1
msg2, handle = rl_handler.received_messages[0]
receiver.message_accepted(handle)
self.process_connections()
assert not sender.active
assert not sender.closed
# pending messages are aborted when close completes:
assert cb.count == 1
assert sl_handler.closed_ct == 0
receiver.close()
self.process_connections()
assert sender.closed
assert sl_handler.closed_ct
assert cb.count == 2
# last callback should be abort:
cond = cb.info.get('condition')
assert cond
assert cond.name == "indigestion"
assert cb.status == pyngus.SenderLink.ABORTED
def test_11b_semantics_closest_is_remote(self):
addr = "amqp:/closest.2"
M1 = self.messenger()
M2 = self.messenger()
M3 = self.messenger()
M4 = self.messenger()
M1.route("amqp:/*", self.routers[0].addresses[0]+"/$1")
M2.route("amqp:/*", self.routers[1].addresses[0]+"/$1")
M3.route("amqp:/*", self.routers[0].addresses[0]+"/$1")
M4.route("amqp:/*", self.routers[1].addresses[0]+"/$1")
M1.start()
M2.start()
M3.start()
M4.start()
M2.subscribe(addr)
M4.subscribe(addr)
self.routers[0].wait_address("closest.2", 0, 1)
tm = Message()
rm = Message()
tm.address = addr
for i in range(30):
tm.body = {'number': i}
M1.put(tm)
M1.send()
i = 0
rx_set = []
for i in range(15):
M2.recv(1)
M2.get(rm)
rx_set.append(rm.body['number'])
M4.recv(1)
M4.get(rm)
rx_set.append(rm.body['number'])
self.assertEqual(30, len(rx_set))
rx_set.sort()
for i in range(30):
self.assertEqual(i, rx_set[i])
M1.stop()
M2.stop()
M3.stop()
M4.stop()
def _send_request(self):
"""Send a message containing the RPC method call
"""
msg = Message()
msg.subject = "An RPC call!"
msg.address = self._to
msg.reply_to = self._reply_to
msg.body = self._method
msg.correlation_id = 5 # whatever...
print("sending RPC call request: %s" % str(self._method))
# @todo send timeout self._sender.send(msg, self, None, time.time() +
# 10)
self._sender.send(msg, self)
def test_11_semantics_closest(self):
addr = self.address+"/closest.1"
M1 = self.messenger()
M2 = self.messenger()
M3 = self.messenger()
M4 = self.messenger()
M1.start()
M2.start()
M3.start()
M4.start()
M2.subscribe(addr)
M3.subscribe(addr)
M4.subscribe(addr)
tm = Message()
rm = Message()
tm.address = addr
for i in range(30):
tm.body = {'number': i}
M1.put(tm)
M1.send()
i = 0
rx_set = []
for i in range(10):
M2.recv(1)
M2.get(rm)
rx_set.append(rm.body['number'])
M3.recv(1)
M3.get(rm)
rx_set.append(rm.body['number'])
M4.recv(1)
M4.get(rm)
rx_set.append(rm.body['number'])
self.assertEqual(30, len(rx_set))
rx_set.sort()
for i in range(30):
self.assertEqual(i, rx_set[i])
M1.stop()
M2.stop()
M3.stop()
M4.stop()
def _send_request(self):
"""Send a message containing the RPC method call
"""
msg = Message()
msg.subject = "An RPC call!"
msg.address = self._to
msg.reply_to = self._reply_to
msg.body = self._method
msg.correlation_id = 5 # whatever...
print("sending RPC call request: %s" % str(self._method))
# @todo send timeout self._sender.send(msg, self, None, time.time() +
# 10)
self._sender.send(msg, self)
def test_11b_semantics_closest_is_remote(self):
addr = "amqp:/closest.2"
M1 = self.messenger()
M2 = self.messenger()
M3 = self.messenger()
M4 = self.messenger()
M1.route("amqp:/*", self.routers[0].addresses[0] + "/$1")
M2.route("amqp:/*", self.routers[1].addresses[0] + "/$1")
M3.route("amqp:/*", self.routers[0].addresses[0] + "/$1")
M4.route("amqp:/*", self.routers[1].addresses[0] + "/$1")
M1.start()
M2.start()
M3.start()
M4.start()
M2.subscribe(addr)
M4.subscribe(addr)
self.routers[0].wait_address("closest.2", 0, 1)
tm = Message()
rm = Message()
tm.address = addr
for i in range(30):
tm.body = {'number': i}
M1.put(tm)
M1.send()
i = 0
rx_set = []
for i in range(15):
M2.recv(1)
M2.get(rm)
rx_set.append(rm.body['number'])
M4.recv(1)
M4.get(rm)
rx_set.append(rm.body['number'])
self.assertEqual(30, len(rx_set))
rx_set.sort()
for i in range(30):
self.assertEqual(i, rx_set[i])
M1.stop()
M2.stop()
M3.stop()
M4.stop()
def test_11_semantics_closest(self):
addr = self.address+"/closest.1"
M1 = self.messenger()
M2 = self.messenger()
M3 = self.messenger()
M4 = self.messenger()
M1.start()
M2.start()
M3.start()
M4.start()
M2.subscribe(addr)
M3.subscribe(addr)
M4.subscribe(addr)
tm = Message()
rm = Message()
tm.address = addr
for i in range(30):
tm.body = {'number': i}
M1.put(tm)
M1.send()
i = 0
rx_set = []
for i in range(10):
M2.recv(1)
M2.get(rm)
rx_set.append(rm.body['number'])
M3.recv(1)
M3.get(rm)
rx_set.append(rm.body['number'])
M4.recv(1)
M4.get(rm)
rx_set.append(rm.body['number'])
self.assertEqual(30, len(rx_set))
rx_set.sort()
for i in range(30):
self.assertEqual(i, rx_set[i])
M1.stop()
M2.stop()
M3.stop()
M4.stop()
def test_08a_test_strip_message_annotations_both_add_ingress_trace(self):
addr = "amqp:/strip_message_annotations_both_add_ingress_trace/1"
M1 = self.messenger()
M2 = self.messenger()
M1.route("amqp:/*", self.routers[0].addresses[2] + "/$1")
M2.route("amqp:/*", self.routers[1].addresses[2] + "/$1")
M1.start()
M2.start()
M2.subscribe(addr)
self.routers[0].wait_address(
"strip_message_annotations_both_add_ingress_trace/1", 0, 1)
ingress_message = Message()
ingress_message.address = addr
ingress_message.body = {'message': 'Hello World!'}
##
# Pre-existing ingress and trace. Intentionally populate the trace with the 0/QDR.A which is the trace
# of the first router. If the inbound annotations were not stripped, the router would drop this message
# since it would consider this message as being looped.
#
ingress_message_annotations = {
'work': 'hard',
'x-opt-qd': 'humble',
'x-opt-qd.ingress': 'ingress-router',
'x-opt-qd.trace': ['0/QDR.A']
}
ingress_message.annotations = ingress_message_annotations
#Put and send the message
M1.put(ingress_message)
M1.send()
# Receive the message
M2.recv(1)
egress_message = Message()
M2.get(egress_message)
# Router specific annotations (annotations with prefix "x-opt-qd.") will be stripped. User defined annotations will not be stripped.
self.assertEqual(egress_message.annotations, {
'work': 'hard',
'x-opt-qd': 'humble'
})
M1.stop()
M2.stop()
def test_08a_test_strip_message_annotations_no_add_trace(self):
addr = "amqp:/strip_message_annotations_no_add_trace/1"
M1 = self.messenger()
M2 = self.messenger()
M1.route("amqp:/*", self.routers[0].addresses[1] + "/$1")
M2.route("amqp:/*", self.routers[1].addresses[1] + "/$1")
M1.start()
M2.start()
M2.subscribe(addr)
self.routers[0].wait_address(
"strip_message_annotations_no_add_trace/1", 0, 1)
ingress_message = Message()
ingress_message.address = addr
ingress_message.body = {'message': 'Hello World!'}
##
## Pre-existing ingress and trace
##
#ingress_message_annotations = {'x-opt-qd.ingress': 'ingress-router', 'x-opt-qd.trace': ['0/QDR.1']}
ingress_message_annotations = {'x-opt-qd.trace': ['0/QDR.1']}
ingress_message.annotations = ingress_message_annotations
ingress_message.annotations = ingress_message_annotations
M1.put(ingress_message)
M1.send()
# Receive the message
M2.recv(1)
egress_message = Message()
M2.get(egress_message)
#Make sure 'Hello World!' is in the message body dict
self.assertEqual('Hello World!', egress_message.body['message'])
egress_message_annotations = egress_message.annotations
self.assertEqual(egress_message_annotations.__class__, dict)
self.assertEqual(egress_message_annotations['x-opt-qd.ingress'],
'0/QDR.A')
self.assertEqual(egress_message_annotations['x-opt-qd.trace'],
['0/QDR.1', '0/QDR.A', '0/QDR.B'])
M1.stop()
M2.stop()
def test_send_expired_no_credit(self):
cb = common.DeliveryCallback()
sender, receiver = self._setup_receiver_sync()
rl_handler = receiver.user_context
msg = Message()
msg.body = "Hi"
sender.send(msg, cb, "my-handle", deadline=10)
# receiver.add_capacity(1)
self.process_connections(timestamp=9)
assert rl_handler.message_received_ct == 0
assert sender.pending == 1
assert cb.status is None
self.process_connections(timestamp=10)
assert sender.pending == 0
assert cb.status == pyngus.SenderLink.TIMED_OUT
def test_send_deadline_idle(self):
"""Validate the connection's deadline processing."""
self.teardown()
self.setup(conn1_props={"idle-time-out": 99})
sender1 = self.conn1.create_sender("src1", "tgt1")
sender1.open()
self.process_connections(timestamp=1)
assert self.conn2_handler.receiver_requested_ct == 1
args = self.conn2_handler.receiver_requested_args[0]
receiver1 = self.conn2.accept_receiver(args.link_handle)
receiver1.open()
sender2 = self.conn1.create_sender("src2", "tgt2")
sender2.open()
self.process_connections(timestamp=1)
assert self.conn2_handler.receiver_requested_ct == 2
args = self.conn2_handler.receiver_requested_args[1]
receiver2 = self.conn2.accept_receiver(args.link_handle)
receiver2.open()
self.process_connections(timestamp=1)
assert self.conn1.deadline == 100.0
msg = Message()
msg.body = "Hi"
sender1.send(msg, deadline=11)
assert self.conn1.deadline == 11
self.process_connections(timestamp=2)
assert self.conn1.deadline == 11
sender2.send(msg, deadline=7)
assert self.conn1.deadline == 7
self.process_connections(timestamp=7)
assert self.conn1.deadline == 11
self.process_connections(timestamp=11)
assert self.conn1.deadline == 100
# next send timeout after the idle keepalive:
sender1.send(msg, deadline=101)
self.process_connections(timestamp=11)
assert self.conn1.deadline == 100
# have remote send idle, next deadline should
# be the pending send:
self.process_connections(timestamp=self.conn2.deadline)
assert self.conn1.deadline == 101
def test_send_released(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]
receiver.message_released(handle)
self.process_connections()
assert cb.link == sender
assert cb.handle == "my-handle"
assert cb.status == pyngus.SenderLink.RELEASED
def test_08a_test_strip_message_annotations_no_add_trace(self):
addr = "amqp:/strip_message_annotations_no_add_trace/1"
M1 = self.messenger()
M2 = self.messenger()
M1.route("amqp:/*", self.routers[0].addresses[1]+"/$1")
M2.route("amqp:/*", self.routers[1].addresses[1]+"/$1")
M1.start()
M2.start()
M2.subscribe(addr)
self.routers[0].wait_address("strip_message_annotations_no_add_trace/1", 0, 1)
ingress_message = Message()
ingress_message.address = addr
ingress_message.body = {'message': 'Hello World!'}
##
## Pre-existing ingress and trace
##
#ingress_message_annotations = {'x-opt-qd.ingress': 'ingress-router', 'x-opt-qd.trace': ['0/QDR.1']}
ingress_message_annotations = {'x-opt-qd.trace': ['0/QDR.1']}
ingress_message.annotations = ingress_message_annotations
ingress_message.annotations = ingress_message_annotations
M1.put(ingress_message)
M1.send()
# Receive the message
M2.recv(1)
egress_message = Message()
M2.get(egress_message)
#Make sure 'Hello World!' is in the message body dict
self.assertEqual('Hello World!', egress_message.body['message'])
egress_message_annotations = egress_message.annotations
self.assertEqual(egress_message_annotations.__class__, dict)
self.assertEqual(egress_message_annotations['x-opt-qd.ingress'], '0/QDR.A')
self.assertEqual(egress_message_annotations['x-opt-qd.trace'], ['0/QDR.1', '0/QDR.A', '0/QDR.B'])
M1.stop()
M2.stop()
def test_04_unsettled_undeliverable(self):
addr = self.routers[0].addresses[0]+"/unsettled_undeliverable/1"
M1 = self.messenger()
M1.outgoing_window = 5
M1.start()
tm = Message()
tm.address = addr
tm.body = {'number': 200}
tx_tracker = M1.put(tm)
M1.send(0)
M1.flush()
self.assertEqual(MODIFIED, M1.status(tx_tracker))
M1.stop()
