Add virtualization feature

Author: LiliDeng

lisa/features/__init__.py

@@ -34,6 +34,7 @@
 )
 from .serial_console import SerialConsole
 from .startstop import StartStop, StopState, VMStatus
+from .virtualization import Virtualization
 
 __all__ = [
     "ACC",
@@ -73,4 +74,5 @@
     "VMStatus",
     "Synthetic",
     "StartStop",
+    "Virtualization",
 ]

lisa/features/virtualization.py

@@ -0,0 +1,91 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+from functools import partial
+from typing import Any, Optional, Type
+
+from lisa import schema, search_space
+from lisa.feature import Feature
+from lisa.util import constants
+
+
+class Virtualization(Feature):
+    """
+    Virtualization platform detection and filtering feature.
+
+    This feature identifies the hypervisor or virtualization environment where
+    the test is running and allows tests to specify compatibility requirements.
+    The host_type field indicates which virtualization platform is in use.
+
+    The host_type field can contain these values:
+    - BareMetal: Physical hardware without virtualization
+    - HyperV: Microsoft Hyper-V hypervisor
+    - QEMU: QEMU/KVM virtualization stack
+    - CloudHypervisor: Cloud Hypervisor
+    - None: Unknown
+
+    Tests can use this feature to ensure they only run on supported
+    hypervisors or to skip execution on platforms where they have known
+    compatibility issues.
+    """
+
+    @classmethod
+    def settings_type(cls) -> Type[schema.FeatureSettings]:
+        return schema.VirtualizationSettings
+
+    @classmethod
+    def name(cls) -> str:
+        return constants.FEATURE_VIRTUALIZATION
+
+    @classmethod
+    def can_disable(cls) -> bool:
+        return False
+
+    def enabled(self) -> bool:
+        return True
+
+    @classmethod
+    def create_setting(
+        cls, *args: Any, **kwargs: Any
+    ) -> Optional[schema.FeatureSettings]:
+        """
+        Base implementation returns platform-agnostic settings.
+
+        Platforms should override this to detect their actual hypervisor.
+        """
+        return schema.VirtualizationSettings(host_type=None)
+
+
+# Helper functions for creating virtualization requirements
+
+
+def _single_host_type_requirement(
+    host_type: schema.VirtualizationHostType,
+) -> partial[schema.VirtualizationSettings]:
+    """
+    Create a virtualization requirement for a specific host type.
+
+    This helper function creates a partial VirtualizationSettings that can be
+    used as a test requirement to filter tests by virtualization platform.
+
+    Args:
+        host_type: The specific virtualization host type to require
+
+    Returns:
+        Partial VirtualizationSettings configured for the specified host type
+    """
+    return partial(
+        schema.VirtualizationSettings,
+        host_type=search_space.SetSpace(True, [host_type]),
+    )
+
+
+# Host type requirements - predefined partial functions for common use cases
+BareMetalHostType = _single_host_type_requirement(
+    schema.VirtualizationHostType.BareMetal
+)
+HyperVHostType = _single_host_type_requirement(schema.VirtualizationHostType.HyperV)
+QemuHostType = _single_host_type_requirement(schema.VirtualizationHostType.QEMU)
+CloudHypervisorHostType = _single_host_type_requirement(
+    schema.VirtualizationHostType.CloudHypervisor
+)

lisa/microsoft/testsuites/core/azure_image_standard.py

@@ -19,6 +19,7 @@
 )
 from lisa.base_tools.uname import Uname
 from lisa.features import Disk
