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

ocp_resources/api_service.py

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

ocp_resources/backup.py

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+
+from ocp_resources.resource import NamespacedResource
+
+
+class Backup(NamespacedResource):
+    """
+    Backup object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.VELERO_IO
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        included_namespaces=None,
+        client=None,
+        teardown=False,
+        privileged_client=None,
+        yaml_file=None,
+        excluded_resources=None,
+        **kwargs,
+    ):
+        if not included_namespaces:
+            raise ValueError("included_namespaces 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.excluded_resources = excluded_resources
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            self.res.update(
+                {
+                    "spec": {
+                        "includedNamespaces": self.included_namespaces,
+                    }
+                }
+            )
+
+            if self.excluded_resources:
+                self.res["spec"]["excludedResources"] = self.excluded_resources

ocp_resources/benchmark.py

@@ -0,0 +1,92 @@
+from ocp_resources.constants import NOT_FOUND_ERROR_EXCEPTION_DICT
+from ocp_resources.resource import NamespacedResource
+from ocp_resources.utils import TimeoutSampler
+
+
+class Benchmark(NamespacedResource):
+    """
+    Benchmark resource
+    Defined by https://github.com/cloud-bulldozer/benchmark-operator
+
+    The benchmark-operator monitors a namespace for `Benchmark` resources.
+    When a new `Benchmark` is created, the benchmark-operator creates and starts the pods or VMs necessary,
+    and triggers the benchmark run.
+    """
+
+    api_group = NamespacedResource.ApiGroup.RIPSAW_CLOUDBULLDOZER_IO
+
+    class Status:
+        NONE = None  # None state is valid for newly created benchmark resources
+
+    class Workload:
+        class Kind:
+            VM = "vm"
+            POD = "pod"
+
+    def _wait_for_instance_key(self, parent, key):
+        """
+        Wait for key to exist in parent attribute of instance
+
+        Args:
+            parent (str): An attribute of self.instance that should contain key
+            key (str): A dictionary entry within parent
+
+        Returns:
+            str or None: Value of key if found, otherwise None
+        """
+        samples = TimeoutSampler(
+            wait_timeout=30,
+            sleep=1,
+            func=lambda: getattr(self.instance, parent, None),
+            exceptions_dict=NOT_FOUND_ERROR_EXCEPTION_DICT,
+        )
+        for sample in samples:
+            if sample:
+                return sample.get(key)
+
+    @property
+    def uuid(self):
+        """
+        Returns:
+            str: UUID string from resource instance
+        """
+        return self._wait_for_instance_key(parent="status", key="uuid")
+
+    @property
+    def suuid(self):
+        """
+        Returns:
+            str: (short)UUID string from resource instance
+        """
+        return self._wait_for_instance_key(parent="status", key="suuid")
+
+    @property
+    def workload_kind(self):
+        """
+        Retrieve the value of spec.workload.args.kind
+
+        Not all Benchmarks have a 'kind' defined, this was added for vms. The default is 'pod'
+
+        Returns:
+            str: Value representing workload kind
+
+        """
+        return self.workload_arg(arg="kind", default="pod")
+
+    def workload_arg(self, arg, default=None):
+        """
+        Retrieve the value of spec.workload.args[arg]
+
+        To provide a similar usage as .get(), a default can be defined if needed.
+
+        Args:
+            arg (str): Argument to retrieve from spec.workload.args
+            default (any): Default value to return if arg is not found in workload args
+
+        Returns:
+            any: Value of workload arg or 'default' if does not exist
+        """
+        workload = self._wait_for_instance_key(parent="spec", key="workload")
+        if workload:
+            return workload.get("args", {}).get(arg, default)
+        return default

ocp_resources/catalog_source.py

@@ -0,0 +1,63 @@
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.resource import NamespacedResource
+
+
+class CatalogSource(NamespacedResource):
+    api_group = NamespacedResource.ApiGroup.OPERATORS_COREOS_COM
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        client=None,
+        source_type=None,
+        image=None,
+        display_name=None,
+        publisher=None,
+        teardown=True,
+        yaml_file=None,
+        delete_timeout=TIMEOUT_4MINUTES,
+        update_strategy_registry_poll_interval=None,
+        **kwargs,
+    ):
+        super().__init__(
+            name=name,
+            namespace=namespace,
+            client=client,
+            teardown=teardown,
+            yaml_file=yaml_file,
+            delete_timeout=delete_timeout,
+            **kwargs,
+        )
+        self.source_type = source_type
+        self.image = image
+        self.display_name = display_name
+        self.publisher = publisher
+        self.update_strategy_registry_poll_interval = (
+            update_strategy_registry_poll_interval
+        )
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            self.res.update(
+                {
+                    "spec": {
+                        "sourceType": self.source_type,
+                        "image": self.image,
+                        "displayName": self.display_name,
+                        "publisher": self.publisher,
+                    }
+                }
+            )
+
+            if self.update_strategy_registry_poll_interval:
+                self.res["spec"].update(
+                    {
+                        "updateStrategy": {
+                            "registryPoll": {
+                                "interval": self.update_strategy_registry_poll_interval,
+                            },
+                        },
+                    }
+                )

ocp_resources/catalog_source_config.py

@@ -0,0 +1,86 @@
+from ocp_resources.constants import PROTOCOL_ERROR_EXCEPTION_DICT, TIMEOUT_4MINUTES
+from ocp_resources.resource import NamespacedResource
+from ocp_resources.utils import TimeoutExpiredError, TimeoutSampler
+
+
+class CatalogSourceConfig(NamespacedResource):
+    api_group = NamespacedResource.ApiGroup.OPERATORS_COREOS_COM
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        source=None,
+        target_namespace=None,
+        packages=None,
+        cs_display_name=None,
+        cs_publisher=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 = source
+        self.target_namespace = target_namespace
+        self.packages = packages
+        self.cs_display_name = cs_display_name
+        self.cs_publisher = cs_publisher
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            self.res.update(
+                {
+                    "spec": {
+                        "source": self.source,
+                        "targetNamespace": self.target_namespace,
+                        "packages": self.packages,
+                        "csDisplayName": self.cs_display_name,
+                        "csPublisher": self.cs_publisher,
+                    }
+                }
+            )
+
+    def wait_for_csc_status(self, status, timeout=120):
+        """
+        Wait for CatalogSourceConfig to reach requested status.
+        CatalogSourceConfig Status is found under currentPhase.phase.
+        Example phase: {'message': 'The object has been successfully reconciled', 'name': 'Succeeded'}
+
+        Raises:
+            TimeoutExpiredError: If CatalogSourceConfig in not in desire status.
+        """
+        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,
+        )
+        current_status = None
+        try:
+            for sample in samples:
+                if sample.items:
+                    sample_status = sample.items[0].status
+                    if sample_status:
+                        current_status = sample_status.currentPhase.phase["name"]
+                        if current_status == status:
+                            return
+
+        except TimeoutExpiredError:
+            if current_status:
+                self.logger.error(
+                    f"Status of {self.kind} {self.name} is {current_status}"
+                )
+            raise

ocp_resources/cdi.py

@@ -0,0 +1,13 @@
+from ocp_resources.resource import Resource
+
+
+class CDI(Resource):
+    """
+    CDI object.
+    """
+
+    api_group = Resource.ApiGroup.CDI_KUBEVIRT_IO
+
+    class Status(Resource.Status):
+        DEPLOYING = "Deploying"
+        DEPLOYED = "Deployed"

ocp_resources/cdi_config.py

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+
+from ocp_resources.constants import PROTOCOL_ERROR_EXCEPTION_DICT, TIMEOUT_4MINUTES
+from ocp_resources.resource import Resource
+from ocp_resources.utils import TimeoutSampler
+
+
+class CDIConfig(Resource):
+    """
+    CDIConfig object.
+    """
+
+    api_group = Resource.ApiGroup.CDI_KUBEVIRT_IO
+
+    @property
+    def scratch_space_storage_class_from_spec(self):
+        return self.instance.spec.scratchSpaceStorageClass
+
+    @property
+    def scratch_space_storage_class_from_status(self):
+        return self.instance.status.scratchSpaceStorageClass
+
+    @property
+    def upload_proxy_url(self):
+        return self.instance.status.uploadProxyURL
+
+    def wait_until_upload_url_changed(self, uploadproxy_url, timeout=TIMEOUT_4MINUTES):
+        """
+        Wait until upload proxy url is changed
+
+        Args:
+            timeout (int): Time to wait for CDI Config.
+
+        Returns:
+            bool: True if url is equal to uploadProxyURL.
+        """
+        self.logger.info(
+            f"Wait for {self.kind} {self.name} to ensure current URL == uploadProxyURL"
+        )
+        samples = TimeoutSampler(
+            wait_timeout=timeout,
+            sleep=1,
+            exceptions_dict=PROTOCOL_ERROR_EXCEPTION_DICT,
+            func=self.api.get,
+            field_selector=f"metadata.name=={self.name}",
+        )
+        for sample in samples:
+            if sample.items:
+                status = sample.items[0].status
+                current_url = status.uploadProxyURL
+                if current_url == uploadproxy_url:
+                    return

ocp_resources/chaos_engine.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+
+from ocp_resources.resource import NamespacedResource
+
+
+class ChaosEngine(NamespacedResource):
+    api_group = NamespacedResource.ApiGroup.LITMUS_IO
+
+    class EngineStatus:
+        INITIALIZED = "initialized"
+        COMPLETED = "completed"
+        STOPPED = "stopped"
+
+    @property
+    def engine_status(self):
+        return self.instance.status["engineStatus"]
+
+    @property
+    def experiments_status(self):
+        experiments = self.instance.status["experiments"]
+        ret_value = {}
+        for experiment in experiments:
+            exp = {"verdict": experiment["verdict"], "status": experiment["status"]}
+            ret_value[experiment["name"]] = exp
+        return ret_value
+
+    @property
+    def success(self):
+        exps = self.experiments_status
+        return all(exp["verdict"] == "Pass" for exp in exps.values())

ocp_resources/chaos_result.py

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+from ocp_resources.resource import NamespacedResource
+
+
+class ChaosResult(NamespacedResource):
+    """
+    ChaosResult resource used in Litmus experiments.
+    """
+
+    api_group = NamespacedResource.ApiGroup.LITMUS_IO

ocp_resources/cluster_operator.py

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

ocp_resources/cluster_role.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.resource import Resource
+
+
+class ClusterRole(Resource):
+    """
+    ClusterRole object
+    """
+
+    api_group = Resource.ApiGroup.RBAC_AUTHORIZATION_K8S_IO
+
+    def __init__(
+        self,
+        name=None,
+        client=None,
+        api_groups=None,
+        permissions_to_resources=None,
+        verbs=None,
+        teardown=True,
+        yaml_file=None,
+        delete_timeout=TIMEOUT_4MINUTES,
+        **kwargs,
+    ):
+        super().__init__(
+            client=client,
+            name=name,
+            teardown=teardown,
+            yaml_file=yaml_file,
+            delete_timeout=delete_timeout,
+            **kwargs,
+        )
+        self.api_groups = api_groups
+        self.permissions_to_resources = permissions_to_resources
+        self.verbs = verbs
+        self.desired_state = {"rules": []}
+
+    def to_dict(self):
+        if not self.res:
+            super().to_dict()
+
+        if not self.yaml_file and self.permissions_to_resources:
+            self.add_rule(
+                api_groups=self.api_groups,
+                permissions_to_resources=self.permissions_to_resources,
+                verbs=self.verbs,
+            )
+
+    def add_rule(
+        self,
+        api_groups=None,
+        permissions_to_resources=None,
+        verbs=None,
+    ):
+        if not self.res:
+            super().to_dict()
+
+        rule = {}
+        if api_groups:
+            rule["apiGroups"] = api_groups
+        if permissions_to_resources:
+            rule["resources"] = permissions_to_resources
+        if verbs:
+            rule["verbs"] = verbs
+        if rule:
+            self._set_rule(rule=rule)
+
+    def _set_rule(self, rule):
+        self.desired_state["rules"].append(rule)
+        self.res["rules"] = self.desired_state["rules"]

ocp_resources/cluster_role_binding.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+
+from ocp_resources.cluster_role import ClusterRole
+from ocp_resources.resource import Resource
+
+
+class ClusterRoleBinding(Resource):
+    """
+    ClusterRoleBinding object.
+    """
+
+    api_group = Resource.ApiGroup.RBAC_AUTHORIZATION_K8S_IO
+
+    def __init__(
+        self,
+        name=None,
+        cluster_role=None,
+        subjects=None,
+        **kwargs,
+    ):
+        super().__init__(name=name, **kwargs)
+        self.cluster_role = cluster_role
+        self.subjects = subjects
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            self.res.setdefault("roleRef", {})
+            self.res["roleRef"] = {
+                "apiGroup": self.api_group,
+                "kind": ClusterRole.kind,
+                "name": self.cluster_role,
+            }
+
+            if self.subjects:
+                self.res.setdefault("subjects", self.subjects)

ocp_resources/cluster_service_version.py

@@ -0,0 +1,8 @@
+from ocp_resources.resource import NamespacedResource
+
+
+class ClusterServiceVersion(NamespacedResource):
+    api_group = NamespacedResource.ApiGroup.OPERATORS_COREOS_COM
+
+    class Status(NamespacedResource.Status):
+        INSTALLING = "Installing"

ocp_resources/cluster_version.py

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

ocp_resources/configmap.py

@@ -0,0 +1,37 @@
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.resource import NamespacedResource
+
+
+class ConfigMap(NamespacedResource):
+    """
+    Configmap object
+    """
+
+    api_version = NamespacedResource.ApiVersion.V1
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        data=None,
+        teardown=True,
+        client=None,
+        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.data = data
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file and self.data:
+            self.res.setdefault("data", {}).update(self.data)

ocp_resources/console_cli_download.py

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

ocp_resources/console_plugin.py

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

ocp_resources/console_quick_start.py

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

ocp_resources/constants.py

@@ -0,0 +1,26 @@
+from kubernetes.dynamic.exceptions import ForbiddenError
+from openshift.dynamic.exceptions import (
+    InternalServerError,
+    NotFoundError,
+    ServerTimeoutError,
+)
+from urllib3.exceptions import MaxRetryError, ProtocolError
+
+
+DEFAULT_CLUSTER_RETRY_EXCEPTIONS = {
+    MaxRetryError: [],
+    ConnectionAbortedError: [],
+    ConnectionResetError: [],
+    InternalServerError: [
+        "etcdserver: leader changed",
+        "etcdserver: request timed out",
+        "Internal error occurred: failed calling webhook",
+        "rpc error:",
+    ],
+    ServerTimeoutError: [],
+    ForbiddenError: ["context deadline exceeded"],
+}
+PROTOCOL_ERROR_EXCEPTION_DICT = {ProtocolError: []}
+NOT_FOUND_ERROR_EXCEPTION_DICT = {NotFoundError: []}
+TIMEOUT_4MINUTES = 240
+TIMEOUT_1MINUTE = 60

ocp_resources/csidriver.py

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

ocp_resources/custom_resource_definition.py

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