tdl-xoa-driver 1.0.0__py3-none-any.whl

xoa_driver/internals/state_storage/ports_state.py

@@ -0,0 +1,154 @@
+import asyncio
+from typing import List
+
+from xoa_driver.internals.commands import (
+    P_CAPABILITIES,
+    P4_CAPABILITIES,
+    P_RECEIVESYNC,
+    P_RESERVEDBY,
+    P_RESERVATION,
+    P_INTERFACE,
+    P_TRAFFIC,
+    P4_STATE,
+)
+from xoa_driver.internals.core import funcs
+from xoa_driver.internals.commands import enums
+
+from xoa_driver.internals.utils import attributes as utils
+from ._speed_detector import SpeedDetector
+
+
+class PortLocalState:
+    """Port local state
+    """
+    __slots__ = (
+        "model",
+        "serial_number",
+        "interface",
+        "reservation",
+        "reserved_by",
+        "sync_status"
+    )
+
+    def __init__(self) -> None:
+        self.model: str = ""
+        self.serial_number: int = 0
+        self.interface: str = ""
+        self.reservation: "enums.ReservedStatus" = enums.ReservedStatus.RELEASED
+        self.reserved_by: str = ""
+        self.sync_status: "enums.SyncStatus" = enums.SyncStatus.NO_SYNC
+
+    async def initiate(self, port) -> None:
+        (
+            sync_status_r,
+            interface_r,
+            reservation_r,
+            reserved_by_r,
+        ) = await funcs.apply(
+            port.sync_status.get(),
+            port.interface.get(),
+            port.reservation.get(),
+            port.reserved_by.get(),
+        )
+        self.sync_status = enums.SyncStatus(sync_status_r.sync_status)
+        self.interface = interface_r.interface
+        self.reservation = enums.ReservedStatus(reservation_r.status)
+        self.reserved_by = reserved_by_r.username
+
+    def register_subscriptions(self, port) -> None:
+        port._conn.subscribe(P_RECEIVESYNC, utils.Update(self, "sync_status", "sync_status", port._check_identity))
+        port._conn.subscribe(P_RESERVEDBY, utils.Update(self, "reserved_by", "username", port._check_identity))
+        port._conn.subscribe(P_RESERVATION, utils.Update(self, "reservation", "status", port._check_identity))
+        port._conn.subscribe(P_INTERFACE, utils.Update(self, "interface", "interface", port._check_identity))
+
+
+class PortChimeraLocalState(PortLocalState):
+    """Chimera port's local state
+    """
+    __slots__ = ("capabilities",)
+    capabilities: "P_CAPABILITIES.GetDataAttr"
+
+    async def initiate(self, port) -> None:
+        capabilities, _ = await asyncio.gather(
+            port.capabilities.get(),
+            super().initiate(port)
+        )
+        self.capabilities = capabilities
+
+
+class PortL23LocalState(PortLocalState):
+    """L23 port's local state
+    """
+    __slots__ = (
+        "capabilities",
+        "traffic_state"
+    )
+    capabilities: "P_CAPABILITIES.GetDataAttr"
+
+    def __init__(self) -> None:
+        self.traffic_state: "enums.TrafficOnOff" = enums.TrafficOnOff.OFF
+
+    async def initiate(self, port) -> None:
+        capabilities, traffic_state_r, _ = await asyncio.gather(
+            port.capabilities.get(),
+            port.traffic.state.get(),
+            super().initiate(port)
+        )
+        self.capabilities = capabilities
+        self.traffic_state = enums.TrafficOnOff(traffic_state_r.on_off)
+
+    def register_subscriptions(self, port) -> None:
+        super().register_subscriptions(port)
+        port._conn.subscribe(P_TRAFFIC, utils.Update(self, "traffic_state", "on_off", port._check_identity))
+
+
+class PortL23GenuineLocalState(PortL23LocalState):
+    """L23 port's local state
+    """
+    __slots__ = ("port_possible_speed_modes",)
+
+    def __init__(self) -> None:
+        self.port_possible_speed_modes: List["enums.PortSpeedMode"] = []
+
+    async def initiate(self, port) -> None:
+        await super().initiate(port)
+        speed_detector = SpeedDetector(
+            self.capabilities,
+            self.interface
+        )
+        self.port_possible_speed_modes = speed_detector.find_port_possible_speed()
+
+    @property
+    def is_brr_mode_supported(self) -> bool:
+        """Whether this L23 port supports BRR mode.
+
+        :return: whether this port supports BRR mode.
+        :rtype: bool
+        """
+        return "T1" in self.interface
+
+
+class PortL47LocalState(PortLocalState):
+    """L47 port's local state
+    """
+    __slots__ = (
+        "capabilities",
+        "traffic_state",
+    )
+    capabilities: "P4_CAPABILITIES.GetDataAttr"
+
+    def __init__(self) -> None:
+        self.traffic_state: "enums.L47PortState" = enums.L47PortState.OFF
+
+    async def initiate(self, port) -> None:
+        capabilities, traffic_state_r, _ = await asyncio.gather(
+            port.capabilities.get(),
+            port.state.get(),
+            super().initiate(port)
+        )
+        self.capabilities = capabilities
+        self.traffic_state = enums.L47PortState(traffic_state_r.state)
+
+    def register_subscriptions(self, port) -> None:
+        super().register_subscriptions(port)
+        port._conn.subscribe(P4_STATE, utils.Update(self, "traffic_state", "state", port._check_identity))

