<div dir="auto">I will test this tonight.</div><div dir="auto"> </div><div dir="auto">What do we have right now in terms of DTS dev systems and NICs for non-iol people like me. Is it still:</div><div dir="auto"> </div><div dir="auto">iol-dts-tester</div><div dir="auto"> </div><div dir="auto">And </div><div dir="auto"> </div><div dir="auto">iol-dts-dut</div><div dir="auto"> </div><div dir="auto">With mlnx cx5 and intel xl710?</div><div dir="auto"> </div><div dir="auto">Just checking in. </div><div> <div class="gmail_quote gmail_quote_container"><div dir="ltr" class="gmail_attr">On Tue, Aug 11, 2026 at 1:04 PM Andrew Bailey <<a href="mailto:abailey@iol.unh.edu">abailey@iol.unh.edu</a>> wrote: </div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">Refactor current flow test suite to utilize a generator method, which dynamically creates flow rules from a dictionary of pattern and action fields during runtime. This allows for much more extensive testing of the flow API without exponential code growth. Signed-off-by: Andrew Bailey <<a href="mailto:abailey@iol.unh.edu" target="_blank">abailey@iol.unh.edu</a>> Signed-off-by: Dean Marx <<a href="mailto:dmarx@iol.unh.edu" target="_blank">dmarx@iol.unh.edu</a>> Reviewed-by: Patrick Robb <<a href="mailto:probb@iol.unh.edu" target="_blank">probb@iol.unh.edu</a>> --- v7: * Resolve merge conflicts. dts/tests/TestSuite_flow_offload.py | 206 ++++++++++++++++++++++++---- 1 file changed, 182 insertions(+), 24 deletions(-) diff --git a/dts/tests/TestSuite_flow_offload.py b/dts/tests/TestSuite_flow_offload.py index be11d09875..d1a6c2fa74 100644 --- a/dts/tests/TestSuite_flow_offload.py +++ b/dts/tests/TestSuite_flow_offload.py @@ -1,7 +1,7 @@ # SPDX-License-Identifier: BSD-3-Clause # Copyright(c) 2025 University of New Hampshire -"""RTE Flow testing suite. +"""Flow offload testing suite. This suite verifies a range of flow rules built using patterns and actions from the RTE Flow API. It would be impossible to cover @@ -10,7 +10,7 @@ """ -from dataclasses import dataclass +from dataclasses import dataclass, field from itertools import product from typing import Any, Callable, Optional @@ -18,6 +18,7 @@ from scapy.layers.inet6 import IPv6 from scapy.layers.l2 import ARP, Dot1Q, Ether from scapy.layers.sctp import SCTP +from scapy.layers.vxlan import VXLAN from scapy.packet import Packet, Raw from api.capabilities import NicCapability, requires_nic_capability @@ -50,10 +51,16 @@ class Protocol: scapy_class: type[Packet] pattern_name: str fields: list[PatternField] + default_values: dict[str, Any] = field(default_factory=dict) def build_scapy_layer(self, field_values: dict[str, Any]) -> Packet: - """Construct a Scapy layer with the given field values.""" - return self.scapy_class(**field_values) + """Construct a Scapy layer with the given field values. + + Default values are applied first, then overridden by any + explicit field values so test parameters always win. + """ + merged = {**self.default_values, **field_values} + return self.scapy_class(**merged) @dataclass @@ -125,6 +132,7 @@ class JumpTest: PROTOCOLS: dict[str, Protocol] = { + # -------------------- Base Protocols -------------------- "eth": Protocol( name="eth", scapy_class=Ether, @@ -215,6 +223,89 @@ class JumpTest: PatternField("op", "opcode", [1, 2]), ], ), + # -------------------- VXLAN Outer Protocols -------------------- + "eth_outer": Protocol( + name="eth_outer", + scapy_class=Ether, + pattern_name="eth", + fields=[ + PatternField("src", "src", ["02:00:00:00:00:00"]), + PatternField("dst", "dst", ["02:00:00:00:00:02"]), + ], + ), + "ipv4_outer": Protocol( + name="ipv4_outer", + scapy_class=IP, + pattern_name="ipv4", + fields=[ + PatternField("src", "src", ["10.0.0.1"]), + PatternField("dst", "dst", ["10.0.0.2"]), + PatternField("ttl", "ttl", [64, 128]), + PatternField("tos", "tos", [0, 4]), + ], + ), + "udp_outer": Protocol( + name="udp_outer", + scapy_class=UDP, + pattern_name="udp", + fields=[], + default_values={"dport": 4789}, + ), + # -------------------- VXLAN Tunnel Header -------------------- + "vxlan": Protocol( + name="vxlan", + scapy_class=VXLAN, + pattern_name="vxlan", + fields=[ + PatternField("vni", "vni", [42, 100]), + ], + ), + # -------------------- VXLAN Inner Protocols -------------------- + "eth_inner": Protocol( + name="eth_inner", + scapy_class=Ether, + pattern_name="eth", + fields=[ + PatternField("src", "src", ["02:00:00:00:00:00"]), + PatternField("dst", "dst", ["02:00:00:00:00:02"]), + ], + ), + "ipv4_inner": Protocol( + name="ipv4_inner", + scapy_class=IP, + pattern_name="ipv4", + fields=[ + PatternField("src", "src", ["192.168.1.1"]), + PatternField("dst", "dst", ["192.168.1.2"]), + ], + ), + "ipv6_inner": Protocol( + name="ipv6_inner", + scapy_class=IPv6, + pattern_name="ipv6", + fields=[ + PatternField("src", "src", ["2001:db8::1"]), + PatternField("dst", "dst", ["2001:db8::2"]), + ], + ), + "tcp_inner": Protocol( + name="tcp_inner", + scapy_class=TCP, + pattern_name="tcp", + fields=[ + PatternField("sport", "src", [1234]), + PatternField("dport", "dst", [80]), + ], + ), + "udp_inner": Protocol( + name="udp_inner", + scapy_class=UDP, + pattern_name="udp", + fields=[ + PatternField("sport", "src", [5000]), + PatternField("dport", "dst", [53]), + ], + ), } @@ -234,6 +325,7 @@ class JumpTest: } PROTOCOL_STACKS = [ + # -------------------- Non-tunnel stacks -------------------- [("eth", True)], [("eth", False), ("ipv4", True)], [("eth", False), ("ipv4", True), ("tcp", True)], @@ -253,6 +345,66 @@ class JumpTest: [("eth", False), ("vlan", False), ("ipv6", True), ("tcp", True)], [("eth", False), ("vlan", False), ("ipv6", True), ("udp", True)], [("eth", False), ("arp", True)], + # -------------------- VXLAN tunnel stacks -------------------- + [ + ("eth_outer", False), + ("ipv4_outer", True), + ("udp_outer", False), + ("vxlan", True), + ("eth_inner", False), + ("ipv4_inner", False), + ], + [ + ("eth_outer", False), + ("ipv4_outer", True), + ("udp_outer", False), + ("vxlan", True), + ("eth_inner", False), + ("ipv4_inner", False), + ("tcp_inner", False), + ], + [ + ("eth_outer", False), + ("ipv4_outer", True), + ("udp_outer", False), + ("vxlan", True), + ("eth_inner", False), + ("ipv4_inner", False), + ("udp_inner", False), + ], + [ + ("eth_outer", False), + ("ipv4_outer", True), + ("udp_outer", False), + ("vxlan", True), + ("eth_inner", False), + ("ipv6_inner", False), + ], + [ + ("eth_outer", False), + ("ipv4_outer", True), + ("udp_outer", False), + ("vxlan", True), + ("eth_inner", False), + ("ipv6_inner", False), + ("tcp_inner", False), + ], + [ + ("eth_outer", False), + ("ipv4_outer", True), + ("udp_outer", False), + ("vxlan", True), + ("eth_inner", False), + ("ipv6_inner", False), + ("udp_inner", False), + ], + [ + ("eth_outer", False), + ("ipv4_outer", True), + ("udp_outer", False), + ("vxlan", True), + ("eth_inner", False), + ], ] @@ -304,6 +456,10 @@ def generate( ) -> list[FlowTest]: """Generate test cases for patterns matching fields across multiple protocols. + Pattern parts are assembled in stack order to preserve positional + correctness, which is required for tunnel encapsulations where + inner and outer layers share the same pattern_name. + Args: protocol_stack: List of (protocol_name, test_fields) tuples. If test_fields is True, iterate through field combinations. @@ -316,15 +472,12 @@ def generate( List of FlowTest objects ready for execution. """ action_spec = self.actions[action_name] - - wildcard_protocols = [name for name, test_fields in protocol_stack if not test_fields] - field_test_protocols = [name for name, test_fields in protocol_stack if test_fields] all_protocol_names = [name for name, _ in protocol_stack] - - wildcard_pattern_parts = [self.protocols[name].pattern_name for name in wildcard_protocols] + field_test_protocols = [name for name, test_fields in protocol_stack if test_fields] if not field_test_protocols: - pattern = " / ".join(wildcard_pattern_parts) + pattern_parts = [self.protocols[name].pattern_name for name, _ in protocol_stack] + pattern = " / ".join(pattern_parts) flow_rule = FlowRule( direction="ingress", pattern=[pattern], @@ -339,7 +492,7 @@ def generate( packet=packet, verification_type=action_spec.verification_type, verification_params=action_spec.build_verification_params(action_value), - description=" / ".join(wildcard_pattern_parts) + f" -> {<a href="http://action_spec.name" rel="noreferrer" target="_blank">action_spec.name</a>}", + description=pattern + f" -> {<a href="http://action_spec.name" rel="noreferrer" target="_blank">action_spec.name</a>}", ) ] @@ -354,24 +507,32 @@ def generate( max_vals = max(len(f_spec.test_parameters) for _, f_spec in field_combo) for i in range(max_vals): - field_pattern_parts = [] + field_value_map: dict[str, tuple[Protocol, PatternField, Any]] = {} all_field_values: dict[str, dict[str, Any]] = {} - desc_parts = [] for protocol_spec, field_spec in field_combo: val = field_spec.test_parameters[i % len(field_spec.test_parameters)] - - field_pattern_parts.append( - f"{protocol_spec.pattern_name} {field_spec.pattern_field} is {val}" - ) + field_value_map[<a href="http://protocol_spec.name" rel="noreferrer" target="_blank">protocol_spec.name</a>] = (protocol_spec, field_spec, val) if <a href="http://protocol_spec.name" rel="noreferrer" target="_blank">protocol_spec.name</a> not in all_field_values: all_field_values[<a href="http://protocol_spec.name" rel="noreferrer" target="_blank">protocol_spec.name</a>] = {} all_field_values[<a href="http://protocol_spec.name" rel="noreferrer" target="_blank">protocol_spec.name</a>][field_spec.scapy_field] = val - desc_parts.append(f"{<a href="http://protocol_spec.name" rel="noreferrer" target="_blank">protocol_spec.name</a>}[{field_spec.scapy_field}={val}]") + pattern_parts = [] + desc_parts = [] + + for proto_name, test_fields in protocol_stack: + proto_spec = self.protocols[proto_name] + if test_fields and proto_name in field_value_map: + _, f_spec, val = field_value_map[proto_name] + pattern_parts.append( + f"{proto_spec.pattern_name} {f_spec.pattern_field} is {val}" + ) + desc_parts.append(f"{<a href="http://proto_spec.name" rel="noreferrer" target="_blank">proto_spec.name</a>}[{f_spec.scapy_field}={val}]") + else: + pattern_parts.append(proto_spec.pattern_name) - full_pattern = " / ".join(wildcard_pattern_parts + field_pattern_parts) + full_pattern = " / ".join(pattern_parts) flow_rule = FlowRule( direction="ingress", @@ -384,10 +545,7 @@ def generate( all_protocol_names, all_field_values, add_payload=True ) - wildcard_desc = " / ".join(wildcard_pattern_parts) - field_desc = " / ".join(desc_parts) - full_desc = f"{wildcard_desc} / {field_desc}" if wildcard_desc else field_desc - + full_desc = " / ".join(desc_parts) test_cases.append( FlowTest( flow_rule=flow_rule, @@ -403,7 +561,7 @@ def generate( @requires_nic_capability(NicCapability.FLOW_CTRL) class TestFlowOffload(TestSuite): - """Flow offload test suite. + """Flow Offload test suite. This suite consists of 4 test cases: 1. Queue Action: Verifies queue actions with multi-protocol patterns -- 2.55.0 </blockquote></div></div>