Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

Avoid idle HTTP fixture teardown waits

pulse-triage[bot]21068a2e3b56
diff --git a/scripts/tests/test_api_auth_docs.py b/scripts/tests/test_api_auth_docs.py
index 2b5e3369a3..4655a94347 100644
--- a/scripts/tests/test_api_auth_docs.py
+++ b/scripts/tests/test_api_auth_docs.py
@@ -104,7 +104,10 @@ def recording_server(status: int = 200, partial: bool = False, response: bytes =
pass
server = HTTPServer(("127.0.0.1", 0), Handler)
- thread = threading.Thread(target=server.serve_forever, daemon=True)
+ # Poll only the fixture server more often so teardown need not wait 500 ms.
+ # This does not shorten any copied request, reader or cleanup deadline.
+ thread = threading.Thread(target=server.serve_forever,
+ kwargs={"poll_interval": 0.05}, daemon=True)
thread.start()
try:
yield server.server_address[1], requests
diff --git a/scripts/tests/test_authentication_diagnostic_docs.py b/scripts/tests/test_authentication_diagnostic_docs.py
index 9163716259..be1ab180af 100644
--- a/scripts/tests/test_authentication_diagnostic_docs.py
+++ b/scripts/tests/test_authentication_diagnostic_docs.py
@@ -76,7 +76,10 @@ def proxy_server(status):
pass
server = HTTPServer(("127.0.0.1", 0), Handler)
- thread = threading.Thread(target=server.serve_forever, daemon=True)
+ # Poll only the fixture server more often so teardown need not wait 500 ms.
+ # This does not shorten any copied request, reader or cleanup deadline.
+ thread = threading.Thread(target=server.serve_forever,
+ kwargs={"poll_interval": 0.05}, daemon=True)
thread.start()
try:
yield server.server_address[1], requests
diff --git a/scripts/tests/test_http_fixture_docs.py b/scripts/tests/test_http_fixture_docs.py
new file mode 100644
index 0000000000..6f79219794
--- /dev/null
+++ b/scripts/tests/test_http_fixture_docs.py
@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""Check the owned lifecycle of documentation HTTP/TLS fixtures.
+
+Run in pulse-worker-source-proof: listeners are guest-local and credentials,
+certificates and installers are synthetic. The consumer suites test requests;
+these controls test idle teardown, exception propagation and listener isolation.
+"""
+
+from pathlib import Path
+import tempfile
+import threading
+import unittest
+from unittest.mock import patch
+
+import test_api_auth_docs as api
+import test_authentication_diagnostic_docs as authentication
+import test_pbs_docs as pbs
+import test_scheduler_polling_docs as scheduler
+import test_signed_installer_docs as installer
+import test_truenas_docs as truenas
+
+
+REAL_THREAD = threading.Thread
+
+
+class FixtureFailure(Exception):
+ pass
+
+
+class HTTPFixtureLifecycleTest(unittest.TestCase):
+ @classmethod
+ def setUpClass(cls):
+ cls.temporary = tempfile.TemporaryDirectory(prefix="pulse-http-lifecycle-")
+ cls.addClassCleanup(cls.temporary.cleanup)
+ cls.cert, cls.key = pbs.certificate(Path(cls.temporary.name), "server")
+
+ def fixtures(self):
+ return (
+ ("api", lambda _: api.recording_server(), 1),
+ ("proxy", lambda _: authentication.proxy_server(403), 1),
+ ("pbs-tls", lambda _: pbs.server(self.cert, self.key), 1),
+ ("scheduler", lambda _: scheduler.server(scheduler.snapshot()), 1),
+ ("signed-install-tls", lambda root: installer.download_servers(root, "success"), 2),
+ ("truenas", lambda _: truenas.server(), 1),
+ )
+
+ def check_lifecycle(self, factory, expected_listeners, *, exceptional):
+ owned = []
+
+ def capture_thread(*args, **kwargs):
+ thread = REAL_THREAD(*args, **kwargs)
+ owned.append((thread, kwargs["target"].__self__, kwargs))
+ return thread
+
+ def exercise(root):
+ with factory(root):
+ self.assertEqual(len(owned), expected_listeners)
+ self.assertTrue(all(thread.is_alive() for thread, _, _ in owned))
+ self.assertEqual(len({server.server_address for _, server, _ in owned}),
+ expected_listeners)
+ if exceptional:
+ raise FixtureFailure("synthetic consumer failure")
+
+ with tempfile.TemporaryDirectory() as temporary, \
+ patch.object(threading, "Thread", side_effect=capture_thread):
+ if exceptional:
+ with self.assertRaisesRegex(FixtureFailure, "synthetic consumer failure"):
+ exercise(Path(temporary))
+ else:
+ exercise(Path(temporary))
+
+ # Observe real cleanup before judging scheduling. A default-poll
+ # regression must not strand its listener just to fail this control.
+ self.assertEqual(len(owned), expected_listeners)
+ for thread, server, kwargs in owned:
+ self.assertFalse(thread.is_alive(), "fixture thread survived teardown")
+ self.assertEqual(server.socket.fileno(), -1, "fixture listener remained open")
+ self.assertEqual(server.server_address[0], "127.0.0.1")
+ self.assertTrue(kwargs["daemon"])
+ self.assertEqual(kwargs.get("kwargs"), {"poll_interval": 0.05},
+ "idle teardown must not wait for the default 500 ms poll")
+
+ def test_idle_fixtures_close_every_owned_listener_and_thread(self):
+ for name, factory, expected in self.fixtures():
+ with self.subTest(fixture=name):
+ self.check_lifecycle(factory, expected, exceptional=False)
+
+ def test_consumer_failure_propagates_after_every_listener_is_closed(self):
+ for name, factory, expected in self.fixtures():
+ with self.subTest(fixture=name):
+ self.check_lifecycle(factory, expected, exceptional=True)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/scripts/tests/test_pbs_docs.py b/scripts/tests/test_pbs_docs.py
index eb55078e30..80bacd552b 100644
--- a/scripts/tests/test_pbs_docs.py
+++ b/scripts/tests/test_pbs_docs.py
@@ -93,7 +93,10 @@ def server(cert, key, status=200, installer=None, installer_path="/install.sh",
http = HTTPServer(("127.0.0.1", 0), Handler)
context = server_context(cert, key)
http.socket = context.wrap_socket(http.socket, server_side=True)
- thread = threading.Thread(target=http.serve_forever, daemon=True)
+ # Poll only the fixture server more often so teardown need not wait 500 ms.
+ # This does not shorten any copied request, reader or cleanup deadline.
+ thread = threading.Thread(target=http.serve_forever,
+ kwargs={"poll_interval": 0.05}, daemon=True)
thread.start()
try:
yield http.server_address[1], requests
diff --git a/scripts/tests/test_scheduler_polling_docs.py b/scripts/tests/test_scheduler_polling_docs.py
index 6643abf5c0..cf4aaa450c 100644
--- a/scripts/tests/test_scheduler_polling_docs.py
+++ b/scripts/tests/test_scheduler_polling_docs.py
@@ -67,7 +67,10 @@ def server(payload, status=200):
pass
httpd = HTTPServer(("127.0.0.1", 0), Handler)
- thread = threading.Thread(target=httpd.serve_forever, daemon=True)
+ # Poll only the fixture server more often so teardown need not wait 500 ms.
+ # This does not shorten any copied request, reader or cleanup deadline.
+ thread = threading.Thread(target=httpd.serve_forever,
+ kwargs={"poll_interval": 0.05}, daemon=True)
thread.start()
try:
yield httpd.server_address[1], calls
diff --git a/scripts/tests/test_signed_installer_docs.py b/scripts/tests/test_signed_installer_docs.py
index 059c6e48b1..d481620d74 100644
--- a/scripts/tests/test_signed_installer_docs.py
+++ b/scripts/tests/test_signed_installer_docs.py
@@ -77,7 +77,10 @@ def download_servers(root, mode):
context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
context.load_cert_chain(root / "tls.crt", root / "tls.key")
secure.socket = context.wrap_socket(secure.socket, server_side=True)
- threads = [threading.Thread(target=server.serve_forever, daemon=True)
+ # Poll only the fixture server more often so teardown need not wait 500 ms.
+ # This does not shorten any copied request, reader or cleanup deadline.
+ threads = [threading.Thread(target=server.serve_forever,
+ kwargs={"poll_interval": 0.05}, daemon=True)
for server in (plain, secure)]
for thread in threads:
thread.start()
diff --git a/scripts/tests/test_truenas_docs.py b/scripts/tests/test_truenas_docs.py
index 49a899a9db..edf00e2a06 100644
--- a/scripts/tests/test_truenas_docs.py
+++ b/scripts/tests/test_truenas_docs.py
@@ -55,7 +55,10 @@ def server(status=200):
pass
http = HTTPServer(("127.0.0.1", 0), Handler)
- thread = threading.Thread(target=http.serve_forever, daemon=True)
+ # Poll only the fixture server more often so teardown need not wait 500 ms.
+ # This does not shorten any copied request, reader or cleanup deadline.
+ thread = threading.Thread(target=http.serve_forever,
+ kwargs={"poll_interval": 0.05}, daemon=True)
thread.start()
try:
yield http.server_address[1], requests