commit 14bb7b862174734fced8fc290d33ffb377d1df49 Author: cypherpunks <cypherpunks@torproject.org> Date: Fri Jul 1 13:32:49 2016 +0000 Move network tests to separate Python files Based on a patch from chobe. Closes ticket 9087. --- README | 5 + chutney | 2 +- lib/chutney/TorNet.py | 219 +++++--------------------------------- scripts/chutney_tests/__init__.py | 0 scripts/chutney_tests/verify.py | 203 +++++++++++++++++++++++++++++++++++ 5 files changed, 233 insertions(+), 196 deletions(-) diff --git a/README b/README index e0eb457..d11da52 100644 --- a/README +++ b/README @@ -69,3 +69,8 @@ The working files: You can override the directory "./net" with the CHUTNEY_DATA_DIR environment variable. + +Test scripts: + The test scripts are stored in the "scripts/chutney_tests" directory. These + Python files must define a "run_test(network)" function. Files starting with + an underscore ("_") are ignored. diff --git a/chutney b/chutney index 2076185..da8d97d 100755 --- a/chutney +++ b/chutney @@ -3,7 +3,7 @@ set -o errexit set -o nounset -export PYTHONPATH="$(dirname "${0}")/lib:${PYTHONPATH-}" +export PYTHONPATH="$(dirname "${0}")/lib:$(dirname "${0}")/scripts:${PYTHONPATH-}" binaries="python2 python" diff --git a/lib/chutney/TorNet.py b/lib/chutney/TorNet.py index a952944..87c5dab 100644 --- a/lib/chutney/TorNet.py +++ b/lib/chutney/TorNet.py @@ -19,6 +19,7 @@ import re import errno import time import shutil +import importlib import chutney.Templating import chutney.Traffic @@ -903,199 +904,6 @@ class Network(object): for c in controllers: c.check(listNonRunning=False) - def verify(self): - print("Verifying data transmission:") - status = self._verify_traffic() - print("Transmission: %s" % ("Success" if status else "Failure")) - if not status: - # TODO: allow the debug flag to be passed as an argument to - # src/test/test-network.sh and chutney - print("Set 'debug_flag = True' in Traffic.py to diagnose.") - return status - - def _verify_traffic(self): - """Verify (parts of) the network by sending traffic through it - and verify what is received.""" - LISTEN_PORT = 4747 # FIXME: Do better! Note the default exit policy. - # HSs must have a HiddenServiceDir with - # "HiddenServicePort <HS_PORT> <CHUTNEY_LISTEN_ADDRESS>:<LISTEN_PORT>" - HS_PORT = 5858 - # The amount of data to send between each source-sink pair, - # each time the source connects. - # We create a source-sink pair for each (bridge) client to an exit, - # and a source-sink pair for a (bridge) client to each hidden service - DATALEN = self._dfltEnv['data_bytes'] - # Print a dot each time a sink verifies this much data - DOTDATALEN = 5 * 1024 * 1024 # Octets. - TIMEOUT = 3 # Seconds. - # Calculate the amount of random data we should use - randomlen = self._calculate_randomlen(DATALEN) - reps = self._calculate_reps(DATALEN, randomlen) - # sanity check - if reps == 0: - DATALEN = 0 - # Get the random data - if randomlen > 0: - # print a dot after every DOTDATALEN data is verified, rounding up - dot_reps = self._calculate_reps(DOTDATALEN, randomlen) - # make sure we get at least one dot per transmission - dot_reps = min(reps, dot_reps) - with open('/dev/urandom', 'r') as randfp: - tmpdata = randfp.read(randomlen) - else: - dot_reps = 0 - tmpdata = {} - # now make the connections - bind_to = (DEFAULTS['ip'], LISTEN_PORT) - tt = chutney.Traffic.TrafficTester(bind_to, tmpdata, TIMEOUT, reps, - dot_reps) - client_list = filter(lambda n: - n._env['tag'] == 'c' or n._env['tag'] == 'bc', - self._nodes) - exit_list = filter(lambda n: - ('exit' in n._env.keys()) and n._env['exit'] == 1, - self._nodes) - hs_list = filter(lambda n: - n._env['tag'] == 'h', - self._nodes) - if len(client_list) == 0: - print(" Unable to verify network: no client nodes available") - return False - if len(exit_list) == 0 and len(hs_list) == 0: - print(" Unable to verify network: no exit/hs nodes available") - print(" Exit nodes must be declared 'relay=1, exit=1'") - print(" HS nodes must be declared 'tag=\"hs\"'") - return False - print("Connecting:") - # the number of tor nodes in paths which will send DATALEN data - # if a node is used in two paths, we count it twice - # this is a lower bound, as cannabilised circuits are one node longer - total_path_node_count = 0 - total_path_node_count += self._configure_exits(tt, bind_to, tmpdata, - reps, client_list, - exit_list, LISTEN_PORT) - total_path_node_count += self._configure_hs(tt, tmpdata, reps, - client_list, hs_list, - HS_PORT, LISTEN_PORT) - print("Transmitting Data:") - start_time = time.clock() - status = tt.run() - end_time = time.clock() - # if we fail, don't report the bandwidth - if not status: - return status - # otherwise, report bandwidth used, if sufficient data was transmitted - self._report_bandwidth(DATALEN, total_path_node_count, - start_time, end_time) - return status - - # In order to performance test a tor network, we need to transmit - # several hundred megabytes of data or more. Passing around this - # much data in Python has its own performance impacts, so we provide - # a smaller amount of random data instead, and repeat it to DATALEN - def _calculate_randomlen(self, datalen): - MAX_RANDOMLEN = 128 * 1024 # Octets. - if datalen > MAX_RANDOMLEN: - return MAX_RANDOMLEN - else: - return datalen - - def _calculate_reps(self, datalen, replen): - # sanity checks - if datalen == 0 or replen == 0: - return 0 - # effectively rounds datalen up to the nearest replen - if replen < datalen: - return (datalen + replen - 1) / replen - else: - return 1 - - # if there are any exits, each client / bridge client transmits - # via 4 nodes (including the client) to an arbitrary exit - # Each client binds directly to <CHUTNEY_LISTEN_ADDRESS>:LISTEN_PORT - # via an Exit relay - def _configure_exits(self, tt, bind_to, tmpdata, reps, client_list, - exit_list, LISTEN_PORT): - CLIENT_EXIT_PATH_NODES = 4 - connection_count = self._dfltEnv['connection_count'] - exit_path_node_count = 0 - if len(exit_list) > 0: - exit_path_node_count += (len(client_list) * - CLIENT_EXIT_PATH_NODES * - connection_count) - for op in client_list: - print(" Exit to %s:%d via client %s:%s" - % (DEFAULTS['ip'], LISTEN_PORT, - 'localhost', op._env['socksport'])) - for i in range(connection_count): - proxy = ('localhost', int(op._env['socksport'])) - tt.add(chutney.Traffic.Source(tt, bind_to, tmpdata, proxy, - reps)) - return exit_path_node_count - - # The HS redirects .onion connections made to hs_hostname:HS_PORT - # to the Traffic Tester's CHUTNEY_LISTEN_ADDRESS:LISTEN_PORT - # an arbitrary client / bridge client transmits via 8 nodes - # (including the client and hs) to each hidden service - # Instead of binding directly to LISTEN_PORT via an Exit relay, - # we bind to hs_hostname:HS_PORT via a hidden service connection - def _configure_hs(self, tt, tmpdata, reps, client_list, hs_list, HS_PORT, - LISTEN_PORT): - CLIENT_HS_PATH_NODES = 8 - connection_count = self._dfltEnv['connection_count'] - hs_path_node_count = (len(hs_list) * CLIENT_HS_PATH_NODES * - connection_count) - # Each client in hs_client_list connects to each hs - if self._dfltEnv['hs_multi_client']: - hs_client_list = client_list - hs_path_node_count *= len(client_list) - else: - # only use the first client in the list - hs_client_list = client_list[:1] - # Setup the connections from each client in hs_client_list to each hs - for hs in hs_list: - hs_bind_to = (hs._env['hs_hostname'], HS_PORT) - for client in hs_client_list: - print(" HS to %s:%d (%s:%d) via client %s:%s" - % (hs._env['hs_hostname'], HS_PORT, - DEFAULTS['ip'], LISTEN_PORT, - 'localhost', client._env['socksport'])) - for i in range(connection_count): - proxy = ('localhost', int(client._env['socksport'])) - tt.add(chutney.Traffic.Source(tt, hs_bind_to, tmpdata, - proxy, reps)) - return hs_path_node_count - - # calculate the single stream bandwidth and overall tor bandwidth - # the single stream bandwidth is the bandwidth of the - # slowest stream of all the simultaneously transmitted streams - # the overall bandwidth estimates the simultaneous bandwidth between - # all tor nodes over all simultaneous streams, assuming: - # * minimum path lengths (no cannibalized circuits) - # * unlimited network bandwidth (that is, localhost) - # * tor performance is CPU-limited - # This be used to estimate the bandwidth capacity of a CPU-bound - # tor relay running on this machine - def _report_bandwidth(self, data_length, total_path_node_count, - start_time, end_time): - # otherwise, if we sent at least 5 MB cumulative total, and - # it took us at least a second to send, report bandwidth - MIN_BWDATA = 5 * 1024 * 1024 # Octets. - MIN_ELAPSED_TIME = 1.0 # Seconds. - cumulative_data_sent = total_path_node_count * data_length - elapsed_time = end_time - start_time - if (cumulative_data_sent >= MIN_BWDATA and - elapsed_time >= MIN_ELAPSED_TIME): - # Report megabytes per second - BWDIVISOR = 1024*1024 - single_stream_bandwidth = (data_length / elapsed_time / BWDIVISOR) - overall_bandwidth = (cumulative_data_sent / elapsed_time / - BWDIVISOR) - print("Single Stream Bandwidth: %.2f MBytes/s" - % single_stream_bandwidth) - print("Overall tor Bandwidth: %.2f MBytes/s" - % overall_bandwidth) - def ConfigureNodes(nodelist): network = _THE_NETWORK @@ -1106,11 +914,22 @@ def ConfigureNodes(nodelist): network._dfltEnv['hasbridgeauth'] = True +def getTests(): + tests = [] + for x in os.listdir("scripts/chutney_tests/"): + if not x.startswith("_") and os.path.splitext(x)[1] == ".py": + tests.append(os.path.splitext(x)[0]) + return tests + + def usage(network): - return "\n".join(["Usage: chutney {command} {networkfile}", + return "\n".join(["Usage: chutney {command/test} {networkfile}", "Known commands are: %s" % ( " ".join(x for x in dir(network) - if not x.startswith("_")))]) + if not x.startswith("_"))), + "Known tests are: %s" % ( + " ".join(getTests())) + ]) def exit_on_error(err_msg): @@ -1128,6 +947,16 @@ def runConfigFile(verb, data): exec(data, _GLOBALS) network = _GLOBALS['_THE_NETWORK'] + # let's check if the verb is a valid test and run it + if verb in getTests(): + test_module = importlib.import_module("chutney_tests.{}".format(verb)) + try: + return test_module.run_test(network) + except AttributeError: + print("Test {!r} has no 'run_test(network)' function".format(verb)) + return False + + # tell the user we don't know what their verb meant if not hasattr(network, verb): print(usage(network)) print("Error: I don't know how to %s." % verb) diff --git a/scripts/chutney_tests/__init__.py b/scripts/chutney_tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/scripts/chutney_tests/verify.py b/scripts/chutney_tests/verify.py new file mode 100644 index 0000000..480cf97 --- /dev/null +++ b/scripts/chutney_tests/verify.py @@ -0,0 +1,203 @@ +import time +import chutney + + +def run_test(network): + print("Verifying data transmission:") + status = _verify_traffic(network) + print("Transmission: %s" % ("Success" if status else "Failure")) + if not status: + # TODO: allow the debug flag to be passed as an argument to + # src/test/test-network.sh and chutney + print("Set 'debug_flag = True' in Traffic.py to diagnose.") + return status + + +def _verify_traffic(network): + """Verify (parts of) the network by sending traffic through it + and verify what is received.""" + LISTEN_ADDR = network._dfltEnv['ip'] + LISTEN_PORT = 4747 # FIXME: Do better! Note the default exit policy. + # HSs must have a HiddenServiceDir with + # "HiddenServicePort <HS_PORT> <CHUTNEY_LISTEN_ADDRESS>:<LISTEN_PORT>" + HS_PORT = 5858 + # The amount of data to send between each source-sink pair, + # each time the source connects. + # We create a source-sink pair for each (bridge) client to an exit, + # and a source-sink pair for a (bridge) client to each hidden service + DATALEN = network._dfltEnv['data_bytes'] + # Print a dot each time a sink verifies this much data + DOTDATALEN = 5 * 1024 * 1024 # Octets. + TIMEOUT = 3 # Seconds. + # Calculate the amount of random data we should use + randomlen = _calculate_randomlen(DATALEN) + reps = _calculate_reps(DATALEN, randomlen) + connection_count = network._dfltEnv['connection_count'] + # sanity check + if reps == 0: + DATALEN = 0 + # Get the random data + if randomlen > 0: + # print a dot after every DOTDATALEN data is verified, rounding up + dot_reps = _calculate_reps(DOTDATALEN, randomlen) + # make sure we get at least one dot per transmission + dot_reps = min(reps, dot_reps) + with open('/dev/urandom', 'r') as randfp: + tmpdata = randfp.read(randomlen) + else: + dot_reps = 0 + tmpdata = {} + # now make the connections + bind_to = (LISTEN_ADDR, LISTEN_PORT) + tt = chutney.Traffic.TrafficTester(bind_to, tmpdata, TIMEOUT, reps, + dot_reps) + client_list = filter(lambda n: + n._env['tag'] == 'c' or n._env['tag'] == 'bc', + network._nodes) + exit_list = filter(lambda n: + ('exit' in n._env.keys()) and n._env['exit'] == 1, + network._nodes) + hs_list = filter(lambda n: + n._env['tag'] == 'h', + network._nodes) + if len(client_list) == 0: + print(" Unable to verify network: no client nodes available") + return False + if len(exit_list) == 0 and len(hs_list) == 0: + print(" Unable to verify network: no exit/hs nodes available") + print(" Exit nodes must be declared 'relay=1, exit=1'") + print(" HS nodes must be declared 'tag=\"hs\"'") + return False + print("Connecting:") + # the number of tor nodes in paths which will send DATALEN data + # if a node is used in two paths, we count it twice + # this is a lower bound, as cannabilised circuits are one node longer + total_path_node_count = 0 + total_path_node_count += _configure_exits(tt, bind_to, tmpdata, reps, + client_list, exit_list, + LISTEN_ADDR, LISTEN_PORT, + connection_count) + total_path_node_count += _configure_hs(tt, tmpdata, reps, client_list, + hs_list, HS_PORT, LISTEN_ADDR, + LISTEN_PORT, connection_count, + network._dfltEnv['hs_multi_client']) + print("Transmitting Data:") + start_time = time.clock() + status = tt.run() + end_time = time.clock() + # if we fail, don't report the bandwidth + if not status: + return status + # otherwise, report bandwidth used, if sufficient data was transmitted + _report_bandwidth(DATALEN, total_path_node_count, start_time, end_time) + return status + + +# In order to performance test a tor network, we need to transmit +# several hundred megabytes of data or more. Passing around this +# much data in Python has its own performance impacts, so we provide +# a smaller amount of random data instead, and repeat it to DATALEN +def _calculate_randomlen(datalen): + MAX_RANDOMLEN = 128 * 1024 # Octets. + if datalen > MAX_RANDOMLEN: + return MAX_RANDOMLEN + else: + return datalen + + +def _calculate_reps(datalen, replen): + # sanity checks + if datalen == 0 or replen == 0: + return 0 + # effectively rounds datalen up to the nearest replen + if replen < datalen: + return (datalen + replen - 1) / replen + else: + return 1 + + +# if there are any exits, each client / bridge client transmits +# via 4 nodes (including the client) to an arbitrary exit +# Each client binds directly to <CHUTNEY_LISTEN_ADDRESS>:LISTEN_PORT +# via an Exit relay +def _configure_exits(tt, bind_to, tmpdata, reps, client_list, exit_list, + LISTEN_ADDR, LISTEN_PORT, connection_count): + CLIENT_EXIT_PATH_NODES = 4 + exit_path_node_count = 0 + if len(exit_list) > 0: + exit_path_node_count += (len(client_list) * + CLIENT_EXIT_PATH_NODES * + connection_count) + for op in client_list: + print(" Exit to %s:%d via client %s:%s" + % (LISTEN_ADDR, LISTEN_PORT, + 'localhost', op._env['socksport'])) + for _ in range(connection_count): + proxy = ('localhost', int(op._env['socksport'])) + tt.add(chutney.Traffic.Source(tt, bind_to, tmpdata, proxy, + reps)) + return exit_path_node_count + + +# The HS redirects .onion connections made to hs_hostname:HS_PORT +# to the Traffic Tester's CHUTNEY_LISTEN_ADDRESS:LISTEN_PORT +# an arbitrary client / bridge client transmits via 8 nodes +# (including the client and hs) to each hidden service +# Instead of binding directly to LISTEN_PORT via an Exit relay, +# we bind to hs_hostname:HS_PORT via a hidden service connection +def _configure_hs(tt, tmpdata, reps, client_list, hs_list, HS_PORT, + LISTEN_ADDR, LISTEN_PORT, connection_count, hs_multi_client): + CLIENT_HS_PATH_NODES = 8 + hs_path_node_count = (len(hs_list) * CLIENT_HS_PATH_NODES * + connection_count) + # Each client in hs_client_list connects to each hs + if hs_multi_client: + hs_client_list = client_list + hs_path_node_count *= len(client_list) + else: + # only use the first client in the list + hs_client_list = client_list[:1] + # Setup the connections from each client in hs_client_list to each hs + for hs in hs_list: + hs_bind_to = (hs._env['hs_hostname'], HS_PORT) + for client in hs_client_list: + print(" HS to %s:%d (%s:%d) via client %s:%s" + % (hs._env['hs_hostname'], HS_PORT, + LISTEN_ADDR, LISTEN_PORT, + 'localhost', client._env['socksport'])) + for _ in range(connection_count): + proxy = ('localhost', int(client._env['socksport'])) + tt.add(chutney.Traffic.Source(tt, hs_bind_to, tmpdata, + proxy, reps)) + return hs_path_node_count + + +# calculate the single stream bandwidth and overall tor bandwidth +# the single stream bandwidth is the bandwidth of the +# slowest stream of all the simultaneously transmitted streams +# the overall bandwidth estimates the simultaneous bandwidth between +# all tor nodes over all simultaneous streams, assuming: +# * minimum path lengths (no cannibalized circuits) +# * unlimited network bandwidth (that is, localhost) +# * tor performance is CPU-limited +# This be used to estimate the bandwidth capacity of a CPU-bound +# tor relay running on this machine +def _report_bandwidth(data_length, total_path_node_count, start_time, + end_time): + # otherwise, if we sent at least 5 MB cumulative total, and + # it took us at least a second to send, report bandwidth + MIN_BWDATA = 5 * 1024 * 1024 # Octets. + MIN_ELAPSED_TIME = 1.0 # Seconds. + cumulative_data_sent = total_path_node_count * data_length + elapsed_time = end_time - start_time + if (cumulative_data_sent >= MIN_BWDATA and + elapsed_time >= MIN_ELAPSED_TIME): + # Report megabytes per second + BWDIVISOR = 1024*1024 + single_stream_bandwidth = (data_length / elapsed_time / BWDIVISOR) + overall_bandwidth = (cumulative_data_sent / elapsed_time / + BWDIVISOR) + print("Single Stream Bandwidth: %.2f MBytes/s" + % single_stream_bandwidth) + print("Overall tor Bandwidth: %.2f MBytes/s" + % overall_bandwidth)