def is_proto_allowed(self, listener_port, tls_protocol):
"""
Opens a simple proton client connection to the provided TCP port using
a specific TLS protocol version and returns True in case connection
was established and accepted or False otherwise.
:param listener_port: TCP port number
:param tls_protocol: TLSv1, TLSv1.1 or TLSv1.2 (string)
:return:
"""
# Management address to connect using the given TLS protocol
url = Url("amqps://0.0.0.0:%d/$management" % listener_port)
# Preparing SSLDomain (client cert) and SASL authentication info
domain = SSLDomain(SSLDomain.MODE_CLIENT)
# Enforcing given TLS protocol
cproton.pn_ssl_domain_set_protocols(domain._domain, tls_protocol)
# Try opening the secure and authenticated connection
try:
connection = BlockingConnection(url, sasl_enabled=False, ssl_domain=domain, timeout=self.TIMEOUT)
except proton.Timeout:
return False
except proton.ConnectionException:
return False
# TLS version provided was accepted
connection.close()
return True
def is_ssl_sasl_client_accepted(self, listener_port, tls_protocol):
"""
Attempts to connect a proton client to the management address
on the given listener_port using the specific tls_protocol provided.
If connection was established and accepted, returns True and False otherwise.
:param listener_port:
:param tls_protocol:
:return:
"""
# Management address to connect using the given TLS protocol
url = Url("amqps://0.0.0.0:%d/$management" % listener_port)
# Preparing SSLDomain (client cert) and SASL authentication info
domain = SSLDomain(SSLDomain.MODE_CLIENT)
domain.set_credentials(self.ssl_file('client-certificate.pem'),
self.ssl_file('client-private-key.pem'),
'client-password')
# Enforcing given TLS protocol
cproton.pn_ssl_domain_set_protocols(domain._domain, tls_protocol)
# Try opening the secure and authenticated connection
try:
connection = BlockingConnection(url,
sasl_enabled=True,
ssl_domain=domain,
allowed_mechs='PLAIN',
user='******',
password='******')
except proton.ConnectionException:
return False
# TLS version provided was accepted
connection.close()
return True
def test_verify_n_receivers(self):
n = 4
addr = self.address()
# connection should be ok
denied = False
try:
br1 = BlockingConnection(addr)
except ConnectionException:
denied = True
self.assertFalse(
denied) # assert if connections that should open did not open
# n receivers OK
try:
r1 = br1.create_receiver(address="****YES_1of4***")
r2 = br1.create_receiver(address="****YES_20f4****")
r3 = br1.create_receiver(address="****YES_3of4****")
r4 = br1.create_receiver(address="****YES_4of4****")
except Exception:
denied = True
self.assertFalse(denied) # n receivers should have worked
# receiver n+1 should be denied
try:
r5 = br1.create_receiver("****NO****")
except Exception:
denied = True
self.assertTrue(denied) # receiver n+1 should have failed
br1.close()
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_inter_router_protocol_trace(self):
qd_manager = QdManager(self, self.address)
# Turn off trace logging on all connections for Router B.
qd_manager.update("org.apache.qpid.dispatch.log", {"enable": "info+"},
name="log/DEFAULT")
# Get the connection id of the inter-router connection
results = qd_manager.query("org.apache.qpid.dispatch.connection")
conn_id = None
for result in results:
if result[u'role'] == u'inter-router':
conn_id = result[u'identity']
# Turn on trace logging for the inter-router connection
qd_manager.update("org.apache.qpid.dispatch.connection",
{"enableProtocolTrace": "true"},
identity=conn_id)
# Create a receiver and make sure the MAU update is seen on the inter-router connection log
TEST_ADDR_1 = "EnableConnectionLevelProtocolTraceTest1"
conn_2 = BlockingConnection(self.address)
blocking_receiver_1 = conn_2.create_receiver(address=TEST_ADDR_1)
# Give some time for the MAU to go over the inter-router link
time.sleep(2)
logs = qd_manager.get_log()
mau_found = False
for log in logs:
if u'PROTOCOL' in log[0]:
if "@transfer" in log[2] and TEST_ADDR_1 in log[
2] and "MAU" in log[2]:
mau_found = True
break
self.assertTrue(mau_found)
# Turn off trace logging for the inter-router connection
qd_manager.update("org.apache.qpid.dispatch.connection",
{"enableProtocolTrace": "no"},
identity=conn_id)
# Create a receiver and make sure the MAU update is NOT seen on the inter-router connection log
TEST_ADDR_2 = "EnableConnectionLevelProtocolTraceTest2"
conn_1 = BlockingConnection(self.address)
blocking_receiver_2 = conn_1.create_receiver(address=TEST_ADDR_2)
time.sleep(1)
logs = qd_manager.get_log()
mau_found = False
for log in logs:
if u'PROTOCOL' in log[0]:
if "@transfer" in log[2] and TEST_ADDR_2 in log[
2] and "MAU" in log[2]:
mau_found = True
break
self.assertFalse(mau_found)
conn_1.close()
conn_2.close()
def test_verify_n_senders(self):
n = 2
addr = self.address()
# connection should be ok
denied = False
try:
bs1 = BlockingConnection(addr)
except ConnectionException:
denied = True
self.assertFalse(
denied) # assert if connections that should open did not open
# n senders OK
try:
s1 = bs1.create_sender(address="****YES_1of2****")
s2 = bs1.create_sender(address="****YES_2of2****")
except Exception:
denied = True
self.assertFalse(denied) # n senders should have worked
# receiver n+1 should be denied
try:
s3 = bs1.create_sender("****NO****")
except Exception:
denied = True
self.assertTrue(denied) # sender n+1 should have failed
bs1.close()
def is_proto_allowed(self, listener_port, tls_protocol):
"""
Opens a simple proton client connection to the provided TCP port using
a specific TLS protocol version and returns True in case connection
was established and accepted or False otherwise.
:param listener_port: TCP port number
:param tls_protocol: TLSv1, TLSv1.1 or TLSv1.2 (string)
:return:
"""
# Management address to connect using the given TLS protocol
url = Url("amqps://0.0.0.0:%d/$management" % listener_port)
# Preparing SSLDomain (client cert) and SASL authentication info
domain = SSLDomain(SSLDomain.MODE_CLIENT)
# Enforcing given TLS protocol
cproton.pn_ssl_domain_set_protocols(domain._domain, tls_protocol)
# Try opening the secure and authenticated connection
try:
connection = BlockingConnection(url, sasl_enabled=False, ssl_domain=domain, timeout=self.TIMEOUT)
except proton.Timeout:
return False
except proton.ConnectionException:
return False
except:
return False
# TLS version provided was accepted
connection.close()
return True
def run(self):
try:
ssl = SSLDomain(SSLDomain.MODE_CLIENT)
ssl.set_credentials(str(self.options.accountPublicKey),
str(self.options.accountPrivateKey), str(""))
ssl.set_trusted_ca_db(str(self.options.brokerPublicKey))
ssl.set_peer_authentication(SSLDomain.VERIFY_PEER_NAME,
trusted_CAs=str(
self.options.brokerPublicKey))
connection = BlockingConnection(self.address,
ssl_domain=ssl,
heartbeat=60000)
receiver = connection.create_receiver(self.broadcast_address,
credit=self.capacity)
while True:
received_message = None
try:
received_message = receiver.receive(
timeout=self.options.timeout)
except Timeout, e:
print("-I- No message received for ", self.options.timeout,
" seconds")
break
self.message_counter += 1
print("-I- Received broadcast message: " +
received_message.body)
receiver.accept()
print("-I- " + str(self.message_counter) + " messages received")
connection.close()
def test_verify_n_receivers(self):
n = 4
addr = self.address()
# connection should be ok
denied = False
try:
br1 = BlockingConnection(addr)
except ConnectionException:
denied = True
self.assertFalse(denied) # assert if connections that should open did not open
# n receivers OK
try:
r1 = br1.create_receiver(address="****YES_1of4***")
r2 = br1.create_receiver(address="****YES_20f4****")
r3 = br1.create_receiver(address="****YES_3of4****")
r4 = br1.create_receiver(address="****YES_4of4****")
except Exception:
denied = True
self.assertFalse(denied) # n receivers should have worked
# receiver n+1 should be denied
try:
r5 = br1.create_receiver("****NO****")
except Exception:
denied = True
self.assertTrue(denied) # receiver n+1 should have failed
br1.close()
def is_ssl_sasl_client_accepted(self, listener_port, tls_protocol):
"""
Attempts to connect a proton client to the management address
on the given listener_port using the specific tls_protocol provided.
If connection was established and accepted, returns True and False otherwise.
:param listener_port:
:param tls_protocol:
:return:
"""
# Management address to connect using the given TLS protocol
url = Url("amqps://0.0.0.0:%d/$management" % listener_port)
# Preparing SSLDomain (client cert) and SASL authentication info
domain = SSLDomain(SSLDomain.MODE_CLIENT)
domain.set_credentials(self.ssl_file('client-certificate.pem'),
self.ssl_file('client-private-key.pem'),
'client-password')
# Enforcing given TLS protocol
cproton.pn_ssl_domain_set_protocols(domain._domain, tls_protocol)
# Try opening the secure and authenticated connection
try:
connection = BlockingConnection(url,
sasl_enabled=True,
ssl_domain=domain,
allowed_mechs='PLAIN',
user='******',
password='******')
except proton.ConnectionException:
return False
# TLS version provided was accepted
connection.close()
return True
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_verify_n_senders(self):
n = 2
addr = self.address()
# connection should be ok
denied = False
try:
bs1 = BlockingConnection(addr)
except ConnectionException:
denied = True
self.assertFalse(denied) # assert if connections that should open did not open
# n senders OK
try:
s1 = bs1.create_sender(address="****YES_1of2****")
s2 = bs1.create_sender(address="****YES_2of2****")
except Exception:
denied = True
self.assertFalse(denied) # n senders should have worked
# receiver n+1 should be denied
try:
s3 = bs1.create_sender("****NO****")
except Exception:
denied = True
self.assertTrue(denied) # sender n+1 should have failed
bs1.close()
def test_verify_maximum_connections(self):
addr = self.address()
# two connections should be ok
denied = False
try:
bc1 = BlockingConnection(addr)
bc2 = BlockingConnection(addr)
except ConnectionException:
denied = True
self.assertFalse(
denied) # assert if connections that should open did not open
# third connection should be denied
denied = False
try:
bc3 = BlockingConnection(addr)
except ConnectionException:
denied = True
self.assertTrue(
denied) # assert if connection that should not open did open
bc1.close()
bc2.close()
def run(self):
try:
ssl = SSLDomain(SSLDomain.MODE_CLIENT)
ssl.set_credentials(str(self.options.accountPublicKey), str(self.options.accountPrivateKey), str(""))
ssl.set_trusted_ca_db(str(self.options.brokerPublicKey))
ssl.set_peer_authentication(SSLDomain.VERIFY_PEER_NAME, trusted_CAs=str(self.options.brokerPublicKey))
connection = BlockingConnection(self.address, ssl_domain=ssl, heartbeat=60000)
receiver = connection.create_receiver(self.broadcast_address, credit=self.capacity)
while True:
received_message = None
try:
received_message = receiver.receive(timeout=self.options.timeout)
except Timeout, e:
print("-I- No message received for ", self.options.timeout, " seconds")
break
self.message_counter += 1
print("-I- Received broadcast message: " + received_message.body)
receiver.accept()
print("-I- " + str(self.message_counter) + " messages received")
connection.close()
def main():
"""Main processing for the application
"""
global MSG_SERVICE_STRING
global MSG_WORK_QUEUE
global MSG_STATUS_QUEUE
# Example connection string: amqp://<username>:<password>@<host>:<port>
MSG_SERVICE_STRING = get_env_var('PROTO_MSG_SERVICE_CONNECTION_STRING',
None)
MSG_WORK_QUEUE = get_env_var('PROTO_MSG_WORK_QUEUE', None)
MSG_STATUS_QUEUE = get_env_var('PROTO_MSG_STATUS_QUEUE', None)
args = retrieve_command_line()
# Configure logging
setup_logging(args)
logger.info('Begin Processing')
try:
while True:
try:
# Create the connection
connection = BlockingConnection(MSG_SERVICE_STRING)
# Create a sender
sender = connection.create_sender(MSG_WORK_QUEUE)
jobs = get_jobs(args.job_filename)
for job in jobs:
message_json = json.dumps(job, ensure_ascii=False)
try:
sender.send(Message(body=message_json))
# TODO - This prototype doesn't care, but we
# TODO - should probably update the status at
# TODO - the work source.
print('Queued Message = {}'.format(message_json))
except proton.ConnectionException:
# TODO - This prototype doesn't care, but does
# TODO - something need to be done if this
# TODO - happens?
print('Returned Message = {}'.format(message_json))
finally:
connection.close()
sleep(60)
except KeyboardInterrupt:
pass
#except pika.exceptions.ConnectionClosed:
# pass
logger.info('Terminated Processing')
def test_expire_never_sender_disallowed(self):
addr = self.routers[1].addresses[0]
connection = BlockingConnection(addr)
try:
sender = connection.create_sender(address="org.apache", options=[SenderExpiry(Terminus.EXPIRE_NEVER)])
self.fail("link should have been detached")
except LinkDetached:
pass
connection.close()
def test_resumable_receiver_disallowed(self):
addr = self.routers[1].addresses[0]
connection = BlockingConnection(addr)
try:
receiver = connection.create_receiver(address="org.apache", options=[DurableSubscription()])
self.fail("link should have been detached")
except LinkDetached:
pass
connection.close()
def _invalid_request_test(self, msg, disposition=Disposition.REJECTED):
bc = BlockingConnection(self.INT_A.edge_listener, timeout=TIMEOUT)
srr = SyncRequestResponse(bc, self.QD_TERMINUS_ADDRESS_LOOKUP)
# @TODO(kgiusti) - self.assertRaises does not work here:
try:
srr.call(msg)
self.assertTrue(False)
except SendException as exc:
self.assertEqual(disposition, exc.state)
bc.close()
def test_non_zero_timeout_sender_disallowed(self):
addr = self.routers[1].addresses[0]
connection = BlockingConnection(addr)
try:
sender = connection.create_sender(address="org.apache", options=[SenderTimeout(10)])
self.fail("link should have been detached")
except LinkDetached:
pass
connection.close()
def test_17_address_wildcard(self):
# verify proper distribution is selected by wildcard
addresses = [
# (address, count of messages expected to be received)
('a.b.c.d', 1), # closest 'a.b.c.d'
('b.c.d', 2), # multi '#.b.c.d'
('f.a.b.c.d', 2), # multi '#.b.c.d
('a.c.d', 2), # multi 'a.*.d'
('a/c/c/d', 1), # closest 'a/*/#.d
('a/x/z/z/d', 1), # closest 'a/*/#.d
('a/x/d', 1), # closest 'a.x.d'
('a.x.e', 1), # balanced ----
('m.b.c.d', 2) # multi '*/b/c/d'
]
# two receivers per address - one for each router
receivers = []
for a in addresses:
for x in range(2):
ar = AsyncTestReceiver(address=self.routers[x].addresses[0],
source=a[0])
receivers.append(ar)
# wait for the consumer info to propagate
for a in addresses:
self.routers[0].wait_address(a[0], 1, 1)
self.routers[1].wait_address(a[0], 1, 1)
# send one message to each address
conn = BlockingConnection(self.routers[0].addresses[0])
sender = conn.create_sender(address=None, options=AtLeastOnce())
for a in addresses:
sender.send(Message(address=a[0], body={'address': a[0]}))
# count received messages by address
msgs_recvd = {}
for M in receivers:
try:
while True:
i = M.queue.get(timeout=0.2).body.get('address', "ERROR")
if i not in msgs_recvd:
msgs_recvd[i] = 0
msgs_recvd[i] += 1
except AsyncTestReceiver.Empty:
pass
# verify expected count == actual count
self.assertTrue("ERROR" not in msgs_recvd)
for a in addresses:
self.assertTrue(a[0] in msgs_recvd)
self.assertEqual(a[1], msgs_recvd[a[0]])
for M in receivers:
M.stop()
conn.close()
def test_forwarding_fanout(self):
"""
Verify bindings that do not have a key receive all messages
"""
config = [
('exchange', {
'address': 'AddressF',
'name': 'ExchangeF'
}),
('binding', {
'name': 'binding1',
'exchangeName': 'ExchangeF',
'bindingKey': 'pattern',
'nextHopAddress': 'nextHop1'
}),
# two bindings w/o key
('binding', {
'name': 'binding2',
'exchangeName': 'ExchangeF',
'nextHopAddress': 'nextHop2'
}),
('binding', {
'name': 'binding3',
'exchangeName': 'ExchangeF',
'nextHopAddress': 'nextHop3'
})
]
for meth in ['amqp', 'mqtt']:
config[0][1]['matchMethod'] = meth
router = self._create_router('A', config)
# create clients for message transfer
conn = BlockingConnection(router.addresses[0])
sender = conn.create_sender(address="AddressF",
options=AtMostOnce())
nhop1 = conn.create_receiver(address="nextHop1", credit=100)
nhop2 = conn.create_receiver(address="nextHop2", credit=100)
nhop3 = conn.create_receiver(address="nextHop3", credit=100)
# send message with subject "nope"
# should arrive at nextHop2 & 3 only
sender.send(Message(subject='nope', body='A'))
self.assertEqual('A', nhop2.receive(timeout=TIMEOUT).body)
self.assertEqual('A', nhop3.receive(timeout=TIMEOUT).body)
# send message with subject "pattern"
# forwarded to all bindings:
sender.send(Message(subject='pattern', body='B'))
self.assertEqual('B', nhop1.receive(timeout=TIMEOUT).body)
self.assertEqual('B', nhop2.receive(timeout=TIMEOUT).body)
self.assertEqual('B', nhop3.receive(timeout=TIMEOUT).body)
conn.close()
router.teardown()
def test_max_frame_small(self):
# Set up a connection to get the Open and a receiver to get a Begin frame in the log
bc = BlockingConnection(self.router.addresses[0])
bc.create_receiver("xxx")
bc.close()
with open('../setUpClass/MaxFrameSmall.log', 'r') as router_log:
log_lines = router_log.read().split("\n")
open_lines = [s for s in log_lines if "-> @open" in s]
# if frame size <= 512 proton set min of 512
self.assertTrue(" max-frame-size=512" in open_lines[0])
def test_link_route_lookup_no_dest(self):
"""
verify correct handling of matches to mobile addresses
"""
bc = BlockingConnection(self.INT_A.edge_listener, timeout=TIMEOUT)
srr = SyncRequestResponse(bc, self.QD_TERMINUS_ADDRESS_LOOKUP)
rsp = self._check_response(srr.call(self._lookup_request("org.apache.A.nope", True)))
self.assertEqual(self.QCM_ADDR_LOOKUP_OK, rsp[0])
self.assertEqual(True, rsp[1])
self.assertEqual(False, rsp[2])
bc.close()
def test_max_frame_default(self):
# Set up a connection to get the Open and a receiver to get a Begin frame in the log
bc = BlockingConnection(self.router.addresses[0])
bc.create_receiver("xxx")
bc.close()
with open('../setUpClass/MaxFrameDefault.log', 'r') as router_log:
log_lines = router_log.read().split("\n")
open_lines = [s for s in log_lines if "-> @open" in s]
# if frame size not set then a default is used
self.assertTrue(" max-frame-size=16384" in open_lines[0])
def test_large_messages(self):
"""
Verify that multi-frame messages are forwarded properly
"""
MAX_FRAME = 1024
config = [('router', {
'mode': 'interior',
'id': 'QDR.X',
'allowUnsettledMulticast': 'yes'
}),
('listener', {
'port': self.tester.get_port(),
'stripAnnotations': 'no',
'maxFrameSize': MAX_FRAME
}),
('address', {
'pattern': 'nextHop1/#',
'distribution': 'multicast'
}), ('exchange', {
'address': 'AddressA',
'name': 'ExchangeA'
}),
('binding', {
'name': 'bindingA1',
'exchangeName': 'ExchangeA',
'bindingKey': 'a/b',
'nextHopAddress': 'nextHop1'
})]
router = self.tester.qdrouterd('QDR.X',
Qdrouterd.Config(config),
wait=True)
# connect clients to router B (no exchange)
nhop1A = AsyncTestReceiver(router.addresses[0],
'nextHop1',
conn_args={'max_frame_size': MAX_FRAME})
nhop1B = AsyncTestReceiver(router.addresses[0],
'nextHop1',
conn_args={'max_frame_size': MAX_FRAME})
conn = BlockingConnection(router.addresses[0],
max_frame_size=MAX_FRAME)
sender = conn.create_sender(address="AddressA")
jumbo = (10 * MAX_FRAME) * 'X'
sender.send(Message(subject='a/b', body=jumbo))
# multicast
self.assertEqual(jumbo, nhop1A.queue.get(timeout=TIMEOUT).body)
self.assertEqual(jumbo, nhop1B.queue.get(timeout=TIMEOUT).body)
nhop1A.stop()
nhop1B.stop()
conn.close()
def test_max_sessions_large(self):
# Set up a connection to get the Open and a receiver to get a Begin frame in the log
bc = BlockingConnection(self.router.addresses[0])
bc.create_receiver("xxx")
bc.close()
with open('../setUpClass/MaxSessionsLarge.log', 'r') as router_log:
log_lines = router_log.read().split("\n")
open_lines = [s for s in log_lines if "-> @open" in s]
# channel-max is 0. Should get proton default 32767
self.assertIn(" channel-max=32767", open_lines[0])
def test_max_sessions(self):
# Set up a connection to get the Open and a receiver to get a Begin frame in the log
bc = BlockingConnection(self.router.addresses[0])
bc.create_receiver("xxx")
bc.close()
with open('../setUpClass/MaxSessions.log', 'r') as router_log:
log_lines = router_log.read().split("\n")
open_lines = [s for s in log_lines if "-> @open" in s]
# channel-max is 10
self.assertTrue(" channel-max=9" in open_lines[0])
def test_inter_router_protocol_trace(self):
qd_manager = QdManager(self, self.address)
# The router already has trace logging turned on for all connections.
# Get the connection id of the inter-router connection
results = qd_manager.query("org.apache.qpid.dispatch.connection")
conn_id = None
for result in results:
if result['role'] == 'inter-router':
conn_id = result['identity']
# Turn off trace logging for the inter-router connection. This update command is run async by the router
# so we need to sleep a bit before the operation is actually completed.
qd_manager.update("org.apache.qpid.dispatch.connection",
{"enableProtocolTrace": "false"},
identity=conn_id)
time.sleep(1)
num_transfers = self._get_transfer_frame_count(conn_id)
# Create a receiver. This will send an MAU update to the other router but we should not see any of that
# in the log since the trace logging for the inter-router connection has been turned off.
TEST_ADDR_1 = "EnableConnectionLevelProtocolTraceTest1"
conn_2 = BlockingConnection(self.address)
conn_2.create_receiver(address=TEST_ADDR_1)
# Give some time for the MAU to go over the inter-router connection.
time.sleep(2)
num_transfers_after_update = self._get_transfer_frame_count(conn_id)
# Since there will be no transfer frames printed in the log, there should be no more new transfers in the
# log file.
self.assertEqual(num_transfers_after_update, num_transfers)
# Turn on trace logging for the inter-router connection
qd_manager.update("org.apache.qpid.dispatch.connection",
{"enableProtocolTrace": "yes"},
identity=conn_id)
# Create a receiver and make sure the MAU update is NOT seen on the inter-router connection log
TEST_ADDR_2 = "EnableConnectionLevelProtocolTraceTest2"
conn_1 = BlockingConnection(self.address)
conn_1.create_receiver(address=TEST_ADDR_2)
# Give time for the MAU to be generated.
time.sleep(2)
num_transfers_after_update = self._get_transfer_frame_count(conn_id)
# Since we have now turned on trace logging for the inter-router connection, we should see
# additional transfer frames in the log and we check that here.
self.assertGreater(num_transfers_after_update, num_transfers)
conn_1.close()
conn_2.close()
def test_verify_n_senders(self):
n = 2
addr = self.address()
bs1 = BlockingConnection(addr)
# n senders OK
bs1.create_sender(address="****YES_1of2****")
bs1.create_sender(address="****YES_2of2****")
# sender n+1 should be denied
self.assertRaises(LinkDetached, bs1.create_sender, "****NO****")
bs1.close()
def get_next_message_on_queue(self) -> Message:
"""
Gets the next message from the queue
:return: Message read from queue
"""
connection = BlockingConnection(self.queue_url, user=self.username, password=self.password)
receiver = connection.create_receiver(self.queue_name)
message = receiver.receive(timeout=30)
receiver.accept()
connection.close()
return message
def test_aaa_partial_link_route_match(self):
"""
The linkRoutePattern on Routers C and B is set to org.apache.
Creates a receiver listening on the address 'org.apache.dev' and a sender that sends to address 'org.apache.dev'.
Sends a message to org.apache.dev via router QDR.C and makes sure that the message was successfully
routed (using partial address matching) and received using pre-created links that were created as a
result of specifying addresses in the linkRoutePattern attribute('org.apache.').
"""
hello_world_1 = "Hello World_1!"
# Connects to listener #2 on QDR.C
addr = self.routers[2].addresses[1]
blocking_connection = BlockingConnection(addr)
# Receive on org.apache.dev
blocking_receiver = blocking_connection.create_receiver(address="org.apache.dev")
apply_options = AtMostOnce()
# Sender to to org.apache.dev
blocking_sender = blocking_connection.create_sender(address="org.apache.dev", options=apply_options)
msg = Message(body=hello_world_1)
# Send a message
blocking_sender.send(msg)
received_message = blocking_receiver.receive()
self.assertEqual(hello_world_1, received_message.body)
# Connect to the router acting like the broker (QDR.A) and check the deliveriesIngress and deliveriesEgress
local_node = Node.connect(self.routers[0].addresses[0], timeout=TIMEOUT)
self.assertEqual(u'QDR.A', local_node.query(type='org.apache.qpid.dispatch.router',
attribute_names=['routerId']).results[0][0])
self.assertEqual(1, local_node.read(type='org.apache.qpid.dispatch.router.address',
name='router.address/M0org.apache.dev').deliveriesEgress,
"deliveriesEgress is wrong")
self.assertEqual(1, local_node.read(type='org.apache.qpid.dispatch.router.address',
name='router.address/M0org.apache.dev').deliveriesIngress,
"deliveriesIngress is wrong")
# There should be 4 links -
# 1. outbound receiver link on org.apache.dev
# 2. inbound sender link on blocking_sender
# 3. inbound link to the $management
# 4. outbound link to $management
# self.assertEqual(4, len()
self.assertEquals(4, len(local_node.query(type='org.apache.qpid.dispatch.router.link').results))
#blocking_receiver.close()
blocking_connection.close()
def test_max_frame_max_session_zero(self):
# Set up a connection to get the Open and a receiver to get a Begin frame in the log
bc = BlockingConnection(self.router.addresses[0])
bc.create_receiver("xxx")
bc.close()
with open('../setUpClass/MaxFrameMaxSessionFramesZero.log', 'r') as router_log:
log_lines = router_log.read().split("\n")
open_lines = [s for s in log_lines if "-> @open" in s]
# max-frame gets set to protocol min
self.assertTrue(' max-frame-size=512,' in open_lines[0])
begin_lines = [s for s in log_lines if "-> @begin" in s]
# incoming-window is defaulted to 2^31-1
self.assertTrue(" incoming-window=2147483647," in begin_lines[0])
def drain(self):
"""
Drain the queue to prevent test failures caused by previous failing tests not ack'ing all of their messages
"""
connection = BlockingConnection(self.queue_url, user=self.username, password=self.password)
receiver = connection.create_receiver(self.queue_name)
try:
while True:
receiver.receive(timeout=1)
receiver.accept()
except Timeout:
pass
finally:
connection.close()
def test_forwarding_sync(self):
"""
Forward unsettled messages to multiple subscribers
"""
config = [
('router', {'mode': 'standalone', 'id': 'QDR.mcast'}),
('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())
def test_forwarding_sync(self):
"""
Forward unsettled messages to multiple subscribers
"""
config = [
('router', {'mode': 'standalone', 'id': 'QDR.mcast'}),
('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())
def test_verify_n_receivers(self):
n = 4
addr = self.address()
br1 = BlockingConnection(addr)
# n receivers OK
br1.create_receiver(address="****YES_1of4***")
br1.create_receiver(address="****YES_20f4****")
br1.create_receiver(address="****YES_3of4****")
br1.create_receiver(address="****YES_4of4****")
# receiver n+1 should be denied
self.assertRaises(LinkDetached, br1.create_receiver, "****NO****")
br1.close()
def ecp_publish(msg, queue=CIM_ECP_PUBLISH, recipient=CIM_ECP_RECIPIENT, label=CIM_ECP_LABEL, sender=CIM_ECP_SENDER, msgid=None, msgctx=None, session=None):
log.debug('ENTER: ecp_publish(msg=#' + str(len(msg)) + ',queue=' + json.dumps(queue) + ',recipient=' + json.dumps(recipient) + ',label=' + json.dumps(label) + ',sender=' + json.dumps(sender) + ',msgid=' + json.dumps(msgid) + ',msgctx=' + json.dumps(msgctx) + ',session=' + json.dumps(session) + ')')
result = {}
CONNECTION = None
CHANNEL = None
try:
CONNECTION = BlockingConnection(URL, timeout=25)
CHANNEL = CONNECTION.create_sender(address=queue)
correlation_id = str(uuid.uuid4())
result = {
'correlation_id': correlation_id,
'queue': queue,
'send': "%sZ" % datetime.now().isoformat()
}
props = {
'baMessageId': str(uuid.uuid4()),
'baCorrelationId': correlation_id, # prefer to use the same AMQP message correlation id as the AMQP application-property "baCorrelationId"
'businessType': CIM_ECP_LABEL,
'receiverCode': CIM_ECP_RECIPIENT,
'senderApplication': CIM_ECP_SENDER
}
for k,v in props.items():
result[k] = v
# channel.basic_publish(
CHANNEL.send(
Message(
body = msg,
correlation_id = correlation_id,
properties = props,
creation_time = int(time.time()),
durable = True)
, timeout = False)
result['published'] = "%sZ" % datetime.now().isoformat()
# print('PUBLISHED: ' + str(result))
CHANNEL.close()
CONNECTION.close()
except Exception as e:
print('EXCEPTION -- ecp_publish')
print(e)
log.error(e)
result['error'] = str(e)
if CHANNEL is not None:
CHANNEL.close()
if CONNECTION is not None:
CONNECTION.close()
# print('RETURNING: ' + str(result))
return result
def test_max_session_frames_default(self):
# Set up a connection to get the Open and a receiver to get a Begin frame in the log
if skip_test:
return self.skipTest("Test skipped on non-64 bit architectures")
bc = BlockingConnection(self.router.addresses[0])
bc.create_receiver("xxx")
bc.close()
with open('../setUpClass/MaxSessionFramesDefault.log', 'r') as router_log:
log_lines = router_log.read().split("\n")
open_lines = [s for s in log_lines if "-> @open" in s]
# if frame size not set then a default is used
self.assertTrue(" max-frame-size=16384" in open_lines[0])
begin_lines = [s for s in log_lines if "-> @begin" in s]
# incoming-window is from the config
self.assertTrue(" incoming-window=2147483647," in begin_lines[0])
def test_max_frame_max_session_frames__max_sessions_default(self):
# Set up a connection to get the Open and a receiver to get a Begin frame in the log
bc = BlockingConnection(self.router.addresses[0])
bc.create_receiver("xxx")
bc.close()
with open('../setUpClass/MaxFrameMaxSessionFrames.log', 'r') as router_log:
log_lines = router_log.read().split("\n")
open_lines = [s for s in log_lines if "-> @open" in s]
# max-frame is from the config
self.assertTrue(' max-frame-size=2048,' in open_lines[0])
# channel-max is default
self.assertTrue(" channel-max=32767" in open_lines[0])
begin_lines = [s for s in log_lines if "-> @begin" in s]
# incoming-window is from the config
self.assertTrue(" incoming-window=10," in begin_lines[0] )
def test_max_frame_max_session_too_big(self):
# Set up a connection to get the Open and a receiver to get a Begin frame in the log
bc = BlockingConnection(self.router.addresses[0])
bc.create_receiver("xxx")
bc.close()
with open('../setUpClass/MaxFrameMaxSessionFramesTooBig.log', 'r') as router_log:
log_lines = router_log.read().split("\n")
open_lines = [s for s in log_lines if "-> @open" in s]
# max-frame is from the config
self.assertTrue(' max-frame-size=1000000,' in open_lines[0])
begin_lines = [s for s in log_lines if "-> @begin" in s]
# incoming-window is truncated
self.assertTrue(" incoming-window=2147," in begin_lines[0])
warning_lines = [s for s in log_lines if "requested maxSessionFrames truncated from 5000000 to 2147" in s]
self.assertTrue(len(warning_lines) == 1)
def test_large_messages(self):
"""
Verify that multi-frame messages are forwarded properly
"""
MAX_FRAME=1024
config = [
('router', {'mode': 'interior', 'id': 'QDR.X',
'allowUnsettledMulticast': 'yes'}),
('listener', {'port': self.tester.get_port(),
'stripAnnotations': 'no',
'maxFrameSize': MAX_FRAME}),
('address', {'pattern': 'nextHop1/#',
'distribution': 'multicast'}),
('exchange', {'address': 'AddressA',
'name': 'ExchangeA'}),
('binding', {'name': 'bindingA1',
'exchangeName': 'ExchangeA',
'bindingKey': 'a/b',
'nextHopAddress': 'nextHop1'})
]
router = self.tester.qdrouterd('QDR.X',
Qdrouterd.Config(config),
wait=True)
# connect clients to router B (no exchange)
nhop1A = AsyncTestReceiver(router.addresses[0], 'nextHop1',
conn_args={'max_frame_size': MAX_FRAME})
nhop1B = AsyncTestReceiver(router.addresses[0], 'nextHop1',
conn_args={'max_frame_size': MAX_FRAME})
conn = BlockingConnection(router.addresses[0],
max_frame_size=MAX_FRAME)
sender = conn.create_sender(address="AddressA")
jumbo = (10 * MAX_FRAME) * 'X'
sender.send(Message(subject='a/b', body=jumbo))
# multicast
self.assertEqual(jumbo, nhop1A.queue.get(timeout=TIMEOUT).body)
self.assertEqual(jumbo, nhop1B.queue.get(timeout=TIMEOUT).body)
nhop1A.stop()
nhop1B.stop()
conn.close()
def test_forwarding_fanout(self):
"""
Verify bindings that do not have a key receive all messages
"""
config = [
('exchange', {'address': 'AddressF',
'name': 'ExchangeF'}),
('binding', {'name': 'binding1',
'exchangeName': 'ExchangeF',
'bindingKey': 'pattern',
'nextHopAddress': 'nextHop1'}),
# two bindings w/o key
('binding', {'name': 'binding2',
'exchangeName': 'ExchangeF',
'nextHopAddress': 'nextHop2'}),
('binding', {'name': 'binding3',
'exchangeName': 'ExchangeF',
'nextHopAddress': 'nextHop3'})
]
for meth in ['amqp', 'mqtt']:
config[0][1]['matchMethod'] = meth
router = self._create_router('A', config)
# create clients for message transfer
conn = BlockingConnection(router.addresses[0])
sender = conn.create_sender(address="AddressF", options=AtMostOnce())
nhop1 = conn.create_receiver(address="nextHop1", credit=100)
nhop2 = conn.create_receiver(address="nextHop2", credit=100)
nhop3 = conn.create_receiver(address="nextHop3", credit=100)
# send message with subject "nope"
# should arrive at nextHop2 & 3 only
sender.send(Message(subject='nope', body='A'))
self.assertEqual('A', nhop2.receive(timeout=TIMEOUT).body)
self.assertEqual('A', nhop3.receive(timeout=TIMEOUT).body)
# send message with subject "pattern"
# forwarded to all bindings:
sender.send(Message(subject='pattern', body='B'))
self.assertEqual('B', nhop1.receive(timeout=TIMEOUT).body)
self.assertEqual('B', nhop2.receive(timeout=TIMEOUT).body)
self.assertEqual('B', nhop3.receive(timeout=TIMEOUT).body)
conn.close()
router.teardown()
def test_full_link_route_match(self):
"""
The linkRoutePattern 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 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 linkRoutePattern attribute('org.apache.').
"""
hello_world_3 = "Hello World_3!"
# Connects to listener #2 on QDR.C
addr = self.routers[2].addresses[1]
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)
# Send a message
blocking_sender.send(msg)
received_message = blocking_receiver.receive()
self.assertEqual(hello_world_3, received_message.body)
local_node = Node.connect(self.routers[0].addresses[0], timeout=TIMEOUT)
# Make sure that the router node acting as the broker (QDR.A) had one message routed through it. This confirms
# that the message was link routed
self.assertEqual(1, local_node.read(type='org.apache.qpid.dispatch.router.address',
name='router.address/M0org.apache').deliveriesEgress,
"deliveriesEgress is wrong")
self.assertEqual(1, local_node.read(type='org.apache.qpid.dispatch.router.address',
name='router.address/M0org.apache').deliveriesIngress,
"deliveriesIngress is wrong")
#blocking_receiver.close()
blocking_connection.close()
def test_full_link_route_match_1(self):
"""
This test is pretty much the same as the previous test (test_full_link_route_match) but the connection is
made to router QDR.B instead of QDR.C and we expect the message to be link routed successfully.
"""
hello_world_4 = "Hello World_4!"
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_4)
# Send a message
blocking_sender.send(msg)
received_message = blocking_receiver.receive()
self.assertEqual(hello_world_4, received_message.body)
local_node = Node.connect(self.routers[0].addresses[0], timeout=TIMEOUT)
# Make sure that the router node acting as the broker (QDR.A) had one message routed through it. This confirms
# that the message was link routed
self.assertEqual(1, local_node.read(type='org.apache.qpid.dispatch.router.address',
name='M0org.apache').deliveriesEgress,
"deliveriesEgress is wrong")
self.assertEqual(1, local_node.read(type='org.apache.qpid.dispatch.router.address',
name='M0org.apache').deliveriesIngress,
"deliveriesIngress is wrong")
blocking_connection.close()
def test_verify_maximum_connections(self):
addr = self.address()
# two connections should be ok
denied = False
try:
bc1 = BlockingConnection(addr)
bc2 = BlockingConnection(addr)
except ConnectionException:
denied = True
self.assertFalse(denied) # assert if connections that should open did not open
# third connection should be denied
denied = False
try:
bc3 = BlockingConnection(addr)
except ConnectionException:
denied = True
self.assertTrue(denied) # assert if connection that should not open did open
bc1.close()
bc2.close()
def run(self):
try:
ssl = SSLDomain(SSLDomain.MODE_CLIENT)
ssl.set_credentials(str(self.options.accountPublicKey), str(self.options.accountPrivateKey), str(""))
ssl.set_trusted_ca_db(str(self.options.brokerPublicKey))
ssl.set_peer_authentication(SSLDomain.VERIFY_PEER_NAME, trusted_CAs=str(self.options.brokerPublicKey))
connection = BlockingConnection(self.address, ssl_domain=ssl, heartbeat=60000)
receiver = connection.create_receiver(self.response_address)
sender = connection.create_sender(self.request_address)
message = Message(body="<FIXML>...</FIXML>", reply_to=self.reply_adress)
print("-I- Sending request message: " + message.body)
sender.send(message);
try:
received_message = receiver.receive(timeout=self.options.timeout)
print("-I- Received response message: " + received_message.body)
self.message_counter += 1
receiver.accept()
except Timeout, e:
print("-I- No message received for ", self.options.timeout, " seconds")
connection.close()
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()
class JMSClient(object):
"""Class JMSClient
"""
_mh = None
_client = None
_host = None
_port = None
_user = None
_passw = None
_verbose = None
_is_connected = None
def __init__(self, verbose=False):
"""Class constructor
Called when the object is initialized
Args:
verbose (bool): verbose mode
"""
try:
self._mh = MasterHead.get_head()
self._verbose = verbose
if (self._verbose):
basicConfig()
getLogger().setLevel(DEBUG)
except ProtonException as ex:
self._mh.demsg('htk_on_error', ex, self._mh.fromhere())
@property
def client(self):
""" AMQP client property getter """
return self._client
@property
def host(self):
""" server host property getter """
return self._host
@property
def port(self):
""" server port property getter """
return self._port
@property
def user(self):
""" username property getter """
return self._user
@property
def passw(self):
""" user password property getter """
return self._passw
@property
def verbose(self):
""" verbose mode property getter """
return self._verbose
@property
def is_connected(self):
""" is_connected property getter """
return self._is_connected
def connect(self, host, port=5672, user=None, passw=None, timeout=10):
"""Method connects to server
Args:
host (str): hostname
port (str): port
user (str): username
passw (str): password
timeout (int): timeout
Returns:
bool: result
Raises:
event: jms_before_connect
event: jms_after_connected
"""
try:
msg = 'host:{0}, port:{1}, user:{2}, passw:{3}, timeout:{4}'.format(
host, port, user, passw, timeout)
self._mh.demsg('htk_on_debug_info', self._mh._trn.msg(
'htk_jms_connecting', msg), self._mh.fromhere())
ev = event.Event(
'jms_before_connect', host, port, user, passw, timeout)
if (self._mh.fire_event(ev) > 0):
host = ev.argv(0)
port = ev.argv(1)
user = ev.argv(2)
passw = ev.argv(3)
timeout = ev.argv(4)
self._host = host
self._port = port
self._user = user
self._passw = passw
if (ev.will_run_default()):
if (self._user == None):
self._client = BlockingConnection(
'amqp://{0}:{1}'.format(self._host, self._port), timeout=timeout)
else:
self._client = BlockingConnection('amqp://{0}:{1}@{2}:{3}'.format(self._user, self._passw,
self._host, self._port), timeout=timeout)
self._is_connected = True
self._mh.demsg('htk_on_debug_info', self._mh._trn.msg(
'htk_jms_connected'), self._mh.fromhere())
ev = event.Event('jms_after_connect')
self._mh.fire_event(ev)
return True
except ProtonException as ex:
self._mh.demsg('htk_on_error', ex, self._mh.fromhere())
return False
def disconnect(self):
"""Method disconnects from server
Args:
none
Returns:
bool: result
"""
try:
self._mh.demsg('htk_on_debug_info', self._mh._trn.msg(
'htk_jms_disconnecting'), self._mh.fromhere())
if (not self._is_connected):
self._mh.demsg('htk_on_warning', self._mh._trn.msg(
'htk_jms_not_connected'), self._mh.fromhere())
return False
else:
self._client.close()
self._is_connected = False
self._mh.demsg('htk_on_debug_info', self._mh._trn.msg(
'htk_jms_disconnected'), self._mh.fromhere())
return True
except ProtonException as ex:
self._mh.demsg('htk_on_error', ex, self._mh.fromhere())
return False
def send(self, destination_name, message, destination_type='queue', headers={}):
"""Method sends message
JMS headers - JMSDeliveryMode, JMSPriority, JMSExpiration, JMSType, JMSMessageID,
JMSDestination, JMSReplyTo, JMSCorrelationID, JMSTimestamp
Args:
destination_name (str): queue|topic name
message (str): message
destination_type (str): queue|topic
headers (dict): JMS headers, key - title, value - string
Returns:
bool: result
Raises:
event: jms_before_send
event: jms_after_send
"""
try:
msg = 'destination_name:{0}, message:{1}, destination_type:{2}, headers:{3}'.format(
destination_name, message, destination_type, headers)
self._mh.demsg('htk_on_debug_info', self._mh._trn.msg(
'htk_jms_sending_msg', msg), self._mh.fromhere())
if (not self._is_connected):
self._mh.demsg('htk_on_warning', self._mh._trn.msg(
'htk_jms_not_connected'), self._mh.fromhere())
return False
ev = event.Event(
'jms_before_send', destination_name, message, destination_type, headers)
if (self._mh.fire_event(ev) > 0):
destination_name = ev.argv(0)
message = ev.argv(1)
destination_type = ev.argv(2)
headers = ev.argv(3)
if (ev.will_run_default()):
sender = self._client.create_sender(
'{0}://{1}'.format(destination_type, destination_name))
headers_new = {}
for key, value in headers.items():
if (key in mapping):
headers_new[mapping[key]] = value
sender.send(Message(body=message, properties=headers_new))
sender.close()
self._mh.demsg('htk_on_debug_info', self._mh._trn.msg(
'htk_jms_msg_sent'), self._mh.fromhere())
ev = event.Event('jms_after_send')
self._mh.fire_event(ev)
return True
except ProtonException as ex:
self._mh.demsg('htk_on_error', ex, self._mh.fromhere())
return False
def receive(self, destination_name, cnt=1):
"""Method receives messages
Args:
destination_name (str): queue name
cnt (int): count of messages
Returns:
list: messages as dictionary {'message', JMS headers}
Raises:
event: jms_before_receive
event: jms_after_receive
"""
try:
msg = 'destination_name:{0}, count:{1}'.format(
destination_name, cnt)
self._mh.demsg('htk_on_debug_info', self._mh._trn.msg(
'htk_jms_receiving_msg', msg), self._mh.fromhere())
if (not self._is_connected):
self._mh.demsg('htk_on_warning', self._mh._trn.msg(
'htk_jms_not_connected'), self._mh.fromhere())
return None
ev = event.Event('jms_before_receive', destination_name, cnt)
if (self._mh.fire_event(ev) > 0):
destination_name = ev.argv(0)
cnt = ev.argv(1)
if (ev.will_run_default()):
receiver = self._client.create_receiver(
'queue://{0}'.format(destination_name))
msgs = []
i = 0
while (i < cnt):
try:
msg = receiver.receive(timeout=1)
receiver.accept()
msgs.append(msg)
i = i + 1
except Timeout:
break
messages = []
for msg in msgs:
message = {}
message['message'] = msg.body
for key, value in msg.properties.items():
if (key in mapping.values()):
message[
list(mapping.keys())[list(mapping.values()).index(key)]] = value
messages.append(message)
receiver.close()
self._mh.demsg('htk_on_debug_info', self._mh._trn.msg(
'htk_jms_msg_received', len(messages)), self._mh.fromhere())
ev = event.Event('jms_after_receive')
self._mh.fire_event(ev)
return messages
except ProtonException as ex:
self._mh.demsg('htk_on_error', ex, self._mh.fromhere())
return None
def browse(self, destination_name, cnt=100, jms_correlation_id=None, jms_type=None):
"""Method browses queue
Args:
destination_name (str): queue name
cnt (int): count of messages
jms_correlation_id (str): requested JMSCorrelationID
jms_type (str): requested JMSType
Returns:
list: messages as dictionary {'message', JMS headers}
Raises:
event: jms_before_browse
event: jms_after_browse
"""
try:
msg = 'destination_name:{0}, count:{1}, jms_correlation_id:{2}, jms_type:{3}'.format(
destination_name, cnt, jms_correlation_id, jms_type)
self._mh.demsg('htk_on_debug_info', self._mh._trn.msg(
'htk_jms_browsing', msg), self._mh.fromhere())
if (not self._is_connected):
self._mh.demsg('htk_on_warning', self._mh._trn.msg(
'htk_jms_not_connected'), self._mh.fromhere())
return None
ev = event.Event('jms_before_browse', destination_name, cnt)
if (self._mh.fire_event(ev) > 0):
destination_name = ev.argv(0)
cnt = ev.argv(1)
jms_correlation_id = ev.argv(2)
jms_type = ev.argv(3)
if (ev.will_run_default()):
receiver = self._client.create_receiver(
'queue://{0}'.format(destination_name), options=Copy())
msgs = []
i = 0
while (i < cnt):
try:
msg = receiver.receive(timeout=1)
receiver.accept()
correlation_id = None
type = None
for key, value in msg.properties.items():
if (key == 'properties.correlation-id'):
correlation_id = value
elif (key == 'message-annotations.x-opt-jms-type'):
type = value
if ((jms_correlation_id == None or jms_correlation_id == correlation_id) and
(jms_type == None or jms_type == type)):
msgs.append(msg)
i = i + 1
except Timeout:
break
receiver.close()
messages = []
for msg in msgs:
message = {}
message['message'] = msg.body
for key, value in msg.properties.items():
if (key in mapping.values()):
message[
list(mapping.keys())[list(mapping.values()).index(key)]] = value
messages.append(message)
self._mh.demsg('htk_on_debug_info', self._mh._trn.msg(
'htk_jms_msg_received', len(messages)), self._mh.fromhere())
ev = event.Event('jms_after_browse')
self._mh.fire_event(ev)
return messages
except ProtonException as ex:
self._mh.demsg('htk_on_error', ex, self._mh.fromhere())
return None
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 test_normal_sender_allowed(self):
addr = self.routers[1].addresses[0]
connection = BlockingConnection(addr)
sender = connection.create_sender(address="org.apache")
connection.close()
# 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 __future__ import print_function
from proton import Message
from proton.utils import BlockingConnection
from proton.handlers import IncomingMessageHandler
conn = BlockingConnection("localhost:5672")
receiver = conn.create_receiver("examples")
sender = conn.create_sender("examples")
sender.send(Message(body="Hello World!"));
msg = receiver.receive(timeout=30)
print(msg.body)
receiver.accept()
conn.close()
