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

xoa_driver/internals/commands/subtypes.py

@@ -0,0 +1,86 @@
+import ipaddress
+from dataclasses import dataclass
+
+from xoa_driver.internals.core.transporter.protocol.payload import (
+    field,
+    XmpByte,
+    XmpShort,
+    XmpInt,
+    XmpLong,
+    XmpMacAddress,
+    XmpIPv4Address,
+    Hex,
+)
+from .enums import (
+    OnOff,
+    VlanType
+)
+
+
+@dataclass
+class ArpChunk:
+    ipv4_address: ipaddress.IPv4Address
+    """The IP address to match to the Target IP address in the ARP requests"""
+
+    prefix: int
+    """The IP prefix used for address matching."""
+
+    patched_mac: OnOff
+    """If on, the target MAC address will be patched with the part of the IP address that is not masked by the prefix"""
+
+    mac_address: Hex
+    """The target MAC address to return in the ARP reply. If set t to all-zero, the port MAC address will be used."""
+
+
+@dataclass
+class NdpChunk:
+    ipv6_address: ipaddress.IPv6Address
+    """The IP address to match to the Target IP address in the NDP Neighbor Solicitation"""
+
+    prefix: int
+    """The IP prefix used for address matching."""
+
+    patched_mac: OnOff
+    """If on, the target MAC address will be patched with the part of the IP address that is not masked by the prefix"""
+
+    mac_address: Hex
+    """The target MAC address to return in the NDP Neighbor Advertisement. If set t to all-zero, the port MAC address will be used."""
+
+@dataclass
+class DhcpChunk:
+    ipv4_address:       ipaddress.IPv4Address = field(XmpIPv4Address())  # provided IP address by DHCP Server
+    subnet_mask:        ipaddress.IPv4Address = field(XmpIPv4Address())  # provided Subnet mask by DHCP Server
+    braodcast_address:  ipaddress.IPv4Address = field(XmpIPv4Address())  # provided Broadcast address by DHCP Server
+    defaultgw:          ipaddress.IPv4Address = field(XmpIPv4Address())  # provided Default GW by DHCP Server
+    lease_time:         int                   = field(XmpInt())          # provided Lease Time by DHCP Server
+    mac_address:        Hex                   = field(XmpMacAddress())   # The client source mac address that this DHCP request blongs to
+
+@dataclass
+class GroupAddressElem:
+    def __init__(self, ip_address, subnet_mask, mac_address):
+        self.ipv4_address = ip_address
+        self.subnet_mask = subnet_mask
+        self.mac_address = mac_address
+        
+    
+    
+    ipv4_address:   ipaddress.IPv4Address = field(XmpIPv4Address()) # Ip address
+    subnet_mask:    ipaddress.IPv4Address = field(XmpIPv4Address()) # Subne Mask
+    mac_address:    Hex                   = field(XmpMacAddress())  # Mac Address
+
+    
+@dataclass
+class VlanTag:
+    def __init__(self, tci, type):
+        self.tci = tci
+        self.type = type
+    
+    tci: int        =   field(XmpShort())  # 
+    type: VlanType  =   field(XmpByte())  # Subne Mask
+    
+@dataclass
+class QueueStatsElem:
+    rx_bytes:   int = field(XmpLong())  # Total Received Bytes
+    rx_packets: int = field(XmpLong())  # Total Received Packets
+    tx_bytes:   int = field(XmpLong())  # Total Sent Bytes
+    tx_packets: int = field(XmpLong())  # Total Sent Packets

xoa_driver/internals/core/builders.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+from .transporter.protocol.struct_request import Request
+from .transporter.protocol._constants import CommandType
+from .transporter._typings import (
+    ICmdOnlySet,
+    ICmdOnlyGet,
+)
+
+
+def build_set_request(cls: ICmdOnlySet, **kwargs) -> Request:
+    indices = kwargs.pop("indices", [])
+    module = kwargs.pop("module", None)
+    port = kwargs.pop("port", None)
+    req_values = cls.SetDataAttr(**kwargs)
+    return Request(
+        class_name=type(cls).__name__,
+        cmd_type=CommandType.COMMAND_VALUE,
+        cmd_code=cls.code,
+        module_index=module,
+        port_index=port,
+        indices=indices,
+        values=req_values
+    )
+
+
+def build_get_request(cls: ICmdOnlyGet, **kwargs) -> Request:
+    indices = kwargs.pop("indices", [])
+    module = kwargs.pop("module", None)
+    port = kwargs.pop("port", None)
+    req_values = None
+    return Request(
+        class_name=type(cls).__name__,
+        cmd_type=CommandType.COMMAND_QUERY,
+        cmd_code=cls.code,
+        module_index=module,
+        port_index=port,
+        indices=indices,
+        values=req_values
+    )

xoa_driver/internals/core/exceptions.py

