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_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 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)
