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

xoa_driver/internals/core/transporter/protocol/struct_header.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import ctypes as c
+from typing import (
+    Type,
+    ClassVar,
+    TypeVar
+)
+from . import _constants as const
+
+
+class ProtocolHeader(c.BigEndianStructure):
+    """The structure for the header data of a packet in the protocol."""
+    __slots__ = (
+        "magic_word",
+        "number_of_indices",
+        "number_of_value_bytes",
+        "command_parameter",
+        "module_index",
+        "port_index",
+        "request_identifier",
+    )
+
+    _fields_ = [
+        ("magic_word", c.c_char * 4),
+        ("number_of_indices", c.c_ushort),
+        ("number_of_value_bytes", c.c_ushort),
+        ("command_parameter", c.c_ushort),
+        ("module_index", c.c_ubyte),
+        ("port_index", c.c_ubyte),
+        ("request_identifier", c.c_uint32),
+    ]
+
+    @property
+    def cmd_type(self) -> int:
+        """Get command type.
+
+        Returns:
+            int: Command type
+        """
+        return (self.command_parameter & 0x0F00) >> 8
+
+    @cmd_type.setter
+    def cmd_type(self, val: int) -> None:
+        """Set command type.
+
+        Args:
+            val (int): Command type
+        """
+        assert 0 <= val < 4
+        self.command_parameter |= val << 8
+
+    @property
+    def cmd_code(self) -> int:
+        """Get command code.
+
+        Returns:
+            int: Command code
+        """
+        last = (self.command_parameter & 0xF000) >> 4
+        first = self.command_parameter & 0x00FF
+        return first | last
+
+    @cmd_code.setter
+    def cmd_code(self, val: int) -> None:
+        """Set command code.
+
+        Args:
+            val (int): Command code
+        """
+        first = (val & 0x0F00) << 4
+        last = val & 0x00FF
+        self.command_parameter |= first | last
+
+    @property
+    def body_size(self) -> int:
+        """Calculate packet body size
+
+        Returns:
+            int: Packet body size
+        """
+        if self.magic_word != const.MAGIC_WORD:
+            return 4
+        body_size = self.number_of_value_bytes + (self.number_of_indices * 4)
+        body_size += (4 - body_size % 4) % 4
+        return body_size
+
+
+Self = TypeVar("Self", bound="ResponseHeader")
+
+
+class ResponseHeader(ProtocolHeader):
+    """The structure for the response header data of a packet in the protocol."""
+    size: ClassVar[int] = c.sizeof(ProtocolHeader)
+
+    @property
+    def is_pushed(self) -> bool:
+        """Check if response is pushed."""
+        return self.request_identifier == 0
+
+    @classmethod
+    def from_bytes(cls: Type[Self], buff: bytes) -> Self | None:
+        """Create ResponseHeader object from bytes."""
+        header_bytes = memoryview(buff)
+        if not cls._header_bytes_is_valid(header_bytes, cls.size, const.MAGIC_WORD):
+            return None
+        return cls.from_buffer_copy(header_bytes)
+
+    @staticmethod
+    def _header_bytes_is_valid(header_bytes: memoryview, expected_size: int, magic_wrd: bytes) -> bool:
+        """Check whether the header bytes are valid.
+
+        Args:
+            header_bytes (memoryview): Header bytes
+            expected_size (int): Expected header size
+            magic_wrd (bytes): Magic word bytes
+
+        Returns:
+            bool: True if the header bytes are valid, False otherwise
+        """
+        is_correct_size = len(header_bytes) == expected_size
+        start_with_mw = header_bytes[:len(magic_wrd)] == magic_wrd
+        return is_correct_size and start_with_mw