@@ -0,0 +1,69 @@
+from .transporter.protocol.exceptions import (
+    XmpStatusException,
+    XmpNoConnectionError,
+    XmpNoLoggedOnError,
+    XmpNotReservedError,
+    XmpNotWritableError,
+    XmpNotReadableError,
+    XmpNotValidError,
+    XmpBadHeaderError,
+    XmpBadCommandError,
+    XmpBadParameterError,
+    XmpBadModuleError,
+    XmpBadPortError,
+    XmpBadIndexError,
+    XmpBadSizeError,
+    XmpBadValueError,
+    XmpFailedError,
+    XmpMemoryFailureError,
+    XmpNoPeLicenseError,
+    XmpNoFreePortLicenseError,
+    XmpNotSupportedError,
+    XmpPendingError,
+    XmpModuleOperationNotSupportedByChassisError,
+    XmpXlsFailedError,
+    XmpXlsDeniedError,
+    XmpXlsInvalidError,
+)
+from .transporter.exceptions import (
+    XoaException,
+    TransporterException,
+    XoaConnectionTimeoutError,
+    XoaConnectionError,
+    RepeatedRequestID,
+    XoaLostFuture
+)
+
+__all__ = (
+    "XmpStatusException",
+    "XmpNoConnectionError",
+    "XmpNoLoggedOnError",
+    "XmpNotReservedError",
+    "XmpNotWritableError",
+    "XmpNotReadableError",
+    "XmpNotValidError",
+    "XmpBadHeaderError",
+    "XmpBadCommandError",
+    "XmpBadParameterError",
+    "XmpBadModuleError",
+    "XmpBadPortError",
+    "XmpBadIndexError",
+    "XmpBadSizeError",
+    "XmpBadValueError",
+    "XmpFailedError",
+    "XmpMemoryFailureError",
+    "XmpNoPeLicenseError",
+    "XmpNoFreePortLicenseError",
+    "XmpNotSupportedError",
+    "XmpPendingError",
+    "XmpModuleOperationNotSupportedByChassisError",
+    "XmpXlsFailedError",
+    "XmpXlsDeniedError",
+    "XmpXlsInvalidError",
+    "XoaException",
+    "TransporterException",
+    "XoaConnectionTimeoutError",
+    "XoaConnectionError",
+    "RepeatedRequestID",
+    "XoaLostFuture",
+)

xoa_driver/internals/core/funcs.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+import asyncio
+from asyncio.events import AbstractEventLoop
+import io
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    AsyncGenerator,
+)
+if TYPE_CHECKING:
+    from .transporter.handler import TransportationHandler
+    from . import interfaces
+
+from .token import Token
+from .transporter import exceptions
+
+
+async def establish_connection(transporter: "TransportationHandler", host: str, port: int = 22606, *, seconds_timeout: int = 5, loop: AbstractEventLoop | None = None) -> None:
+    """
+    Establish connection to provided host and port and assign ``<TransportationHandler>`` to it.
+    """
+    assert isinstance(loop, AbstractEventLoop) or loop is None, "<loop> must be an instance of AbstractEventLoop or None"
+    __loop = loop if loop else asyncio.get_event_loop()
+    try:
+        await asyncio.wait_for(
+            __loop.create_connection(lambda: transporter, host=host, port=port),
+            seconds_timeout
+        )
+    except OSError:
+        raise exceptions.XoaConnectionError(host, port) from None
+    except asyncio.exceptions.TimeoutError:
+        raise exceptions.XoaConnectionTimeoutError(host, port, seconds_timeout) from None
+
+
+async def apply_iter(*cmd_tokens: Token[Any], return_exceptions: bool = False, token_timeout_sec: float | None = 5.0) -> AsyncGenerator[Any, None]:
+    """
+    Main interface for chunking the commands which need to be send to the single tester at the same time.
+    """
+    if not cmd_tokens:
+        return
+    conn: "interfaces.IConnection" = cmd_tokens[0].connection
+    buffer_bytes = io.BytesIO()
+    queue: asyncio.Queue[asyncio.Future] = asyncio.Queue()
+    for t in cmd_tokens:
+        (data, fut) = await t.connection.prepare_data(t.request)
+        buffer_bytes.write(data)
+        queue.put_nowait(fut)
+    conn.send(buffer_bytes.getvalue())
+    buffer_bytes.close()
+    del buffer_bytes
+
+    while not queue.empty():
+        future = await queue.get()
+        try:
+            result_ = await asyncio.wait_for(
+                asyncio.shield(future),
+                token_timeout_sec if return_exceptions else None
+            )
+        except Exception as e:
+            if return_exceptions:
+                yield e
+            else:
+                raise e
+        else:
+            yield result_
+        queue.task_done()
+    await queue.join()
+
+
+async def apply(*cmd_tokens: Token[Any], return_exceptions: bool = False, token_timeout_sec: float | None = 5.0) -> list[Any]:
+    """
+    Main interface for chunking the commands which need to be send to one or multiple testers at the same time.
+    """
+    assert len(cmd_tokens) <= 200, "Number of the commands is bigger then 200 for one aggregation, please use function <apply_iter> instead"
+    return [
+        f async for f in apply_iter(
+            *cmd_tokens, 
+            return_exceptions=return_exceptions, 
+            token_timeout_sec=token_timeout_sec
+        )
+    ]