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

xoa_driver/internals/utils/managers/abc.py

@@ -0,0 +1,44 @@
+from abc import (
+    ABC,
+    abstractmethod
+)
+from typing import (
+    Generic,
+    TypeVar,
+    Tuple,
+)
+from collections import OrderedDict
+
+
+T = TypeVar("T")
+
+
+class AbcResourcesManager(ABC, Generic[T]):
+    """Resource Base Manager
+    """
+    __slots__ = ("_items", "_lock", )
+
+    def __init__(self) -> None:
+        self._items: OrderedDict[int, T] = OrderedDict()
+        self._lock: bool = False
+
+    def __len__(self) -> int:
+        return len(self._items)
+
+    def __iter__(self):
+        return iter(self._items.values())
+
+    def obtain(self, key: int) -> T:
+        """Obtain a single resource.
+        """
+        return self._items[key]
+
+    def obtain_multiple(self, *keys: int) -> Tuple[T, ...]:
+        """Obtain multiple resources as a tuple of resources.
+        """
+        return tuple(self._items[k] for k in keys)
+
+    @abstractmethod
+    async def fill(self, *args, **kwargs) -> None:
+        """Method for create and fill in."""
+        raise NotImplementedError()

xoa_driver/internals/utils/managers/exceptions.py

@@ -0,0 +1,22 @@
+class XoaResourceError(Exception):
+    ...
+
+
+class WrongTesterError(XoaResourceError):
+    def __init__(self) -> None:
+        self.msg = "Connected tester is of the wrong type!"
+        super().__init__(self.msg)
+
+
+class NoSuchModuleError(XoaResourceError):
+    def __init__(self, module_id: int) -> None:
+        self.module_id = module_id
+        self.msg = f"No such module {module_id}!"
+        super().__init__(self.msg)
+
+
+class NoSuchPortError(XoaResourceError):
+    def __init__(self, port_id: int) -> None:
+        self.port_id = port_id
+        self.msg = f"No such port {port_id}!"
+        super().__init__(self.msg)

xoa_driver/internals/utils/managers/modules_manager.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+import asyncio
+import functools
+from typing import (
+    TYPE_CHECKING,
+    Awaitable,
+    Iterable,
+    NamedTuple,
+    Type,
+    TypeVar,
+    Callable,
+    Union,
+    cast,
+)
+from collections import OrderedDict
+
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    M_REVISION,
+    M_MODEL,
+    M_VERSIONSTR,
+)
+from .abc import AbcResourcesManager
+from .exceptions import (
+    NoSuchModuleError,
+    WrongTesterError
+)
+
+# region Module Init dataset
+
+
+class ModuleData(NamedTuple):
+    """Base module data."""
+    module_id: int
+    ports_count: int
+    revision: str
+
+
+class L23ModuleData(ModuleData):
+    """L23 module data"""
+    @classmethod
+    async def create(cls, conn, mid: int, p_cnt: int) -> "L23ModuleData":
+        """Return the module name of the L23 module."""
+        r = await M_REVISION(conn, mid).get()
+        return cls(
+            module_id=mid,
+            ports_count=p_cnt,
+            revision=r.revision
+        )
+
+
+class L47ModuleData(ModuleData):
+    """L47 module data"""
+    @classmethod
+    async def create(cls, conn, mid: int, p_cnt: int) -> "L47ModuleData":
+        """Return the module name of the L47 module."""
+        r = await M_MODEL(conn, mid).get()
+        return cls(
+            module_id=mid,
+            ports_count=p_cnt,
+            revision=r.model
+        )
+
+# endregion
+
+
+MT = TypeVar("MT")
+MTypeObtainer = Callable[[str], Type]
+ModuleDataType = Union[Type["L23ModuleData"], Type["L47ModuleData"]]
+
+
+class ModulesManager(AbcResourcesManager[MT]):
+    """Modules Manager"""
+
+    __slots__ = ("_conn", "__m_types_obtainer")
+
+    def __init__(self, conn: "itf.IConnection", m_types_obtainer: MTypeObtainer) -> None:
+        super().__init__()
+        self._conn = conn
+        self.__m_types_obtainer = m_types_obtainer
+
+    def obtain(self, key: int) -> MT:
+        try:
+            return super().obtain(key)
+        except KeyError:
+            raise NoSuchModuleError(key)
+
+    def obtain_multiple(self, *keys: int) -> tuple[MT, ...]:
+        try:
+            return super().obtain_multiple(*keys)
+        except KeyError as err:
+            raise NoSuchModuleError(err.args[0])
+
+    async def fill(self, ports_count: list[int], module_type: ModuleDataType) -> None:
+        """Method for create and fill in."""
+        assert not self._lock, "Method <fill> can be called only once."
+        module_builder = (
+            module_type.create(self._conn, slot_id, p_count)
+            for slot_id, p_count in enumerate(ports_count)
+            if p_count > 0
+        )
+        identities: Iterable[ModuleData] = await asyncio.gather(*module_builder)
+
+        self._items = OrderedDict(
+            (
+                idnt.module_id,
+                self.__m_types_obtainer(idnt.revision)(self._conn, idnt)
+            )
+            for idnt in identities
+        )
+        if len(self) == 0:
+            raise WrongTesterError()
+        coros = cast(Iterable[Awaitable], self._items.values())
+        await asyncio.gather(*coros)
+
+    fill_l23 = functools.partialmethod(fill, module_type=L23ModuleData)
+    fill_l47 = functools.partialmethod(fill, module_type=L47ModuleData)

