krkn-lib 5.0.2__py3-none-any.whl → 5.1.1__py3-none-any.whl

krkn_lib/k8s/pods_monitor_pool.py

@@ -26,7 +26,7 @@ class PodsMonitorPool:
         self.events: list[Event] = []
 
     def select_and_monitor_by_label(
-        self, label_selector: str, max_timeout: int
+        self, label_selector: str, field_selector: str, max_timeout: int
     ):
         """
         Pushes into the pool a monitoring thread for all the pods identified
@@ -47,18 +47,23 @@ class PodsMonitorPool:
         event = Event()
         self.events.append(event)
         pods_and_namespaces = self.krkn_lib.select_pods_by_label(
-            label_selector=label_selector
+            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, max_timeout: int
+        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
@@ -74,6 +79,7 @@ class PodsMonitorPool:
             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
@@ -90,6 +96,7 @@ class PodsMonitorPool:
             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,
             )
         )
 
@@ -98,6 +105,7 @@ class PodsMonitorPool:
                 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,
             )
@@ -109,6 +117,7 @@ class PodsMonitorPool:
         self,
         namespace_pattern: str,
         label_selector: str,
+        field_selector: str = None,
         max_timeout=30,
     ):
         """
@@ -138,6 +147,7 @@ class PodsMonitorPool:
             self.krkn_lib.select_pods_by_namespace_pattern_and_label(
                 namespace_pattern=namespace_pattern,
                 label_selector=label_selector,
+                field_selector=field_selector,
             )
         )
 
@@ -146,6 +156,7 @@ class PodsMonitorPool:
                 namespace_pattern=namespace_pattern,
                 label_selector=label_selector,
                 pods_and_namespaces=pods_and_namespaces,
+                field_selector=field_selector,
                 max_timeout=max_timeout,
                 event=event,
             )

krkn_lib/k8s/templates/node_exec_pod.j2

@@ -19,7 +19,12 @@ spec:
     - mountPath: /run/dbus/system_bus_socket
       name: dbus
       readOnly: true
+    - name: host
+      mountPath: /host      
   volumes:
   - name: dbus
     hostPath:
-      path: /run/dbus/system_bus_socket
+      path: /run/dbus/system_bus_socket
+  - name: host
+    hostPath:
+      path: /      

krkn_lib/models/elastic/models.py

