Python p2p testing framework

mininode.py provides a framework for connecting to a bitcoin node over the p2p
network. NodeConn is the main object that manages connectivity to a node and
provides callbacks; the interface for those callbacks is defined by NodeConnCB.
Defined also are all data structures from bitcoin core that pass on the network
(CBlock, CTransaction, etc), along with de-/serialization functions.

maxblocksinflight.py is an example test using this framework that tests whether
a node is limiting the maximum number of in-flight block requests.

This also adds support to util.py for specifying the binary to use when
starting nodes (for tests that compare the behavior of different bitcoind
versions), and adds maxblocksinflight.py to the pull tester.

qa/pull-tester/rpc-tests.sh

@@ -30,6 +30,7 @@ testScripts=(
     'proxy_test.py'
     'merkle_blocks.py'
 #    'forknotify.py'
+    'maxblocksinflight.py'
 );
 if [ "x${ENABLE_BITCOIND}${ENABLE_UTILS}${ENABLE_WALLET}" = "x111" ]; then
     for (( i = 0; i < ${#testScripts[@]}; i++ ))

qa/rpc-tests/maxblocksinflight.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python2
+#
+# Distributed under the MIT/X11 software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+#
+
+from mininode import *
+from test_framework import BitcoinTestFramework
+from util import *
+import logging
+
+'''
+In this test we connect to one node over p2p, send it numerous inv's, and
+compare the resulting number of getdata requests to a max allowed value.  We
+test for exceeding 128 blocks in flight, which was the limit an 0.9 client will
+reach. [0.10 clients shouldn't request more than 16 from a single peer.]
+'''
+MAX_REQUESTS = 128
+
+class TestManager(NodeConnCB):
+    # set up NodeConnCB callbacks, overriding base class
+    def on_getdata(self, conn, message):
+        self.log.debug("got getdata %s" % repr(message))
+        # Log the requests
+        for inv in message.inv:
+            if inv.hash not in self.blockReqCounts:
+                self.blockReqCounts[inv.hash] = 0
+            self.blockReqCounts[inv.hash] += 1
+
+    def on_close(self, conn):
+        if not self.disconnectOkay:
+            raise EarlyDisconnectError(0)
+
+    def __init__(self):
+        NodeConnCB.__init__(self)
+        self.log = logging.getLogger("BlockRelayTest")
+        self.create_callback_map()
+
+    def add_new_connection(self, connection):
+        self.connection = connection
+        self.blockReqCounts = {}
+        self.disconnectOkay = False
+
+    def run(self):
+        try:
+            fail = False
+            self.connection.rpc.generate(1) # Leave IBD
+
+            numBlocksToGenerate = [ 8, 16, 128, 1024 ]
+            for count in range(len(numBlocksToGenerate)):
+                current_invs = []
+                for i in range(numBlocksToGenerate[count]):
+                    current_invs.append(CInv(2, random.randrange(0, 1<<256)))
+                    if len(current_invs) >= 50000:
+                        self.connection.send_message(msg_inv(current_invs))
+                        current_invs = []
+                if len(current_invs) > 0:
+                    self.connection.send_message(msg_inv(current_invs))
+                
+                # Wait and see how many blocks were requested
+                time.sleep(2)
+
+                total_requests = 0
+                for key in self.blockReqCounts:
+                    total_requests += self.blockReqCounts[key]
+                    if self.blockReqCounts[key] > 1:
+                        raise AssertionError("Error, test failed: block %064x requested more than once" % key)
+                if total_requests > MAX_REQUESTS:
+                    raise AssertionError("Error, too many blocks (%d) requested" % total_requests)
+                print "Round %d: success (total requests: %d)" % (count, total_requests)
+        except AssertionError as e:
+            print "TEST FAILED: ", e.args
+
+        self.disconnectOkay = True
+        self.connection.disconnect_node()
+
+        
+class MaxBlocksInFlightTest(BitcoinTestFramework):
+    def add_options(self, parser):
+        parser.add_option("--testbinary", dest="testbinary", default="bitcoind",
+                          help="Binary to test max block requests behavior")
+
+    def setup_chain(self):
+        print "Initializing test directory "+self.options.tmpdir
+        initialize_chain_clean(self.options.tmpdir, 1)
+
+    def setup_network(self):
+        self.nodes = start_nodes(1, self.options.tmpdir, 
+                                 extra_args=[['-debug', '-whitelist=127.0.0.1']],
+                                 binary=[self.options.testbinary])
+
+    def run_test(self):
+        test = TestManager()
+        test.add_new_connection(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], test))
+        NetworkThread().start()  # Start up network handling in another thread
+        test.run()
+
+if __name__ == '__main__':
+    MaxBlocksInFlightTest().main()

qa/rpc-tests/util.py

@@ -158,12 +158,14 @@ def _rpchost_to_args(rpchost):
         rv += ['-rpcport=' + rpcport]
     return rv
 
-def start_node(i, dirname, extra_args=None, rpchost=None, timewait=None):
+def start_node(i, dirname, extra_args=None, rpchost=None, timewait=None, binary=None):
     """
     Start a bitcoind and return RPC connection to it
     """
     datadir = os.path.join(dirname, "node"+str(i))
-    args = [ os.getenv("BITCOIND", "bitcoind"), "-datadir="+datadir, "-keypool=1", "-discover=0", "-rest" ]
+    if binary is None:
+        binary = os.getenv("BITCOIND", "bitcoind")
+    args = [ binary, "-datadir="+datadir, "-keypool=1", "-discover=0", "-rest" ]
     if extra_args is not None: args.extend(extra_args)
     bitcoind_processes[i] = subprocess.Popen(args)
     devnull = open("/dev/null", "w+")
@@ -179,12 +181,13 @@ def start_node(i, dirname, extra_args=None, rpchost=None, timewait=None):
     proxy.url = url # store URL on proxy for info
     return proxy
 
-def start_nodes(num_nodes, dirname, extra_args=None, rpchost=None):
+def start_nodes(num_nodes, dirname, extra_args=None, rpchost=None, binary=None):
     """
     Start multiple bitcoinds, return RPC connections to them
     """
     if extra_args is None: extra_args = [ None for i in range(num_nodes) ]
-    return [ start_node(i, dirname, extra_args[i], rpchost) for i in range(num_nodes) ]
+    if binary is None: binary = [ None for i in range(num_nodes) ]
+    return [ start_node(i, dirname, extra_args[i], rpchost, binary=binary[i]) for i in range(num_nodes) ]
 
 def log_filename(dirname, n_node, logname):
     return os.path.join(dirname, "node"+str(n_node), "regtest", logname)