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

ocp_resources/restore.py

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+
+from ocp_resources.resource import NamespacedResource
+
+
+class Restore(NamespacedResource):
+    """
+    Restore object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.VELERO_IO
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        included_namespaces=None,
+        backup_name=None,
+        client=None,
+        teardown=False,
+        privileged_client=None,
+        yaml_file=None,
+        **kwargs,
+    ):
+        if not backup_name:
+            raise ValueError("backup_name can't be None")
+
+        super().__init__(
+            name=name,
+            namespace=namespace,
+            client=client,
+            teardown=teardown,
+            privileged_client=privileged_client,
+            yaml_file=yaml_file,
+            **kwargs,
+        )
+
+        self.included_namespaces = included_namespaces
+        self.backup_name = backup_name
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            self.res.update(
+                {
+                    "spec": {
+                        "backupName": self.backup_name,
+                    }
+                }
+            )
+            if self.included_namespaces:
+                self.res["spec"]["includedNamespaces"] = self.included_namespaces

ocp_resources/role.py

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

ocp_resources/role_binding.py

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.resource import NamespacedResource
+
+
+class RoleBinding(NamespacedResource):
+    """
+    RoleBinding object
+    """
+
+    api_group = NamespacedResource.ApiGroup.RBAC_AUTHORIZATION_K8S_IO
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        client=None,
+        subjects_kind=None,
+        subjects_name=None,
+        subjects_namespace=None,
+        subjects_api_group=None,
+        role_ref_kind=None,
+        role_ref_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.subjects_kind = subjects_kind
+        self.subjects_name = subjects_name
+        self.subjects_namespace = subjects_namespace
+        self.subjects_api_group = subjects_api_group
+        self.role_ref_kind = role_ref_kind
+        self.role_ref_name = role_ref_name
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            subjects = {}
+            if self.subjects_kind:
+                subjects["kind"] = self.subjects_kind
+            if self.subjects_name:
+                subjects["name"] = self.subjects_name
+            if self.subjects_namespace:
+                subjects["namespace"] = self.subjects_namespace
+            if self.subjects_api_group:
+                subjects["apiGroup"] = self.subjects_api_group
+            if subjects:
+                self.res["subjects"] = [subjects]
+
+            roleref = {}
+            if self.role_ref_kind:
+                roleref["kind"] = self.role_ref_kind
+            if self.role_ref_name:
+                roleref["name"] = self.role_ref_name
+            if roleref:
+                roleref["apiGroup"] = self.api_group
+                self.res["roleRef"] = roleref

ocp_resources/route.py

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.resource import NamespacedResource
+
+
+class Route(NamespacedResource):
+    """
+    OpenShift Route object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.ROUTE_OPENSHIFT_IO
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        client=None,
+        service=None,
+        destination_ca_cert=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.service = service
+        self.destination_ca_cert = destination_ca_cert
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            if self.service:
+                self.res.update(
+                    {"spec": {"to": {"kind": "Service", "name": self.service}}}
+                )
+            if self.destination_ca_cert:
+                self.res["spec"]["tls"] = {
+                    "destinationCACertificate": self.destination_ca_cert,
+                    "termination": "reencrypt",
+                }
+
+    @property
+    def exposed_service(self):
+        """
+        returns the service the route is exposing
+        """
+        return self.instance.spec.to.name
+
+    @property
+    def host(self):
+        """
+        returns hostname that is exposing the service
+        """
+        return self.instance.spec.host
+
+    @property
+    def ca_cert(self):
+        """
+        returns destinationCACertificate
+        """
+        return self.instance.spec.tls.destinationCACertificate
+
+    @property
+    def termination(self):
+        """
+        returns a secured route using re-encrypt termination
+        """
+        return self.instance.spec.tls.termination

ocp_resources/secret.py

@@ -0,0 +1,75 @@
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.resource import NamespacedResource
+
+
+class Secret(NamespacedResource):
+    """
+    Secret object.
+    """
+
+    api_version = NamespacedResource.ApiVersion.V1
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        client=None,
+        accesskeyid=None,
+        secretkey=None,
+        htpasswd=None,
+        teardown=True,
+        data_dict=None,
+        string_data=None,
+        yaml_file=None,
+        delete_timeout=TIMEOUT_4MINUTES,
+        type=None,
+        **kwargs,
+    ):
+        super().__init__(
+            name=name,
+            namespace=namespace,
+            client=client,
+            teardown=teardown,
+            yaml_file=yaml_file,
+            delete_timeout=delete_timeout,
+            **kwargs,
+        )
+        self.accesskeyid = accesskeyid
+        self.secretkey = secretkey
+        self.htpasswd = htpasswd
+        self.data_dict = data_dict
+        self.string_data = string_data
+        self.type = type
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            if self.accesskeyid:
+                self.res.update(
+                    {
+                        "data": {
+                            "accessKeyId": self.accesskeyid,
+                            "secretKey": self.secretkey,
+                        }
+                    }
+                )
+            if self.htpasswd:
+                self.res.update({"data": {"htpasswd": self.htpasswd}})
+            if self.data_dict:
+                self.res.update({"data": self.data_dict})
+            if self.string_data:
+                self.res.update({"stringData": self.string_data})
+            if self.type:
+                self.res.update({"type": self.type})
+
+    @property
+    def certificate_not_after(self):
+        return self.instance.metadata.annotations[
+            "auth.openshift.io/certificate-not-after"
+        ]
+
+    @property
+    def certificate_not_before(self):
+        return self.instance.metadata.annotations[
+            "auth.openshift.io/certificate-not-before"
+        ]