xoa_driver/internals/utils/managers/ports_manager.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+import asyncio
+from typing import (
+    Awaitable,
+    Iterable,
+    Type,
+    TypeVar,
+    Protocol,
+    TYPE_CHECKING,
+    cast,
+)
+from collections import OrderedDict
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+
+from .abc import AbcResourcesManager
+from .exceptions import NoSuchPortError
+from ..con_traffic_light import ConnectionTrafficLight
+
+
+class IPort(Protocol):
+    _conn: "itf.IConnection"
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        ...
+
+
+PT = TypeVar("PT", bound=IPort)
+
+
+class PortBaseManager(AbcResourcesManager[PT]):
+    def obtain(self, key: int) -> PT:
+        try:
+            return super().obtain(key)
+        except KeyError:
+            raise NoSuchPortError(key)
+
+    def obtain_multiple(self, *keys: int) -> tuple[PT, ...]:
+        try:
+            return super().obtain_multiple(*keys)
+        except KeyError as err:
+            raise NoSuchPortError(err.args[0])
+
+
+class PortsManager(PortBaseManager[PT]):
+
+    __slots__ = ("_conn", "_ports_type", "_ports_count", "_module_id", )
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, ports_type: Type[PT], ports_count: int) -> None:
+        super().__init__()
+        self._conn = conn
+        self._ports_type = ports_type
+        self._module_id = module_id
+        self._items: OrderedDict[int, PT] = OrderedDict()
+        self._ports_count = 0
+        self.reinit(ports_count)
+
+    def reinit(self, ports_count: int) -> bool:
+        if ports_count == self._ports_count:
+            return False
+        
+        if self._items:
+            for v in self._items.values():
+                v._conn.set_outdated()
+        del self._items
+        self._items: OrderedDict[int, PT] = OrderedDict(
+            (
+                port_id,
+                self._ports_type(
+                    conn=ConnectionTrafficLight(self._conn),
+                    module_id=self._module_id,
+                    port_id=port_id,
+                )
+            )
+            for port_id in range(ports_count)
+        )
+        self._ports_count = ports_count
+        return True
+
+    async def fill(self) -> None:
+        assert not self._lock, "Method <fill> can be called only once."
+        coros = cast(Iterable[Awaitable], self._items.values())
+        await asyncio.gather(*coros)
+
+
+class PortResolver(Protocol):
+    async def __call__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> Type:
+        ...
+
+
+class PortsCombiManager(PortBaseManager[PT]):
+
+    __slots__ = ("_conn", "_resolver", "_ports_count", "_module_id",)
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, resolver: PortResolver, ports_count: int) -> None:
+        super().__init__()
+        self._conn = conn
+        self._resolver = resolver
+        self._ports_count = ports_count
+        self._module_id = module_id
+        self._items: OrderedDict[int, PT] = OrderedDict()
+
+    async def fill(self) -> None:
+        assert not self._lock, "Method <fill> can be called only once."
+        coros = iter(
+            self._resolver(
+                conn=ConnectionTrafficLight(self._conn),
+                module_id=self._module_id,
+                port_id=port_id,
+            )
+            for port_id in range(self._ports_count)
+        )
+        ports = await asyncio.gather(*coros)
+        self._items = OrderedDict(
+            (port.kind.port_id, port) for port in ports
+        )

