openshift-python-wrapper 4.11.61__py3-none-any.whl

ocp_resources/subscription.py

@@ -0,0 +1,66 @@
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.resource import NamespacedResource
+
+
+class Subscription(NamespacedResource):
+    api_group = NamespacedResource.ApiGroup.OPERATORS_COREOS_COM
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        client=None,
+        source=None,
+        source_namespace=None,
+        install_plan_approval=None,
+        channel=None,
+        starting_csv=None,
+        node_selector=None,
+        tolerations=None,
+        teardown=True,
+        yaml_file=None,
+        delete_timeout=TIMEOUT_4MINUTES,
+        **kwargs,
+    ):
+        super().__init__(
+            client=client,
+            name=name,
+            namespace=namespace,
+            teardown=teardown,
+            yaml_file=yaml_file,
+            delete_timeout=delete_timeout,
+            **kwargs,
+        )
+        self.source = source
+        self.source_namespace = source_namespace
+        self.channel = channel
+        self.install_plan_approval = install_plan_approval
+        self.starting_csv = starting_csv
+        self.node_selector = node_selector
+        self.tolerations = tolerations
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            self.res.update(
+                {
+                    "spec": {
+                        "sourceNamespace": self.source_namespace,
+                        "source": self.source,
+                        "name": self.name,
+                        "channel": self.channel,
+                        "installPlanApproval": self.install_plan_approval,
+                        "startingCSV": self.starting_csv,
+                    }
+                }
+            )
+
+            if self.node_selector:
+                self.res["spec"].setdefault("config", {}).setdefault(
+                    "nodeSelector", {}
+                ).update(self.node_selector)
+
+            if self.tolerations:
+                self.res["spec"].setdefault("config", {}).setdefault(
+                    "tolerations", []
+                ).append(self.tolerations)

ocp_resources/tekton_tasks.py

@@ -0,0 +1,9 @@
+from ocp_resources.resource import NamespacedResource
+
+
+class TektonTasks(NamespacedResource):
+    """
+    TektonTasks object, inherited from NamespacedResource.
+    """
+
+    api_group = NamespacedResource.ApiGroup.TEKTONTASKS_KUBEVIRT_IO

ocp_resources/template.py

@@ -0,0 +1,74 @@
+import json
+
+from ocp_resources.resource import NamespacedResource, Resource
+
+
+class Template(NamespacedResource):
+    api_group = NamespacedResource.ApiGroup.TEMPLATE_OPENSHIFT_IO
+    singular_name = "template"
+
+    class Labels:
+        BASE = f"{NamespacedResource.ApiGroup.TEMPLATE_KUBEVIRT_IO}/type=base"
+        FLAVOR = "flavor.template.kubevirt.io"
+        OS = "os.template.kubevirt.io"
+        WORKLOAD = "workload.template.kubevirt.io"
+
+    class Workload:
+        DESKTOP = "desktop"
+        HIGHPERFORMANCE = "highperformance"
+        SERVER = "server"
+        SAPHANA = "saphana"
+
+    class Flavor:
+        LARGE = "large"
+        MEDIUM = "medium"
+        SMALL = "small"
+        TINY = "tiny"
+
+    class Annotations:
+        DEPRECATED = f"{NamespacedResource.ApiGroup.TEMPLATE_KUBEVIRT_IO}/deprecated"
+        PROVIDER = f"{NamespacedResource.ApiGroup.TEMPLATE_KUBEVIRT_IO}/provider"
+        PROVIDER_SUPPORT_LEVEL = (
+            f"{NamespacedResource.ApiGroup.TEMPLATE_KUBEVIRT_IO}/provider-support-level"
+        )
+        PROVIDER_URL = (
+            f"{NamespacedResource.ApiGroup.TEMPLATE_KUBEVIRT_IO}/provider-url"
+        )
+
+    class VMAnnotations:
+        OS = f"{Resource.ApiGroup.VM_KUBEVIRT_IO}/os"
+        FLAVOR = f"{Resource.ApiGroup.VM_KUBEVIRT_IO}/flavor"
+        WORKLOAD = f"{Resource.ApiGroup.VM_KUBEVIRT_IO}/workload"
+
+    def process(self, client=None, **kwargs):
+        client = client or self.client
+        instance_dict = self.instance.to_dict()
+        params = instance_dict["parameters"]
+        # filling the template parameters with given kwargs
+        for param in params:
+            try:
+                param["value"] = kwargs[param["name"]]
+            except KeyError:
+                continue
+        instance_dict["parameters"] = params
+        # TODO: remove after fix - https://issues.redhat.com/browse/KNIP-1055 (bug 1753554)
+        # For template validator to be used - template namespace needs to be updated
+        instance_dict["objects"][0]["metadata"]["labels"][
+            "vm.kubevirt.io/template.namespace"
+        ] = instance_dict["metadata"]["namespace"]
+        instance_json = json.dumps(instance_dict)
+        body = json.loads(instance_json)
+        response = client.request(
+            method="Post",
+            path=f"/apis/{self.api_version}/namespaces/openshift/processedtemplates",
+            body=body,
+        )
+        return response.to_dict()["objects"]
+
+    @staticmethod
+    def generate_template_labels(os, workload, flavor):
+        return [
+            f"{Template.Labels.OS}/{os}",
+            f"{Template.Labels.WORKLOAD}/{getattr(Template.Workload, workload.upper())}",
+            f"{Template.Labels.FLAVOR}/{getattr(Template.Flavor, flavor.upper())}",
+        ]

