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

ocp_resources/machine_health_check.py

@@ -0,0 +1,76 @@
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.resource import NamespacedResource
+
+
+class MachineHealthCheck(NamespacedResource):
+    """
+    MachineHealthCheck object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.MACHINE_OPENSHIFT_IO
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        cluster_name=None,
+        machineset_name=None,
+        client=None,
+        machine_role="worker",
+        machine_type="worker",
+        node_startup_timeout="120m",
+        max_unhealthy=2,  # can also be a persentage, for e.g. "40%"
+        unhealthy_timeout="300s",
+        reboot_strategy=False,
+        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.cluster_name = cluster_name
+        self.machineset_name = machineset_name
+        self.machine_role = machine_role
+        self.machine_type = machine_type
+        self.node_startup_timeout = node_startup_timeout
+        self.max_unhealthy = max_unhealthy
+        self.unhealthy_timeout = unhealthy_timeout
+        self.reboot_strategy = reboot_strategy
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            if self.reboot_strategy:
+                self.res["metadata"]["annotations"] = {
+                    f"{self.api_group}/remediation-strategy": "external-baremetal"
+                }
+            self.res.setdefault("spec", {})
+            self.res["spec"]["nodeStartupTimeout"] = self.node_startup_timeout
+            self.res["spec"]["maxUnhealthy"] = self.max_unhealthy
+            self.res["spec"].setdefault("selector", {})
+            self.res["spec"]["selector"]["matchLabels"] = {
+                f"{self.api_group}/cluster-api-cluster": self.cluster_name,
+                f"{self.api_group}/cluster-api-machine-role": self.machine_role,
+                f"{self.api_group}/cluster-api-machine-type": self.machine_type,
+                f"{self.api_group}/cluster-api-machineset": self.machineset_name,
+            }
+            self.res["spec"]["unhealthyConditions"] = [
+                {
+                    "type": self.Condition.READY,
+                    "timeout": self.unhealthy_timeout,
+                    "status": self.Condition.Status.FALSE,
+                },
+                {
+                    "type": self.Condition.READY,
+                    "timeout": self.unhealthy_timeout,
+                    "status": self.Condition.Status.UNKNOWN,
+                },
+            ]

ocp_resources/machine_set.py

@@ -0,0 +1,189 @@
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.resource import NamespacedResource
+from ocp_resources.utils import TimeoutExpiredError, TimeoutSampler
+
+
+TIMEOUT_5MINUTES = 300
+
+
+class MachineSet(NamespacedResource):
+    """
+    Machineset object.
+
+    Args:
+        cluster_name (str): OpenShift cluster name.
+        machine_role (str): machine role. e.g.: 'worker'.
+        machine_type (str): machine role. e.g.: 'worker'.
+        replicas (int): amount of replicas the machine-set will have.
+        provider_spec (dict): provider spec information.
+
+        provider spec example:
+
+    {
+        "value": {
+            "apiVersion": "ovirtproviderconfig.machine.openshift.io/v1beta1",
+            "auto_pinning_policy": "none",
+            "cluster_id": "5612af70-f4f5-455d-b7df-fbad66accc38",
+            "cpu": {
+                "cores": 8,
+                "sockets": 1,
+                "threads": 1
+            },
+            "credentialsSecret": {
+                "name": "ovirt-credentials"
+            },
+            "kind": "OvirtMachineProviderSpec",
+            "memory_mb": 16000,
+            "os_disk": {
+                "size_gb": 31
+            },
+            "template_name": "ge2n1-gcwmg-rhcos",
+            "type": "server",
+            "userDataSecret": {
+                "name": "worker-user-data"
+            }
+        }
+    }
+    """
+
+    api_group = NamespacedResource.ApiGroup.MACHINE_OPENSHIFT_IO
+
+    def __init__(
+        self,
+        cluster_name=None,
+        name=None,
+        namespace=None,
+        teardown=True,
+        client=None,
+        machine_role="worker",
+        machine_type="worker",
+        replicas=1,
+        provider_spec=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.replicas = replicas
+        self.cluster_name = cluster_name
+        self.machine_role = machine_role
+        self.machine_type = machine_type
+        self.provider_spec = provider_spec or {}
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            _spec, _metadata, _labels = ("spec", "metadata", "labels")
+            (
+                _cluster_api_cluster,
+                _cluster_api_machine_role,
+                _cluster_api_machine_type,
+                _cluster_api_machineset,
+            ) = (
+                "cluster-api-cluster",
+                "cluster-api-machine-role",
+                "cluster-api-machine-type",
+                "cluster-api-machineset",
+            )
+
+            self.res[_metadata][_labels] = {
+                f"{self.api_group}/{_cluster_api_cluster}": self.cluster_name,
+                f"{self.api_group}/{_cluster_api_machine_role}": self.machine_role,
+                f"{self.api_group}/{_cluster_api_machine_type}": self.machine_type,
+            }
+
+            self.res[_spec] = {
+                "replicas": self.replicas,
+                "selector": {
+                    "matchLabels": {
+                        f"{self.api_group}/{_cluster_api_cluster}": self.cluster_name,
+                        f"{self.api_group}/{_cluster_api_machineset}": f"{self.cluster_name}-{self.machine_role}",
+                    }
+                },
+                "template": {
+                    _metadata: {
+                        _labels: {
+                            f"{self.api_group}/{_cluster_api_cluster}": self.cluster_name,
+                            f"{self.api_group}/{_cluster_api_machine_role}": self.machine_role,
+                            f"{self.api_group}/{_cluster_api_machine_type}": self.machine_type,
+                            f"{self.api_group}/{_cluster_api_machineset}": f"{self.cluster_name}-{self.machine_role}",
+                        }
+                    },
+                    _spec: {"providerSpec": self.provider_spec},
+                },
+            }
+
+    @property
+    def available_replicas(self):
+        return self.instance.status.availableReplicas
+
+    @property
+    def ready_replicas(self):
+        return self.instance.status.readyReplicas
+
+    @property
+    def desired_replicas(self):
+        return self.instance.status.replicas
+
+    @property
+    def provider_spec_value(self):
+        return self.instance.spec.template.spec.providerSpec.value
+
+    def wait_for_replicas(self, timeout=TIMEOUT_5MINUTES, sleep=1):
+        """
+        Wait for machine-set replicas to reach 'ready' state.
+
+        Args:
+            timeout (int): maximum time to wait_for_replicas for the 'ready' state.
+            sleep (int): sleep time between each sample.
+
+        Returns:
+            bool: True if machine-set reached 'ready' state, False otherwise.
+        """
+        try:
+            return any(
+                ready_replicas and ready_replicas == self.desired_replicas
+                for ready_replicas in TimeoutSampler(
+                    wait_timeout=timeout, sleep=sleep, func=lambda: self.ready_replicas
+                )
+            )
+        except TimeoutExpiredError:
+            self.logger.error(
+                f"Machine-set {self.name} replicas failed to reach into 'ready' state, actual ready replicas: "
+                f"{self.ready_replicas}, desired replicas: {self.desired_replicas}"
+            )
+            return False
+
+    def scale_replicas(
+        self, replicas, wait_timeout=TIMEOUT_5MINUTES, sleep=1, wait=True
+    ):
+        """
+        Scale down/up a machine-set replicas.
+
+        Args:
+            replicas (int): num of replicas to scale_replicas to.
+            wait_timeout (int): maximum time to wait_for_replicas for scaling the machine-set.
+            sleep (int): sleep time between each sample of the machine-set state.
+            wait (bool): True if waiting for machine-set to reach into 'ready' state, False otherwise.
+
+        Returns:
+            bool: True if scaling the machine-set was successful or wait=False, False otherwise.
+        """
+        super().to_dict()
+        self.res.update({"spec": {"replicas": replicas}})
+
+        self.logger.info(
+            f"Scale machine-set from {self.desired_replicas} replicas to {replicas} replicas"
+        )
+        self.update(resource_dict=self.res)
+        if wait:
+            return self.wait_for_replicas(timeout=wait_timeout, sleep=sleep)
+        return True

ocp_resources/migration.py

@@ -0,0 +1,63 @@
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.mtv import MTV
+from ocp_resources.resource import NamespacedResource
+
+
+class Migration(NamespacedResource, MTV):
+    """
+    Migration Toolkit For Virtualization (MTV) Migration object.
+
+    Args:
+        plan_name (str): MTV Plan CR name.
+        plan_namespace (str): MTV Plan CR namespace.
+        cut_over (date): For Warm Migration Only.Cut Over Phase Start Date & Time.
+
+    """
+
+    api_group = NamespacedResource.ApiGroup.FORKLIFT_KONVEYOR_IO
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        plan_name=None,
+        plan_namespace=None,
+        cut_over=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.plan_name = plan_name
+        self.plan_namespace = plan_namespace
+        self.cut_over = cut_over
+        self.condition_message_succeeded = self.ConditionMessage.MIGRATION_SUCCEEDED
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            self.res.update(
+                {
+                    "spec": {
+                        "plan": {
+                            "name": self.plan_name,
+                            "namespace": self.plan_namespace,
+                        }
+                    }
+                }
+            )
+
+            if self.cut_over:
+                self.res["spec"]["cutover"] = self.cut_over.strftime(
+                    format="%Y-%m-%dT%H:%M:%SZ"
+                )

ocp_resources/migration_policy.py

@@ -0,0 +1,66 @@
+from ocp_resources.resource import Resource
+
+
+class MigrationPolicy(Resource):
+    api_group = Resource.ApiGroup.MIGRATIONS_KUBEVIRT_IO
+
+    def __init__(
+        self,
+        name=None,
+        allow_auto_converge=None,
+        allow_post_copy=None,
+        bandwidth_per_migration=None,
+        completion_timeout_per_gb=None,
+        namespace_selector=None,
+        vmi_selector=None,
+        **kwargs,
+    ):
+        """
+        Create MigrationPolicy object.
+
+        Args:
+            name (str): Migration Policy name
+            allow_auto_converge (bool, optional)
+            allow_post_copy (bool, optional)
+            bandwidth_per_migration (str, optional, i.e. "1Gi")
+            completion_timeout_per_gb (int, optional)
+            namespace_selector (dict, optional): Dict of Namespace labels to match (e.g. {"project-owner": "redhat"})
+            vmi_selector (dict, optional): Dict of VMI labels to match (e.g. {"best-vm": ""})
+        """
+        super().__init__(
+            name=name,
+            **kwargs,
+        )
+        self.allow_auto_converge = allow_auto_converge
+        self.allow_post_copy = allow_post_copy
+        self.bandwidth_per_migration = bandwidth_per_migration
+        self.completion_timeout_per_gb = completion_timeout_per_gb
+        self.namespace_selector = namespace_selector or {}
+        self.vmi_selector = vmi_selector or {}
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            spec = self.res.setdefault("spec", {})
+            selectors = spec.setdefault("selectors", {})
+
+            if self.allow_auto_converge is not None:
+                self.res["spec"]["allowAutoConverge"] = self.allow_auto_converge
+            if self.allow_post_copy is not None:
+                self.res["spec"]["allowPostCopy"] = self.allow_post_copy
+            if self.bandwidth_per_migration:
+                self.res["spec"]["bandwidthPerMigration"] = self.bandwidth_per_migration
+            if self.completion_timeout_per_gb:
+                self.res["spec"][
+                    "completionTimeoutPerGiB"
+                ] = self.completion_timeout_per_gb
+
+            if self.namespace_selector:
+                selectors.setdefault("namespaceSelector", {}).setdefault(
+                    "matchLabels", self.namespace_selector
+                )
+
+            if self.vmi_selector:
+                selectors.setdefault("virtualMachineInstanceSelector", {}).setdefault(
+                    "matchLabels", self.vmi_selector
+                )

ocp_resources/mtv.py

@@ -0,0 +1,171 @@
+from ocp_resources.utils import TimeoutExpiredError, TimeoutSampler
+
+
+def _get_status_condition_log_message(**status_condition):
+    log_msg = "Waiting For: \n"
+    for status_condition_name, status_condition in status_condition.items():
+        log_msg += (
+            f"{status_condition_name}->{status_condition} \n"
+            if status_condition
+            else ""
+        )
+
+    return log_msg
+
+
+class MTV:
+    """
+    Abstract Class for all Migration ToolKit For Virtualization (MTV) Resources:
+        Provider
+        Plan
+        Migration
+        StorageMap
+        NetworkMap
+        Host
+        ForkliftController
+    """
+
+    def __init__(self):
+        self.api = None
+        self.name = None
+        self.namespace = None
+        self.kind = None
+        self.Condition = None
+        self.Status = None
+
+        self.condition_message_ready = None
+        self.condition_message_succeeded = None
+        self.mapping = None
+        self.source_provider_name = None
+        self.source_provider_namespace = None
+        self.destination_provider_name = None
+        self.destination_provider_namespace = None
+
+        if self.__class__.__name__ == "MTV":
+            raise TypeError("MTV is not a Resource. Please Use one of its successors.")
+
+    class ConditionMessage:
+        PROVIDER_READY = "The provider is ready."
+        NETWORK_MAP_READY = "The network map is ready."
+        STORAGE_MAP_READY = "The storage map is ready."
+        PLAN_READY = "The migration plan is ready."
+        PLAN_SUCCEEDED = "The plan execution has SUCCEEDED."
+        PLAN_FAILED = "The plan execution has FAILED."
+        MIGRATION_READY = "The migration is ready."
+        MIGRATION_RUNNING = "The migration is RUNNING"
+        MIGRATION_SUCCEEDED = "The migration has SUCCEEDED."
+        HOST_READY = "The host is ready."
+
+    class ConditionCategory:
+        CRITICAL = "Critical"
+
+    class ConditionType:
+        SUCCEEDED = "Succeeded"
+        FAILED = "Failed"
+        TARGET_NAME_NOT_VALID = "TargetNameNotValid"
+        VM_ALREADY_EXISTS = "VMAlreadyExists"
+
+    class ProviderType:
+        VSPHERE = "vsphere"
+        OPENSHIFT = "openshift"
+        RHV = "ovirt"
+
+    def wait_for_resource_status(
+        self,
+        condition_status,
+        condition_type,
+        condition_message=None,
+        condition_reason=None,
+        condition_category=None,
+        wait_timeout=600,
+    ):
+        """
+        Wait for MTV Resource Status Conditions.
+        """
+
+        self.logger.info(
+            _get_status_condition_log_message(
+                condition_status=condition_status,
+                condition_type=condition_type,
+                condition_message=condition_message,
+                condition_reason=condition_reason,
+                condition_category=condition_category,
+            )
+        )
+
+        samples = TimeoutSampler(
+            wait_timeout=wait_timeout,
+            sleep=1,
+            func=self.api.get,
+            field_selector=f"metadata.name=={self.name}",
+            namespace=self.namespace,
+        )
+        last_condition = None
+        try:
+            for sample in samples:
+                current_conditions = (
+                    sample.items[0].status.get("conditions")
+                    if sample.items and sample.items[0].status
+                    else []
+                )
+                for condition in current_conditions:
+                    last_condition = condition
+                    valid_status_type = (
+                        condition_status == condition.status
+                        and condition_type == condition.type
+                    )
+                    valid_message = (
+                        condition_message == condition.message
+                        or condition_message is None
+                    )
+                    valid_reason = (
+                        condition_reason == condition.reason or condition_reason is None
+                    )
+                    valid_category = (
+                        condition_category == condition.category
+                        or condition_category is None
+                    )
+                    if all(
+                        [valid_status_type, valid_message, valid_reason, valid_category]
+                    ):
+                        return
+
+        except TimeoutExpiredError:
+            self.logger.error(
+                msg=f"Last Status Condition of {self.kind} {self.name} was: {last_condition}"
+            )
+            raise
+
+    def wait_for_condition_ready(self, wait_timeout=360):
+        self.wait_for_resource_status(
+            condition_message=self.condition_message_ready,
+            condition_status=self.Condition.Status.TRUE,
+            condition_type=self.Condition.READY,
+            wait_timeout=wait_timeout,
+        )
+
+    def wait_for_condition_succeeded(self, wait_timeout=600):
+        self.wait_for_resource_status(
+            condition_type=self.Status.SUCCEEDED,
+            condition_message=self.condition_message_succeeded,
+            condition_status=self.Condition.Status.TRUE,
+            wait_timeout=wait_timeout,
+        )
+
+    @property
+    def map_to_dict(self):
+        return {
+            "spec": {
+                "map": self.mapping,
+                "provider": {
+                    "source": {
+                        "name": self.source_provider_name,
+                        "namespace": self.source_provider_namespace,
+                    },
+                    "destination": {
+                        "name": self.destination_provider_name,
+                        "namespace": self.destination_provider_namespace,
+                    },
+                },
+            }
+        }

ocp_resources/mutating_webhook_config.py

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

ocp_resources/namespace.py

@@ -0,0 +1,40 @@
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.resource import Resource
+
+
+class Namespace(Resource):
+    """
+    Namespace object, inherited from Resource.
+    """
+
+    api_version = Resource.ApiVersion.V1
+
+    class Status(Resource.Status):
+        ACTIVE = "Active"
+
+    def __init__(
+        self,
+        name=None,
+        client=None,
+        teardown=True,
+        label=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.label = label
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file and self.label:
+            self.res.setdefault("metadata", {}).setdefault("labels", {}).update(
+                self.label
+            )

ocp_resources/network.py

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

ocp_resources/network_addons_config.py

@@ -0,0 +1,9 @@
+from ocp_resources.resource import Resource
+
+
+class NetworkAddonsConfig(Resource):
+    """
+    NetworkAddonsConfig (a Custom Resource) object, inherited from Resource.
+    """
+
+    api_group = Resource.ApiGroup.NETWORKADDONSOPERATOR_NETWORK_KUBEVIRT_IO

ocp_resources/network_attachment_definition.py

@@ -0,0 +1,24 @@
+from ocp_resources.resource import NamespacedResource
+
+
+class NetworkAttachmentDefinition(NamespacedResource):
+    """
+    NetworkAttachmentDefinition object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.K8S_CNI_CNCF_IO
+    resource_name = None
+
+    def wait_for_status(
+        self, status, timeout=None, label_selector=None, resource_version=None
+    ):
+        raise NotImplementedError(f"{self.kind} does not have status")
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            if self.resource_name is not None:
+                self.res["metadata"]["annotations"] = {
+                    f"{NamespacedResource.ApiGroup.K8S_V1_CNI_CNCF_IO}/resourceName": self.resource_name
+                }
+            self.res["spec"] = {}