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

ocp_resources/node_network_state.py

@@ -0,0 +1,121 @@
+import time
+
+from openshift.dynamic.exceptions import ConflictError
+
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.resource import Resource
+from ocp_resources.utils import TimeoutSampler
+
+
+SLEEP = 1
+
+
+class NodeNetworkState(Resource):
+    api_group = Resource.ApiGroup.NMSTATE_IO
+
+    def __init__(
+        self,
+        name=None,
+        client=None,
+        teardown=True,
+        yaml_file=None,
+        delete_timeout=TIMEOUT_4MINUTES,
+        **kwargs,
+    ):
+        super().__init__(
+            name=name,
+            client=client,
+            teardown=teardown,
+            yaml_file=yaml_file,
+            delete_timeout=delete_timeout,
+            **kwargs,
+        )
+        status = self.instance.to_dict()["status"]
+        self.desired_state = status.get("desiredState", {"interfaces": []})
+
+    def set_interface(self, interface):
+        # First drop the interface is's already in the list
+        interfaces = [
+            iface
+            for iface in self.desired_state["interfaces"]
+            if iface["name"] != interface["name"]
+        ]
+
+        # Add the interface
+        interfaces.append(interface)
+        self.desired_state["interfaces"] = interfaces
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            self.res.update(
+                {
+                    "spec": {
+                        "nodeName": self.name,
+                        "managed": True,
+                        "desiredState": self.desired_state,
+                    }
+                }
+            )
+
+    def apply(self):
+        retries_on_conflict = 3
+        while True:
+            try:
+                self.res["metadata"] = self.instance.to_dict()["metadata"]
+                self.update(self.res)
+                break
+            except ConflictError as e:
+                retries_on_conflict -= 1
+                if retries_on_conflict == 0:
+                    raise e
+                time.sleep(1)
+
+    def wait_until_up(self, name):
+        def _find_up_interface():
+            iface = self.get_interface(name=name)
+            if iface.get("state") == self.Interface.State.UP:
+                return iface
+
+            return None
+
+        self.logger.info(f"Checking if interface {name} is up -- {self.name}")
+        samples = TimeoutSampler(
+            wait_timeout=TIMEOUT_4MINUTES, sleep=SLEEP, func=_find_up_interface
+        )
+        for sample in samples:
+            if sample:
+                return
+
+    def wait_until_deleted(self, name):
+        self.logger.info(f"Checking if interface {name} is deleted -- {self.name}")
+        samples = TimeoutSampler(
+            wait_timeout=self.delete_timeout,
+            sleep=SLEEP,
+            func=self.get_interface,
+            name=name,
+        )
+        for sample in samples:
+            if not sample:
+                return
+
+    @property
+    def interfaces(self):
+        return self.instance.to_dict()["status"]["currentState"]["interfaces"]
+
+    @property
+    def routes(self):
+        return self.instance.status.currentState.routes
+
+    def ipv4(self, iface):
+        for interface in self.interfaces:
+            if interface["name"] == iface:
+                addresses = interface["ipv4"]["address"]
+                if addresses:
+                    return interface["ipv4"]["address"][0]["ip"]
+
+    def get_interface(self, name):
+        for interface in self.interfaces:
+            if interface["name"] == name:
+                return interface
+        return {}

ocp_resources/oauth.py

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

ocp_resources/operator_condition.py

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

ocp_resources/operator_group.py

@@ -0,0 +1,37 @@
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.resource import NamespacedResource
+
+
+class OperatorGroup(NamespacedResource):
+    api_group = NamespacedResource.ApiGroup.OPERATORS_COREOS_COM
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        target_namespaces=None,
+        teardown=True,
+        client=None,
+        yaml_file=None,
+        delete_timeout=TIMEOUT_4MINUTES,
+        **kwargs,
+    ):
+        """
+        Args:
+            target_namespaces(list): namespaces in which to generate required RBAC access for its member Operators.
+        """
+        super().__init__(
+            name=name,
+            namespace=namespace,
+            client=client,
+            teardown=teardown,
+            yaml_file=yaml_file,
+            delete_timeout=delete_timeout,
+            **kwargs,
+        )
+        self.target_namespaces = target_namespaces
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            self.res.update({"spec": {"targetNamespaces": self.target_namespaces}})