xoa_driver/internals/state_storage/testers_state.py

@@ -0,0 +1,104 @@
+import asyncio
+from typing import (
+    Optional,
+    Final,
+)
+from xoa_driver.internals.core import funcs
+from xoa_driver.internals.commands import enums
+from xoa_driver.internals.commands import (
+    C_RESERVATION,
+    C_CAPABILITIES,
+    C_RESERVEDBY,
+)
+from xoa_driver.internals.utils import attributes as utils
+from xoa_driver.internals.exceptions.testers import UnsupportedFirmwareError
+
+MIN_SUPPORTED_VERSION = 446.5
+
+
+class TesterLocalState:
+    """Tester local state
+
+    :param host: tester's address/hostname
+    :type host: str
+    :param port: the port number for connection establishment
+    :type port: int
+    """
+    __slots__ = (
+        "host",
+        "port",
+        "model",
+        "capabilities",
+        "serial_number",
+        "version_major",
+        "driver_version",
+        "reservation",
+        "reserved_by",
+    )
+
+    def __init__(self, host: str, port: int) -> None:
+        self.host: Final[str] = host
+        self.port: Final[int] = port
+        self.model: str = ""
+        self.capabilities: Optional["C_CAPABILITIES.GetDataAttr"] = None
+        self.serial_number: int = 0
+        self.version_major: int = 0
+        self.driver_version: int = 0
+        self.reservation: enums.ReservedStatus = enums.ReservedStatus.RELEASED
+        self.reserved_by: str = ""
+
+    async def initiate(self, tester) -> None:
+        (
+            capabilities_resp,
+            model_res,
+            v_major_res,
+            serial_res,
+            reserved_by_res,
+            reservation_resp,
+        ) = await funcs.apply(
+            tester.capabilities.get(),
+            tester.model.get(),
+            tester.version_no.get(),
+            tester.serial_no.get(),
+            tester.reserved_by.get(),
+            tester.reservation.get(),
+        )
+        self.reserved_by = reserved_by_res.username
+        self.model = model_res.model
+        self.driver_version = v_major_res.pci_driver_version
+        self.version_major = v_major_res.chassis_major_version
+        self.serial_number = serial_res.serial_number
+        self.reservation = reservation_resp.operation
+        self.capabilities = capabilities_resp
+
+    def register_subscriptions(self, tester) -> None:
+        tester._conn.subscribe(C_RESERVEDBY, utils.Update(self, "reserved_by", "username"))
+        tester._conn.subscribe(C_RESERVATION, utils.Update(self, "reservation", "operation"))
+
+
+class GenuineTesterLocalState(TesterLocalState):
+    """Genuine Tester Local State
+
+    :param host: tester's address/hostname
+    :type host: str
+    :param port: the port number for connection establishment
+    :type port: int
+    """
+    __slots__ = ("build_string", "version_minor")
+
+    def __init__(self, host: str, port: int) -> None:
+        super().__init__(host, port)
+        self.build_string: str = ""
+        self.version_minor: int = 0
+
+    async def initiate(self, tester) -> None:
+        bs, v_minor, _ = await asyncio.gather(
+            tester.build_string.get(),
+            tester.version_no_minor.get(),
+            super().initiate(tester)
+        )
+        self.build_string = bs.build_string
+        self.version_minor = v_minor.chassis_minor_version
+        current_version = float(f"{self.version_major}.{self.version_minor}")
+        if current_version < MIN_SUPPORTED_VERSION:
+            raise UnsupportedFirmwareError(current_version)