+from lisa.features.virtualization import HyperVHostType
 from lisa.operating_system import (
     BSD,
     SLES,
@@ -721,7 +722,10 @@ def verify_os_update(self, node: Node) -> None:
         has length greater than zero.
         """,
         priority=2,
-        requirement=simple_requirement(supported_platform_type=[AZURE, READY, HYPERV]),
+        requirement=simple_requirement(
+            supported_platform_type=[AZURE, READY, HYPERV],
+            supported_features=[HyperVHostType()],
+        ),
     )
     def verify_hv_kvp_daemon_installed(self, node: Node) -> None:
         if isinstance(node.os, Debian):

lisa/schema.py

@@ -451,6 +451,22 @@ class ResourceDiskType(str, Enum):
     NVME = constants.STORAGE_INTERFACE_TYPE_NVME
 
 
+class VirtualizationHostType(str, Enum):
+    """
+    Virtualization host type enumeration.
+    Defines the type of hypervisor or virtualization platform being used.
+    """
+
+    # Physical hardware without virtualization
+    BareMetal = "BareMetal"
+    # Microsoft Hyper-V hypervisor
+    HyperV = "HyperV"
+    # QEMU/KVM virtualization
+    QEMU = "QEMU"
+    # Cloud Hypervisor
+    CloudHypervisor = "CloudHypervisor"
+
+
 disk_controller_type_priority: List[DiskControllerType] = [
     DiskControllerType.SCSI,
     DiskControllerType.NVME,
@@ -847,6 +863,104 @@ def _call_requirement_method(
         return value
 
 
+@dataclass_json()
+@dataclass()
+class VirtualizationSettings(FeatureSettings):
+    """
+    Virtualization feature settings to specify the host type.
+    Used to indicate the type of hypervisor or virtualization platform.
+    """
+
+    type: str = constants.FEATURE_VIRTUALIZATION
+    # Host type - specifies the virtualization platform being used
+    # Default is None (no restrictions/requirements)
+    host_type: Optional[
+        Union[
+            search_space.SetSpace[VirtualizationHostType],
+            VirtualizationHostType,
+        ]
+    ] = field(
+        default=None,
+        metadata=field_metadata(
+            decoder=partial(
+                search_space.decode_nullable_set_space,
+                base_type=VirtualizationHostType,
+                default_values=[],
+            )
+        ),
+    )
+
+    def __eq__(self, o: object) -> bool:
+        assert isinstance(o, VirtualizationSettings), f"actual: {type(o)}"
+        return super().__eq__(o) and self.host_type == o.host_type
+
+    def __hash__(self) -> int:
+        return hash(self._get_key())
+
+    def _get_key(self) -> str:
+        # Include host_type in key for different hash values
+        host_type_str = str(self.host_type) if self.host_type else "None"
+        return f"{self.type}_{host_type_str}"
+
+    def __repr__(self) -> str:
+        return f"type:{self.type}, " f"host_type:{self.host_type}"
+
+    def check(self, capability: Any) -> search_space.ResultReason:
+        result = super().check(capability)
+        assert isinstance(capability, VirtualizationSettings)
+
+        # Check host_type compatibility
+        if self.host_type is not None:
+            if capability.host_type is None:
+                # Requirement specifies host_type but capability doesn't provide it
+                result.add_reason(
+                    f"requirement specifies host_type {self.host_type} "
+                    f"but capability has no host_type specified"
+                )
+            else:
+                # Both have host_type, check compatibility
+                result.merge(
+                    search_space.check_setspace(self.host_type, capability.host_type)
+                )
+
+        return result
+
+    def _call_requirement_method(
+        self, method: search_space.RequirementMethod, capability: Any
+    ) -> Any:
+        assert isinstance(capability, VirtualizationSettings)
+        value = type(self)()
+
+        # Handle host_type intersection/generation based on method
+        if self.host_type is not None and capability.host_type is not None:
+            # Convert single values to SetSpace if needed
+            if isinstance(self.host_type, VirtualizationHostType):
+                self_host_type = search_space.SetSpace(
+                    is_allow_set=True, items=[self.host_type]
+                )
+            else:
+                self_host_type = self.host_type
+
+            if isinstance(capability.host_type, VirtualizationHostType):
+                cap_host_type = search_space.SetSpace(
+                    is_allow_set=True, items=[capability.host_type]
+                )
+            else:
+                cap_host_type = capability.host_type
+
+            # Use SetSpace methods directly
+            if method == search_space.RequirementMethod.intersect:
+                value.host_type = self_host_type.intersect(cap_host_type)
+            elif method == search_space.RequirementMethod.generate_min_capability:
+                value.host_type = self_host_type.generate_min_capability(cap_host_type)
+        elif capability.host_type is not None:
+            value.host_type = capability.host_type
+        else:
+            value.host_type = self.host_type
+
+        return value
+
+
 @dataclass_json()
 @dataclass()
 class FeaturesSpace(

lisa/sut_orchestrator/azure/features.py

@@ -3863,3 +3863,31 @@ def _prepare_azure_file_share(
                 sudo=True,
                 append=True,
             )
+
+
+class Virtualization(AzureFeatureMixin, features.Virtualization):
+    """
+    Azure-specific implementation of Virtualization feature.
+
+    Automatically sets host_type to HyperV for Azure VMs since Azure
+    uses Microsoft Hyper-V hypervisor technology as its underlying
+    virtualization platform. Azure's hypervisor is based on Hyper-V.
+    """
+
+    @classmethod
+    def create_setting(
+        cls, *args: Any, **kwargs: Any
+    ) -> Optional[schema.FeatureSettings]:
+        """
+        Create Azure virtualization settings.
+
+        Azure VMs always run on Microsoft Hyper-V hypervisor technology,
+        so we set host_type to HyperV by default. Azure's underlying
+        virtualization is based on the Hyper-V hypervisor.
+
+        Returns:
+            VirtualizationSettings with host_type=HyperV
+        """
+        return schema.VirtualizationSettings(
+            host_type=schema.VirtualizationHostType.HyperV
+        )

lisa/sut_orchestrator/azure/platform_.py

@@ -513,6 +513,7 @@ def supported_features(cls) -> List[Type[feature.Feature]]:
             features.Availability,
             features.Infiniband,
             features.Hibernation,
+            features.Virtualization,
         ]
 
     def _prepare_environment(self, environment: Environment, log: Logger) -> bool:

lisa/sut_orchestrator/hyperv/platform_.py

@@ -4,7 +4,7 @@
 from pathlib import PurePath
 from typing import Any, List, Optional, Type, cast
 
-from lisa import feature, schema, search_space
+from lisa import feature, features, schema, search_space
 from lisa.environment import Environment
 from lisa.node import RemoteNode
 from lisa.platform_ import Platform
@@ -36,7 +36,7 @@ def type_name(cls) -> str:
 
     @classmethod
     def supported_features(cls) -> List[Type[feature.Feature]]:
-        return [SerialConsole]
+        return [SerialConsole, Virtualization]
 
     def _initialize(self, *args: Any, **kwargs: Any) -> None:
         self._hyperv_runbook = self._get_hyperv_runbook()
@@ -383,3 +383,29 @@ def _delete_nodes(self, environment: Environment, log: Logger) -> None:
                 for node in environment.nodes.list()
             ]
         )
+
+
+class Virtualization(features.Virtualization):
+    """
+    HyperV-specific implementation of Virtualization feature.
+
+    Automatically sets host_type to HyperV since nodes on HyperV platform
+    are always running under Microsoft Hyper-V hypervisor.
+    """
+
+    @classmethod
+    def create_setting(
+        cls, *args: Any, **kwargs: Any
+    ) -> Optional[schema.FeatureSettings]:
+        """
+        Create HyperV virtualization settings.
+
+        HyperV VMs always run under Microsoft Hyper-V hypervisor, so we set
+        host_type to HyperV by default.
+
+        Returns:
+            VirtualizationSettings with host_type=HyperV
+        """
+        return schema.VirtualizationSettings(
+            host_type=schema.VirtualizationHostType.HyperV
+        )

lisa/util/constants.py

@@ -43,6 +43,8 @@
 
 # feature names
 FEATURE_DISK = "Disk"
+# Virtualization feature to specify host type (BareMetal, HyperV, etc.)
+FEATURE_VIRTUALIZATION = "Virtualization"
 
 # list types
 LIST = "list"