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

xoa_driver/internals/hli_v2/testers/genuine/management_interface.py

@@ -0,0 +1,38 @@
+from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    C_IPADDRESS,
+    C_DHCP,
+    C_MACADDRESS,
+    C_HOSTNAME,
+)
+
+
+class ManagementInterface:
+    """
+    Tester management interface address configuration.
+    """
+
+    def __init__(self, conn: "itf.IConnection") -> None:
+        self.ip_address = C_IPADDRESS(conn)
+        """
+        Chassis management port IP address configuration.
+        Representation of C_IPADDRESS
+        """
+
+        self.dhcp = C_DHCP(conn)
+        """
+        Chassis management port IP address configuration with DHCP.
+        Representation of C_DHCP
+        """
+
+        self.macaddress = C_MACADDRESS(conn)
+        """
+        Chassis management port MAC address.
+        Representation of C_MACADDRESS
+        """
+
+        self.hostname = C_HOSTNAME(conn)
+        """
+        Chassis management hostname.
+        Representation of C_HOSTNAME
+        """

xoa_driver/internals/hli_v2/testers/l23_tester.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+from typing import (
+    Union,
+    TYPE_CHECKING,
+    Type,
+)
+from xoa_driver.internals.commands import (
+    C_PORTCOUNTS,
+    C_MULTIUSER,
+    C_TRAFFIC,
+    C_TRAFFICSYNC,
+    C_VERSIONNO_MINOR,
+    C_BUILDSTRING,
+    C_VERSIONSTR,
+)
+from xoa_driver.internals.core.transporter.logger import CustomLogger
+from xoa_driver.internals.utils.managers.modules_manager import ModulesManager
+from ._base_tester import BaseTester
+from .genuine import management_interface as mi
+from .genuine.l_23 import (
+    upload_file,
+    time_keeper,
+    rest_api,
+    health,
+)
+if TYPE_CHECKING:
+    from xoa_driver.v2 import modules
+
+from xoa_driver.internals.state_storage import testers_state
+from xoa_driver.internals.hli_v2 import revisions
+from xoa_driver.internals import exceptions
+
+
+TypeL23Manager = ModulesManager[
+    Union[
+        "modules.GenericL23Module",
+        "modules.ModuleChimera",
+    ]
+]
+
+
+def get_module_type(revision: str) -> Type:
+    module_type = dict(
+        **revisions.VALKYRIE_MODULES,
+        **revisions.CHIMERA_MODULES,
+    ).get(revision)
+    if not module_type:
+        raise exceptions.WrongModuleError(
+            revision,
+            set.union(
+                set(revisions.VALKYRIE_MODULES.keys()),
+                set(revisions.CHIMERA_MODULES.keys()),
+            )
+        )
+    return module_type
+
+
+class L23Tester(BaseTester["testers_state.GenuineTesterLocalState"]):
+    """
+    This is a conceptual class of Xena Valkyrie Tester.
+    It is essentially an extended :class:`BaseTester`.
+
+
+    :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:
+        super().__init__(
+            host=host,
+            username=username,
+            password=password,
+            port=port,
+            enable_logging=enable_logging,
+            custom_logger=custom_logger,
+            session_timeout=session_timeout
+        )
+
+        self._local_states = testers_state.GenuineTesterLocalState(host, port)
+
+        self.management_interface = mi.ManagementInterface(self._conn)
+        """Tester management interface that includes IP address, DHCP, MAC address and hostname.
+        """
+
+        self.upload_file = upload_file.UploadFile(self._conn)
+        """File upload functions of the tester.
+        """
+
+        self.rest_api_server = rest_api.RestApiServer(self._conn)
+        """REST API server of the tester.
+        """
+
+        self.time_keeper = time_keeper.TimeKeeper(self._conn)
+        """TimeKeeper of the tester.
+        """
+
+        self.multiuser = C_MULTIUSER(self._conn)
+        """
+        Representation of C_MULTIUSER
+        """
+
+        self.traffic = C_TRAFFIC(self._conn)
+        """
+        Representation of C_TRAFFIC
+        """
+        self.traffic_sync = C_TRAFFICSYNC(self._conn)
+        """
+        Representation of C_TRAFFICSYNC
+        """
+        self.version_no_minor = C_VERSIONNO_MINOR(self._conn)
+        """
+        Representation of C_VERSIONNO_MINOR
+        """
+        self.version_str = C_VERSIONSTR(self._conn)
+        """
+        Returns xenaserver version number in the new format.
+
+        :type: C_VERSIONSTR
+        """
+        self.build_string = C_BUILDSTRING(self._conn)
+        """
+        Representation of C_BUILDSTRING
+        """
+        self.health = health.Health(self._conn)
+        """
+        Chassis system health information.
+
+        :type: C_HEALTH
+        """
+        self.modules: TypeL23Manager = ModulesManager(self._conn, get_module_type)
+        """
+        Module index manager of the L23 tester.
+        """
+
+    @property
+    def info(self) -> testers_state.GenuineTesterLocalState:
+        return self._local_states
+
+    async def _setup(self):
+        await super()._setup()
+        await self._local_states.initiate(self)
+        self._local_states.register_subscriptions(self)
+
+        ft_pc = await C_PORTCOUNTS(self._conn).get()
+        port_counts = ft_pc.port_counts
+        await self.modules.fill_l23(port_counts)
+        return self

xoa_driver/internals/hli_v2/testers/l23ve_tester.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+from typing import Type
+from xoa_driver.internals.commands import (
+    C_PORTCOUNTS,
+    C_MULTIUSER,
+    C_TRAFFIC,
+    C_TRAFFICSYNC,
+    C_VERSIONNO_MINOR,
+)
+from xoa_driver.internals.core.transporter.logger import CustomLogger
+from xoa_driver.internals.utils.managers.modules_manager import ModulesManager
+from ._base_tester import BaseTester
+
+
+from xoa_driver.v2 import modules
+from xoa_driver.internals.state_storage import testers_state
+
+
+TypeL23Manager = ModulesManager["modules.ModuleL23VE"]
+
+
+def get_module_type(revision: str) -> Type:
+    return modules.ModuleL23VE
+
+
+class L23VeTester(BaseTester["testers_state.TesterLocalState"]):
+    """
+    This is a conceptual class of Xena ValkyrieVE Tester.
+    It is essentially an extended :class:`BaseTester`.
+
+
+    :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:
+        super().__init__(
+            host=host,
+            username=username,
+            password=password,
+            port=port,
+            enable_logging=enable_logging,
+            custom_logger=custom_logger,
+            session_timeout=session_timeout
+        )
+
+        self._local_states = testers_state.TesterLocalState(host, port)
+
+        self.multiuser = C_MULTIUSER(self._conn)
+        """
+        Representation of C_MULTIUSER
+        """
+
+        self.traffic = C_TRAFFIC(self._conn)
+        """
+        Representation of C_TRAFFIC
+        """
+
+        self.traffic_sync = C_TRAFFICSYNC(self._conn)
+        """
+        Representation of C_TRAFFICSYNC
+        """
+
+        self.version_no_minor = C_VERSIONNO_MINOR(self._conn)
+        """
+        Representation of C_VERSIONNO_MINOR
+        """
+
+        self.modules: TypeL23Manager = ModulesManager(self._conn, get_module_type)
+        """
+        Module index manager of the L23 tester.
+        """
+
+    @property
+    def info(self) -> testers_state.TesterLocalState:
+        return self._local_states
+
+    async def _setup(self):
+        await super()._setup()
+        await self._local_states.initiate(self)
+        self._local_states.register_subscriptions(self)
+
+        ft_pc = await C_PORTCOUNTS(self._conn).get()
+        port_counts = ft_pc.port_counts
+        await self.modules.fill_l23(port_counts)
+        return self