xoa_driver/internals/utils/attributes.py

@@ -0,0 +1,33 @@
+from dataclasses import dataclass
+from typing import (
+    Callable,
+    Type,
+    TYPE_CHECKING,
+)
+if TYPE_CHECKING:
+    from xoa_driver.internals.core.transporter.protocol.struct_response import Response
+    from xoa_driver.internals.core.transporter._typings import XoaCommandType
+    from xoa_driver.internals.core import interfaces as itf
+
+
+@dataclass
+class Update:
+    inst: Type
+    property_name: str
+    response_key: str
+    condition: Callable[["Response"], bool] = lambda _: True
+
+    # keep it Async just for consistent interface of event_observer
+    async def __call__(self, response: "Response") -> None:
+        if not self.condition(response):
+            return None
+        v = getattr(response.values, self.response_key)
+        setattr(self.inst, self.property_name, v)
+
+
+def on_event(self, evt: "XoaCommandType", callback: "itf.CallbackType") -> None:
+    async def _f(response: "Response", *args, **kwargs) -> None:
+        if not self._check_identity(response):
+            return None
+        await callback(self, response.values, *args, **kwargs)
+    self._conn.subscribe(evt, _f)

xoa_driver/internals/utils/cap_id.py

@@ -0,0 +1,63 @@
+from typing import (
+    NamedTuple,
+    Type,
+    TypeVar,
+)
+from xoa_driver.internals.commands import P_CAPABILITIES
+
+T = TypeVar("T", bound="CapID")
+
+
+class CapID(NamedTuple):
+    """ID generated based on the port capability"""
+
+    can_set_autoneg: int
+    can_eee: int
+    can_hw_reg_access: int
+    can_tcvr_mii_reg_access: int
+    can_adv_phy_man: int
+    can_mdi_mdix: int
+    can_dyn_traffic_change: int
+    can_pcs_pma_config: int
+    can_fec: int
+    can_fec_stats: int
+    can_tx_eq: int
+    can_rx_retune: int
+    can_manipulate_preamble: int
+    can_set_link_train: int
+    can_link_flap: int
+    can_auto_neg_base_r: int
+    can_pma_error_pulse: int
+
+    @classmethod
+    def create_from_capabilities(cls: Type[T], cap: P_CAPABILITIES.GetDataAttr) -> T:
+        return cls(
+            cap.can_set_autoneg,
+            cap.can_eee,
+            cap.can_hw_reg_access,
+            cap.can_tcvr_mii_reg_access,
+            cap.can_adv_phy_man,
+            cap.can_mdi_mdix,
+            cap.can_dyn_traffic_change,
+            cap.can_pcs_pma_config,
+            cap.can_fec,
+            cap.can_fec_stats,
+            cap.can_tx_eq,
+            cap.can_rx_retune,
+            cap.can_manipulate_preamble,
+            cap.can_set_link_train,
+            cap.can_link_flap,
+            cap.can_auto_neg_base_r,
+            cap.can_pma_error_pulse,
+        )
+
+    def to_int(self) -> int:
+        return int("".join(str(ele) for ele in self), 2)
+
+    def __eq__(self, other: "CapID") -> bool:
+        if isinstance(other, CapID):
+            return self.to_int() == other.to_int()
+        return False
+
+    def __ne__(self, other: "CapID") -> bool:
+        return not self.__eq__(other)

