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

xoa_driver/internals/hli_v1/ports/port_l47/counters.py

@@ -0,0 +1,174 @@
+from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    P4_ETH_TX_COUNTERS,
+    P4_ETH_RX_COUNTERS,
+    P4_PORT_TX_COUNTERS,
+    P4_PORT_RX_COUNTERS,
+    P4_PORT_COUNTERS,
+    P4_IPV4_RX_COUNTERS,
+    P4_IPV4_TX_COUNTERS,
+    P4_IPV4_COUNTERS,
+    P4_IPV6_RX_COUNTERS,
+    P4_IPV6_TX_COUNTERS,
+    P4_IPV6_COUNTERS,
+    P4_ARP_RX_COUNTERS,
+    P4_ARP_TX_COUNTERS,
+    P4_ARP_COUNTERS,
+    P4_NDP_RX_COUNTERS,
+    P4_NDP_TX_COUNTERS,
+    P4_NDP_COUNTERS,
+    P4_ICMP_RX_COUNTERS,
+    P4_ICMP_TX_COUNTERS,
+    P4_ICMP_COUNTERS,
+    P4_TCP_RX_COUNTERS,
+    P4_TCP_TX_COUNTERS,
+    P4_TCP_COUNTERS,
+    P4_UDP_RX_COUNTERS,
+    P4_UDP_TX_COUNTERS,
+    P4_UDP_COUNTERS,
+    P4_CLEAR_COUNTERS,
+    P4_ETH_COUNTERS,
+)
+
+
+class PCountersIPv4:
+    """IPV4 statistics"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.rx = P4_IPV4_RX_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_IPV4_RX_COUNTERS"""
+        self.tx = P4_IPV4_TX_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_IPV4_TX_COUNTERS"""
+        self.total = P4_IPV4_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_IPV4_COUNTERS"""
+
+
+class PCountersIPv6:
+    """IPV6 statistics"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.rx = P4_IPV6_RX_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_IPV6_RX_COUNTERS"""
+        self.tx = P4_IPV6_TX_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_IPV6_TX_COUNTERS"""
+        self.total = P4_IPV6_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_IPV6_COUNTERS"""
+
+
+class PCountersICMP:
+    """ICMP statistics"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.rx = P4_ICMP_RX_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_ICMP_RX_COUNTERS"""
+        self.tx = P4_ICMP_TX_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_ICMP_TX_COUNTERS"""
+        self.total = P4_ICMP_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_ICMP_COUNTERS"""
+
+
+class PCountersTCP:
+    """ICMP statistics"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.rx = P4_TCP_RX_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_TCP_RX_COUNTERS"""
+        self.tx = P4_TCP_TX_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_TCP_TX_COUNTERS"""
+        self.total = P4_TCP_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_TCP_COUNTERS"""
+
+
+class PCountersUDP:
+    """ICMP statistics"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.rx = P4_UDP_RX_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_UDP_RX_COUNTERS"""
+        self.tx = P4_UDP_TX_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_UDP_TX_COUNTERS"""
+        self.total = P4_UDP_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_UDP_COUNTERS"""
+
+
+class PCountersETH:
+    """ICMP statistics"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.rx = P4_ETH_RX_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_ETH_RX_COUNTERS"""
+        self.tx = P4_ETH_TX_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_ETH_TX_COUNTERS"""
+        self.total = P4_ETH_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_ETH_COUNTERS"""
+
+
+class PCountersARP:
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.rx = P4_ARP_RX_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_ARP_RX_COUNTERS"""
+        self.tx = P4_ARP_TX_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_ARP_TX_COUNTERS"""
+        self.total = P4_ARP_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_ARP_COUNTERS"""
+
+
+class PCountersNDP:
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.rx = P4_NDP_RX_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_NDP_RX_COUNTERS"""
+        self.tx = P4_NDP_TX_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_NDP_TX_COUNTERS"""
+        self.total = P4_NDP_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_NDP_COUNTERS"""
+
+
+class PCounters:
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.clear = P4_CLEAR_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_CLEAR_COUNTERS"""
+        self.total_tx = P4_PORT_TX_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_PORT_TX_COUNTERS"""
+        self.total_rx = P4_PORT_RX_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_PORT_RX_COUNTERS"""
+        self.total = P4_PORT_COUNTERS(conn, module_id, port_id)
+        """
+        :type: P4_PORT_COUNTERS"""
+
+        self.ipv4 = PCountersIPv4(conn, module_id, port_id)
+        """L47 port IPv4 counters."""
+        self.ipv6 = PCountersIPv6(conn, module_id, port_id)
+        """L47 port IPv6 counters."""
+        self.icmp = PCountersICMP(conn, module_id, port_id)
+        """L47 port ICMP counters."""
+        self.tcp = PCountersTCP(conn, module_id, port_id)
+        """L47 port TCP counters."""
+        self.udp = PCountersUDP(conn, module_id, port_id)
+        """L47 port UDP counters."""
+        self.eth = PCountersETH(conn, module_id, port_id)
+        """L47 port Ethernet counters."""
+        self.arp = PCountersARP(conn, module_id, port_id)
+        """L47 port ARP counters."""
+        self.ndp = PCountersNDP(conn, module_id, port_id)
+        """L47 port NDP counters."""

xoa_driver/internals/hli_v1/ports/port_l47/main.py

@@ -0,0 +1,228 @@
+import functools
+from typing import TYPE_CHECKING
+from typing_extensions import Self
+
+from xoa_driver.internals.commands import (
+    P4_TRAFFIC,
+    P4_STATE,
+    P4_CAPABILITIES,
+    P4_STATE_STATUS,
+    P4_VLAN_OFFLOAD,
+    P4_ARP_CONFIG,
+    P4_NDP_CONFIG,
+    P4_CAPTURE,
+    P4_CAPTURE_GET_FIRST,
+    P4_CAPTURE_GET_NEXT,
+    P4_TX_PACKET_SIZE,
+    P4_RX_PACKET_SIZE,
+    P4_TX_MTU,
+    P4_RX_MTU,
+    P4_CLEAR,
+    P4_SPEEDSELECTION,
+    P4_MAX_PACKET_RATE,
+    P4_PCI_INFO,
+    P4_FW_VER,
+    P4_DEV_NAME,
+    P4_PORT_TYPE,
+    P4_LICENSE_INFO,
+    P4_APTITUDES,
+)
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+
+from xoa_driver.internals.hli_v1.ports import base_port
+from xoa_driver.internals.state_storage import ports_state
+from xoa_driver.internals.utils import attributes as utils
+from xoa_driver.internals.utils.indices import index_manager as im
+from xoa_driver.internals.hli_v1.indices.connection_group.cg import ConnectionGroupIdx
+
+from .counters import PCounters
+from .packet_engine import PacketEngine
+
+
+class PCapture:
+    """Packet capture
+    """
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.start = P4_CAPTURE(conn, module_id, port_id)
+        """Control L47 packet capture.
+
+        :type: P4_CAPTURE
+        """
+
+        self.get_first_frame = P4_CAPTURE_GET_FIRST(conn, module_id, port_id)
+        """Get the first captured packet.
+
+        :type: P4_CAPTURE_GET_FIRST
+        """
+
+        self.get_next_frame = P4_CAPTURE_GET_NEXT(conn, module_id, port_id)
+        """Get the next captured packet.
+
+        :type: P4_CAPTURE_GET_NEXT
+        """
+
+
+class PortL47(base_port.BasePort["ports_state.PortL47LocalState"]):
+    """L47 Port"""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        super().__init__(conn, module_id, port_id)
+
+        self._local_states = ports_state.PortL47LocalState()
+
+        self.traffic = P4_TRAFFIC(self._conn, module_id, port_id)
+        """
+        Control L47 traffic.
+
+        :type: P4_TRAFFIC
+        """
+
+        self.clear = P4_CLEAR(self._conn, module_id, port_id)
+        """
+        Clear all the connection groups on the port and set the port state to OFF.
+
+        :type: P4_CLEAR
+        """
+
+        self.state = P4_STATE(self._conn, module_id, port_id)
+        """
+        :type: P4_STATE
+        """
+
+        self.type = P4_PORT_TYPE(self._conn, module_id, port_id)
+        """
+        :type: P4_PORT_TYPE
+        """
+
+        self.aptitudes = P4_APTITUDES(self._conn, module_id, port_id)
+        """
+        :type: P4_APTITUDES
+        """
+
+        self.last_state_status = P4_STATE_STATUS(self._conn, module_id, port_id)
+        """
+        :type: P4_STATE_STATUS
+        """
+
+        self.nic_name = P4_DEV_NAME(self._conn, module_id, port_id)
+        """
+        :type: P4_DEV_NAME
+        """
+
+        self.nic_firmware_version = P4_FW_VER(self._conn, module_id, port_id)
+        """
+        :type: P4_FW_VER
+        """
+
+        self.vlan_offload = P4_VLAN_OFFLOAD(self._conn, module_id, port_id)
+        """
+        :type: P4_VLAN_OFFLOAD
+        """
+
+        self.max_packet_rate = P4_MAX_PACKET_RATE(self._conn, module_id, port_id)
+        """
+        :type: P4_MAX_PACKET_RATE
+        """
+
+        self.capabilities = P4_CAPABILITIES(self._conn, module_id, port_id)
+        """
+        :type: P4_CAPABILITIES
+        """
+
+        self.speed_selection = P4_SPEEDSELECTION(self._conn, module_id, port_id)
+        """
+        :type: P4_SPEEDSELECTION
+        """
+
+        # region Not sure if this commands must be at this level
+        self.tx_packet_size = P4_TX_PACKET_SIZE(self._conn, module_id, port_id)
+        """
+        :type: P4_TX_PACKET_SIZE
+        """
+
+        self.rx_packet_size = P4_RX_PACKET_SIZE(self._conn, module_id, port_id)
+        """
+        :type: P4_RX_PACKET_SIZE
+        """
+
+        self.tx_mtu = P4_TX_MTU(self._conn, module_id, port_id)
+        """
+        :type: P4_TX_MTU
+        """
+
+        self.rx_mtu = P4_RX_MTU(self._conn, module_id, port_id)
+        """
+        :type: P4_RX_MTU
+        """
+        # endregion
+
+        self.pci_info = P4_PCI_INFO(self._conn, module_id, port_id)
+        """
+        :type: P4_PCI_INFO
+        """
+
+        self.license_info = P4_LICENSE_INFO(self._conn, module_id, port_id)
+        """
+        :type: P4_LICENSE_INFO
+        """
+
+        self.arp_config = P4_ARP_CONFIG(self._conn, module_id, port_id)
+        """
+        :type: P4_ARP_CONFIG
+        """
+
+        self.ndp_config = P4_NDP_CONFIG(self._conn, module_id, port_id)
+        """
+        :type: P4_NDP_CONFIG
+        """
+
+        self.capture = PCapture(self._conn, module_id, port_id)
+        """L47 packet capture
+        
+        :type: PCapture
+        """
+
+        self.counters = PCounters(self._conn, module_id, port_id)
+        """L47 counters
+        
+        :type: PCounters
+        """
+
+        self.packet_engine = PacketEngine(self._conn, module_id, port_id)
+        """L47 packet engine.
+        
+        :type: ~xoa_driver.internals.hli_v1.ports.port_l47.packet_engine.PacketEngine
+        """
+
+        self.connection_groups: "im.IndexManager[ConnectionGroupIdx]" = im.IndexManager(
+            self._conn,
+            ConnectionGroupIdx,
+            module_id,
+            port_id
+        )
+        """L47 connection group index manager.
+        
+        :type: IndexManager
+        """
+
+    @property
+    def info(self) -> ports_state.PortL47LocalState:
+        return self._local_states
+
+    async def _setup(self) -> Self:
+        await self._local_states.initiate(self)
+        self._local_states.register_subscriptions(self)
+        return self
+
+    on_capabilities_change = functools.partialmethod(utils.on_event, P4_CAPABILITIES)
+    """Register a callback to the event that the L47 port's capabilities change."""
+
+    on_speed_selection_change = functools.partialmethod(utils.on_event, P4_SPEEDSELECTION)
+    """Register a callback to the event that the L47 port's speed mode changes."""
+
+    on_state_change = functools.partialmethod(utils.on_event, P4_STATE)
+    """Register a callback to the event that the L47 port's state changes."""
+    
+    on_license_info_change = functools.partialmethod(utils.on_event, P4_LICENSE_INFO)
+    """Register a callback to the event that the L47 port's license information changes."""