ocp_resources/operator_hub.py

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

ocp_resources/operator_source.py

@@ -0,0 +1,50 @@
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.resource import NamespacedResource
+
+
+class OperatorSource(NamespacedResource):
+    api_group = NamespacedResource.ApiGroup.OPERATORS_COREOS_COM
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        registry_namespace=None,
+        display_name=None,
+        publisher=None,
+        secret=None,
+        client=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.registry_namespace = registry_namespace
+        self.display_name = display_name
+        self.publisher = publisher
+        self.secret = secret
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            self.res.update(
+                {
+                    "spec": {
+                        "type": "appregistry",
+                        "endpoint": "https://quay.io/cnr",
+                        "registryNamespace": self.registry_namespace,
+                        "displayName": self.display_name,
+                        "publisher": self.publisher,
+                        "authorizationToken": {"secretName": self.secret},
+                    }
+                }
+            )

ocp_resources/package_manifest.py

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

ocp_resources/peer_authentication.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+
+from ocp_resources.resource import NamespacedResource
+
+
+class PeerAuthentication(NamespacedResource):
+    """
+    Peer Authentication object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.SECURITY_ISTIO_IO
+
+    class MtlsMode:
+        """
+        mTLS Traffic Mode object.
+        """
+
+        STRICT = "STRICT"

ocp_resources/persistent_volume.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+
+from ocp_resources.resource import Resource
+
+
+class PersistentVolume(Resource):
+    """
+    PersistentVolume object
+    """
+
+    api_version = Resource.ApiVersion.V1
+
+    class Status(Resource.Status):
+        RELEASED = "Released"
+
+    @property
+    def max_available_pvs(self):
+        """
+        Returns the maximum number (int) of PV's which are in 'Available' state
+        """
+        return len(
+            [
+                pv
+                for pv in self.api.get()["items"]
+                if pv.status.phase == Resource.Condition.AVAILABLE
+            ]
+        )

ocp_resources/persistent_volume_claim.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.resource import NamespacedResource
+
+
+class PersistentVolumeClaim(NamespacedResource):
+    """
+    PersistentVolumeClaim object
+    """
+
+    api_version = NamespacedResource.ApiVersion.V1
+
+    class Status(NamespacedResource.Status):
+        BOUND = "Bound"
+
+    class AccessMode:
+        """
+        AccessMode object.
+        """
+
+        RWO = "ReadWriteOnce"
+        ROX = "ReadOnlyMany"
+        RWX = "ReadWriteMany"
+
+    class VolumeMode:
+        """
+        VolumeMode object
+        """
+
+        BLOCK = "Block"
+        FILE = "Filesystem"
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        client=None,
+        storage_class=None,
+        accessmodes=None,
+        volume_mode=VolumeMode.FILE,
+        size=None,
+        hostpath_node=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.accessmodes = accessmodes
+        self.volume_mode = volume_mode
+        self.size = size
+        self.hostpath_node = hostpath_node
+        self.storage_class = storage_class
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            self.res.update(
+                {
+                    "spec": {
+                        "volumeMode": self.volume_mode,
+                        "accessModes": [self.accessmodes],
+                        "resources": {"requests": {"storage": self.size}},
+                    }
+                }
+            )
+            """
+            Hostpath-provisioner is "node aware", when using it,
+            a node attribute on the claim must be introduced as follows.
+            annotations:
+              kubevirt.io/provisionOnNode: <specified_node_name>
+            """
+            if self.hostpath_node:
+                self.res["metadata"]["annotations"] = {
+                    "kubevirt.io/provisionOnNode": self.hostpath_node
+                }
+            if self.storage_class:
+                self.res["spec"]["storageClassName"] = self.storage_class
+
+    def bound(self):
+        """
+        Check if PVC is bound
+
+        Returns:
+            bool: True if bound else False
+        """
+        self.logger.info(f"Check if {self.kind} {self.name} is bound")
+        return self.status == self.Status.BOUND
+
+    @property
+    def selected_node(self):
+        return self.instance.metadata.annotations.get(
+            "volume.kubernetes.io/selected-node"
+        )

ocp_resources/plan.py

@@ -0,0 +1,143 @@
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.mtv import MTV
+from ocp_resources.resource import NamespacedResource
+
+
+class Plan(NamespacedResource, MTV):
+    """
+    Migration Tool for Virtualization (MTV) Plan Resource.
+
+    Args:
+        source_provider_name (str): MTV Source Provider CR name.
+        source_provider_namespace (str): MTV Source Provider CR namespace.
+        destination_provider_name (str): MTV Destination Provider CR name.
+        destination_provider_namespace (str): MTV Destination Provider CR namespace.
+        storage_map_name (str): MTV StorageMap CR name.
+        storage_map_namespace (str): MTV StorageMap CR namespace.
+        network_map_name (str): MTV NetworkMap CR name.
+        network_map_namespace (str): MTV NetworkMap CR CR namespace.
+        virtual_machines_list (list): A List of dicts, each contain
+                                      the Name Or Id of the source Virtual Machines to migrate.
+                                      Example: [ { "id": "vm-id-x" }, { "name": "vm-name-x" } ]
+        warm_migration (bool, default: False): Warm (True) or Cold (False) migration.
+    """
+
+    api_group = NamespacedResource.ApiGroup.FORKLIFT_KONVEYOR_IO
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        source_provider_name=None,
+        source_provider_namespace=None,
+        destination_provider_name=None,
+        destination_provider_namespace=None,
+        storage_map_name=None,
+        storage_map_namespace=None,
+        network_map_name=None,
+        network_map_namespace=None,
+        virtual_machines_list=None,
+        target_namespace=None,
+        warm_migration=False,
+        pre_hook_name=None,
+        pre_hook_namespace=None,
+        after_hook_name=None,
+        after_hook_namespace=None,
+        client=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_provider_name = source_provider_name
+        self.source_provider_namespace = source_provider_namespace
+        self.destination_provider_name = destination_provider_name
+        self.destination_provider_namespace = destination_provider_namespace
+        self.storage_map_name = storage_map_name
+        self.storage_map_namespace = storage_map_namespace
+        self.network_map_name = network_map_name
+        self.network_map_namespace = network_map_namespace
+        self.virtual_machines_list = virtual_machines_list
+        self.warm_migration = warm_migration
+        self.pre_hook_name = pre_hook_name
+        self.pre_hook_namespace = pre_hook_namespace
+        self.after_hook_name = after_hook_name
+        self.after_hook_namespace = after_hook_namespace
+        self.target_namespace = target_namespace or self.namespace
+        self.condition_message_ready = self.ConditionMessage.PLAN_READY
+        self.condition_message_succeeded = self.ConditionMessage.PLAN_SUCCEEDED
+
+        def generate_hook_spec(hook_name, hook_namespace, hook_type):
+            hook = {
+                "hook": {
+                    "name": hook_name,
+                    "namespace": hook_namespace,
+                },
+                "step": hook_type,
+            }
+            return hook
+
+        hooks_array = []
+        if self.pre_hook_name and self.pre_hook_namespace:
+            hooks_array.append(
+                generate_hook_spec(
+                    hook_name=self.pre_hook_name,
+                    hook_namespace=self.pre_hook_namespace,
+                    hook_type="PreHook",
+                )
+            )
+
+        if self.after_hook_name and self.after_hook_namespace:
+            hooks_array.append(
+                generate_hook_spec(
+                    hook_name=self.after_hook_name,
+                    hook_namespace=self.after_hook_namespace,
+                    hook_type="AfterHook",
+                )
+            )
+
+        if hooks_array:
+            for vm in self.virtual_machines_list:
+                vm["hooks"] = hooks_array
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            self.res.update(
+                {
+                    "spec": {
+                        "warm": self.warm_migration,
+                        "targetNamespace": self.target_namespace,
+                        "map": {
+                            "storage": {
+                                "name": self.storage_map_name,
+                                "namespace": self.storage_map_namespace,
+                            },
+                            "network": {
+                                "name": self.network_map_name,
+                                "namespace": self.network_map_namespace,
+                            },
+                        },
+                        "vms": self.virtual_machines_list,
+                        "provider": {
+                            "source": {
+                                "name": self.source_provider_name,
+                                "namespace": self.source_provider_namespace,
+                            },
+                            "destination": {
+                                "name": self.destination_provider_name,
+                                "namespace": self.destination_provider_namespace,
+                            },
+                        },
+                    }
+                }
+            )