net, localnet, jumbo frame: localnet jumbo no fragmentaion test (#2119)

##### Short description:
Add new test: Verify tcp connectivity using localnet and jumbo frames
over ovs bridge, without fragmentaion
This test combines the existing localnet and jumbo frame tests

 The test includes 2 steps:
      1) Verify jumbo frames are not fragmented with ping
      2) Verify connectivity using iperf3 client-server with jumbo frame
More details in spike: https://issues.redhat.com/browse/CNV-69347


##### What this PR does / why we need it:
This test combines the existing localnet and jumbo frame tests to
provide better test coverage.
- Added option to configure mtu in NNCP and CUDN
- Refactoring of NNCP fixture and added helper function for more generic
code
- Added iperf3 client-server fixtures for sending jumbo frames from
client with a parameter:
  `--set-mss <maximum_segment_size>`
    which is calculated by: MSS = MTU - headers size (ip,tcp)


##### jira-ticket:
https://issues.redhat.com/browse/CNV-69286


<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

* **New Features**
* Optional TCP Maximum Segment Size (MSS) support for traffic clients
(default disabled)
* Dynamic MTU support and NNCP-driven OVS bridge workflows for local
networks, plus helper to configure physical NIC MTU

* **Tests**
  * New jumbo-frame connectivity test ensuring no-fragmentation TCP
* Expanded fixtures and test wiring to provision jumbo-frame VMs and
client/server scenarios

* **Chores**
  * Added IP/TCP/ICMP header size constants
  * Increased test wait timeout for improved reliability

<sub>✏️ Tip: You can customize this high-level summary in your review
settings.</sub>
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: rnetser

libs/net/traffic_generator.py

@@ -87,16 +87,20 @@ class VMTcpClient(BaseTcpClient):
         vm (BaseVirtualMachine): The virtual machine where the client runs.
         server_ip (str): The destination IP address of the server the client connects to.
         server_port (int): The port on which the server listens for connections.
