mfd-dcb 1.18.0__py3-none-any.whl

mfd_dcb/__init__.py

@@ -0,0 +1,6 @@
+# Copyright (C) 2025 Intel Corporation
+# SPDX-License-Identifier: MIT
+"""Module for MFD DCB."""
+
+from .mfd_dcb import Dcb
+from .dcbtool_wrapper import DcbTool

mfd_dcb/const.py

@@ -0,0 +1,7 @@
+# Copyright (C) 2025 Intel Corporation
+# SPDX-License-Identifier: MIT
+"""Const for DCBmodule."""
+
+PFC_STATS = ["GLPRT_PXONRXCNT", "GLPRT_PXOFFRXCNT", "GLPRT_PXONTXCNT", "GLPRT_PXOFFTXCNT"]
+
+QOS_ENABLED = ["*QOS"]

mfd_dcb/data_structures.py

@@ -0,0 +1,12 @@
+# Copyright (C) 2025 Intel Corporation
+# SPDX-License-Identifier: MIT
+"""Module for DCB common data structures."""
+
+from enum import Enum
+
+
+class State(Enum):
+    """States."""
+
+    ENABLED = "enabled"
+    DISABLED = "disabled"

mfd_dcb/dcbnl_wrapper.py

@@ -0,0 +1,144 @@
+# Copyright (C) 2025 Intel Corporation
+# SPDX-License-Identifier: MIT
+
+"""Module for dcbnl."""
+
+import re
+
+from typing import Dict, TYPE_CHECKING, Any
+from mfd_const.qos import LOCAL_ETS, LOCAL_PFC, LOCAL_APP, DCB_TOOL_PATH_LNX
+from .exceptions import DcbExecutionError, DcbExecutionProcessError
+
+if TYPE_CHECKING:
+    from mfd_connect import RPyCConnection
+
+
+class Dcbnl:
+    """Dcbnl class provides DCB configuration using dcbnl python script."""
+
+    def __init__(self, interface_name: str, connection: "RPyCConnection"):
+        """Initialize class parameters.
+
+        :param interface_name: tested interface
+        :param connection: connection
+        """
+        self.interface_name = interface_name
+        self._connection = connection
+
+    def get_dcb(self) -> Dict[str, Dict[str, Any]]:
+        """Get complete DCB configuration for ETS, PFC and APP TLVs, local and remote.
+
+        :return: Dictionary of QoS configuration
+        """
+        qos = {}
+        qos.update(self.get_ets())
+        qos.update(self.get_pfc(from_cache=True))
+        qos.update(self.get_app(from_cache=True))
+        return qos
+
+    def get_ets(self, from_cache: bool = False) -> Dict[str, Dict[str, Any]]:
+        """Get local ETS TLV configuration of the interface_name.
+
+        :param from_cache: use current configuration output
+        :return: Dictionary of local ETS TLV configuration
+        """
+        if not from_cache:
+            self._read_qos_configuration()
+        return self._parse_ets(LOCAL_ETS)
+
+    def get_pfc(self, from_cache: bool = False) -> Dict[str, bool]:
+        """Get local PFC TLV configuration of the interface_name.
+
+        :param from_cache: use current configuration output
+        :return: Dictionary of local PFC TLV configuration
+        """
+        if not from_cache:
+            self._read_qos_configuration()
+        return self._parse_pfc(LOCAL_PFC)
+
+    def get_app(self, from_cache: bool = False) -> Dict[str, Dict[str, Any]]:
+        """Get local APP TLV configuration of the interface_name.
+
+        :param from_cache: use current configuration output
+        :return: Dictionary of local APP TLV configuration
+        """
+        if not from_cache:
+            self._read_qos_configuration()
+        return self._parse_app(LOCAL_APP)
+
+    def _read_qos_configuration(self) -> None:
+        """Run dcbnl.py script for given interface_name and store it in self._qos_output for future use.
+
+        dcbnl.py - Netlink message generation/parsing - DCB_TOOL_PATH_LNX = /tmp/tools/dcb
+        :raises DcbExecutionError: when return code of bash command is unexpected
+        """
+        dcbnl_path = self._connection.path(DCB_TOOL_PATH_LNX, "dcbnl.py")
+        command = f"{self._connection.modules().sys.executable} {dcbnl_path} {self.interface_name}"
+        output = self._connection.execute_command(
+            command, custom_exception=DcbExecutionProcessError, expected_return_codes=[0]
+        )
+        if output.stderr:
+            raise DcbExecutionError(f"Error while executing dcbnl {command}: {output.stderr}")
+        self._qos_output = output.stdout
+
+    def _parse_ets(self, key: str) -> Dict[str, Dict[str, int]]:
+        """Get local or remote QoS traffic classes as dictionary.
+
+        :param key: key in configuration dictionary for ETS
+        :return: Dictionary of QoS traffic classes configuration
+        """
+        ets_config = {}
+        current_tc = ""
+        for line in self._qos_output.splitlines():
+            line = line.strip()
+            exp = re.compile(r"tc: (?P<tc>[0-7]) tsa: (?P<tsa>ets|strict)(?:, bw: (?P<bw>\d+)%)")
+            match = exp.match(line)
+            if match:
+                current_tc = match.group("tc")
+                ets_config[current_tc] = {
+                    "TSA": match.group("tsa").upper(),
+                    "Bandwidth": int(match.group("bw") or "0"),
+                    "Priorities": [],
+                }
+                continue
+            match = re.match(r"up:\s+(?P<up>[0-7])", line)
+            if match:
+                up = int(match.group("up"))
+                ets_config[current_tc]["Priorities"].append(up)
+                continue
+        return {key: ets_config}
+
+    def _parse_pfc(self, key: str) -> Dict[str, bool]:
+        """Get operational or remote QoS flow control as dictionary.
+
+        :param key: key in configuration dictionary for PFC
+        :return: Dictionary of QoS flow control configuration
+        """
+        pfc_config = [False] * 8
+        match = re.search(r"pfc_enable:\s+(?P<pfc>0x[0-9a-fA-F]+)", self._qos_output)
+        if match:
+            pfc_bin = int(match.group("pfc"), 16)
+            for i in range(8):
+                pfc_config[i] = pfc_bin & (pow(2, i)) > 0
+        return {key: pfc_config}
+
+    def _parse_app(self, key: str) -> Dict[str, Dict[str, str]]:
+        """Get operational or remote QoS apps table.
+
+        :param key: key in configuration dictionary for PFC
+        :return: Dictionary of QoS flow control configuration
+        """
+        app_config = {}
+        no = 0
+        for line in self._qos_output.splitlines():
+            line = line.strip()
+            exp = re.compile(r"selector: (?P<selector>\d+) priority: (?P<priority>\d+) protocol: (?P<protocol>\S*)")
+            match = exp.match(line)
+            if match:
+                app_config[no] = {
+                    "selector": int(match.group("selector")),
+                    "priority": int(match.group("priority")),
+                    "protocol": match.group("protocol"),
+                }
+                no += 1
+        return {key: app_config}

