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

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

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/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,10 @@ 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
         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": [

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):

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_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):

krkn_lib/tests/test_krkn_kubernetes_models.py

@@ -1,10 +1,10 @@
+from krkn_lib.models.krkn import HogConfig, HogType
 from krkn_lib.models.k8s import (
     AffectedNode,
     AffectedNodeStatus,
     AffectedPod,
     PodsStatus,
 )
-from krkn_lib.models.krkn import HogConfig, HogType
 from krkn_lib.tests import BaseTest