Inside Bitcoin

501            "Should only call stop_node() on a running node after wait_for_rpc_connection() succeeded. "
502            f"Did you forget to call the latter after start()? Not connected to process: {self.process.pid}")
503        self.log.debug("Stopping node")
504        # Do not use wait argument when testing older nodes, e.g. in wallet_backwards_compatibility.py
505        if self.version_is_at_least(180000):
506            self.stop(wait=wait)
507        else:
508            self.stop()
509
510        del self.p2ps[:]
511
512        assert (not expected_stderr) or wait_until_stopped  # Must wait to check stderr
513        if wait_until_stopped:
514            self.wait_until_stopped(expected_stderr=expected_stderr)
515
516    def is_node_stopped(self, *, expected_stderr="", expected_ret_code=0):
517        """Checks whether the node has stopped.
518
519        Returns True if the node has stopped. False otherwise.
520
521        If the process has exited, asserts that the exit code matches
522        `expected_ret_code` (which may be a single value or an iterable of values),
523        and that stderr matches `expected_stderr` exactly or, if a regex pattern is
524        provided, contains the pattern.
525
526        This method is responsible for freeing resources (self.process)."""
527        if not self.running:
528            return True
529        return_code = self.process.poll()
530        if return_code is None:
531            return False
532
533        # process has stopped. Assert that it didn't return an error code.
534        if not isinstance(expected_ret_code, Iterable):
535            expected_ret_code = (expected_ret_code,)
536        assert return_code in expected_ret_code, self._node_msg(
537            f"Node returned unexpected exit code ({return_code}) vs ({expected_ret_code}) when stopping")
538        # Check that stderr is as expected
539        self.stderr.seek(0)
540        stderr = self.stderr.read().decode('utf-8').strip()
541        if isinstance(expected_stderr, re.Pattern):
542            if not expected_stderr.search(stderr):
543                raise AssertionError(f"Unexpected stderr {stderr!r} does not contain {expected_stderr.pattern!r}")
544        elif stderr != expected_stderr:
545            raise AssertionError("Unexpected stderr {} != {}".format(stderr, expected_stderr))
546
547        self.stdout.close()
548        self.stderr.close()
549
550        self.running = False
551        self.process = None
552        self.rpc_connected = False
553        self._rpc = None
554        self.log.debug("Node stopped")
555        return True
556
557    def wait_until_stopped(self, *, timeout=BITCOIND_PROC_WAIT_TIMEOUT, expect_error=False, **kwargs):
558        if "expected_ret_code" not in kwargs:
559            kwargs["expected_ret_code"] = 1 if expect_error else 0  # Whether node shutdown return EXIT_FAILURE or EXIT_SUCCESS
560        self.wait_until(lambda: self.is_node_stopped(**kwargs), timeout=timeout)
561
562    def kill_process(self):
563        self.process.kill()
564        self.wait_until_stopped(expected_ret_code=1 if platform.system() == "Windows" else -9)
565        assert self.is_node_stopped()
566
567    def replace_in_config(self, replacements):
568        """
569        Perform replacements in the configuration file.
570        The substitutions are passed as a list of search-replace-tuples, e.g.
571            [("old", "new"), ("foo", "bar"), ...]
572        """
573        with open(self.bitcoinconf, 'r') as conf:
574            conf_data = conf.read()
575        for replacement in replacements:
576            assert_equal(len(replacement), 2)
577            old, new = replacement[0], replacement[1]
578            conf_data = conf_data.replace(old, new)
579        with open(self.bitcoinconf, 'w') as conf:
580            conf.write(conf_data)
581
582    @property
583    def chain_path(self) -> Path:
584        return self.datadir_path / self.chain
585
586    @property
587    def debug_log_path(self) -> Path:
588        return self.chain_path / 'debug.log'
589
590    @property
591    def blocks_path(self) -> Path:
592        return self.chain_path / "blocks"
593
594    @property
595    def blocks_key_path(self) -> Path:
596        return self.blocks_path / "xor.dat"
597
598    def read_xor_key(self) -> bytes:
599        with open(self.blocks_key_path, "rb") as xor_f:
600            return xor_f.read(NUM_XOR_BYTES)
601
602    @property
603    def wallets_path(self) -> Path:
604        return self.chain_path / "wallets"
605
606    def debug_log_size(self, **kwargs) -> int:
607        with open(self.debug_log_path, **kwargs) as dl:
608            dl.seek(0, 2)
609            return dl.tell()
610
611    @contextlib.contextmanager
612    def assert_debug_log(self, expected_msgs, unexpected_msgs=None, *, timeout=0):
613        if unexpected_msgs is None:
614            unexpected_msgs = []
615        assert_equal(type(expected_msgs), list)
616        assert_equal(type(unexpected_msgs), list)
617        remaining_expected = list(expected_msgs)
618
619        time_end = time.time() + timeout * self.timeout_factor
620        prev_size = self.debug_log_size(encoding="utf-8")  # Must use same encoding that is used to read() below
621
622        def join_log(log):
623            return " - " + "\n - ".join(log.splitlines())
624
625        yield
626
627        while True:
628            with open(self.debug_log_path, encoding="utf-8", errors="replace") as dl:
629                dl.seek(prev_size)
630                log = dl.read()
631            for unexpected_msg in unexpected_msgs:
632                if unexpected_msg in log:
633                    self._raise_assertion_error(f'Unexpected message "{unexpected_msg}" '
634                                                f'found in log:\n\n{join_log(log)}\n\n')
635            while remaining_expected and remaining_expected[-1] in log:
636                remaining_expected.pop()
637            if not remaining_expected:
638                return
639            if time.time() >= time_end:
640                break
641            time.sleep(0.05)
642        remaining_expected = [e for e in remaining_expected if e not in log]
643        self._raise_assertion_error(f'Expected message(s) {remaining_expected!s} '
644                                    f'not found in log:\n\n{join_log(log)}\n\n')
645
646    @contextlib.contextmanager
647    def busy_wait_for_debug_log(self, expected_msgs, timeout=60):
648        """
649        Block until we see a particular debug log message fragment or until we exceed the timeout.
650        """
651        time_end = time.time() + timeout * self.timeout_factor
652        prev_size = self.debug_log_size(mode="rb")  # Must use same mode that is used to read() below
653        remaining_expected = list(expected_msgs)
654
655        yield
656
657        while True:
658            with open(self.debug_log_path, "rb") as dl:
659                dl.seek(prev_size)
660                log = dl.read()
661
662            while remaining_expected and remaining_expected[-1] in log:
663                remaining_expected.pop()
664            if not remaining_expected:
665                return
666
667            if time.time() >= time_end:
668                print_log = " - " + "\n - ".join(log.decode("utf8", errors="replace").splitlines())
669                break
670
671            # No sleep here because we want to detect the message fragment as fast as
672            # possible.
673
674        remaining_expected = [e for e in remaining_expected if e not in log]
675        self._raise_assertion_error(f'Expected message(s) {remaining_expected!s} '
676                                    f'not found in log:\n\n{print_log}\n\n')
677
678    @contextlib.contextmanager
679    def wait_for_new_peer(self, timeout=5):
680        """
681        Wait until the node is connected to at least one new peer. We detect this
682        by watching for an increased highest peer id, using the `getpeerinfo` RPC call.
683        Note that the simpler approach of only accounting for the number of peers
684        suffers from race conditions, as disconnects from unrelated previous peers
685        could happen anytime in-between.
686        """
687        def get_highest_peer_id():
688            peer_info = self.getpeerinfo()
689            return peer_info[-1]["id"] if peer_info else -1
690
691        initial_peer_id = get_highest_peer_id()
692        yield
693        self.wait_until(lambda: get_highest_peer_id() > initial_peer_id, timeout=timeout)
694
695    def assert_start_raises_init_error(self, extra_args=None, expected_msg=None, match=ErrorMatch.FULL_TEXT, *args, **kwargs):
696        """Attempt to start the node and expect it to raise an error.
697
698        extra_args: extra arguments to pass through to bitcoind
699        expected_msg: regex that stderr should match when bitcoind fails
700
701        Will raise if bitcoind starts without an error.
702        Will raise if an expected_msg is provided and it does not match bitcoind's stdout."""
703        assert not self.running
704        with tempfile.NamedTemporaryFile(dir=self.stderr_dir, delete=False) as log_stderr, \
705             tempfile.NamedTemporaryFile(dir=self.stdout_dir, delete=False) as log_stdout:
706            assert_msg = None
707            try:
708                self.start(extra_args, stdout=log_stdout, stderr=log_stderr, *args, **kwargs)
709                ret = self.process.wait(timeout=self.rpc_timeout)
710                self.log.debug(self._node_msg(f'bitcoind exited with status {ret} during initialization'))
711                assert_not_equal(ret, 0) # Exit code must indicate failure
712                self.running = False
713                self.process = None
714                # Check stderr for expected message
715                if expected_msg is not None:
716                    log_stderr.seek(0)
717                    stderr = log_stderr.read().decode('utf-8').strip()
718                    if match == ErrorMatch.PARTIAL_REGEX:
719                        if re.search(expected_msg, stderr, flags=re.MULTILINE) is None:
720                            self._raise_assertion_error(
721                                'Expected message "{}" does not partially match stderr:\n"{}"'.format(expected_msg, stderr))
722                    elif match == ErrorMatch.FULL_REGEX:
723                        if re.fullmatch(expected_msg, stderr) is None:
724                            self._raise_assertion_error(
725                                'Expected message "{}" does not fully match stderr:\n"{}"'.format(expected_msg, stderr))
726                    elif match == ErrorMatch.FULL_TEXT:
727                        if expected_msg != stderr:
728                            self._raise_assertion_error(
729                                'Expected message "{}" does not fully match stderr:\n"{}"'.format(expected_msg, stderr))
730            except subprocess.TimeoutExpired as e:
731                self.process.kill()
732                self.running = False
733                self.process = None
734                assert_msg = f'bitcoind should have exited within {self.rpc_timeout}s '
735                if expected_msg is None:
736                    assert_msg += "with an error"
737                else:
738                    assert_msg += "with expected error " + expected_msg
739                assert_msg += f" (cmd: {e.cmd})"
740
741            # Raise assertion outside of except-block above in order for it not to be treated as a knock-on exception.
742            if assert_msg:
743                self._raise_assertion_error(assert_msg)
744
745    def add_p2p_connection(self, p2p_conn, *, wait_for_verack=True, send_version=True, supports_v2_p2p=None, wait_for_v2_handshake=True, expect_success=True, **kwargs):
746        """Add an inbound p2p connection to the node.
747
748        This method adds the p2p connection to the self.p2ps list and also
749        returns the connection to the caller.
750