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

ocp_resources/daemonset.py

@@ -0,0 +1,61 @@
+import kubernetes
+
+from ocp_resources.constants import PROTOCOL_ERROR_EXCEPTION_DICT, TIMEOUT_4MINUTES
+from ocp_resources.resource import NamespacedResource
+from ocp_resources.utils import TimeoutSampler
+
+
+class DaemonSet(NamespacedResource):
+    """
+    DaemonSet object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.APPS
+
+    def wait_until_deployed(self, timeout=TIMEOUT_4MINUTES):
+        """
+        Wait until all Pods are deployed and ready.
+
+        Args:
+            timeout (int): Time to wait for the Daemonset.
+
+        Raises:
+            TimeoutExpiredError: If not all the pods are deployed.
+        """
+        self.logger.info(f"Wait for {self.kind} {self.name} to deploy all desired pods")
+        samples = TimeoutSampler(
+            wait_timeout=timeout,
+            sleep=1,
+            exceptions_dict=PROTOCOL_ERROR_EXCEPTION_DICT,
+            func=self.api.get,
+            field_selector=f"metadata.name=={self.name}",
+            namespace=self.namespace,
+        )
+        for sample in samples:
+            if sample.items:
+                status = sample.items[0].status
+                desired_number_scheduled = status.desiredNumberScheduled
+                number_ready = status.numberReady
+                if (
+                    desired_number_scheduled > 0
+                    and desired_number_scheduled == number_ready
+                ):
+                    return
+
+    def delete(self, wait=False, timeout=TIMEOUT_4MINUTES, body=None):
+        """
+        Delete Daemonset
+
+        Args:
+            wait (bool): True to wait for Daemonset to be deleted.
+            timeout (int): Time to wait for resource deletion
+            body (dict): Content to send for delete()
+
+        Returns:
+            bool: True if delete succeeded, False otherwise.
+        """
+        super().delete(
+            wait=wait,
+            timeout=timeout,
+            body=kubernetes.client.V1DeleteOptions(propagation_policy="Foreground"),
+        )

ocp_resources/data_import_cron.py

@@ -0,0 +1,100 @@
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.resource import NamespacedResource
+
+
+class DataImportCron(NamespacedResource):
+    """
+    DataImportCron object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.CDI_KUBEVIRT_IO
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        client=None,
+        image_stream=None,
+        url=None,
+        cert_configmap=None,
+        pull_method=None,
+        storage_class=None,
+        size=None,
+        schedule=None,
+        garbage_collect=None,
+        managed_data_source=None,
+        imports_to_keep=None,
+        bind_immediate_annotation=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.image_stream = image_stream
+        self.url = url
+        self.cert_configmap = cert_configmap
+        self.pull_method = pull_method
+        self.storage_class = storage_class
+        self.size = size
+        self.schedule = schedule
+        self.garbage_collect = garbage_collect
+        self.managed_data_source = managed_data_source
+        self.imports_to_keep = imports_to_keep
+        self.bind_immediate_annotation = bind_immediate_annotation
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            if self.image_stream and self.url:
+                raise ValueError("imageStream and url can not coexist")
+
+            self.res.update(
+                {
+                    "spec": {
+                        "template": {
+                            "spec": {
+                                "source": {
+                                    "registry": {"pullMethod": self.pull_method}
+                                },
+                                "storage": {
+                                    "resources": {"requests": {"storage": self.size}}
+                                },
+                            }
+                        }
+                    }
+                }
+            )
+            spec = self.res["spec"]["template"]["spec"]
+            if self.bind_immediate_annotation:
+                self.res["metadata"].setdefault("annotations", {}).update(
+                    {
+                        f"{NamespacedResource.ApiGroup.CDI_KUBEVIRT_IO}/storage.bind.immediate.requested": "true"
+                    }
+                )
+            if self.image_stream:
+                spec["source"]["registry"]["imageStream"] = self.image_stream
+            if self.url:
+                spec["source"]["registry"]["url"] = self.url
+            if self.cert_configmap:
+                spec["source"]["registry"]["certConfigMap"] = self.cert_configmap
+            if self.storage_class:
+                spec["storage"]["storageClassName"] = self.storage_class
+            if self.schedule:
+                self.res["spec"]["schedule"] = self.schedule
+            if self.garbage_collect:
+                self.res["spec"]["garbageCollect"] = self.garbage_collect
+            if self.managed_data_source:
+                self.res["spec"]["managedDataSource"] = self.managed_data_source
+            if self.imports_to_keep:
+                self.res["spec"]["importsToKeep"] = self.imports_to_keep