mfd_dcb/dcbtool_wrapper.py

@@ -0,0 +1,155 @@
+# Copyright (C) 2025 Intel Corporation
+# SPDX-License-Identifier: MIT
+
+"""Module for dcbtool."""
+
+import re
+from typing import List, Dict, Any, TYPE_CHECKING
+from mfd_const.qos import LOCAL_ETS, LOCAL_PFC
+from .exceptions import DcbExecutionError, DcbExecutionProcessError
+
+if TYPE_CHECKING:
+    from mfd_connect import RPyCConnection
+
+
+class DcbTool:
+    """DcbTool class provide check DCB configuration using dcbtool tool."""
+
+    def __init__(self, interface_name: str, connection: "RPyCConnection"):
+        """Initialize class parameters.
+
+        :param interface_name: tested interface
+        :param connection: connection
+        """
+        self.interface_name = interface_name
+        self._connection = connection
+
+    def get_dcb(self) -> Dict[str, Dict[str, Any]]:
+        """Get complete DCB configuration for ETS, PFC and APP TLVs, local and remote.
+
+        :return: Dictionary of QoS configuration
+        """
+        qos = {}
+        qos.update(self.get_ets())
+        qos.update(self.get_pfc())
+        return qos
+
+    def get_ets(self, from_cache: bool = False) -> Dict[str, Dict[str, Any]]:
+        """Get local ETS TLV configuration of the interface_name.
+
+        :param from_cache: use current configuration output
+        :return: Dictionary of local ETS TLV configuration
+        """
+        if not from_cache:
+            self._read_qos_configuration(check_type="pg")
+        return self._parse_qos(LOCAL_ETS)
+
+    def get_pfc(self, from_cache: bool = False) -> Dict[str, bool]:
+        """Get local PFC TLV configuration of the interface_name.
+
+        :param from_cache: use current configuration output
+        :return: Dictionary of local PFC TLV configuration
+        """
+        if not from_cache:
+            self._read_qos_configuration(check_type="pfc")
+        return self._parse_qos(LOCAL_PFC)
+
+    def _read_qos_configuration(self, check_type: str) -> None:
+        """Run dcbtool tool for given interface_name and store it in self._qos_output for future use.
+
+        :param check_type: for checking dcbtool type - pg/ pfc
+        :raises DcbExecutionProcessError: when return code of bash command is unexpected
+        """
+        command = f"dcbtool go {self.interface_name} {check_type}"
+        output = self._connection.execute_command(command, custom_exception=DcbExecutionProcessError)
+        if output.stderr:
+            raise DcbExecutionError(f"Error while executing dcbnl {command}: {output.stderr}")
+        self._qos_output = output.stdout
+
+    def _parse_qos(self, key: str) -> Dict[str, Dict[str, Any]]:
+        """Get local or remote QoS traffic classes as dictionary.
+
+        :param key: key in configuration dictionary for ETS & PFC
+        :return: Dictionary of QoS traffic classes configuration
+        """
+        config_ets = {}
+        config_pfc = []
+        for line in self._qos_output.splitlines():
+            self._parse_lines(key, line, config_ets, config_pfc)
+        configs = {LOCAL_PFC: config_pfc, LOCAL_ETS: config_ets}
+        return {key: configs[key]}
+
+    def _parse_lines(
+        self,
+        key: str,
+        line: str,
+        config_ets: dict,
+        config_pfc: list,
+    ) -> None:
+        """Parse and updates in-place config_pfc and config_ets.
+
+        :param key: key in configuration dictionary for ETS or PFC
+        :param line: Each entries from dcbtool go interface <checkType(pg/pfc)>
+        :param config_ets: ets config data
+        :param config_pfc: pfc config data
+        """
+        bw_pattern = r"\s+(\d{1,3})%\s"
+        tc_pattern = r"pgid:\s+(\d\s)*\d"
+        pattern = r"pfcup:\s+(\d\s)*\d"
+        if "ETS" in key and (("pgid" in line) or ("pgpct" in line) or ("uppct" in line)):
+            line = line.strip()
+            bw_list = self._parse_line(line, bw_pattern)
+            if bw_list:
+                self._set_bw_config(bw_list, config_ets)
+            tc_list = self._parse_line(line, tc_pattern)
+            if tc_list:
+                self._set_up_config(tc_list, config_ets)
+            if not (tc_list or bw_list):
+                raise DcbExecutionError("No match found for ETS")
+        elif "PFC" in key and "pfc" in line:
+            pfc_list = self._parse_line(line, pattern)
+            if pfc_list:
+                for pfc in pfc_list:
+                    config_pfc.append(bool(not (pfc)))
+            else:
+                raise DcbExecutionError("No match found for PFC")
+
+    @staticmethod
+    def _parse_line(line: str, pattern: str) -> List[int]:
+        """To parse line and return dict with data.
+
+        :param line: line to search
+        :param pattern: regex pattern
+        :return: list of data with bw_pattern/tc_pattern
+        """
+        data = []
+        if "%" in line:
+            data = list(map(int, (re.findall(pattern, line))))
+        else:
+            match = re.compile(pattern).match(line)
+            if match:
+                for idx in range(re.compile(pattern).groups):
+                    data.append(int(match.group(idx + 1)))
+        return data
+
+    @staticmethod
+    def _set_bw_config(bw_list: list, ets_config: dict) -> None:
+        """To set bandwidth data in ets_config.
+
+        :param bw_list: list with bandwidth data
+        :param ets_config: ets config data
+        """
+        for up, bw in enumerate(bw_list):
+            if bw > 0:
+                current_tc = str(up)
+                ets_config[current_tc] = {"TSA": "ETS", "Bandwidth": bw, "Priorities": []}
+
+    @staticmethod
+    def _set_up_config(tc_list: list, ets_config: dict) -> None:
+        """To set user priority data in ets_config.
+
+        :param tc_list: list with user priority
+        :param ets_config: ets config data
+        """
+        for up, tc in enumerate(tc_list):
+            ets_config[str(tc)]["Priorities"].append(up)

