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

ocp_resources/virtual_machine_import.py

@@ -0,0 +1,307 @@
+# -*- coding: utf-8 -*-
+
+
+from ocp_resources.constants import PROTOCOL_ERROR_EXCEPTION_DICT, TIMEOUT_4MINUTES
+from ocp_resources.resource import NamespacedResource
+from ocp_resources.utils import TimeoutExpiredError, TimeoutSampler
+from ocp_resources.virtual_machine import VirtualMachine
+
+
+def _map_mappings(mappings):
+    mappings_list = []
+    for mapping in mappings:
+        mapping_dict = {"target": {"name": mapping.target_name}}
+        if mapping.target_namespace:
+            mapping_dict["target"]["namespace"] = mapping.target_namespace
+        if mapping.target_type:
+            mapping_dict["type"] = mapping.target_type
+        if mapping.source_id:
+            mapping_dict.setdefault("source", {})["id"] = mapping.source_id
+        if mapping.source_name:
+            mapping_dict.setdefault("source", {})["name"] = mapping.source_name
+        if mapping.target_access_modes:
+            mapping_dict["accessMode"] = mapping.target_access_modes
+        if mapping.target_volume_mode:
+            mapping_dict["volumeMode"] = mapping.target_volume_mode
+        mappings_list.append(mapping_dict)
+    return mappings_list
+
+
+class VirtualMachineImport(NamespacedResource):
+    """
+    Virtual Machine Import object, inherited from NamespacedResource.
+    """
+
+    api_group = NamespacedResource.ApiGroup.V2V_KUBEVIRT_IO
+
+    class Condition(NamespacedResource.Condition):
+        SUCCEEDED = "Succeeded"
+        VALID = "Valid"
+        MAPPING_RULES_VERIFIED = "MappingRulesVerified"
+        PROCESSING = "Processing"
+
+    class ValidConditionReason:
+        """
+        Valid condition reason object
+        """
+
+        VALIDATION_COMPLETED = "ValidationCompleted"
+        SECRET_NOT_FOUND = "SecretNotFound"  # pragma: allowlist secret
+        RESOURCE_MAPPING_NOT_FOUND = "ResourceMappingNotFound"
+        UNINITIALIZED_PROVIDER = "UninitializedProvider"
+        SOURCE_VM_NOT_FOUND = "SourceVMNotFound"
+        INCOMPLETE_MAPPING_RULES = "IncompleteMappingRules"
+
+    class MappingRulesConditionReason:
+        """
+        Mapping rules verified condition reason object
+        """
+
+        MAPPING_COMPLETED = "MappingRulesVerificationCompleted"
+        MAPPING_FAILED = "MappingRulesVerificationFailed"
+        MAPPING_REPORTED_WARNINGS = "MappingRulesVerificationReportedWarnings"
+
+    class ProcessingConditionReason:
+        """
+        Processing condition reason object
+        """
+
+        CREATING_TARGET_VM = "CreatingTargetVM"
+        COPYING_DISKS = "CopyingDisks"
+        COMPLETED = "ProcessingCompleted"
+        FAILED = "ProcessingFailed"
+
+    class SucceededConditionReason:
+        """
+        Succeeced cond reason object
+        """
+
+        VALIDATION_FAILED = "ValidationFailed"
+        VM_CREATION_FAILED = "VMCreationFailed"
+        DATAVOLUME_CREATION_FAILED = "DataVolumeCreationFailed"
+        VIRTUAL_MACHINE_READY = "VirtualMachineReady"
+        VIRTUAL_MACHINE_RUNNING = "VirtualMachineRunning"
+        VMTEMPLATE_MATCHING_FAILED = "VMTemplateMatchingFailed"
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        provider_credentials_secret_name=None,
+        provider_type=None,
+        provider_credentials_secret_namespace=None,
+        client=None,
+        teardown=True,
+        vm_id=None,
+        vm_name=None,
+        cluster_id=None,
+        cluster_name=None,
+        target_vm_name=None,
+        start_vm=False,
+        provider_mappings=None,
+        resource_mapping_name=None,
+        resource_mapping_namespace=None,
+        warm=False,
+        finalize_date=None,
+        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,
+        )
+        self.vm_id = vm_id
+        self.vm_name = vm_name
+        self.cluster_id = cluster_id
+        self.cluster_name = cluster_name
+        self.target_vm_name = target_vm_name
+        self.start_vm = start_vm
+        self.provider_credentials_secret_name = provider_credentials_secret_name
+        self.provider_credentials_secret_namespace = (
+            provider_credentials_secret_namespace
+        )
+        self.provider_mappings = provider_mappings
+        self.resource_mapping_name = resource_mapping_name
+        self.resource_mapping_namespace = resource_mapping_namespace
+        self.provider_type = provider_type
+        self.warm = warm
+        self.finalize_date = finalize_date
+
+    @property
+    def vm(self):
+        return VirtualMachine(
+            name=self.target_vm_name,
+            namespace=self.namespace,
+            client=self.client,
+            privileged_client=self.privileged_client or self.client,
+        )
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            spec = self.res.setdefault("spec", {})
+
+            secret = spec.setdefault("providerCredentialsSecret", {})
+            secret["name"] = self.provider_credentials_secret_name
+
+            if self.provider_credentials_secret_namespace:
+                secret["namespace"] = self.provider_credentials_secret_namespace
+
+            if self.resource_mapping_name:
+                spec.setdefault("resourceMapping", {})[
+                    "name"
+                ] = self.resource_mapping_name
+            if self.resource_mapping_namespace:
+                spec.setdefault("resourceMapping", {})[
+                    "namespace"
+                ] = self.resource_mapping_namespace
+
+            if self.target_vm_name:
+                spec["targetVmName"] = self.target_vm_name
+
+            if self.start_vm is not None:
+                spec["startVm"] = self.start_vm
+
+            if self.warm:
+                spec["warm"] = self.warm
+            if self.finalize_date:
+                spec["finalizeDate"] = self.finalize_date.strftime(
+                    format="%Y-%m-%dT%H:%M:%SZ"
+                )
+
+            provider_source = spec.setdefault("source", {}).setdefault(
+                self.provider_type, {}
+            )
+            vm = provider_source.setdefault("vm", {})
+            if self.vm_id:
+                vm["id"] = self.vm_id
+            if self.vm_name:
+                vm["name"] = self.vm_name
+
+            if self.cluster_id:
+                vm.setdefault("cluster", {})["id"] = self.cluster_id
+            if self.cluster_name:
+                vm.setdefault("cluster", {})["name"] = self.cluster_name
+
+            if self.provider_mappings:
+                if self.provider_mappings.disk_mappings:
+                    mappings = _map_mappings(
+                        mappings=self.provider_mappings.disk_mappings
+                    )
+                    provider_source.setdefault("mappings", {}).setdefault(
+                        "diskMappings", mappings
+                    )
+
+                if self.provider_mappings.network_mappings:
+                    mappings = _map_mappings(
+                        mappings=self.provider_mappings.network_mappings
+                    )
+                    provider_source.setdefault("mappings", {}).setdefault(
+                        "networkMappings", mappings
+                    )
+
+                if self.provider_mappings.storage_mappings:
+                    mappings = _map_mappings(
+                        mappings=self.provider_mappings.storage_mappings
+                    )
+                    provider_source.setdefault("mappings", {}).setdefault(
+                        "storageMappings", mappings
+                    )
+
+    def wait(
+        self,
+        timeout=600,
+        cond_reason=SucceededConditionReason.VIRTUAL_MACHINE_READY,
+        cond_status=Condition.Status.TRUE,
+        cond_type=Condition.SUCCEEDED,
+    ):
+        self.logger.info(
+            f"Wait for {self.kind} {self.name} {cond_reason} condition to be {cond_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,
+        )
+        last_condition = None
+        try:
+            for sample in samples:
+                if sample.items:
+                    sample_status = sample.items[0].status
+                    if sample_status:
+                        current_conditions = sample_status.conditions
+                        for cond in current_conditions:
+                            last_condition = cond
+                            if (
+                                cond.type == cond_type
+                                and cond.status == cond_status
+                                and cond.reason == cond_reason
+                            ):
+                                msg = (
+                                    f"Status of {self.kind} {self.name} {cond.type} is "
+                                    f"{cond.status} ({cond.reason}: {cond.message})"
+                                )
+                                self.logger.info(msg)
+                                return
+        except TimeoutExpiredError:
+            raise TimeoutExpiredError(
+                f"Last condition of {self.kind} {self.name} {last_condition.type} was "
+                f"{last_condition.status} ({last_condition.reason}: {last_condition.message})"
+            )
+
+
+class ResourceMapping(NamespacedResource):
+    """
+    ResourceMapping object.
+    """
+
+    api_group = NamespacedResource.ApiGroup.V2V_KUBEVIRT_IO
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        mapping=None,
+        client=None,
+        teardown=True,
+        yaml_file=None,
+        **kwargs,
+    ):
+        super().__init__(
+            name=name,
+            namespace=namespace,
+            client=client,
+            teardown=teardown,
+            yaml_file=yaml_file,
+            **kwargs,
+        )
+        self.mapping = mapping
+
+    def to_dict(self):
+        super().to_dict()
+        if not self.yaml_file:
+            for provider, mapping in self.mapping.items():
+                res_provider_section = self.res.setdefault("spec", {}).setdefault(
+                    provider, {}
+                )
+                if mapping.network_mappings is not None:
+                    res_provider_section.setdefault(
+                        "networkMappings",
+                        _map_mappings(mappings=mapping.network_mappings),
+                    )
+                if mapping.storage_mappings is not None:
+                    res_provider_section.setdefault(
+                        "storageMappings",
+                        _map_mappings(mappings=mapping.storage_mappings),
+                    )

