krkn-lib 5.1.4__py3-none-any.whl → 5.1.6__py3-none-any.whl

krkn_lib/k8s/pods_monitor_pool.py

@@ -1,202 +0,0 @@
-from concurrent.futures import ThreadPoolExecutor, wait
-from multiprocessing import Event
-
-from krkn_lib.k8s import KrknKubernetes
-from krkn_lib.models.k8s import PodsMonitorThread, PodsStatus
-
-
-class PodsMonitorPool:
-    """
-    This class has the purpose to manage pools of pod
-    status monitoring threads for the Krkn Scenarios
-    having multiple killing sessions at the same time (eg. Plugin scenarios)
-    the methods reflects the behaviour of the underlying
-    KrknKubernetes Primitives but each call to select_and_monitor_*
-    method pushes a new thread that is managed by the pool.
-    The join method joins all the threads in the pool simultaneously
-    and merges the results on a single PodsStatus structure.
-    """
-
-    events: list[Event]
-
-    def __init__(self, krkn_lib: KrknKubernetes):
-        self.krkn_lib = krkn_lib
-        self.pods_monitor_threads: list[PodsMonitorThread] = []
-        self.pods_statuses = []
-        self.events: list[Event] = []
-
-    def select_and_monitor_by_label(
-        self, label_selector: str, field_selector: str, max_timeout: int
-    ):
-        """
-        Pushes into the pool a monitoring thread for all the pods identified
-        by a label selector and collects infos about the
-        pods recovery after a kill scenario while the scenario is running.
-
-        :param label_selector: the label selector used
-            to filter the pods to monitor (must be the
-            same used in `select_pods_by_label`)
-        :param max_timeout: the expected time the pods should take
-            to recover. If the killed pods are replaced in this time frame,
-            but they didn't reach the Ready State, they will be marked as
-            unrecovered. If during the time frame the pods are not replaced
-            at all the error field of the PodsStatus structure will be
-            valorized with an exception.
-
-        """
-        event = Event()
-        self.events.append(event)
-        pods_and_namespaces = self.krkn_lib.select_pods_by_label(
-            label_selector=label_selector, field_selector=field_selector
-        )
-        pod_monitor_thread = self.krkn_lib.monitor_pods_by_label(
-            label_selector=label_selector,
-            pods_and_namespaces=pods_and_namespaces,
-            field_selector=field_selector,
-            max_timeout=max_timeout,
-            event=event,
-        )
-        self.pods_monitor_threads.append(pod_monitor_thread)
-
-    def select_and_monitor_by_name_pattern_and_namespace_pattern(
-        self,
-        pod_name_pattern: str,
-        namespace_pattern: str,
-        field_selector: str,
-        max_timeout: int,
-    ):
-        """
-        Pushes into the pool a monitoring thread for all the pods identified
-        by a pod name regex pattern
-        and a namespace regex pattern, that collects infos about the
-        pods recovery after a kill scenario while the scenario is running.
-
-        :param pod_name_pattern: a regex representing the
-            pod name pattern used to filter the pods to be monitored
-            (must be the same used in
-            `select_pods_by_name_pattern_and_namespace_pattern`)
-        :param namespace_pattern: a regex representing the namespace
-            pattern used to filter the pods to be monitored
-            (must be the same used in
-            `select_pods_by_name_pattern_and_namespace_pattern`)
-        :param field_selector: Pod field selector
-        :param max_timeout: the expected time the pods should take to
-            recover. If the killed pods are replaced in this time frame,
-            but they didn't reach the Ready State, they will be marked as
-            unrecovered. If during the time frame the pods are not replaced
-            at all the error field of the PodsStatus structure will be
-            valorized with an exception.
-
-        """
-
-        event = Event()
-        self.events.append(event)
-
-        pods_and_namespaces = (
-            self.krkn_lib.select_pods_by_name_pattern_and_namespace_pattern(
-                pod_name_pattern=pod_name_pattern,
-                namespace_pattern=namespace_pattern,
-                field_selector=field_selector,
-            )
-        )
-
-        pods_monitor_thread = (
-            self.krkn_lib.monitor_pods_by_name_pattern_and_namespace_pattern(
-                pod_name_pattern=pod_name_pattern,
-                namespace_pattern=namespace_pattern,
-                pods_and_namespaces=pods_and_namespaces,
-                field_selector=field_selector,
-                max_timeout=max_timeout,
-                event=event,
-            )
-        )
-
-        self.pods_monitor_threads.append(pods_monitor_thread)
-
-    def select_and_monitor_by_namespace_pattern_and_label(
-        self,
-        namespace_pattern: str,
-        label_selector: str,
-        field_selector: str = None,
-        max_timeout=30,
-    ):
-        """
-        Pushes into the pool a monitoring thread for all the pods identified
-        by a namespace regex pattern
-        and a pod label selector, that collects infos about the
-        pods recovery after a kill scenario while the scenario is running.
-
-        :param label_selector: the label selector used to filter
-            the pods to monitor (must be the same used in
-            `select_pods_by_label`)
-        :param namespace_pattern: a regex representing the namespace
-            pattern used to filter the pods to be monitored (must be
-            the same used
-            in `select_pods_by_name_pattern_and_namespace_pattern`)
-        :param max_timeout: the expected time the pods should take to recover.
-            If the killed pods are replaced in this time frame, but they
-            didn't reach the Ready State, they will be marked as unrecovered.
-            If during the time frame the pods are not replaced
-            at all the error field of the PodsStatus structure will be
-            valorized with an exception.
-
-        """
-        event = Event()
-        self.events.append(event)
-        pods_and_namespaces = (
-            self.krkn_lib.select_pods_by_namespace_pattern_and_label(
-                namespace_pattern=namespace_pattern,
-                label_selector=label_selector,
-                field_selector=field_selector,
-            )
-        )
-
-        pod_monitor_thread = (
-            self.krkn_lib.monitor_pods_by_namespace_pattern_and_label(
-                namespace_pattern=namespace_pattern,
-                label_selector=label_selector,
-                pods_and_namespaces=pods_and_namespaces,
-                field_selector=field_selector,
-                max_timeout=max_timeout,
-                event=event,
-            )
-        )
-        self.pods_monitor_threads.append(pod_monitor_thread)
-
-    def cancel(self):
-        """
-        cancels all the threads in the pool and makes return
-        the join() call immediately
-        """
-        for event in self.events:
-            event.set()
-
-    def join(self) -> PodsStatus:
-        """
-        waits all the threads pushed into the pool to finish
-
-        :return: a PodsStatus structure that is the merge between
-            all the PodsStatus structures returned by every thread
-            pushed into the pool.
-        """
-        futures = []
-        pods_statuses: list[PodsStatus] = []
-        final_status = PodsStatus()
-        with ThreadPoolExecutor() as executor:
-            for thread in self.pods_monitor_threads:
-                futures.append(executor.submit(thread.join))
-            done, _ = wait(futures)
-
-            for future in done:
-                pods_statuses.append(future.result())
-
-        exceptions = [status.error for status in pods_statuses if status.error]
-        if len(exceptions) > 0:
-            merged_exception_message = ", ".join([str(e) for e in exceptions])
-            final_status.error = merged_exception_message
-            return final_status
-
-        for pod_status in pods_statuses:
-            final_status.merge(pod_status)
-
-        return final_status