xoa_driver/internals/hli_v2/testers/l47_tester.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+from typing import (
+    TYPE_CHECKING,
+    Type
+)
+from typing_extensions import Self
+from xoa_driver.internals.commands import (
+    C_REMOTEPORTCOUNTS,
+    C_BUILDSTRING,
+)
+from xoa_driver.internals.core.transporter.logger import CustomLogger
+from xoa_driver.internals.utils.managers.modules_manager import ModulesManager
+from xoa_driver.internals.hli_v2 import revisions
+from xoa_driver.internals import exceptions
+if TYPE_CHECKING:
+    from xoa_driver.internals.hli_v2.modules import module_l47 as ml47
+
+from xoa_driver.internals.state_storage import testers_state
+from ._base_tester import BaseTester
+from .genuine import management_interface as mi
+
+
+def get_module_type(revision: str) -> "Type":
+    module_type = revisions.VULCAN_MODULES.get(revision)
+    if not module_type:
+        raise exceptions.WrongModuleError(
+            revision,
+            set(revisions.VULCAN_MODULES.keys()),
+        )
+    return module_type
+
+
+class L47Tester(BaseTester["testers_state.GenuineTesterLocalState"]):
+    """
+    This is a conceptual class of Xena Vulcan Tester.
+    It is essentially an extended :class:`BaseTester`.
+
+
+    :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:
+        super().__init__(
+            host=host,
+            username=username,
+            password=password,
+            port=port,
+            enable_logging=enable_logging,
+            custom_logger=custom_logger,
+            session_timeout=session_timeout
+        )
+
+        self._local_states = testers_state.GenuineTesterLocalState(host, port)
+
+        self.build_string = C_BUILDSTRING(self._conn)
+        """
+        Representation of C_BUILDSTRING
+        """
+
+        self.management_interface = mi.ManagementInterface(self._conn)
+        """
+        Tester management interface that includes IP address, DHCP, MAC address and hostname.
+        """
+
+        self.modules: ModulesManager["ml47.ModuleL47"] = ModulesManager(self._conn, get_module_type)
+        """
+        Module index manager of the tester.
+        """
+
+    @property
+    def info(self) -> testers_state.GenuineTesterLocalState:
+        return self._local_states
+
+    async def _setup(self) -> Self:
+        await super()._setup()
+        await self._local_states.initiate(self)
+        self._local_states.register_subscriptions(self)
+
+        ft_pc = await C_REMOTEPORTCOUNTS(self._conn).get()
+        port_counts = ft_pc.port_counts
+        await self.modules.fill_l47(port_counts)
+        return self

xoa_driver/internals/hli_v2/testers/l47ve_tester.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+from xoa_driver.internals.commands import (
+    C_BUILDSTRING,
+    C_VERSIONNO_MINOR
+)
+from xoa_driver.internals.core.transporter.logger import CustomLogger
+from .l47_tester import L47Tester
+
+
+class L47VeTester(L47Tester):
+    """
+    This is a conceptual class of Xena VulcanVE Tester.
+    It is essentially an extended :class:`BaseTester`.
+
+
+    :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:
+        super().__init__(
+            host=host,
+            username=username,
+            password=password,
+            port=port,
+            enable_logging=enable_logging,
+            custom_logger=custom_logger,
+            session_timeout=session_timeout
+        )
+        self.version_no_minor = C_VERSIONNO_MINOR(self._conn)
+        """
+        Representation of C_VERSIONNO_MINOR
+        """
+
+        self.build_string = C_BUILDSTRING(self._conn)
+        """
+        Representation of C_BUILDSTRING
+        """