ocp_resources/data_source.py

@@ -0,0 +1,59 @@
+from openshift.dynamic.exceptions import ResourceNotFoundError
+
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.persistent_volume_claim import PersistentVolumeClaim
+from ocp_resources.resource import NamespacedResource
+
+
+class DataSource(NamespacedResource):
+    api_group = NamespacedResource.ApiGroup.CDI_KUBEVIRT_IO
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        client=None,
+        source=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.source = source
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            self.res.update(
+                {
+                    "spec": {
+                        "source": self.source,
+                    },
+                }
+            )
+
+    @property
+    def pvc(self):
+        data_source_pvc = self.instance.spec.source.pvc
+        pvc_name = data_source_pvc.name
+        pvc_namespace = data_source_pvc.namespace
+        try:
+            return PersistentVolumeClaim(
+                client=self.client,
+                name=pvc_name,
+                namespace=pvc_namespace,
+            )
+        except ResourceNotFoundError:
+            self.logger.warning(
+                f"dataSource {self.name} is pointing to a non-existing PVC, name: {pvc_name}, "
+                f"namespace: {pvc_namespace}"
+            )

ocp_resources/datavolume.py

@@ -0,0 +1,275 @@
+# -*- coding: utf-8 -*-
+
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.persistent_volume_claim import PersistentVolumeClaim
+from ocp_resources.resource import NamespacedResource, Resource
+from ocp_resources.utils import TimeoutExpiredError, TimeoutSampler
+
+
+class DataVolume(NamespacedResource):
+    """
+    DataVolume object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.CDI_KUBEVIRT_IO
+
+    class Status(NamespacedResource.Status):
+        BLANK = "Blank"
+        PVC_BOUND = "PVCBound"
+        IMPORT_SCHEDULED = "ImportScheduled"
+        ClONE_SCHEDULED = "CloneScheduled"
+        UPLOAD_SCHEDULED = "UploadScheduled"
+        IMPORT_IN_PROGRESS = "ImportInProgress"
+        CLONE_IN_PROGRESS = "CloneInProgress"
+        UPLOAD_IN_PROGRESS = "UploadInProgress"
+        SNAPSHOT_FOR_SMART_CLONE_IN_PROGRESS = "SnapshotForSmartCloneInProgress"
+        SMART_CLONE_PVC_IN_PROGRESS = "SmartClonePVCInProgress"
+        UPLOAD_READY = "UploadReady"
+        UNKNOWN = "Unknown"
+        WAIT_FOR_FIRST_CONSUMER = "WaitForFirstConsumer"
+
+    class AccessMode:
+        """
+        AccessMode object.
+        """
+
+        RWO = "ReadWriteOnce"
+        ROX = "ReadOnlyMany"
+        RWX = "ReadWriteMany"
+
+    class ContentType:
+        """
+        ContentType object
+        """
+
+        KUBEVIRT = "kubevirt"
+        ARCHIVE = "archive"
+
+    class VolumeMode:
+        """
+        VolumeMode object
+        """
+
+        BLOCK = "Block"
+        FILE = "Filesystem"
+
+    class Condition:
+        class Type:
+            READY = "Ready"
+            BOUND = "Bound"
+            RUNNING = "Running"
+
+        class Status(Resource.Condition.Status):
+            UNKNOWN = "Unknown"
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        source=None,
+        size=None,
+        storage_class=None,
+        url=None,
+        content_type=ContentType.KUBEVIRT,
+        access_modes=None,
+        cert_configmap=None,
+        secret=None,
+        client=None,
+        volume_mode=None,
+        hostpath_node=None,
+        source_pvc=None,
+        source_namespace=None,
+        multus_annotation=None,
+        bind_immediate_annotation=None,
+        preallocation=None,
+        teardown=True,
+        privileged_client=None,
+        yaml_file=None,
+        delete_timeout=TIMEOUT_4MINUTES,
+        api_name="pvc",
+        **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.source = source
+        self.url = url
+        self.cert_configmap = cert_configmap
+        self.secret = secret
+        self.content_type = content_type
+        self.size = size
+        self.access_modes = access_modes
+        self.storage_class = storage_class
+        self.volume_mode = volume_mode
+        self.hostpath_node = hostpath_node
+        self.source_pvc = source_pvc
+        self.source_namespace = source_namespace
+        self.multus_annotation = multus_annotation
+        self.bind_immediate_annotation = bind_immediate_annotation
+        self.preallocation = preallocation
+        self.api_name = api_name
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            self.res.update(
+                {
+                    "spec": {
+                        "source": {self.source: {"url": self.url}},
+                        self.api_name: {
+                            "resources": {"requests": {"storage": self.size}},
+                        },
+                    }
+                }
+            )
+            if self.access_modes:
+                self.res["spec"][self.api_name]["accessModes"] = [self.access_modes]
+            if self.content_type:
+                self.res["spec"]["contentType"] = self.content_type
+            if self.storage_class:
+                self.res["spec"][self.api_name]["storageClassName"] = self.storage_class
+            if self.secret:
+                self.res["spec"]["source"][self.source]["secretRef"] = self.secret.name
+            if self.volume_mode:
+                self.res["spec"][self.api_name]["volumeMode"] = self.volume_mode
+            if self.source == "http" or "registry":
+                self.res["spec"]["source"][self.source]["url"] = self.url
+            if self.cert_configmap:
+                self.res["spec"]["source"][self.source][
+                    "certConfigMap"
+                ] = self.cert_configmap
+            if self.source == "upload" or self.source == "blank":
+                self.res["spec"]["source"][self.source] = {}
+            if self.hostpath_node:
+                self.res["metadata"].setdefault("annotations", {}).update(
+                    {
+                        f"{NamespacedResource.ApiGroup.KUBEVIRT_IO}/provisionOnNode": self.hostpath_node
+                    }
+                )
+            if self.multus_annotation:
+                self.res["metadata"].setdefault("annotations", {}).update(
+                    {
+                        f"{NamespacedResource.ApiGroup.K8S_V1_CNI_CNCF_IO}/networks": self.multus_annotation
+                    }
+                )
+            if self.bind_immediate_annotation:
+                self.res["metadata"].setdefault("annotations", {}).update(
+                    {
+                        f"{NamespacedResource.ApiGroup.CDI_KUBEVIRT_IO}/storage.bind.immediate.requested": "true"
+                    }
+                )
+            if self.source == "pvc":
+                self.res["spec"]["source"]["pvc"] = {
+                    "name": self.source_pvc or "dv-source",
+                    "namespace": self.source_namespace or self.namespace,
+                }
+            if self.preallocation is not None:
+                self.res["spec"]["preallocation"] = self.preallocation
+
+    def wait_deleted(self, timeout=TIMEOUT_4MINUTES):
+        """
+        Wait until DataVolume and the PVC created by it are deleted
+
+        Args:
+        timeout (int):  Time to wait for the DataVolume and PVC to be deleted.
+
+        Returns:
+        bool: True if DataVolume and its PVC are gone, False if timeout reached.
+        """
+        super().wait_deleted(timeout=timeout)
+        return self.pvc.wait_deleted(timeout=timeout)
+
+    def wait(self, timeout=600, failure_timeout=120):
+        self._check_none_pending_status(failure_timeout=failure_timeout)
+
+        # If DV's status is not Pending, continue with the flow
+        self.wait_for_status(status=self.Status.SUCCEEDED, timeout=timeout)
+        self.pvc.wait_for_status(
+            status=PersistentVolumeClaim.Status.BOUND, timeout=timeout
+        )
+
+    @property
+    def pvc(self):
+        return PersistentVolumeClaim(
+            client=self.privileged_client or self.client,
+            name=self.name,
+            namespace=self.namespace,
+        )
+
+    @property
+    def scratch_pvc(self):
+        return PersistentVolumeClaim(
+            name=f"{self.name}-scratch",
+            namespace=self.namespace,
+            client=self.client,
+        )
+
+    def _check_none_pending_status(self, failure_timeout=120):
+        # Avoid waiting for "Succeeded" status if DV's in Pending/None status
+        sample = None
+        # if garbage collector is enabled, DV will be deleted after success
+        try:
+            for sample in TimeoutSampler(
+                wait_timeout=failure_timeout,
+                sleep=10,
+                func=lambda: self.exists,
+            ):
+                # If DV status is Pending (or Status is not yet updated) continue to wait, else exit the wait loop
+                if sample and (
+                    not sample.status
+                    or sample.status.phase
+                    in [
+                        self.Status.PENDING,
+                        None,
+                    ]
+                ):
+                    continue
+                break
+        except TimeoutExpiredError:
+            self.logger.error(f"{self.name} status is {sample}")
+            raise
+
+    def wait_for_dv_success(self, timeout=600, failure_timeout=120):
+        self.logger.info(f"Wait DV success for {timeout} seconds")
+        self._check_none_pending_status(failure_timeout=failure_timeout)
+        self.pvc.wait_for_status(
+            status=PersistentVolumeClaim.Status.BOUND, timeout=timeout
+        )
+        # if garbage collector enabled, the DV deleted once succeeded
+        try:
+            for sample in TimeoutSampler(
+                sleep=1,
+                wait_timeout=timeout,
+                func=lambda: self.exists,
+            ):
+                # DV reach to success if the status is succeeded or if the DV does not exists
+                if sample is None or sample.status.phase == self.Status.SUCCEEDED:
+                    return
+        except TimeoutExpiredError:
+            self.logger.error(f"Status of {self.kind} {self.name} is {sample}")
+            raise
+
+    def delete(self, wait=False, timeout=TIMEOUT_4MINUTES, body=None):
+        """
+        Delete DataVolume
+
+        Args:
+            wait (bool): True to wait for DataVolume and PVC to be deleted.
+            timeout (int): Time to wait for resources deletion
+            body (dict): Content to send for delete()
+
+        Returns:
+            bool: True if delete succeeded, False otherwise.
+        """
+        # if garbage collector is enabled, DV will be deleted after success
+        if self.exists:
+            return super().delete(wait=wait, timeout=timeout, body=body)
+        else:
+            return self.pvc.delete(wait=wait, timeout=timeout, body=body)

ocp_resources/deployment.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+from ocp_resources.constants import PROTOCOL_ERROR_EXCEPTION_DICT, TIMEOUT_4MINUTES
+from ocp_resources.resource import NamespacedResource
+from ocp_resources.utils import TimeoutSampler
+
+
+class Deployment(NamespacedResource):
+    """
+    OpenShift Deployment object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.APPS
+
+    def scale_replicas(self, replica_count=int):
+        """
+        Update replicas in deployment.
+
+        Args:
+            replica_count (int): Number of replicas.
+
+        Returns:
+            Deployment is updated successfully
+        """
+        super().to_dict()
+        self.res.update({"spec": {"replicas": replica_count}})
+
+        self.logger.info(f"Set deployment replicas: {replica_count}")
+        return self.update(resource_dict=self.res)
+
+    def wait_for_replicas(self, deployed=True, timeout=TIMEOUT_4MINUTES):
+        """
+        Wait until all replicas are updated.
+
+        Args:
+            deployed (bool): True for replicas deployed, False for no replicas.
+            timeout (int): Time to wait for the deployment.
+
+        Raises:
+            TimeoutExpiredError: If not availableReplicas is equal to replicas.
+        """
+        self.logger.info(f"Wait for {self.kind} {self.name} to be deployed: {deployed}")
+        samples = TimeoutSampler(
+            wait_timeout=timeout,
+            sleep=1,
+            exceptions_dict=PROTOCOL_ERROR_EXCEPTION_DICT,
+            func=lambda: self.instance,
+        )
+        for sample in samples:
+            if sample:
+                status = sample.status
+
+                spec_replicas = sample.spec.replicas
+                total_replicas = status.replicas or 0
+                updated_replicas = status.updatedReplicas or 0
+                available_replicas = status.availableReplicas or 0
+                ready_replicas = status.readyReplicas or 0
+
+                if (
+                    (deployed and spec_replicas)
+                    and spec_replicas
+                    == updated_replicas
+                    == available_replicas
+                    == ready_replicas
+                ) or not (deployed or spec_replicas or total_replicas):
+                    return