ocp_resources/upload_token_request.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.resource import NamespacedResource
+
+
+class UploadTokenRequest(NamespacedResource):
+    """
+    OpenShift UploadTokenRequest object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.UPLOAD_CDI_KUBEVIRT_IO
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        client=None,
+        pvc_name=None,
+        teardown=True,
+        yaml_file=None,
+        delete_timeout=TIMEOUT_4MINUTES,
+        **kwargs,
+    ):
+        super().__init__(
+            name=name,
+            namespace=namespace,
+            client=client,
+            teardown=teardown,
+            yaml_file=yaml_file,
+            delete_timeout=delete_timeout,
+            **kwargs,
+        )
+        self.pvc_name = pvc_name
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            self.res.update({"spec": {"pvcName": self.pvc_name}})

ocp_resources/utils.py

@@ -0,0 +1,278 @@
+import time
+
+import yaml
+
+from ocp_resources.logger import get_logger
+
+
+LOGGER = get_logger(name=__name__)
+
+
+class TimeoutExpiredError(Exception):
+    def __init__(self, value):
+        super().__init__()
+        self.value = value
+
+    def __str__(self):
+        return f"Timed Out: {self.value}"
+
+
+class TimeoutSampler:
+    """
+    Samples the function output.
+
+    This is a generator object that at first yields the output of callable.
+    After the yield, it either raises instance of `TimeoutExpiredError` or
+    sleeps `sleep` seconds.
+
+    Yielding the output allows you to handle every value as you wish.
+
+    exceptions_dict should be in the following format:
+    {
+        exception0: [exception0_msg0],
+        exception1: [
+            exception1_msg0,
+            exception1_msg1
+        ],
+        exception2: []
+    }
+
+    If an exception is raised within `func`:
+        Example exception inheritance:
+            class Exception
+            class AExampleError(Exception)
+            class BExampleError(AExampleError)
+
+        The raised exception's class will fall into one of three categories:
+            1. An exception class specifically declared in exceptions_dict
+                exceptions_dict: {BExampleError: []}
+                raise: BExampleError
+                result: continue
+
+            2. A child class inherited from an exception class in exceptions_dict
+                exceptions_dict: {AExampleError: []}
+                raise: BExampleError
+                result: continue
+
+            3. Everything else, this will always re-raise the exception
+                exceptions_dict: {BExampleError: []}
+                raise: AExampleError
+                result: raise
+
+    Args:
+        wait_timeout (int): Time in seconds to wait for func to return a value equating to True
+        sleep (int): Time in seconds between calls to func
+        func (Callable): to be wrapped by TimeoutSampler
+        exceptions_dict (dict): Exception handling definition
+        print_log (bool): Print elapsed time to log
+    """
+
+    def __init__(
+        self,
+        wait_timeout,
+        sleep,
+        func,
+        exceptions_dict=None,
+        print_log=True,
+        **func_kwargs,
+    ):
+        self.wait_timeout = wait_timeout
+        self.sleep = sleep
+        self.func = func
+        self.func_kwargs = func_kwargs
+        self.elapsed_time = None
+        self.print_log = print_log
+
+        self.exceptions_dict = exceptions_dict or {Exception: []}
+        self._exceptions = tuple(self.exceptions_dict.keys())
+
+    def _get_func_info(self, _func, type_):
+        # If func is partial function.
+        if getattr(_func, "func", None):
+            return self._get_func_info(_func=_func.func, type_=type_)
+
+        res = getattr(_func, type_, None)
+        if res:
+            # If func is lambda function.
+            if _func.__name__ == "<lambda>":
+                if type_ == "__module__":
+                    return f"{res}.{_func.__qualname__.split('.')[1]}"
+
+                elif type_ == "__name__":
+                    free_vars = _func.__code__.co_freevars
+                    free_vars = f"{'.'.join(free_vars)}." if free_vars else ""
+                    return f"lambda: {free_vars}{'.'.join(_func.__code__.co_names)}"
+            return res
+
+    @property
+    def _func_log(self):
+        """
+        Returns:
+            string: `func` information to include in log message
+        """
+        _func_kwargs = f"Kwargs: {self.func_kwargs}" if self.func_kwargs else ""
+        _func_module = self._get_func_info(_func=self.func, type_="__module__")
+        _func_name = self._get_func_info(_func=self.func, type_="__name__")
+        return f"Function: {_func_module}.{_func_name} {_func_kwargs}".strip()
+
+    def __iter__(self):
+        """
+        Iterator
+
+        Yields:
+            any: Return value from `func`
+        """
+        timeout_watch = TimeoutWatch(timeout=self.wait_timeout)
+        if self.print_log:
+            LOGGER.info(
+                f"Waiting for {self.wait_timeout} seconds, retry every {self.sleep} seconds. ({self._func_log})"
+            )
+
+        last_exp = None
+        while timeout_watch.remaining_time() > 0:
+            try:
+                self.elapsed_time = self.wait_timeout - timeout_watch.remaining_time()
+                yield self.func(**self.func_kwargs)
+                self.elapsed_time = None
+
+                time.sleep(self.sleep)
+
+            except self._exceptions as exp:
+                last_exp = exp
+                last_exp_log = self._get_exception_log(exp=last_exp)
+                if self._is_raisable_exception(exp=last_exp):
+                    LOGGER.error(last_exp_log)
+                    raise exp
+
+                self.elapsed_time = None
+                time.sleep(self.sleep)
+
+            finally:
+                if self.elapsed_time and self.print_log:
+                    LOGGER.info(f"Elapsed time: {self.elapsed_time}")
+
+        raise TimeoutExpiredError(self._get_exception_log(exp=last_exp))
+
+    @staticmethod
+    def _is_exception_matched(exp, exception_messages):
+        """
+        Args:
+            exp (Exception): Exception object raised by `func`
+            exception_messages (list): Either an empty list allowing all text,
+                                       or a list of allowed strings to match against the exception text.
+
+        Returns:
+            bool: True if exception text is allowed or no exception text given, False otherwise
+        """
+        if not exception_messages:
+            return True
+
+        # Prevent match if provided with empty string
+        return any(msg and msg in str(exp) for msg in exception_messages)
+
+    def _is_raisable_exception(self, exp):
+        """
+        Verify whether exception should be raised during execution of `func`
+
+        Args:
+            exp (Exception): Exception object raised by `func`
+
+        Returns:
+            bool: True if exp should be raised, False otherwise
+        """
+
+        for entry in self.exceptions_dict:
+            if isinstance(exp, entry):  # Check inheritance for raised exception
+                exception_messages = self.exceptions_dict.get(entry)
+                if self._is_exception_matched(
+                    exp=exp, exception_messages=exception_messages
+                ):
+                    return False
+
+        return True
+
+    def _get_exception_log(self, exp):
+        """
+        Args:
+            exp (any): Raised exception
+
+        Returns:
+            string: Log message for exception
+        """
+        exp_name = exp.__class__.__name__ if exp else "N/A"
+
+        last_exception_log = f"Last exception: {exp_name}: {exp}"
+        return f"{self.wait_timeout}\n{self._func_log}\n{last_exception_log}"
+
+
+class TimeoutWatch:
+    """
+    A time counter allowing to determine the time remaining since the start
+    of a given interval
+    """
+
+    def __init__(self, timeout):
+        self.timeout = timeout
+        self.start_time = time.time()
+
+    def remaining_time(self):
+        """
+        Return the remaining part of timeout since the object was created.
+        """
+        return self.start_time + self.timeout - time.time()
+
+
+def skip_existing_resource_creation_teardown(
+    resource, export_str, user_exported_args, check_exists=True
+):
+    """
+    Args:
+        resource (Resource): Resource to match against.
+        export_str (str): The user export str. (REUSE_IF_RESOURCE_EXISTS or SKIP_RESOURCE_TEARDOWN)
+        user_exported_args (str): Value of export_str. (os.environ.get)
+        check_exists (bool): Check if resource exists before return. (applied only for REUSE_IF_RESOURCE_EXISTS)
+
+    Returns:
+        Resource or None: If resource match.
+    """
+
+    def _return_resource(_resource, _check_exists, _msg):
+        """
+        Return the resource if exists when got _check_exists else return None.
+        If _check_exists=False returns the resource.
+        """
+        if not _check_exists:  # In case of SKIP_RESOURCE_TEARDOWN
+            return _resource
+
+        elif _resource.exists:  # In case of REUSE_IF_RESOURCE_EXISTS
+            LOGGER.warning(_msg)
+            return _resource
+
+    resource.to_dict()
+    resource_name = resource.res["metadata"]["name"]
+    resource_namespace = resource.res["metadata"].get("namespace")
+    skip_create_warn_msg = (
+        f"Skip resource {resource.kind} {resource_name} creation, using existing one."
+        f" Got {export_str}={user_exported_args}"
+    )
+    user_args = yaml.safe_load(stream=user_exported_args)
+    if resource.kind in user_args:
+        _resource_args = user_args[resource.kind]
+        if not _resource_args:
+            # Match only by kind, user didn't send name and/or namespace.
+            return _return_resource(
+                _resource=resource,
+                _check_exists=check_exists,
+                _msg=skip_create_warn_msg,
+            )
+
+        for _name, _namespace in _resource_args.items():
+            if resource_name == _name and (
+                resource_namespace == _namespace
+                or not (resource_namespace and _namespace)
+            ):
+                return _return_resource(
+                    _resource=resource,
+                    _check_exists=check_exists,
+                    _msg=skip_create_warn_msg,
+                )

ocp_resources/validating_webhook_config.py

@@ -0,0 +1,9 @@
+from ocp_resources.resource import Resource
+
+
+class ValidatingWebhookConfiguration(Resource):
+    """
+    ValidatingWebhookConfiguration object.
+    """
+
+    api_group = Resource.ApiGroup.ADMISSIONREGISTRATION_K8S_IO

ocp_resources/virtual_machine.py

@@ -0,0 +1,177 @@
+# -*- coding: utf-8 -*-
+
+
+from ocp_resources.constants import (
+    DEFAULT_CLUSTER_RETRY_EXCEPTIONS,
+    PROTOCOL_ERROR_EXCEPTION_DICT,
+    TIMEOUT_4MINUTES,
+)
+from ocp_resources.resource import NamespacedResource
+from ocp_resources.utils import TimeoutSampler
+from ocp_resources.virtual_machine_instance import VirtualMachineInstance
+
+
+class VirtualMachine(NamespacedResource):
+    """
+    Virtual Machine object, inherited from Resource.
+    Implements actions start / stop / status / wait for VM status / is running
+    """
+
+    api_group = NamespacedResource.ApiGroup.KUBEVIRT_IO
+
+    class RunStrategy:
+        MANUAL = "Manual"
+        HALTED = "Halted"
+        ALWAYS = "Always"
+        RERUNONFAILURE = "RerunOnFailure"
+
+    class Status(NamespacedResource.Status):
+        MIGRATING = "Migrating"
+        PAUSED = "Paused"
+        PROVISIONING = "Provisioning"
+        STARTING = "Starting"
+        STOPPED = "Stopped"
+        STOPPING = "Stopping"
+        WAITING_FOR_VOLUME_BINDING = "WaitingForVolumeBinding"
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        client=None,
+        body=None,
+        teardown=True,
+        privileged_client=None,
+        yaml_file=None,
+        delete_timeout=TIMEOUT_4MINUTES,
+        **kwargs,
+    ):
+        super().__init__(
+            name=name,
+            namespace=namespace,
+            client=client,
+            teardown=teardown,
+            privileged_client=privileged_client,
+            yaml_file=yaml_file,
+            delete_timeout=delete_timeout,
+            **kwargs,
+        )
+        self.body = body
+
+    @property
+    def _subresource_api_url(self):
+        return (
+            f"{self.client.configuration.host}/"
+            f"apis/subresources.kubevirt.io/{self.api.api_version}/"
+            f"namespaces/{self.namespace}/virtualmachines/{self.name}"
+        )
+
+    def api_request(self, method, action, **params):
+        return super().api_request(
+            method=method, action=action, url=self._subresource_api_url, **params
+        )
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            body_spec = self.body.get("spec") if self.body else None
+            self.res["spec"] = body_spec or {"template": {"spec": {}}}
+
+    def start(self, timeout=TIMEOUT_4MINUTES, wait=False):
+        self.api_request(method="PUT", action="start")
+        if wait:
+            return self.wait_for_ready_status(timeout=timeout, status=True)
+
+    def restart(self, timeout=TIMEOUT_4MINUTES, wait=False):
+        self.api_request(method="PUT", action="restart")
+        if wait:
+            self.vmi.virt_launcher_pod.wait_deleted()
+            return self.vmi.wait_until_running(timeout=timeout, stop_status="dummy")
+
+    def stop(
+        self, timeout=TIMEOUT_4MINUTES, vmi_delete_timeout=TIMEOUT_4MINUTES, wait=False
+    ):
+        self.api_request(method="PUT", action="stop")
+        if wait:
+            self.wait_for_ready_status(timeout=timeout, status=None)
+            return self.vmi.wait_deleted(timeout=vmi_delete_timeout)
+
+    def wait_for_ready_status(self, status, timeout=TIMEOUT_4MINUTES, sleep=1):
+        """
+        Wait for VM resource ready status to be at desire status
+
+        Args:
+            status (any): True for a running VM, None for a stopped VM.
+            timeout (int): Time to wait for the resource.
+
+        Raises:
+            TimeoutExpiredError: If timeout reached.
+        """
+        self.logger.info(
+            f"Wait for {self.kind} {self.name} status to be {'ready' if status == True else status}"
+        )
+        samples = TimeoutSampler(
+            wait_timeout=timeout,
+            sleep=sleep,
+            exceptions_dict={
+                **PROTOCOL_ERROR_EXCEPTION_DICT,
+                **DEFAULT_CLUSTER_RETRY_EXCEPTIONS,
+            },
+            func=self.api.get,
+            field_selector=f"metadata.name=={self.name}",
+            namespace=self.namespace,
+        )
+        for sample in samples:
+            if sample.items and self.ready == status:
+                # VM with runStrategy does not have spec.running attribute
+                # VM status should be taken from spec.status.ready
+                return
+
+    def get_interfaces(self):
+        return self.instance.spec.template.spec.domain.devices.interfaces
+
+    @property
+    def vmi(self):
+        """
+        Get VMI
+
+        Returns:
+            VirtualMachineInstance: VMI
+        """
+        return VirtualMachineInstance(
+            client=self.client,
+            name=self.name,
+            namespace=self.namespace,
+            privileged_client=self.privileged_client or self.client,
+        )
+
+    @property
+    def ready(self):
+        """
+        Get VM status
+
+        Returns:
+            True if Running else None
+        """
+        return self.instance.get("status", {}).get("ready")
+
+    @property
+    def printable_status(self):
+        """
+        Get VM printableStatus
+
+        Returns:
+            VM printableStatus if VM.status.printableStatus else None
+        """
+        return self.instance.get("status", {}).get("printableStatus")
+
+    def wait_for_status_none(self, status, timeout=TIMEOUT_4MINUTES):
+        self.logger.info(f"Wait for {self.kind} {self.name} status {status} to be None")
+        for sample in TimeoutSampler(
+            wait_timeout=timeout,
+            sleep=1,
+            exceptions_dict=PROTOCOL_ERROR_EXCEPTION_DICT,
+            func=lambda: self.instance.get("status", {}).get(status),
+        ):
+            if sample is None:
+                return

ocp_resources/virtual_machine_Instance_replica_set.py

@@ -0,0 +1,9 @@
+from ocp_resources.resource import NamespacedResource
+
+
+class VirtualMachineInstanceReplicaSet(NamespacedResource):
+    """
+    VirtualMachineInstancePreset object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.KUBEVIRT_IO

ocp_resources/virtual_machine_cluster_flavor.py

@@ -0,0 +1,5 @@
+from ocp_resources.resource import Resource
+
+
+class VirtualMachineClusterFlavor(Resource):
+    api_group = Resource.ApiGroup.FLAVOR_KUBEVIRT_IO

ocp_resources/virtual_machine_flavor.py

@@ -0,0 +1,5 @@
+from ocp_resources.resource import NamespacedResource
+
+
+class VirtualMachineFlavor(NamespacedResource):
+    api_group = NamespacedResource.ApiGroup.FLAVOR_KUBEVIRT_IO