Re: [PATCH v4] dts: add flow rule dataclass to testpmd shell

[Luca Vizzarro <Luca.Vizzarro@arm.com>]

Hi Dean,

This looks fine for most of it, but some of Juraj's prior comments still 
apply. See comments in line.

On 10/10/2024 22:06, Dean Marx wrote:
> +@dataclass

I'd make this kw_only=True:

   @dataclass(kw_only=True)

this enforces the construction to include field names for the sake of 
readability. Having:

   FlowRule(0, True, "ip", "rss")

is not really as self-descriptive as:

   FlowRule(port_id=0, ingress=True, pattern="ip", actions="rss")

> +class FlowRule:
> +    """Dataclass for setting flow rule parameters."""

We should add the pattern that this is meant to represent in the class 
docstring here above, as suggested by Juraj. Also I'd change the current 
docstring to what the class is actually doing, e.g.:

   Class representation of flow rule parameters.

   This class represents the parameters of any flow rule as per the
   following pattern:

     [group {group_id}] [priority {level}] [ingress] [egress]
     [user_id {user_id}] pattern {item} [/ {item} [...]] / end
     actions {action} [/ {action} [...]] / end

Mind that the pattern above is taking from the testpmd guide[1], I 
excluded the bits that you haven't implemented.

> +
> +    #:
> +    port_id: int

I would leave out the `port_id` here, if we wanted to apply the same 
flow rule to multiple ports, this would complicate things. This should 
belong under the `flow_create` function.

> +    #:
> +    ingress: bool
> +    #:
> +    pattern: str

The rule pattern above also suggests that this...

> +    #:
> +    actions: str

...and this can be `list[str]`, and then joined in __str__:

   "/ ".join(self.actions)

> +
> +    #:
> +    group_id: int | None = None
> +    #:
> +    priority_level: int | None = None
> +    #:
> +    user_id: int | None = None

Perhaps, order the fields in the way they are represented in the flow 
rule. So this should go before actions and patterns.

> +
> +    def __str__(self) -> str:
> +        """Returns the string representation of a flow_func instance.

s/flow_func/FlowRule, or just don't mention it at all as it's implicit:

   Returns the string representation of this instance.

> +
> +        In this case, a properly formatted flow create command that can be sent to testpmd.

I reckon that `flow create` should be created by the flow create command 
function. Let's keep this to just produce the parameters settings...

> +        """
> +        ret = f"flow create {self.port_id} "

...and make this an empty string:

   ret = ""

> +        if self.group_id is not None:
> +            ret += f"group {self.group_id} "
> +        if self.priority_level is not None:
> +            ret += f"priority {self.priority_level} "
> +        ret += "ingress " if self.ingress else "egress "

The pattern above suggests we can have flow rules for both ingress and 
egress. Therefore I'd have a field for egress as well, or we want to get 
fancy, create a FlowRuleDirection enum.Flag, so that we can do:

   FlowRule(direction=FlowRuleDirection.INGRESS|EGRESS, ...)

Or to not overcomplicate we can just rely on mypy's checking:

   class FlowRule:
     ...
     direction: Literal["ingress", "egress", "both"]

   FlowRule(direction="ingress")

> +        if self.user_id is not None:
> +            ret += f"user_id {self.user_id} "
> +        ret += f"pattern {self.pattern} / end "
> +        ret += f"actions {self.actions} / end"
> +        return ret
> +
> +
>   class PacketOffloadFlag(Flag):
>       """Flag representing the Packet Offload Features Flags in DPDK.
>   
> @@ -1717,6 +1755,25 @@ def show_port_stats(self, port_id: int) -> TestPmdPortStats:
>   
>           return TestPmdPortStats.parse(output)
>   
> +    def flow_create(self, flow_rule: FlowRule, verify: bool = True) -> None:

As mentioned, let's put the port_id here.

> +        """Creates a flow rule in the testpmd session.
> +
> +        Args:
> +            flow_rule: FlowRule object used for creating testpmd flow rule.

Reference to the class missing:

   :class:`FlowRule` object

> +            verify: If :data:`True`, the output of the command is scanned
> +            to ensure the flow rule was created successfully.
> +
> +        Raises:
> +            InteractiveCommandExecutionError: If flow rule is invalid.
> +        """
> +        flow_output = self.send_command(str(flow_rule))

And this can be come:

   flow_output = self.send_command(f"flow create {port_id} {flow_rule}")

> +        if verify:
> +            if "created" not in flow_output:
> +                self._logger.debug(f"Failed to create flow rule:\n{flow_output}")
> +                raise InteractiveCommandExecutionError(
> +                    f"Failed to create flow rule:\n{flow_output}"
> +                )
> +
>       @requires_stopped_ports
>       def set_port_mtu(self, port_id: int, mtu: int, verify: bool = True) -> None:
>           """Change the MTU of a port using testpmd.

Finally, I also agree with Juraj's comment to make a structure for 
actions and patterns. But that's overkill for now. We can just deal with 
it if we have to deal with their complexity in the future.

But like also Juraj's said, I'd introduce a flow_delete function with 
flow_create. You should make it so flow_create returns the flow rule ID, 
so that we can manipulate it, and use it with flow_delete.

Last thing, I'd split the FlowRule class and the flow_(create|delete) 
commands in two commits.

I hope my comments are helpful and make sense. Also mind that I don't 
have a thorough knowledge of flows, I've just had a crash course for the 
purpose of this review. So I may not understand everything and could be 
wrong, in which case please correct me.

Best,
Luca

[1] 
https://doc.dpdk.org/guides/testpmd_app_ug/testpmd_funcs.html#flow-syntax