ocp_resources/destination_rule.py

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+from ocp_resources.resource import NamespacedResource
+
+
+class DestinationRule(NamespacedResource):
+    """
+    Destination Rule object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.NETWORKING_ISTIO_IO

ocp_resources/event.py

@@ -0,0 +1,114 @@
+from ocp_resources.logger import get_logger
+
+
+LOGGER = get_logger(name=__name__)
+
+
+class Event:
+    """
+    Allow read and remove K8s events.
+    """
+
+    api_version = "v1"
+
+    @classmethod
+    def get(
+        cls,
+        dyn_client,
+        namespace=None,
+        name=None,
+        label_selector=None,
+        field_selector=None,
+        resource_version=None,
+        timeout=None,
+    ):
+        """
+        get - retrieves K8s events.
+
+        Args:
+            dyn_client (DynamicClient): K8s client
+            namespace (str): event namespace
+            name (str): event name
+            label_selector (str): filter events by labels; comma separated string of key=value
+            field_selector (str): filter events by fields; comma separated string of key=valueevent fields;
+                comma separated string of key=value
+            resource_version (str): filter events by their resource's version
+            timeout (int): timeout in seconds
+
+        Returns
+            list: event objects
+
+        example: reading all CSV Warning events in namespace "my-namespace", with reason of "AnEventReason"
+              for event in Event.get(
+                  default_client,
+                  namespace="my-namespace",
+                  field_selector="involvedObject.kind==ClusterServiceVersion,type==Warning,reason=AnEventReason",
+                  timeout=10,
+              ):
+                print(event.object)
+        """
+
+        LOGGER.info("Reading events")
+        LOGGER.debug(
+            f"get events parameters: namespace={namespace}, name={name}, label_selector={label_selector}, "
+            f"field_selector='{field_selector}', resource_version={resource_version}, timeout={timeout}"
+        )
+
+        event_listener = dyn_client.resources.get(
+            api_version=cls.api_version, kind=cls.__name__
+        )
+        yield from event_listener.watch(
+            namespace=namespace,
+            name=name,
+            label_selector=label_selector,
+            field_selector=field_selector,
+            resource_version=resource_version,
+            timeout=timeout,
+        )
+
+    @classmethod
+    def delete_events(
+        cls,
+        dyn_client,
+        namespace=None,
+        name=None,
+        label_selector=None,
+        field_selector=None,
+        resource_version=None,
+        timeout=None,
+    ):
+        """
+        delete_events - delete K8s events. For example, to cleanup events before test, in order to not get old
+            events in the test, in order to prevent false positive test.
+
+        Args:
+            dyn_client (DynamicClient): K8s client
+            namespace (str): event namespace
+            name (str): event name
+            label_selector (str): filter events by labels; comma separated string of key=value
+            field_selector (str): filter events by fields; comma separated string of key=valueevent fields;
+                comma separated string of key=value
+            resource_version (str): filter events by their resource's version
+            timeout (int): timeout in seconds
+
+        Returns
+            list: event objects
+
+        example: deleting all the event with a reason of "AnEventReason", from "my-namespace" namespace
+
+        def delete_events_before_test(default_client):
+          Event.delete_events(default_client, namespace=my-namespace, field_selector="reason=AnEventReason")
+        """
+        LOGGER.info("Deleting events")
+        LOGGER.debug(
+            f"delete_events parameters: namespace={namespace}, name={name}, label_selector={label_selector}, "
+            f"field_selector='{field_selector}', resource_version={resource_version}, timeout={timeout}"
+        )
+        dyn_client.resources.get(api_version=cls.api_version, kind=cls.__name__).delete(
+            namespace=namespace,
+            name=name,
+            label_selector=label_selector,
+            field_selector=field_selector,
+            resource_version=resource_version,
+            timeout=timeout,
+        )

ocp_resources/forklift_controller.py

@@ -0,0 +1,10 @@
+from ocp_resources.mtv import MTV
+from ocp_resources.resource import NamespacedResource
+
+
+class ForkliftController(NamespacedResource, MTV):
+    """
+    Migration Toolkit For Virtualization (MTV) ForkliftController Resource
+    """
+
+    api_group = NamespacedResource.ApiGroup.FORKLIFT_KONVEYOR_IO