mfd_dcb/enums.py

@@ -0,0 +1,28 @@
+# Copyright (C) 2025 Intel Corporation
+# SPDX-License-Identifier: MIT
+"""Enums for DCBmodule."""
+
+from enum import Enum, IntEnum
+
+
+class WindowsDcbMode(Enum):
+    """Enum class for Windows DCB Features."""
+
+    SWITCH = "Switch Settings"
+    OS = "OS Controlled"
+    ENABLED = "Enabled"
+    DISABLED = "Disabled"
+
+
+class PfcType(Enum):
+    """Enum class for PFC Type."""
+
+    LOCAL = "local"
+    REMOTE = "remote"
+
+
+class PfcMode(IntEnum):
+    """Enum class for PFC Mode."""
+
+    VLAN = 0
+    DSCP = 1

mfd_dcb/exceptions.py

@@ -0,0 +1,21 @@
+# Copyright (C) 2025 Intel Corporation
+# SPDX-License-Identifier: MIT
+"""Exceptions for module."""
+
+from subprocess import CalledProcessError
+
+
+class DcbConnectedOSNotSupported(Exception):
+    """Handle Dcb unsupported os exceptions."""
+
+
+class DcbException(Exception):
+    """Handle Dcb exceptions."""
+
+
+class DcbExecutionError(Exception):
+    """Handle Dcb execution errors."""
+
+
+class DcbExecutionProcessError(CalledProcessError):
+    """Handle Dcb process execution errors."""