krkn_lib/tests/test_krkn_kubernetes_monitor.py

@@ -1,367 +0,0 @@
-import logging
-import time
-import unittest
-
-from krkn_lib.tests import BaseTest
-
-
-class KrknKubernetesTestsCreate(BaseTest):
-    def test_monitor_pods_by_label_no_pods_affected(self):
-        # test no pods affected
-        namespace = "test-ns-0-" + self.get_random_string(10)
-        delayed_1 = "delayed-0-" + self.get_random_string(10)
-        delayed_2 = "delayed-0-" + self.get_random_string(10)
-        label = "readiness-" + self.get_random_string(5)
-        self.deploy_namespace(namespace, [])
-        self.deploy_delayed_readiness_pod(delayed_1, namespace, 0, label)
-        self.deploy_delayed_readiness_pod(delayed_2, namespace, 0, label)
-
-        self.wait_pod(delayed_1, namespace)
-        self.wait_pod(delayed_2, namespace)
-
-        monitor_timeout = 2
-        pods_and_namespaces = self.lib_k8s.select_pods_by_label(
-            f"test={label}"
-        )
-        start_time = time.time()
-        pods_thread = self.lib_k8s.monitor_pods_by_label(
-            f"test={label}",
-            pods_and_namespaces,
-            field_selector="status.phase=Running",
-            max_timeout=monitor_timeout,
-        )
-
-        result = pods_thread.join()
-        end_time = time.time() - start_time
-        self.background_delete_pod(delayed_1, namespace)
-        self.background_delete_pod(delayed_2, namespace)
-        # added half second of delay that might be introduced to API
-        # calls
-        self.assertTrue(monitor_timeout < end_time < monitor_timeout + 0.5)
-        self.assertIsNone(result.error)
-        self.assertEqual(len(result.recovered), 0)
-        self.assertEqual(len(result.unrecovered), 0)
-        self.background_delete_ns(namespace)
-
-    def test_pods_by_name_and_namespace_pattern_different_names_respawn(
-        self,
-    ):
-        # test pod with different name recovered
-        namespace = "test-ns-1-" + self.get_random_string(10)
-        delayed_1 = "delayed-1-" + self.get_random_string(10)
-        delayed_2 = "delayed-1-" + self.get_random_string(10)
-        delayed_respawn = "delayed-1-respawn-" + self.get_random_string(10)
-        label = "readiness-" + self.get_random_string(5)
-        pod_delay = 1
-        monitor_timeout = 10
-        self.deploy_namespace(namespace, [])
-        self.deploy_delayed_readiness_pod(delayed_1, namespace, 0, label)
-        self.deploy_delayed_readiness_pod(delayed_2, namespace, 0, label)
-        self.wait_pod(delayed_1, namespace)
-        self.wait_pod(delayed_2, namespace)
-        pods_and_namespaces = (
-            self.lib_k8s.select_pods_by_name_pattern_and_namespace_pattern(
-                "^delayed-1-.*",
-                "^test-ns-1-.*",
-                field_selector="status.phase=Running",
-            )
-        )
-
-        pods_thread = (
-            self.lib_k8s.monitor_pods_by_name_pattern_and_namespace_pattern(
-                "^delayed-1-.*",
-                "^test-ns-1-.*",
-                pods_and_namespaces,
-                field_selector="status.phase=Running",
-                max_timeout=monitor_timeout,
-            )
-        )
-
-        self.background_delete_pod(delayed_1, namespace)
-        self.deploy_delayed_readiness_pod(
-            delayed_respawn, namespace, pod_delay, label
-        )
-        self.wait_pod(delayed_1, namespace)
-        self.wait_pod(delayed_respawn, namespace)
-        result = pods_thread.join()
-        self.assertIsNone(result.error)
-        self.assertEqual(len(result.recovered), 1)
-        self.assertEqual(result.recovered[0].pod_name, delayed_respawn)
-        self.assertEqual(result.recovered[0].namespace, namespace)
-        self.assertTrue(result.recovered[0].pod_readiness_time > 0)
-        self.assertTrue(result.recovered[0].pod_rescheduling_time > 0)
-        self.assertTrue(result.recovered[0].total_recovery_time >= pod_delay)
-        self.assertEqual(len(result.unrecovered), 0)
-        self.background_delete_ns(namespace)
-
-    def test_pods_by_namespace_pattern_and_label_same_name_respawn(
-        self,
-    ):
-        # test pod with same name recovered
-        namespace = "test-ns-2-" + self.get_random_string(10)
-        delayed_1 = "delayed-2-1-" + self.get_random_string(10)
-        delayed_2 = "delayed-2-2-" + self.get_random_string(10)
-        label = "readiness-" + self.get_random_string(5)
-        self.deploy_namespace(namespace, [])
-        self.deploy_delayed_readiness_pod(delayed_1, namespace, 0, label)
-        self.deploy_delayed_readiness_pod(delayed_2, namespace, 0, label)
-        self.wait_pod(delayed_1, namespace)
-        self.wait_pod(delayed_2, namespace)
-        monitor_timeout = 45
-        pod_delay = 0
-        pods_and_namespaces = (
-            self.lib_k8s.select_pods_by_namespace_pattern_and_label(
-                "^test-ns-2-.*",
-                f"test={label}",
-                field_selector="status.phase=Running",
-            )
-        )
-        pods_thread = self.lib_k8s.monitor_pods_by_namespace_pattern_and_label(
-            "^test-ns-2-.*",
-            f"test={label}",
-            pods_and_namespaces,
-            field_selector="status.phase=Running",
-            max_timeout=monitor_timeout,
-        )
-
-        self.lib_k8s.delete_pod(delayed_1, namespace)
-        time.sleep(3)
-        self.deploy_delayed_readiness_pod(
-            delayed_1, namespace, pod_delay, label
-        )
-        self.wait_pod(delayed_1, namespace)
-        result = pods_thread.join()
-        self.assertIsNone(result.error)
-        self.assertEqual(len(result.recovered), 1)
-        self.assertEqual(result.recovered[0].pod_name, delayed_1)
-        self.assertEqual(result.recovered[0].namespace, namespace)
-        self.assertTrue(result.recovered[0].pod_readiness_time > 0)
-        self.assertTrue(result.recovered[0].pod_rescheduling_time > 0)
-        self.assertTrue(result.recovered[0].total_recovery_time >= pod_delay)
-        self.assertEqual(len(result.unrecovered), 0)
-        self.background_delete_ns(namespace)
-
-    def test_pods_by_label_respawn_timeout(self):
-        # test pod will not recover before the timeout
-        namespace = "test-ns-3-" + self.get_random_string(10)
-        delayed_1 = "delayed-3-" + self.get_random_string(10)
-        delayed_2 = "delayed-3-" + self.get_random_string(10)
-        delayed_respawn = "delayed-respawn-3-" + self.get_random_string(10)
-        label = "readiness-" + self.get_random_string(5)
-
-        self.deploy_namespace(namespace, [])
-        self.deploy_delayed_readiness_pod(delayed_1, namespace, 0, label)
-        self.deploy_delayed_readiness_pod(delayed_2, namespace, 0, label)
-        self.wait_pod(delayed_1, namespace)
-        self.wait_pod(delayed_2, namespace)
-        monitor_timeout = 20
-        pod_delay = 30
-        # pod with same name recovered
-
-        pods_and_namespaces = self.lib_k8s.select_pods_by_label(
-            f"test={label}", field_selector="status.phase=Running"
-        )
-        pods_thread = self.lib_k8s.monitor_pods_by_label(
-            f"test={label}",
-            pods_and_namespaces,
-            field_selector="status.phase=Running",
-            max_timeout=monitor_timeout,
-        )
-
-        self.background_delete_pod(delayed_1, namespace)
-        self.deploy_delayed_readiness_pod(
-            delayed_respawn, namespace, pod_delay, label
-        )
-        time.sleep(3)
-        result = pods_thread.join()
-        self.assertIsNone(result.error)
-        self.assertEqual(len(result.unrecovered), 1)
-        self.assertEqual(result.unrecovered[0].pod_name, delayed_respawn)
-        self.assertEqual(result.unrecovered[0].namespace, namespace)
-        self.assertEqual(len(result.recovered), 0)
-        self.background_delete_ns(namespace)
-
-    def test_pods_by_label_never_respawn(self):
-        # test pod will never recover
-        namespace = "test-ns-4-" + self.get_random_string(10)
-        delayed_1 = "delayed-4-" + self.get_random_string(10)
-        delayed_2 = "delayed-4-" + self.get_random_string(10)
-        label = "readiness-" + self.get_random_string(5)
-        self.deploy_namespace(namespace, [])
-        self.deploy_delayed_readiness_pod(delayed_1, namespace, 0, label)
-        self.deploy_delayed_readiness_pod(delayed_2, namespace, 0, label)
-        self.wait_pod(delayed_1, namespace)
-        self.wait_pod(delayed_2, namespace)
-
-        monitor_timeout = 15
-
-        pods_and_namespaces = self.lib_k8s.select_pods_by_label(
-            f"test={label}", field_selector="status.phase=Running"
-        )
-        pods_thread = self.lib_k8s.monitor_pods_by_label(
-            f"test={label}",
-            pods_and_namespaces,
-            field_selector="status.phase=Running",
-            max_timeout=monitor_timeout,
-        )
-        self.background_delete_pod(delayed_1, namespace)
-        time.sleep(3)
-        result = pods_thread.join()
-        self.assertIsNone(result.error)
-        self.assertEqual(len(result.unrecovered), 0)
-        self.assertEqual(len(result.recovered), 0)
-        self.background_delete_ns(namespace)
-
-    def test_flaky_tests(self):
-        logging.warn("test_pods_by_label_multiple_respawn")
-        logging.warn("test_pods_by_label_multiple_respawn_one_too_late")
-        logging.warn("FLAKY TESTS NEED TO BE REFACTORED AND REENABLED")
-
-    ######## FLAKY TEST NEEDS TO BE REFACTORED # NOQA
-    # def test_pods_by_label_multiple_respawn(self):
-    #     # test pod will never recover
-    #     namespace = "test-ns-4-" + self.get_random_string(10)
-    #     delayed_1 = "delayed-4-" + self.get_random_string(10)
-    #     delayed_2 = "delayed-4-" + self.get_random_string(10)
-    #     delayed_3 = "delayed-4-" + self.get_random_string(10)
-    #     delayed_respawn_1 = "delayed-4-respawn-" + self.get_random_string(10)
-    #     delayed_respawn_2 = "delayed-4-respawn-" + self.get_random_string(10)
-    #     label = "readiness-" + self.get_random_string(5)
-    #     self.deploy_namespace(namespace, [])
-    #     self.deploy_delayed_readiness_pod(delayed_1, namespace, 0, label)
-    #     self.deploy_delayed_readiness_pod(delayed_2, namespace, 0, label)
-    #     self.deploy_delayed_readiness_pod(delayed_3, namespace, 0, label)
-    #     self.wait_pod(delayed_1, namespace)
-    #     self.wait_pod(delayed_2, namespace)
-    #     self.wait_pod(delayed_3, namespace)
-    #     monitor_timeout = 20
-    #     pod_delay = 2
-    #     pods_and_namespaces = self.lib_k8s.select_pods_by_label(
-    #         f"test={label}", field_selector="status.phase=Running"
-    #     )
-    #     pods_thread = self.lib_k8s.monitor_pods_by_label(
-    #         f"test={label}",
-    #         pods_and_namespaces,
-    #         field_selector="status.phase=Running",
-    #         max_timeout=monitor_timeout,
-    #     )
-    #
-    #     self.background_delete_pod(delayed_1, namespace)
-    #     self.background_delete_pod(delayed_2, namespace)
-    #
-    #     self.deploy_delayed_readiness_pod(
-    #         delayed_respawn_1, namespace, pod_delay, label
-    #     )
-    #     self.deploy_delayed_readiness_pod(
-    #         delayed_respawn_2, namespace, pod_delay, label
-    #     )
-    #     self.wait_pod(delayed_respawn_1, namespace)
-    #     self.wait_pod(delayed_respawn_2, namespace)
-    #     result = pods_thread.join()
-    #     self.background_delete_pod(delayed_3, namespace)
-    #     self.background_delete_pod(delayed_respawn_1, namespace)
-    #     self.background_delete_pod(delayed_respawn_2, namespace)
-    #     self.assertIsNone(result.error)
-    #     self.assertEqual(len(result.unrecovered), 0)
-    #     self.assertEqual(len(result.recovered), 2)
-    #     self.assertTrue(
-    #         delayed_respawn_1 in [p.pod_name for p in result.recovered]
-    #     )
-    #     self.assertTrue(
-    #         delayed_respawn_2 in [p.pod_name for p in result.recovered]
-    #     )
-    #     self.background_delete_ns(namespace)
-
-    ######## FLAKY TEST NEEDS TO BE REFACTORED # NOQA
-    # def test_pods_by_label_multiple_respawn_one_too_late(self):
-    #     # test pod will never recover
-    #     namespace = "test-ns-4-" + self.get_random_string(10)
-    #     delayed_1 = "delayed-4-" + self.get_random_string(10)
-    #     delayed_2 = "delayed-4-" + self.get_random_string(10)
-    #     delayed_3 = "delayed-4-" + self.get_random_string(10)
-    #     delayed_respawn_1 = "delayed-4-respawn-" + self.get_random_string(10)
-    #     delayed_respawn_2 = "delayed-4-respawn-" + self.get_random_string(10)
-    #     label = "readiness-" + self.get_random_string(5)
-    #     self.deploy_namespace(namespace, [])
-    #     self.deploy_delayed_readiness_pod(delayed_1, namespace, 0, label)
-    #     self.deploy_delayed_readiness_pod(delayed_2, namespace, 0, label)
-    #     self.deploy_delayed_readiness_pod(delayed_3, namespace, 0, label)
-    #     self.wait_pod(delayed_1, namespace)
-    #     self.wait_pod(delayed_2, namespace)
-    #     self.wait_pod(delayed_3, namespace)
-    #     monitor_timeout = 20
-    #     pod_delay = 2
-    #     pod_too_much_delay = 25
-    #     pods_and_namespaces = self.lib_k8s.select_pods_by_label(
-    #         f"test={label}", field_selector="status.phase=Running"
-    #     )
-    #     pods_thread = self.lib_k8s.monitor_pods_by_label(
-    #         f"test={label}",
-    #         pods_and_namespaces,
-    #         field_selector="status.phase=Running",
-    #         max_timeout=monitor_timeout,
-    #     )
-    #     self.background_delete_pod(delayed_1, namespace)
-    #     self.background_delete_pod(delayed_2, namespace)
-    #
-    #     self.deploy_delayed_readiness_pod(
-    #         delayed_respawn_1, namespace, pod_delay, label
-    #     )
-    #     self.deploy_delayed_readiness_pod(
-    #         delayed_respawn_2, namespace, pod_too_much_delay, label
-    #     )
-    #     self.wait_pod(delayed_respawn_1, namespace)
-    #     result = pods_thread.join()
-    #     self.assertIsNone(result.error)
-    #     self.assertEqual(len(result.unrecovered), 1)
-    #     self.assertEqual(len(result.recovered), 1)
-    #     self.assertTrue(
-    #         delayed_respawn_1 in [p.pod_name for p in result.recovered]
-    #     )
-    #     self.assertTrue(
-    #         delayed_respawn_2 in [p.pod_name for p in result.unrecovered]
-    #     )
-    #     self.background_delete_ns(namespace)
-
-    def test_pods_by_label_multiple_respawn_one_fails(self):
-        # test pod will never recover
-        namespace = "test-ns-4-" + self.get_random_string(10)
-        delayed_1 = "delayed-4-" + self.get_random_string(10)
-        delayed_2 = "delayed-4-" + self.get_random_string(10)
-        delayed_3 = "delayed-4-" + self.get_random_string(10)
-        delayed_respawn_1 = "delayed-4-respawn-" + self.get_random_string(10)
-        label = "readiness-" + self.get_random_string(5)
-        self.deploy_namespace(namespace, [])
-        self.deploy_delayed_readiness_pod(delayed_1, namespace, 0, label)
-        self.deploy_delayed_readiness_pod(delayed_2, namespace, 0, label)
-        self.deploy_delayed_readiness_pod(delayed_3, namespace, 0, label)
-        self.wait_pod(delayed_1, namespace)
-        self.wait_pod(delayed_2, namespace)
-        self.wait_pod(delayed_3, namespace)
-
-        monitor_timeout = 10
-        pod_delay = 1
-        pods_and_namespaces = self.lib_k8s.select_pods_by_label(
-            f"test={label}", field_selector="status.phase=Running"
-        )
-        pods_thread = self.lib_k8s.monitor_pods_by_label(
-            f"test={label}",
-            pods_and_namespaces,
-            field_selector="status.phase=Running",
-            max_timeout=monitor_timeout,
-        )
-
-        self.background_delete_pod(delayed_1, namespace)
-        self.background_delete_pod(delayed_2, namespace)
-        time.sleep(3)
-        self.deploy_delayed_readiness_pod(
-            delayed_respawn_1, namespace, pod_delay, label
-        )
-        result = pods_thread.join()
-        self.assertEqual(len(result.unrecovered), 0)
-        self.assertEqual(len(result.recovered), 1)
-        self.background_delete_ns(namespace)
-
-
-if __name__ == "__main__":
-    unittest.main()