krkn-lib 5.1.11__py3-none-any.whl → 6.0.0__py3-none-any.whl

krkn_lib/aws_tests/__init__.py

@@ -1 +1 @@
-from ..tests.base_test import *  # NOQA
+from ..tests.base_test import *  # NOQA

krkn_lib/elastic/krkn_elastic.py

@@ -53,7 +53,9 @@ class KrknElastic:
                 ssl_show_warn=False,
             )
         except Exception as e:
-            self.safe_logger.error("Failed to initalize elasticsearch: %s" % e)
+            self.safe_logger.error(
+                "Failed to initialize elasticsearch: %s" % e
+            )
             raise e
 
     def upload_data_to_elasticsearch(self, item: dict, index: str = "") -> int:

krkn_lib/k8s/krkn_kubernetes.py

@@ -159,17 +159,23 @@ class KrknKubernetes:
                 os.environ["HTTP_PROXY"] = http_proxy
                 self.client_config.proxy = http_proxy
                 proxy_auth = urlparse(http_proxy)
-                auth_string = proxy_auth.username + ":" + proxy_auth.password
-                self.client_config.proxy_headers = urllib3.util.make_headers(
-                    proxy_basic_auth=auth_string
-                )
+                if (
+                    proxy_auth.username is not None
+                    and proxy_auth.password is not None
+                ):
+                    auth_string = (
+                        proxy_auth.username + ":" + proxy_auth.password
+                    )
+                    self.client_config.proxy_headers = (
+                        urllib3.util.make_headers(proxy_basic_auth=auth_string)
+                    )
 
             client.Configuration.set_default(self.client_config)
             self.watch_resource = watch.Watch()
             # Get the logger for the kubernetes client
-            kubernetes_logger = logging.getLogger('kubernetes')
+            kubernetes_logger = logging.getLogger("kubernetes")
 
-            # Set the logging level to a higher level than DEBUG, 
+            # Set the logging level to a higher level than DEBUG,
             # such as INFO, WARNING, or ERROR
             # This will effectively disable DEBUG level messages.
             kubernetes_logger.setLevel(logging.INFO)
@@ -185,7 +191,7 @@ class KrknKubernetes:
         on other distributions
 
         *** IT MUST BE CONSIDERED A PRIVATE METHOD (CANNOT USE
-        *** DOUBLE UNDERSCORE TO MANTAIN IT VISIBLE ON SUB-CLASSES)
+        *** DOUBLE UNDERSCORE TO MAINTAIN IT VISIBLE ON SUB-CLASSES)
         *** USED IN KrknKubernetes and KrknOpenshift TO AUTODETECT
         *** THE CLUSTER TYPE
 
@@ -237,7 +243,10 @@ class KrknKubernetes:
             minor_version = api_response.minor
             return major_version + "." + minor_version
         except ApiException as e:
-            print("Exception when calling VersionApi->get_code: %s\n" % e)
+            logging.error(
+                "Exception when calling VersionApi->get_code: %s", str(e)
+            )
+            raise e
 
     def get_host(self) -> str:
         """
@@ -874,7 +883,7 @@ class KrknKubernetes:
             services.append(serv.metadata.name)
         return services
 
-    # Outputs a json blob with informataion about all pods in a given namespace
+    # Outputs a json blob with information about all pods in a given namespace
     def get_all_pod_info(
         self,
         namespace: str = "default",
@@ -978,7 +987,7 @@ class KrknKubernetes:
         :param command: command parameters list or full command string
             if the command must be piped to `bash -c`
             (in that case `base_command` parameter
-            must is omitted`)
+            must be omitted`)
         :param pod_name: pod where the command must be executed
         :param namespace: namespace of the pod
         :param container: container where the command
@@ -1038,7 +1047,7 @@ class KrknKubernetes:
         :param command: command parameters list or full command string
             if the command must be piped to `bash -c`
             (in that case `base_command` parameter
-            must is omitted`)
+            must be omitted`)
         :param pod_name: pod where the command must be executed
         :param namespace: namespace of the pod
         :param container: container where the command
@@ -1093,7 +1102,7 @@ class KrknKubernetes:
                 )
         except Exception as e:
             raise e
-        # apparently stream API doesn't rise an Exception
+        # apparently stream API doesn't raise an Exception
         # if the command fails to be executed
 
         if "OCI runtime exec failed" in ret:
@@ -1388,6 +1397,311 @@ class KrknKubernetes:
                 str(e),
             )
 
+    def get_vm(self, name: str, namespace: str) -> Optional[Dict]:
+        """
+        Get a Virtual Machine by name and namespace.
+
+        :param name: Name of the VM to retrieve
+        :param namespace: Namespace of the VM
+        :return: The VM object if found, None otherwise
+        """
+        try:
+            vm = self.custom_object_client.get_namespaced_custom_object(
+                group="kubevirt.io",
+                version="v1",
+                namespace=namespace,
+                plural="virtualmachines",
+                name=name,
+            )
+            return vm
+        except ApiException as e:
+            if e.status == 404:
+                logging.warning(
+                    f"VM {name} not found in namespace {namespace}"
+                )
+                return None
+            else:
+                logging.error(f"Error getting VM {name}: {e}")
+                raise
+        except Exception as e:
+            logging.error(f"Unexpected error getting VM {name}: {e}")
+            raise
+
+    def get_vmi(self, name: str, namespace: str) -> Optional[Dict]:
+        """
+        Get a Virtual Machine Instance by name and namespace.
+
+        :param name: Name of the VMI to retrieve
+        :param namespace: Namespace of the VMI
+        :return: The VMI object if found, None otherwise
+        """
+        try:
+            vmi = self.custom_object_client.get_namespaced_custom_object(
+                group="kubevirt.io",
+                version="v1",
+                namespace=namespace,
+                plural="virtualmachineinstances",
+                name=name,
+            )
+            return vmi
+        except ApiException as e:
+            if e.status == 404:
+                logging.warning(
+                    f"VMI {name} not found in namespace {namespace}"
+                )
+                return None
+            else:
+                logging.error(f"Error getting VMI {name}: {e}")
+                raise
+        except Exception as e:
+            logging.error(f"Unexpected error getting VMI {name}: {e}")
+            raise
+
+    def get_vmis(self, regex_name: str, namespace: str) -> Optional[Dict]:
+        """
+        Get a Virtual Machine Instance by name and namespace.
+
+        :param name: Name of the VMI to retrieve
+        :param namespace: Namespace of the VMI
+        :return: The VMI object if found, None otherwise
+        """
+        try:
+            vmis_list = []
+            namespaces = self.list_namespaces_by_regex(namespace)
+            for namespace in namespaces:
+                vmis = self.custom_object_client.list_namespaced_custom_object(
+                    group="kubevirt.io",
+                    version="v1",
+                    namespace=namespace,
+                    plural="virtualmachineinstances",
+                )
+
+                for vmi in vmis.get("items"):
+                    vmi_name = vmi.get("metadata", {}).get("name")
+                    match = re.match(regex_name, vmi_name)
+                    if match:
+                        vmis_list.append(vmi)
+        except ApiException as e:
+            if e.status == 404:
+                logging.warning(
+                    f"VMI {regex_name} not found in namespace {namespace}"
+                )
+                return []
+            else:
+                logging.error(f"Error getting VMI {regex_name}: {e}")
+                raise
+        except Exception as e:
+            logging.error(f"Unexpected error getting VMI {regex_name}: {e}")
+            raise
+        return vmis_list
+
+    def create_vmi(
+        self, name: str, namespace: str, vm_name: str, vmi_body: dict
+    ) -> Optional[Dict]:
+        """
+        Create a Virtual Machine Instance by name and namespace.
+
+        :param name: Name of the VMI to create
+        :param namespace: Namespace of the VMI
+        :param vm_name: Name of the Virtual Machine to create the VMI from
+        :return: The VMI object if created, None otherwise
+        """
+        try:
+            vmi = self.custom_object_client.create_namespaced_custom_object(
+                group="kubevirt.io",
+                version="v1",
+                namespace=namespace,
+                plural="virtualmachineinstances",
+                body=vmi_body,
+            )
+            return vmi
+        except ApiException as e:
+            if e.status == 404:
+                logging.warning(
+                    f"VMI {name} not found in namespace {namespace}"
+                )
+                return None
+            else:
+                logging.error(f"Error creating VMI {name}: {e}")
+                raise
+        except Exception as e:
+            logging.error(f"Unexpected error creating VMI {name}: {e}")
+            raise
+
+    def patch_vm(
+        self, name: str, namespace: str, vm_body: dict
+    ) -> Optional[Dict]:
+        """
+        Patch a Virtual Machine by name and namespace.
+
+        :param name: Name of the VM to patch
+        :param namespace: Namespace of the VM
+        :param vm_body: Body of the VM to patch
+        :return: The VM object if patched, None otherwise
+        """
+        try:
+            vmi = self.custom_object_client.patch_namespaced_custom_object(
+                group="kubevirt.io",
+                version="v1",
+                namespace=namespace,
+                plural="virtualmachines",
+                name=name,
+                body=vm_body,
+            )
+            return vmi
+        except ApiException as e:
+            if e.status == 404:
+                logging.warning(
+                    f"VM {name} not found in namespace {namespace}"
+                )
+                return None
+            else:
+                logging.error(f"Error patching VM {name}: {e}")
+                raise
+        except Exception as e:
+            logging.error(f"Unexpected error patching VM {name}: {e}")
+            raise
+
+    def patch_vmi(
+        self, name: str, namespace: str, vmi_body: dict
+    ) -> Optional[Dict]:
+        """
+        Patch a Virtual Machine Instance by name and namespace.
+
+        :param name: Name of the VMI to patch
+        :param namespace: Namespace of the VMI
+        :param vmi_body: Body of the VMI to patch
+        :return: The VMI object if patched, None otherwise
+        """
+        try:
+            vmi = self.custom_object_client.patch_namespaced_custom_object(
+                group="kubevirt.io",
+                version="v1",
+                namespace=namespace,
+                plural="virtualmachineinstances",
+                name=name,
+                body=vmi_body,
+            )
+            return vmi
+        except ApiException as e:
+            if e.status == 404:
+                logging.warning(
+                    f"VMI {name} not found in namespace {namespace}"
+                )
+                return None
+            else:
+                logging.error(f"Error patching VMI {name}: {e}")
+                raise
+        except Exception as e:
+            logging.error(f"Unexpected error patching VMI {name}: {e}")
+            raise
+
+    def get_vms(self, regex_name: str, namespace: str) -> Optional[Dict]:
+        """
+        Get a Virtual Machine by name and namespace.
+
+        :param name: Name of the VM to retrieve
+        :param namespace: Namespace of the VM
+        :return: The VM object if found, None otherwise
+        """
+        try:
+            vms_list = []
+            namespaces = self.list_namespaces_by_regex(namespace)
+            for namespace in namespaces:
+                vms = self.custom_object_client.list_namespaced_custom_object(
+                    group="kubevirt.io",
+                    version="v1",
+                    namespace=namespace,
+                    plural="virtualmachines",
+                )
+
+                for vm in vms.get("items"):
+                    vm_name = vm.get("metadata", {}).get("name")
+                    match = re.match(regex_name, vm_name)
+                    if match:
+                        vms_list.append(vm)
+            return vms_list
+        except ApiException as e:
+            if e.status == 404:
+                logging.warning(
+                    f"VM {regex_name} not found in namespace {namespace}"
+                )
+                return []
+            else:
+                logging.error(f"Error getting VM {regex_name}: {e}")
+                raise
+        except Exception as e:
+            logging.error(f"Unexpected error getting VM {regex_name}: {e}")
+            raise
+
+    def get_snapshot(self, name: str, namespace: str) -> Optional[Dict]:
+        """
+        Get a Snapshot by name and namespace.
+
+        :param name: Name of the Snapshot to retrieve
+        :param namespace: Namespace of the Snapshot
+        :return: The Snapshot object if found, None otherwise
+        """
+        try:
+            snapshot = self.custom_object_client.get_namespaced_custom_object(
+                group="snapshot.kubevirt.io",
+                version="v1beta1",
+                namespace=namespace,
+                plural="virtualmachinesnapshots",
+                name=name,
+            )
+            return snapshot
+        except ApiException as e:
+            if e.status == 404:
+                logging.warning(
+                    f"SnapShot {name} not found in namespace {namespace}"
+                )
+                return None
+            else:
+                logging.error(f"Error getting snapshot {name}: {e}")
+                raise
+        except Exception as e:
+            logging.error(f"Unexpected error getting snapshot {name}: {e}")
+            raise
+
+    def create_snapshot(
+        self, name: str, namespace: str, vm_name: str
+    ) -> Optional[Dict]:
+        """
+        Create a Snapshot by name and namespace.
+
+        :param name: Name of the Snapshot to create
+        :param namespace: Namespace of the Snapshot
+        :param vm_name: Name of the Virtual Machine to create the Snapshot from
+        :return: The Snapshot object if created, None otherwise
+        """
+        try:
+            file_loader = PackageLoader("krkn_lib.k8s", "templates")
+            env = Environment(loader=file_loader, autoescape=True)
+            snapshot_template = env.get_template("snapshot.j2")
+            ss_body = yaml.safe_load(
+                snapshot_template.render(
+                    name=name, namespace=namespace, vm_name=vm_name
+                )
+            )
+            snapshot = (
+                self.custom_object_client.create_namespaced_custom_object(
+                    group="snapshot.kubevirt.io",
+                    version="v1beta1",
+                    namespace=namespace,
+                    plural="virtualmachinesnapshots",
+                    body=ss_body,
+                )
+            )
+            return snapshot
+        except ApiException as e:
+
+            logging.error(f"Error creating Snapshot {name}: {e}")
+            raise
+        except Exception as e:
+            logging.error(f"Unexpected error creating Snapshot {name}: {e}")
+            raise
+
     def get_job_status(
         self, name: str, namespace: str = "default"
     ) -> client.V1Job:
@@ -1410,6 +1724,80 @@ class KrknKubernetes:
             )
             raise
 
+    def delete_vm(self, name: str, namespace: str) -> Optional[Dict]:
+        """
+        Delete a Virtual Machine by name and namespace.
+
+        :param name: Name of the VM to delete
+        :param namespace: Namespace of the VM
+        :return: The VM object if found, None otherwise
+        """
+        try:
+            return self.custom_object_client.delete_namespaced_custom_object(
+                group="kubevirt.io",
+                version="v1",
+                namespace=namespace,
+                plural="virtualmachines",
+                name=name,
+            )
+        except ApiException as e:
+            if e.status == 404:
+                logging.warning(
+                    f"VM {name} not found in namespace {namespace}"
+                )
+                return None
+            else:
+                logging.error(f"Error deleting VM {name}: {e}")
+                raise
+        except Exception as e:
+            logging.error(f"Error deleting VM {name}: {e}")
+            raise
+
+    def delete_vmi(self, vm_name: str, namespace: str):
+        """
+        Delete a Virtual Machine Instance to simulate a VM outage.
+
+        :param vm_name: Name of the VMI to delete
+        :param namespace: Namespace of the VMI
+        :return: 0 for success, 1 for failure
+        """
+        logging.info(
+            f"Injecting chaos: Deleting VMI {vm_name} in namespace {namespace}"
+        )
+        try:
+            self.custom_object_client.delete_namespaced_custom_object(
+                group="kubevirt.io",
+                version="v1",
+                namespace=namespace,
+                plural="virtualmachineinstances",
+                name=vm_name,
+            )
+        except ApiException as e:
+            if e.status == 404:
+                logging.warning(f"VMI {vm_name} not found during deletion")
+                return 1
+            else:
+                logging.error(f"API error during VMI deletion: {e}")
+                return 1
+
+    def delete_snapshot(self, snapshot_name: str, namespace: str):
+        """Helper method to delete any snapshot created by the scenario."""
+        logging.info(f"Deleting snapshot '{snapshot_name}'...")
+        try:
+            self.custom_object_client.delete_namespaced_custom_object(
+                group="snapshot.kubevirt.io",
+                version="v1beta1",
+                namespace=namespace,
+                plural="virtualmachinesnapshots",
+                name=snapshot_name,
+            )
+            logging.info(f"Snapshot '{snapshot_name}' deleted successfully.")
+        except Exception as e:
+            logging.warning(
+                "Failed to delete snapshot, "
+                f"might have been already deleted: {e}"
+            )
+
     def monitor_nodes(
         self,
     ) -> (bool, list[str]):
@@ -1432,6 +1820,7 @@ class KrknKubernetes:
                     str(e),
                 )
                 raise e
+            node_ready_status = "False"
             for condition in node_info.status.conditions:
                 if condition.type == "KernelDeadlock":
                     node_kerneldeadlock_status = condition.status
@@ -2005,7 +2394,7 @@ class KrknKubernetes:
                         )
 
                         path = f"/api/{api_version}/{resource.name}"
-                        (data) = self.api_client.call_api(
+                        data = self.api_client.call_api(
                             path,
                             "GET",
                             path_params,
@@ -2168,7 +2557,6 @@ class KrknKubernetes:
                 else:
                     node_info.nodes_type = "unknown"
 
-                node_info.architecture = node.status.node_info.architecture
                 node_info.architecture = node.status.node_info.architecture
                 node_info.kernel_version = node.status.node_info.kernel_version
                 node_info.kubelet_version = (
@@ -2255,7 +2643,7 @@ class KrknKubernetes:
             sequential number of the archive assigned to the worker
             and the extension tar.b64
         :param queue: the queue from which the sequential
-            number wil be popped
+            number will be popped
         :param queue_size: total size of the queue
         :param downloaded_file_list: the list of
             archive number and local filename  downloaded
@@ -2377,7 +2765,7 @@ class KrknKubernetes:
             where the temporary archive
             will be stored (will be deleted once the download
             terminates, must be writable
-            and must have enough space to temporarly store the archive)
+            and must have enough space to temporarily store the archive)
         :param target_path: the path that will be archived
             and downloaded from the container
         :param archive_files_prefix: prefix string that will be added
@@ -2640,7 +3028,7 @@ class KrknKubernetes:
             ["application/json"]
         )
         try:
-            (data) = self.api_client.call_api(
+            data = self.api_client.call_api(
                 path,
                 "POST",
                 path_params,
@@ -2881,7 +3269,7 @@ class KrknKubernetes:
             default 5000
         :param port_name: the port name if the Service is pointing to
             a string name instead of a port number
-        :param stats_route: overrides the defautl route where the stats
+        :param stats_route: overrides the default route where the stats
             action will be mapped, change it only if you have a /stats
             route in your test_plan
         :return: a structure containing all the infos of the
@@ -2946,7 +3334,7 @@ class KrknKubernetes:
 
     def service_exists(self, service_name: str, namespace: str) -> bool:
         """
-        Checks wheter a kubernetes Service exist or not
+        Checks whether a kubernetes Service exist or not
         :param service_name: the name of the service to check
         :param namespace: the namespace where the service should exist
         :return: True if the service exists, False if not
@@ -3059,7 +3447,7 @@ class KrknKubernetes:
             ["application/json"]
         )
         path = f"/api/v1/nodes/{node_name}/proxy/stats/summary"
-        (data) = self.api_client.call_api(
+        data = self.api_client.call_api(
             path,
             "GET",
             path_params,

krkn_lib/k8s/pod_monitor/__init__.py

@@ -1,10 +1,9 @@
 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,
+    select_and_monitor_by_namespace_pattern_and_label,
 )
 
-
 __all__ = [
     "select_and_monitor_by_label",
     "select_and_monitor_by_namespace_pattern_and_label",