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

ocp_resources/pod.py

@@ -0,0 +1,175 @@
+import json
+
+import kubernetes
+
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.node import Node
+from ocp_resources.resource import NamespacedResource, kube_v1_api
+from ocp_resources.utils import TimeoutWatch
+
+
+class ExecOnPodError(Exception):
+    def __init__(self, command, rc, out, err):
+        self.cmd = command
+        self.rc = rc
+        self.out = out
+        self.err = err
+
+    def __str__(self):
+        return (
+            f"Command execution failure: "
+            f"{self.cmd}, "
+            f"RC: {self.rc}, "
+            f"OUT: {self.out}, "
+            f"ERR: {self.err}"
+        )
+
+
+class Pod(NamespacedResource):
+    """
+    Pod object, inherited from Resource.
+    """
+
+    api_version = NamespacedResource.ApiVersion.V1
+
+    class Status(NamespacedResource.Status):
+        CRASH_LOOPBACK_OFF = "CrashLoopBackOff"
+        IMAGE_PULL_BACK_OFF = "ImagePullBackOff"
+        ERR_IMAGE_PULL = "ErrImagePull"
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        client=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,
+        )
+
+    @property
+    def containers(self):
+        """
+        Get Pod containers
+
+        Returns:
+            list: List of Pod containers
+        """
+        return self.instance.spec.containers
+
+    def execute(self, command, timeout=60, container=None, ignore_rc=False):
+        """
+        Run command on Pod
+
+        Args:
+            command (list): Command to run.
+            timeout (int): Time to wait for the command.
+            container (str): Container name where to exec the command.
+            ignore_rc (bool): If True ignore error rc from the shell and return out.
+
+        Returns:
+            str: Command output.
+
+        Raises:
+            ExecOnPodError: If the command failed.
+        """
+        error_channel = {}
+        stream_closed_error = "stream resp is closed"
+        self.logger.info(f"Execute {command} on {self.name} ({self.node.name})")
+        resp = kubernetes.stream.stream(
+            api_method=self._kube_v1_api.connect_get_namespaced_pod_exec,
+            name=self.name,
+            namespace=self.namespace,
+            command=command,
+            container=container or self.containers[0].name,
+            stderr=True,
+            stdin=False,
+            stdout=True,
+            tty=False,
+            _preload_content=False,
+        )
+
+        timeout_watch = TimeoutWatch(timeout=timeout)
+        while resp.is_open():
+            resp.run_forever(timeout=2)
+            try:
+                error_channel = json.loads(
+                    resp.read_channel(kubernetes.stream.ws_client.ERROR_CHANNEL)
+                )
+                break
+            except json.decoder.JSONDecodeError:
+                # Check remaining time, in order to throw exception
+                # if remaining time reached zero
+                if timeout_watch.remaining_time() <= 0:
+                    raise ExecOnPodError(
+                        command=command, rc=-1, out="", err=stream_closed_error
+                    )
+
+        rcstring = error_channel.get("status")
+        if rcstring is None:
+            raise ExecOnPodError(
+                command=command, rc=-1, out="", err=stream_closed_error
+            )
+
+        stdout = resp.read_stdout(timeout=5)
+        stderr = resp.read_stderr(timeout=5)
+
+        if rcstring == "Success" or ignore_rc:
+            return stdout
+
+        if rcstring == "Failure":
+            raise ExecOnPodError(command=command, rc=-1, out="", err=error_channel)
+
+        returncode = [
+            int(cause["message"])
+            for cause in error_channel["details"]["causes"]
+            if cause["reason"] == "ExitCode"
+        ][0]
+
+        raise ExecOnPodError(command=command, rc=returncode, out=stdout, err=stderr)
+
+    def log(self, **kwargs):
+        """
+        Get Pod logs
+
+        Returns:
+            str: Pod logs.
+        """
+        return self._kube_v1_api.read_namespaced_pod_log(
+            name=self.name, namespace=self.namespace, **kwargs
+        )
+
+    @property
+    def node(self):
+        """
+        Get the node name where the Pod is running
+
+        Returns:
+            Node: Node
+        """
+        node_name = self.instance.spec.nodeName
+        assert node_name, f"Node not found for pod {self.name}"
+        return Node(
+            client=self.privileged_client or self.client,
+            name=node_name,
+        )
+
+    @property
+    def ip(self):
+        return self.instance.status.podIP
+
+    @property
+    def _kube_v1_api(self):
+        return kube_v1_api(api_client=self.client.client)

ocp_resources/pod_disruption_budget.py