xoa_driver/internals/hli_v1/ports/port_l47/packet_engine.py

@@ -0,0 +1,31 @@
+from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    P4E_ASSIGN,
+    P4E_AVAILABLE,
+    P4E_ALLOCATE,
+    P4E_ALLOCATION_INFO,
+)
+
+
+class PacketEngine:
+    """L47 port's packet engine."""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.assign = P4E_ASSIGN(conn, module_id, port_id)
+        """
+        :type: P4E_ASSIGN
+        """
+
+        self.available = P4E_AVAILABLE(conn, module_id, port_id)
+        """
+        :type: P4E_AVAILABLE
+        """
+
+        self.allocate = P4E_ALLOCATE(conn, module_id, port_id)
+        """
+        :type: P4E_ALLOCATE
+        """
+
+        self.allocation_info = P4E_ALLOCATION_INFO(conn, module_id, port_id)
+        """
+        :type: P4E_ALLOCATION_INFO
+        """

xoa_driver/internals/hli_v1/revisions.py

@@ -0,0 +1,11 @@
+from functools import partial
+from xoa_driver.internals.utils.rev_tool import RegisterModule
+
+VALKYRIE_MODULES = {}
+CHIMERA_MODULES = {}
+VULCAN_MODULES = {}
+
+
+register_valkyrie_module = partial(RegisterModule, modules_store=VALKYRIE_MODULES)
+register_chimera_module = partial(RegisterModule, modules_store=CHIMERA_MODULES)
+register_vulcan_module = partial(RegisterModule, modules_store=VULCAN_MODULES)