xoa_driver/internals/state_storage/_speed_detector.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from enum import (
+    Enum,
+    auto
+)
+from xoa_driver.internals.commands import enums
+if TYPE_CHECKING:
+    from xoa_driver.internals.commands import P_CAPABILITIES
+
+
+class EPortInterfaceSubtype(Enum):
+    Unspecified = auto()
+    Single = auto()
+    Dual = auto()
+    Triple = auto()
+    Quint = auto()
+
+
+class SpeedDetector:
+    """
+    Work around of ports speed detection. Only for Genuine L23 ports.
+    Keep it as a class for not couple all logic under one function.
+    """
+    __slots__ = ("capabilities", "interface")
+
+    def __init__(self, capabilities: "P_CAPABILITIES.GetDataAttr", interface: str) -> None:
+        self.capabilities = capabilities
+        self.interface = interface
+
+    @property
+    def __determinate_interface_subtype(self) -> EPortInterfaceSubtype:
+        if "[Triple]" in self.interface:
+            return EPortInterfaceSubtype.Triple
+        elif "[Quint]" in self.interface:
+            return EPortInterfaceSubtype.Quint
+        elif "[Dual]" in self.interface:
+            return EPortInterfaceSubtype.Dual
+        elif "[Single]" in self.interface:
+            return EPortInterfaceSubtype.Single
+        return EPortInterfaceSubtype.Unspecified
+
+    @property
+    def can_set_port_speed(self) -> bool:
+        return self.__determinate_interface_subtype in {
+            EPortInterfaceSubtype.Triple,
+            EPortInterfaceSubtype.Quint,
+            EPortInterfaceSubtype.Dual,
+            EPortInterfaceSubtype.Single
+        }
+
+    def __define_single(self) -> list[enums.PortSpeedMode]:
+        if "T1S" not in self.interface:
+            return []
+        return [
+            enums.PortSpeedMode.AUTO,
+            enums.PortSpeedMode.F100M,
+            enums.PortSpeedMode.F1G,
+        ]
+
+    def __define_dual(self) -> list[enums.PortSpeedMode]:
+        if "T1" in self.interface:
+            return [enums.PortSpeedMode.F10MHDX, ]
+        return []
+
+    def __define_triple(self) -> list[enums.PortSpeedMode]:
+        if self.interface.startswith("SFP"):
+            if self.capabilities.max_speed == 1_000:
+                return [
+                    enums.PortSpeedMode.AUTO,
+                    enums.PortSpeedMode.F10M,
+                    enums.PortSpeedMode.F100M,
+                    enums.PortSpeedMode.F1G,
+                    enums.PortSpeedMode.F10M100M,
+                    enums.PortSpeedMode.F100M1G,
+                    enums.PortSpeedMode.F10MHDX,
+                    enums.PortSpeedMode.F100MHDX,
+                ]
+            elif self.capabilities.max_speed == 10_000:
+                return [
+                    enums.PortSpeedMode.AUTO,
+                    enums.PortSpeedMode.F100M,
+                    enums.PortSpeedMode.F1G,
+                    enums.PortSpeedMode.F10G,
+                    enums.PortSpeedMode.F100M1G,
+                ]
+        elif self.interface.startswith("10GBASE-T"):
+            return [
+                enums.PortSpeedMode.AUTO,
+                enums.PortSpeedMode.F100M,
+                enums.PortSpeedMode.F1G,
+                enums.PortSpeedMode.F10G,
+                enums.PortSpeedMode.F100M1G,
+            ]
+        return []
+
+    def __define_quint(self) -> list[enums.PortSpeedMode]:
+        speeds = [
+            enums.PortSpeedMode.AUTO,
+            enums.PortSpeedMode.F100M,
+            enums.PortSpeedMode.F1G,
+            enums.PortSpeedMode.F2500M,
+            enums.PortSpeedMode.F5G,
+            enums.PortSpeedMode.F100M1G,
+            enums.PortSpeedMode.F100M1G2500M,
+        ]
+        if self.interface.startswith("10GBASE-T"):
+            speeds.append(enums.PortSpeedMode.F10G)
+        return speeds
+
+    def find_port_possible_speed(self) -> list[enums.PortSpeedMode]:
+        if not self.can_set_port_speed:
+            return []
+        define_func = {
+            EPortInterfaceSubtype.Single: self.__define_single,
+            EPortInterfaceSubtype.Dual: self.__define_dual,
+            EPortInterfaceSubtype.Triple: self.__define_triple,
+            EPortInterfaceSubtype.Quint: self.__define_quint
+        }.get(self.__determinate_interface_subtype, lambda: [])
+        return define_func()