@@ -0,0 +1,53 @@
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.resource import NamespacedResource
+
+
+class PodDisruptionBudget(NamespacedResource):
+    """
+    PodDisruptionBudget object
+    """
+
+    api_group = NamespacedResource.ApiGroup.POLICY
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        client=None,
+        min_available=None,
+        max_unavailable=None,
+        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.min_available = min_available
+        self.max_unavailable = max_unavailable
+        self.selector = selector
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            update_dict = {
+                "spec": {
+                    "selector": self.selector,
+                },
+            }
+
+            if self.min_available is not None:
+                update_dict["spec"]["minAvailable"] = self.min_available
+
+            if self.max_unavailable is not None:
+                update_dict["spec"]["maxUnavailable"] = self.max_unavailable
+
+            self.res.update(update_dict)

ocp_resources/priority_class.py

@@ -0,0 +1,48 @@
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.resource import Resource
+
+
+class PriorityClass(Resource):
+    """
+    Priority Class object.
+    """
+
+    api_group = Resource.ApiGroup.SCHEDULING_K8S_IO
+
+    def __init__(
+        self,
+        name=None,
+        client=None,
+        teardown=True,
+        value=None,
+        global_default=False,
+        description=None,
+        preemption_policy=None,
+        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,
+        )
+        self.value = value
+        self.global_default = global_default
+        self.description = description
+        self.preemption_policy = preemption_policy
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            if self.value:
+                self.res["value"] = self.value
+            if self.global_default:
+                self.res["globalDefault"] = self.global_default
+            if self.description:
+                self.res["description"] = self.description
+            if self.preemption_policy:
+                self.res["preemptionPolicy"] = self.preemption_policy

ocp_resources/project.py

@@ -0,0 +1,60 @@
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.resource import Resource
+
+
+class Project(Resource):
+    """
+    Project object.
+    This is openshift's object which represents Namespace
+    """
+
+    api_group = Resource.ApiGroup.PROJECT_OPENSHIFT_IO
+
+    class Status(Resource.Status):
+        ACTIVE = "Active"
+
+    def clean_up(self):
+        Project(name=self.name).delete(wait=True)
+
+
+class ProjectRequest(Resource):
+    """
+    RequestProject object.
+    Resource which adds Project and grand
+    full access to user who originated this request
+    """
+
+    api_group = Resource.ApiGroup.PROJECT_OPENSHIFT_IO
+
+    def __init__(
+        self,
+        name=None,
+        client=None,
+        teardown=True,
+        timeout=TIMEOUT_4MINUTES,
+        yaml_file=None,
+        delete_timeout=TIMEOUT_4MINUTES,
+        **kwargs,
+    ):
+        super().__init__(
+            name=name,
+            client=client,
+            teardown=teardown,
+            timeout=timeout,
+            yaml_file=yaml_file,
+            delete_timeout=delete_timeout,
+            **kwargs,
+        )
+
+    def clean_up(self):
+        Project(name=self.name).delete(wait=True)
+
+    def client_wait_deleted(self, timeout):
+        """
+        client-side Wait until resource is deleted
+
+        Args:
+            timeout (int): Time to wait for the resource.
+
+        """
+        super().client_wait_deleted(timeout=timeout)

ocp_resources/prometheus.py

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

ocp_resources/prometheus_rule.py

@@ -0,0 +1,9 @@
+from ocp_resources.resource import NamespacedResource
+
+
+class PrometheusRule(NamespacedResource):
+    """
+    Prometheus Rule object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.MONITORING_COREOS_COM

ocp_resources/provider.py

@@ -0,0 +1,59 @@
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.mtv import MTV
+from ocp_resources.resource import NamespacedResource
+
+
+class Provider(NamespacedResource, MTV):
+    """
+    Migration Toolkit For Virtualization (MTV) Provider object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.FORKLIFT_KONVEYOR_IO
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        provider_type=None,
+        url=None,
+        secret_name=None,
+        secret_namespace=None,
+        vddk_init_image=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.provider_type = provider_type
+        self.url = url
+        self.secret_name = secret_name
+        self.secret_namespace = secret_namespace
+        self.condition_message_ready = self.ConditionMessage.PROVIDER_READY
+        self.vddk_init_image = vddk_init_image
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            self.res.update(
+                {
+                    "spec": {
+                        "type": self.provider_type,
+                        "url": self.url,
+                        "secret": {
+                            "name": self.secret_name,
+                            "namespace": self.secret_namespace,
+                        },
+                        "settings": {"vddkInitImage": self.vddk_init_image},
+                    }
+                }
+            )

ocp_resources/replicaset.py

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