krkn-lib 5.1.3__py3-none-any.whl → 5.1.5__py3-none-any.whl

krkn_lib/k8s/krkn_kubernetes.py

@@ -7,8 +7,6 @@ import re
 import threading
 import time
 import warnings
-from concurrent.futures import ThreadPoolExecutor, wait
-from functools import partial
 from queue import Queue
 from typing import Any, Dict, List, Optional
 from urllib.parse import urlparse
@@ -27,13 +25,10 @@ from urllib3 import HTTPResponse
 from krkn_lib.models.k8s import (
     PVC,
     AffectedNode,
-    AffectedPod,
     ApiRequestException,
     Container,
     NodeResources,
     Pod,
-    PodsMonitorThread,
-    PodsStatus,
     ServiceHijacking,
     Volume,
     VolumeMount,
@@ -1513,11 +1508,15 @@ class KrknKubernetes:
             logging.error("Error trying to apply_yaml" + str(e))
 
     def get_pod_info(
-        self, name: str, namespace: str = "default", delete_expected: bool = False
+        self,
+        name: str,
+        namespace: str = "default",
+        delete_expected: bool = False,
     ) -> Optional[Pod]:
         """
         Retrieve information about a specific pod
 
+
         :param name: pod name
         :param namespace: namespace (optional default `default`)
         :return: Data class object of type Pod with the output of the above
@@ -1583,11 +1582,11 @@ class KrknKubernetes:
                     creation_timestamp=response.metadata.creation_timestamp,
                 )
         except Exception:
-            if not delete_expected: 
+            if not delete_expected:
                 logging.error(
                     "Pod '%s' doesn't exist in namespace '%s'", name, namespace
                 )
-            else: 
+            else:
                 logging.info(
                     "Pod '%s' doesn't exist in namespace '%s'", name, namespace
                 )
@@ -2745,374 +2744,6 @@ class KrknKubernetes:
         ]
         return pods_and_namespaces
 
-    def monitor_pods_by_label(
-        self,
-        label_selector: str,
-        pods_and_namespaces: list[(str, str)],
-        field_selector: str = None,
-        max_timeout: int = 30,
-        event: threading.Event = None,
-    ) -> PodsMonitorThread:
-        """
-        Starts monitoring a list of pods identified as tuples
-        (pod_name, namespace) filtered by label selector
-        and collects infos about the pods recovery after a kill scenario.
-        Returns a PodsMonitorThread that can be joined after the scenario
-        to retrieve the PodsStatus object containing all the information
-        collected in background during the chaos run.
-
-        :param label_selector: the label selector used
-            to filter the pods to monitor (must be the
-            same used in `select_pods_by_label`)
-        :param pods_and_namespaces: the list of pods collected
-            by `select_pods_by_label` against which the changes
-            in the pods state is monitored
-        :param field_selector: filter results by config details
-            select only running pods by setting "status.phase=Running"
-        :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.
-        :param event: a threading event can be passed to interrupt the process
-            before the timeout. Simply call set() method on the event passed
-            to make the thread return immediately
-        :return: a PodsMonitorThread structure that can be joined
-            in any place of the code, to collect the PodsStatus structure
-            returned, in order to make the process run in background
-            while a chaos scenario is performed.
-
-        """
-        pods_status = PodsStatus()
-        return self.__start_monitoring_pods(
-            pods_and_namespaces=pods_and_namespaces,
-            max_timeout=max_timeout,
-            pods_status=pods_status,
-            label_selector=label_selector,
-            field_selector=field_selector,
-            event=event,
-        )
-
-    def monitor_pods_by_name_pattern_and_namespace_pattern(
-        self,
-        pod_name_pattern: str,
-        namespace_pattern: str,
-        pods_and_namespaces: list[(str, str)],
-        field_selector: str = None,
-        max_timeout=30,
-        event: threading.Event = None,
-    ) -> PodsMonitorThread:
-        """
-        Starts monitoring a list of pods identified as tuples
-        (pod_name, namespace) filtered by a pod name regex pattern
-        and a namespace regex pattern, and collects infos about the
-        pods recovery after a kill scenario. Returns a PodsMonitorThread
-        that can be joined after the scenario to retrieve the PodsStatus
-        object containing all the information collected in background during
-        the chaos run.
-
-        :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 pods_and_namespaces: the list of pods collected by
-            `select_pods_by_name_pattern_and_namespace_pattern` against
-            which the changes in the pods state is monitored
-        :param field_selector: filter results by config details
-            select only running pods by setting "status.phase=Running"
-        :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.
-        :param event: a threading event can be passed to interrupt the process
-            before the timeout. Simply call set() method on the event passed
-            to make the thread return immediately
-        :return: a PodsMonitorThread structure that can be joined in any
-            place of the code, to collect the PodsStatus structure returned,
-            in order to make the process run in background while a chaos
-            scenario is performed.
-
-        """
-        pods_status = PodsStatus()
-        return self.__start_monitoring_pods(
-            pods_and_namespaces=pods_and_namespaces,
-            max_timeout=max_timeout,
-            pods_status=pods_status,
-            field_selector=field_selector,
-            name_pattern=pod_name_pattern,
-            namespace_pattern=namespace_pattern,
-            event=event,
-        )
-
-    def monitor_pods_by_namespace_pattern_and_label(
-        self,
-        namespace_pattern: str,
-        label_selector: str,
-        pods_and_namespaces: list[(str, str)],
-        field_selector: str = None,
-        max_timeout=30,
-        event: threading.Event = None,
-    ) -> PodsMonitorThread:
-        """
-        Starts monitoring a list of pods identified as tuples
-        (pod_name, namespace) filtered by a namespace regex pattern
-        and a pod label selector, and collects infos about the
-        pods recovery after a kill scenario. Returns a PodsMonitorThread
-        that can be joined after the scenario to retrieve the PodsStatus
-        object containing all the information collected in background during
-        the chaos run.
-
-        :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 pods_and_namespaces: the list of pods collected by
-            `select_pods_by_name_pattern_and_namespace_pattern` against
-            which the changes in the pods state is monitored
-        :param field_selector: filter results by config details
-            select only running pods by setting "status.phase=Running"
-        :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.
-        :param event: a threading event can be passed to interrupt the process
-            before the timeout. Simply call set() method on the event passed
-            to make the thread return immediately
-        :return: a PodsMonitorThread structure that can be joined in
-            any place of the code, to collect the PodsStatus structure
-            returned, in order to make the process run in background while
-            a chaos scenario is performed.
-
-        """
-        pods_status = PodsStatus()
-        return self.__start_monitoring_pods(
-            pods_and_namespaces=pods_and_namespaces,
-            max_timeout=max_timeout,
-            pods_status=pods_status,
-            label_selector=label_selector,
-            field_selector=field_selector,
-            namespace_pattern=namespace_pattern,
-            event=event,
-        )
-
-    def __start_monitoring_pods(
-        self,
-        pods_and_namespaces: list[(str, str)],
-        pods_status: PodsStatus,
-        max_timeout: int,
-        label_selector: str = None,
-        field_selector: str = None,
-        pod_name: str = None,
-        namespace_pattern: str = None,
-        name_pattern: str = None,
-        event: threading.Event = None,
-    ) -> PodsMonitorThread:
-        executor = ThreadPoolExecutor()
-        future = executor.submit(
-            self.__monitor_pods_worker,
-            pods_and_namespaces=pods_and_namespaces,
-            pods_status=pods_status,
-            max_timeout=max_timeout,
-            label_selector=label_selector,
-            field_selector=field_selector,
-            pod_name=pod_name,
-            namespace_pattern=namespace_pattern,
-            name_pattern=name_pattern,
-            event=event,
-        )
-
-        return PodsMonitorThread(executor, future)
-
-    def __monitor_pods_worker(
-        self,
-        pods_and_namespaces: [(str, str)],
-        pods_status: PodsStatus,
-        max_timeout: int,
-        label_selector: str = None,
-        field_selector: str = None,
-        pod_name: str = None,
-        namespace_pattern: str = None,
-        name_pattern: str = None,
-        event: threading.Event = None,
-    ) -> PodsStatus:
-        missing_pods = set()
-        pods_to_wait = set()
-        pods_already_watching = set()
-        start_time = time.time()
-        _event = threading.Event() if not event else event
-        if (
-            label_selector
-            and not pod_name
-            and not name_pattern
-            and not namespace_pattern
-        ):
-            select_method = partial(
-                self.select_pods_by_label,
-                label_selector=label_selector,
-                field_selector=field_selector,
-            )
-        elif (
-            name_pattern
-            and namespace_pattern
-            and not pod_name
-            and not label_selector
-        ):
-            select_method = partial(
-                self.select_pods_by_name_pattern_and_namespace_pattern,
-                pod_name_pattern=name_pattern,
-                namespace_pattern=namespace_pattern,
-                field_selector=field_selector,
-            )
-        elif (
-            namespace_pattern
-            and label_selector
-            and not pod_name
-            and not name_pattern
-        ):
-            select_method = partial(
-                self.select_pods_by_namespace_pattern_and_label,
-                namespace_pattern=namespace_pattern,
-                label_selector=label_selector,
-                field_selector=field_selector,
-            )
-        else:
-            pods_status.error = (
-                "invalid parameter combination, "
-                "check hasn't been performed, aborting."
-            )
-            return pods_status
-
-        while time.time() - start_time <= max_timeout:
-            if event and event.is_set():
-                return pods_status
-
-            time_offset = time.time() - start_time
-            remaining_time = max_timeout - time_offset
-            current_pods_and_namespaces = select_method()
-            # no pods have been killed or pods have been killed and
-            # respawned with the same names
-            if set(pods_and_namespaces) == set(current_pods_and_namespaces):
-                for pod in current_pods_and_namespaces:
-
-                    pod_info = self.get_pod_info(pod[0], pod[1], delete_expected=True)
-                    # for pod_info in pod_list_info:
-                    if pod_info:
-                        pod_creation_timestamp = (
-                            pod_info.creation_timestamp.timestamp()
-                        )
-                        if start_time < pod_creation_timestamp:
-                            missing_pods.add(pod)
-                pods_to_wait.update(missing_pods)
-
-            # pods have been killed but respawned with different names
-            elif set(pods_and_namespaces) != set(
-                current_pods_and_namespaces
-            ) and len(pods_and_namespaces) <= len(current_pods_and_namespaces):
-                # in this case the pods to wait have been respawn
-                # with different names
-                pods_to_wait.update(
-                    set(current_pods_and_namespaces) - set(pods_and_namespaces)
-                )
-
-            # pods have been killed and are not
-            # respawned yet (missing pods names
-            # are collected
-            elif set(pods_and_namespaces) != set(
-                current_pods_and_namespaces
-            ) and len(pods_and_namespaces) > len(current_pods_and_namespaces):
-                # update on missing_pods set is idempotent since the tuple
-                # pod_name,namespace is unique in the cluster
-                missing_pods.update(
-                    set(pods_and_namespaces) - set(current_pods_and_namespaces)
-                )
-                continue
-            # no change has been made in the pod set,
-            # maybe is taking some time to
-            # inject the chaos, let's see the next iteration.
-            if len(pods_to_wait) == 0:
-                continue
-            futures = []
-            with ThreadPoolExecutor() as executor:
-                for pod_and_namespace in pods_to_wait:
-                    if pod_and_namespace not in pods_already_watching:
-
-                        # need name of new pod
-                        future = executor.submit(
-                            self.__wait_until_pod_is_ready_worker,
-                            pod_name=pod_and_namespace[0],
-                            namespace=pod_and_namespace[1],
-                            event=_event,
-                        )
-                        futures.append(future)
-                        pods_already_watching.add(pod_and_namespace)
-
-                # this will wait all the futures to
-                # finish within the remaining time
-                done, undone = wait(futures, timeout=remaining_time)
-                _event.set()
-                for future in done:
-                    result = future.result()
-                    # sum the time elapsed waiting before the pod
-                    # has been rescheduled (rescheduling time)
-                    # to the effective recovery time of the pod
-                    if result.pod_readiness_time:
-                        result.pod_rescheduling_time = (
-                            time.time()
-                            - start_time
-                            - result.pod_readiness_time
-                        )
-                        result.total_recovery_time = (
-                            result.pod_readiness_time
-                            + result.pod_rescheduling_time
-                        )
-
-                        pods_status.recovered.append(result)
-                for future in undone:
-                    result = future.result()
-                    pods_status.unrecovered.append(result)
-
-                missing_pods.clear()
-
-        # if there are missing pods, pods affected
-        # by the chaos did not restart after the chaos
-        # an exception will be set in the PodsStatus
-        # structure that will be catched at the end of
-        # the monitoring,
-        if len(missing_pods) > 0:
-            if not _event.is_set():
-                pods_status.error = f'{", ".join([f"pod: {p[0]} namespace:{p[1]}" for p in missing_pods])}'  # NOQA
-
-        return pods_status
-
-    def __wait_until_pod_is_ready_worker(
-        self, pod_name: str, namespace: str, event: threading.Event
-    ) -> AffectedPod:
-        start_time = time.time()
-        ready = False
-
-        while not ready and not event.is_set():
-            ready = self.is_pod_running(pod_name, namespace)
-        end_time = time.time()
-        pod = AffectedPod(
-            pod_name=pod_name,
-            namespace=namespace,
-        )
-        if not event.is_set():
-            pod.pod_readiness_time = end_time - start_time
-        return pod
-
     def replace_service_selector(
         self, new_selectors: list[str], service_name: str, namespace: str
     ) -> Optional[dict[Any]]:
@@ -3217,7 +2848,7 @@ class KrknKubernetes:
         port_number: int = 5000,
         port_name: str = "flask",
         stats_route: str = "/stats",
-        privileged: bool = True
+        privileged: bool = True,
     ) -> ServiceHijacking:
         """
         Deploys a pod running the service-hijacking webservice
@@ -3271,7 +2902,7 @@ class KrknKubernetes:
                 config_map_name=config_map_name,
                 port_number=port_number,
                 stats_route=stats_route,
-                privileged=privileged
+                privileged=privileged,
             )
         )
 
@@ -3483,8 +3114,9 @@ class KrknKubernetes:
             )
 
         cmd = (
-            "for dir in /proc/[0-9]*; do [ $(cat $dir/cgroup | grep %s) ] && "
-            "echo ${dir/\/proc\//}; done" % pod_container_id  # noqa
+            f"for dir in /proc/[0-9]*; do grep -q {pod_container_id}  "
+            f"$dir/cgroup 2>/dev/null "
+            "&& echo ${dir/\/proc\//}; done"  # NOQA
         )
 
         pids = self.exec_cmd_in_pod(

krkn_lib/k8s/pod_monitor/__init__.py

@@ -0,0 +1,12 @@
+from .pod_monitor import (
+    select_and_monitor_by_label,
+    select_and_monitor_by_namespace_pattern_and_label,
+    select_and_monitor_by_name_pattern_and_namespace_pattern,
+)
+
+
+__all__ = [
+    "select_and_monitor_by_label",
+    "select_and_monitor_by_namespace_pattern_and_label",
+    "select_and_monitor_by_name_pattern_and_namespace_pattern",
+]