ocp_resources/security_context_constraints.py

@@ -0,0 +1,9 @@
+from ocp_resources.resource import Resource
+
+
+class SecurityContextConstraints(Resource):
+    """
+    Security Context Constraints object.
+    """
+
+    api_group = Resource.ApiGroup.SECURITY_OPENSHIFT_IO

ocp_resources/service.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+
+from ocp_resources.resource import NamespacedResource
+
+
+class Service(NamespacedResource):
+    """
+    OpenShift Service object.
+    """
+
+    api_version = NamespacedResource.ApiVersion.V1
+
+    class Type:
+        CLUSTER_IP = "ClusterIP"
+        NODE_PORT = "NodePort"
+        LOAD_BALANCER = "LoadBalancer"

ocp_resources/service_account.py

@@ -0,0 +1,9 @@
+from ocp_resources.resource import NamespacedResource
+
+
+class ServiceAccount(NamespacedResource):
+    """
+    Service Account object
+    """
+
+    api_version = NamespacedResource.ApiVersion.V1

ocp_resources/service_mesh_control_plane.py

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+from ocp_resources.resource import NamespacedResource
+
+
+class ServiceMeshControlPlane(NamespacedResource):
+    """
+    Service Mesh Control Plane object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.MAISTRA_IO

ocp_resources/service_mesh_member_roll.py

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+
+from ocp_resources.resource import NamespacedResource
+
+
+class ServiceMeshMemberRoll(NamespacedResource):
+    """
+    Service Mesh Member Roll object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.MAISTRA_IO
+
+    class Status:
+        CONFIGURED = "Configured"

ocp_resources/service_monitor.py

@@ -0,0 +1,9 @@
+from ocp_resources.resource import NamespacedResource
+
+
+class ServiceMonitor(NamespacedResource):
+    """
+    Service Monitor object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.MONITORING_COREOS_COM

ocp_resources/sriov_network.py

@@ -0,0 +1,54 @@
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.resource import NamespacedResource
+
+
+class SriovNetwork(NamespacedResource):
+    """
+    SriovNetwork object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.SRIOVNETWORK_OPENSHIFT_IO
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        network_namespace=None,
+        client=None,
+        resource_name=None,
+        vlan=None,
+        ipam=None,
+        teardown=True,
+        yaml_file=None,
+        delete_timeout=TIMEOUT_4MINUTES,
+        macspoofchk=None,
+        **kwargs,
+    ):
+        super().__init__(
+            name=name,
+            namespace=namespace,
+            client=client,
+            teardown=teardown,
+            yaml_file=yaml_file,
+            delete_timeout=delete_timeout,
+            **kwargs,
+        )
+        self.network_namespace = network_namespace
+        self.resource_name = resource_name
+        self.vlan = vlan
+        self.ipam = ipam
+        self.macspoofchk = macspoofchk
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            self.res["spec"] = {
+                "ipam": self.ipam or "{}\n",
+                "networkNamespace": self.network_namespace,
+                "resourceName": self.resource_name,
+            }
+            if self.vlan:
+                self.res["spec"]["vlan"] = self.vlan
+
+            if self.macspoofchk:
+                self.res["spec"]["spoofChk"] = self.macspoofchk

ocp_resources/sriov_network_node_policy.py