+        maximum_segment_size (int): Define explicitly the TCP payload size (in bytes).
+                                    Default value is 0 (do not change mss).
     """
 
     def __init__(
         self,
         vm: BaseVirtualMachine,
         server_ip: str,
         server_port: int,
+        maximum_segment_size: int = 0,
     ):
         super().__init__(server_ip=server_ip, server_port=server_port)
         self._vm = vm
+        self._cmd += f" --set-mss {maximum_segment_size}" if maximum_segment_size else ""
 
     def __enter__(self) -> "VMTcpClient":
         self._vm.console(

tests/network/libs/cluster_user_defined_network.py

@@ -51,6 +51,7 @@ class Role(Enum):
     physicalNetworkName: str  # noqa: N815
     ipam: Ipam
     vlan: Vlan | None = None
+    mtu: int | None = None
 
 
 @dataclass

tests/network/libs/ip.py

@@ -4,6 +4,9 @@
 
 _MAX_NUM_OF_RANDOM_OCTETS_PER_SESSION: Final[int] = 16
 _IPV4_ADDRESS_SUBNET_PREFIX_VMI: Final[str] = "172.16"
+TCP_HEADER_SIZE: Final[int] = 20
+IPV4_HEADER_SIZE: Final[int] = 20
+ICMPV4_HEADER_SIZE: Final[int] = 8
 
 
 def random_ipv4_address(net_seed: int, host_address: int) -> str:

tests/network/libs/nodenetworkconfigurationpolicy.py

@@ -13,7 +13,7 @@
 
 from tests.network.libs.apimachinery import dict_normalization_for_dataclass
 
-WAIT_FOR_STATUS_TIMEOUT_SEC = 90
+WAIT_FOR_STATUS_TIMEOUT_SEC = 120
 WAIT_FOR_STATUS_INTERVAL_SEC = 5
 DEFAULT_OVN_EXTERNAL_BRIDGE = "br-ex"  # Default name for OVN-Kubernetes external bridge
 
@@ -68,6 +68,7 @@ class Interface:
     name: str
     type: str
     state: str
+    mtu: int | None = None
     ipv4: IPv4 | None = None
     ipv6: IPv6 | None = None
     bridge: Bridge | None = None

tests/network/localnet/conftest.py

@@ -3,7 +3,6 @@
 import pytest
 from kubernetes.dynamic import DynamicClient
 from ocp_resources.namespace import Namespace
-from ocp_resources.node import Node
 
 import tests.network.libs.nodenetworkconfigurationpolicy as libnncp
 from libs.net.traffic_generator import TcpServer
@@ -13,8 +12,9 @@
 from libs.vm.vm import BaseVirtualMachine
 from tests.network.libs import cloudinit
 from tests.network.libs import cluster_user_defined_network as libcudn
-from tests.network.libs.ip import random_ipv4_address
+from tests.network.libs.ip import IPV4_HEADER_SIZE, TCP_HEADER_SIZE, random_ipv4_address
 from tests.network.localnet.liblocalnet import (
+    _IPERF_SERVER_PORT,
     LINK_STATE_DOWN,
     LOCALNET_BR_EX_INTERFACE,
     LOCALNET_BR_EX_INTERFACE_NO_VLAN,
@@ -24,6 +24,7 @@
     LOCALNET_OVS_BRIDGE_NETWORK,
     LOCALNET_TEST_LABEL,
     client_server_active_connection,
+    create_nncp_localnet_on_secondary_node_nic,
     create_traffic_client,
     create_traffic_server,
     localnet_cudn,
@@ -36,7 +37,6 @@
 from utilities.infra import create_ns
 from utilities.virt import migrate_vm_and_verify
 
-NNCP_INTERFACE_TYPE_OVS_BRIDGE = "ovs-bridge"
 PRIMARY_INTERFACE_NAME = "eth0"
 
 
@@ -207,46 +207,6 @@ def localnet_client(localnet_running_vms: tuple[BaseVirtualMachine, BaseVirtualM
         yield client
 
 
-@pytest.fixture(scope="module")
-def nncp_localnet_on_secondary_node_nic(
-    worker_node1: Node, nodes_available_nics: dict[str, list[str]]
-) -> Generator[libnncp.NodeNetworkConfigurationPolicy]:
-    bridge_name = "localnet-ovs-br"
-    desired_state = libnncp.DesiredState(
-        interfaces=[
-            libnncp.Interface(
-                name=bridge_name,
-                type=NNCP_INTERFACE_TYPE_OVS_BRIDGE,
-                ipv4=libnncp.IPv4(enabled=False),
-                ipv6=libnncp.IPv6(enabled=False),
-                state=libnncp.Resource.Interface.State.UP,
-                bridge=libnncp.Bridge(
-                    options=libnncp.BridgeOptions(libnncp.STP(enabled=False)),
-                    port=[
-                        libnncp.Port(
-                            name=nodes_available_nics[worker_node1.name][-1],
-                        )
-                    ],
-                ),
-            )
-        ],
-        ovn=libnncp.OVN([
-            libnncp.BridgeMappings(
-                localnet=LOCALNET_OVS_BRIDGE_NETWORK,
-                bridge=bridge_name,
-                state=libnncp.BridgeMappings.State.PRESENT.value,
-            )
-        ]),
-    )
-    with libnncp.NodeNetworkConfigurationPolicy(
-        name=bridge_name,
-        desired_state=desired_state,
-        node_selector={WORKER_NODE_LABEL_KEY: ""},
-    ) as nncp:
-        nncp.wait_for_status_success()
-        yield nncp
-
-
 @pytest.fixture(scope="module")
 def cudn_localnet_ovs_bridge(
     vlan_id: int,
@@ -389,3 +349,109 @@ def migrated_localnet_vm(
     vm, _ = localnet_running_vms
     migrate_vm_and_verify(vm=vm)
     return vm
+
+
+@pytest.fixture(scope="module")
+def nncp_localnet_on_secondary_node_nic(
+    hosts_common_available_ports: list[str],
+) -> Generator[libnncp.NodeNetworkConfigurationPolicy]:
+    with create_nncp_localnet_on_secondary_node_nic(node_nic_name=(hosts_common_available_ports[-1])) as nncp:
+        yield nncp
+
+
+@pytest.fixture(scope="module")
+def nncp_localnet_on_secondary_node_nic_with_jumbo_frame(
+    hosts_common_available_ports: list[str], cluster_hardware_mtu: int
+) -> Generator[libnncp.NodeNetworkConfigurationPolicy]:
+    with create_nncp_localnet_on_secondary_node_nic(
+        node_nic_name=(hosts_common_available_ports[-1]), mtu=cluster_hardware_mtu
+    ) as nncp:
+        yield nncp
+
+
+@pytest.fixture(scope="module")
+def cudn_localnet_ovs_bridge_jumbo_frame(
+    vlan_id: int,
+    cluster_hardware_mtu: int,
+    namespace_localnet_1: Namespace,
+) -> Generator[libcudn.ClusterUserDefinedNetwork]:
+    with localnet_cudn(
+        name=LOCALNET_OVS_BRIDGE_NETWORK,
+        match_labels=LOCALNET_TEST_LABEL,
+        vlan_id=vlan_id,
+        physical_network_name=LOCALNET_OVS_BRIDGE_NETWORK,
+        mtu=cluster_hardware_mtu,
+    ) as cudn:
+        cudn.wait_for_status_success()
+        yield cudn
+
+
+@pytest.fixture(scope="module")
+def vm1_ovs_bridge_localnet_jumbo_frame(
+    namespace_localnet_1: Namespace,
+    ipv4_localnet_address_pool: Generator[str],
+    cudn_localnet_ovs_bridge_jumbo_frame: libcudn.ClusterUserDefinedNetwork,
+    unprivileged_client: DynamicClient,
+) -> Generator[BaseVirtualMachine]:
+    with localnet_vm(
+        namespace=namespace_localnet_1.name,
+        name="localnet-ovs-vm1-jumbo",
+        client=unprivileged_client,
+        networks=[
+            Network(
+                name=LOCALNET_OVS_BRIDGE_INTERFACE, multus=Multus(networkName=cudn_localnet_ovs_bridge_jumbo_frame.name)
+            )
+        ],
+        interfaces=[Interface(name=LOCALNET_OVS_BRIDGE_INTERFACE, bridge={})],
+        network_data=cloudinit.NetworkData(
+            ethernets={PRIMARY_INTERFACE_NAME: cloudinit.EthernetDevice(addresses=[next(ipv4_localnet_address_pool)])}
+        ),
+    ) as vm:
+        yield vm
+
+
+@pytest.fixture(scope="module")
+def vm2_ovs_bridge_localnet_jumbo_frame(
+    namespace_localnet_1: Namespace,
+    ipv4_localnet_address_pool: Generator[str],
+    cudn_localnet_ovs_bridge_jumbo_frame: libcudn.ClusterUserDefinedNetwork,
+    unprivileged_client: DynamicClient,
+) -> Generator[BaseVirtualMachine]:
+    with localnet_vm(
+        namespace=namespace_localnet_1.name,
+        name="localnet-ovs-vm2-jumbo",
+        client=unprivileged_client,
+        networks=[
+            Network(
+                name=LOCALNET_OVS_BRIDGE_INTERFACE, multus=Multus(networkName=cudn_localnet_ovs_bridge_jumbo_frame.name)
+            )
+        ],
+        interfaces=[Interface(name=LOCALNET_OVS_BRIDGE_INTERFACE, bridge={})],
+        network_data=cloudinit.NetworkData(
+            ethernets={PRIMARY_INTERFACE_NAME: cloudinit.EthernetDevice(addresses=[next(ipv4_localnet_address_pool)])}
+        ),
+    ) as vm:
+        yield vm
+
+
+@pytest.fixture(scope="module")
+def ovs_bridge_localnet_running_jumbo_frame_vms(
+    vm1_ovs_bridge_localnet_jumbo_frame: BaseVirtualMachine, vm2_ovs_bridge_localnet_jumbo_frame: BaseVirtualMachine
+) -> Generator[tuple[BaseVirtualMachine, BaseVirtualMachine]]:
+    vm1, vm2 = run_vms(vms=(vm1_ovs_bridge_localnet_jumbo_frame, vm2_ovs_bridge_localnet_jumbo_frame))
+    yield vm1, vm2
+
+
+@pytest.fixture()
+def localnet_ovs_bridge_jumbo_frame_client_and_server_vms(
+    ovs_bridge_localnet_running_jumbo_frame_vms: tuple[BaseVirtualMachine, BaseVirtualMachine],
+    cluster_hardware_mtu: int,
+) -> Generator[tuple[TcpClient, TcpServer], None, None]:
+    with client_server_active_connection(
+        client_vm=ovs_bridge_localnet_running_jumbo_frame_vms[1],
+        server_vm=ovs_bridge_localnet_running_jumbo_frame_vms[0],
+        spec_logical_network=LOCALNET_OVS_BRIDGE_INTERFACE,
+        port=_IPERF_SERVER_PORT,
+        maximum_segment_size=cluster_hardware_mtu - IPV4_HEADER_SIZE - TCP_HEADER_SIZE,
+    ) as (client, server):
+        yield client, server