xoa_driver/internals/hli_v1/testers/_base_tester.py

@@ -0,0 +1,259 @@
+from __future__ import annotations
+from typing import (
+    TypeVar,
+    Awaitable,
+    Generic,
+    Callable,
+    Generator,
+    Any
+)
+from abc import (
+    ABC,
+    abstractmethod,
+)
+import functools
+from xoa_driver.internals.commands import enums
+from xoa_driver.internals.commands import (
+    C_RESERVATION,
+    C_DOWN,
+    C_PASSWORD,
+    C_TIME,
+    C_CAPABILITIES,
+    C_DEBUGLOGS,
+    C_NAME,
+    C_MODEL,
+    C_COMMENT,
+    C_VERSIONNO,
+    C_SERIALNO,
+    C_RESERVEDBY,
+    C_FLASH,
+    C_MODEL_NAME,
+    C_MODEL_NUMBER,
+)
+from xoa_driver.internals.core.funcs import establish_connection
+from xoa_driver.internals.core.transporter.handler import TransportationHandler
+from xoa_driver.internals.core.transporter.logger import CustomLogger
+from xoa_driver.internals.utils import session
+from xoa_driver.internals.state_storage import testers_state
+
+
+T = TypeVar('T', bound="BaseTester")
+TesterStateStorage = TypeVar('TesterStateStorage', bound="testers_state.TesterLocalState")
+
+
+# min version = 83.2
+class BaseTester(ABC, Generic[TesterStateStorage]):
+    """
+    Basic Tester class.
+
+    :param host: tester's address/hostname
+    :type host: str
+    :param username: username of the user
+    :type username: str
+    :param password: login password of the tester, defaults to "xena"
+    :type password: str, optional
+    :param port: the port number for connection establishment, default to 22606
+    :type port: int, optional
+    :param enable_logging: `True` if debug log output from the tester is needed, and `False` otherwise
+    :type enable_logging: bool
+    :param custom_logger: `None` allow to specify logger with custom configurations
+    :type enable_logging: CustomLogger | None
+    :param session_timeout: `130` Session timeout in seconds
+    :type session_timeout: int
+    """
+
+    def __init__(self, host: str, username: str, password: str = "xena", port: int = 22606, *, enable_logging: bool = False, custom_logger: CustomLogger | None = None, session_timeout: int = 130) -> None:
+        self.__host = host
+        self.__port = port
+        self._conn = TransportationHandler(
+            enable_logging=enable_logging,
+            custom_logger=custom_logger
+        )
+        self.session = session.TesterSession(
+            self._conn,
+            username,
+            password=password,
+            timeout_seconds=session_timeout,
+            keepalive=True,
+        )
+        """
+        Current management session
+
+        :type: TesterSession
+        """
+
+        self.name = C_NAME(self._conn)
+        """
+        Get and set the name of the tester
+
+        :type: C_NAME
+        """
+
+        self.comment = C_COMMENT(self._conn)
+        """Description of the tester.
+
+        :type: C_COMMENT
+        """
+
+        self.model = C_MODEL(self._conn)
+        """Specifies tester's model.
+
+        :type: C_MODEL
+        """
+
+        self.model_name = C_MODEL_NAME(self._conn)
+        """Specifies tester's model name.
+
+        :type: C_MODEL_NAME
+        """
+
+        self.model_number = C_MODEL_NUMBER(self._conn)
+        """Specifies tester's model number.
+
+        :type: C_MODEL_NUMBER
+        """
+
+        self.version_no = C_VERSIONNO(self._conn)
+        """Tester's version number.
+
+        :type: C_VERSIONNO
+        """
+
+        self.serial_no = C_SERIALNO(self._conn)
+        """Tester's serial number.
+
+        :type: C_SERIALNO
+        """
+
+        self.reservation = C_RESERVATION(self._conn)
+        """Tester's reservation operation.
+
+        :type: C_RESERVATION
+        """
+
+        self.reserved_by = C_RESERVEDBY(self._conn)
+        """Tester's reservation status.
+
+        :type: C_RESERVEDBY
+        """
+
+        self.down = C_DOWN(self._conn)
+        """Shutdown/reboot the tester.
+
+        :type: C_DOWN
+        """
+
+        self.password = C_PASSWORD(self._conn)
+        """Specifies tester's password.
+
+        :type: C_PASSWORD
+        """
+
+        self.time = C_TIME(self._conn)
+        """Tester's time in seconds.
+
+        :type: C_TIME
+        """
+
+        self.capabilities = C_CAPABILITIES(self._conn)
+        """Tester's capabilities.
+
+        :type: C_CAPABILITIES
+        """
+
+        self.debug_log = C_DEBUGLOGS(self._conn)
+        """Tester's debug log.
+
+        :type: C_DEBUGLOGS
+        """
+
+        self.flash = C_FLASH(self._conn)
+        """Specifies tester's flash LEDs status.
+
+        :type: C_FLASH
+        """
+
+    async def __aenter__(self: Awaitable[T]) -> T:
+        return await self
+
+    async def __aexit__(self, type, value, traceback) -> None:
+        await self.session.logoff()
+
+    def __await__(self: T) -> Generator[Any, None, T]:
+        if self.session.is_online:
+            async def skip():
+                return self
+            return skip().__await__()
+        return self._setup().__await__()
+
+    async def _setup(self: T) -> T:
+        await establish_connection(self._conn, self.__host, self.__port)
+        await self.session.logon()
+        return self
+
+    def __is_reservation(self, reserved_status: enums.ReservedStatus) -> bool:
+        return self.info.reservation == reserved_status
+
+    is_released = functools.partialmethod(__is_reservation, enums.ReservedStatus.RELEASED)
+    """Validate if the tester is released.
+
+    :return: whether the tester is released.
+    :rtype: bool
+    """
+
+    is_reserved_by_me = functools.partialmethod(__is_reservation, enums.ReservedStatus.RESERVED_BY_YOU)
+    """Validate if the tester is reserved by your connection under the username used when logging in.
+
+    :return: whether the tester is reserved by your connection under the username used when logging in.
+    :rtype: bool
+    """
+
+    @property
+    @abstractmethod
+    def info(self) -> TesterStateStorage:
+        """
+        Tester's local information.
+
+        :type: TesterStateStorage
+        """
+
+        raise NotImplementedError()
+
+    # region Events
+
+    # We are not supporting Subscription on Connection made, coz Connection is happens at Awaiting of instance
+    # but subscription only registered after instance is already created, means already connected,
+    # means On_connected event will never b called, it's can be tweaked, but then Creating process of tester instance
+    # will be less intuitive, and in one case subscription will work while in another not.
+
+    def on_disconnected(self, callback: "Callable") -> None:
+        """
+        Register a callback function that will be called at the time when connection will be closed.
+
+        :param callback: the callback function that can be called when the event happens.
+        :type callback: Callable
+        """
+
+        self._conn.on_disconnected(callback)
+
+    def on_reservation_change(self, callback: "Callable") -> None:
+        """
+        Register an callback function that will be called when tester's reservation status is changed.
+
+        :param callback: the callback function that can be called when the event happens.
+        :type callback: Callable
+        """
+
+        self._conn.subscribe(C_RESERVATION, callback)
+
+    def on_reserved_by_change(self, callback: "Callable") -> None:
+        """
+        Register an callback function that will be called when tester's owner is changed.
+
+        :param callback: the callback function that can be called when the event happens.
+        :type callback: Callable
+        """
+
+        self._conn.subscribe(C_RESERVEDBY, callback)
+
+    # endregion