Inside Bitcoin

251
252            for dir in dirs:
253                self.cleanup_folder(node.chain_path / dir)
254                shutil.move(node.chain_path / f"{dir}_bak", node.chain_path / dir)
255
256    def init_pid_test(self):
257        BITCOIN_PID_FILENAME_CUSTOM = "my_fancy_bitcoin_pid_file.foobar"
258
259        self.log.info("Test specifying custom pid file via -pid command line option")
260        custom_pidfile_relative = BITCOIN_PID_FILENAME_CUSTOM
261        self.log.info(f"-> path relative to datadir ({custom_pidfile_relative})")
262        self.restart_node(0, [f"-pid={custom_pidfile_relative}"])
263        datadir = self.nodes[0].chain_path
264        assert not (datadir / BITCOIN_PID_FILENAME_DEFAULT).exists()
265        assert (datadir / custom_pidfile_relative).exists()
266        self.stop_node(0)
267        assert not (datadir / custom_pidfile_relative).exists()
268
269        custom_pidfile_absolute = Path(self.options.tmpdir) / BITCOIN_PID_FILENAME_CUSTOM
270        self.log.info(f"-> absolute path ({custom_pidfile_absolute})")
271        self.restart_node(0, [f"-pid={custom_pidfile_absolute}"])
272        assert not (datadir / BITCOIN_PID_FILENAME_DEFAULT).exists()
273        assert custom_pidfile_absolute.exists()
274        self.stop_node(0)
275        assert not custom_pidfile_absolute.exists()
276
277    def break_wait_test(self):
278        """Test what happens when a break signal is sent during a
279        waitforblockheight RPC call with a long timeout. Ctrl-Break is sent on
280        Windows and SIGTERM is sent on other platforms, to trigger the same node
281        shutdown sequence that would happen if Ctrl-C were pressed in a
282        terminal. (This can be different than the node shutdown sequence that
283        happens when the stop RPC is sent.)
284
285        The waitforblockheight call should be interrupted and return right away,
286        and not time out."""
287
288        self.log.info("Testing waitforblockheight RPC call followed by break signal")
289        node = self.nodes[0]
290
291        self.start_node(node.index, **get_process_group_kwargs())
292
293        current_height = node.getblock(node.getbestblockhash())['height']
294
295        with ThreadPoolExecutor(max_workers=1) as ex:
296            # Call waitforblockheight with wait timeout longer than RPC timeout,
297            # so it is possible to distinguish whether it times out or returns
298            # early. If it times out it will throw an exception, and if it
299            # returns early it will return the current block height.
300            self.log.debug(f"Calling waitforblockheight with {self.rpc_timeout} sec RPC timeout")
301            fut = ex.submit(node.waitforblockheight, height=current_height+1, timeout=self.rpc_timeout*1000*2)
302
303            self.wait_until(lambda: any(c["method"] == "waitforblockheight" for c in node.cli.getrpcinfo()["active_commands"]))
304
305            self.log.debug(f"Sending break signal to pid {node.process.pid}")
306            if platform.system() == 'Windows':
307                # Note: CTRL_C_EVENT should not be sent here because unlike
308                # CTRL_BREAK_EVENT it can not be targeted at a specific process
309                # group and may behave unpredictably.
310                node.process.send_signal(signal.CTRL_BREAK_EVENT)
311            else:
312                # Note: signal.SIGINT would work here as well
313                node.process.send_signal(signal.SIGTERM)
314            node.process.wait()
315
316            result = fut.result()
317            self.log.debug(f"waitforblockheight returned {result!r}")
318            assert_equal(result["height"], current_height)
319            node.wait_until_stopped()
320
321    def init_empty_test(self):
322        self.log.info("Test that stopping and restarting a node that has done nothing is not causing a failure")
323        options = [
324            [],
325            ALL_INDEX_ARGS,
326        ]
327        for option in options:
328            self.restart_node(1, option)
329
330    def restart_node_with_fd_limit(self, limit):
331        """Restart node 1 with a given soft RLIMIT_NOFILE. Skips if the limit cannot be set."""
332        import resource
333        soft, hard = resource.getrlimit(resource.RLIMIT_NOFILE)
334        try:
335            resource.setrlimit(resource.RLIMIT_NOFILE, (limit, hard))
336        except (ValueError, OSError):
337            self.log.warning(f"Skipping rlimit test: cannot set soft limit (hard={hard})")
338            return
339        try:
340            self.restart_node(1)
341            self.log.debug(f"Node started successfully with RLIM_INFINITY limit (soft={limit})")
342        finally:
343            resource.setrlimit(resource.RLIMIT_NOFILE, (soft, hard))
344            self.log.debug(f"Restored previous RLIMIT_NOFILE limits (soft={soft}, hard={hard})")
345
346    def init_rlimit_test(self):
347        """Test that bitcoind starts correctly when the soft RLIMIT_NOFILE limit is RLIM_INFINITY."""
348        if self.RLIM_INFINITY is None:
349            self.log.warning("Skipping: resource module not available")
350            return
351
352        self.log.info("Testing node startup with RLIM_INFINITY fd limit")
353        self.restart_node_with_fd_limit(self.RLIM_INFINITY)
354
355    def init_rlimit_large_test(self):
356        """Test that bitcoind starts correctly when the soft RLIMIT_NOFILE limit is above INT_MAX."""
357        if self.RLIM_INFINITY is None:
358            self.log.warning("Skipping: resource module not available")
359            return
360
361        self.log.info("Testing node startup with fd limit above INT_MAX")
362        self.restart_node_with_fd_limit(1 << 31)
363
364    def init_fd_overflow_test(self):
365        node = self.nodes[1]
366        if node.running:
367            self.stop_node(1)
368
369        # A value larger than any possible int saturates to INT_MAX during arg parsing.
370        # Adding in other file descriptor requirements is guaranteed to overflow,
371        # so expect an InitError before RaiseFileDescriptorLimit() is called.
372        self.log.info("Checking -rpcmaxconnections setting that would overflow int is rejected")
373        node.assert_start_raises_init_error(
374            extra_args=[f"-rpcmaxconnections={2**64}"],
375            expected_msg="Error: Too many file descriptors requested.",
376            match=ErrorMatch.PARTIAL_REGEX
377        )
378
379        self.log.info("Checking -rpcmaxconnections is ignored when disabling the HTTP server")
380        with node.assert_debug_log(
381            expected_msgs = ["net thread start"],
382            unexpected_msgs = ["Initialized HTTP server"],
383            timeout = 10
384        ):
385            node.start(extra_args=[f"-rpcmaxconnections={2**64}", "-server=0"], **get_process_group_kwargs())
386        # No HTTP server, no RPC `stop`
387        sigterm_node(node)
388
389        # From net.h
390        MAX_PEER_CONNECTIONS = 2000
391
392        self.log.info("Checking -maxconnections is capped before reserving file descriptors")
393        for requested, parsed in [(MAX_PEER_CONNECTIONS + 1, MAX_PEER_CONNECTIONS + 1), (2**64, 2**31 - 1)]:
394            warning = f"Reducing -maxconnections from {parsed} to {MAX_PEER_CONNECTIONS}."
395            self.restart_node(1, extra_args=[f"-maxconnections={requested}"])
396            self.stop_node(1, expected_stderr=re.compile(re.escape(warning)))
397
398        if self.RLIM_INFINITY is not None:
399            # Get the platform's file descriptor limit, if possible
400            import resource
401            soft, hard = resource.getrlimit(resource.RLIMIT_NOFILE)
402            # Stay within the -maxconnections cap so the descriptor limit is what reduces it
403            soft = min(soft, MAX_PEER_CONNECTIONS)
404
405            # Lower the hard limit so RaiseFileDescriptorLimit() has a ceiling.
406            # The hard limit can not be raised again without root privilges,
407            # so this test should always be left for last in the process.
408            try:
409                resource.setrlimit(resource.RLIMIT_NOFILE, (soft, soft))
410            except (ValueError, OSError):
411                self.log.warning(f"Skipping rlimit test: cannot reduce hard limit (soft={soft}, hard={hard})")
412                return
413
414            self.log.info("Checking that large -maxconnections setting gets adjusted for available file descriptors")
415            # Note this prints a message to the log and stderr but does not abort the process
416            with node.assert_debug_log(expected_msgs=[f"Reducing -maxconnections from {soft} "]):
417                self.restart_node(1, extra_args=[f"-maxconnections={soft}"])
418            self.stop_node(1, expected_stderr=re.compile(f"Reducing -maxconnections from {soft} "))
419
420            # From httpserver.h
421            DEFAULT_MAX_HTTP_CONNECTIONS = 16
422
423            self.log.info("Checking -rpcmaxconnections gets blamed if available file descriptors are insufficient")
424            node.assert_start_raises_init_error(
425                extra_args=[f"-rpcmaxconnections={DEFAULT_MAX_HTTP_CONNECTIONS + 1}", f"-maxconnections={soft}"],
426                expected_msg="Not enough file descriptors available. Try reducing -rpcmaxconnections",
427                match=ErrorMatch.PARTIAL_REGEX
428            )
429
430    def run_test(self):
431        self.init_pid_test()
432        self.init_stress_test_interrupt()
433        self.init_stress_test_removals()
434        self.break_wait_test()
435        self.init_empty_test()
436        self.init_rlimit_test()
437        self.init_rlimit_large_test()
438        self.init_fd_overflow_test()
439
440
441if __name__ == '__main__':
442    InitTest(__file__).main()
443