@@ -1,7 +1,6 @@
 import datetime
 
 from elasticsearch_dsl import (
-    Boolean,
     Date,
     Document,
     Float,
@@ -10,6 +9,7 @@ from elasticsearch_dsl import (
     Keyword,
     Nested,
     Text,
+    Boolean,
 )
 
 from krkn_lib.models.telemetry import ChaosRunTelemetry
@@ -94,7 +94,7 @@ class ElasticNodeInfo(InnerDoc):
     count = Integer()
     architecture = Text()
     instance_type = Text()
-    node_type = Text()
+    nodes_type = Text()
     kernel_version = Text()
     kubelet_version = Text()
     os_version = Text()
@@ -114,6 +114,15 @@ class ElasticHealthChecks(InnerDoc):
     end_timestamp = Date()
     duration = Float()
 
+class ElasticVirtChecks(InnerDoc):
+    vm_name = Text()
+    ip_address = Text()
+    namespace = Text()
+    node_name = Text()
+    status = Boolean()
+    start_timestamp = Date()
+    end_timestamp = Date()
+    duration = Float()
 
 class ElasticChaosRunTelemetry(Document):
     scenarios = Nested(ElasticScenarioTelemetry, multi=True)
@@ -127,10 +136,11 @@ class ElasticChaosRunTelemetry(Document):
     cloud_type = Text()
     cluster_version = Text()
     major_version = Text()
+    build_url = Text()
     job_status = Boolean()
     run_uuid = Text(fields={"keyword": Keyword()})
     health_checks = Nested(ElasticHealthChecks, multi=True)
-
+    virt_checks = Nested(ElasticVirtChecks, multi=True)
     class Index:
         name = "chaos_run_telemetry"
 
@@ -188,6 +198,7 @@ class ElasticChaosRunTelemetry(Document):
         self.node_summary_infos = [
             ElasticNodeInfo(
                 count=info.count,
+                nodes_type=info.nodes_type,
                 architecture=info.architecture,
                 instance_type=info.instance_type,
                 kernel_version=info.kernel_version,
@@ -204,7 +215,7 @@ class ElasticChaosRunTelemetry(Document):
             chaos_run_telemetry.kubernetes_objects_count
         )
         self.network_plugins = chaos_run_telemetry.network_plugins
-
+        
         if chaos_run_telemetry.health_checks:
             self.health_checks = [
                 ElasticHealthChecks(
@@ -223,6 +234,27 @@ class ElasticChaosRunTelemetry(Document):
             ]
         else:
             self.health_checks = None
+        
+        if chaos_run_telemetry.virt_checks:
+            self.virt_checks = [
+                ElasticVirtChecks(
+                    vm_name=info.vm_name,
+                    ip_address=info.ip_address,
+                    namespace=info.namespace,
+                    node_name=info.node_name,
+                    status=info.status,
+                    start_timestamp=datetime.datetime.fromisoformat(
+                        str(info.start_timestamp)
+                    ),
+                    end_timestamp=datetime.datetime.fromisoformat(
+                        str(info.end_timestamp)
+                    ),
+                    duration=info.duration,
+                )
+                for info in chaos_run_telemetry.virt_checks
+            ]
+        else:
+            self.virt_checks = None
 
         self.timestamp = chaos_run_telemetry.timestamp
         self.total_node_count = chaos_run_telemetry.total_node_count
@@ -232,3 +264,4 @@ class ElasticChaosRunTelemetry(Document):
         self.run_uuid = chaos_run_telemetry.run_uuid
         self.job_status = chaos_run_telemetry.job_status
         self.major_version = chaos_run_telemetry.major_version
+        self.build_url = chaos_run_telemetry.build_url

krkn_lib/models/k8s/models.py

@@ -77,6 +77,10 @@ class Container:
     """
     Container Ready status
     """
+    containerId: str = ""
+    """
+    Container Id
+    """
 
 
 @dataclass(frozen=True, order=False)

krkn_lib/models/telemetry/models.py

@@ -421,6 +421,55 @@ class HealthCheck:
             self.end_timestamp = json_dict["end_timestamp"]
             self.duration = json_dict["duration"]
 
+@dataclass(order=False)
+class VirtCheck:
+    """
+    Virt checks Response for VMI endpoints
+    """
+
+    vm_name: str
+    """
+    Vm name
+    """
+    ip_address: str
+    """
+    Vm ip address
+    """
+    namespace: str
+    """
+    Namespace
+    """
+    node_name: str
+    """
+    Node Name
+    """
+    status: bool
+    """
+    Status of VMI ssh connection
+    """
+    start_timestamp: str
+    """
+    start time stamp of virt check
+    """
+    end_timestamp: str
+    """
+    end time stamp of virt check
+    """
+    duration: float
+    """
+    Denotes the time between start time and end time
+    """
+
+    def __init__(self, json_dict: dict = None):
+        if json_dict is not None:
+            self.node_name = json_dict["node_name"]
+            self.ip_address = json_dict["ip_address"]
+            self.namespace = json_dict["namespace"]
+            self.vm_name = json_dict["vm_name"]
+            self.status = json_dict.get("status",True)
+            self.start_timestamp = json_dict.get("start_timestamp","")
+            self.end_timestamp = json_dict.get("end_timestamp","")
+            self.duration = json_dict.get("duration","")
 
 @dataclass(order=False)
 class ChaosRunTelemetry:
@@ -485,10 +534,18 @@ class ChaosRunTelemetry:
     """
     Health checks of application endpoint
     """
+    virt_checks: list[VirtCheck] = None
+    """
+    Virt checks of VMIs
+    """
     job_status: bool = True
     """
     Overall job status, will take all scenario's exit status
     """
+    build_url: str = "manual"
+    """
+    Build url if run in CI
+    """
 
     def __init__(self, json_dict: any = None):
         self.scenarios = list[ScenarioTelemetry]()
@@ -500,6 +557,7 @@ class ChaosRunTelemetry:
             "%Y-%m-%dT%H:%M:%SZ"
         )
         self.health_checks = list[HealthCheck]()
+        self.virt_checks = list[VirtCheck]()
         if json_dict is not None:
             scenarios = json_dict.get("scenarios")
             if scenarios is None or isinstance(scenarios, list) is False:
@@ -527,7 +585,13 @@ class ChaosRunTelemetry:
                 if json_dict.get("health_checks")
                 else None
             )
+            self.virt_checks = (
+                [VirtCheck(k) for k in json_dict.get("virt_checks")]
+                if json_dict.get("virt_checks")
+                else None
+            )
             self.job_status = json_dict.get("job_status")
+            self.build_url = json_dict.get("build_url")
 
     def to_json(self) -> str:
         return json.dumps(self, default=lambda o: o.__dict__, indent=4)

krkn_lib/prometheus/krkn_prometheus.py

@@ -50,7 +50,7 @@ class KrknPrometheus:
         query: str,
         start_time: datetime = None,
         end_time: datetime = None,
-        granularity: int = 10,
+        granularity: int = 10
     ) -> list[dict[str:any]]:
         """
         Executes a query to the Prometheus API in PromQL languag,

krkn_lib/telemetry/k8s/krkn_telemetry_kubernetes.py

@@ -100,12 +100,11 @@ class KrknTelemetryKubernetes:
         node_infos, taints = self.__kubecli.get_nodes_infos()
         chaos_telemetry.node_summary_infos = node_infos
         chaos_telemetry.cluster_version = self.__kubecli.get_version()
-
         chaos_telemetry.major_version = chaos_telemetry.cluster_version[1:5]
         chaos_telemetry.node_taints = taints
+        chaos_telemetry.build_url = utils.get_ci_job_url()
         for info in node_infos:
             chaos_telemetry.total_node_count += info.count
-
         chaos_telemetry.job_status = True
         for scenario in chaos_telemetry.scenarios:
             if scenario.exit_status > 0:

krkn_lib/tests/base_test.py

@@ -491,6 +491,13 @@ class BaseTest(unittest.TestCase):
         thread.daemon = True
         thread.start()
 
+    def background_delete_ns(self, namespace: str):
+        thread = threading.Thread(
+            target=self.lib_k8s.delete_namespace, args=(namespace,)
+        )
+        thread.daemon = True
+        thread.start()
+
     def get_ChaosRunTelemetry_json(self, run_uuid: str) -> dict:
         example_data = {
             "scenarios": [
@@ -542,6 +549,7 @@ class BaseTest(unittest.TestCase):
                     "kernel_version": "5.4.0-66-generic",
                     "kubelet_version": "v2.1.2",
                     "os_version": "Linux",
+                    "nodes_type": "master"
                 }
             ],
             "node_taints": [
@@ -564,6 +572,37 @@ class BaseTest(unittest.TestCase):
                     "duration": 259.113742,
                 }
             ],
+            "virt_checks": [
+            {
+                "node_name": "h03-r660",
+                "namespace": "benchmark-runner",
+                "ip_address": "0.0.0.0",
+                "vm_name": "windows-vm-50",
+                "status": True,
+                "start_timestamp": "2025-03-12T14:57:34.555878",
+                "end_timestamp": "2025-03-12T14:57:54.904352",
+                "duration": 20.348474
+            },
+            {
+                "node_name": "h27-r660",
+                "namespace": "benchmark-runner",
+                "vm_name": "windows-vm-51",
+                "ip_address": "0.0.0.1",
+                "status": True,
+                "start_timestamp": "2025-03-12T14:57:34.759105",
+                "end_timestamp": "2025-03-12T14:57:54.904352",
+                "duration": 20.145247
+            },
+            {
+                "node_name": "h10-r660",
+                "namespace": "benchmark-runner",
+                "vm_name": "windows-vm-52",
+                "ip_address": "0.0.0.2",
+                "status": False,
+                "start_timestamp": "2025-03-12T14:57:35.308957",
+                "end_timestamp": "2025-03-12T14:57:54.904352",
+                "duration": 19.595395
+            }],
             "total_node_count": 3,
             "cloud_infrastructure": "AWS",
             "cloud_type": "EC2",
@@ -571,5 +610,6 @@ class BaseTest(unittest.TestCase):
             "cluster_version": "4.18.0-0.nightly-202491014",
             "major_verison": "4.18",
             "job_status": True,
+            "build_url": "https://github.com/krkn-chaos/krkn-lib/actions/runs/16724993547",  # NOQA
         }
         return example_data

krkn_lib/tests/test_krkn_elastic_models.py

@@ -1,9 +1,9 @@
-import datetime
 import uuid
 
 from krkn_lib.models.elastic.models import ElasticChaosRunTelemetry
 from krkn_lib.models.telemetry import ChaosRunTelemetry
 from krkn_lib.tests import BaseTest
+import datetime
 
 
 class TestKrknElasticModels(BaseTest):
@@ -149,6 +149,9 @@ class TestKrknElasticModels(BaseTest):
         self.assertEqual(
             elastic_telemetry.node_summary_infos[0].instance_type, "m2i.xlarge"
         )
+        self.assertEqual(
+            elastic_telemetry.node_summary_infos[0].nodes_type, "master"
+        )
         self.assertEqual(
             elastic_telemetry.node_summary_infos[0].kernel_version,
             "5.4.0-66-generic",
@@ -211,10 +214,39 @@ class TestKrknElasticModels(BaseTest):
             elastic_telemetry.health_checks[0].duration, 259.113742
         )
 
+        # virt_checks
+        self.assertEqual(len(elastic_telemetry.virt_checks), 3)
+        self.assertEqual(
+            elastic_telemetry.virt_checks[0].vm_name, "windows-vm-50"
+        )
+        self.assertEqual(
+            elastic_telemetry.virt_checks[0].ip_address, "0.0.0.0"
+        )
+        self.assertEqual(
+            elastic_telemetry.virt_checks[0].namespace, "benchmark-runner"
+        )
+        self.assertEqual(
+            elastic_telemetry.virt_checks[0].node_name, "h03-r660"
+        )
+
+        self.assertEqual(elastic_telemetry.virt_checks[0].status, True)
+        self.assertEqual(
+            elastic_telemetry.virt_checks[0].start_timestamp,
+            datetime.datetime.fromisoformat("2025-03-12T14:57:34.555878"),
+        )
+        self.assertEqual(
+            elastic_telemetry.virt_checks[0].end_timestamp,
+            datetime.datetime.fromisoformat("2025-03-12T14:57:54.904352"),
+        )
+        self.assertEqual(
+            elastic_telemetry.virt_checks[0].duration, 20.348474
+        )
+
         self.assertEqual(elastic_telemetry.total_node_count, 3)
         self.assertEqual(elastic_telemetry.cloud_infrastructure, "AWS")
         self.assertEqual(elastic_telemetry.cloud_type, "EC2")
         self.assertEqual(elastic_telemetry.run_uuid, run_uuid)
+        self.assertEqual(elastic_telemetry.build_url, "https://github.com/krkn-chaos/krkn-lib/actions/runs/16724993547")
 
     def test_ElasticChaosRunTelemetry(self):
         run_uuid = str(uuid.uuid4())

krkn_lib/tests/test_krkn_kubernetes_check.py

@@ -2,10 +2,9 @@ import logging
 import time
 import unittest
 
-from kubernetes.client import ApiException
-
-from krkn_lib.k8s import ApiRequestException
 from krkn_lib.tests import BaseTest
+from krkn_lib.k8s import ApiRequestException
+from kubernetes.client import ApiException
 
 
 class KrknKubernetesTestsCheck(BaseTest):

krkn_lib/tests/test_krkn_kubernetes_create.py

@@ -1,12 +1,10 @@
 import logging
-import tempfile
 import unittest
-
 import yaml
-from jinja2 import Environment, FileSystemLoader
-from kubernetes.client import ApiException
-
+import tempfile
 from krkn_lib.tests import BaseTest
+from kubernetes.client import ApiException
+from jinja2 import Environment, FileSystemLoader
 
 
 class KrknKubernetesTestsCreate(BaseTest):

krkn_lib/tests/test_krkn_kubernetes_delete.py

@@ -2,10 +2,9 @@ import logging
 import time
 import unittest
 
-from kubernetes.client import ApiException
-
-from krkn_lib.k8s import ApiRequestException
 from krkn_lib.tests import BaseTest
+from krkn_lib.k8s import ApiRequestException
+from kubernetes.client import ApiException
 
 
 class KrknKubernetesTestsDelete(BaseTest):

krkn_lib/tests/test_krkn_kubernetes_exec.py

@@ -124,7 +124,7 @@ class KrknKubernetesTestsExec(BaseTest):
             self.fail(f"exception on node command execution: {e}")
 
     def test_download_folder_from_pod_as_archive(self):
-        workdir_basepath = os.getenv("TEST_WORKDIR")
+        workdir_basepath = os.getenv("TEST_WORKDIR", "/tmp")
         workdir = self.get_random_string(10)
         test_workdir = os.path.join(workdir_basepath, workdir)
         os.mkdir(test_workdir)

krkn_lib/tests/test_krkn_kubernetes_get.py

@@ -1,16 +1,15 @@
 import logging
-import os
 import random
 import re
 import time
+import os
 import unittest
 
-from kubernetes import config
-from kubernetes.client import ApiException
-
-from krkn_lib.k8s import ApiRequestException, KrknKubernetes
 from krkn_lib.models.telemetry import ChaosRunTelemetry
 from krkn_lib.tests import BaseTest
+from kubernetes import config
+from krkn_lib.k8s import ApiRequestException, KrknKubernetes
+from kubernetes.client import ApiException
 
 
 class KrknKubernetesTestsGet(BaseTest):
@@ -55,8 +54,22 @@ class KrknKubernetesTestsGet(BaseTest):
         # test with label_selector filter
         results = self.lib_k8s.get_all_pods("random=%s" % random_label)
         self.assertTrue(len(results) == 1)
+        self.assertEqual(results[0][1], namespace)
         self.assertEqual(results[0][0], "kraken-deployment")
+        self.wait_pod("kraken-deployment", namespace)
+        results = self.lib_k8s.get_all_pods(
+            "random=%s" % random_label, field_selector="status.phase=Running"
+        )
+        print("resuls" + str(results))
+        self.assertTrue(len(results) == 1)
         self.assertEqual(results[0][1], namespace)
+        self.assertEqual(results[0][0], "kraken-deployment")
+
+        results = self.lib_k8s.get_all_pods(
+            field_selector="status.phase=Running"
+        )
+        self.assertTrue(len(results) >= 1)
+
         self.pod_delete_queue.put(["kraken-deployment", namespace])
 
     def test_get_pod_log(self):
@@ -135,6 +148,9 @@ class KrknKubernetesTestsGet(BaseTest):
             self.assertIsNotNone(info.podIP)
             self.assertIsNotNone(info.nodeName)
             self.assertIsNotNone(info.containers)
+
+            info = self.lib_k8s.get_pod_info("test1", namespace)
+            self.assertIsNone(info)
         except Exception as e:
             logging.error("test raised exception {0}".format(str(e)))
             self.assertTrue(False)
@@ -247,6 +263,89 @@ class KrknKubernetesTestsGet(BaseTest):
         with self.assertRaises(Exception):
             ip_address = self.lib_k8s.get_node_ip("not_existing")
 
+    def test_get_pod_container_id(self):
+        namespace = "test-cid-" + self.get_random_string(10)
+        name = "test-name-" + self.get_random_string(10)
+        self.deploy_namespace(namespace, [])
+        self.deploy_fedtools(namespace=namespace, name=name)
+        self.wait_pod(name, namespace)
+        container_ids = self.lib_k8s.get_container_ids(
+            pod_name=name, namespace=namespace
+        )
+        self.assertTrue(len(container_ids) > 0)
+        container_ids = self.lib_k8s.get_container_ids(
+            pod_name="do_not_exists", namespace="do_not_exists"
+        )
+        self.assertTrue(len(container_ids) == 0)
+
+    def test_get_pod_pids(self):
+        namespace = "test-cid-" + self.get_random_string(10)
+        base_pod_name = "test-name-" + self.get_random_string(10)
+        target_pod_name = "test-name-" + self.get_random_string(10)
+
+        self.deploy_namespace(namespace, [])
+        self.deploy_fedtools(namespace=namespace, name=base_pod_name)
+        self.deploy_fedtools(namespace=namespace, name=target_pod_name)
+
+        self.wait_pod(base_pod_name, namespace)
+        self.wait_pod(target_pod_name, namespace)
+
+        container_id = self.lib_k8s.get_container_ids(
+            pod_name=target_pod_name, namespace=namespace
+        )
+        pids = self.lib_k8s.get_pod_pids(
+            base_pod_name,
+            namespace,
+            base_pod_name,
+            target_pod_name,
+            namespace,
+            container_id[0],
+        )
+
+        self.assertIsNotNone(pids)
+        self.assertTrue(isinstance(pids, list))
+        self.assertTrue(len(pids) > 0)
+
+        pids = self.lib_k8s.get_pod_pids(
+            base_pod_name,
+            namespace,
+            base_pod_name,
+            target_pod_name,
+            namespace,
+            "does_not_exist",
+        )
+        self.assertIsNone(pids)
+
+        with self.assertRaises(Exception):
+            _ = self.lib_k8s.get_pod_pids(
+                "does_not_exist",
+                namespace,
+                base_pod_name,
+                target_pod_name,
+                namespace,
+                container_id[0],
+            )
+
+        with self.assertRaises(Exception):
+            _ = self.lib_k8s.get_pod_pids(
+                base_pod_name,
+                namespace,
+                base_pod_name,
+                "does_not_exist",
+                namespace,
+                container_id[0],
+            )
+
+        with self.assertRaises(Exception):
+            _ = self.lib_k8s.get_pod_pids(
+                base_pod_name,
+                namespace,
+                "does_not_exist",
+                target_pod_name,
+                namespace,
+                container_id[0],
+            )
+
 
 if __name__ == "__main__":
     unittest.main()

krkn_lib/tests/test_krkn_kubernetes_list.py

@@ -70,6 +70,19 @@ class KrknKubernetesTestsList(BaseTest):
         pods = self.lib_k8s.list_pods(namespace=namespace)
         self.assertTrue(len(pods) == 1)
         self.assertIn("kraken-deployment", pods)
+
+        self.wait_pod(pods[0], namespace)
+
+        pods = self.lib_k8s.list_pods(
+            namespace=namespace, field_selector="status.phase=Running"
+        )
+        self.assertTrue(len(pods) == 1)
+        self.assertIn("kraken-deployment", pods)
+
+        pods = self.lib_k8s.list_pods(
+            namespace=namespace, field_selector="status.phase=Terminating"
+        )
+        self.assertTrue(len(pods) == 0)
         self.pod_delete_queue.put(["kraken-deployment", namespace])
 
     def test_list_ready_nodes(self):

krkn_lib/tests/test_krkn_kubernetes_misc.py

@@ -6,11 +6,11 @@ import time
 import unittest
 
 import yaml
-from kubernetes.client import ApiException
-from tzlocal import get_localzone
 
 from krkn_lib.models.krkn import HogConfig, HogType
 from krkn_lib.tests import BaseTest
+from tzlocal import get_localzone
+from kubernetes.client import ApiException
 
 
 class KrknKubernetesTestsMisc(BaseTest):