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))
def setUpClass(cls):
super(TwoRouterIngressEgressTest, cls).setUpClass()
listen_port_1 = cls.tester.get_port()
listen_port_2 = cls.tester.get_port()
listen_port_inter_router = cls.tester.get_port()
config_1 = Qdrouterd.Config([
('router', {'mode': 'interior', 'id': 'A'}),
('listener', {'port': listen_port_1, 'authenticatePeer': False, 'saslMechanisms': 'ANONYMOUS'}),
('listener', {'role': 'inter-router', 'port': listen_port_inter_router, 'authenticatePeer': False, 'saslMechanisms': 'ANONYMOUS'}),
])
config_2 = Qdrouterd.Config([
('router', {'mode': 'interior', 'id': 'B'}),
('listener', {'port': listen_port_2, 'authenticatePeer': False, 'saslMechanisms': 'ANONYMOUS'}),
('connector', {'name': 'connectorToA', 'role': 'inter-router', 'port': listen_port_inter_router,
'verifyHostname': 'no'}),
])
cls.routers = []
cls.routers.append(cls.tester.qdrouterd("A", config_1, wait=True))
cls.routers.append(cls.tester.qdrouterd("B", config_2, wait=True))
cls.routers[1].wait_router_connected('A')
def router(name, mode, connection, extra=None, args=[]):
config = [('router', {
'mode': mode,
'id': name
}),
('listener', {
'port': cls.tester.get_port(),
'stripAnnotations': 'no'
}), connection]
if extra:
config.append(extra)
config = Qdrouterd.Config(config)
cls.routers.append(
cls.tester.qdrouterd(name, config, wait=True, cl_args=args))
def setUpClass(cls):
super(QdmanageTest, cls).setUpClass()
cls.inter_router_port = cls.tester.get_port()
config_1 = Qdrouterd.Config([
('router', {'mode': 'interior', 'id': 'R1'}),
('sslProfile', {'name': 'server-ssl',
'certDb': cls.ssl_file('ca-certificate.pem'),
'certFile': cls.ssl_file('server-certificate.pem'),
'keyFile': cls.ssl_file('server-private-key.pem'),
'password': '******'}),
('listener', {'port': cls.tester.get_port()}),
('connector', {'role': 'inter-router', 'port': cls.inter_router_port}),
('address', {'name': 'test-address', 'prefix': 'abcd', 'distribution': 'multicast'}),
('linkRoute', {'name': 'test-link-route', 'prefix': 'xyz', 'dir': 'in'}),
('autoLink', {'name': 'test-auto-link', 'addr': 'mnop', 'dir': 'out'}),
('listener', {'port': cls.tester.get_port(), 'sslProfile': 'server-ssl'})
])
config_2 = Qdrouterd.Config([
('router', {'mode': 'interior', 'id': 'R2'}),
('listener', {'role': 'inter-router', 'port': cls.inter_router_port}),
])
cls.router_2 = cls.tester.qdrouterd('test_router_2', config_2, wait=True)
cls.router_1 = cls.tester.qdrouterd('test_router_1', config_1, wait=True)
def setUpClass(cls):
super(DefaultDistributionTest, cls).setUpClass()
name = "test-router"
config = Qdrouterd.Config([
('router', {'mode': 'standalone', 'id': 'QDR', "defaultDistribution": 'unavailable'}),
('listener', {'port': cls.tester.get_port()}),
('address', {'prefix': 'closest', 'distribution': 'closest'}),
('address', {'prefix': 'spread', 'distribution': 'balanced'}),
('address', {'prefix': 'multicast', 'distribution': 'multicast'})
])
cls.router = cls.tester.qdrouterd(name, config)
cls.router.wait_ready()
cls.address = cls.router.addresses[0]
def setUpClass(cls):
"""
Tests the delegation of sasl auth to an external auth service.
"""
super(AuthServicePluginAuthzTest, cls).setUpClass()
if not SASL.extended():
return
cls.createSaslFiles()
cls.auth_service_port = cls.tester.get_port()
cls.tester.popen([
'/usr/bin/env', 'python',
os.path.join(os.path.dirname(os.path.abspath(__file__)),
'authservice.py'), '-a',
'amqps://127.0.0.1:%d' % cls.auth_service_port, '-c',
os.getcwd()
],
expect=Process.RUNNING)
cls.router_port = cls.tester.get_port()
cls.tester.qdrouterd(
'router',
Qdrouterd.Config([('sslProfile', {
'name': 'myssl'
}),
('authServicePlugin', {
'name':
'myauth',
'authSslProfile':
'myssl',
'authService':
'127.0.0.1:%d' % cls.auth_service_port
}),
('listener', {
'host': '0.0.0.0',
'port': cls.router_port,
'role': 'normal',
'saslPlugin': 'myauth',
'saslMechanisms': 'SCRAM-SHA-1 PLAIN'
}),
('router', {
'mode': 'standalone',
'id': 'router',
'saslConfigName': 'tests-mech-SCRAM',
'saslConfigPath': os.getcwd()
})])).wait_ready()
def router(name, connection):
config = [
('router', {
'mode': 'interior',
'id': 'QDR.%s' % name
}),
# No protocolFamily is specified for this listener.
# This will test if the router defaults host to 127.0.0.1 and if the router auto-detects protocol family
('listener', {
'port': cls.tester.get_port()
}),
# Specify host as 127.0.0.1 and protocol family as IPv4
('listener', {
'host': '127.0.0.1',
'protocolFamily': 'IPv4',
'port': cls.tester.get_port()
}),
# Specify protocol family as IPv4 but don't specify any host
# This will test if the router defaults the host field to 127.0.0.1
('listener', {
'protocolFamily': 'IPv4',
'port': cls.tester.get_port()
}),
# Specify the host as 127.0.0.1
# This will test router's auto-detection of protocol family
('listener', {
'host': '127.0.0.1',
'port': cls.tester.get_port()
}),
# Specify host as ::1 and protocol family as IPv6
('listener', {
'host': '::1',
'protocolFamily': 'IPv6',
'port': cls.tester.get_port(protocol_family='IPv6')
}),
] + connection
config = Qdrouterd.Config(config)
# The wait=True attempts to connect to each listening port with the appropriate protocol family
# and tests each connector
cls.routers.append(cls.tester.qdrouterd(name, config, wait=True))
def router(name, client_server, connection):
config = cls.ssl_config(client_server, connection) + [
('router', {
'mode': 'interior',
'id': 'QDR.%s' % name
}),
('listener', {
'port': cls.tester.get_port(),
'stripAnnotations': 'no'
}),
# The following listeners were exclusively added to test the stripAnnotations attribute in qdrouterd.conf file
# Different listeners will be used to test all allowed values of stripAnnotations ('no', 'both', 'out', 'in')
('listener', {
'port': cls.tester.get_port(),
'stripAnnotations': 'no'
}),
('listener', {
'port': cls.tester.get_port(),
'stripAnnotations': 'both'
}),
('listener', {
'port': cls.tester.get_port(),
'stripAnnotations': 'out'
}),
('listener', {
'port': cls.tester.get_port(),
'stripAnnotations': 'in'
}),
('address', {
'prefix': 'closest',
'distribution': 'closest'
}),
('address', {
'prefix': 'spread',
'distribution': 'balanced'
}),
('address', {
'prefix': 'multicast',
'distribution': 'multicast'
}),
connection
]
config = Qdrouterd.Config(config)
cls.routers.append(cls.tester.qdrouterd(name, config, wait=True))
def test_http_get(self):
config = Qdrouterd.Config([
('router', {
'id': 'QDR.HTTP'
}),
# httpRoot has been deprecated. We are using it here to test backward compatibility.
('listener', {
'port': self.get_port(),
'httpRoot': os.path.dirname(__file__)
}),
('listener', {
'port': self.get_port(),
'httpRootDir': os.path.dirname(__file__)
}),
])
r = self.qdrouterd('http-test-router', config)
def test(port):
self.assert_get("http://localhost:%d" % port)
self.assertRaises(HTTPError, urlopen,
"http://localhost:%d/nosuch" % port)
# Sequential calls on multiple ports
for port in r.ports:
test(port)
# Concurrent calls on multiple ports
class TestThread(threading.Thread):
def __init__(self, port):
threading.Thread.__init__(self)
self.port, self.ex = port, None
self.start()
def run(self):
try:
test(self.port)
except Exception as e:
self.ex = e
threads = [TestThread(p) for p in r.ports + r.ports]
for t in threads:
t.join()
for t in threads:
if t.ex: raise t.ex
# https not configured
self.assertRaises(URLError, urlopen,
"https://localhost:%d/nosuch" % r.ports[0])
def router(name, mode, extra=None):
config = [('router', {
'mode': mode,
'id': name
}),
('listener', {
'role': 'normal',
'host': '0.0.0.0',
'port': cls.tester.get_port(),
'saslMechanisms': 'ANONYMOUS'
})]
if extra:
config.extend(extra)
config = Qdrouterd.Config(config)
cls.routers.append(cls.tester.qdrouterd(name, config, wait=False))
def setUpClass(cls):
super(EnableConnectionLevelProtocolTraceTest, cls).setUpClass()
name = "test-router"
LogLevelUpdateTest.listen_port = cls.tester.get_port()
config = Qdrouterd.Config([
('router', {
'mode': 'standalone',
'id': 'QDR'
}),
('listener', {
'port': LogLevelUpdateTest.listen_port
}),
])
cls.router = cls.tester.qdrouterd(name, config)
cls.router.wait_ready()
cls.address = cls.router.addresses[0]
def setUpClass(cls):
"""Start three routers"""
super(OneRouterRejectedTest, cls).setUpClass()
listen_port = cls.tester.get_port()
config = Qdrouterd.Config([('router', {
'mode': 'standalone',
'id': 'A'
}),
('listener', {
'port': listen_port,
'authenticatePeer': False,
'saslMechanisms': 'ANONYMOUS'
})])
cls.router = cls.tester.qdrouterd(name="A", config=config, wait=True)
def setUpClass(cls):
"""Start the router"""
super(AbsoluteConnectionCountLimit, cls).setUpClass()
config = Qdrouterd.Config([('router', {
'mode': 'standalone',
'id': 'QDR.Policy'
}), ('listener', {
'port': cls.tester.get_port()
}), ('policy', {
'maxConnections': 2,
'enableVhostPolicy': 'false'
})])
cls.router = cls.tester.qdrouterd('conn-limit-router',
config,
wait=True)
def setUpClass(cls):
super(ReceiverDropsOffDrainTest, cls).setUpClass()
config = Qdrouterd.Config([
('router', {
'mode': 'standalone',
'id': 'Broker'
}),
('listener', {
'role': 'normal',
'port': cls.tester.get_port(),
'saslMechanisms': 'ANONYMOUS'
}),
])
cls.router = cls.tester.qdrouterd("A", config, wait=True)
cls.address = cls.router.addresses[0]
def router(cls, name, mode, extra):
config = [
('router', {'mode': mode,
'id': name,
'allowUnsettledMulticast': 'yes'}),
('listener', {'role': 'normal',
'port': cls.tester.get_port()}),
('address', {'prefix': 'closest', 'distribution': 'closest'}),
('address', {'prefix': 'multicast', 'distribution': 'multicast'}),
]
if extra:
config.extend(extra)
config = Qdrouterd.Config(config)
cls.routers.append(cls.tester.qdrouterd(name, config, wait=True))
return cls.routers[-1]
def setUpClass(cls):
super(LogLevelUpdateTest, cls).setUpClass()
name = "test-router"
LogLevelUpdateTest.listen_port = cls.tester.get_port()
config = Qdrouterd.Config([
('router', {'mode': 'standalone', 'id': 'QDR'}),
('listener', {'port': LogLevelUpdateTest.listen_port}),
('address', {'prefix': 'closest', 'distribution': 'closest'}),
('address', {'prefix': 'balanced', 'distribution': 'balanced'}),
('address', {'prefix': 'multicast', 'distribution': 'multicast'})
])
cls.router = cls.tester.qdrouterd(name, config)
cls.router.wait_ready()
cls.address = cls.router.addresses[0]
cls.closest_count = 1
def setUpClass(cls):
"""
Single router configuration with one HTTPListener and one
HTTPConnector.
"""
super(Http1AdaptorBadEndpointsTest, cls).setUpClass()
cls.http_server_port = cls.tester.get_port()
cls.http_listener_port = cls.tester.get_port()
cls.http_fake_port = cls.tester.get_port()
config = [
('router', {
'mode': 'standalone',
'id': 'TestBadEndpoints',
'allowUnsettledMulticast': 'yes'
}),
('listener', {
'role': 'normal',
'port': cls.tester.get_port()
}),
('httpConnector', {
'port': cls.http_server_port,
'protocolVersion': 'HTTP1',
'address': 'testServer'
}),
('httpListener', {
'port': cls.http_listener_port,
'protocolVersion': 'HTTP1',
'address': 'testServer'
}),
('httpListener', {
'port': cls.http_fake_port,
'protocolVersion': 'HTTP1',
'address': 'fakeServer'
}),
('address', {
'prefix': 'closest',
'distribution': 'closest'
}),
('address', {
'prefix': 'multicast',
'distribution': 'multicast'
}),
]
config = Qdrouterd.Config(config)
cls.INT_A = cls.tester.qdrouterd("TestBadEndpoints", config, wait=True)
cls.INT_A.listener = cls.INT_A.addresses[0]
def setUpClass(cls):
super(QdstatSslNoExternalTest, cls).setUpClass()
# Write SASL configuration file:
with open('tests-mech-NOEXTERNAL.conf', 'w') as sasl_conf:
sasl_conf.write("mech_list: ANONYMOUS DIGEST-MD5 PLAIN\n")
# qdrouterd configuration:
config = Qdrouterd.Config([('router', {
'id': 'QDR.C',
'saslConfigPath': os.getcwd(),
'workerThreads': 1,
'saslConfigName': 'tests-mech-NOEXTERNAL'
}),
('sslProfile', {
'name':
'server-ssl',
'caCertFile':
cls.ssl_file('ca-certificate.pem'),
'certFile':
cls.ssl_file('server-certificate.pem'),
'privateKeyFile':
cls.ssl_file('server-private-key.pem'),
'password':
'******'
}),
('listener', {
'port': cls.tester.get_port()
}),
('listener', {
'port': cls.tester.get_port(),
'sslProfile': 'server-ssl',
'authenticatePeer': 'no',
'requireSsl': 'yes'
}),
('listener', {
'port': cls.tester.get_port(),
'sslProfile': 'server-ssl',
'authenticatePeer': 'no',
'requireSsl': 'no'
}),
('listener', {
'port': cls.tester.get_port(),
'sslProfile': 'server-ssl',
'authenticatePeer': 'yes',
'requireSsl': 'yes',
'saslMechanisms': 'EXTERNAL'
})])
cls.router = cls.tester.qdrouterd('test-router', config)
def test_http_healthz(self):
if not sys.version_info >= (2, 7):
return
config = Qdrouterd.Config([
('router', {
'id': 'QDR.HEALTHZ'
}),
('listener', {
'port': self.get_port(),
'http': 'yes'
}),
('listener', {
'port': self.get_port(),
'httpRootDir': os.path.dirname(__file__)
}),
])
r = self.qdrouterd('metrics-test-router', config)
def test(port):
result = urlopen("http://localhost:%d/healthz" % port,
cafile=self.ssl_file('ca-certificate.pem'))
self.assertEqual(200, result.getcode())
# Sequential calls on multiple ports
for port in r.ports:
test(port)
# Concurrent calls on multiple ports
class TestThread(threading.Thread):
def __init__(self, port):
threading.Thread.__init__(self)
self.port, self.ex = port, None
self.start()
def run(self):
try:
test(self.port)
except Exception as e:
self.ex = e
threads = [TestThread(p) for p in r.ports + r.ports]
for t in threads:
t.join()
for t in threads:
if t.ex: raise t.ex
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 setUpClass(cls):
"""Start a router and a messenger"""
super(MaxSessionFramesDefaultTest, cls).setUpClass()
name = "MaxSessionFramesDefault"
config = Qdrouterd.Config([
('router', {
'mode': 'standalone',
'id': 'QDR'
}),
('listener', {
'host': '0.0.0.0',
'port': cls.tester.get_port()
}),
])
cls.router = cls.tester.qdrouterd(name, config)
cls.router.wait_ready()
cls.address = cls.router.addresses[0]
def router(name, mode, max_size, extra):
config = [('router', {
'mode': mode,
'id': name,
'allowUnsettledMulticast': 'yes',
'workerThreads': W_THREADS
}), ('listener', {
'role': 'normal',
'port': cls.tester.get_port()
}),
('address', {
'prefix': 'multicast',
'distribution': 'multicast'
}),
('policy', {
'maxConnections': 100,
'enableVhostPolicy': 'true',
'maxMessageSize': max_size,
'defaultVhost': '$default'
}),
('address', {
'prefix': 'multicast',
'distribution': 'multicast'
}),
('vhost', {
'hostname':
'$default',
'allowUnknownUser':
'******',
'groups': [('$default', {
'users': '*',
'maxConnections': 100,
'remoteHosts': '*',
'sources': '*',
'targets': '*',
'allowAnonymousSender': 'true',
'allowWaypointLinks': 'true',
'allowDynamicSource': 'true'
})]
})]
if extra:
config.extend(extra)
config = Qdrouterd.Config(config)
cls.routers.append(cls.tester.qdrouterd(name, config, wait=True))
return cls.routers[-1]
def router(name, mode, connection, extra=None):
config = [
('router', {'mode': mode, 'id': name}),
('listener', {'port': cls.tester.get_port(), 'stripAnnotations': 'no'}),
('listener', {'port': cls.tester.get_port(), 'role': 'route-container', 'stripAnnotations': 'no'}),
('linkRoute', {'prefix': 'queue', 'containerId': 'LRC_S', 'direction': 'out'}),
('linkRoute', {'prefix': 'queue', 'containerId': 'LRC_R', 'direction': 'in'}),
('address', {'prefix': 'closest', 'distribution': 'closest'}),
('address', {'prefix': 'spread', 'distribution': 'balanced'}),
('address', {'prefix': 'multicast', 'distribution': 'multicast'}),
connection
]
if extra:
config.append(extra)
config = Qdrouterd.Config(config)
cls.routers.append(cls.tester.qdrouterd(name, config, wait=True))
def router(name, connection):
config = [
('router', {'mode': 'interior', 'id': name, 'allowUnsettledMulticast': 'yes'}),
('listener', {'port': cls.tester.get_port(), 'stripAnnotations': 'no'}),
('listener', {'port': cls.tester.get_port(), 'stripAnnotations': 'no', 'role': 'route-container'}),
('linkRoute', {'prefix': 'link', 'direction': 'in', 'containerId': 'LRC'}),
('linkRoute', {'prefix': 'link', 'direction': 'out', 'containerId': 'LRC'}),
('address', {'prefix': 'closest', 'distribution': 'closest'}),
('address', {'prefix': 'spread', 'distribution': 'balanced'}),
('address', {'prefix': 'multicast', 'distribution': 'multicast'}),
connection
]
config = Qdrouterd.Config(config)
cls.routers.append(cls.tester.qdrouterd(name, config, wait=True))
def router(name, connection, args=[]):
config = [
('router', {'mode': 'interior', 'id': name}),
('listener', {'port': cls.tester.get_port(), 'stripAnnotations': 'no'}),
('listener', {'port': cls.tester.get_port(), 'stripAnnotations': 'no', 'multiTenant': 'yes'}),
('listener', {'port': cls.tester.get_port(), 'stripAnnotations': 'no', 'role': 'route-container'}),
('address', {'prefix': 'closest', 'distribution': 'closest'}),
('address', {'prefix': 'spread', 'distribution': 'balanced'}),
('address', {'prefix': 'multicast', 'distribution': 'multicast'}),
('address', {'prefix': '0.0.0.0/queue', 'waypoint': 'yes'}),
connection
]
config = Qdrouterd.Config(config)
cls.routers.append(cls.tester.qdrouterd(name, config, wait=True, cl_args=args))
def router(name, mode, connection, extra=None):
"""
Launch a router through the system_test framework.
For each router:
* normal listener first
#* http listener for console connections
* tcp listener for 'nodest', which will never exist
* tcp connector to echo server whose address is the same as this router's name
* six tcp listeners, one for each server on each router on the network
:param name: router name
:param mode: router mode: interior or edge
:param connection: list of router-level connection/listener tuples
:param extra: yet more configuation tuples. unused for now
:return:
"""
config = [
('router', {'mode': mode, 'id': name}),
('listener', {'port': cls.amqp_listener_ports[name]}),
# ('listener', {'port': cls.http_listener_ports[name], 'http': 'yes'}),
('tcpListener', {'host': "0.0.0.0",
'port': cls.nodest_listener_ports[name],
'address': 'nodest',
'siteId': cls.site}),
('tcpConnector', {'host': "127.0.0.1",
'port': cls.tcp_server_listener_ports[name],
'address': 'ES_' + name,
'siteId': cls.site})
]
if connection:
config.extend(connection)
listeners = []
for rtr in cls.router_order:
listener = {'host': "0.0.0.0",
'port': cls.tcp_client_listener_ports[name][rtr],
'address': 'ES_' + rtr,
'siteId': cls.site}
tup = [(('tcpListener', listener))]
listeners.extend(tup)
config.extend(listeners)
if extra:
config.extend(extra)
config = Qdrouterd.Config(config)
cls.routers.append(cls.tester.qdrouterd(name, config, wait=True))
def setUpClass(cls):
"""Start a router and a messenger"""
super(AutolinkTest, cls).setUpClass()
name = "test-router"
config = Qdrouterd.Config([
('router', {'mode': 'standalone', 'id': 'QDR'}),
#
# Create a general-purpose listener for sending and receiving deliveries
#
('listener', {'port': cls.tester.get_port()}),
#
# Create a route-container listener for the autolinks
#
('listener', {'port': cls.tester.get_port(), 'role': 'route-container'}),
#
# Set up the prefix 'node' as a prefix for waypoint addresses
#
('address', {'prefix': 'node', 'waypoint': 'yes'}),
#
# Create a pair of default auto-links for 'node.1'
#
('autoLink', {'addr': 'node.1', 'containerId': 'container.1', 'dir': 'in'}),
('autoLink', {'addr': 'node.1', 'containerId': 'container.1', 'dir': 'out'}),
#
# Create a pair of auto-links on non-default phases for container-to-container transfers
#
('autoLink', {'addr': 'xfer.2', 'containerId': 'container.2', 'dir': 'in', 'phase': '4'}),
('autoLink', {'addr': 'xfer.2', 'containerId': 'container.3', 'dir': 'out', 'phase': '4'}),
#
# Create a pair of auto-links with a different external address
#
('autoLink', {'addr': 'node.2', 'externalAddr': 'ext.2', 'containerId': 'container.4', 'dir': 'in'}),
('autoLink', {'addr': 'node.2', 'externalAddr': 'ext.2', 'containerId': 'container.4', 'dir': 'out'}),
])
cls.router = cls.tester.qdrouterd(name, config)
cls.router.wait_ready()
cls.normal_address = cls.router.addresses[0]
cls.route_address = cls.router.addresses[1]
def router(name, mode, extra):
config = [
('router', {'mode': mode,
'id': name,
'allowUnsettledMulticast': 'yes',
'workerThreads': W_THREADS}),
('listener', {'role': 'normal',
'port': cls.tester.get_port(),
'maxFrameSize': MAX_FRAME,
'linkCapacity': LINK_CAPACITY}),
('address', {'prefix': 'multicast', 'distribution': 'multicast'}),
]
if extra:
config.extend(extra)
config = Qdrouterd.Config(config)
cls.routers.append(cls.tester.qdrouterd(name, config, wait=True))
return cls.routers[-1]
def router(name, extra_config):
config = [
('router', {'id': name,
'mode': 'interior',
"defaultDistribution": "unavailable"}),
('listener', {'role': 'normal',
'port': cls.tester.get_port(),
"linkCapacity": '100'}),
('address', {'prefix': 'closest', 'distribution': 'closest'}),
('address', {'prefix': 'balanced', 'distribution': 'balanced'}),
('address', {'prefix': 'multicast', 'distribution': 'multicast'}),
] + extra_config
config = Qdrouterd.Config(config)
cls.routers.append(cls.tester.qdrouterd(name, config, wait=False))
def test_listen_error(self):
"""Make sure a router exits if an initial HTTP listener fails, doesn't hang"""
listen_port = self.get_port()
config = Qdrouterd.Config([('router', {
'mode': 'standalone',
'id': 'bad'
}),
('listener', {
'port': listen_port,
'maxFrameSize': '2048',
'stripAnnotations': 'no'
}),
('listener', {
'port': listen_port,
'http': True
})])
r = Qdrouterd(name="expect_fail", config=config, wait=False)
self.assertEqual(1, r.wait())
