openshift-python-wrapper 10.0.55__tar.gz → 10.0.58__tar.gz

{openshift_python_wrapper-10.0.55 → openshift_python_wrapper-10.0.58}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openshift-python-wrapper
-Version: 10.0.55
+Version: 10.0.58
 Summary: Wrapper around https://github.com/kubernetes-client/python
 Home-page: https://github.com/RedHatQE/openshift-python-wrapper
 License: Apache-2.0
@@ -18,7 +18,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: colorlog (>=6.7.0,<7.0.0)
 Requires-Dist: jinja2 (>=3.1.2,<4.0.0)
-Requires-Dist: kubernetes (>=29.0.0,<30.0.0)
+Requires-Dist: kubernetes (>=30.0.0,<31.0.0)
 Requires-Dist: packaging (>=23.1,<24.0)
 Requires-Dist: python-benedict (>=0.33.0,<0.34.0)
 Requires-Dist: python-simple-logger (>=1.0.6)

openshift_python_wrapper-10.0.58/ocp_resources/application_aware_applied_cluster_resource_quota.py

@@ -0,0 +1,12 @@
+# API reference: https://github.com/kubevirt/application-aware-quota/tree/main/staging/src/kubevirt.io/application-aware-quota-api/pkg/apis/core/v1alpha1
+# TODO: update API reference when OCP doc is available
+
+from ocp_resources.resource import NamespacedResource
+
+
+class ApplicationAwareAppliedClusterResourceQuota(NamespacedResource):
+    """
+    ApplicationAwareAppliedClusterResourceQuota object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.AAQ_KUBEVIRT_IO

openshift_python_wrapper-10.0.58/ocp_resources/application_aware_cluster_resource_quota.py

@@ -0,0 +1,40 @@
+# API reference: https://github.com/kubevirt/application-aware-quota/tree/main/staging/src/kubevirt.io/application-aware-quota-api/pkg/apis/core/v1alpha1
+# TODO: update API reference when OCP doc is available
+from typing import Dict, Any
+
+from ocp_resources.resource import MissingRequiredArgumentError, Resource
+
+
+class ApplicationAwareClusterResourceQuota(Resource):
+    api_group = Resource.ApiGroup.AAQ_KUBEVIRT_IO
+
+    def __init__(
+        self,
+        quota: Dict[str, Any] | None = None,
+        selector: Dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Create ApplicationAwareClusterResourceQuota object.
+
+        Args:
+            quota (dict): defines the desired quota
+                example: {"hard": {"pod": 3, "requests.cpu": "500m"}}
+            selector (dict): Dict of Namespace labels/annotations to match
+                example: {"annotations": {"acrq-annotation": "true"}, "labels": {"matchLabels": {"acrq-label": "true"}}}
+        """
+        super().__init__(**kwargs)
+        self.quota = quota
+        self.selector = selector
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            if not (self.quota or self.selector):
+                raise MissingRequiredArgumentError(argument="'quota' or 'selector'")
+
+            self.res["spec"] = {}
+            _spec = self.res["spec"]
+
+            _spec["quota"] = self.quota
+            _spec["selector"] = self.selector

openshift_python_wrapper-10.0.58/ocp_resources/application_aware_resource_quota.py

