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

xoa_driver/internals/hli_v1/testers/genuine/l_23/health.py

@@ -0,0 +1,16 @@
+from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    C_HEALTH,
+)
+
+
+class Health:
+    """File uploading functions of the Valkyrie tester."""
+
+    def __init__(self, conn: "itf.IConnection") -> None:
+        self.all = C_HEALTH(conn, [])
+        """All chassis health information"""
+        self.info = C_HEALTH(conn, [0])
+        """Chassis identification information"""
+        self.uptime = C_HEALTH(conn, [1])
+        """Chassis system uptime"""

xoa_driver/internals/hli_v1/testers/genuine/l_23/rest_api.py

@@ -0,0 +1,38 @@
+from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    C_RESTPORT,
+    C_RESTENABLE,
+    C_RESTSTATUS,
+    C_RESTCONTROL,
+)
+
+
+class RestApiServer:
+    """
+    Rest API server for the Valkyrie tester
+    """
+
+    def __init__(self, conn: "itf.IConnection") -> None:
+        self.port = C_RESTPORT(conn)
+        """TCP port for the REST server.
+                
+        :type: C_RESTPORT
+        """
+
+        self.enable = C_RESTENABLE(conn)
+        """Enable the REST server.
+                
+        :type: C_RESTENABLE
+        """
+
+        self.status = C_RESTSTATUS(conn)
+        """Status of the REST server.
+                
+        :type: C_RESTSTATUS
+        """
+
+        self.control = C_RESTCONTROL(conn)
+        """Control the REST server.
+                
+        :type: C_RESTCONTROL
+        """

xoa_driver/internals/hli_v1/testers/genuine/l_23/time_keeper.py

@@ -0,0 +1,57 @@
+from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    C_TKLICFILE,
+    C_TKLICSTATE,
+    C_TKSTATUS,
+    C_TKSTATUSEXT,
+    C_TKSVCSTATE,
+    C_TKGPSSTATE,
+    C_TKCONFIG,
+)
+
+
+class TimeKeeper:
+    """TimeKeeper of Valkyrie."""
+
+    def __init__(self, conn: "itf.IConnection") -> None:
+        self.license_file = C_TKLICFILE(conn)
+        """TimeKeeper license file content.
+                
+        :type: C_TKLICFILE
+        """
+
+        self.license_state = C_TKLICSTATE(conn)
+        """State of TimeKeeper license file content.
+                
+        :type: C_TKLICSTATE
+        """
+
+        self.status = C_TKSTATUS(conn)
+        """Version and status of TimeKeeper.
+                
+        :type: C_TKSTATUS
+        """
+
+        self.status_extended = C_TKSTATUSEXT(conn)
+        """Version and status of TimeKeeper (extended).
+                
+        :type: C_TKSTATUSEXT
+        """
+
+        self.svc_state = C_TKSVCSTATE(conn)
+        """TimeKeeper service state.
+                
+        :type: C_TKSVCSTATE
+        """
+
+        self.gps_state = C_TKGPSSTATE(conn)
+        """TimeKeeper GPS state.
+                
+        :type: C_TKGPSSTATE
+        """
+
+        self.config_file = C_TKCONFIG(conn)
+        """TimeKeeper configuration file content.
+                
+        :type: C_TKCONFIG
+        """

xoa_driver/internals/hli_v1/testers/genuine/l_23/upload_file.py

@@ -0,0 +1,29 @@
+from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    C_FILESTART,
+    C_FILEDATA,
+    C_FILEFINISH
+)
+
+
+class UploadFile:
+    """File uploading functions of the Valkyrie tester."""
+
+    def __init__(self, conn: "itf.IConnection") -> None:
+        self.start = C_FILESTART(conn)
+        """Start uploading file.
+                
+        :type: C_FILESTART
+        """
+
+        self.data = C_FILEDATA(conn)
+        """Uploading a file fragment.
+                
+        :type: C_FILEDATA
+        """
+
+        self.finish = C_FILEFINISH(conn)
+        """Finish uploading file.
+                
+        :type: C_FILEFINISH
+        """

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