mfd_dcb/freebsd.py

@@ -0,0 +1,146 @@
+# Copyright (C) 2025 Intel Corporation
+# SPDX-License-Identifier: MIT
+
+"""Module for DCB support for FreeBSD OS."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, List, Tuple
+
+from mfd_common_libs import add_logging_level, log_levels, os_supported
+from mfd_typing import OSName
+from mfd_sysctl.freebsd import FreebsdSysctl
+from mfd_connect.exceptions import ConnectionCalledProcessError
+from .mfd_dcb import Dcb
+from .enums import PfcMode
+from .exceptions import DcbException
+
+
+if TYPE_CHECKING:
+    from mfd_connect import RPyCConnection
+
+logger = logging.getLogger(__name__)
+add_logging_level("MODULE_DEBUG", log_levels.MODULE_DEBUG)
+
+
+class FreeBsdDcb(Dcb):
+    """Class to handle DCB in FreeBSD."""
+
+    @os_supported(OSName.FREEBSD)
+    def __init__(self, *, connection: "RPyCConnection") -> None:
+        """Initialize FreeBSD DCB."""
+        super().__init__(connection=connection)
+        self._sysctl = FreebsdSysctl(connection=connection)
+
+    def dscp_apply_map(self, interface_name: str, dscpmap: List[int]) -> None:
+        """Configure DSCP2TC map on the interface.
+
+        :param interface_name: name of the network interface
+        :param dscpmap: DSCP2TC map for setting on the interface
+        :raises DcbException: when DSCP map failed to apply (wrong number of elements or invalid values).
+        :raises ConnectionCalledProcessError: when sysctl failed and returned an unexpected error code.
+        """
+
+        def _apply_range(device_oid: str, values: list, start: int) -> None:
+            command = f"sysctl {device_oid}.dscp2tc_map.{start}-{start + 7}={','.join(map(str, values))}"
+            try:
+                self._connection.execute_command(command, expected_return_codes=[0])
+            except ConnectionCalledProcessError as e:
+                if "returned unexpected exit status 1" in str(e):
+                    raise DcbException(f"Failed to apply DSCP map for range {start}-{start + 7}")
+                else:
+                    raise e
+
+        device_oid = (
+            f"dev.{self._sysctl.get_driver_name(interface_name)}."
+            f"{self._sysctl.get_driver_interface_number(interface_name)}"
+        )
+        logger.log(
+            level=log_levels.MODULE_DEBUG,
+            msg=f"Applying DSCP map: {dscpmap} on interface {interface_name}",
+        )
+        # apply DSCP map in parts (8 elements for each sysctl variable)
+        for r in range(0, 64, 8):
+            _apply_range(device_oid, dscpmap[r : r + 8], r)
+
+    def dscp_read_map(self, interface_name: str) -> List[int]:
+        """Read DSCP2TC map from the interface.
+
+        :param interface_name: name of the network interface
+        :return: DSCP map that is configured on the interface
+        """
+
+        def _read_range(device_oid: str, start: int) -> Tuple[int]:
+            full_oid = f"{device_oid}.dscp2tc_map.{start}-{start + 7}"
+            result = self._sysctl.get_sysctl_value(full_oid)
+            return tuple(map(int, str(result).split(",")))
+
+        device_oid = (
+            f"dev.{self._sysctl.get_driver_name(interface_name)}."
+            f"{self._sysctl.get_driver_interface_number(interface_name)}"
+        )
+        m = []
+        logger.log(level=log_levels.MODULE_DEBUG, msg=f"Reading DSCP map on interface {interface_name}")
+        # read DSCP map in chunks (8 elements each) and add them to a list
+        for r in range(0, 64, 8):
+            m.extend(_read_range(device_oid, r))
+        return m
+
+    def dscp_verify_map(self, interface_name: str, dscpmap: List[int]) -> bool:
+        """Check that the interface has the same DSCP2TC map.
+
+        :param interface_name: Network interface
+        :param dscpmap: DSCP2TC map to compare
+        :return: True if the interface has the same dscp2tc map
+        """
+        current_dscpmap = self.dscp_read_map(interface_name)
+        return current_dscpmap == dscpmap
+
+    def set_pfc_mode(self, interface_name: str, mode: PfcMode) -> None:
+        """Enable/disable DSCP mode on the interface.
+
+        :param interface_name: Network interface
+        :param mode: Enable (PfcMode.DSCP) or disable (PfcMode.VLAN) DSCP mode on the interface
+        """
+        oid = (
+            f"dev.{self._sysctl.get_driver_name(interface_name)}."
+            f"{self._sysctl.get_driver_interface_number(interface_name)}.pfc_mode"
+        )
+        self._sysctl.set_sysctl_value(oid, value=str(mode.value))
+
+    def get_pfc_mode(self, interface_name: str) -> PfcMode:
+        """Get the current PFC mode on the interface.
+
+        :param interface_name: Name of the network interface
+        :return: Current PFC mode (VLAN/DSCP) on the interface
+        """
+        oid = (
+            f"dev.{self._sysctl.get_driver_name(interface_name)}."
+            f"{self._sysctl.get_driver_interface_number(interface_name)}.pfc_mode"
+        )
+        return PfcMode(int(self._sysctl.get_sysctl_value(oid)))
+
+    def set_ets_min_rate(self, interface_name: str, ets: List[int]) -> None:
+        """Configure ETS on an interface.
+
+        :param interface_name: Network interface
+        :param ets: ETS bandwidth table (list of 8 elements of ints)
+        """
+        oid = (
+            f"dev.{self._sysctl.get_driver_name(interface_name)}."
+            f"{self._sysctl.get_driver_interface_number(interface_name)}.ets_min_rate"
+        )
+        self._sysctl.set_sysctl_value(oid, value=str(",".join(map(str, ets))))
+
+    def get_ets_min_rate(self, interface_name: str) -> List[int]:
+        """Read current ETS bandwidth table.
+
+        :param interface_name: Name of the network interface
+        :return: Current ETS bandwidth table configured on the interface
+        """
+        oid = (
+            f"dev.{self._sysctl.get_driver_name(interface_name)}."
+            f"{self._sysctl.get_driver_interface_number(interface_name)}.ets_min_rate"
+        )
+        return list(map(int, str(self._sysctl.get_sysctl_value(oid)).split(",")))