@@ -0,0 +1,67 @@
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.resource import NamespacedResource
+
+
+class SriovNetworkNodePolicy(NamespacedResource):
+    """
+    SriovNetworkNodePolicy object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.SRIOVNETWORK_OPENSHIFT_IO
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        pf_names=None,
+        root_devices=None,
+        num_vfs=None,
+        resource_name=None,
+        client=None,
+        priority=None,
+        mtu=None,
+        node_selector=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.pf_names = pf_names
+        self.root_devices = root_devices
+        self.num_vfs = num_vfs
+        self.priority = priority
+        self.resource_name = resource_name
+        self.mtu = mtu
+        self.node_selector = node_selector
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            self.res["spec"] = {
+                "deviceType": "vfio-pci",
+                "nicSelector": {
+                    "pfNames": [self.pf_names],
+                    "rootDevices": [self.root_devices],
+                },
+                "numVfs": self.num_vfs,
+                "resourceName": self.resource_name,
+            }
+            if self.mtu:
+                self.res["spec"]["mtu"] = self.mtu
+            if self.priority:
+                self.res["spec"]["priority"] = self.priority
+            if self.node_selector:
+                self.res["spec"]["nodeSelector"] = self.node_selector
+            else:
+                self.res["spec"]["nodeSelector"] = {
+                    "feature.node.kubernetes.io/network-sriov.capable": "true"
+                }

ocp_resources/sriov_network_node_state.py

@@ -0,0 +1,44 @@
+from ocp_resources.resource import NamespacedResource
+from ocp_resources.utils import TimeoutExpiredError, TimeoutSampler
+
+
+class SriovNetworkNodeState(NamespacedResource):
+    """
+    SriovNetworkNodeState object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.SRIOVNETWORK_OPENSHIFT_IO
+
+    @property
+    def interfaces(self):
+        return self.instance.status.interfaces
+
+    @staticmethod
+    def iface_name(iface):
+        return iface.name
+
+    @staticmethod
+    def pciaddress(iface):
+        return iface.pciAddress
+
+    @staticmethod
+    def totalvfs(iface):
+        return iface.totalvfs
+
+    def wait_for_status_sync(self, wanted_status, timeout=1000):
+        self.logger.info(
+            f"Wait for {self.kind} {self.name} status to be {wanted_status}"
+        )
+        try:
+            for sample in TimeoutSampler(
+                wait_timeout=timeout,
+                sleep=3,
+                func=lambda: self.instance.status.syncStatus,
+            ):
+                if sample == wanted_status:
+                    return
+        except TimeoutExpiredError:
+            self.logger.error(
+                f"after {timeout} seconds, {self.name} status is {self.instance.status.syncStatus}"
+            )
+            raise

ocp_resources/ssp.py

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

ocp_resources/storage_class.py

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+
+from ocp_resources.resource import Resource
+
+
+class StorageClass(Resource):
+    """
+    StorageClass object.
+    """
+
+    api_group = Resource.ApiGroup.STORAGE_K8S_IO
+
+    class Types:
+        """
+        These are names of StorageClass instances when you run `oc get sc`
+        """
+
+        LOCAL_BLOCK = "local-block"
+        HOSTPATH = "hostpath-provisioner"
+        CEPH_RBD = "ocs-storagecluster-ceph-rbd"
+        NFS = "nfs"
+        HOSTPATH_CSI = "hostpath-csi"
+
+    class Provisioner:
+        HOSTPATH = "kubevirt.io/hostpath-provisioner"
+        NO_PROVISIONER = "kubernetes.io/no-provisioner"
+        CEPH_RBD = "openshift-storage.rbd.csi.ceph.com"
+        HOSTPATH_CSI = "kubevirt.io.hostpath-provisioner"
+
+    class VolumeBindingMode:
+        """
+        VolumeBindingMode indicates how PersistentVolumeClaims should be provisioned and bound.
+        When unset, Immediate is used.
+        When "Immediate", if you want to use the "node aware" hostpath-provisioner,
+        ProvisionOnNode annotations should be introduced to PVC.
+        Or in order to be able to use the hpp without specifying the node on the PVC,
+        since CNV-2.2, hpp supports for "WaitForFirstConsumer".
+        """
+
+        # TODO: Rename to Uppercase
+        Immediate = "Immediate"
+        WaitForFirstConsumer = "WaitForFirstConsumer"
+
+    class Annotations:
+        IS_DEFAULT_CLASS = (
+            f"{Resource.ApiGroup.STORAGECLASS_KUBERNETES_IO}/is-default-class"
+        )

ocp_resources/storage_map.py

@@ -0,0 +1,67 @@
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.mtv import MTV
+from ocp_resources.resource import NamespacedResource
+
+
+class StorageMap(NamespacedResource, MTV):
+    """
+    Migration Toolkit For Virtualization (MTV) StorageMap object.
+
+    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.
+        mapping (dict): Storage Resources Mapping
+            Example:
+                [ { "destination" : { "storageClass": "nfs",
+                                      "accessMode": " ReadWriteMany",
+                                      "volumeMode": "Filesystem" },
+                    "source" : { "id": "datastore-11" }},
+
+                  { "destination" : { "storageClass": "hss",
+                                      "accessMode": " ReadWriteMany",
+                                      "volumeMode": "Block" },
+                    "source" : { "name": "MyDatastore" }},
+
+                ]
+
+    """
+
+    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,
+        mapping=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.mapping = mapping
+        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.condition_message_ready = self.ConditionMessage.STORAGE_MAP_READY
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            self.res.update(self.map_to_dict)

ocp_resources/storage_profile.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+
+from ocp_resources.resource import Resource
+
+
+class StorageProfile(Resource):
+    api_group = Resource.ApiGroup.CDI_KUBEVIRT_IO