xoa_driver/internals/core/transporter/protocol/struct_request.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+import struct
+
+from . import _constants as const
+from . import _utils
+from .struct_header import ProtocolHeader
+from .payload import RequestBodyStruct
+
+NOT_SET_IDENTIFIER = 0
+
+
+class Request:
+    __slots__ = (
+        "class_name",
+        "header",
+        "index_values",
+        "values"
+    )
+
+    def __init__(
+        self,
+        class_name: str,
+        cmd_type: const.CommandType,
+        cmd_code: int,
+        module_index: int | None,
+        port_index: int | None,
+        indices: list[int],
+        values: RequestBodyStruct | None = None,
+    ) -> None:
+        self.class_name = class_name
+        self.header = ProtocolHeader(
+            magic_word=const.MAGIC_WORD,
+            number_of_indices=len(indices),
+            number_of_value_bytes=values.nbytes() if values else 0,
+            cmd_code=cmd_code,
+            cmd_type=cmd_type.value,
+            module_index=const.NOTHING if module_index is None else module_index,
+            port_index=const.NOTHING if port_index is None else port_index,
+            request_identifier=NOT_SET_IDENTIFIER,
+        )
+        self.index_values = indices
+        self.values = values
+
+    def __str__(self) -> str:
+        return _utils.format_str(self)
+
+    def __repr__(self) -> str:
+        return _utils.format_repr(self)
+
+    def __bytes__(self) -> bytes:
+        idx_format = const.indices_format(self.header.number_of_indices)
+        return bytes().join(
+            (
+                self.header,
+                struct.pack(idx_format, *self.index_values),
+                self.values.to_bytes() if self.values else b""
+            )
+        )
+
+    def update_identifier(self, request_id: int) -> None:
+        self.header.request_identifier = request_id
+
+    @property
+    def cmd_code(self) -> int:
+        return self.header.cmd_code

xoa_driver/internals/core/transporter/protocol/struct_response.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+import struct
+from typing import Any
+from . import _constants as const
+from . import _utils
+from .struct_header import ResponseHeader
+from .payload import ResponseBodyStruct
+from .exceptions import get_status_error, XmpStatusException
+
+
+class Response:
+    """
+    Response serializer
+    """
+
+    __slots__ = (
+        "class_name",
+        "header",
+        "index_values",
+        "values",
+        "__buffer",
+    )
+
+    def __init__(self, class_name: str, header: ResponseHeader, buffer: bytes, response_struct: type[ResponseBodyStruct] | None) -> None:
+        self.class_name = class_name
+        self.header = header
+        idces_fmt_ = const.indices_format(header.number_of_indices)
+        idx_count_ = struct.calcsize(idces_fmt_)
+        self.__buffer = memoryview(buffer)
+        self.index_values = self.__parse_indices(idces_fmt_, self.__buffer[:idx_count_])
+        payload_position = slice(idx_count_, idx_count_ + header.number_of_value_bytes)
+        self.values: Any = self.__parse_values(self.__buffer[payload_position], response_struct)
+
+    def __str__(self) -> str:
+        return _utils.format_str(self)
+
+    def __repr__(self) -> str:
+        return _utils.format_repr(self)
+
+    def __bytes__(self) -> bytes:
+        return bytes().join((self.header, self.__buffer))
+
+    def __parse_indices(self, fmt: str, buffer: memoryview) -> list[int]:
+        return list(struct.unpack_from(fmt, buffer, 0))
+
+    def __parse_values(self, buffer: memoryview, struct_type: type[ResponseBodyStruct] | None) -> ResponseBodyStruct | None:
+        if self.header.cmd_type == const.CommandType.COMMAND_VALUE:
+            return struct_type(buffer) if struct_type else None
+        return None
+
+    def get_error(self) -> XmpStatusException | None:
+        if self.is_ok:
+            return None
+        exception = get_status_error(self.command_status)
+        return exception(self.class_name)
+
+    @property
+    def is_pushed(self) -> bool:
+        return self.header.is_pushed
+
+    @property
+    def request_identifier(self) -> int:
+        return self.header.request_identifier
+
+    @property
+    def cmd_code(self) -> int:
+        return self.header.cmd_code
+
+    @property
+    def command_status(self) -> const.CommandStatus | None:
+        if self.header.cmd_type == const.CommandType.COMMAND_STATUS:
+            return const.CommandStatus(self.header.cmd_code)
+        return None
+
+    @property
+    def is_ok(self) -> bool:
+        return self.get_return_ok or self.set_return_ok
+
+    @property
+    def set_return_ok(self) -> bool:
+        is_status_resp = self.header.cmd_type == const.CommandType.COMMAND_STATUS
+        is_succesful = self.header.cmd_code == const.CommandStatus.OK
+        return is_status_resp and is_succesful
+
+    @property
+    def get_return_ok(self) -> bool:
+        is_payload_resp = self.header.cmd_type == const.CommandType.COMMAND_VALUE
+        contain_values = self.values is not None
+        return is_payload_resp and contain_values