@@ -0,0 +1,49 @@
+# API reference: https://github.com/kubevirt/application-aware-quota/tree/main/staging/src/kubevirt.io/application-aware-quota-api/pkg/apis/core/v1alpha1
+# TODO: update API reference when OCP doc is available
+from typing import Dict, Any, List
+
+from ocp_resources.resource import MissingRequiredArgumentError, NamespacedResource
+
+
+class ApplicationAwareResourceQuota(NamespacedResource):
+    api_group = NamespacedResource.ApiGroup.AAQ_KUBEVIRT_IO
+
+    def __init__(
+        self,
+        hard: Dict[str, Any] | None = None,
+        scope_selector: Dict[str, Any] | None = None,
+        scopes: List[str] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Create ApplicationAwareResourceQuota object.
+
+        Args:
+            hard (dict): set of desired hard limits
+                example: {"pod": 3, "requests.cpu": "500m", "requests.memory/vmi": "4Gi", "requests.instances/vmi": 2}
+            scope_selector (dict, optional): collection of filters
+                example: {"matchExpressions": [{"operator": "In", "scopeName": "PriorityClass", "values": ["low"]}]}
+            scopes (list, optional): collection of filters
+                example: ["Terminating", "PriorityClass"]
+        """
+        super().__init__(**kwargs)
+        self.hard = hard
+        self.scope_selector = scope_selector
+        self.scopes = scopes
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            if not self.hard:
+                raise MissingRequiredArgumentError(argument="hard")
+
+            self.res["spec"] = {}
+            _spec = self.res["spec"]
+
+            _spec["hard"] = self.hard
+
+            if self.scope_selector:
+                _spec["scopeSelector"] = self.scope_selector
+
+            if self.scopes:
+                _spec["scopes"] = self.scopes

openshift_python_wrapper-10.0.58/ocp_resources/ingress_controller.py

@@ -0,0 +1,221 @@
+from typing import Any, Dict, Optional
+from ocp_resources.resource import NamespacedResource
+
+
+class IngressController(NamespacedResource):
+    """
+    https://docs.openshift.com/container-platform/4.15/rest_api/operator_apis/ingresscontroller-operator-openshift-io-v1.html
+    """
+
+    api_group = NamespacedResource.ApiGroup.OPERATOR_OPENSHIFT_IO
+
+    def __init__(
+        self,
+        domain: Optional[str] = "",
+        replicas: Optional[int] = None,
+        endpoint_publishing_strategy: Optional[Dict[str, Any]] = None,
+        default_certificate: Optional[Dict[str, str]] = None,
+        namespace_selector: Optional[Dict[str, Any]] = None,
+        node_selector: Optional[Dict[str, Any]] = None,
+        route_selector: Optional[Dict[str, Any]] = None,
+        tls_security_profile: Optional[Dict[str, Any]] = None,
+        logging: Optional[Dict[str, Any]] = None,
+        route_admission: Optional[Dict[str, Any]] = None,
+        client_tls: Optional[Dict[str, Any]] = None,
+        trusted_ca: Optional[Dict[str, Any]] = None,
+        http_compression: Optional[Dict[str, str]] = None,
+        http_empty_requests_policy: Optional[str] = "",
+        http_error_code_pages: Optional[Dict[str, Any]] = None,
+        http_headers: Optional[Dict[str, Any]] = None,
+        node_placement: Optional[Dict[str, Any]] = None,
+        tuning_options: Optional[Dict[str, Any]] = None,
+        unsupported_config_overrides: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Args:
+            domain (str, optional): The domain for the ingress controller.
+            replicas (int, optional): The number of desired replicas.
+            endpoint_publishing_strategy (dict, optional): The strategy for publishing endpoints.
+                Example: {
+                    "type": "LoadBalancerService",
+                    "loadBalancer": {
+                        "scope": "External"
+                    }
+                }
+            default_certificate (dict, optional): A reference to a secret containing the default certificate.
+                Example: {
+                    "name": "default-cert-secret",
+                    "namespace": "openshift-ingress"
+                }
+            namespace_selector (dict, optional): A selector to select which namespaces the ingress controller should observe.
+                Example: {
+                    "matchLabels": {
+                        "app": "myapp"
+                    }
+                }
+            node_selector (dict, optional): A selector to select nodes the ingress controller should run on.
+                Example: {
+                    "matchLabels": {
+                        "node-role.kubernetes.io/worker": ""
+                    }
+                }
+            route_selector (dict, optional): A selector to select which routes the ingress controller should observe.
+                Example: {
+                    "matchLabels": {
+                        "route": "myroute"
+                    }
+                }
+            tls_security_profile (dict, optional): Settings for TLS connections.
+                Example: {
+                    "type": "Intermediate"
+                }
+            logging (dict, optional): Parameters for logging.
+                Example: {
+                    "access": {
+                        "destination": {
+                            "type": "Container",
+                            "name": "access-logs"
+                        }
+                    }
+                }
+            route_admission (dict, optional): Policy for handling new route claims.
+                Example: {
+                    "namespaceOwnership": "InterNamespaceAllowed"
+                }
+            client_tls (dict, optional): Client TLS settings, including `clientCA` and `clientCertificatePolicy`.
+                Example: {
+                    "clientCA": {
+                        "name": "client-ca",
+                        "namespace": "openshift-ingress"
+                    },
+                    "clientCertificatePolicy": "Required"
+                }
+            trusted_ca (dict, optional): TrustedCA data.
+                Example: {
+                    "name": "trusted-ca",
+                    "namespace": "openshift-config"
+                }
+            http_compression (dict, optional): Policy for HTTP traffic compression.
+                Example: {
+                    "type": "Gzip"
+                }
+            http_empty_requests_policy (str, optional): Policy for handling HTTP connections if the connection times out.
+            http_error_code_pages (dict, optional): Custom error pages.
+                Example: {
+                    "name": "custom-error-pages",
+                    "namespace": "openshift-config"
+                }
+            http_headers (dict, optional): Policy for HTTP headers.
+                Example: {
+                    "setHeaders": {
+                        "Strict-Transport-Security": "max-age=31536000; includeSubDomains"
+                    }
+                }
+            node_placement (dict, optional): Control over the scheduling of the ingress controller.
+                Example: {
+                    "nodeSelector": {
+                        "matchLabels": {
+                            "kubernetes.io/os": "linux"
+                        }
+                    },
+                    "tolerations": [
+                        {
+                            "effect": "NoSchedule",
+                            "operator": "Exists"
+                        }
+                    ]
+                }
+            tuning_options (dict, optional): Parameters for adjusting the performance of ingress controller pods.
+                Example: {
+                    "maxConnections": 10000
+                }
+            unsupported_config_overrides (dict, optional): Unsupported configuration options.
+                Example: {
+                    "customConfig": "value"
+                }
+        """
+        super().__init__(**kwargs)
+        self.domain = domain
+        self.replicas = replicas
+        self.endpoint_publishing_strategy = endpoint_publishing_strategy
+        self.default_certificate = default_certificate
+        self.namespace_selector = namespace_selector
+        self.node_selector = node_selector  # type: ignore
+        self.route_selector = route_selector
+        self.tls_security_profile = tls_security_profile
+        self.logging = logging
+        self.route_admission = route_admission
+        self.client_tls = client_tls
+        self.trusted_ca = trusted_ca
+        self.http_compression = http_compression
+        self.http_empty_requests_policy = http_empty_requests_policy
+        self.http_error_code_pages = http_error_code_pages
+        self.http_headers = http_headers
+        self.node_placement = node_placement
+        self.tuning_options = tuning_options
+        self.unsupported_config_overrides = unsupported_config_overrides
+
+    def to_dict(self) -> None:
+        super().to_dict()
+
+        if not self.yaml_file:
+            self.res["spec"] = {}
+            _spec = self.res["spec"]
+
+            if self.domain:
+                _spec["domain"] = self.domain
+
+            if self.replicas:
+                _spec["replicas"] = self.replicas
+
+            if self.endpoint_publishing_strategy:
+                _spec["endpointPublishingStrategy"] = self.endpoint_publishing_strategy
+
+            if self.default_certificate:
+                _spec["defaultCertificate"] = self.default_certificate
+
+            if self.namespace_selector:
+                _spec["namespaceSelector"] = self.namespace_selector
+
+            if self.node_selector:
+                _spec["nodeSelector"] = self.node_selector
+
+            if self.route_selector:
+                _spec["routeSelector"] = self.route_selector
+
+            if self.tls_security_profile:
+                _spec["tlsSecurityProfile"] = self.tls_security_profile
+
+            if self.logging:
+                _spec["logging"] = self.logging
+
+            if self.route_admission:
+                _spec["routeAdmission"] = self.route_admission
+
+            if self.client_tls:
+                _spec["clientTLS"] = self.client_tls
+
+            if self.trusted_ca:
+                _spec["trustedCA"] = self.trusted_ca
+
+            if self.http_compression:
+                _spec["httpCompression"] = self.http_compression
+
+            if self.http_empty_requests_policy:
+                _spec["httpEmptyRequestsPolicy"] = self.http_empty_requests_policy
+
+            if self.http_error_code_pages:
+                _spec["httpErrorCodePages"] = self.http_error_code_pages
+
+            if self.http_headers:
+                _spec["httpHeaders"] = self.http_headers
+
+            if self.node_placement:
+                _spec["nodePlacement"] = self.node_placement
+
+            if self.tuning_options:
+                _spec["tuningOptions"] = self.tuning_options
+
+            if self.unsupported_config_overrides:
+                _spec["unsupportedConfigOverrides"] = self.unsupported_config_overrides

openshift_python_wrapper-10.0.58/ocp_resources/proxy.py

@@ -0,0 +1,60 @@
+from typing import Any, Dict, List, Optional
+from ocp_resources.resource import Resource
+
+
+class Proxy(Resource):
+    """
+    https://docs.openshift.com/container-platform/4.15/rest_api/config_apis/proxy-config-openshift-io-v1.html
+    """
+
+    api_group = Resource.ApiGroup.CONFIG_OPENSHIFT_IO
+
+    def __init__(
+        self,
+        http_proxy: Optional[str] = "",
+        https_proxy: Optional[str] = "",
+        no_proxy: Optional[str] = "",
+        readiness_endpoints: Optional[List[str]] = None,
+        trusted_ca: Optional[Dict[str, str]] = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Args:
+            http_proxy (str, optional): URL of the proxy for HTTP requests.
+            https_proxy (str, optional): URL of the proxy for HTTPS requests.
+            no_proxy (str, optional): Comma-separated list of hostnames for which the proxy should not be used.
+            readiness_endpoints (list, optional): List of endpoints used to verify readiness of the proxy.
+            trusted_ca (dict, optional): Reference to a ConfigMap containing a CA certificate bundle.
+                Example: {
+                    "name": "trusted-ca-bundle",
+                    "namespace": "openshift-config"
+                }
+        """
+        super().__init__(**kwargs)
+        self.http_proxy = http_proxy
+        self.https_proxy = https_proxy
+        self.no_proxy = no_proxy
+        self.readiness_endpoints = readiness_endpoints
+        self.trusted_ca = trusted_ca
+
+    def to_dict(self) -> None:
+        super().to_dict()
+
+        if not self.yaml_file:
+            self.res["spec"] = {}
+            _spec = self.res["spec"]
+
+            if self.http_proxy:
+                _spec["httpProxy"] = self.http_proxy
+
+            if self.https_proxy:
+                _spec["httpsProxy"] = self.https_proxy
+
+            if self.no_proxy:
+                _spec["noProxy"] = self.no_proxy
+
+            if self.readiness_endpoints:
+                _spec["readinessEndpoints"] = self.readiness_endpoints
+
+            if self.trusted_ca:
+                _spec["trustedCA"] = self.trusted_ca

openshift_python_wrapper-10.0.58/ocp_resources/reclaim_space_cron_job.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+from typing import Any, Dict, Optional
+from ocp_resources.resource import NamespacedResource, MissingRequiredArgumentError
+
+
+class ReclaimSpaceCronJob(NamespacedResource):
+    """
+    https://github.com/csi-addons/kubernetes-csi-addons/blob/main/apis/csiaddons/v1alpha1/reclaimspacecronjob_types.go
+    """
+
+    api_group = NamespacedResource.ApiGroup.CSIADDONS_OPENSHIFT_IO
+
+    def __init__(
+        self,
+        schedule: Optional[str] = "",
+        job_template: Optional[Dict[str, Any]] = None,
+        concurrency_policy: Optional[str] = "",
+        successful_jobs_history_limit: Optional[int] = None,
+        failed_jobs_history_limit: Optional[int] = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Args:
+            schedule (Optional, str): schedule of the reclaim space cron job
+            job_template (Optional, dict): describes the reclaim space job that would be created when a reclaim space cronjob
+                would be executed
+                Example: https://github.com/csi-addons/kubernetes-csi-addons/blob/main/docs/reclaimspace.md
+            concurrency_policy (str, optional): indicates how to treat concurrent execution of a job
+            successful_jobs_history_limit (int, optional): number of successful jobs to retain
+            failed_jobs_history_limit (int, optional): number of failed jobs to retain start at scheduled time
+        """
+        super().__init__(
+            **kwargs,
+        )
+        self.job_template = job_template
+        self.schedule = schedule
+        self.concurrency_policy = concurrency_policy
+        self.successful_jobs_history_limit = successful_jobs_history_limit
+        self.failed_jobs_history_limit = failed_jobs_history_limit
+
+    def to_dict(self) -> None:
+        super().to_dict()
+        if not self.yaml_file:
+            if not (self.job_template and self.schedule):
+                raise MissingRequiredArgumentError(argument="'job_template' and 'schedule'")
+            self.res["spec"] = {"jobTemplate": self.job_template, "schedule": self.schedule}
+            spec_dict = self.res["spec"]
+            if self.successful_jobs_history_limit:
+                spec_dict["successfulJobsHistoryLimit"] = self.successful_jobs_history_limit
+            if self.failed_jobs_history_limit:
+                spec_dict["failedJobsHistoryLimit"] = self.failed_jobs_history_limit
+            if self.concurrency_policy:
+                spec_dict["concurrencyPolicy"] = self.concurrency_policy

openshift_python_wrapper-10.0.58/ocp_resources/reclaim_space_job.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+from typing import Any, Optional
+from ocp_resources.resource import NamespacedResource, MissingRequiredArgumentError
+
+
+class ReclaimSpaceJob(NamespacedResource):
+    """
+    https://github.com/csi-addons/kubernetes-csi-addons/blob/main/apis/csiaddons/v1alpha1/reclaimspacejob_types.go
+    """
+
+    api_group = NamespacedResource.ApiGroup.CSIADDONS_OPENSHIFT_IO
+
+    def __init__(
+        self,
+        backoff_limit: Optional[int] = None,
+        target: Optional[dict[str, Any]] = None,
+        retry_deadline_seconds: Optional[int] = None,
+        timeout_seconds_reclaim_job: int | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Args:
+            backoff_limit (int, Optional): The number of retries for a reclaim space job.
+            target (Optional, dict): Volume target on which the operation would be performed.
+            retryDeadlineSeconds (int, Optional): Duration in seconds relative to the start time that the
+                operation may be retried.
+            timeout_seconds_reclaim_job (int, Optional): Specifies the timeout in seconds for the grpc request sent to
+                the CSI driver.
+        """
+        super().__init__(
+            **kwargs,
+        )
+        self.backoff_limit = backoff_limit
+        self.target = target
+        self.retry_deadline_seconds = retry_deadline_seconds
+        self.timeout_seconds_reclaim_job = timeout_seconds_reclaim_job
+
+    def to_dict(self) -> None:
+        super().to_dict()
+        if not self.yaml_file:
+            if not self.target:
+                raise MissingRequiredArgumentError(argument="target")
+            self.res["spec"] = {"target": self.target}
+            spec_dict = self.res["spec"]
+            if self.retry_deadline_seconds:
+                spec_dict["retryDeadlineSeconds"] = self.retry_deadline_seconds
+            if self.timeout_seconds_reclaim_job:
+                spec_dict["timeout"] = self.timeout_seconds_reclaim_job
+            if self.backoff_limit:
+                spec_dict["backOffLimit"] = self.backoff_limit

{openshift_python_wrapper-10.0.55 → openshift_python_wrapper-10.0.58}/ocp_resources/resource.py

@@ -9,7 +9,7 @@ import sys
 from io import StringIO
 from signal import SIGINT, signal
 from types import TracebackType
-from typing import Optional
+from typing import Optional, Any, Dict, List
 
 import kubernetes
 from kubernetes.dynamic import DynamicClient, ResourceInstance
@@ -24,7 +24,7 @@ from kubernetes.dynamic.exceptions import (
 )
 from kubernetes.dynamic.resource import ResourceField
 from packaging.version import Version
-from simple_logger.logger import Any, Dict, List, get_logger, logging
+from simple_logger.logger import get_logger, logging
 from urllib3.exceptions import MaxRetryError
 
 from ocp_resources.constants import (
@@ -274,6 +274,7 @@ class Resource:
         CONFIG_OPENSHIFT_IO = "config.openshift.io"
         CONSOLE_OPENSHIFT_IO = "console.openshift.io"
         COORDINATION_K8S_IO = "coordination.k8s.io"
+        CSIADDONS_OPENSHIFT_IO = "csiaddons.openshift.io"
         DATA_IMPORT_CRON_TEMPLATE_KUBEVIRT_IO = "dataimportcrontemplate.kubevirt.io"
         DISCOVERY_K8S_IO = "discovery.k8s.io"
         EVENTS_K8S_IO = "events.k8s.io"
@@ -325,6 +326,7 @@ class Resource:
         SCHEDULING_K8S_IO = "scheduling.k8s.io"
         SECURITY_ISTIO_IO = "security.istio.io"
         SECURITY_OPENSHIFT_IO = "security.openshift.io"
+        SELF_NODE_REMEDIATION_MEDIK8S_IO = "self-node-remediation.medik8s.io"
         SNAPSHOT_STORAGE_K8S_IO = "snapshot.storage.k8s.io"
         SNAPSHOT_KUBEVIRT_IO = "snapshot.kubevirt.io"
         SRIOVNETWORK_OPENSHIFT_IO = "sriovnetwork.openshift.io"
@@ -438,7 +440,6 @@ class Resource:
         self._set_client_and_api_version()
 
     def _ensure_exists(self) -> None:
-        self.logger.error(self.namespace)
         if not self.exists:
             _name_for_raise = self.name if not self.namespace else f"{self.namespace}/{self.name}"
             raise ResourceNotFoundError(f"Resource `{self.kind}` `{_name_for_raise}` does not exist")

openshift_python_wrapper-10.0.58/ocp_resources/self_node_remediation_templates.py

@@ -0,0 +1,36 @@
+# API reference: https://github.com/medik8s/self-node-remediation
+from typing import Any
+
+from ocp_resources.resource import NamespacedResource
+
+
+class SelfNodeRemediationTemplate(NamespacedResource):
+    """
+    SelfNodeRemediationTemplate CRD
+    """
+
+    api_group = NamespacedResource.ApiGroup.SELF_NODE_REMEDIATION_MEDIK8S_IO
+
+    def __init__(
+        self,
+        remediation_strategy: str = "",
+        **kwargs: Any,
+    ) -> None:
+        """
+        Create SelfNodeRemediationTemplate object.
+
+        Args:
+            remediation_strategy (str, optional): The remediation method for unhealthy nodes.
+        """
+        super().__init__(
+            **kwargs,
+        )
+        self.remediation_strategy = remediation_strategy
+
+    def to_dict(self) -> None:
+        super().to_dict()
+        if not self.yaml_file:
+            _spec = self.res["spec"] = {"template": {"spec": {}}}
+
+            if self.remediation_strategy:
+                _spec["template"]["spec"]["remediationStrategy"] = self.remediation_strategy

{openshift_python_wrapper-10.0.55 → openshift_python_wrapper-10.0.58}/pyproject.toml

@@ -19,7 +19,7 @@ warn_unused_ignores = true
 
 [tool.poetry]
 name = "openshift-python-wrapper"
-version = "10.0.55"
+version = "10.0.58"
 description = "Wrapper around https://github.com/kubernetes-client/python"
 authors = ["Meni Yakove <myakove@gmail.com>", "Ruth Netser <rnetser@gmail.com>"]
 readme = "README.md"
@@ -60,7 +60,7 @@ build-backend = "poetry_dynamic_versioning.backend"
 python = "^3.8"
 xmltodict = "^0.13.0"
 colorlog = "^6.7.0"
-kubernetes = "^29.0.0"
+kubernetes = "^30.0.0"
 python-benedict = "^0.33.0"
 packaging = "^23.1"
 python-simple-logger = ">=1.0.6"