@@ -0,0 +1,42 @@
+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.
+
+        :type: C_IPADDRESS
+        """
+
+        self.dhcp = C_DHCP(conn)
+        """
+        Chassis management port IP address configuration with DHCP.
+
+        :type: C_DHCP
+        """
+
+        self.macaddress = C_MACADDRESS(conn)
+        """
+        Chassis management port MAC address.
+
+        :type: C_MACADDRESS
+        """
+
+        self.hostname = C_HOSTNAME(conn)
+        """
+        Chassis hostname.
+
+        :type: C_HOSTNAME
+        """

xoa_driver/internals/hli_v1/testers/l23_tester.py

@@ -0,0 +1,196 @@
+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.utils.managers import modules_manager as mm
+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 import modules
+
+from xoa_driver.internals.core.transporter.logger import CustomLogger
+from xoa_driver.internals.state_storage import testers_state
+from xoa_driver.internals.hli_v1 import revisions
+from xoa_driver.internals import exceptions
+
+
+TypeL23Manager = mm.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)
+        """
+        The management interface address configuration includes IP address, DHCP settings, MAC address and hostname.
+
+        :type: ManagementInterface
+        """
+
+        self.upload_file = upload_file.UploadFile(self._conn)
+        """
+        File upload functions of the tester.
+
+        :type: UploadFile
+        """
+
+        self.rest_api_server = rest_api.RestApiServer(self._conn)
+        """
+        REST API server of the tester.
+
+        :type: RestApiServer
+        """
+
+        self.time_keeper = time_keeper.TimeKeeper(self._conn)
+        """
+        TimeKeeper of the tester.
+
+        :type: TimeKeeper
+        """
+
+        self.multiuser = C_MULTIUSER(self._conn)
+        """
+        Enable or disable the ability to control one resource from several different TCP
+        connections.
+
+        :type: C_MULTIUSER
+        """
+
+        self.traffic = C_TRAFFIC(self._conn)
+        """
+        Starts or stops the traffic on a number of ports on the chassis simultaneously.
+        The ports are identified by pairs of integers (module port).
+
+        :type: C_TRAFFIC
+        """
+
+        self.traffic_sync = C_TRAFFICSYNC(self._conn)
+        """
+        This can be used to start traffic simultaneously on multiple chassis. The ports are identified by pairs of integers (module port).
+
+        :type: C_TRAFFICSYNC
+        """
+
+        self.version_no_minor = C_VERSIONNO_MINOR(self._conn)
+        """
+        Get the minor version number of the tester firmware.
+
+        :type: 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)
+        """
+        Identify the hostname of the PC that builds the xenaserver. It uniquely identifies the build of a xenaserver.
+
+        :type: C_BUILDSTRING
+        """
+
+        self.health = health.Health(self._conn)
+        """
+        Chassis system health information.
+
+        :type: C_HEALTH
+        """
+
+        self.modules: TypeL23Manager = mm.ModulesManager(self._conn, get_module_type)
+        """
+        Module Index Manager of the L23 tester.
+
+        :type: ModulesManager
+        """
+
+    @property
+    def info(self) -> testers_state.GenuineTesterLocalState:
+        """Return tester's local state
+
+        :return: tester's local state
+        :rtype: 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_v1/testers/l23ve_tester.py

@@ -0,0 +1,114 @@
+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 import modules_manager as mm
+from ._base_tester import BaseTester
+
+
+from xoa_driver import modules
+from xoa_driver.internals.state_storage import testers_state
+
+
+TypeL23Manager = mm.ModulesManager["modules.ModuleL23VE"]
+
+
+def get_module_type(_: 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)
+        """
+        Enable or disable the ability to control one resource from several different TCP connections.
+
+        :type:  C_MULTIUSER
+        """
+
+        self.traffic = C_TRAFFIC(self._conn)
+        """
+        Starts or stops the traffic on a number of ports on the chassis simultaneously.
+        The ports are identified by pairs of integers (module port).
+
+        :type: C_TRAFFIC
+        """
+
+        self.traffic_sync = C_TRAFFICSYNC(self._conn)
+        """
+        This can be used to start traffic simultaneously on multiple chassis. The ports are identified by pairs of integers (module port).
+
+        :type: C_TRAFFICSYNC
+        """
+
+        self.version_no_minor = C_VERSIONNO_MINOR(self._conn)
+        """
+        Get the minor version number of the tester firmware.
+
+        :type: C_VERSIONNO_MINOR
+        """
+
+        self.modules: TypeL23Manager = mm.ModulesManager(self._conn, get_module_type)
+        """
+        Module Index Manager of the L23 VE tester.
+
+        :type: ModulesManager
+        """
+
+    @property
+    def info(self) -> testers_state.TesterLocalState:
+        """Return tester's local state
+
+        :return: tester's local state
+        :rtype: 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_v1/testers/l47_tester.py

@@ -0,0 +1,106 @@
+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 import modules_manager as mm
+from xoa_driver.internals.hli_v1 import revisions
+from xoa_driver.internals import exceptions
+if TYPE_CHECKING:
+    from xoa_driver.internals.hli_v1.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)
+        """
+        Identify the hostname of the PC that builds the xenaserver. It uniquely identifies the build of a xenaserver.
+
+        :type: C_BUILDSTRING
+        """
+
+        self.management_interface = mi.ManagementInterface(self._conn)
+        """
+        The management interface address configuration includes IP address, DHCP settings, MAC address and hostname.
+
+        :type: ManagementInterface
+        """
+
+        self.modules: mm.ModulesManager["ml47.ModuleL47"] = mm.ModulesManager(self._conn, get_module_type)
+        """
+        Module Index Manager of the tester.
+
+        :type: ModulesManager
+        """
+
+    @property
+    def info(self) -> testers_state.GenuineTesterLocalState:
+        """Return tester's local state
+
+        :return: tester's local state
+        :rtype: 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_v1/testers/l47ve_tester.py

@@ -0,0 +1,54 @@
+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)
+        """
+        Get the minor version number of the tester firmware.
+
+        :type: C_VERSIONNO_MINOR
+        """
+
+        self.build_string = C_BUILDSTRING(self._conn)
+        """
+        Identify the hostname of the PC that builds the xenaserver. It uniquely identifies the build of a xenaserver.
+
+        :type: C_BUILDSTRING
+        """