Add IPv6 support in NetworkInterface feature

lisa/features/__init__.py

@@ -21,7 +21,13 @@
 from .infiniband import Infiniband
 from .isolated_resource import IsolatedResource
 from .nested_virtualization import NestedVirtualization
-from .network_interface import NetworkInterface, Sriov, Synthetic
+from .network_interface import (
+    NetworkInterface,
+    Sriov,
+    SriovIPv6,
+    Synthetic,
+    SyntheticIPv6,
+)
 from .nfs import Nfs
 from .nvme import Nvme, NvmeSettings
 from .password_extension import PasswordExtension
@@ -69,6 +75,8 @@
     "SecurityProfileSettings",
     "SecurityProfileType",
     "Sriov",
+    "SriovIPv6",
+    "SyntheticIPv6",
     "StopState",
     "VMStatus",
     "Synthetic",

lisa/features/network_interface.py

@@ -70,3 +70,13 @@ def _initialize(self, *args: Any, **kwargs: Any) -> None:
 Synthetic = partial(
     NetworkInterfaceOptionSettings, data_path=schema.NetworkDataPath.Synthetic
 )
+SriovIPv6 = partial(
+    NetworkInterfaceOptionSettings,
+    data_path=schema.NetworkDataPath.Sriov,
+    ip_version=schema.IPVersion.IPv6,
+)
+SyntheticIPv6 = partial(
+    NetworkInterfaceOptionSettings,
+    data_path=schema.NetworkDataPath.Synthetic,
+    ip_version=schema.IPVersion.IPv6,
+)

lisa/schema.py

@@ -709,6 +709,11 @@ class NetworkDataPath(str, Enum):
     Sriov = "Sriov"
 
 
+class IPVersion(str, Enum):
+    IPv4 = "IPv4"
+    IPv6 = "IPv6"
+
+
 _network_data_path_priority: List[NetworkDataPath] = [
     NetworkDataPath.Sriov,
     NetworkDataPath.Synthetic,
@@ -740,6 +745,21 @@ class NetworkInterfaceOptionSettings(FeatureSettings):
             )
         ),
     )
+    ip_version: Optional[Union[search_space.SetSpace[IPVersion], IPVersion]] = (
+        field(  # type: ignore
+            default_factory=partial(
+                search_space.SetSpace,
+                items=[IPVersion.IPv4, IPVersion.IPv6],
+            ),
+            metadata=field_metadata(
+                decoder=partial(
+                    search_space.decode_nullable_set_space,
+                    base_type=IPVersion,
+                    default_values=[IPVersion.IPv4, IPVersion.IPv6],
+                )
+            ),
+        )
+    )
     # nic_count is used for specifying associated nic count during provisioning vm
     nic_count: search_space.CountSpace = field(
         default_factory=partial(search_space.IntRange, min=1),
@@ -762,14 +782,15 @@ def __eq__(self, o: object) -> bool:
         return (
             self.type == o.type
             and self.data_path == o.data_path
+            and self.ip_version == o.ip_version
             and self.nic_count == o.nic_count
             and self.max_nic_count == o.max_nic_count
         )
 
     def __repr__(self) -> str:
         return (
-            f"data_path:{self.data_path}, nic_count:{self.nic_count},"
-            f" max_nic_count:{self.max_nic_count}"
+            f"data_path:{self.data_path}, ip_version:{self.ip_version}, "
+            f"nic_count:{self.nic_count}, max_nic_count:{self.max_nic_count}"
         )
 
     def __str__(self) -> str:
@@ -806,6 +827,11 @@ def check(self, capability: Any) -> search_space.ResultReason:
             "data_path",
         )
 
