def __init__(self, first_host, second_host, first_address, second_address,
dynamic, lookup_host, routers):
super(LinkRouteTest, self).__init__(prefetch=0)
self.logger = Logger(title="LinkRouteTest")
self.first_host = first_host
self.second_host = second_host
self.first_address = first_address
self.second_address = second_address
self.dynamic = dynamic
self.lookup_host = lookup_host
self.routers = routers
self.reactor = None
self.first_conn = None
self.second_conn = None
self.error = None
self.first_sender = None
self.first_receiver = None
self.second_sender = None
self.second_receiver = None
self.poll_timer = None
self.count = 10
self.n_sent = 0
self.n_rcvd = 0
self.n_settled = 0
def __init__(self, first_host, second_host, first_address, second_address, container_id="ALC"):
super(WaypointTest, self).__init__()
self.first_host = first_host
self.second_host = second_host
self.first_address = first_address
self.second_address = second_address
self.container_id = container_id
self.logger = Logger(title="WaypointTest")
self.first_conn = None
self.second_conn = None
self.error = None
self.first_sender = None
self.first_sender_created = False
self.first_sender_link_opened = False
self.first_receiver = None
self.first_receiver_created = False
self.waypoint_sender = None
self.waypoint_receiver = None
self.waypoint_queue = []
self.waypoint_sender_opened = False
self.waypoint_receiver_opened = False
self.firsts_created = False
self.count = 10
self.n_sent = 0
self.n_rcvd = 0
self.n_waypoint_rcvd = 0
self.n_thru = 0
self.outs = None
def __init__(self, sender_host, receiver_host, test_address,
message_size=100000, count=10, expect_block=True, print_to_console=False):
super(OversizeMessageTransferTest, self).__init__()
self.sender_host = sender_host
self.receiver_host = receiver_host
self.test_address = test_address
self.msg_size = message_size
self.count = count
self.expect_block = expect_block
self.sender_conn = None
self.receiver_conn = None
self.error = None
self.sender = None
self.receiver = None
self.proxy = None
self.n_sent = 0
self.n_rcvd = 0
self.n_accepted = 0
self.n_rejected = 0
self.n_aborted = 0
self.n_connection_error = 0
self.shut_down = False
self.logger = Logger(title=("OversizeMessageTransferTest - %s" % (self.test_address)), print_to_console=print_to_console)
self.log_unhandled = False
def setUpClass(cls):
super(TcpAdaptorManagementTest, cls).setUpClass()
if DISABLE_SELECTOR_TESTS:
return
cls.tcp_server_port = cls.tester.get_port()
cls.tcp_listener_port = cls.tester.get_port()
cls.test_name = 'TCPMgmtTest'
# Here we have a simple barebones standalone router config.
config = [
('router', {'mode': 'standalone',
'id': cls.test_name}),
('listener', {'role': 'normal',
'port': cls.tester.get_port()}),
]
config = Qdrouterd.Config(config)
cls.router = cls.tester.qdrouterd(cls.test_name, config, wait=True)
# Start the echo server. This is the server that the tcpConnector
# will be connecting to.
server_prefix = "ECHO_SERVER ES_%s" % cls.test_name
cls.logger = Logger(title="TcpAdaptor",
print_to_console=True,
save_for_dump=False,
ofilename="../setUpClass/TcpAdaptor_echo_server.log")
cls.echo_server = TcpEchoServer(prefix=server_prefix,
port=cls.tcp_server_port,
logger=cls.logger)
# The router and the echo server are running at this point.
assert cls.echo_server.is_running
def __init__(self,
test_class,
sender_host,
routers,
test_address,
expect_receives,
blocked_by_ingress,
blocked_by_interior,
message_size=100000,
count=10,
print_to_console=False):
"""
Construct an instance of the multicast test
:param test_class: test class - has wait-connection function
:param sender_host: router for the sender connection
:param routers: a list of all the routers for receiver connections
:param test_address: sender/receiver AMQP address
:param expect_receives: array of expected receive counts
:param blocked_by_ingress: true if ingress router blocks
:param blocked_by_interior: true if edge router messages also blocked by interior
:param message_size: in bytes
:param count: how many messages to send
:param print_to_console: print logs as they happen
"""
super(OversizeMulticastTransferTest, self).__init__()
self.test_class = test_class
self.sender_host = sender_host
self.routers = routers
self.test_address = test_address
self.msg_size = message_size
self.count = count
self.expect_receives = expect_receives # router array
self.blocked_by_ingress = blocked_by_ingress
self.blocked_by_interior = blocked_by_interior
self.messages = []
self.sender_conn = None
self.receiver_conns = [None, None, None, None] # router array
self.error = None
self.sender = None
self.receivers = [None, None, None, None] # router array
self.proxy = None
self.network_stable = False
self.n_sent = 0
self.n_rcvds = [0, 0, 0, 0] # router array
self.n_accepted = 0
self.n_rejected = 0
self.n_modified = 0
self.n_released = 0
self.n_send_settled = 0
self.n_aborteds = [0, 0, 0, 0] # router array
self.n_connection_error = 0
self.shut_down = False
self.logger = Logger(title=("OversizeMulticastTransferTest - %s" %
(self.test_address)),
print_to_console=print_to_console)
self.log_unhandled = False # verbose diagnostics of proton callbacks
def __init__(self, server_port, client_port, tests, handler_cls=None):
self._logger = Logger(title="TestServer", print_to_console=False)
self._client_port = client_port
self._server_addr = ("", server_port)
self._server = MyHTTPServer(self._server_addr,
handler_cls or RequestHandler,
tests)
self._server.allow_reuse_address = True
self._thread = Thread(target=self._run)
self._thread.daemon = True
self._thread.start()
def __init__(self,
test_class,
sender_host,
receiver_host,
test_address,
message_size=100000,
count=10,
blocked_by_both=False,
print_to_console=False):
"""
Construct an instance of the unicast test
:param test_class: test class - has wait-connection function
:param sender_host: router for sender connection
:param receiver_host: router for receiver connection
:param test_address: sender/receiver AMQP address
:param message_size: in bytes
:param count: how many messages to send
:param blocked_by_both: true if edge router messages are also blocked by interior
:param print_to_console: print logs as they happen
"""
super(OversizeMessageTransferTest, self).__init__()
self.test_class = test_class
self.sender_host = sender_host
self.receiver_host = receiver_host
self.test_address = test_address
self.msg_size = message_size
self.count = count
self.blocked_by_both = blocked_by_both
self.expect_block = True
self.messages = []
self.sender_conn = None
self.receiver_conn = None
self.error = None
self.sender = None
self.receiver = None
self.proxy = None
self.network_stable = False
self.n_sent = 0
self.n_rcvd = 0
self.n_accepted = 0
self.n_rejected = 0
self.n_modified = 0
self.n_released = 0
self.n_send_settled = 0
self.n_aborted = 0
self.n_connection_error = 0
self.shut_down = False
self.logger = Logger(title=("OversizeMessageTransferTest - %s" %
(self.test_address)),
print_to_console=print_to_console)
self.log_unhandled = False # verbose diagnostics of proton callbacks
def __init__(self, test_name, client_n, logger, client, server, size,
count,
print_client_logs=True,
timeout=TIMEOUT,
port_override=None):
"""
Launch an echo client upon construction.
:param test_name: Unique name for log file prefix
:param client_n: Client number for differentiating otherwise identical clients
:param logger: parent logger for logging test activity vs. client activity
:param client: router name to which the client connects
:param server: name whose address the client is targeting
:param size: length of messages in bytes
:param count: number of messages to be sent/verified
:param print_client_logs: verbosity switch
:return Null if success else string describing error
"""
self.test_name = test_name
self.client_n = str(client_n)
self.logger = logger
self.client = client
self.server = server
self.size = size
self.count = count
self.timeout = timeout
self.print_client_logs = print_client_logs
self.client_final = False
# Each router has a listener for the echo server attached to every router
self.listener_port = TcpAdaptor.tcp_client_listener_ports[self.client][self.server] if port_override is None else port_override
self.name = "%s_%s_%s_%s" % \
(self.test_name, self.client_n, self.size, self.count)
self.client_prefix = "ECHO_CLIENT %s" % self.name
self.client_logger = Logger(title=self.client_prefix,
print_to_console=self.print_client_logs,
save_for_dump=False,
ofilename="../setUpClass/TcpAdaptor_echo_client_%s.log" % self.name)
try:
self.e_client = TcpEchoClient(prefix=self.client_prefix,
host='localhost',
port=self.listener_port,
size=self.size,
count=self.count,
timeout=self.timeout,
logger=self.client_logger)
except Exception as exc:
self.e_client.error = "TCP_TEST TcpAdaptor_runner_%s failed. Exception: %s" % \
(self.name, traceback.format_exc())
self.logger.log(self.e_client.error)
raise Exception(self.e_client.error)
def __init__(self, tests, port, repeat=1):
self._id = uuid.uuid4().hex
self._conn_addr = ("127.0.0.1:%s" % port)
self._tests = tests
self._repeat = repeat
self._logger = Logger(title="TestClient: %s" % self._id,
print_to_console=False)
self._thread = Thread(target=self._run)
self._thread.daemon = True
self.error = None
self.count = 0
self._thread.start()
def __init__(self, url, container_id=None, **handler_kwargs):
super(FakeBroker, self).__init__(**handler_kwargs)
self.url = url
self.queues = {}
self.acceptor = None
self.in_count = 0
self.out_count = 0
self.link_errors = 0
self._connections = []
self._error = None
self._container = Container(self)
self._container.container_id = container_id or 'FakeBroker'
self._logger = Logger(title=self._container.container_id)
self._thread = Thread(target=self._main)
self._thread.daemon = True
self._stop_thread = False
self._thread.start()
def __init__(self, sender_host, receiver_host, address):
super(MessageRouteAbortTest, self).__init__()
self.sender_host = sender_host
self.receiver_host = receiver_host
self.address = address
self.sender_conn = None
self.receiver_conn = None
self.error = None
self.sender1 = None
self.receiver = None
self.delivery = None
self.logger = Logger(title="MessageRouteAbortTest")
self.program = [('D', 10), ('D', 20), ('A', 30), ('A', 40), ('D', 50), ('D', 60),
('A', 100), ('D', 110),
('A', 1000), ('A', 1010), ('A', 1020), ('A', 1030), ('A', 1040), ('D', 1050),
('A', 10000), ('A', 10010), ('A', 10020), ('A', 10030), ('A', 10040), ('D', 10050),
('A', 100000), ('A', 100010), ('A', 100020), ('A', 100030), ('A', 100040), ('D', 100050), ('F', 10)]
self.result = []
self.expected_result = [10, 20, 50, 60, 110, 1050, 10050, 100050]
def __init__(self, sender_host, primary_host, fallback_host, addr):
super(SwitchoverTest, self).__init__()
self.sender_host = sender_host[0]
self.primary_host = primary_host[0]
self.fallback_host = fallback_host[0]
self.sender_name = sender_host[1]
self.primary_name = primary_host[1]
self.fallback_name = fallback_host[1]
self.addr = addr
self.count = 300
# DISPATCH-2213 back off on logging.
self.log_sends = 100 # every 100th send
self.log_recvs = 100 # every 100th receive
self.log_released = 100 # every 100th sender released
self.sender_conn = None
self.primary_conn = None
self.fallback_conn = None
self.primary_open = False
self.fallback_open = False
self.error = None
self.n_tx = 0
self.n_rx = 0
self.n_rel = 0
self.phase = 0
self.tx_seq = 0
self.local_rel = 0
self.log_prefix = "FALLBACK_TEST %s" % self.addr
self.logger = Logger("SwitchoverTest_%s" % addr,
print_to_console=False)
# Prepend a convenience SERVER line for scraper tool.
# Then the logs from this test can be merged with the router logs in scraper.
self.logger.log("SERVER (info) Container Name: %s" % self.addr)
self.logger.log("%s SwitchoverTest sender:%s primary:%s fallback:%s" %
(self.log_prefix, self.sender_name, self.primary_name,
self.fallback_name))
def test_yy_query_many_links(self):
# This test will fail without the fix for DISPATCH-974
c = BlockingConnection(self.address())
self.logger = Logger(title="test_yy_query_many_links")
count = 0
COUNT = 5000
ADDRESS_SENDER = "examples-sender"
ADDRESS_RECEIVER = "examples-receiver"
# This loop creates 5000 consumer and 5000 producer links with
# different addresses
while count < COUNT:
r = c.create_receiver(ADDRESS_RECEIVER + str(count))
s = c.create_sender(ADDRESS_SENDER + str(count))
count += 1
# Try fetching all 10,000 addresses
# This qdmanage query command would fail without the fix
# for DISPATCH-974
query_command = 'QUERY --type=org.apache.qpid.dispatch.router.address'
outs = json.loads(self.run_qdmanage(query_command))
sender_addresses = 0
receiver_addresses = 0
for out in outs:
if ADDRESS_SENDER in out['name']:
sender_addresses += 1
if ADDRESS_RECEIVER in out['name']:
receiver_addresses += 1
self.assertEqual(sender_addresses, COUNT)
self.assertEqual(receiver_addresses, COUNT)
query_command = 'QUERY --type=link'
outs = json.loads(self.run_qdmanage(query_command))
out_links = 0
in_links = 0
success = False
i = 0
while i < 3:
i += 1
for out in outs:
if out.get('owningAddr'):
if ADDRESS_SENDER in out['owningAddr']:
in_links += 1
if ADDRESS_RECEIVER in out['owningAddr']:
out_links += 1
# If the link count is less than COUNT, try again in 2 seconds
# Try after 2 more seconds for a total of 6 seconds.
# If the link count is still less than expected count, there
# is something wrong, the test has failed.
if out_links < COUNT or in_links < COUNT:
self.logger.log("out_links=%s, in_links=%s" %
(str(out_links), str(in_links)))
sleep(2)
outs = json.loads(self.run_qdmanage(query_command))
else:
self.logger.log("Test success!")
success = True
break
if not success:
self.logger.dump()
self.assertEqual(out_links, COUNT)
self.assertEqual(in_links, COUNT)
def main(argv):
retval = 0
logger = None
# parse args
p = argparse.ArgumentParser()
p.add_argument('--port', '-p', help='Required listening port number')
p.add_argument('--name', help='Optional logger prefix')
p.add_argument(
'--echo',
'-e',
type=int,
default=0,
const=1,
nargs="?",
help=
'Exit after echoing this many bytes. Default value "0" disables exiting on byte count.'
)
p.add_argument(
'--timeout',
'-t',
type=float,
default=0.0,
const=1,
nargs="?",
help='Timeout in seconds. Default value "0" disables timeouts')
p.add_argument('--log',
'-l',
action='store_true',
help='Write activity log to console')
del argv[0]
args = p.parse_args(argv)
# port
if args.port is None:
raise Exception("User must specify a port number")
port = args.port
# name / prefix
prefix = args.name if args.name is not None else "ECHO_SERVER (%s)" % (
str(port))
# echo
if args.echo < 0:
raise Exception("Echo count must be greater than zero")
# timeout
if args.timeout < 0.0:
raise Exception("Timeout must be greater than or equal to zero")
signaller = GracefulExitSignaler()
server = None
try:
# logging
logger = Logger(title="%s port %s" % (prefix, port),
print_to_console=args.log,
save_for_dump=False)
server = TcpEchoServer(prefix, port, args.echo, args.timeout, logger)
keep_running = True
while keep_running:
time.sleep(0.1)
if server.error is not None:
logger.log("%s Server stopped with error: %s" %
(prefix, server.error))
keep_running = False
retval = 1
if server.exit_status is not None:
logger.log("%s Server stopped with status: %s" %
(prefix, server.exit_status))
keep_running = False
if signaller.kill_now:
logger.log("%s Process killed with signal" % prefix)
keep_running = False
if keep_running and not server.is_running:
logger.log("%s Server stopped with no error or status" %
prefix)
keep_running = False
except Exception:
if logger is not None:
logger.log("%s Exception: %s" % (prefix, traceback.format_exc()))
retval = 1
if server is not None and server.sock is not None:
server.sock.close()
return retval
def setUpClass(cls):
"""Start a router"""
super(TcpAdaptor, cls).setUpClass()
if DISABLE_SELECTOR_TESTS:
return
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))
cls.routers = []
# define logging levels
cls.print_logs_server = False
cls.print_logs_client = True
cls.logger = Logger(title="TcpAdaptor-testClass",
print_to_console=True,
save_for_dump=False,
ofilename='../setUpClass/TcpAdaptor.log')
# Write a dummy log line for scraper.
cls.logger.log("SERVER (info) Container Name: TCP_TEST")
# Allocate echo server ports first
for rtr in cls.router_order:
cls.tcp_server_listener_ports[rtr] = cls.tester.get_port()
# start echo servers immediately after the echo server
# ports are assigned.
for rtr in cls.router_order:
test_name = "TcpAdaptor"
server_prefix = "ECHO_SERVER %s ES_%s" % (test_name, rtr)
server_logger = Logger(
title=test_name,
print_to_console=cls.print_logs_server,
save_for_dump=False,
ofilename="../setUpClass/TcpAdaptor_echo_server_%s.log" % rtr)
cls.logger.log("TCP_TEST Launching echo server '%s'" %
server_prefix)
server = TcpEchoServer(prefix=server_prefix,
port=cls.tcp_server_listener_ports[rtr],
logger=server_logger)
assert server.is_running
cls.echo_servers[rtr] = server
cls.EC2_conn_stall_connector_port = cls.tester.get_port()
# start special naughty servers that misbehave on purpose
server_prefix = "ECHO_SERVER TcpAdaptor NS_EC2_CONN_STALL"
server_logger = Logger(
title="TcpAdaptor",
print_to_console=cls.print_logs_server,
save_for_dump=False,
ofilename="../setUpClass/TcpAdaptor_echo_server_NS_CONN_STALL.log")
cls.logger.log("TCP_TEST Launching echo server '%s'" % server_prefix)
server = TcpEchoServer(prefix=server_prefix,
port=cls.EC2_conn_stall_connector_port,
logger=server_logger,
conn_stall=Q2_DELAY_SECONDS)
assert server.is_running
cls.echo_server_NS_CONN_STALL = server
# Allocate a sea of router ports
for rtr in cls.router_order:
cls.amqp_listener_ports[rtr] = cls.tester.get_port()
tl_ports = {}
for tcp_listener in cls.router_order:
tl_ports[tcp_listener] = cls.tester.get_port()
cls.tcp_client_listener_ports[rtr] = tl_ports
cls.nodest_listener_ports[rtr] = cls.tester.get_port()
inter_router_port_AB = cls.tester.get_port()
cls.INTA_edge_port = cls.tester.get_port()
cls.INTA_conn_stall_listener_port = cls.tester.get_port()
# Launch the routers using the sea of router ports
router('INTA', 'interior',
[('listener', {
'role': 'inter-router',
'port': inter_router_port_AB
}),
('listener', {
'name': 'uplink',
'role': 'edge',
'port': cls.INTA_edge_port
}),
('tcpListener', {
'host': "0.0.0.0",
'port': cls.INTA_conn_stall_listener_port,
'address': 'NS_EC2_CONN_STALL',
'siteId': cls.site
})])
inter_router_port_BC = cls.tester.get_port()
cls.INTB_edge_port = cls.tester.get_port()
router('INTB', 'interior', [('connector', {
'role': 'inter-router',
'port': inter_router_port_AB
}), ('listener', {
'role': 'inter-router',
'port': inter_router_port_BC
}),
('listener', {
'name': 'uplink',
'role': 'edge',
'port': cls.INTB_edge_port
})])
cls.INTC_edge_port = cls.tester.get_port()
router('INTC', 'interior', [('connector', {
'role': 'inter-router',
'port': inter_router_port_BC
}),
('listener', {
'name': 'uplink',
'role': 'edge',
'port': cls.INTC_edge_port
})])
router('EA1', 'edge', [('connector', {
'name': 'uplink',
'role': 'edge',
'port': cls.INTA_edge_port
})])
router('EA2', 'edge', [('connector', {
'name': 'uplink',
'role': 'edge',
'port': cls.INTA_edge_port
})])
router('EB1', 'edge', [('connector', {
'name': 'uplink',
'role': 'edge',
'port': cls.INTB_edge_port
})])
router('EB2', 'edge', [('connector', {
'name': 'uplink',
'role': 'edge',
'port': cls.INTB_edge_port
})])
router('EC1', 'edge', [('connector', {
'name': 'uplink',
'role': 'edge',
'port': cls.INTC_edge_port
})])
cls.EC2_conn_stall_listener_port = cls.tester.get_port()
router('EC2', 'edge', [('connector', {
'name': 'uplink',
'role': 'edge',
'port': cls.INTC_edge_port
}),
('tcpConnector', {
'host': "127.0.0.1",
'port': cls.EC2_conn_stall_connector_port,
'address': 'NS_EC2_CONN_STALL',
'siteId': cls.site
}),
('tcpListener', {
'host': "0.0.0.0",
'port': cls.EC2_conn_stall_listener_port,
'address': 'NS_EC2_CONN_STALL',
'siteId': cls.site
})])
cls.INTA = cls.routers[0]
cls.INTB = cls.routers[1]
cls.INTC = cls.routers[2]
cls.EA1 = cls.routers[3]
cls.EA2 = cls.routers[4]
cls.EB1 = cls.routers[5]
cls.EB2 = cls.routers[6]
cls.EC1 = cls.routers[7]
cls.EC2 = cls.routers[8]
cls.router_dict = {}
cls.router_dict['INTA'] = cls.INTA
cls.router_dict['INTB'] = cls.INTB
cls.router_dict['INTC'] = cls.INTC
cls.router_dict['EA1'] = cls.EA1
cls.router_dict['EA2'] = cls.EA2
cls.router_dict['EB1'] = cls.EB1
cls.router_dict['EB2'] = cls.EB2
cls.router_dict['EC1'] = cls.EC1
cls.router_dict['EC2'] = cls.EC2
cls.logger.log("TCP_TEST INTA waiting for connection to INTB")
cls.INTA.wait_router_connected('INTB')
cls.logger.log("TCP_TEST INTB waiting for connection to INTA")
cls.INTB.wait_router_connected('INTA')
cls.logger.log("TCP_TEST INTB waiting for connection to INTC")
cls.INTB.wait_router_connected('INTC')
cls.logger.log("TCP_TEST INTC waiting for connection to INTB")
cls.INTC.wait_router_connected('INTB')
# Create a scoreboard for the ports
p_out = []
for rtr in cls.router_order:
p_out.append("%s_amqp=%d" % (rtr, cls.amqp_listener_ports[rtr]))
p_out.append("%s_echo_server=%d" %
(rtr, cls.tcp_server_listener_ports[rtr]))
for tcp_listener in cls.router_order:
p_out.append(
"%s_echo_listener_for_%s=%d" %
(rtr, tcp_listener,
cls.tcp_client_listener_ports[rtr][tcp_listener]))
p_out.append("%s_nodest_listener=%d" %
(rtr, cls.nodest_listener_ports[rtr]))
# p_out.append("%s_http_listener=%d" %
# (rtr, cls.http_listener_ports[rtr]))
p_out.append("inter_router_port_AB=%d" % inter_router_port_AB)
p_out.append("inter_router_port_BC=%d" % inter_router_port_BC)
p_out.append("INTA_edge_port=%d" % cls.INTA_edge_port)
p_out.append("INTB_edge_port=%d" % cls.INTB_edge_port)
p_out.append("INTC_edge_port=%d" % cls.INTC_edge_port)
p_out.append("EC2_conn_stall_connector_port%d" %
cls.EC2_conn_stall_connector_port)
p_out.append("INTA_conn_stall_listener_port%d" %
cls.INTA_conn_stall_listener_port)
p_out.append("EC2_conn_stall_listener_port%d" %
cls.EC2_conn_stall_listener_port)
# write to log
for line in p_out:
cls.logger.log("TCP_TEST %s" % line)
# write to shell script
with open("../setUpClass/TcpAdaptor-ports.sh", 'w') as o_file:
for line in p_out:
o_file.write("set %s\n" % line)
# Write a script to run scraper on this test's log files
scraper_abspath = os.path.join(os.environ.get('BUILD_DIR'), 'tests',
'scraper', 'scraper.py')
logs_dir = os.path.abspath("../setUpClass")
main_log = "TcpAdaptor.log"
echo_logs = "TcpAdaptor_echo*"
big_test_log = "TcpAdaptor_all.log"
int_logs = "I*.log"
edge_logs = "E*.log"
log_modules_spec = "--log-modules TCP_ADAPTOR,TCP_TEST,ECHO_SERVER,ECHO_CLIENT"
html_output = "TcpAdaptor.html"
with open("../setUpClass/TcpAdaptor-run-scraper.sh", 'w') as o_file:
o_file.write("#!/bin/bash\n\n")
o_file.write(
"# Script to run scraper on test class TcpAdaptor test result\n"
)
o_file.write("# cd into logs directory\n")
o_file.write("cd %s\n\n" % logs_dir)
o_file.write("# Concatenate test class logs into single file\n")
o_file.write("cat %s %s > %s\n\n" %
(main_log, echo_logs, big_test_log))
o_file.write("# run scraper\n")
o_file.write("python %s %s -f %s %s %s > %s\n\n" %
(scraper_abspath, log_modules_spec, int_logs,
edge_logs, big_test_log, html_output))
o_file.write("echo View the results by opening the html file\n")
o_file.write("echo firefox %s" %
(os.path.join(logs_dir, html_output)))
# wait for server addresses (mobile ES_<rtr>) to propagate to all interior routers
interior_rtrs = [
rtr for rtr in cls.router_order if rtr.startswith('I')
]
found_all = False
while not found_all:
found_all = True
cls.logger.log(
"TCP_TEST Poll wait for echo server addresses to propagate")
for rtr in interior_rtrs:
# query each interior for addresses
p = Process([
'qdstat', '-b',
str(cls.router_dict[rtr].addresses[0]), '-a'
],
name='qdstat-snap1',
stdout=PIPE,
expect=None,
universal_newlines=True)
out = p.communicate()[0]
# examine what this router can see; signal poll loop to continue or not
lines = out.split("\n")
server_lines = [
line for line in lines
if "mobile" in line and "ES_" in line
]
if not len(server_lines) == len(cls.router_order):
found_all = False
seen = []
for line in server_lines:
flds = line.split()
seen.extend(
[fld for fld in flds if fld.startswith("ES_")])
unseen = [
srv for srv in cls.router_order
if "ES_" + srv not in seen
]
cls.logger.log(
"TCP_TEST Router %s sees only %d of %d addresses. Waiting for %s"
% (rtr, len(server_lines), len(
cls.router_order), unseen))
cls.logger.log("TCP_TEST Done poll wait")
def main(argv):
retval = 0
# parse args
p = argparse.ArgumentParser()
p.add_argument('--host', '-b', help='Required target host')
p.add_argument('--port',
'-p',
type=int,
help='Required target port number')
p.add_argument(
'--size',
'-s',
type=int,
default=100,
const=1,
nargs='?',
help=
'Size of payload in bytes must be >= 0. Size of zero connects and disconnects with no data traffic.'
)
p.add_argument(
'--count',
'-c',
type=int,
default=1,
const=1,
nargs='?',
help=
'Number of payloads to process must be >= 0. Count of zero connects and disconnects with no data traffic.'
)
p.add_argument('--name', help='Optional logger prefix')
p.add_argument(
'--timeout',
'-t',
type=float,
default=0.0,
const=1,
nargs="?",
help='Timeout in seconds. Default value "0" disables timeouts')
p.add_argument('--log',
'-l',
action='store_true',
help='Write activity log to console')
del argv[0]
args = p.parse_args(argv)
# host
if args.host is None:
raise Exception("User must specify a host")
host = args.host
# port
if args.port is None:
raise Exception("User must specify a port number")
port = args.port
# size
if args.size < 0:
raise Exception("Size must be greater than or equal to zero")
size = args.size
# count
if args.count < 0:
raise Exception("Count must be greater than or equal to zero")
count = args.count
# name / prefix
prefix = args.name if args.name is not None else "ECHO_CLIENT (%d_%d_%d)" % \
(port, size, count)
# timeout
if args.timeout < 0.0:
raise Exception("Timeout must be greater than or equal to zero")
signaller = GracefulExitSignaler()
logger = None
try:
# logging
logger = Logger(title="%s host:%s port %d size:%d count:%d" %
(prefix, host, port, size, count),
print_to_console=args.log,
save_for_dump=False)
client = TcpEchoClient(prefix, host, port, size, count, args.timeout,
logger)
keep_running = True
while keep_running:
time.sleep(0.1)
if client.error is not None:
logger.log("%s Client stopped with error: %s" %
(prefix, client.error))
keep_running = False
retval = 1
if client.exit_status is not None:
logger.log("%s Client stopped with status: %s" %
(prefix, client.exit_status))
keep_running = False
if signaller.kill_now:
logger.log("%s Process killed with signal" % prefix)
keep_running = False
if keep_running and not client.is_running:
logger.log("%s Client stopped with no error or status" %
prefix)
keep_running = False
except Exception:
client.error = "ERROR: exception : '%s'" % traceback.format_exc()
if logger is not None:
logger.log("%s Exception: %s" % (prefix, traceback.format_exc()))
retval = 1
if client.error is not None:
# write client errors to stderr
def eprint(*args, **kwargs):
print(*args, file=sys.stderr, **kwargs)
elines = client.error.split("\n")
for line in elines:
eprint("ERROR:", prefix, line)
return retval
def main(argv):
retval = 0
logger = None
# parse args
p = argparse.ArgumentParser()
p.add_argument('--port', '-p', help='Required listening port number')
p.add_argument('--name', help='Optional logger prefix')
p.add_argument(
'--echo',
'-e',
type=int,
default=0,
const=1,
nargs="?",
help=
'Exit after echoing this many bytes. Default value "0" disables exiting on byte count.'
)
p.add_argument(
'--timeout',
'-t',
type=float,
default=0.0,
const=1,
nargs="?",
help='Timeout in seconds. Default value "0.0" disables timeouts')
p.add_argument('--log',
'-l',
action='store_true',
help='Write activity log to console')
# Add controlled server misbehavior for testing conditions seen in the field
# Stall required to trigger Q2 testing for DISPATCH-1947 and improving test DISPATCH-1981
p.add_argument(
'--connect-stall',
type=float,
default=0.0,
const=1,
nargs="?",
help=
'Accept connections but wait this many seconds before reading from socket. Default value "0.0" disables stall'
)
# Close on connect - exercises control paths scrutinized under DISPATCH-1968
p.add_argument(
'--close-on-connect',
action='store_true',
help=
'Close client connection without reading from socket when listener connects. If stall is specified then stall before closing.'
)
# Close on data - exercises control paths scrutinized under DISPATCH-1968
p.add_argument('--close-on-data',
action='store_true',
help='Close client connection as soon as data arrives.')
del argv[0]
args = p.parse_args(argv)
# port
if args.port is None:
raise Exception("User must specify a port number")
port = args.port
# name / prefix
prefix = args.name if args.name is not None else "ECHO_SERVER (%s)" % (
str(port))
# echo
if args.echo < 0:
raise Exception("Echo count must be greater than zero")
# timeout
if args.timeout < 0.0:
raise Exception("Timeout must be greater than or equal to zero")
# timeout
if args.connect_stall < 0.0:
raise Exception("Connect-stall must be greater than or equal to zero")
signaller = GracefulExitSignaler()
server = None
try:
# logging
logger = Logger(title="%s port %s" % (prefix, port),
print_to_console=args.log,
save_for_dump=False)
server = TcpEchoServer(prefix, port, args.echo, args.timeout, logger,
args.connect_stall, args.close_on_connect,
args.close_on_data)
keep_running = True
while keep_running:
time.sleep(0.1)
if server.error is not None:
logger.log("%s Server stopped with error: %s" %
(prefix, server.error))
keep_running = False
retval = 1
if server.exit_status is not None:
logger.log("%s Server stopped with status: %s" %
(prefix, server.exit_status))
keep_running = False
if signaller.kill_now:
logger.log("%s Process killed with signal" % prefix)
keep_running = False
if keep_running and not server.is_running:
logger.log("%s Server stopped with no error or status" %
prefix)
keep_running = False
except Exception:
if logger is not None:
logger.log("%s Exception: %s" % (prefix, traceback.format_exc()))
retval = 1
if server is not None and server.sock is not None:
server.sock.close()
return retval