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 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 send ( self ) :
if self.sender.credit <= 0:
self.receiver.flow ( 100 )
return
# First send the payload messages.
if self.n_sent < self.n_messages :
for i in range(50) :
msg = Message ( body=self.n_sent )
msg.priority = 3
self.sender.send ( msg )
self.n_sent += 1
# Then send the management queries.
# But only send them once.
elif not self.sent_queries :
# Query router A.
mgmt_helper = self.routers['A'] ['mgmt_helper']
mgmt_sender = self.routers['A'] ['mgmt_sender']
msg = mgmt_helper.make_router_link_query ( )
mgmt_sender.send ( msg )
# Query router B.
mgmt_helper = self.routers['B'] ['mgmt_helper']
mgmt_sender = self.routers['B'] ['mgmt_sender']
msg = mgmt_helper.make_router_link_query ( )
mgmt_sender.send ( msg )
self.sent_queries = True
def test_09c_management_get_operations(self):
addr = "amqp:/_local/$management"
M = self.messenger()
M.start()
M.route("amqp:/*", self.address+"/$1")
sub = M.subscribe("amqp:/#")
reply = sub.address
request = Message()
response = Message()
##
## Unrestricted request
##
request.address = addr
request.reply_to = reply
request.properties = {u'type':u'org.amqp.management', u'name':u'self', u'operation':u'GET-OPERATIONS'}
M.put(request)
M.send()
M.recv()
M.get(response)
self.assertEqual(response.properties['statusCode'], 200)
self.assertEqual(response.body.__class__, dict)
self.assertTrue('org.apache.qpid.dispatch.router' in response.body.keys())
self.assertTrue(len(response.body.keys()) > 2)
self.assertTrue(response.body['org.apache.qpid.dispatch.router'].__class__, list)
M.stop()
def on_sendable(self, event):
if self.num_sent < 1:
msg = Message(id=1, body='Hello World')
# this is a unavailable address
msg.address = "SomeUnavailableAddress"
event.sender.send(msg)
self.num_sent += 1
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_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_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_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_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_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_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_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_09d_management_not_implemented(self):
addr = "amqp:/$management"
M = self.messenger()
M.start()
M.route("amqp:/*", self.address+"/$1")
sub = M.subscribe("amqp:/#")
reply = sub.address
request = Message()
response = Message()
##
## Request with an invalid operation
##
request.address = addr
request.reply_to = reply
request.properties = {u'type':u'org.amqp.management', u'name':u'self', u'operation':u'NOT-IMPL'}
M.put(request)
M.send()
M.recv()
M.get(response)
self.assertEqual(response.properties['statusCode'], 501)
M.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_custom_annotations_match(self):
"""
The linkRoute on Routers C and B is set to org.apache.
Creates a receiver listening on the address 'org.apache' and a sender that sends to address 'org.apache'.
Sends a message with custom annotations to org.apache via router QDR.C and makes sure that the message was successfully
routed (using full address matching) and received using pre-created links that were created as a
result of specifying addresses in the linkRoute attribute('org.apache.'). Make sure custom annotations arrived as well.
"""
hello_world_3 = "Hello World_3!"
# Connects to listener #2 on QDR.C
addr = self.routers[2].addresses[0]
blocking_connection = BlockingConnection(addr)
# Receive on org.apache
blocking_receiver = blocking_connection.create_receiver(address="org.apache")
apply_options = AtMostOnce()
# Sender to to org.apache
blocking_sender = blocking_connection.create_sender(address="org.apache", options=apply_options)
msg = Message(body=hello_world_3)
annotations = {'custom-annotation': '1/Custom_Annotation'}
msg.annotations = annotations
# Send a message
blocking_sender.send(msg)
received_message = blocking_receiver.receive()
self.assertEqual(hello_world_3, received_message.body)
self.assertEqual(received_message.annotations, annotations)
blocking_connection.close()
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 on_delivery(self, event):
rcv = event.receiver
msg = Message()
if rcv and msg.recv(rcv):
event.delivery.settle()
self.messages += [msg.body]
self.count -= 1
if (self.count == 0):
self.acceptor.close()
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 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_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 send(self, response, reply_to):
sender = self.relay
if not sender:
sender = self.senders.get(reply_to)
if not sender:
sender = self.container.create_sender(self.conn, reply_to)
self.senders[reply_to] = sender
msg = Message(body=response)
if self.relay:
msg.address = reply_to
sender.send_msg(msg)
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_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 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()
class ReconnectTests(unittest.TestCase):
def setUp(self):
with TestPort() as tp:
self.server = DisconnectServer(tp.addr)
def tearDown(self):
self.server.stop()
def test_reconnect_delays(self):
self.assertEquals([0, 1, 2, 4, 7, 7, 7, 7],
list(ReconnectDelays(1, 7, 3)))
self.assertEquals([0, .2, .4, .8, 1.0], list(ReconnectDelays(.2, 1,
0)))
self.assertRaises(ValueError, ReconnectDelays, 0, 1)
self.assertRaises(ValueError, ReconnectDelays, 1, -1)
d = iter(ReconnectDelays(5, 5)) # 5's forever
self.assertEquals(0, d.next())
for x in xrange(100):
self.assertEquals(5, d.next())
query_response = Message(body=[],
properties={
"method": "response",
"qmf.agent": "broker",
"qmf.content": "_data",
"qmf.opcode": "_query_response"
})
method_response = Message(body={"_arguments": []},
properties={
"method": "response",
"qmf.agent": "broker",
"qmf.content": "_data",
"qmf.opcode": "_method_response"
})
def test_reconnect_agent(self):
# Dummy response message
self.server.response = self.query_response
# Failure during initial connection should raise an exception, no reconnect
self.server.disconnect.put(True)
self.assertRaises(ConnectionException,
BrokerAgent.connect,
self.server.addr,
reconnect_delays=[0, 0, 0])
self.assertEquals(Event.LINK_REMOTE_OPEN,
self.server.disconnected.get())
agent = BrokerAgent.connect(self.server.addr,
reconnect_delays=[0, 0, 0])
agent.getBroker() # Should work OK
self.server.disconnect.put(True) # Disconnect on message delivery
self.server.disconnect.put(
True) # Disconnect first reconnect on link open
self.server.disconnect.put(
True) # Disconnect second reconnect on link open
agent.getBroker()
self.assertEquals(Event.DELIVERY, self.server.disconnected.get())
self.assertEquals(Event.LINK_REMOTE_OPEN,
self.server.disconnected.get())
self.assertEquals(Event.LINK_REMOTE_OPEN,
self.server.disconnected.get())
# Try a healthy get
agent.getBroker()
self.server.disconnect.put(True)
agent.list("foo")
self.assertEquals(Event.DELIVERY, self.server.disconnected.get())
self.server.disconnect.put(True)
agent.getConnection("foo")
self.assertEquals(Event.DELIVERY, self.server.disconnected.get())
# Try a method call
self.server.response = self.method_response
self.server.disconnect.put(True)
agent.echo()
self.assertEquals(Event.DELIVERY, self.server.disconnected.get())
# We should give up after 4 disconnects
self.server.disconnect.put(True)
self.server.disconnect.put(True)
self.server.disconnect.put(True)
self.server.disconnect.put(True)
self.assertRaises(ConnectionException, agent.echo)
def test_reconnect_agent_delay(self):
self.server.response = self.query_response
agent = BrokerAgent.connect(self.server.addr,
reconnect_delays=[0.1, 0.2])
def elapsed(f, *args, **kwargs):
t = time.time()
f(*args, **kwargs)
return time.time() - t
self.server.disconnect.put(True)
self.assertLess(0.1, elapsed(agent.getBroker))
self.server.disconnect.put(True)
self.server.disconnect.put(True)
self.assertLess(0.3, elapsed(agent.getBroker))
def recv_msg(delivery):
msg = Message()
msg.decode(delivery.link.recv(delivery.pending))
delivery.link.advance()
return msg
def on_sendable(self, event):
if event.sender == self.sender:
while self.n_sent < self.count and event.sender.credit > 0:
msg = Message(body="AutoLinkTest")
self.sender.send(msg)
self.n_sent += 1
def query_conn_link_routes(self):
ap = {
'operation': 'QUERY',
'type': 'org.apache.qpid.dispatch.router.connection.linkRoute'
}
return Message(properties=ap, reply_to=self.reply_addr)
def on_sendable(self, event):
while self.sender.credit > 0 and self.sent < self.count:
msg = Message(body="Discard Test")
self.sender.send(msg)
self.sent += 1
def create_reply(self, message):
return Message(body=message.body,
correlation_id=message.correlation_id)
def on_sendable(self, event):
if self.sent_count < 10:
msg = Message(body="Hello World", properties={'seq': self.sent_count})
dlv = event.sender.send(msg)
dlv.settle()
self.sent_count += 1
def test_forwarding_sync(self):
"""
Forward unsettled messages to multiple subscribers
"""
config = [('router', {
'mode': 'standalone',
'id': 'QDR.mcast',
'allowUnsettledMulticast': True
}),
('listener', {
'role': 'normal',
'host': '0.0.0.0',
'port': self.tester.get_port(),
'saslMechanisms': 'ANONYMOUS'
}),
('address', {
'pattern': 'nextHop2/#',
'distribution': 'multicast'
}),
('exchange', {
'address': 'Address3',
'name': 'Exchange1',
'alternateAddress': 'altNextHop'
}),
('binding', {
'name': 'binding1',
'exchangeName': 'Exchange1',
'bindingKey': 'a.b',
'nextHopAddress': 'nextHop1'
}),
('binding', {
'name': 'binding2',
'exchangeName': 'Exchange1',
'bindingKey': '*.b',
'nextHopAddress': 'nextHop2'
})]
router = self.tester.qdrouterd('QDR.mcast', Qdrouterd.Config(config))
# create clients for message transfer
conn = BlockingConnection(router.addresses[0])
sender = conn.create_sender(address="Address3", options=AtLeastOnce())
nhop1 = AsyncTestReceiver(address=router.addresses[0],
source="nextHop1")
nhop2A = AsyncTestReceiver(address=router.addresses[0],
source="nextHop2")
nhop2B = AsyncTestReceiver(address=router.addresses[0],
source="nextHop2")
alt = AsyncTestReceiver(address=router.addresses[0],
source="altNextHop")
sender.send(Message(subject='a.b', body='A'))
sender.send(Message(subject='x.y', body='B'))
self.assertEqual('A', nhop1.queue.get(timeout=TIMEOUT).body)
self.assertEqual('A', nhop2A.queue.get(timeout=TIMEOUT).body)
self.assertEqual('A', nhop2B.queue.get(timeout=TIMEOUT).body)
self.assertEqual('B', alt.queue.get(timeout=TIMEOUT).body)
nhop1.stop()
nhop2A.stop()
nhop2B.stop()
alt.stop()
conn.close()
self.assertTrue(nhop1.queue.empty())
self.assertTrue(nhop2A.queue.empty())
self.assertTrue(nhop2B.queue.empty())
self.assertTrue(alt.queue.empty())
# ensure failure if unsettled multicast not allowed:
config = [('router', {
'mode': 'standalone',
'id': 'QDR.mcast2',
'allowUnsettledMulticast': False
}),
('listener', {
'role': 'normal',
'host': '0.0.0.0',
'port': self.tester.get_port(),
'saslMechanisms': 'ANONYMOUS'
}), ('exchange', {
'address': 'Address4',
'name': 'Exchange1'
}),
('binding', {
'name': 'binding1',
'exchangeName': 'Exchange1',
'bindingKey': 'a.b',
'nextHopAddress': 'nextHop1'
})]
router = self.tester.qdrouterd('QDR.mcast2', Qdrouterd.Config(config))
# create clients for message transfer
conn = BlockingConnection(router.addresses[0])
sender = conn.create_sender(address="Address4", options=AtLeastOnce())
nhop1 = AsyncTestReceiver(address=router.addresses[0],
source="nextHop1")
self.assertRaises(SendException, sender.send,
Message(subject='a.b', body='A'))
nhop1.stop()
conn.close()
self.assertTrue(nhop1.queue.empty())
def test_remote_exchange(self):
"""
Verify that the exchange and bindings are visible to other routers in
the network
"""
def router(self, name, extra_config):
config = [('router', {
'mode': 'interior',
'id': 'QDR.%s' % name,
'allowUnsettledMulticast': 'yes'
}),
('listener', {
'port': self.tester.get_port(),
'stripAnnotations': 'no'
})] + extra_config
config = Qdrouterd.Config(config)
self.routers.append(self.tester.qdrouterd(name, config, wait=True))
self.inter_router_port = self.tester.get_port()
self.routers = []
router(self, 'A', [('listener', {
'role': 'inter-router',
'port': self.inter_router_port
}), ('address', {
'pattern': 'nextHop1/#',
'distribution': 'multicast'
}), ('address', {
'pattern': 'nextHop2/#',
'distribution': 'balanced'
}), ('address', {
'pattern': 'nextHop3/#',
'distribution': 'closest'
}),
('exchange', {
'address': 'AddressA',
'name': 'ExchangeA',
'matchMethod': 'mqtt'
}),
('binding', {
'name': 'bindingA1',
'exchangeName': 'ExchangeA',
'bindingKey': 'a/b',
'nextHopAddress': 'nextHop1'
}),
('binding', {
'name': 'bindingA2',
'exchangeName': 'ExchangeA',
'bindingKey': 'a/+',
'nextHopAddress': 'nextHop2'
}),
('binding', {
'name': 'bindingA3',
'exchangeName': 'ExchangeA',
'bindingKey': '+/b',
'nextHopAddress': 'nextHop3'
}),
('binding', {
'name': 'bindingA4',
'exchangeName': 'ExchangeA',
'bindingKey': 'a/#',
'nextHopAddress': 'NotSubscribed'
})])
router(self, 'B', [('connector', {
'name': 'connectorToA',
'role': 'inter-router',
'port': self.inter_router_port,
'verifyHostname': 'no'
}), ('address', {
'pattern': 'nextHop1/#',
'distribution': 'multicast'
}), ('address', {
'pattern': 'nextHop2/#',
'distribution': 'balanced'
}), ('address', {
'pattern': 'nextHop3/#',
'distribution': 'closest'
})])
self.routers[0].wait_router_connected('QDR.B')
self.routers[1].wait_router_connected('QDR.A')
self.routers[1].wait_address('AddressA')
# connect clients to router B (no exchange)
nhop1A = AsyncTestReceiver(self.routers[1].addresses[0], 'nextHop1')
nhop1B = AsyncTestReceiver(self.routers[1].addresses[0], 'nextHop1')
nhop2 = AsyncTestReceiver(self.routers[1].addresses[0], 'nextHop2')
nhop3 = AsyncTestReceiver(self.routers[1].addresses[0], 'nextHop3')
self.routers[0].wait_address('nextHop1', remotes=1)
self.routers[0].wait_address('nextHop2', remotes=1)
self.routers[0].wait_address('nextHop3', remotes=1)
conn = BlockingConnection(self.routers[1].addresses[0])
sender = conn.create_sender(address="AddressA", options=AtLeastOnce())
sender.send(Message(subject='a/b', body='Hi!'))
# multicast
self.assertEqual('Hi!', nhop1A.queue.get(timeout=TIMEOUT).body)
self.assertEqual('Hi!', nhop1B.queue.get(timeout=TIMEOUT).body)
# balanced and closest
self.assertEqual('Hi!', nhop2.queue.get(timeout=TIMEOUT).body)
self.assertEqual('Hi!', nhop3.queue.get(timeout=TIMEOUT).body)
nhop1A.stop()
nhop1B.stop()
nhop2.stop()
nhop3.stop()
conn.close()
def test_forwarding_mqtt(self):
"""
Simple forwarding over a single mqtt exchange
"""
config = [
('exchange', {
'address': 'Address2',
'name': 'Exchange1',
'matchMethod': 'mqtt',
'alternateAddress': 'altNextHop'
}),
('binding', {
'name': 'binding1',
'exchangeName': 'Exchange1',
'bindingKey': 'a/b',
'nextHopAddress': 'nextHop1'
}),
('binding', {
'name': 'binding2',
'exchangeName': 'Exchange1',
'bindingKey': 'a/+',
'nextHopAddress': 'nextHop2'
}),
('binding', {
'name': 'binding3',
'exchangeName': 'Exchange1',
'bindingKey': 'c/#',
'nextHopAddress': 'nextHop1'
}),
('binding', {
'name': 'binding4',
'exchangeName': 'Exchange1',
'bindingKey': 'c/b',
'nextHopAddress': 'nextHop2'
}),
]
router = self._create_router('B', config)
# create clients for message transfer
conn = BlockingConnection(router.addresses[0])
sender = conn.create_sender(address="Address2", options=AtMostOnce())
nhop1 = conn.create_receiver(address="nextHop1", credit=100)
nhop2 = conn.create_receiver(address="nextHop2", credit=100)
alt = conn.create_receiver(address="altNextHop", credit=100)
# send message with subject "a.b"
# matches (binding1, binding2)
# forwarded to NextHop1, NextHop2
sender.send(Message(subject='a/b', body='A'))
self.assertEqual('A', nhop1.receive(timeout=TIMEOUT).body)
self.assertEqual('A', nhop2.receive(timeout=TIMEOUT).body)
# send message with subject "a/c"
# matches binding2
# -> NextHop2
sender.send(Message(subject='a/c', body='B'))
self.assertEqual('B', nhop2.receive(timeout=TIMEOUT).body)
# send message with subject "c/b"
# matches bindings 3,4
# -> NextHop1, NextHop2
sender.send(Message(subject='c/b', body='C'))
self.assertEqual('C', nhop1.receive(timeout=TIMEOUT).body)
self.assertEqual('C', nhop2.receive(timeout=TIMEOUT).body)
# send message with subject "c/b/dee/eee"
# matches binding3
# -> NextHop1
sender.send(Message(subject='c/b/dee/eee', body='D'))
self.assertEqual('D', nhop1.receive(timeout=TIMEOUT).body)
# send message with subject "x.y.z"
# no binding match
# -> alternate
sender.send(Message(subject='x.y.z', body="?"))
self.assertEqual('?', alt.receive(timeout=TIMEOUT).body)
# ensure there are no more messages on either hop:
self.assertRaises(Timeout, nhop1.receive, timeout=0.25)
self.assertRaises(Timeout, nhop2.receive, timeout=0.25)
self.assertRaises(Timeout, alt.receive, timeout=0.25)
# validate counters
self._validate_binding(router, name='binding1', matchedCount=1)
self._validate_binding(router, name='binding2', matchedCount=2)
self._validate_binding(router, name='binding3', matchedCount=2)
self._validate_binding(router, name='binding4', matchedCount=1)
self._validate_exchange(router,
name="Exchange1",
receivedCount=5,
forwardedCount=5,
divertedCount=1,
droppedCount=0)
conn.close()
def test_forwarding(self):
"""
Simple forwarding over a single 0-10 exchange
"""
config = [
('exchange', {
'address': 'Address1',
'name': 'Exchange1',
'matchMethod': 'amqp'
}),
# two different patterns, same next hop:
('binding', {
'name': 'binding1',
'exchangeName': 'Exchange1',
'bindingKey': 'a.*',
'nextHopAddress': 'nextHop1'
}),
('binding', {
'name': 'binding2',
'exchangeName': 'Exchange1',
'bindingKey': 'a.b',
'nextHopAddress': 'nextHop1'
}),
# duplicate patterns, different next hops:
('binding', {
'name': 'binding3',
'exchangeName': 'Exchange1',
'bindingKey': 'a.c.#',
'nextHopAddress': 'nextHop1'
}),
('binding', {
'name': 'binding4',
'exchangeName': 'Exchange1',
'bindingKey': 'a.c.#',
'nextHopAddress': 'nextHop2'
}),
# match for nextHop2 only
('binding', {
'name': 'binding5',
'exchangeName': 'Exchange1',
'bindingKey': 'a.b.c',
'nextHopAddress': 'nextHop2'
})
]
router = self._create_router('A', config)
# create clients for message transfer
conn = BlockingConnection(router.addresses[0])
sender = conn.create_sender(address="Address1", options=AtMostOnce())
nhop1 = conn.create_receiver(address="nextHop1", credit=100)
nhop2 = conn.create_receiver(address="nextHop2", credit=100)
# verify initial metrics
self._validate_exchange(router,
name='Exchange1',
bindingCount=5,
receivedCount=0,
droppedCount=0,
forwardedCount=0,
divertedCount=0)
for b in range(5):
self._validate_binding(router,
name='binding%s' % (b + 1),
matchedCount=0)
# send message with subject "a.b"
# matches (binding1, binding2)
# forwarded to NextHop1 only
sender.send(Message(subject='a.b', body='A'))
self.assertEqual('A', nhop1.receive(timeout=TIMEOUT).body)
# send message with subject "a.c"
# matches (bindings 1,3,4)
# -> NextHop1, NextHop2
sender.send(Message(subject='a.c', body='B'))
self.assertEqual('B', nhop1.receive(timeout=TIMEOUT).body)
self.assertEqual('B', nhop2.receive(timeout=TIMEOUT).body)
# send message with subject "a.c.d"
# matches bindings 3,4
# -> NextHop1, NextHop2
sender.send(Message(subject='a.c.d', body='C'))
self.assertEqual('C', nhop1.receive(timeout=TIMEOUT).body)
self.assertEqual('C', nhop2.receive(timeout=TIMEOUT).body)
# send message with subject "x.y.z"
# no binding match - expected to drop
# not forwarded
sender.send(Message(subject='x.y.z', body=["I am Noone"]))
# send message with subject "a.b.c"
# matches binding5
# -> NextHop2
sender.send(Message(subject='a.b.c', body='D'))
self.assertEqual('D', nhop2.receive(timeout=TIMEOUT).body)
# ensure there are no more messages on either hop:
self.assertRaises(Timeout, nhop1.receive, timeout=0.25)
self.assertRaises(Timeout, nhop2.receive, timeout=0.25)
# validate counters
self._validate_binding(router, name='binding1', matchedCount=2)
self._validate_binding(router, name='binding2', matchedCount=1)
self._validate_binding(router, name='binding3', matchedCount=2)
self._validate_binding(router, name='binding4', matchedCount=2)
self._validate_binding(router, name='binding5', matchedCount=1)
self._validate_exchange(router,
name="Exchange1",
receivedCount=5,
forwardedCount=4,
divertedCount=0,
droppedCount=1)
conn.close()
def on_sendable(self, event):
if self.n_sent < self.num_messages:
msg = Message(body={'number': self.n_sent})
self.sender.send(msg)
self.n_sent += 1
def read_address(self, name):
ap = {'operation': 'READ', 'type': 'org.apache.qpid.dispatch.router.address', 'name': name}
return Message(properties=ap, reply_to=self.reply_addr)
def create_reply(self, message):
return Message(body=dict())
def _create_jms_textmessage(self, test_value_text):
"""Create a JMS text message"""
return Message(id=(self.sent + 1),
body=unicode(test_value_text),
annotations=create_annotation('JMS_TEXTMESSAGE_TYPE'))
def next_request(self):
if self.receiver.remote_source.address:
req = Message(reply_to=self.receiver.remote_source.address,
body=self.requests[0])
self.sender.send(req)
print("Message '%s' sent" % self.requests.pop(0))
def on_sendable(self, event):
if self.sent == 0:
msg = Message(body="Hello World")
event.sender.send(msg)
self.sent += 1
def main(argv=None):
_usage = """Usage: %prog [options] [message content string]"""
parser = optparse.OptionParser(usage=_usage)
parser.add_option("-a", dest="server", type="string",
default="amqp://0.0.0.0:5672",
help="The address of the server [amqp://0.0.0.0:5672]")
parser.add_option("--idle", dest="idle_timeout", type="int",
default=0,
help="Idle timeout for connection (seconds).")
parser.add_option("--debug", dest="debug", action="store_true",
help="enable debug logging")
parser.add_option("--source", dest="source_addr", type="string",
help="Address for link source.")
parser.add_option("--target", dest="target_addr", type="string",
help="Address for link target.")
parser.add_option("--trace", dest="trace", action="store_true",
help="enable protocol tracing")
parser.add_option("-f", "--forever", action="store_true",
help="Keep sending forever")
parser.add_option("--ca",
help="Certificate Authority PEM file")
parser.add_option("--ssl-cert-file",
help="Self-identifying certificate (PEM file)")
parser.add_option("--ssl-key-file",
help="Key for self-identifying certificate (PEM file)")
parser.add_option("--ssl-key-password",
help="Password to unlock SSL key file")
parser.add_option("--username", type="string",
help="User Id for authentication")
parser.add_option("--password", type="string",
help="User password for authentication")
parser.add_option("--sasl-mechs", type="string",
help="The list of acceptable SASL mechs")
parser.add_option("--sasl-config-dir", type="string",
help="Path to directory containing sasl config")
parser.add_option("--sasl-config-name", type="string",
help="Name of the sasl config file (without '.config')")
opts, payload = parser.parse_args(args=argv)
if not payload:
payload = "Hi There!"
if opts.debug:
LOG.setLevel(logging.DEBUG)
host, port = get_host_port(opts.server)
my_socket = connect_socket(host, port)
# create AMQP Container, Connection, and SenderLink
#
container = pyngus.Container(uuid.uuid4().hex)
conn_properties = {'hostname': host,
'x-server': False}
if opts.trace:
conn_properties["x-trace-protocol"] = True
if opts.ca:
conn_properties["x-ssl-ca-file"] = opts.ca
if opts.ssl_cert_file:
conn_properties["x-ssl-identity"] = (opts.ssl_cert_file,
opts.ssl_key_file,
opts.ssl_key_password)
if opts.idle_timeout:
conn_properties["idle-time-out"] = opts.idle_timeout
if opts.username:
conn_properties['x-username'] = opts.username
if opts.password:
conn_properties['x-password'] = opts.password
if opts.sasl_mechs:
conn_properties['x-sasl-mechs'] = opts.sasl_mechs
if opts.sasl_config_dir:
conn_properties["x-sasl-config-dir"] = opts.sasl_config_dir
if opts.sasl_config_name:
conn_properties["x-sasl-config-name"] = opts.sasl_config_name
c_handler = ConnectionEventHandler()
connection = container.create_connection("sender",
c_handler,
conn_properties)
connection.open()
source_address = opts.source_addr or uuid.uuid4().hex
s_handler = SenderEventHandler()
sender = connection.create_sender(source_address,
opts.target_addr,
s_handler)
sender.open()
class SendCallback(object):
def __init__(self):
self.done = False
self.status = None
def __call__(self, link, handle, status, error):
self.done = True
self.status = status
while True:
# Send a single message:
msg = Message()
msg.body = str(payload)
cb = SendCallback()
sender.send(msg, cb)
# Poll connection until SendCallback is invoked:
while not cb.done:
process_connection(connection, my_socket)
if c_handler.error:
break
if connection.closed:
break
if cb.done:
print("Send done, status=%s" % SEND_STATUS.get(cb.status,
"???"))
else:
print("Send failed due to connection failure: %s" %
c_handler.error or "remote closed unexpectedly")
break
if not opts.forever:
break
if not sender.closed:
sender.close()
if not connection.closed:
connection.close()
# Poll connection until close completes:
while not c_handler.error and not connection.closed:
process_connection(connection, my_socket)
sender.destroy()
connection.destroy()
container.destroy()
my_socket.close()
return 0
def test(name, address="x"):
for i in range(5):
body="%s%s" % (name, i)
response = client.call(Message(address=address, body=body))
self.assertEquals(response.address, client.reply_to)
self.assertEquals(response.body, body)
def __init__(self, count, capacity):
self._count = count
self._capacity = capacity
self._msg = Message()
self.receives = 0
self.tx_total_latency = 0.0
def on_sendable(self, event):
if self.count:
self._sender.send(Message(body=self._body))
self.count -= 1
def send_client(self):
while self.first_sender.credit > 0 and self.n_sent < self.count:
self.n_sent += 1
m = Message(body="Message %d of %d" % (self.n_sent, self.count))
self.first_sender.send(m)
def on_message(self, event):
m = event.message
sender = self.senders.get(m.reply_to)
if sender:
reply = Message(address=m.reply_to, body=m.body, correlation_id=m.correlation_id)
sender.send(reply)
def __init__(self, body=None):
"""
@param kwargs: name/value pairs in properties.
"""
self.message = Message(body)
def on_sendable(self, event):
event.sender.send(Message(body="Hello World!"))
event.sender.close()
def query_addresses(self):
ap = {
'operation': 'QUERY',
'type': 'org.apache.qpid.dispatch.router.address'
}
return Message(properties=ap, reply_to=self.reply_addr)
def on_message(self, event):
self.receivedMessages = self.receivedMessages + 1
print("Received " + str(self.receivedMessages) + " messages")
self.sender.send(
Message(address=self.send_destination, body="RECEIVED"))
def send(self):
while self.sender.credit > 0 and self.n_sent < self.count:
self.n_sent += 1
m = Message(body="Message %d of %d" % (self.n_sent, self.count))
m.address = self.sender_address
self.sender.send(m)
# # Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional information # regarding copyright ownership. The ASF licenses this file # to you under the Apache License, Version 2.0 (the # "License"); you may not use this file except in compliance # with the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, # software distributed under the License is distributed on an # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied. See the License for the # specific language governing permissions and limitations # under the License. # from proton import Message messages = [Message(subject='s%d' % i, body='b%d' % i) for i in range(10)]
def on_message(self, event):
print("Received", event.message)
self.server.send(
Message(address=event.message.reply_to,
body=event.message.body.upper(),
correlation_id=event.message.correlation_id))