xoa_driver/internals/utils/rev_tool.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+from typing import (
+    Type,
+    TypeVar
+)
+
+T = TypeVar("T")
+
+
+class RegisterModule:
+    """Register revision and it's module class"""
+
+    def __init__(self, modules_store: dict[str, Type], rev: str) -> None:
+        self.modules_store = modules_store
+        self.revision = rev
+
+    def __call__(self, module_type: Type[T]) -> Type[T]:
+        if self.revision in self.modules_store:
+            raise RuntimeError(f"Module of revision: {self.revision}, is already registered.")
+        self.modules_store[self.revision] = module_type
+        return module_type

xoa_driver/internals/utils/session.py

@@ -0,0 +1,117 @@
+import asyncio
+from contextlib import suppress
+from typing import (
+    TYPE_CHECKING,
+    Tuple
+)
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.core import funcs
+from xoa_driver.internals.core.exceptions import XmpBadValueError
+from xoa_driver.internals import exceptions
+from xoa_driver.internals.commands import (
+    C_LOGON,
+    C_LOGOFF,
+    C_OWNER,
+    C_TIMEOUT,
+    C_KEEPALIVE,
+    C_INDICES,
+    C_STATSESSION,
+)
+
+
+class TesterSession:
+    """
+    Establishing communication session through connection with the tester.
+
+    :param conn: connection handler
+    :type host: itf.IConnection
+    :param owner_name: username of the user
+    :type username: str
+    :param password: login password of the tester, defaults to "xena"
+    :type password: str, optional
+    :param timeout_seconds: the timeout to close idle connection
+    :type port: int, optional
+    :param keepalive: `True` if keepalive signal is needed, and `False` otherwise, defaults to `False`.
+    :type keepalive: bool, optional
+    """
+
+    __slots__ = ("_conn", "owner_name", "pwd", "timeout", "keepalive")
+
+    def __init__(self, conn: "itf.IConnection", owner_name: str, password: str = "xena", timeout_seconds: int = 130, keepalive: bool = False) -> None:
+        self._conn = conn
+        self.owner_name = owner_name
+        self.pwd = password
+        self.timeout = timeout_seconds
+        self.keepalive = keepalive
+
+    async def logon(self) -> "TesterSession":
+        logon, *_ = await funcs.apply(
+            C_LOGON(self._conn).set(self.pwd),
+            C_OWNER(self._conn).set(self.owner_name),
+            C_TIMEOUT(self._conn).set(self.timeout),
+            return_exceptions=True,
+            token_timeout_sec=1.0
+        )
+        if isinstance(logon, XmpBadValueError):
+            raise exceptions.WrongTesterPasswordError(self.pwd) from None
+
+        if self.keepalive:
+            asyncio.create_task(self.__do_keepalive(), name="keepalive").add_done_callback(
+                self.__handle_exceptions
+            )
+        return self
+
+    async def chang_timeout(self, seconds: int = 130) -> None:
+        """Modify session timeout, """
+        if not self.is_online:
+            raise RuntimeError("Timeout can be changet only after connection is established.")
+        self.timeout = seconds
+        await C_TIMEOUT(self._conn).set(self.timeout)
+
+    def __handle_exceptions(self, fut: asyncio.Future) -> None:
+        if fut.cancelled():
+            return None
+        elif e := fut.exception():
+            raise e
+
+    async def __do_keepalive(self) -> None:
+        while self._conn.is_connected:
+            with suppress(Exception):
+                await C_KEEPALIVE(self._conn).get()
+            await asyncio.sleep(max(0, self.timeout - 5))
+
+    @property
+    def is_online(self) -> bool:
+        """
+        Check if connection is still active.
+
+        :return: connection is still on or not.
+        :rtype: bool
+        """
+
+        return self._conn.is_connected
+
+    async def logoff(self) -> None:
+        """
+        Gracefully log off from the tester.
+        """
+
+        await C_LOGOFF(self._conn).set()
+        self._conn.close()
+
+    async def sessions_info(self) -> Tuple[C_STATSESSION.GetDataAttr, ...]:
+        """
+        Return information about all active sessions on the tester.
+
+        :return: a list of session information
+        :rtype: List[C_STATSESSION]
+        """
+
+        sessions = await C_INDICES(self._conn).get()
+        session_ids = sessions.session_ids
+        query_sessions = (
+            C_STATSESSION(self._conn, _session_xindex=sid).get()
+            for sid in session_ids
+        )
+        return tuple(await funcs.apply(*query_sessions))

