Inside Bitcoin

251        seed = self.options.randomseed
252
253        if seed is None:
254            seed = random.randrange(sys.maxsize)
255        else:
256            self.log.info("User supplied random seed {}".format(seed))
257
258        random.seed(seed)
259        self.log.info("PRNG seed is: {}".format(seed))
260
261        self.log.debug('Setting up network thread')
262        self.network_thread = NetworkThread()
263        self.network_thread.start()
264        self.wait_until(lambda: self.network_thread.network_event_loop is not None and self.network_thread.network_event_loop.is_running())
265
266        if self.options.usecli:
267            if not self.supports_cli:
268                raise SkipTest("--usecli specified but test does not support using CLI")
269            self.skip_if_no_cli()
270        self.skip_test_if_missing_module()
271        self.setup_chain()
272        self.setup_network()
273
274        self.success = TestStatus.PASSED
275
276    def shutdown(self):
277        """Call this method to shut down the test framework object."""
278
279        if self.success == TestStatus.FAILED and self.options.pdbonfailure:
280            print("Testcase failed. Attaching python debugger. Enter ? for help")
281            pdb.set_trace()
282
283        self.log.debug('Closing down network thread')
284        self.network_thread.close(timeout=self.options.timeout_factor * 10)
285        if self.success == TestStatus.FAILED:
286            self.log.info("Not stopping nodes as test failed. The dangling processes will be cleaned up later.")
287        else:
288            self.log.info("Stopping nodes")
289            if self.nodes:
290                self.stop_nodes()
291
292        should_clean_up = (
293            not self.options.nocleanup and
294            self.success != TestStatus.FAILED
295        )
296        if should_clean_up:
297            self.log.info("Cleaning up {} on exit".format(self.options.tmpdir))
298            cleanup_tree_on_exit = True
299        else:
300            self.log.warning("Not cleaning up dir {}".format(self.options.tmpdir))
301            cleanup_tree_on_exit = False
302
303        if self.success == TestStatus.PASSED:
304            self.log.info("Tests successful")
305            exit_code = TEST_EXIT_PASSED
306        elif self.success == TestStatus.SKIPPED:
307            self.log.info("Test skipped")
308            exit_code = TEST_EXIT_SKIPPED
309        else:
310            self.log.error("Test failed. Test logging available at %s/test_framework.log", self.options.tmpdir)
311            self.log.error("")
312            self.log.error("Hint: Call {} '{}' to consolidate all logs".format(os.path.normpath(os.path.dirname(os.path.realpath(__file__)) + "/../combine_logs.py"), self.options.tmpdir))
313            self.log.error("")
314            self.log.error("If this failure happened unexpectedly or intermittently, please file a bug and provide a link or upload of the combined log.")
315            self.log.error(self.config['environment']['CLIENT_BUGREPORT'])
316            self.log.error("")
317            exit_code = TEST_EXIT_FAILED
318        # Logging.shutdown will not remove stream- and filehandlers, so we must
319        # do it explicitly. Handlers are removed so the next test run can apply
320        # different log handler settings.
321        # See: https://docs.python.org/3/library/logging.html#logging.shutdown
322        for h in list(self.log.handlers):
323            h.flush()
324            h.close()
325            self.log.removeHandler(h)
326        rpc_logger = logging.getLogger("BitcoinRPC")
327        for h in list(rpc_logger.handlers):
328            h.flush()
329            rpc_logger.removeHandler(h)
330        if cleanup_tree_on_exit:
331            self.cleanup_folder(self.options.tmpdir)
332
333        self.nodes.clear()
334        return exit_code
335
336    # Methods to override in subclass test scripts.
337    def set_test_params(self):
338        """Tests must override this method to change default values for number of nodes, topology, etc"""
339        raise NotImplementedError
340
341    def add_options(self, parser):
342        """Override this method to add command-line options to the test"""
343        pass
344
345    def skip_test_if_missing_module(self):
346        """Override this method to skip a test if a module is not compiled"""
347        pass
348
349    def setup_chain(self):
350        """Override this method to customize blockchain setup"""
351        self.log.info("Initializing test directory " + self.options.tmpdir)
352        if self.setup_clean_chain:
353            self._initialize_chain_clean()
354        else:
355            self._initialize_chain()
356
357    def setup_network(self):
358        """Override this method to customize test network topology"""
359        self.setup_nodes()
360
361        # Connect the nodes as a "chain".  This allows us
362        # to split the network between nodes 1 and 2 to get
363        # two halves that can work on competing chains.
364        #
365        # Topology looks like this:
366        # node0 <-- node1 <-- node2 <-- node3
367        #
368        # If all nodes are in IBD (clean chain from genesis), node0 is assumed to be the source of blocks (miner). To
369        # ensure block propagation, all nodes will establish outgoing connections toward node0.
370        # See fPreferredDownload in net_processing.
371        #
372        # If further outbound connections are needed, they can be added at the beginning of the test with e.g.
373        # self.connect_nodes(1, 2)
374        for i in range(self.num_nodes - 1):
375            self.connect_nodes(i + 1, i)
376        self.sync_all()
377
378    def setup_nodes(self):
379        """Override this method to customize test node setup"""
380        self.add_nodes(self.num_nodes, self.extra_args)
381        self.start_nodes()
382        if self.uses_wallet:
383            self.import_deterministic_coinbase_privkeys()
384        if not self.setup_clean_chain:
385            for n in self.nodes:
386                assert_equal(n.getblockchaininfo()["blocks"], 199)
387            # To ensure that all nodes are out of IBD, the most recent block
388            # must have a timestamp not too old (see IsInitialBlockDownload()).
389            self.log.debug('Generate a block with current time')
390            block_hash = self.generate(self.nodes[0], 1, sync_fun=self.no_op)[0]
391            block = self.nodes[0].getblock(blockhash=block_hash, verbosity=0)
392            for n in self.nodes:
393                n.submitblock(block)
394                chain_info = n.getblockchaininfo()
395                assert_equal(chain_info["blocks"], 200)
396                assert_equal(chain_info["initialblockdownload"], False)
397
398    def import_deterministic_coinbase_privkeys(self):
399        for i in range(self.num_nodes):
400            self.init_wallet(node=i)
401
402    def init_wallet(self, *, node):
403        wallet_name = self.default_wallet_name if self.wallet_names is None else self.wallet_names[node] if node < len(self.wallet_names) else False
404        if wallet_name is not False:
405            n = self.nodes[node]
406            if wallet_name is not None:
407                n.createwallet(wallet_name=wallet_name, load_on_startup=True)
408            wallet_importprivkey(n.get_wallet_rpc(wallet_name), n.get_deterministic_priv_key().key, 0, label="coinbase")
409
410    def run_test(self):
411        """Tests must override this method to define test logic"""
412        raise NotImplementedError
413
414    # Public helper methods. These can be accessed by the subclass test scripts.
415
416    def add_nodes(self, num_nodes: int, extra_args=None, *, rpchost=None, versions=None):
417        """Instantiate TestNode objects.
418
419        Should only be called once after the nodes have been specified in
420        set_test_params()."""
421        def bin_dir_from_version(version):
422            if not version:
423                return None
424            if version > 219999:
425                # Starting at client version 220000 the first two digits represent
426                # the major version, e.g. v22.0 instead of v0.22.0.
427                version *= 100
428            return os.path.join(
429                self.options.previous_releases_path,
430                re.sub(
431                    r'\.0$' if version <= 219999 else r'(\.0){1,2}$',
432                    '', # Remove trailing dot for point releases, after 22.0 also remove double trailing dot.
433                    'v{}.{}.{}.{}'.format(
434                        (version % 100000000) // 1000000,
435                        (version % 1000000) // 10000,
436                        (version % 10000) // 100,
437                        (version % 100) // 1,
438                    ),
439                ),
440                'bin',
441            )
442
443        if self.bind_to_localhost_only:
444            extra_confs = [["bind=127.0.0.1"]] * num_nodes
445        else:
446            extra_confs = [[]] * num_nodes
447        if extra_args is None:
448            extra_args = [[]] * num_nodes
449        # Whitelist peers to speed up tx relay / mempool sync. Don't use it if testing tx relay or timing.
450        if self.noban_tx_relay:
451            for i in range(len(extra_args)):
452                extra_args[i] = extra_args[i] + ["-whitelist=noban,in,[email protected]"]
453        if versions is None:
454            versions = [None] * num_nodes
455        bin_dirs = []
456        for v in versions:
457            bin_dir = bin_dir_from_version(v)
458            bin_dirs.append(bin_dir)
459
460        extra_init = [{}] * num_nodes if self.extra_init is None else self.extra_init # type: ignore[var-annotated]
461        assert_equal(len(extra_init), num_nodes)
462        assert_equal(len(extra_confs), num_nodes)
463        assert_equal(len(extra_args), num_nodes)
464        assert_equal(len(versions), num_nodes)
465        assert_equal(len(bin_dirs), num_nodes)
466        for i in range(num_nodes):
467            args = list(extra_args[i])
468            init = dict(
469                chain=self.chain,
470                rpchost=rpchost,
471                timewait=self.rpc_timeout,
472                timeout_factor=self.options.timeout_factor,
473                binaries=self.get_binaries(bin_dirs[i]),
474                version=versions[i],
475                coverage_dir=self.options.coveragedir,
476                cwd=self.options.tmpdir,
477                extra_conf=extra_confs[i],
478                extra_args=args,
479                use_cli=self.options.usecli,
480                v2transport=self.options.v2transport,
481                uses_wallet=self.uses_wallet,
482            )
483            init.update(extra_init[i])
484            test_node_i = TestNode(
485                i,
486                get_datadir_path(self.options.tmpdir, i),
487                **init)
488            self.nodes.append(test_node_i)
489            if not test_node_i.version_is_at_least(170000):
490                # adjust conf for pre 17
491                test_node_i.replace_in_config([('[regtest]', '')])
492
493    def start_node(self, i, *args, **kwargs):
494        """Start a bitcoind"""
495
496        node = self.nodes[i]
497
498        node.start(*args, **kwargs)
499        node.wait_for_rpc_connection()
500