From: Jeremy Spewock <jspew...@iol.unh.edu>
There are methods within DTS currently that support updating the MTU of
ports on a node, but the methods for doing this in a linux session rely
on the ip command and the port being bound to the kernel driver. Since
test suites are run while bound to the driver for DPDK, there needs to
be a way to modify the value while bound to said driver as well. This is
done by using testpmd to modify the MTU.
Signed-off-by: Jeremy Spewock <jspew...@iol.unh.edu>
---
dts/framework/remote_session/testpmd_shell.py | 97 ++++++++++++++++++-
1 file changed, 95 insertions(+), 2 deletions(-)
diff --git a/dts/framework/remote_session/testpmd_shell.py
b/dts/framework/remote_session/testpmd_shell.py
index 805bb3a77d..703f3cbeff 100644
--- a/dts/framework/remote_session/testpmd_shell.py
+++ b/dts/framework/remote_session/testpmd_shell.py
@@ -20,7 +20,7 @@
from enum import Enum, auto
from functools import partial
from pathlib import PurePath
-from typing import Callable, ClassVar
+from typing import Any, Callable, ClassVar
from framework.exception import InteractiveCommandExecutionError
from framework.settings import SETTINGS
@@ -82,12 +82,48 @@ class TestPmdForwardingModes(StrEnum):
recycle_mbufs = auto()
+def stop_then_start_port(
+ func: Callable[["TestPmdShell", int, Any], None], verify: bool = True
+) -> Callable[["TestPmdShell", int, Any], None]:
+ """Decorator that stops a port, runs decorated function, then starts the
port.
+
+ The function being decorated must be a method defined in
:class:`TestPmdShell` that takes a
+ port ID (as an int) as its first parameter. The port ID will be passed into
+ :meth:`~TestPmdShell._stop_port` and :meth:`~TestPmdShell._start_port` so
that the correct port
+ is stopped/started.
+
+ Args:
+ func: The function to run while the port is stopped. The first
parameter of `func` must be
+ a port ID given as an int.
+ verify: Whether to verify the stopping and starting of the port.
+
+ Returns:
+ Function that stops a port, runs the decorated function, then starts
the port.
+ """
+
+ def wrapper(shell: "TestPmdShell", port_id: int, *args, **kwargs) -> None:
+ """Function that wraps the instance method of :class:`TestPmdShell`.
+
+ Args:
+ shell: Instance of the shell containing the method to decorate.
+ port_id: ID of the port to stop/start.
+ """
+ shell._stop_port(port_id, verify)
+ func(shell, port_id, *args, **kwargs)
+ shell._start_port(port_id, verify)
+
+ return wrapper
+
+
class TestPmdShell(SingleActiveInteractiveShell):
"""Testpmd interactive shell.
The testpmd shell users should never use
the :meth:`~.interactive_shell.InteractiveShell.send_command` method
directly, but rather
- call specialized methods. If there isn't one that satisfies a need, it
should be added.
+ call specialized methods. If there isn't one that satisfies a need, it
should be added. Methods
+ of this class can be optionally decorated by :func:`~stop_then_start_port`
if their first
+ parameter is the ID of a port in testpmd. This decorator will stop the
port before running the
+ method and then start it again once the method is finished.
Attributes:
number_of_ports: The number of ports which were allowed on the
command-line when testpmd
@@ -227,6 +263,63 @@ def set_forward_mode(self, mode: TestPmdForwardingModes,
verify: bool = True):
f"Test pmd failed to set fwd mode to {mode.value}"
)
+ def _stop_port(self, port_id: int, verify: bool = True) -> None:
+ """Stop port with `port_id` in testpmd.
+
+ Depending on the PMD, the port may need to be stopped before
configuration can take place.
+ This method wraps the command needed to properly stop ports and take
their link down.
+
+ Raises:
+ InteractiveCommandExecutionError: If `verify` is :data:`True` and
the port did not
+ successfully stop.
+ """
+ stop_port_output = self.send_command(f"port stop {port_id}")
+ if verify and ("Done" not in stop_port_output):
+ self._logger.debug(f"Failed to stop port {port_id}. Output
was:\n{stop_port_output}")
+ raise InteractiveCommandExecutionError(f"Test pmd failed to stop
port {port_id}.")
+
+ def _start_port(self, port_id: int, verify: bool = True) -> None:
+ """Start port with `port_id` in testpmd.
+
+ Because the port may need to be stopped to make some configuration
changes, it naturally
+ follows that it will need to be started again once those changes have
been made.
+
+ Raises:
+ InteractiveCommandExecutionError: If `verify` is :data:`True` and
the port did not come
+ back up.
+ """
+ start_port_output = self.send_command(f"port start {port_id}")
+ if verify and ("Done" not in start_port_output):
+ self._logger.debug(f"Failed to start port {port_id}. Output
was:\n{start_port_output}")
+ raise InteractiveCommandExecutionError(f"Test pmd failed to start
port {port_id}.")
+
+ @stop_then_start_port
+ def set_port_mtu(self, port_id: int, mtu: int, verify: bool = True) ->
None:
+ """Change the MTU of a port using testpmd.
+
+ Some PMDs require that the port be stopped before changing the MTU,
and it does no harm to
+ stop the port before configuring in cases where it isn't required, so
we first stop ports,
+ then update the MTU, then start the ports again afterwards.
+
+ Args:
+ port_id: ID of the port to adjust the MTU on.
+ mtu: Desired value for the MTU to be set to.
+ verify: If `verify` is :data:`True` then the output will be
scanned in an attempt to
+ verify that the mtu was properly set on the port. Defaults to
:data:`True`.
+
+ Raises:
+ InteractiveCommandExecutionError: If `verify` is :data:`True` and
the MTU was not
+ properly updated on the port matching `port_id`.
+ """
+ set_mtu_output = self.send_command(f"port config mtu {port_id} {mtu}")
+ if verify and (f"MTU: {mtu}" not in self.send_command(f"show port info
{port_id}")):
+ self._logger.debug(
+ f"Failed to set mtu to {mtu} on port {port_id}." f" Output
was:\n{set_mtu_output}"
+ )
+ raise InteractiveCommandExecutionError(
+ f"Test pmd failed to update mtu of port {port_id} to {mtu}"
+ )
+
def _close(self) -> None:
"""Overrides :meth:`~.interactive_shell.close`."""
self.stop()
--
2.45.2