xoa_driver/internals/warn.py

@@ -0,0 +1,32 @@
+import warnings
+from functools import partial
+
+__all__ = (
+    "depricated",
+    "resource"
+)
+
+
+class XoaResourceWarning(ResourceWarning):
+    ...
+
+
+class XoaDeprecationWarning(DeprecationWarning):
+    ...
+
+
+warnings.simplefilter('always', XoaResourceWarning)
+warnings.simplefilter('always', XoaDeprecationWarning)
+
+
+def formatter(message, category, filename, lineno, *_) -> str:
+    if category is XoaDeprecationWarning:
+        return f"\n\33[101m{category.__name__}\33[0m: {message}\n\n"
+    return f"\n\33[103m{category.__name__}\33[0m: {message}\n\n"
+
+
+warnings.formatwarning = formatter
+
+
+depricated = partial(warnings.warn, category=XoaDeprecationWarning)
+resource = partial(warnings.warn, category=XoaResourceWarning)

xoa_driver/lli.py

@@ -0,0 +1,15 @@
+#: Low-Level interface
+
+
+from xoa_driver.internals import commands
+from xoa_driver.internals.core.transporter.registry import get_command
+from xoa_driver.internals.core.transporter.handler import TransportationHandler
+from xoa_driver.internals.core.funcs import establish_connection
+
+
+__all__ = (
+    "commands",
+    "get_command",
+    "TransportationHandler",
+    "establish_connection"
+)

xoa_driver/misc.py

@@ -0,0 +1,57 @@
+#: Other types which are used by ports or as a parameter to attribute set method.
+
+
+from .internals.core.token import Token
+from .internals.core.transporter.protocol.payload.types import Hex
+from .internals.commands.subtypes import (
+    ArpChunk,
+    NdpChunk,
+    DhcpChunk,
+    GroupAddressElem,
+    VlanTag,
+    QueueStatsElem,
+)
+
+import sys
+
+if "xoa_driver.v2" in sys.modules:
+    raise ImportError("\33[31mOnly Single interface version is allowed to being use at the same time.\33[0m")
+
+# indices types
+from .internals.hli_v1.indices.connection_group.cg import ConnectionGroupIdx as ConnectionGroup
+from .internals.hli_v1.indices.filter.base_filter import BaseFilterIdx as BasePortFilter
+from .internals.hli_v1.indices.filter.genuine_filter import GenuineFilterIdx as GenuinePortFilter
+from .internals.hli_v1.indices.length_term import LengthTermIdx as LengthTerm
+from .internals.hli_v1.indices.match_term import MatchTermIdx as MatchTerm
+from .internals.hli_v1.indices.port_dataset import PortDatasetIdx as PortDataset
+from .internals.hli_v1.indices.streams.base_stream import BaseStreamIdx as BaseStream
+from .internals.hli_v1.indices.streams.genuine_stream import GenuineStreamIdx as GenuineStream
+from .internals.hli_v1.ports.port_l23.chimera.port_emulation import CFlow as ImpairmentFlow
+from .internals.hli_v1.ports.port_l23.chimera.filter_definition.general import ModeBasic as BasicImpairmentFlowFilter
+from .internals.hli_v1.ports.port_l23.chimera.filter_definition.general import ModeExtended as ExtendedImpairmentFlowFilter
+from xoa_driver.internals.hli_v1.indices.macsecscs.genuine_macsecsc import GenuineMacSecTxScIdx, GenuineMacSecRxScIdx
+
+
+__all__ = (
+    "Token",
+    "Hex",
+    "ArpChunk",
+    "NdpChunk",
+    "DhcpChunk",
+    "GroupAddressElem",
+    "VlanTag",
+    "QueueStatsElem",
+    "ConnectionGroup",
+    "BasePortFilter",
+    "GenuinePortFilter",
+    "LengthTerm",
+    "MatchTerm",
+    "PortDataset",
+    "BaseStream",
+    "GenuineStream",
+    "ImpairmentFlow",
+    "BasicImpairmentFlowFilter",
+    "ExtendedImpairmentFlowFilter",
+    "GenuineMacSecTxScIdx",
+    "GenuineMacSecRxScIdx",
+)