xoa_driver/internals/utils/con_traffic_light.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+import asyncio
+import typing as t
+from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.core.transporter.protocol.struct_request import Request
+from xoa_driver.internals.core.transporter._typings import ICommand
+
+
+class Green:
+    @staticmethod
+    def is_connected(inst: itf.IConnection) -> bool:
+        return inst.is_connected
+
+    @staticmethod
+    def send(inst: itf.IConnection, data: bytes | bytearray | memoryview) -> None:
+        return inst.send(data)
+
+    @staticmethod
+    def close(inst: itf.IConnection) -> None:
+        return inst.close()
+
+    @staticmethod
+    async def prepare_data(inst: itf.IConnection, request: "Request") -> tuple[bytes, asyncio.Future]:
+        return await inst.prepare_data(request)
+
+    @staticmethod
+    def subscribe(inst: itf.IConnection, xmc_cls: "ICommand", callback: t.Callable) -> None:
+        return inst.subscribe(xmc_cls, callback)
+
+    @staticmethod
+    def on_disconnected(inst: itf.IConnection, callback: t.Callable) -> None:
+        return inst.on_disconnected(callback)
+
+
+class Red:
+    @staticmethod
+    def is_connected(inst: itf.IConnection) -> bool:
+        return False
+
+    @staticmethod
+    def send(inst: itf.IConnection, data: bytes | bytearray | memoryview) -> None:
+        raise ConnectionRefusedError("The instance is not valid anymore, please obtain() a new one.")
+
+    @staticmethod
+    def close(inst) -> None:
+        raise ConnectionRefusedError("The instance is not valid anymore, please obtain() a new one.")
+
+    @staticmethod
+    async def prepare_data(inst, request: "Request") -> tuple[bytes, asyncio.Future]:
+        raise ConnectionRefusedError("The instance is not valid anymore, please obtain() a new one.")
+
+    @staticmethod
+    def subscribe(inst, xmc_cls: "ICommand", callback: t.Callable) -> None:
+        raise ConnectionRefusedError("The instance is not valid anymore, please obtain() a new one.")
+
+    @staticmethod
+    def on_disconnected(inst, callback: t.Callable) -> None:
+        raise ConnectionRefusedError("The instance is not valid anymore, please obtain() a new one.")
+
+
+class ConnectionTrafficLight:
+    __slots__ = ("_conn", "state")
+
+    def __init__(self, connection: itf.IConnection) -> None:
+        self._conn = connection
+        self.state = Green
+
+    def set_outdated(self) -> None:
+        self.state = Red
+
+    @property
+    def is_connected(self) -> bool:
+        return self.state.is_connected(self._conn)
+
+    def send(self, data: bytes | bytearray | memoryview) -> None:
+        return self.state.send(self._conn, data)
+
+    def close(self) -> None:
+        return self.state.close(self._conn)
+
+    async def prepare_data(self, request: "Request") -> tuple[bytes, asyncio.Future]:
+        return await self.state.prepare_data(self._conn, request)
+
+    def subscribe(self, xmc_cls: "ICommand", callback: t.Callable) -> None:
+        return self.state.subscribe(self._conn, xmc_cls, callback)
+
+    def on_disconnected(self, callback: t.Callable) -> None:
+        return self.state.on_disconnected(self._conn, callback)

xoa_driver/internals/utils/indices/_interfaces.py

@@ -0,0 +1,26 @@
+from typing import (
+    Protocol,
+    List,
+    Type,
+    TYPE_CHECKING,
+)
+
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+    from .. import kind
+    from . import observer
+
+
+class IIndexType(Protocol):
+    def __init__(self, conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "observer.IndicesObserver") -> None: ...  # noqa: E704
+
+    async def delete(self) -> None: ...  # noqa: E704
+
+    @property
+    def idx(self) -> int: ...  # noqa: E704
+
+    @classmethod
+    async def _fetch(cls, conn, module_id, port_id) -> List[int]: ...  # noqa: E704
+
+    @classmethod
+    async def _new(cls, conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "observer.IndicesObserver") -> Type: ...  # noqa: E704

xoa_driver/internals/utils/indices/header_modifier_manager.py

@@ -0,0 +1,56 @@
+from typing import (
+    List,
+    Type,
+    Union,
+    Generic,
+    TypeVar,
+    TYPE_CHECKING,
+)
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+    from xoa_driver.internals.commands import (
+        PS_MODIFIERCOUNT,
+        PS_MODIFIEREXTCOUNT
+    )
+    CT = Union[Type[PS_MODIFIERCOUNT], Type[PS_MODIFIEREXTCOUNT]]
+
+MT = TypeVar("MT")
+
+
+class ModifiersManager(Generic[MT]):
+    def __init__(self, conn: "itf.IConnection", kind, count_type: "CT", modifier_type: Type[MT]) -> None:
+        self.__conn = conn
+        self.__kind = kind
+        self.__modifier_type = modifier_type
+
+        self._count = count_type(self.__conn, *kind)
+        self.__items: List[MT] = []
+
+    async def _populate(self) -> None:
+        count = (await self._count.get()).to_tuple()[0]  # modifier_count or ext_modifier_count
+        self.__items = [
+            self.__modifier_type(
+                self.__conn,
+                *self.__kind,
+                idx
+            )
+            for idx in range(count)
+        ]
+
+    async def configure(self, number: int) -> None:
+        await self._count.set(number)
+        await self._populate()
+
+    async def clear(self) -> None:
+        await self._count.set(0)
+        self.__items.clear()
+
+    def __len__(self) -> int:
+        return len(self.__items)
+
+    def __iter__(self):
+        return iter(self.__items)
+
+    def obtain(self, idx: int) -> MT:
+        """Access modifier of the index value"""
+        return self.__items[idx]