+        result.merge(
+            search_space.check_setspace(self.ip_version, capability.ip_version),
+            "ip_version",
+        )
+
         result.merge(
             search_space.check_countspace(self.max_nic_count, capability.max_nic_count),
             "max_nic_count",
@@ -839,6 +865,7 @@ def _call_requirement_method(
         value.data_path = getattr(search_space, f"{method.value}_setspace_by_priority")(
             self.data_path, capability.data_path, _network_data_path_priority
         )
+
         return value
 
 

lisa/sut_orchestrator/azure/common.py

@@ -2274,13 +2274,27 @@ def get_primary_ip_addresses(
         nic_name = get_matched_str(network_interface.id, NIC_NAME_PATTERN)
         nic = network_client.network_interfaces.get(resource_group_name, nic_name)
         if nic.primary:
+            # Check if IPv6 is actually enabled on the NIC
+            # if its enabled, use it as internal ip.
+            ipv6_enabled = any(
+                ip_config.private_ip_address_version == IpProtocol.ipv6
+                for ip_config in nic.ip_configurations
+            )
             if use_ipv6:
                 nic_index = 1
 
             ip_config = nic.ip_configurations[nic_index]
             if use_ipv6 and ip_config.private_ip_address_version != IpProtocol.ipv6:
                 raise LisaException(f"private address is not IPv6 in nic {nic.name}")
-            private_ip = ip_config.private_ip_address
+
+            # If IPv6 is actually enabled on the NIC, use it as the internal IP.
+            # Public IP can continue to be IPv4.
+            if ipv6_enabled:
+                ipv6_nic_index = 1
+                ipv6_config = nic.ip_configurations[ipv6_nic_index]
+                private_ip = ipv6_config.private_ip_address
+            else:
+                private_ip = ip_config.private_ip_address
 
             if create_public_address:
                 if not ip_config.public_ip_address:

lisa/sut_orchestrator/azure/features.py

@@ -783,9 +783,32 @@ class NetworkInterface(AzureFeatureMixin, features.NetworkInterface):
     def settings_type(cls) -> Type[schema.FeatureSettings]:
         return schema.NetworkInterfaceOptionSettings
 
+    @classmethod
+    def create_setting(
+        cls, *args: Any, **kwargs: Any
+    ) -> Optional[schema.FeatureSettings]:
+        # All Azure VMs support synthetic and SRIOV networking
+        # All Azure VMs can support both IPv4 and IPv6 via ARM template configuration
+        return schema.NetworkInterfaceOptionSettings(
+            data_path=search_space.SetSpace(
+                items=[
+                    schema.NetworkDataPath.Synthetic,
+                    schema.NetworkDataPath.Sriov,
+                ]
+            ),
+            ip_version=search_space.SetSpace(
+                is_allow_set=True,
+                items=[
+                    schema.IPVersion.IPv4,
+                    schema.IPVersion.IPv6,
+                ],
+            ),
+        )
+
     def _initialize(self, *args: Any, **kwargs: Any) -> None:
         super()._initialize(*args, **kwargs)
         self._initialize_information(self._node)
+
         all_nics = self._get_all_nics()
         # store extra synthetic and sriov nics count
         # in order to restore nics status after testing which needs change nics

lisa/sut_orchestrator/azure/platform_.py

@@ -1199,6 +1199,12 @@ def _create_deployment_parameters(
         )
         arm_parameters.use_ipv6 = self._azure_runbook.use_ipv6
 
+        # Override IPv6 setting if environment specifically requires IPv6
+        if not arm_parameters.use_ipv6:  # Only check if not already enabled
+            ipv6_required = self._check_ipv6_requirements(environment)
+            if ipv6_required:
+                arm_parameters.use_ipv6 = True
+
         is_windows: bool = False
         arm_parameters.admin_username = self.runbook.admin_username
         # if no key or password specified, generate the key pair
@@ -2242,6 +2248,11 @@ def _generate_max_capability(self, vm_size: str, location: str) -> AzureCapabili
         ](is_allow_set=True, items=[])
         node_space.network_interface.data_path.add(schema.NetworkDataPath.Synthetic)
         node_space.network_interface.data_path.add(schema.NetworkDataPath.Sriov)
+        node_space.network_interface.ip_version = search_space.SetSpace[
+            schema.IPVersion
+        ](is_allow_set=True, items=[])
+        node_space.network_interface.ip_version.add(schema.IPVersion.IPv4)
+        node_space.network_interface.ip_version.add(schema.IPVersion.IPv6)
         node_space.network_interface.nic_count = search_space.IntRange(min=1)
         # till now, the max nic number supported in Azure is 8
         node_space.network_interface.max_nic_count = 8
@@ -3054,6 +3065,29 @@ def _is_byoip_feature_registered(self) -> bool:
             self._cached_byoip_registered = False
         return self._cached_byoip_registered
 
+    def _check_ipv6_requirements(self, environment: Environment) -> bool:
+        """Check if IPv6 is specifically required by analyzing environment requirements."""
+        ipv6_required = False
+
+        # Check environment runbook node requirements for IPv6 specifications
+        if environment.runbook and environment.runbook.nodes_requirement:
+            for node_requirement in environment.runbook.nodes_requirement:
+                if (
+                    node_requirement.network_interface
+                    and node_requirement.network_interface.ip_version is not None
+                ):
+                    ip_version = node_requirement.network_interface.ip_version
+                    if isinstance(ip_version, search_space.SetSpace):
+                        if schema.IPVersion.IPv6 in ip_version.items:
+                            ipv6_required = True
+                            break
+                    elif isinstance(ip_version, schema.IPVersion):
+                        if ip_version == schema.IPVersion.IPv6:
+                            ipv6_required = True
+                            break
+
+        return ipv6_required
+
 
 def _get_allowed_locations(nodes_requirement: List[schema.NodeSpace]) -> List[str]:
     existing_locations_str: str = ""

lisa/tools/ip.py

@@ -12,7 +12,7 @@
 from lisa.tools import Cat
 from lisa.tools.start_configuration import StartConfiguration
 from lisa.tools.whoami import Whoami
-from lisa.util import LisaException, find_patterns_in_lines
+from lisa.util import LisaException, find_patterns_in_lines, get_matched_str
 
 
 class IpInfo:
@@ -346,6 +346,17 @@ def get_ip_address(self, nic_name: str) -> str:
         assert "ip_addr" in matched, f"not find ip address for nic {nic_name}"
         return matched["ip_addr"]
 
+    def get_ipv6_address(self, nic_name: str) -> str:
+        """Get the global IPv6 address for a network interface."""
+        result = self.run(f"-6 addr show {nic_name}", force_run=True, sudo=True)
+
+        # Regex to match IPv6 addresses with global scope
+        # Example: inet6 2001:db8::5/128 scope global dynamic noprefixroute
+        ipv6_pattern = re.compile(r"inet6\s+([0-9a-fA-F:]+)\/\d+\s+scope\s+global")
+
+        ipv6_address = get_matched_str(result.stdout, ipv6_pattern)
+        return ipv6_address
+
     def get_default_route_info(self) -> tuple[str, str]:
         result = self.run("route", force_run=True, sudo=True)
         result.assert_exit_code()

lisa/tools/lagscope.py

@@ -1,6 +1,7 @@
 # Copyright (c) Microsoft Corporation.
 # Licensed under the MIT license.
 
+import ipaddress
 import re
 from decimal import Decimal
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type, cast
@@ -135,10 +136,13 @@ def run_as_server_async(self, ip: str = "") -> Process:
         # -r: run as a receiver
         # -rip: run as server mode with specified ip address
         cmd = ""
+        if ipaddress.ip_address(ip).version == 6:
+            cmd += " -6"
         if ip:
             cmd += f" -r{ip}"
         else:
             cmd += " -r"
+
         process = self.run_async(cmd, sudo=True, shell=True, force_run=True)
         if not process.is_running():
             raise LisaException("lagscope server failed to start")
@@ -172,6 +176,8 @@ def run_as_client_async(
         # -R: dumps raw latencies into csv file
         # -D: run as daemon
         cmd = f"{self.command} -s{server_ip} "
+        if ipaddress.ip_address(server_ip).version == 6:
+            cmd += " -6 "
         if run_time_seconds:
             cmd += f" -t{run_time_seconds} "
         if count_of_histogram_intervals:

lisa/tools/ntttcp.py

@@ -1,6 +1,7 @@
 # Copyright (c) Microsoft Corporation.
 # Licensed under the MIT license.
 
+import ipaddress
 import re
 import time
 from decimal import Decimal
@@ -215,6 +216,8 @@ def run_as_server_async(
         udp_mode: bool = False,
     ) -> Process:
         cmd = ""
+        if ipaddress.ip_address(server_ip).version == 6:
+            cmd += " -6 "
         if server_ip:
             cmd += f" -r{server_ip} "
         cmd += (
@@ -326,11 +329,15 @@ def run_as_client(
         # the devices specified by the differentiator
         # Examples for differentiator: Hyper-V PCIe MSI, mlx4, Hypervisor callback
         # interrupts
-        cmd = (
+        cmd = ""
+        if ipaddress.ip_address(server_ip).version == 6:
+            cmd += " -6 "
+        cmd += (
             f" -s{server_ip} -P {ports_count} -n {threads_count} -t {run_time_seconds} "
             f"-W {warm_up_time_seconds} -C {cool_down_time_seconds} -b {buffer_size}k "
             f"--show-nic-packets {nic_name} "
         )
+
         if udp_mode:
             cmd += " -u "
         if dev_differentiator:

microsoft/testsuites/network/sriov.py

@@ -38,6 +38,7 @@
     Lscpu,
     Service,
 )
+from lisa.tools.ip import Ip
 from lisa.util import (
     LisaException,
     LisaTimeoutException,
@@ -877,6 +878,29 @@ def verify_sriov_interrupts_change(self, environment: Environment) -> None:
                     "interrupt count!"
                 ).is_greater_than(unused_cpu)
 
+    @TestCaseMetadata(
+        description="""
+        Verify IPv6 networking functionality with IPv6
+        1. Create an Azure VM with AN Enabled and IPv6 enabled
+        2. Verify that the NIC has an IPv6 address
+        """,
+        priority=2,
+        requirement=node_requirement(
+            node=schema.NodeSpace(
+                network_interface=features.SriovIPv6(),
+            )
+        ),
+    )
+    def verify_sriov_ipv6_basic(self, node: Node, log: Logger) -> None:
+        ip = node.tools[Ip]
+        # for each nic, verify that ipv6 exists using nic name
+        for nic in node.nics.nics.keys():
+            nic_ipv6 = ip.get_ipv6_address(nic)
+            assert_that(
+                nic_ipv6,
+                f"Expected IPv6 address but found none on nic {nic}",
+            ).is_not_empty()
+
     def after_case(self, log: Logger, **kwargs: Any) -> None:
         environment: Environment = kwargs.pop("environment")
         cleanup_iperf3(environment)