xoa_driver/internals/core/transporter/registry.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+from typing import Type
+from ._typings import XoaCommandType
+
+
+class XmpRegistryException(Exception):
+    ...
+
+
+class XmpCmdDuplicatedDefenitionError(XmpRegistryException):
+    def __init__(self, xmc_cls: Type[XoaCommandType]) -> None:
+        self.cmd_type = xmc_cls
+        self.msg = f"The defenition of <{self.cmd_type.__name__}> is duplicated."
+        super().__init__(self.msg)
+
+
+class XmpCmdNotImplemented(XmpRegistryException):
+    def __init__(self, cmd_idx: int) -> None:
+        self.cmd_idx = cmd_idx
+        self.msg = f"The command of the code: [{cmd_idx}], is not implemented or not registered as a XMP command."
+        super().__init__(self.msg)
+
+
+COMMANDS_REGISTRY: dict[int, Type[XoaCommandType]] = dict()
+"""A global registry of which map command id to its class implementation."""
+
+
+def register_command(xmc_cls: Type[XoaCommandType]) -> Type:
+    """A decorator used for register commands descriptors in to global registry"""
+    global COMMANDS_REGISTRY
+    if xmc_cls.code in COMMANDS_REGISTRY:
+        raise XmpCmdDuplicatedDefenitionError(xmc_cls)
+    COMMANDS_REGISTRY[xmc_cls.code] = xmc_cls
+    return xmc_cls
+
+
+def get_command(command_idx: int) -> Type[XoaCommandType]:
+    """Method allows to get a command class by the command code"""
+    global COMMANDS_REGISTRY
+    xmc_type = COMMANDS_REGISTRY.get(command_idx, None)
+    if not xmc_type:
+        raise XmpCmdNotImplemented(command_idx)
+    return xmc_type

xoa_driver/internals/exceptions/__init__.py

@@ -0,0 +1,9 @@
+from .modules import *  # noqa: F403
+from .testers import *  # noqa: F403
+
+
+__all__ = (  # noqa: F405
+    "WrongModuleError",
+    "WrongTesterError",
+    "WrongTesterPasswordError",
+)

xoa_driver/internals/exceptions/modules.py

@@ -0,0 +1,13 @@
+from typing import Set
+
+
+class WrongModuleError(Exception):
+    """Module can not be assign to the current tester"""
+    def __init__(self, module_revision: str, allowed_revisions: Set[str]) -> None:
+        self.module_revision = module_revision
+        self.allowed_revisions = allowed_revisions
+        self.msg = (
+            f"Module of revision <{self.module_revision}> can not be assign to the current tester,\n"
+            f"Permitted only modules of next revisions {allowed_revisions}"
+        )
+        super().__init__(self.msg)

xoa_driver/internals/exceptions/testers.py

@@ -0,0 +1,21 @@
+class WrongTesterError(Exception):
+    """Tester you are trying to connect is of a different type"""
+    def __init__(self) -> None:
+        self.msg = "Tester you are trying to connect is of a different type."
+        super().__init__(self.msg)
+
+
+class WrongTesterPasswordError(Exception):
+    """Cannot create session on the tester because the password is incorrect"""
+    def __init__(self, password: str) -> None:
+        self.password = password
+        self.msg = "Can't create session on the tester because the password is incorrect."
+        super().__init__(self.msg)
+
+
+class UnsupportedFirmwareError(Exception):
+    """Testers firmware version is too old"""
+    def __init__(self, version: float) -> None:
+        self.version = version
+        self.msg = f"Testers firmware version is too old, current: {self.version}. Minimum required: 446.5"
+        super().__init__(self.msg)

xoa_driver/internals/hli_v1/indices/base_index.py

