def test_000_stats(self):
# Run curl 127.0.0.1:port --http2-prior-knowledge
address = self.router_qdra.http_addresses[0]
self.run_curl(address=address)
address = self.router_qdra.http_addresses[0] + "/myinfo"
out = self.run_curl(
args=['-d', 'fname=Mickey&lname=Mouse', '-X', 'POST'],
address=address)
self.assertIn('Success! Your first name is Mickey, last name is Mouse',
out)
qd_manager = QdManager(self, address=self.router_qdra.addresses[0])
stats = qd_manager.query('org.apache.qpid.dispatch.httpRequestInfo')
self.assertEqual(len(stats), 2)
for s in stats:
self.assertEqual(s.get('requests'), 2)
self.assertEqual(s.get('details').get('GET:200'), 1)
self.assertEqual(s.get('details').get('POST:200'), 1)
if stats[0].get('direction') == 'out':
self.assertEqual(stats[1].get('direction'), 'in')
self.assertEqual(stats[0].get('bytesOut'), 24)
self.assertEqual(stats[0].get('bytesIn'), 3944)
self.assertEqual(stats[1].get('bytesOut'), 3944)
self.assertEqual(stats[1].get('bytesIn'), 24)
else:
self.assertEqual(stats[0].get('direction'), 'in')
self.assertEqual(stats[1].get('direction'), 'out')
self.assertEqual(stats[0].get('bytesOut'), 3944)
self.assertEqual(stats[0].get('bytesIn'), 24)
self.assertEqual(stats[1].get('bytesOut'), 24)
self.assertEqual(stats[1].get('bytesIn'), 3944)
def test_000_stats(self):
client = HTTPConnection("127.0.0.1:%s" % self.http_listener11_port,
timeout=TIMEOUT)
self._do_request(client, self.TESTS_11["GET"])
self._do_request(client, self.TESTS_11["POST"])
client.close()
qd_manager = QdManager(self, address=self.INT_A.listener)
stats = qd_manager.query('org.apache.qpid.dispatch.httpRequestInfo')
self.assertEqual(len(stats), 2)
for s in stats:
self.assertEqual(s.get('requests'), 10)
self.assertEqual(s.get('details').get('GET:400'), 1)
self.assertEqual(s.get('details').get('GET:200'), 6)
self.assertEqual(s.get('details').get('GET:204'), 1)
self.assertEqual(s.get('details').get('POST:200'), 2)
def assert_approximately_equal(a, b):
self.assertTrue((abs(a - b) / a) < 0.1)
if stats[0].get('direction') == 'out':
self.assertEqual(stats[1].get('direction'), 'in')
assert_approximately_equal(stats[0].get('bytesOut'), 1059)
assert_approximately_equal(stats[0].get('bytesIn'), 8849)
assert_approximately_equal(stats[1].get('bytesOut'), 8830)
assert_approximately_equal(stats[1].get('bytesIn'), 1059)
else:
self.assertEqual(stats[0].get('direction'), 'in')
self.assertEqual(stats[1].get('direction'), 'out')
assert_approximately_equal(stats[0].get('bytesOut'), 8849)
assert_approximately_equal(stats[0].get('bytesIn'), 1059)
assert_approximately_equal(stats[1].get('bytesOut'), 1059)
assert_approximately_equal(stats[1].get('bytesIn'), 8830)
def test_enable_protocol_trace_on_non_existent_connection(self):
qd_manager = QdManager(self, self.address)
bad_request = False
try:
# Turn on trace logging for connection with invalid or non-existent identity
outs = qd_manager.update("org.apache.qpid.dispatch.connection", {"enableProtocolTrace": "true"}, identity='G10000')
except Exception as e:
if "BadRequestStatus" in str(e):
bad_request = True
self.assertTrue(bad_request)
def test_router_core_logger(self):
blocking_connection = BlockingConnection(self.address)
TEST_ADDRESS = "test_multiple_log_file"
blocking_receiver = blocking_connection.create_receiver(
address=TEST_ADDRESS)
blocking_sender = blocking_connection.create_sender(
address=TEST_ADDRESS, options=apply_options)
TEST_MSG_BODY = "LOGTEST"
msg = Message(body=TEST_MSG_BODY)
blocking_sender.send(msg)
received_message = blocking_receiver.receive()
self.assertEqual(TEST_MSG_BODY, received_message.body)
qd_manager = QdManager(self, self.address)
logs = qd_manager.get_log()
router_core_found = False
for log in logs:
if 'ROUTER_CORE' in log[0]:
router_core_found = True
break
self.assertTrue(router_core_found)
core_log_file_found = True
all_lines_router_core = True
try:
# Before the fix to DISPATCH-1575, this file will not be
# created because the router core module was logging to the ROUTER
# module instead of the ROUTER_CORE module.
with open(self.router.outdir + '/test-router-core.log',
'r') as core_log:
for line in core_log:
# Every line in the file must log to the router core module.
if "ROUTER_CORE" not in line:
all_lines_router_core = False
break
except:
core_log_file_found = False
self.assertTrue(core_log_file_found)
self.assertTrue(all_lines_router_core)
def test_000_stats(self):
# Run curl 127.0.0.1:port --http2-prior-knowledge
address = self.router_qdra.http_addresses[0]
qd_manager = QdManager(self, address=self.router_qdra.addresses[0])
# First request
out = self.run_curl(address)
# Second request
address = self.router_qdra.http_addresses[0] + "/myinfo"
out = self.run_curl(address, args=['-d', 'fname=Mickey&lname=Mouse', '-X', 'POST'])
self.assertIn('Success! Your first name is Mickey, last name is Mouse', out)
stats = qd_manager.query('org.apache.qpid.dispatch.httpRequestInfo')
self.assertEqual(len(stats), 2)
# Give time for the core thread to augment the stats.
i = 0
while i < 3:
if not stats or stats[0].get('requests') < 2:
i += 1
sleep(1)
stats = qd_manager.query('org.apache.qpid.dispatch.httpRequestInfo')
else:
break
for s in stats:
self.assertEqual(s.get('requests'), 2)
self.assertEqual(s.get('details').get('GET:200'), 1)
self.assertEqual(s.get('details').get('POST:200'), 1)
if stats[0].get('direction') == 'out':
self.assertEqual(stats[1].get('direction'), 'in')
self.assertEqual(stats[0].get('bytesOut'), 24)
self.assertEqual(stats[0].get('bytesIn'), 3944)
self.assertEqual(stats[1].get('bytesOut'), 3944)
self.assertEqual(stats[1].get('bytesIn'), 24)
else:
self.assertEqual(stats[0].get('direction'), 'in')
self.assertEqual(stats[1].get('direction'), 'out')
self.assertEqual(stats[0].get('bytesOut'), 3944)
self.assertEqual(stats[0].get('bytesIn'), 24)
self.assertEqual(stats[1].get('bytesOut'), 24)
self.assertEqual(stats[1].get('bytesIn'), 3944)
def test_000_stats(self):
# Run curl 127.0.0.1:port --http2-prior-knowledge
address = self.router_qdra.http_addresses[0]
self.run_curl(address=address)
address = self.router_qdra.http_addresses[0] + "/myinfo"
out = self.run_curl(
args=['-d', 'fname=Mickey&lname=Mouse', '-X', 'POST'],
address=address)
self.assertIn('Success! Your first name is Mickey, last name is Mouse',
out)
qd_manager_a = QdManager(self, address=self.router_qdra.addresses[0])
stats_a = qd_manager_a.query(
'org.apache.qpid.dispatch.httpRequestInfo')
# Give time for the core thread to augment the stats.
i = 0
while i < 3:
s = stats_a[0]
i += 1
if s.get('requests') < 2:
sleep(1)
stats_a = qd_manager_a.query(
'org.apache.qpid.dispatch.httpRequestInfo')
else:
break
self.assertEqual(len(stats_a), 1)
self.assertEqual(stats_a[0].get('requests'), 2)
self.assertEqual(stats_a[0].get('direction'), 'in')
self.assertEqual(stats_a[0].get('bytesOut'), 3944)
self.assertEqual(stats_a[0].get('bytesIn'), 24)
qd_manager_b = QdManager(self, address=self.router_qdrb.addresses[0])
stats_b = qd_manager_b.query(
'org.apache.qpid.dispatch.httpRequestInfo')
self.assertEqual(len(stats_b), 1)
i = 0
while i < 3:
s = stats_b[0]
i += 1
if s.get('requests') < 2:
sleep(1)
stats_b = qd_manager_b.query(
'org.apache.qpid.dispatch.httpRequestInfo')
else:
break
self.assertEqual(stats_b[0].get('requests'), 2)
self.assertEqual(stats_b[0].get('direction'), 'out')
self.assertEqual(stats_b[0].get('bytesOut'), 24)
self.assertEqual(stats_b[0].get('bytesIn'), 3944)
def test_inter_router_sasl_fail(self):
passed = False
long_type = 'org.apache.qpid.dispatch.connection'
qd_manager = QdManager(self, address=self.routers[1].addresses[0])
connections = qd_manager.query(long_type)
for connection in connections:
if connection['role'] == 'inter-router':
passed = True
break
# There was no inter-router connection established.
self.assertFalse(passed)
qd_manager = QdManager(self, address=self.routers[1].addresses[0])
logs = qd_manager.get_log()
sasl_failed = False
file_open_failed = False
for log in logs:
if log[0] == 'SERVER' and log[
1] == "info" and "amqp:unauthorized-access Authentication failed [mech=PLAIN]" in log[
2]:
sasl_failed = True
if log[0] == "CONN_MGR" and log[
1] == "error" and "Unable to open password file" in log[
2] and "error: No such file or directory" in log[2]:
file_open_failed = True
self.assertTrue(sasl_failed)
self.assertTrue(file_open_failed)
def test_http_listener_delete(self):
name = 'delete_listener'
name_1 = 'delete_listener_1'
normal_listen_port = self.get_port()
#
# Open listeners on two HTTP enabled ports. Delete one of the
# HTTP listeners and make sure that it is really gone and also
# make sure that the other HTTP listener is still working.
#
http_delete_listen_port_1 = self.get_port()
http_delete_listen_port_2 = self.get_port()
config = Qdrouterd.Config([
('router', {'mode': 'standalone', 'id': 'A'}),
('listener', {'port': normal_listen_port}),
('listener', {'httpRootDir': os.path.dirname(__file__), 'name': name, 'port': http_delete_listen_port_1, 'http': True}),
('listener', {'httpRootDir': os.path.dirname(__file__), 'name': name_1, 'port': http_delete_listen_port_2, 'http': True})])
router = self.qdrouterd(name="expect_fail_1", config=config, wait=True)
def address():
return router.addresses[0]
# Perform a GET request on the http_delete_listen_port_1 just to make
# sure that it is up and running.
url_1 = "%s/system_tests_http.txt" % "http://localhost:%d" % http_delete_listen_port_1
out = self.get(url_1, use_ca=False)
# Perform a GET request on the http_delete_listen_port_2 just to make
# sure that it is up and running.
url_2 = "%s/system_tests_http.txt" % "http://localhost:%d" % http_delete_listen_port_2
out = self.get(url_2, use_ca=False)
# Now both http_delete_listen_port_1 and http_delete_listen_port_2
# are working.
# Delete the listener on port http_delete_listen_port_1
long_type = 'org.apache.qpid.dispatch.listener'
mgmt = QdManager(self, address=address())
if self.skip_delete_http_listener_test:
# You are not allowed to delete a http:yes listener
# Try deleting it and make sure you get an exception.
try:
mgmt.delete(long_type, name=name)
except Exception as e:
if "BadRequestStatus: HTTP listeners cannot be deleted" in str(e):
exception_raised = True
self.assertTrue(exception_raised)
else:
mgmt.delete(long_type, name=name)
# Once again try to perform a GET request. Now since the listener
# is gone, the GET will fail.
ret_val = retry(lambda: self.is_get_request_failing(url_1, use_ca=False), timeout=10, delay=2)
self.assertTrue(ret_val)
# HTTP listener on port http_delete_listen_port_1 has been
# deleted successfully. Make sure that the listener on port
# http_delete_listen_port_2 is still working.
out = self.get(url_2, use_ca=False)
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_01_toggle_default_trace_logging(self):
hello_world_1 = "Hello World_1!"
hello_world_2 = "Hello World_2!"
hello_world_3 = "Hello World_3!"
hello_world_4 = "Hello World_4!"
qd_manager = QdManager(self, self.address)
blocking_connection = BlockingConnection(self.address)
TEST_ADDR = "apachetest1"
self.create_sender_receiver(TEST_ADDR, hello_world_1,
blocking_connection)
# STEP 1: Make sure that proton trace logging is turned on already.
# Search for attach frames in the log for address TEST_ADDR. There should be 4 attaches
num_attaches = 0
logs = qd_manager.get_log()
for log in logs:
if u'SERVER' in log[0]:
if "@attach" in log[2] and TEST_ADDR in log[2]:
num_attaches += 1
# num_attaches for address TEST_ADDR must be 4, two attaches to/from sender and receiver
self.assertTrue(num_attaches == 4)
# STEP 2: Turn off trace logging using qdmanage
qd_manager.update("org.apache.qpid.dispatch.log", {"enable": "info+"},
name="log/DEFAULT")
# Step 3: Now, router trace logging is turned off (has been set to info+)
# Create the sender and receiver again on a different address and make
# sure that the attaches are NOT showing in the log for that address.
TEST_ADDR = "apachetest2"
self.create_sender_receiver(TEST_ADDR, hello_world_2,
blocking_connection)
# STEP 3: Count the nimber of attaches for address TEST_ADDR, there should be none
num_attaches = 0
logs = qd_manager.get_log()
for log in logs:
if u'SERVER' in log[0]:
if "@attach" in log[2] and TEST_ADDR in log[2]:
num_attaches += 1
# There should be no attach frames with address TEST_ADDR
# because we turned of trace logging.
self.assertTrue(num_attaches == 0)
# STEP 4: Tuen trace logging back on again and make sure num_attaches = 4
TEST_ADDR = "apachetest3"
qd_manager.update("org.apache.qpid.dispatch.log", {"enable": "trace+"},
name="log/DEFAULT")
self.create_sender_receiver(TEST_ADDR, hello_world_3,
blocking_connection)
# STEP 3: Count the number of attaches for address TEST_ADDR, there should be 4
num_attaches = 0
logs = qd_manager.get_log()
for log in logs:
if u'SERVER' in log[0]:
if "@attach" in log[2] and TEST_ADDR in log[2]:
num_attaches += 1
# There should be 4 attach frames with address TEST_ADDR
# because we turned on trace logging.
self.assertTrue(num_attaches == 4)
# Create a brand new blocking connection and make sure that connection
# is logging at trace level as well.
num_attaches = 0
TEST_ADDR = "apachetest4"
self.create_sender_receiver(TEST_ADDR, hello_world_4)
num_attaches = 0
logs = qd_manager.get_log()
for log in logs:
if u'SERVER' in log[0]:
if "@attach" in log[2] and TEST_ADDR in log[2]:
num_attaches += 1
self.assertTrue(num_attaches == 4)
def test_02_toggle_server_trace_logging(self):
"""
This test is similar to test_01_toggle_default_trace_logging but it tests the
SERVER log level.
"""
hello_world_5 = "Hello World_5!"
hello_world_6 = "Hello World_6!"
hello_world_7 = "Hello World_7!"
TEST_ADDR = "apachetest5"
# Step 1. Turn off trace logging for module DEFAULT and enable trace logging
# for the SERVER module and make sure it works.
qd_manager = QdManager(self, self.address)
# Set log level to info+ on the DEFAULT module
qd_manager.update("org.apache.qpid.dispatch.log", {"enable": "info+"},
name="log/DEFAULT")
# Set log level to trace+ on the SERVER module
qd_manager.update("org.apache.qpid.dispatch.log", {"enable": "trace+"},
name="log/SERVER")
blocking_connection = BlockingConnection(self.address)
self.create_sender_receiver(TEST_ADDR, hello_world_5,
blocking_connection)
# Count the nimber of attaches for address TEST_ADDR, there should be 4
num_attaches = 0
logs = qd_manager.get_log()
for log in logs:
if u'SERVER' in log[0]:
if "@attach" in log[2] and TEST_ADDR in log[2]:
num_attaches += 1
# There should be 4 attach frames with address TEST_ADDR
# because we turned on trace logging.
self.assertTrue(num_attaches == 4)
TEST_ADDR = "apachetest6"
qd_manager.update("org.apache.qpid.dispatch.log", {"enable": "info+"},
name="log/SERVER")
self.create_sender_receiver(TEST_ADDR, hello_world_6,
blocking_connection)
# Count the nimber of attaches for address TEST_ADDR, there should be 0
num_attaches = 0
logs = qd_manager.get_log()
for log in logs:
if u'SERVER' in log[0]:
if "@attach" in log[2] and TEST_ADDR in log[2]:
num_attaches += 1
self.assertTrue(num_attaches == 0)
# Create a brand new blocking connection and make sure that connection
# is logging at info level as well.
TEST_ADDR = "apachetest7"
self.create_sender_receiver(TEST_ADDR, hello_world_7)
num_attaches = 0
logs = qd_manager.get_log()
for log in logs:
if u'SERVER' in log[0]:
if "@attach" in log[2] and TEST_ADDR in log[2]:
num_attaches += 1
self.assertTrue(num_attaches == 0)
def test_call_timeout(self):
qm = QdManager(self, self.router.addresses[0])
ts = TestCallTimeout(self.router.addresses[0], qm)
ts.run()
self.assertEqual("TIMED OUT!", ts.error)
def test_turn_on_protocol_trace(self):
hello_world_0 = "Hello World_0!"
qd_manager = QdManager(self, self.address)
blocking_connection = BlockingConnection(self.address)
TEST_ADDR = "moduletest0"
self.create_sender_receiver(TEST_ADDR, hello_world_0,
blocking_connection)
num_attaches = 0
logs = qd_manager.get_log()
for log in logs:
if u'PROTOCOL' in log[0]:
if "@attach" in log[2] and TEST_ADDR in log[2]:
num_attaches += 1
# num_attaches for address TEST_ADDR must be 4, two attaches to/from sender and receiver
self.assertTrue(num_attaches == 4)
# Turn off trace logging using qdmanage
qd_manager.update("org.apache.qpid.dispatch.log", {"enable": "info+"},
name="log/DEFAULT")
# Turn on trace (not trace+) level logging for the PROTOCOL module. After doing
# this we will create a sender and a receiver and make sure that the PROTOCOL module
# is emitting proton frame trace messages.
# Before DISPATCH-1558, the only way to turn on proton frame trace logging was to set
# enable to trace on the SERVER or the DEFAULT module. Turning on trace for the SERVER
# module would also spit out dispatch trace level messages from the SERVER module.
# DISPATCH-1558 adds the new PROTOCOL module which moves all protocol traces into
# that module.
qd_manager.update("org.apache.qpid.dispatch.log", {"enable": "trace+"},
name="log/PROTOCOL")
TEST_ADDR = "moduletest1"
hello_world_1 = "Hello World_1!"
self.create_sender_receiver(TEST_ADDR, hello_world_1,
blocking_connection)
num_attaches = 0
logs = qd_manager.get_log()
for log in logs:
if u'PROTOCOL' in log[0]:
if "@attach" in log[2] and TEST_ADDR in log[2]:
num_attaches += 1
# num_attaches for address TEST_ADDR must be 4, two attaches to/from sender and receiver
self.assertTrue(num_attaches == 4)
# Now turn off trace logging for the PROTOCOL module and make sure
# that there is no more proton frame trace messages appearing in the log
qd_manager.update("org.apache.qpid.dispatch.log", {"enable": "info+"},
name="log/PROTOCOL")
TEST_ADDR = "moduletest2"
hello_world_2 = "Hello World_2!"
self.create_sender_receiver(TEST_ADDR, hello_world_2,
blocking_connection)
num_attaches = 0
logs = qd_manager.get_log()
for log in logs:
if u'PROTOCOL' in log[0]:
if "@attach" in log[2] and TEST_ADDR in log[2]:
num_attaches += 1
# num_attaches for address TEST_ADDR must be 4, two attaches to/from sender and receiver
self.assertTrue(num_attaches == 0)
def test_single_connection_protocol_trace(self):
qd_manager = QdManager(self, self.address)
# Turn off trace logging on all connections.
qd_manager.update("org.apache.qpid.dispatch.log", {"enable": "info+"},
name="log/DEFAULT")
TEST_ADDR_1 = "EnableConnectionLevelProtocolTraceTest1"
MSG_BODY = "EnableConnectionLevelProtocolTraceTestMessage1"
CONTAINER_ID_1 = "CONTAINERID_1"
container_1 = Container()
container_1.container_id = CONTAINER_ID_1
conn_1 = BlockingConnection(self.address, container=container_1)
TEST_ADDR_2 = "EnableConnectionLevelProtocolTraceTest1"
CONTAINER_ID_2 = "CONTAINERID_2"
container_2 = Container()
container_2.container_id = CONTAINER_ID_2
conn_2 = BlockingConnection(self.address, container=container_2)
results = qd_manager.query("org.apache.qpid.dispatch.connection")
conn_id = None
for result in results:
if result[u'container'] == CONTAINER_ID_1:
conn_id = result[u'identity']
# Turn on trace logging for connection with identity conn_id
qd_manager.update("org.apache.qpid.dispatch.connection",
{"enableProtocolTrace": "true"},
identity=conn_id)
blocking_receiver_1 = conn_1.create_receiver(address=TEST_ADDR_1)
blocking_sender_1 = conn_1.create_sender(address=TEST_ADDR_1,
options=apply_options)
blocking_receiver_2 = conn_2.create_receiver(address=TEST_ADDR_2)
blocking_sender_2 = conn_2.create_sender(address=TEST_ADDR_2,
options=apply_options)
num_attaches_1 = 0
num_attaches_2 = 0
logs = qd_manager.get_log()
for log in logs:
if u'PROTOCOL' in log[0]:
if "@attach" in log[2] and TEST_ADDR_1 in log[2]:
num_attaches_1 += 1
elif "@attach" in log[2] and TEST_ADDR_2 in log[2]:
num_attaches_2 += 1
# num_attaches_1 for address TEST_ADDR_1 must be 4, two attaches to/from sender and receiver
self.assertTrue(num_attaches_1 == 4)
# num_attaches_2 for address TEST_ADDR_2 must be 0 since trace was not
# turned on for that connection
self.assertTrue(num_attaches_2 == 0)
# Now turn off the connection tracing on that connection
qd_manager.update("org.apache.qpid.dispatch.connection",
{"enableProtocolTrace": "off"},
identity=conn_id)
blocking_receiver_1.close()
blocking_sender_1.close()
# Since tracing was turned off, there should be no detaches
logs = qd_manager.get_log()
num_detaches = 0
for log in logs:
if u'PROTOCOL' in log[0]:
if "@detach" in log[2]:
num_detaches += 1
self.assertTrue(num_detaches == 0)
blocking_receiver_2.close()
blocking_sender_2.close()
conn_1.close()
conn_2.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 check_connector_delete(self, client_addr, server_addr):
# Run curl 127.0.0.1:port --http2-prior-knowledge
# We are first making sure that the http request goes thru successfully.
out = self.run_curl(client_addr)
# Run a qdmanage query on connections to see how many qdr_connections are
# there on the egress router
qd_manager = QdManager(self, address=server_addr)
connections = qd_manager.query('org.apache.qpid.dispatch.connection')
self.assertGreaterEqual(len(connections), 2)
server_conn_found = False
for conn in connections:
if os.environ['SERVER_LISTEN_PORT'] in conn['name']:
server_conn_found = True
break
self.assertTrue(server_conn_found)
# Run a qdmanage DELETE on the httpConnector
http_connectors = qd_manager.query('org.apache.qpid.dispatch.httpConnector')
self.assertEqual(len(http_connectors), 1)
# Delete the httpConnector
qd_manager.delete("org.apache.qpid.dispatch.httpConnector", name=self.connector_name)
# Make sure the connector is gone
http_connectors = qd_manager.query('org.apache.qpid.dispatch.httpConnector')
self.assertEqual(len(http_connectors), 0)
# Deleting the connector must have taken out the connection to the server.
connections = qd_manager.query('org.apache.qpid.dispatch.connection')
http_server_conn_found = False
for conn in connections:
if os.environ['SERVER_LISTEN_PORT'] in conn['name']:
server_conn_found = True
break
self.assertFalse(http_server_conn_found)
sleep(2)
# Now, run a curl client GET request with a timeout
request_timed_out = False
try:
out = self.run_curl(client_addr, timeout=5)
print(out)
except Exception as e:
request_timed_out = True
self.assertTrue(request_timed_out)
# Add back the httpConnector
# qdmanage CREATE type=httpConnector address=examples.com host=127.0.0.1 port=80 protocolVersion=HTTP2
create_result = qd_manager.create("org.apache.qpid.dispatch.httpConnector", self.connector_props)
num_tries = 2
tries = 0
conn_present = False
while tries < num_tries:
connections = qd_manager.query('org.apache.qpid.dispatch.connection')
tries += 1
if (len(connections) < 2):
sleep(2)
else:
conn_present = True
self.assertTrue(conn_present)
out = self.run_curl(client_addr)
ret_string = ""
i = 0
while (i < 1000):
ret_string += str(i) + ","
i += 1
self.assertIn(ret_string, out)
def test_name_collision(self):
args = {"name": "autoLink", "address": "autoLink1", "connection": "broker", "dir": "in"}
# Add autoLink with the same name as the one already present.
al_long_type = 'org.apache.qpid.dispatch.router.config.autoLink'
addr_long_type = 'org.apache.qpid.dispatch.router.config.address'
lr_long_type = 'org.apache.qpid.dispatch.router.config.linkRoute'
mgmt = QdManager(self, address=self.router.addresses[0])
test_pass = False
try:
mgmt.create(al_long_type, args)
except Exception as e:
if "BadRequestStatus: Name conflicts with an existing entity" in str(e):
test_pass = True
self.assertTrue(test_pass)
# Try to add duplicate linkRoute and make sure it fails
args = {"name": "linkRoute", "prefix": "linkRoute",
"connection": "broker", "dir": "in"}
mgmt = QdManager(self, address=self.router.addresses[0])
test_pass = False
try:
mgmt.create(lr_long_type, args)
except Exception as e:
if "BadRequestStatus: Name conflicts with an existing entity" in str(e):
test_pass = True
self.assertTrue(test_pass)
args = {"name": "address", "prefix": "address.1",
"waypoint": "yes"}
mgmt = QdManager(self, address=self.router.addresses[0])
test_pass = False
try:
mgmt.create(addr_long_type, args)
except Exception as e:
if "BadRequestStatus: Name conflicts with an existing entity" in str(e):
test_pass = True
self.assertTrue(test_pass)
# The linkRoutes, autoLinks and addrConfigs share the same hashtable
# but with a prefix.
# The following tests make sure that same names used on
# different entities are allowed.
# insert a linkRoute with the name of an existing autoLink and make
# sure that is ok
args = {"name": "autoLink", "prefix": "linkRoute",
"connection": "broker", "dir": "in"}
mgmt = QdManager(self, address=self.router.addresses[0])
mgmt.create(lr_long_type, args)
# insert a linkRoute with the name of an existing addr config and make
# sure that is ok
args = {"name": "address", "prefix": "linkRoute",
"connection": "broker", "dir": "in"}
mgmt = QdManager(self, address=self.router.addresses[0])
mgmt.create(lr_long_type, args)
# insert an autoLink with the name of an existing linkRoute and make
# sure that is ok
args = {"name": "linkRoute", "address": "autoLink1", "connection": "broker", "dir": "in"}
mgmt = QdManager(self, address=self.router.addresses[0])
mgmt.create(al_long_type, args)
# insert an autoLink with the name of an existing address and make
# sure that is ok
args = {"name": "address", "address": "autoLink1", "connection": "broker", "dir": "in"}
al_long_type = 'org.apache.qpid.dispatch.router.config.autoLink'
mgmt = QdManager(self, address=self.router.addresses[0])
mgmt.create(al_long_type, args)
# insert an address with the name of an existing autoLink and make
# sure that is ok
args = {"name": "autoLink", "prefix": "address.2",
"waypoint": "yes"}
mgmt = QdManager(self, address=self.router.addresses[0])
mgmt.create(addr_long_type, args)
# insert an autoLink with the name of an existing linkRoute and make
# sure that is ok
args = {"name": "linkRoute", "prefix": "address.3",
"waypoint": "yes"}
mgmt = QdManager(self, address=self.router.addresses[0])
mgmt.create(addr_long_type, args)
def _valid_properties_check(self, client_class):
"""
Test a few different valid property maps
"""
valid_properties = [
{
# empty
},
{
"simple": "string",
"int": -3,
"bool": True,
"Null": None,
"list": [1, 2, "a", None, False, "done"],
"map": {
"key": "value"
},
},
# compound + nested
{
"string":
"string value",
"integer":
999,
"map": {
"map-bool": False,
"map-list": [1, "A", None],
"map-map": {
"key1": "string",
"key2": 1,
"key3": True,
"key4": False,
"key5": None,
"key6": ["x", False, "z", None]
},
},
"None":
None,
"True":
True,
"False":
False,
"list":
[1, 2, {
"a": 1,
"b": None,
"c": True,
"d": "end"
}, "text", 3]
}
]
i = 0
for op in valid_properties:
name = "Router%d" % i
i += 1
config = [('router', {
'id': name
}), ('listener', {
'port': self.tester.get_port()
})]
router = self.tester.qdrouterd(name,
Qdrouterd.Config(config),
wait=True)
new_port = self.tester.get_port()
input = json.dumps({
'port': new_port,
'name': "%s%d" % (client_class.entity, i),
'openProperties': op
})
cmd = "CREATE --type=org.apache.qpid.dispatch.%s --stdin" % client_class.entity
output = QdManager(tester=self)(cmd=cmd,
address=router.addresses[0],
input=input,
timeout=TIMEOUT)
rc = json.loads(output)
self.assertIn("openProperties", rc)
self.assertEqual(op, rc["openProperties"])
client = client_class(router)
client.run(host=rc.get("host"),
port=new_port,
pf=rc.get("protocolFamily", "IPv4"))
router.teardown()
def test_https_get(self):
def http_listener(**kwargs):
args = dict(kwargs)
args.update({'port': self.get_port(), 'http': 'yes', 'httpRootDir': os.path.dirname(__file__)})
return ('listener', args)
def listener(**kwargs):
args = dict(kwargs)
args.update({'port': self.get_port()})
return ('listener', args)
name = 'delete-me'
config = Qdrouterd.Config([
('router', {'id': 'QDR.HTTPS'}),
('sslProfile', {'name': 'simple-ssl',
'caCertFile': self.ssl_file('ca-certificate.pem'),
'certFile': self.ssl_file('server-certificate.pem'),
'privateKeyFile': self.ssl_file('server-private-key.pem'),
'ciphers': 'ECDH+AESGCM:DH+AESGCM:ECDH+AES256:DH+AES256:ECDH+AES128:DH+AES:RSA+AESGCM:RSA+AES:!aNULL:!MD5:!DSS',
'password': '******'
}),
http_listener(sslProfile='simple-ssl', requireSsl=False, authenticatePeer=False),
http_listener(sslProfile='simple-ssl', requireSsl=True, authenticatePeer=False),
http_listener(sslProfile='simple-ssl', requireSsl=True, authenticatePeer=True),
http_listener(name=name, sslProfile='simple-ssl', requireSsl=True, authenticatePeer=True),
listener(name='mgmt_listener', authenticatePeer=False)])
# saslMechanisms='EXTERNAL'
r = self.qdrouterd('https-test-router', config)
r.wait_ready()
def address():
return r.addresses[4]
self.assert_get("https://localhost:%s" % r.ports[0])
# requireSsl=false Allows simple-ssl HTTP
# DISPATCH-1513: libwebsockets versions 3.2.0 introduces a new flag called
# LWS_SERVER_OPTION_ALLOW_HTTP_ON_HTTPS_LISTENER
# The new flag allows (as the flag says) HTTP over HTTPS listeners.
# Since this flag is not available before lws 3.2.0 we need
# to selectively disable this check
if qpid_dispatch_site.LIBWEBSOCKETS_VERSION >= (3, 2, 0):
self.assert_get("http://localhost:%s" % r.ports[0])
self.assert_get("https://localhost:%s" % r.ports[1])
# requireSsl=True does not allow simple-ssl HTTP
self.assertRaises(Exception, self.assert_get, "http://localhost:%s" % r.ports[1])
# authenticatePeer=True requires a client cert
self.assertRaises((URLError, ssl.SSLError), self.assert_get, "https://localhost:%s" % r.ports[2])
# Provide client cert
self.assert_get_cert("https://localhost:%d" % r.ports[2])
# Try a get on the HTTP listener we are going to delete
self.assert_get_cert("https://localhost:%d" % r.ports[3])
if not self.skip_delete_http_listener_test:
# Delete the listener with name 'delete-me'
long_type = 'org.apache.qpid.dispatch.listener'
mgmt = QdManager(self, address=address())
mgmt.delete(long_type, name=name)
# Make sure that the listener got deleted.
ret_val = retry(lambda: self.is_get_request_failing("https://localhost:%s/system_tests_http.txt" % r.ports[3], use_get_cert=True), timeout=10, delay=2)
self.assertTrue(ret_val)
# Make sure other ports are working normally after the above delete.
self.assert_get_cert("https://localhost:%d" % r.ports[2])
def test_worker_threads(self):
long_type = 'org.apache.qpid.dispatch.router'
qd_manager = QdManager(self, address=self.address())
output = qd_manager.query('org.apache.qpid.dispatch.router')
self.assertEqual(output[0]['workerThreads'], 4)
