qontract-reconcile 0.9.1rc298__py3-none-any.whl → 0.10.1.dev1203__py3-none-any.whl

reconcile/utils/oc.py

@@ -2,9 +2,9 @@ import copy
 import json
 import logging
 import os
+import pathlib
 import re
 import subprocess
-import tempfile
 import threading
 import time
 from collections.abc import (
@@ -17,14 +17,10 @@ from datetime import datetime
 from functools import wraps
 from subprocess import Popen
 from threading import Lock
-from typing import (
-    Any,
-    Optional,
-    Union,
-)
+from typing import Any
 
 import urllib3
-from kubernetes.client import (
+from kubernetes.client import (  # type: ignore[attr-defined]
     ApiClient,
     Configuration,
 )
@@ -55,6 +51,7 @@ from reconcile.utils.jump_host import (
 )
 from reconcile.utils.metrics import reconcile_time
 from reconcile.utils.oc_connection_parameters import OCConnectionParameters
+from reconcile.utils.openshift_resource import OpenshiftResource as OR
 from reconcile.utils.secret_reader import (
     SecretNotFound,
     SecretReader,
@@ -66,6 +63,13 @@ urllib3.disable_warnings()
 GET_REPLICASET_MAX_ATTEMPTS = 20
 
 
+oc_run_execution_counter = Counter(
+    name="oc_run_execution_counter",
+    documentation="Counts _run method executions per integration",
+    labelnames=["integration"],
+)
+
+
 class StatusCodeError(Exception):
     pass
 
@@ -130,6 +134,10 @@ class JobNotRunningError(Exception):
     pass
 
 
+class RequestEntityTooLargeError(Exception):
+    pass
+
+
 class OCDecorators:
     @classmethod
     def process_reconcile_time(cls, function):
@@ -156,7 +164,7 @@ class OCDecorators:
         @wraps(function)
         def wrapper(*args, **kwargs):
             result = function(*args, **kwargs)
-            msg = result[:-1] if isinstance(result, (list, tuple)) else result
+            msg = result[:-1] if isinstance(result, list | tuple) else result
 
             if not isinstance(msg, OCProcessReconcileTimeDecoratorMsg):
                 return result
@@ -166,10 +174,10 @@ class OCDecorators:
             time_spent = time.time() - commit_time
 
             try:
-                resource_kind = msg.resource["kind"]
-                resource_name = msg.resource["metadata"]["name"]
-                annotations = msg.resource["metadata"].get("annotations", {})
-            except KeyError as e:
+                resource_kind = msg.resource.kind
+                resource_name = msg.resource.name
+                annotations = msg.resource.annotations
+            except Exception as e:
                 logging.warning(f"Error processing metric: {e}")
                 return result
 
@@ -208,11 +216,11 @@ class OCDecorators:
 class OCProcessReconcileTimeDecoratorMsg:
     def __init__(
         self,
-        namespace,
-        resource,
-        server,
-        slow_oc_reconcile_threshold,
-        is_log_slow_oc_reconcile,
+        namespace: str,
+        resource: OR,
+        server: str | None,
+        slow_oc_reconcile_threshold: float,
+        is_log_slow_oc_reconcile: bool,
     ):
         self.namespace = namespace
         self.resource = resource
@@ -230,21 +238,17 @@ def equal_spec_template(t1: dict, t2: dict) -> bool:
     """Compare two spec.templates."""
     t1_copy = copy.deepcopy(t1)
     t2_copy = copy.deepcopy(t2)
-    try:
+    with suppress(KeyError):
         del t1_copy["metadata"]["labels"]["pod-template-hash"]
-    except KeyError:
-        pass
-    try:
+    with suppress(KeyError):
         del t2_copy["metadata"]["labels"]["pod-template-hash"]
-    except KeyError:
-        pass
     return t1_copy == t2_copy
 
 
 @dataclass
-class OCDeprecatedApiResource:
+class OCCliApiResource:
     """This class mimics kubernetes.dynamic.resource.Resource and it's used
-    To get Api Resources with the OCDeprecated client"""
+    To get Api Resources with the OCCli client"""
 
     kind: str
     group: str
@@ -254,23 +258,23 @@ class OCDeprecatedApiResource:
     @property
     def group_version(self):
         if self.group:
-            return "{}/{}".format(self.group, self.api_version)
+            return f"{self.group}/{self.api_version}"
         return self.api_version
 
 
-class OCDeprecated:  # pylint: disable=too-many-public-methods
+class OCCli:  # pylint: disable=too-many-public-methods
     def __init__(
         self,
-        cluster_name: Optional[str],
-        server: Optional[str],
-        token: Optional[str],
-        jh: Optional[Mapping[Any, Any]] = None,
-        settings: Optional[Mapping[Any, Any]] = None,
+        cluster_name: str | None,
+        server: str | None,
+        token: str | None,
+        jh: Mapping[Any, Any] | None = None,
+        settings: Mapping[Any, Any] | None = None,
         init_projects: bool = False,
         init_api_resources: bool = False,
         local: bool = False,
         insecure_skip_tls_verify: bool = False,
-        connection_parameters: Optional[OCConnectionParameters] = None,
+        connection_parameters: OCConnectionParameters | None = None,
     ):
         """
         As of now we have to conform with 2 ways to initialize this client:
@@ -309,10 +313,10 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
     def _init_old_without_types(
         self,
         cluster_name: str,
-        server: Optional[str],
-        token: Optional[str],
-        jh: Optional[Mapping[Any, Any]] = None,
-        settings: Optional[Mapping[Any, Any]] = None,
+        server: str | None,
+        token: str | None,
+        jh: Mapping[Any, Any] | None = None,
+        settings: Mapping[Any, Any] | None = None,
         init_projects: bool = False,
         init_api_resources: bool = False,
         local: bool = False,
@@ -366,6 +370,7 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
         self.api_resources_lock = threading.RLock()
         self.init_api_resources = init_api_resources
         self.api_resources = {}
+        self.projects = set()
         if self.init_api_resources:
             self.api_resources = self.get_api_resources()
 
@@ -375,7 +380,7 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
                 kind = "Project.project.openshift.io"
             else:
                 kind = "Namespace"
-            self.projects = [p["metadata"]["name"] for p in self.get_all(kind)["items"]]
+            self.projects = {p["metadata"]["name"] for p in self.get_all(kind)["items"]}
 
         self.slow_oc_reconcile_threshold = float(
             os.environ.get("SLOW_OC_RECONCILE_THRESHOLD", 600)
@@ -383,7 +388,7 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
 
         self.is_log_slow_oc_reconcile = os.environ.get(
             "LOG_SLOW_OC_RECONCILE", ""
-        ).lower() in ["true", "yes"]
+        ).lower() in {"true", "yes"}
 
     def _init(
         self,
@@ -438,6 +443,7 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
         self.api_resources_lock = threading.RLock()
         self.init_api_resources = init_api_resources
         self.api_resources = {}
+        self.projects = set()
         if self.init_api_resources:
             self.api_resources = self.get_api_resources()
 
@@ -447,7 +453,7 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
                 kind = "Project.project.openshift.io"
             else:
                 kind = "Namespace"
-            self.projects = [p["metadata"]["name"] for p in self.get_all(kind)["items"]]
+            self.projects = {p["metadata"]["name"] for p in self.get_all(kind)["items"]}
 
         self.slow_oc_reconcile_threshold = float(
             os.environ.get("SLOW_OC_RECONCILE_THRESHOLD", 600)
@@ -455,7 +461,7 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
 
         self.is_log_slow_oc_reconcile = os.environ.get(
             "LOG_SLOW_OC_RECONCILE", ""
-        ).lower() in ["true", "yes"]
+        ).lower() in {"true", "yes"}
 
     def whoami(self):
         return self._run(["whoami"])
@@ -477,9 +483,7 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
                 cmd.extend(["-n", namespace])
 
         if "labels" in kwargs:
-            labels_list = [
-                "{}={}".format(k, v) for k, v in kwargs.get("labels").items()
-            ]
+            labels_list = [f"{k}={v}" for k, v in kwargs.get("labels").items()]
 
             cmd.append("-l")
             cmd.append(",".join(labels_list))
@@ -527,7 +531,7 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
         ]
         self._run(cmd)
 
-    def _msg_to_process_reconcile_time(self, namespace, resource):
+    def _msg_to_process_reconcile_time(self, namespace: str, resource: OR):
         return OCProcessReconcileTimeDecoratorMsg(
             namespace=namespace,
             resource=resource,
@@ -550,53 +554,29 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
         result = self._run(cmd, stdin=json.dumps(template, sort_keys=True))
         return json.loads(result)["items"]
 
-    def release_mirror(self, from_release, to, to_release, dockerconfig):
-        with tempfile.NamedTemporaryFile() as fp:
-            content = json.dumps(dockerconfig)
-            fp.write(content.encode())
-            fp.seek(0)
-
-            cmd = [
-                "adm",
-                "--registry-config",
-                fp.name,
-                "release",
-                "mirror",
-                "--from",
-                from_release,
-                "--to",
-                to,
-                "--to-release-image",
-                to_release,
-                "--max-per-registry",
-                "1",
-            ]
-
-            self._run(cmd)
-
     @OCDecorators.process_reconcile_time
     def apply(self, namespace, resource):
         cmd = ["apply", "-n", namespace, "-f", "-"]
         self._run(cmd, stdin=resource.toJSON(), apply=True)
-        return self._msg_to_process_reconcile_time(namespace, resource.body)
+        return self._msg_to_process_reconcile_time(namespace, resource)
 
     @OCDecorators.process_reconcile_time
     def create(self, namespace, resource):
         cmd = ["create", "-n", namespace, "-f", "-"]
         self._run(cmd, stdin=resource.toJSON(), apply=True)
-        return self._msg_to_process_reconcile_time(namespace, resource.body)
+        return self._msg_to_process_reconcile_time(namespace, resource)
 
     @OCDecorators.process_reconcile_time
     def replace(self, namespace, resource):
         cmd = ["replace", "-n", namespace, "-f", "-"]
         self._run(cmd, stdin=resource.toJSON(), apply=True)
-        return self._msg_to_process_reconcile_time(namespace, resource.body)
+        return self._msg_to_process_reconcile_time(namespace, resource)
 
     @OCDecorators.process_reconcile_time
     def patch(self, namespace, kind, name, patch):
         cmd = ["patch", "-n", namespace, kind, name, "-p", json.dumps(patch)]
         self._run(cmd)
-        resource = {"kind": kind, "metadata": {"name": name}}
+        resource = OR({"kind": kind, "metadata": {"name": name}}, "", "")
         return self._msg_to_process_reconcile_time(namespace, resource)
 
     @OCDecorators.process_reconcile_time
@@ -611,7 +591,7 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
         if not cascade:
             cmd.append("--cascade=orphan")
         self._run(cmd)
-        resource = {"kind": kind, "metadata": {"name": name}}
+        resource = OR({"kind": kind, "metadata": {"name": name}}, "", "")
         return self._msg_to_process_reconcile_time(namespace, resource)
 
     @OCDecorators.process_reconcile_time
@@ -623,13 +603,12 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
         cmd = ["label"] + ns + [kind, name, overwrite_param]
         cmd.extend(added + removed)
         self._run(cmd)
-        resource = {"kind": kind, "metadata": {"name": name}}
+        resource = OR({"kind": kind, "metadata": {"name": name}}, "", "")
         return self._msg_to_process_reconcile_time(namespace, resource)
 
     def project_exists(self, name):
-        if self.init_projects:
-            return name in self.projects
-
+        if name in self.projects:
+            return True
         try:
             if self.is_kind_supported("Project"):
                 self.get(None, "Project.project.openshift.io", name)
@@ -654,7 +633,7 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
                 raise e
 
         # This return will be removed by the last decorator
-        resource = {"kind": "Namespace", "metadata": {"name": namespace}}
+        resource = OR({"kind": "Namespace", "metadata": {"name": namespace}}, "", "")
         return self._msg_to_process_reconcile_time(namespace, resource)
 
     @OCDecorators.process_reconcile_time
@@ -666,7 +645,7 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
         self._run(cmd)
 
         # This return will be removed by the last decorator
-        resource = {"kind": "Namespace", "metadata": {"name": namespace}}
+        resource = OR({"kind": "Namespace", "metadata": {"name": namespace}}, "", "")
         return self._msg_to_process_reconcile_time(namespace, resource)
 
     def get_group_if_exists(self, name):
@@ -725,7 +704,7 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
                     group_version = r[-3].split("/", 1)
                     group = "" if len(group_version) == 1 else group_version[0]
                     api_version = group_version[-1]
-                    obj = OCDeprecatedApiResource(kind, group, api_version, namespaced)
+                    obj = OCCliApiResource(kind, group, api_version, namespaced)
                     d = self.api_resources.setdefault(kind, [])
                     d.append(obj)
 
@@ -744,27 +723,72 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
         ready_pods = [
             pod
             for pod in pods
-            if pod["status"].get("phase") in ("Running", "Succeeded")
+            if pod["status"].get("phase") in {"Running", "Succeeded"}
         ]
 
         if not ready_pods:
             raise JobNotRunningError(name)
 
-    def job_logs(self, namespace, name, follow, output):
-        self.wait_for_job_running(namespace, name)
+    def job_logs(
+        self,
+        namespace,
+        name,
+        follow,
+        output,
+        wait_for_job_running=True,
+        wait_for_logs_process=False,
+    ):
+        if wait_for_job_running:
+            self.wait_for_job_running(namespace, name)
+
         cmd = ["logs", "--all-containers=true", "-n", namespace, f"job/{name}"]
         if follow:
             cmd.append("-f")
-        # pylint: disable=consider-using-with
-        output_file = open(os.path.join(output, name), "w")
-        # collect logs to file async
-        Popen(self.oc_base_cmd + cmd, stdout=output_file)
+
+        if isinstance(output, str | pathlib.Path):
+            output_file = open(os.path.join(output, name), "w", encoding="locale")  # noqa: SIM115
+        else:
+            # assume it's a file-like object, e.g. sys.stdout, TextIO, ...
+            output_file = output
+
+        if wait_for_logs_process:
+            subprocess.run(self.oc_base_cmd + cmd, stdout=output_file, check=False)
+        else:
+            # collect logs to file async
+            Popen(self.oc_base_cmd + cmd, stdout=output_file)
+
+    def job_logs_latest_pod(self, namespace: str, name: str, output: str) -> str:
+        pods = self.get_items("Pod", namespace=namespace, labels={"job-name": name})
+
+        finished_pods = [
+            pod for pod in pods if pod["status"].get("phase") in {"Failed", "Succeeded"}
+        ]
+        if not finished_pods:
+            raise JobNotRunningError(name)
+
+        latest_pod = sorted(
+            finished_pods, key=lambda pod: pod["metadata"]["creationTimestamp"]
+        )[-1]
+        cmd = [
+            "logs",
+            "--all-containers=true",
+            "-n",
+            namespace,
+            f"pod/{latest_pod['metadata']['name']}",
+        ]
+        output_file_name = os.path.join(output, name)
+        with open(output_file_name, "w", encoding="locale") as f:
+            # collect logs to file async
+            p = Popen(self.oc_base_cmd + cmd, stdout=f)
+            # wait here for the log collection to finish
+            p.wait()
+        return output_file_name
 
     @staticmethod
     def get_service_account_username(user):
         namespace = user.split("/")[0]
         name = user.split("/")[1]
-        return "system:serviceaccount:{}:{}".format(namespace, name)
+        return f"system:serviceaccount:{namespace}:{name}"
 
     def get_owned_pods(self, namespace, resource):
         pods = self.get(namespace, "Pod")["items"]
@@ -850,9 +874,12 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
 
     @retry(max_attempts=20)
     def validate_pod_ready(self, namespace, name):
-        logging.info(
-            [self.validate_pod_ready.__name__, self.cluster_name, namespace, name]
-        )
+        logging.info([
+            self.validate_pod_ready.__name__,
+            self.cluster_name,
+            namespace,
+            name,
+        ])
         pod = self.get(namespace, "Pod", name)
         for status in pod["status"]["containerStatuses"]:
             if not status["ready"]:
@@ -868,29 +895,27 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
 
         supported_kinds = ["Secret", "ConfigMap"]
         if dep_kind not in supported_kinds:
-            logging.debug(
-                [
-                    "skipping_pod_recycle_unsupported",
-                    self.cluster_name,
-                    namespace,
-                    dep_kind,
-                ]
-            )
+            logging.debug([
+                "skipping_pod_recycle_unsupported",
+                self.cluster_name,
+                namespace,
+                dep_kind,
+            ])
             return
 
         dep_annotations = dep_resource.body["metadata"].get("annotations", {})
+        # Note, that annotations might have been set to None explicitly
+        dep_annotations = dep_resource.body["metadata"].get("annotations") or {}
         qontract_recycle = dep_annotations.get("qontract.recycle")
         if qontract_recycle is True:
             raise RecyclePodsInvalidAnnotationValue('should be "true"')
         if qontract_recycle != "true":
-            logging.debug(
-                [
-                    "skipping_pod_recycle_no_annotation",
-                    self.cluster_name,
-                    namespace,
-                    dep_kind,
-                ]
-            )
+            logging.debug([
+                "skipping_pod_recycle_no_annotation",
+                self.cluster_name,
+                namespace,
+                dep_kind,
+            ])
             return
 
         dep_name = dep_resource.name
@@ -1009,7 +1034,7 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
         kind: str,
         include_optional: bool = True,
     ) -> dict[str, set[str]]:
-        if kind not in ("Secret", "ConfigMap"):
+        if kind not in {"Secret", "ConfigMap"}:
             raise KeyError(f"unsupported resource kind: {kind}")
         optional = "optional"
         if kind == "Secret":
@@ -1065,6 +1090,7 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
 
     @retry(exceptions=(StatusCodeError, NoOutputError), max_attempts=10)
     def _run(self, cmd, **kwargs) -> bytes:
+        oc_run_execution_counter.labels(integration=RunningState().integration).inc()
         stdin = kwargs.get("stdin")
         stdin_text = stdin.encode() if stdin else None
         result = subprocess.run(
@@ -1102,6 +1128,8 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
                     raise StatefulSetUpdateForbidden(f"[{self.server}]: {err}")
                 if "the object has been modified" in err:
                     raise ObjectHasBeenModifiedError(f"[{self.server}]: {err}")
+                if "Request entity too large" in err:
+                    raise RequestEntityTooLargeError(f"[{self.server}]: {err}")
             if not (allow_not_found and "NotFound" in err):
                 raise StatusCodeError(f"[{self.server}]: {err}")
 
@@ -1118,7 +1146,7 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
         try:
             out_json = json.loads(out)
         except ValueError as e:
-            raise JSONParsingError(out + "\n" + str(e))
+            raise JSONParsingError(out + "\n" + str(e)) from e
 
         return out_json
 
@@ -1143,7 +1171,7 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
             find = False
             for gv in self.api_resources[kind]:
                 if apigroup_override == gv.group:
-                    if gv.group == "":
+                    if not gv.group:
                         group_version = gv.api_version
                     else:
                         group_version = f"{gv.group}/{gv.api_version}"
@@ -1194,18 +1222,21 @@ class OCDeprecated:  # pylint: disable=too-many-public-methods
         return kind_resources[0].namespaced
 
 
-class OCNative(OCDeprecated):
+REQUEST_TIMEOUT = 60
+
+
+class OCNative(OCCli):
     def __init__(
         self,
-        cluster_name: Optional[str],
-        server: Optional[str],
-        token: Optional[str],
-        jh: Optional[Mapping[Any, Any]] = None,
-        settings: Optional[Mapping[Any, Any]] = None,
+        cluster_name: str | None,
+        server: str | None,
+        token: str | None,
+        jh: Mapping[Any, Any] | None = None,
+        settings: Mapping[Any, Any] | None = None,
         init_projects: bool = False,
         local: bool = False,
         insecure_skip_tls_verify: bool = False,
-        connection_parameters: Optional[OCConnectionParameters] = None,
+        connection_parameters: OCConnectionParameters | None = None,
     ):
         super().__init__(
             cluster_name,
@@ -1235,14 +1266,14 @@ class OCNative(OCDeprecated):
             raise Exception("A method relies on client/api_kind_version to be set")
 
         self.object_clients: dict[Any, Any] = {}
-
+        self.projects = set()
         self.init_projects = init_projects
         if self.init_projects:
             if self.is_kind_supported("Project"):
                 kind = "Project.project.openshift.io"
             else:
                 kind = "Namespace"
-            self.projects = [p["metadata"]["name"] for p in self.get_all(kind)["items"]]
+            self.projects = {p["metadata"]["name"] for p in self.get_all(kind)["items"]}
 
     def __enter__(self):
         return self
@@ -1257,13 +1288,13 @@ class OCNative(OCDeprecated):
 
     @retry(exceptions=(ServerTimeoutError, InternalServerError, ForbiddenError))
     def _get_client(self, server, token):
-        opts = dict(
-            api_key={"authorization": f"Bearer {token}"},
-            host=server,
-            verify_ssl=False,
+        opts = {
+            "api_key": {"authorization": f"Bearer {token}"},
+            "host": server,
+            "verify_ssl": False,
             # default timeout seems to be 1+ minutes
-            retries=5,
-        )
+            "retries": 5,
+        }
         if self.jump_host:
             # the ports could be parameterized, but at this point
             # we only have need of 1 tunnel for 1 service
@@ -1284,7 +1315,7 @@ class OCNative(OCDeprecated):
         try:
             return DynamicClient(k8s_client, discoverer=OpenshiftLazyDiscoverer)
         except urllib3.exceptions.MaxRetryError as e:
-            raise StatusCodeError(f"[{self.server}]: {e}")
+            raise StatusCodeError(f"[{self.server}]: {e}") from None
 
     def _get_obj_client(self, kind, group_version):
         key = f"{kind}.{group_version}"
@@ -1310,9 +1341,7 @@ class OCNative(OCDeprecated):
 
         labels = ""
         if "labels" in kwargs:
-            labels_list = [
-                "{}={}".format(k, v) for k, v in kwargs.get("labels").items()
-            ]
+            labels_list = [f"{k}={v}" for k, v in kwargs.get("labels").items()]
 
             labels = ",".join(labels_list)
 
@@ -1322,7 +1351,10 @@ class OCNative(OCDeprecated):
             for resource_name in resource_names:
                 try:
                     item = obj_client.get(
-                        name=resource_name, namespace=namespace, label_selector=labels
+                        name=resource_name,
+                        namespace=namespace,
+                        label_selector=labels,
+                        _request_timeout=REQUEST_TIMEOUT,
                     )
                     if item:
                         items.append(item.to_dict())
@@ -1331,13 +1363,14 @@ class OCNative(OCDeprecated):
             items_list = {"items": items}
         else:
             items_list = obj_client.get(
-                namespace=namespace, label_selector=labels
+                namespace=namespace,
+                label_selector=labels,
+                _request_timeout=REQUEST_TIMEOUT,
             ).to_dict()
 
         items = items_list.get("items")
         if items is None:
             raise Exception("Expecting items")
-
         return items
 
     @retry(max_attempts=5, exceptions=(ServerTimeoutError, ForbiddenError))
@@ -1345,26 +1378,30 @@ class OCNative(OCDeprecated):
         k, group_version = self._parse_kind(kind)
         obj_client = self._get_obj_client(group_version=group_version, kind=k)
         try:
-            obj = obj_client.get(name=name, namespace=namespace)
+            obj = obj_client.get(
+                name=name,
+                namespace=namespace,
+                _request_timeout=REQUEST_TIMEOUT,
+            )
             return obj.to_dict()
         except NotFoundError as e:
             if allow_not_found:
                 return {}
-            raise StatusCodeError(f"[{self.server}]: {e}")
+            raise StatusCodeError(f"[{self.server}]: {e}") from None
 
     def get_all(self, kind, all_namespaces=False):
         k, group_version = self._parse_kind(kind)
         obj_client = self._get_obj_client(group_version=group_version, kind=k)
         try:
-            return obj_client.get().to_dict()
+            return obj_client.get(_request_timeout=REQUEST_TIMEOUT).to_dict()
         except NotFoundError as e:
-            raise StatusCodeError(f"[{self.server}]: {e}")
+            raise StatusCodeError(f"[{self.server}]: {e}") from None
 
 
-OCClient = Union[OCNative, OCDeprecated]
+OCClient = OCNative | OCCli
 
 
-class OCLocal(OCDeprecated):
+class OCLocal(OCCli):
     def __init__(
         self,
         cluster_name,
@@ -1389,21 +1426,21 @@ class OC:
 
     def __new__(
         cls,
-        cluster_name: Optional[str] = None,
-        server: Optional[str] = None,
-        token: Optional[str] = None,
-        jh: Optional[Mapping[Any, Any]] = None,
-        settings: Optional[Mapping[Any, Any]] = None,
+        cluster_name: str | None = None,
+        server: str | None = None,
+        token: str | None = None,
+        jh: Mapping[Any, Any] | None = None,
+        settings: Mapping[Any, Any] | None = None,
         init_projects: bool = False,
         init_api_resources: bool = False,
         local: bool = False,
         insecure_skip_tls_verify: bool = False,
-        connection_parameters: Optional[OCConnectionParameters] = None,
+        connection_parameters: OCConnectionParameters | None = None,
     ):
         use_native_env = os.environ.get("USE_NATIVE_CLIENT", "")
         use_native = True
         if len(use_native_env) > 0:
-            use_native = use_native_env.lower() in ["true", "yes"]
+            use_native = use_native_env.lower() in {"true", "yes"}
         else:
             enable_toggle = "openshift-resources-native-client"
             use_native = get_feature_toggle_state(
@@ -1428,7 +1465,7 @@ class OC:
             )
 
         OC.client_status.labels(cluster_name=cluster_name, native_client=False).inc()
-        return OCDeprecated(
+        return OCCli(
             cluster_name=cluster_name,
             server=server,
             token=token,
@@ -1460,7 +1497,6 @@ class OC_Map:
         clusters=None,
         namespaces=None,
         integration="",
-        e2e_test="",
         settings=None,
         internal=None,
         use_jump_host=True,
@@ -1472,7 +1508,6 @@ class OC_Map:
         self.oc_map = {}
         self.privileged_oc_map = {}
         self.calling_integration = integration
-        self.calling_e2e_test = e2e_test
         self.settings = settings
         self.internal = internal
         self.use_jump_host = use_jump_host
@@ -1612,10 +1647,7 @@ class OC_Map:
                 )
                 return
 
-            if self.use_jump_host:
-                jump_host = cluster_info.get("jumpHost")
-            else:
-                jump_host = None
+            jump_host = cluster_info.get("jumpHost") if self.use_jump_host else None
             if jump_host:
                 self.set_jh_ports(jump_host)
             try:
@@ -1654,12 +1686,6 @@ class OC_Map:
                 return True
         except (KeyError, TypeError):
             pass
-        try:
-            tests = cluster_info["disable"]["e2eTests"]
-            if self.calling_e2e_test.replace("_", "-") in tests:
-                return True
-        except (KeyError, TypeError):
-            pass
 
         return False
 
@@ -1717,6 +1743,9 @@ class OCLogMsg(Exception):
         """
         return False
 
+    def __str__(self) -> str:
+        return super().__str__() + self.message
+
 
 LABEL_MAX_VALUE_LENGTH = 63
 LABEL_MAX_KEY_NAME_LENGTH = 63
@@ -1778,7 +1807,7 @@ def validate_labels(labels: dict[str, str]) -> Iterable[str]:
                     f"Label key prefix is invalid, it needs to match "
                     f"'{k_prefix_pattern}'': {prefix}"
                 )
-            if prefix in ("kubernetes.io", "k8s.io"):
+            if prefix in {"kubernetes.io", "k8s.io"}:
                 err.append(f"Label key prefix is reserved: {prefix}")
 
     return err
@@ -1824,22 +1853,17 @@ class OpenshiftLazyDiscoverer(LazyDiscoverer):
             ]
         # If there are multiple matches, prefer non-List kinds
         if len(results) > 1 and not all(  # pylint: disable=R1729
-            [isinstance(x, ResourceList) for x in results]
+            isinstance(x, ResourceList) for x in results
         ):
             results = [
                 result for result in results if not isinstance(result, ResourceList)
             ]
         # if multiple resources are found that share a GVK, prefer the one with the most supported verbs
-        if (
-            len(results) > 1
-            and len(set((x.group_version, x.kind) for x in results)) == 1
-        ):
-            if len(set(len(x.verbs) for x in results)) != 1:
+        if len(results) > 1 and len({(x.group_version, x.kind) for x in results}) == 1:
+            if len({len(x.verbs) for x in results}) != 1:
                 results = [max(results, key=lambda x: len(x.verbs))]
         if len(results) == 1:
             return results[0]
         if not results:
-            raise ResourceNotFoundError("No matches found for {}".format(kwargs))
-        raise ResourceNotUniqueError(
-            "Multiple matches found for {}: {}".format(kwargs, results)
-        )
+            raise ResourceNotFoundError(f"No matches found for {kwargs}")
+        raise ResourceNotUniqueError(f"Multiple matches found for {kwargs}: {results}")