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.

3.8 KB
Raw Blame
#!/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()