xoa_driver/internals/utils/indices/index_manager.py

@@ -0,0 +1,95 @@
+import asyncio
+from typing import (
+    List,
+    Type,
+    Generic,
+    TypeVar,
+    TYPE_CHECKING,
+)
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+    from ._interfaces import IIndexType
+
+from . import observer
+from .. import kind
+
+
+IT = TypeVar("IT", bound="IIndexType")
+
+
+class IndexManager(Generic[IT]):
+    __slots__ = ("_conn", "_idx_type", "_module_id", "_port_id", "_indices", "_lock", "_observer")
+
+    def __init__(self, conn: "itf.IConnection", idx_type: Type[IT], module_id: int, port_id: int) -> None:
+        self._conn = conn
+        self._idx_type = idx_type
+        self._module_id = module_id
+        self._port_id = port_id
+        self._indices: List[IT] = []
+        self._lock = asyncio.Lock()
+        self._observer: "observer.IndicesObserver" = observer.IndicesObserver()
+        self._observer.subscribe(
+            observer.IndexEvents.DEL,
+            self.__remove_from_slot
+        )
+
+    async def server_sync(self) -> None:
+        """Sync the indices with xenaserver"""
+        self._indices.clear()
+        idxs: List[int] = await self._idx_type._fetch(self._conn, self._module_id, self._port_id)
+        for idx_id in idxs:
+            index_kind = kind.IndicesKind(
+                self._module_id,
+                self._port_id,
+                idx_id
+            )
+            idx_instance = self._idx_type(self._conn, index_kind, self._observer)
+            self._indices.append(idx_instance)
+
+    def __str__(self) -> str:
+        return f"Iterable[{self._idx_type.__name__}]({self._indices!s})"
+
+    def __len__(self) -> int:
+        """Return the number of existing indices"""
+        return len(self._indices)
+
+    def __iter__(self):
+        return iter(self._indices)
+
+    def obtain(self, key: int):
+        return self._indices[key]
+
+    def obtain_multiple(self, *keys: int):
+        """Obtain multiple resources as a tuple of indices"""
+        return tuple(self._indices[k] for k in keys)
+
+    def __detect_empty_idx_slot(self) -> int:
+        if len(self._indices) == 0:
+            return 0
+        existing_indices = [i.idx for i in self._indices]
+        empties = [
+            ele
+            for ele in range(max(existing_indices) + 1)
+            if ele not in existing_indices
+        ]
+        return min(empties) if empties else len(existing_indices)
+
+    def __remove_from_slot(self, index_inst: Type) -> None:
+        # throws ValueError if element is not exists in list of indices
+        self._indices.remove(index_inst)
+
+    async def create(self):
+        async with self._lock:
+            index_kind = kind.IndicesKind(
+                self._module_id,
+                self._port_id,
+                self.__detect_empty_idx_slot()
+            )
+            index_inst: IT = await self._idx_type._new(self._conn, index_kind, self._observer)
+            assert index_inst, f"Failed to create Index: {len(self)}"
+            self._indices.append(index_inst)
+            return index_inst
+
+    async def remove(self, position_idx: int) -> None:
+        """Remove an index from the port"""
+        await self._indices[position_idx].delete()

xoa_driver/internals/utils/indices/observer.py

@@ -0,0 +1,17 @@
+from enum import IntEnum, auto
+
+
+class IndexEvents(IntEnum):
+    DEL = auto()
+
+
+class IndicesObserver:
+    def __init__(self) -> None:
+        self.__subscriptions = {}
+
+    def subscribe(self, evt, func) -> None:
+        assert evt not in self.__subscriptions, f"Event <{evt}> is already registered."
+        self.__subscriptions[evt] = func
+
+    def notify(self, evt, index_inst) -> None:
+        self.__subscriptions[evt](index_inst)

xoa_driver/internals/utils/kind.py

@@ -0,0 +1,19 @@
+from typing import NamedTuple
+
+
+class ModuleKind(NamedTuple):
+    """NamedTuple of id's of module."""
+    module_id: int
+
+
+class PortKind(NamedTuple):
+    """NamedTuple of id's of module, port."""
+    module_id: int
+    port_id: int
+
+
+class IndicesKind(NamedTuple):
+    """NamedTuple of id's of module, port, and xindex."""
+    module_id: int
+    port_id: int
+    index_id: int