xoa_driver/internals/state_storage/modules_state.py

@@ -0,0 +1,128 @@
+import asyncio
+from typing import List
+from dataclasses import (
+    dataclass,
+    field,
+)
+from xoa_driver.internals.core import funcs
+from xoa_driver.internals.commands import enums
+from xoa_driver.internals.commands import (
+    M_MODEL,
+    M_RESERVATION,
+    M_RESERVEDBY,
+    M_MEDIASUPPORT,
+)
+
+from xoa_driver.internals.utils import attributes as utils
+
+
+class ModuleLocalState:
+    """Module local state.
+    """
+    __slots__ = (
+        "reservation",
+        "reserved_by",
+        "model",
+    )
+
+    def __init__(self) -> None:
+        self.reservation: enums.ReservedStatus = enums.ReservedStatus.RELEASED
+        self.reserved_by: str = ""
+        self.model: str = ""
+
+    async def initiate(self, module) -> None:
+        (
+            reservation_r,
+            reserved_by_r,
+            model_r,
+        ) = await funcs.apply(
+            module.reservation.get(),
+            module.reserved_by.get(),
+            module.model.get(),
+        )
+        self.reservation = enums.ReservedStatus(reservation_r.operation)
+        self.reserved_by = reserved_by_r.username
+        self.model = model_r.model
+
+    def register_subscriptions(self, module) -> None:
+        module._conn.subscribe(M_RESERVEDBY, utils.Update(self, "reserved_by", "username", module._check_identity))
+        module._conn.subscribe(M_RESERVATION, utils.Update(self, "reservation", "operation", module._check_identity))
+        module._conn.subscribe(M_MODEL, utils.Update(self, "model", "model", module._check_identity))
+
+
+@dataclass(frozen=True)
+class ModuleSpeed:
+    """Module's port-speed information.
+    """
+    port_count: int
+    """Port count
+
+    :return: number of ports that have the same speed
+    :rtype: int
+    """
+
+    port_speed: int
+    """Port speed
+
+    :return: speed of the ports
+    :rtype: int
+    """
+
+
+@dataclass(frozen=True)
+class MediaInfo:
+    """Module media information
+    """
+    cage_type: "enums.MediaConfigurationType"
+    """Module Media Configuration
+
+    :return: module media configuration
+    :rtype: MediaConfigurationType
+    """
+
+    available_speeds: List["ModuleSpeed"] = field(default_factory=list)
+    """List of module's port-speed information
+
+    :return: list of module's port-speed information
+    :rtype: List[ModuleSpeed]
+    """
+
+
+class ModuleL23LocalState(ModuleLocalState):
+    """L23 Module local state
+    """
+    __slots__ = ("__media_info_list",)
+
+    def __init__(self) -> None:
+        self.__media_info_list: List["MediaInfo"] = []
+
+    @property
+    def media_info_list(self) -> List["MediaInfo"]:
+        return self.__media_info_list
+
+    @media_info_list.setter
+    def media_info_list(self, value: List[int]) -> None:
+        self.__media_info_list.clear()
+        _vs = value[:]
+        while _vs:
+            cage_type = enums.MediaConfigurationType(_vs.pop(0))
+            available_speeds_count = _vs.pop(0)
+            mi = MediaInfo(
+                cage_type,
+                [
+                    ModuleSpeed(_vs.pop(0), _vs.pop(0))
+                    for _ in range(available_speeds_count)
+                ]
+            )
+            self.__media_info_list.append(mi)
+
+    async def initiate(self, module) -> None:
+        m_support_resp, *_ = await asyncio.gather(
+            M_MEDIASUPPORT(module._conn, module.module_id).get(),
+            super().initiate(module)
+        )
+        self.media_info_list = m_support_resp.media_info_list
+
+    def register_subscriptions(self, module) -> None:
+        super().register_subscriptions(module)
+        module._conn.subscribe(M_MEDIASUPPORT, utils.Update(self, "media_info_list", "media_info_list", module._check_identity))