@@ -0,0 +1,39 @@
+import abc
+from typing import (
+    List,
+    TypeVar,
+    Type,
+    TYPE_CHECKING,
+)
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+    from xoa_driver.internals.utils import kind
+    from xoa_driver.internals.utils.indices import observer
+
+
+CT = TypeVar("CT")
+
+
+class BaseIndex(abc.ABC):
+    def __init__(self, conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "observer.IndicesObserver") -> None:
+        self._observer = observer
+        self._conn = conn
+        self.kind = kind
+
+    @property
+    def idx(self) -> int:
+        return self.kind.index_id
+
+    @abc.abstractmethod
+    async def delete(self) -> None:
+        raise NotImplementedError()
+
+    @classmethod
+    @abc.abstractmethod
+    async def _fetch(cls, conn: "itf.IConnection", module_id: int, port_id: int) -> List[int]:
+        raise NotImplementedError()
+
+    @classmethod
+    @abc.abstractmethod
+    async def _new(cls: Type[CT], conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "observer.IndicesObserver") -> CT:
+        raise NotImplementedError()

xoa_driver/internals/hli_v1/indices/connection_group/cg.py

@@ -0,0 +1,186 @@
+from typing import (
+    final,
+    List,
+    Type,
+    TypeVar,
+    TYPE_CHECKING,
+)
+
+from xoa_driver.internals.commands import (
+    P4G_INDICES,
+    P4G_CREATE,
+    P4G_DELETE,
+    P4G_ENABLE,
+    P4G_COMMENT,
+    P4G_CLEAR_COUNTERS,
+    P4G_ROLE,
+    P4G_LP_TIME_SCALE,
+    P4G_LP_SHAPE,
+    P4G_TEST_APPLICATION,
+    P4G_L4_PROTOCOL,
+)
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+    from xoa_driver.internals.utils import kind
+from xoa_driver.internals.utils.indices import observer as idx_obs
+from .tls import GTls
+from .l2 import GL2
+from .raw import GRaw
+from .tcp import GTcp
+from .udp import GUdp
+from .replay import GReplay
+from .l3 import GL3
+from .user_state import GUserState
+from .histogram import GHistogram
+
+from ..base_index import BaseIndex
+
+
+class GCounters:
+    """Connection Group's counters
+    """
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.clear = P4G_CLEAR_COUNTERS(conn, module_id, port_id, group_idx)
+        """Clear the counters
+        
+        :type: P4G_CLEAR_COUNTERS
+        """
+
+
+class GLoadProfile:
+    """Connection Group's load profile.
+    """
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.time_scale = P4G_LP_TIME_SCALE(conn, module_id, port_id, group_idx)
+        """Time scale of the load profile
+        
+        :type: P4G_LP_TIME_SCALE
+        """
+
+        self.shape = P4G_LP_SHAPE(conn, module_id, port_id, group_idx)
+        """Shape of the load profile.
+        
+        :type: P4G_LP_SHAPE
+        """
+
+
+CG = TypeVar("CG")
+
+
+@final
+class ConnectionGroupIdx(BaseIndex):
+    """L47 Connection Group Index Manager"""
+    def __init__(self, conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> None:
+        super().__init__(conn, kind, observer)
+
+        self.comment = P4G_COMMENT(self._conn, *kind)
+        """Description of the connection group
+        
+        :type: P4G_COMMENT
+        """
+
+        self.status = P4G_ENABLE(self._conn, *kind)
+        """Enable/disable/suppress a previously created connection group
+        
+        :type: P4G_ENABLE
+        """
+
+        self.role = P4G_ROLE(self._conn, *kind)
+        """Specifies the client or server role for this Connection Group.
+        
+        :type: P4G_ROLE
+        """
+
+        self.layer4_protocol = P4G_L4_PROTOCOL(self._conn, *kind)
+        """Specifies either TCP or UDP as Layer 4 protocol.
+        
+        :type: P4G_L4_PROTOCOL
+        """
+
+        self.test_application = P4G_TEST_APPLICATION(self._conn, *kind)
+        """Configure the application layer mode.
+        
+        :type: P4G_TEST_APPLICATION
+        """
+
+        self.tls = GTls(self._conn, *kind)
+        """TLS configurations.
+        
+        :type: GTls
+        """
+
+        self.l2 = GL2(self._conn, *kind)
+        """L2 configurations.
+        
+        :type: GL2
+        """
+
+        self.raw = GRaw(self._conn, *kind)
+        """Raw configurations.
+        
+        :type: GRaw
+        """
+
+        self.tcp = GTcp(self._conn, *kind)
+        """TCP configurations.
+        
+        :type: GTcp
+        """
+
+        self.udp = GUdp(self._conn, *kind)
+        """UDP configurations.
+        
+        :type: GUdp
+        """
+
+        self.replay = GReplay(self._conn, *kind)
+        """Replay configurations.
+        
+        :type: GReplay
+        """
+
+        self.l3 = GL3(self._conn, *kind)
+        """L3 configurations.
+        
+        :type: GL3
+        """
+
+        self.user_state = GUserState(self._conn, *kind)
+        """User state configurations.
+        
+        ;type: GUserState
+        """
+
+        self.histogram = GHistogram(self._conn, *kind)
+        """Histogram configurations.
+        
+        :type: GHistogram
+        """
+
+        self.counters = GCounters(self._conn, *kind)
+        """Counters.
+        
+        :type: GCounters
+        """
+
+        self.load_profile = GLoadProfile(self._conn, *kind)
+        """Load Profile configurations.
+        
+        :type: GLoadProfile
+        """
+
+    async def delete(self):
+        """Delete the Connection Group.
+        """
+        await P4G_DELETE(self._conn, *self.kind).set()
+        self._observer.notify(idx_obs.IndexEvents.DEL, self)
+
+    @classmethod
+    async def _fetch(cls, conn: "itf.IConnection", module_id: int, port_id: int) -> List[int]:
+        resp = await P4G_INDICES(conn, module_id, port_id).get()
+        return list(resp.group_identifiers)
+
+    @classmethod
+    async def _new(cls: Type[CG], conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> CG:
+        await P4G_CREATE(conn, *kind).set()
+        return cls(conn, kind, observer)

xoa_driver/internals/hli_v1/indices/connection_group/histogram.py

@@ -0,0 +1,78 @@
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    P4G_TIME_HIST_CONF,
+    P4G_PAYLOAD_HIST_CONF,
+    P4G_TRANSACTION_HIST_CONF,
+    P4G_APP_TRANSACTION_HIST,
+    P4G_RECALC_TIME_HIST,
+    P4G_RECALC_PAYLOAD_HIST,
+    P4G_RECALC_TRANSACTION_HIST,
+)
+
+
+class GConfigHistogram:
+    """L47 Histogram Config"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.time = P4G_TIME_HIST_CONF(conn, module_id, port_id, group_idx)
+        """Sets the start value and the interval size for the time histograms
+        
+        :type: P4G_TIME_HIST_CONF
+        """
+
+        self.payload = P4G_PAYLOAD_HIST_CONF(conn, module_id, port_id, group_idx)
+        """Sets the start value and the interval size for the payload histograms.
+        
+        :type: P4G_PAYLOAD_HIST_CONF
+        """
+
+        self.transaction = P4G_TRANSACTION_HIST_CONF(conn, module_id, port_id, group_idx)
+        """Sets the start value and the interval size for the transaction histogram.
+        
+        :type: P4G_TRANSACTION_HIST_CONF
+        """
+
+
+class GRecalculatesHistogram:
+    """L47 Histogram Recalculation."""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.time = P4G_RECALC_TIME_HIST(conn, module_id, port_id, group_idx)
+        """Recalculates connection time histograms
+        
+        :type: P4G_RECALC_TIME_HIST
+        """
+
+        self.payload = P4G_RECALC_PAYLOAD_HIST(conn, module_id, port_id, group_idx)
+        """Recalculates connection payload histograms
+        
+        :type: P4G_RECALC_PAYLOAD_HIST
+        """
+
+        self.transaction = P4G_RECALC_TRANSACTION_HIST(conn, module_id, port_id, group_idx)
+        """Recalculates transaction histograms
+        
+        :type: P4G_RECALC_TRANSACTION_HIST
+        """
+
+
+class GHistogram:
+    """L47 Histogram."""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.transaction = P4G_APP_TRANSACTION_HIST(conn, module_id, port_id, group_idx)
+        """Returns a histogram over completed request/response transactions per connection.
+        
+        :type: P4G_APP_TRANSACTION_HIST
+        """
+
+        self.recalculates = GRecalculatesHistogram(conn, module_id, port_id, group_idx)
+        """L47 Histogram Recalculation.
+        
+        :type: GRecalculatesHistogram
+        """
+        
+        self.config = GConfigHistogram(conn, module_id, port_id, group_idx)
+        """L47 Histogram Config
+        
+        :type: GConfigHistogram
+        """