ocp_resources/virtual_machine_instance.py

@@ -0,0 +1,322 @@
+import shlex
+
+import xmltodict
+from openshift.dynamic.exceptions import ResourceNotFoundError
+
+from ocp_resources.constants import PROTOCOL_ERROR_EXCEPTION_DICT, TIMEOUT_4MINUTES
+from ocp_resources.node import Node
+from ocp_resources.pod import Pod
+from ocp_resources.resource import NamespacedResource
+from ocp_resources.utils import TimeoutExpiredError, TimeoutSampler
+
+
+class VirtualMachineInstance(NamespacedResource):
+    """
+    Virtual Machine Instance object, inherited from Resource.
+    """
+
+    api_group = NamespacedResource.ApiGroup.KUBEVIRT_IO
+
+    class Status(NamespacedResource.Status):
+        SCHEDULING = "Scheduling"
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        client=None,
+        privileged_client=None,
+        yaml_file=None,
+        delete_timeout=TIMEOUT_4MINUTES,
+        **kwargs,
+    ):
+        super().__init__(
+            name=name,
+            namespace=namespace,
+            client=client,
+            privileged_client=privileged_client,
+            yaml_file=yaml_file,
+            delete_timeout=delete_timeout,
+            **kwargs,
+        )
+
+    @property
+    def _subresource_api_url(self):
+        return (
+            f"{self.client.configuration.host}/"
+            f"apis/subresources.kubevirt.io/{self.api.api_version}/"
+            f"namespaces/{self.namespace}/virtualmachineinstances/{self.name}"
+        )
+
+    def api_request(self, method, action, **params):
+        return super().api_request(
+            method=method, action=action, url=self._subresource_api_url, **params
+        )
+
+    def pause(self, timeout=TIMEOUT_4MINUTES, wait=False):
+        self.api_request(method="PUT", action="pause")
+        if wait:
+            return self.wait_for_pause_status(pause=True, timeout=timeout)
+
+    def unpause(self, timeout=TIMEOUT_4MINUTES, wait=False):
+        self.api_request(method="PUT", action="unpause")
+        if wait:
+            return self.wait_for_pause_status(pause=False, timeout=timeout)
+
+    @property
+    def interfaces(self):
+        return self.instance.status.interfaces
+
+    @property
+    def virt_launcher_pod(self):
+        pods = list(
+            Pod.get(
+                dyn_client=self.privileged_client or self.client,
+                namespace=self.namespace,
+                label_selector=f"kubevirt.io=virt-launcher,kubevirt.io/created-by={self.instance.metadata.uid}",
+            )
+        )
+        migration_state = self.instance.status.migrationState
+        if migration_state:
+            #  After VM migration there are two pods, one in Completed status and one in Running status.
+            #  We need to return the Pod that is not in Completed status.
+            for pod in pods:
+                if migration_state.targetPod == pod.name:
+                    return pod
+        else:
+            return pods[0]
+
+        raise ResourceNotFoundError
+
+    @property
+    def virt_handler_pod(self):
+        pods = list(
+            Pod.get(
+                dyn_client=self.privileged_client or self.client,
+                label_selector="kubevirt.io=virt-handler",
+            )
+        )
+        for pod in pods:
+            if pod.instance["spec"]["nodeName"] == self.instance.status.nodeName:
+                return pod
+
+        raise ResourceNotFoundError
+
+    def wait_until_running(self, timeout=TIMEOUT_4MINUTES, logs=True, stop_status=None):
+        """
+        Wait until VMI is running
+
+        Args:
+            timeout (int): Time to wait for VMI.
+            logs (bool): True to extract logs from the VMI pod and from the VMI.
+            stop_status (str): Status which should stop the wait and failed.
+
+        Raises:
+            TimeoutExpiredError: If VMI failed to run.
+        """
+        try:
+            self.wait_for_status(
+                status=self.Status.RUNNING, timeout=timeout, stop_status=stop_status
+            )
+        except TimeoutExpiredError:
+            if not logs:
+                raise
+
+            virt_pod = self.virt_launcher_pod
+            if virt_pod:
+                self.logger.debug(f"{virt_pod.name} *****LOGS*****")
+                self.logger.debug(virt_pod.log(container="compute"))
+
+            raise
+
+    def wait_for_pause_status(self, pause, timeout=TIMEOUT_4MINUTES):
+        """
+        Wait for Virtual Machine Instance to be paused / unpaused.
+        Paused status is checked in libvirt and in the VMI conditions.
+
+        Args:
+            pause (bool): True for paused, False for unpause
+            timeout (int): Time to wait for the resource.
+
+        Raises:
+            TimeoutExpiredError: If resource not exists.
+        """
+        self.logger.info(
+            f"Wait until {self.kind} {self.name} is "
+            f"{'Paused' if pause else 'Unpuased'}"
+        )
+        self.wait_for_domstate_pause_status(pause=pause, timeout=timeout)
+        self.wait_for_vmi_condition_pause_status(pause=pause, timeout=timeout)
+
+    def wait_for_domstate_pause_status(self, pause, timeout=TIMEOUT_4MINUTES):
+        pause_status = "paused" if pause else "running"
+        samples = TimeoutSampler(
+            wait_timeout=timeout,
+            sleep=1,
+            exceptions_dict=PROTOCOL_ERROR_EXCEPTION_DICT,
+            func=self.get_domstate,
+        )
+        for sample in samples:
+            if pause_status in sample:
+                return
+
+    def wait_for_vmi_condition_pause_status(self, pause, timeout=TIMEOUT_4MINUTES):
+        samples = TimeoutSampler(
+            wait_timeout=timeout,
+            sleep=1,
+            exceptions_dict=PROTOCOL_ERROR_EXCEPTION_DICT,
+            func=self.get_vmi_active_condition,
+        )
+        for sample in samples:
+            # VM in state change
+            # We have commanded a [un]pause condition via the API but the CR has not been updated yet to match.
+            # 'reason' may not exist yet
+            # or
+            # 'reason' may still exist after unpause if the CR has not been updated before we perform this check
+            if (pause and not sample.get("reason")) or (
+                sample.get("reason") == "PausedByUser" and not pause
+            ):
+                continue
+            # Paused VM
+            if pause and sample["reason"] == "PausedByUser":
+                return
+            # Unpaused VM
+            if not (pause and sample.get("reason")):
+                return
+
+    @property
+    def node(self):
+        """
+        Get the node name where the VM is running
+
+        Returns:
+            Node: Node
+        """
+        return Node(
+            client=self.privileged_client or self.client,
+            name=self.instance.status.nodeName,
+        )
+
+    def virsh_cmd(self, action):
+        return shlex.split(
+            f"virsh {self.virt_launcher_pod_hypervisor_connection_uri} {action} {self.namespace}_{self.name}"
+        )
+
+    def get_xml(self):
+        """
+        Get virtual machine instance XML
+
+        Returns:
+            xml_output(string): VMI XML in the multi-line string
+        """
+        return self.execute_virsh_command(command="dumpxml")
+
+    @property
+    def virt_launcher_pod_user_uid(self):
+        """
+        Get Virt Launcher Pod User UID value
+
+        Returns:
+            Int: Virt Launcher Pod UID value
+        """
+        return self.virt_launcher_pod.instance.spec.securityContext.runAsUser
+
+    @property
+    def is_virt_launcher_pod_root(self):
+        """
+        Check if Virt Launcher Pod is Root
+
+        Returns:
+            Bool: True if Virt Launcher Pod is Root.
+        """
+        return not bool(self.virt_launcher_pod_user_uid)
+
+    @property
+    def virt_launcher_pod_hypervisor_connection_uri(self):
+        """
+        Get Virt Launcher Pod Hypervisor Connection URI
+
+        Required to connect to Hypervisor for
+        Non-Root Virt-Launcher Pod.
+
+        Returns:
+            String: Hypervisor Connection URI
+        """
+        return (
+            ""
+            if self.is_virt_launcher_pod_root
+            else "-c qemu+unix:///session?socket=/var/run/libvirt/libvirt-sock"
+        )
+
+    def get_domstate(self):
+        """
+        Get virtual machine instance Status.
+
+        Current workaround, as VM/VMI shows no status/phase == Paused yet.
+        Bug: https://bugzilla.redhat.com/show_bug.cgi?id=1805178
+
+        Returns:
+            String: VMI Status as string
+        """
+        return self.execute_virsh_command(command="domstate")
+
+    def get_dommemstat(self):
+        """
+        Get virtual machine domain memory stats
+        link: https://libvirt.org/manpages/virsh.html#dommemstat
+
+        Returns:
+            String: VMI domain memory stats as string
+        """
+        return self.execute_virsh_command(command="dommemstat")
+
+    def get_vmi_active_condition(self):
+        """A VMI may have multiple conditions; the active one it the one with
+        'lastTransitionTime'"""
+        return {
+            k: v
+            for condition in self.instance.status.conditions
+            for k, v in condition.items()
+            if condition["lastTransitionTime"]
+        }
+
+    @property
+    def xml_dict(self):
+        """Get virtual machine instance XML as dict"""
+
+        return xmltodict.parse(xml_input=self.get_xml(), process_namespaces=True)
+
+    @property
+    def guest_os_info(self):
+        return self.api_request(method="GET", action="guestosinfo")
+
+    @property
+    def guest_fs_info(self):
+        return self.api_request(method="GET", action="filesystemlist")
+
+    @property
+    def guest_user_info(self):
+        return self.api_request(method="GET", action="userlist")
+
+    @property
+    def os_version(self):
+        vmi_os_version = self.instance.status.guestOSInfo.get("version", {})
+        if not vmi_os_version:
+            self.logger.warning(
+                "Guest agent is not installed on the VM; OS version is not available."
+            )
+        return vmi_os_version
+
+    def interface_ip(self, interface):
+        iface_ip = [
+            iface["ipAddress"]
+            for iface in self.interfaces
+            if iface["interfaceName"] == interface
+        ]
+        return iface_ip[0] if iface_ip else None
+
+    def execute_virsh_command(self, command):
+        return self.virt_launcher_pod.execute(
+            command=self.virsh_cmd(action=command),
+            container="compute",
+        )

ocp_resources/virtual_machine_instance_migration.py

@@ -0,0 +1,36 @@
+from ocp_resources.constants import TIMEOUT_4MINUTES
+from ocp_resources.resource import NamespacedResource
+
+
+class VirtualMachineInstanceMigration(NamespacedResource):
+    api_group = NamespacedResource.ApiGroup.KUBEVIRT_IO
+
+    def __init__(
+        self,
+        name=None,
+        namespace=None,
+        vmi=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._vmi = vmi
+
+    def to_dict(self):
+        # When creating VirtualMachineInstanceMigration vmi is mandatory but when calling get()
+        # we cannot pass vmi.
+        super().to_dict()
+        if not self.yaml_file:
+            assert self._vmi, "vmi is mandatory for create"
+            self.res["spec"] = {"vmiName": self._vmi.name}

ocp_resources/virtual_machine_instance_preset.py

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