cgse 2024.7.0__py3-none-any.whl → 2025.0.2__py3-none-any.whl

egse/dsi/spw.py

@@ -1,335 +0,0 @@
-"""
-This module contains functions to handle SpaceWire communication.
-"""
-from __future__ import annotations
-
-import logging
-import socket
-import textwrap
-from typing import Tuple
-
-import egse.rmap
-import egse.spw
-from egse.dsi import constants
-from egse.dsi.constants import esl_rmap_error_codes
-from egse.dsi.esl import ESLError
-from egse.dsi.esl import esl_close_connection
-from egse.dsi.esl import esl_configure
-from egse.dsi.esl import esl_flush
-from egse.dsi.esl import esl_get_active_link
-from egse.dsi.esl import esl_get_hwa
-from egse.dsi.esl import esl_get_manufacturer_string
-from egse.dsi.esl import esl_get_number_of_links
-from egse.dsi.esl import esl_get_product_string
-from egse.dsi.esl import esl_get_serial_number
-from egse.dsi.esl import esl_open_connection
-from egse.dsi.esl import esl_read_packet
-from egse.dsi.esl import esl_send_timecode
-from egse.dsi.esl import esl_set_active_link
-from egse.dsi.esl import esl_write_packet
-from egse.dsi.rmap import rmap_configure
-from egse.dsi.rmap import rmap_open_connection
-from egse.settings import Settings
-from egse.spw import SpaceWireInterface
-from egse.spw import SpaceWirePacket
-from egse.spw import WriteRequestReply
-from egse.spw import ReadRequestReply
-
-LOGGER = logging.getLogger(__name__)
-
-DSI_SETTINGS = Settings.load("DSI")
-
-# Naming conventions:
-#
-# rx_buffer:
-#     is used for any buffer (of type bytes) that is or was received over the SpaceWire interface.
-# tx_buffer:
-#     is used for any buffer (of type bytes) that will be transmitted over the SpaceWire interface.
-
-
-def handle_extension_packet(rx_buffer: bytes, bytes_received: int):
-    """
-    Decide how to handle the extension packet that was received over the SpaceWire.
-
-    The following extension packets are supported:
-
-    * a timecode packet
-
-    Args:
-        rx_buffer (bytes): the packet that was received as a bytes object
-        bytes_received (int): the length of the rx_buffer (allocated space might be larger)
-
-    Returns:
-        Nothing: yet.
-
-    """
-    LOGGER.debug("*" * 80)
-    LOGGER.debug("Extension Packet returned by DSI")
-    LOGGER.debug(
-        f"extension packet: {bin(int.from_bytes(rx_buffer, 'big'))} (length={bytes_received})"
-    )
-    LOGGER.debug("*" * 80)
-
-
-def handle_special_packet(rx_buffer: bytes, bytes_received: int):
-    """
-    Decide how to handle a special packet that was received over the SpaceWire interface.
-
-    Args:
-        rx_buffer (bytes): the packet that was received as a bytes object
-        bytes_received (int): the length of the rx_buffer (allocated space might be larger)
-
-    Returns:
-        Nothing: yet.
-
-    """
-    LOGGER.debug("*" * 80)
-    LOGGER.debug("Special Packet returned by DSI")
-    LOGGER.debug(f"Special packet: {rx_buffer} (length={bytes_received})")
-    LOGGER.debug("*" * 80)
-
-
-class SpaceWireOverDSI(SpaceWireInterface):
-    """
-    The SpaceWireOverDSI implements the SpaceWire communication/transport over a Diagnostic
-    SpaceWire Interface (DSI).
-    """
-
-    def __init__(self, dsi_address, dsi_port, esl_link=None, rmap_link=None):
-        self.dsi_address = dsi_address
-        self.dsi_port = dsi_port
-        self.esl_link = esl_link
-        self.rmap_link = rmap_link
-        self.socket = None
-
-    def __str__(self):
-        hwa = esl_get_hwa(self.esl_link)
-        serial_number = esl_get_serial_number(self.esl_link)
-
-        msg = textwrap.dedent(f"""\
-            Info on SpaceWire Interface:
-              Manufacturer      {esl_get_manufacturer_string(self.esl_link)}
-              Product           {esl_get_product_string(self.esl_link)}
-              Number of links   {esl_get_number_of_links(self.esl_link)} [active port={esl_get_active_link(self.esl_link)}]
-              Serial number     {serial_number}
-              Hardware Address  0x{hwa[0]:02X}-{hwa[1]:02X}-{hwa[2]:02X}-{hwa[3]:02X}-{hwa[4]:02X}-{hwa[5]:02X}
-            """
-        )
-
-        return msg
-
-    def connect(self):
-        if self.esl_link is None:
-            self.esl_link = esl_open_connection(self.dsi_address)
-        if self.rmap_link is None:
-            self.rmap_link = rmap_open_connection(self.esl_link)
-        # esl_print_info(self.esl_link)
-
-    def disconnect(self):
-        esl_close_connection(self.esl_link)
-
-    def configure(self):
-        esl_configure(
-            self.esl_link,
-            active_link=self.dsi_port,
-            speed=DSI_SETTINGS.LINK_SPEED,
-            mode=constants.ESL_LINK_MODE_NORMAL,
-            report=constants.ESL_ER_REPORT_PARITY_ERROR
-            | constants.ESL_ER_REPORT_TIME_CODE
-            | constants.ESL_ER_REPORT_ESC_EOP
-            | constants.ESL_ER_REPORT_ESC_EEP
-            | constants.ESL_ER_REPORT_ESC_ESC
-            | constants.ESL_ER_REPORT_TIMEOUT,
-        )
-
-        rmap_configure(
-            self.rmap_link,
-            target_key=constants.RMAP_TARGET_KEY,
-            initiator_logical_address=DSI_SETTINGS.INITIATOR_LOGICAL_ADDRESS,
-            target_logical_address=DSI_SETTINGS.TARGET_LOGICAL_ADDRESS,
-        )
-
-        # esl_print_summary_of_structure(self.esl_link)
-
-    def get_socket(self):
-        """
-        Returns the TCP socket that is associated with this transport.
-
-        Returns:
-            A TCP socket or None when the transport has not been initialized or connected.
-        """
-        # This 'trick' of getting the socket from the `fileno` works only once, so, if we have already
-        # requested the socket for this `fileno`, don't do it again. It will either result in a
-        # `OSError: [Errno 9] Bad file descriptor` or I've seen that a new socket created with the same
-        # family and type will reuse the same `fileno` down the line...
-
-        if self.socket is None and self.esl_link is not None:
-            sock_fd = self.esl_link.contents.sock
-            self.socket = socket.socket(fileno=sock_fd)  # This is how to get the socket from the esl_connection.
-
-        return self.socket
-
-    def set_active_link(self, port: int):
-        """
-        Sets the active SpW port on the DSI.
-
-        Raises:
-            An ESLError when an invalid link is provided.
-
-        Returns:
-            The return code of the library call.
-        """
-        rc = esl_set_active_link(self.esl_link, port)
-        if rc == constants.ESL_API_INVALID_LINK:  # noqa
-            raise ESLError(
-                f"Could not set active link {port}, ESL error: Invalid Link selected [-45]."
-            )
-
-        return rc
-
-    def get_active_link(self):
-        """Return the number of the currently active SpW port on the DSI."""
-        return esl_get_active_link(self.esl_link)
-
-    def flush(self):
-        esl_flush(self.esl_link)
-
-    def send_timecode(self, timecode: int) -> int:
-        return esl_send_timecode(self.esl_link, timecode)
-
-    def read_packet(self, timeout: int = None) -> Tuple[int, bytes]:
-        return esl_read_packet(self.esl_link, timeout=timeout)
-
-    def write_packet(self, packet: bytes) -> int:
-        return esl_write_packet(self.esl_link, packet, len(packet), constants.ESL_EOP)  # noqa
-
-    def read_register(self, address: int, length: int = 4, strict: bool = True) -> bytes:
-        reply_packet = self.rmap_read_request(address, length, strict=strict)
-
-        if reply_packet is None:
-            LOGGER.critical(f"read_register() failed: An error occurred in the rmap_read_request() call.")
-            return bytes()
-
-        return reply_packet.data
-
-    def write_register(self, address: int, data: bytes) -> int:
-        reply_packet = self.rmap_write_request(address, data)
-
-        if reply_packet is None:
-            LOGGER.critical(f"write_register() failed: An error occurred in the rmap_write_request() call.")
-            return -1
-
-        if reply_packet.status:
-            LOGGER.warning(f"write_register() failed: An error occurred in the rmap_write_request() call: "
-                           f"{reply_packet.status = }")
-
-        return reply_packet.status
-
-    def read_memory_map(self, address: int, size: int) -> bytes:
-        reply_packet = self.rmap_read_request(address, size, strict=False)
-
-        if reply_packet is None:
-            LOGGER.critical(f"read_memory_map(): An error occurred in the rmap_read_request() call.")
-            return bytes()
-
-        return reply_packet.data
-
-    def rmap_read_request(
-            self, address: int, length: int, timeout: int = 1000, strict: bool = True) -> ReadRequestReply | None:
-        """
-        Read `length` bytes from the remote memory starting at `address`.
-
-        Args:
-            address: the start address (32-bit aligned) in the remote memory
-            length: the number of bytes to read from the remote memory
-            timeout: timeout in milliseconds
-            strict: perform strict checking of read areas
-
-        Returns:
-            A tuple containing the terminator value and the RMAP Reply packet with the data read from
-            the remote memory.
-
-        """
-        # TODO:
-        #   the timeout parameter is currently not implemented
-
-        self.rmap_link.transaction_identifier = egse.spw.update_transaction_identifier(self.rmap_link.transaction_identifier)
-
-        buffer = egse.rmap.create_rmap_read_request_packet(
-            address, length, self.rmap_link.transaction_identifier, strict=strict)
-
-        result = esl_write_packet(self.rmap_link.spw_device, buffer, len(buffer), constants.ESL_EOP)  # noqa
-        if result:
-            raise egse.rmap.RMAPError(
-                f"Couldn't send data within timeout of {timeout} ms, "
-                f"ESL RMAP Error Code = {esl_rmap_error_codes[self.rmap_link.ESL_RMAP_error]} ["
-                f"{self.rmap_link.ESL_RMAP_error}]")
-
-        result = esl_flush(self.rmap_link.spw_device)
-        if result:
-            raise egse.rmap.RMAPError(
-                f"Couldn't send data or clear buffers, "
-                f"ESL RMAP Error Code = {esl_rmap_error_codes[self.rmap_link.ESL_RMAP_error]} ["
-                f"{self.rmap_link.ESL_RMAP_error}]")
-
-        # Read the read request reply packet
-
-        _, rx_buffer = esl_read_packet(self.rmap_link.spw_device, timeout=timeout)
-
-        if rx_buffer:
-            reply_packet = SpaceWirePacket.create_packet(rx_buffer)
-            return reply_packet if isinstance(reply_packet, ReadRequestReply) else None
-
-        return None
-
-    def rmap_write_request(
-            self, address: int, data: bytes, length: int = 4, timeout: int = 1000) -> WriteRequestReply | None:
-        """
-        Sends an RMAP write command over the SpaceWire link.
-
-        Based on the address this function will decided to send a verified or unverified write request.
-
-        TODO: the timeout parameter is currently not implemented.
-
-        Args:
-            address: the starting memory address to which the data from buffer will be written
-            data: the data that will be written into the targets memory
-            length: the number of bytes to write (the buffer maybe longer) [default=4]
-            timeout: timeout in milliseconds [default=1000]
-
-        Returns:
-            The Write Request Reply packet.
-
-        Raises:
-            egse.rmap.RMAPError: when data can not be written on the target.
-
-        """
-
-        self.rmap_link.transaction_identifier = egse.spw.update_transaction_identifier(
-            self.rmap_link.transaction_identifier
-        )
-
-        if egse.rmap.CRITICAL_AREA_START <= address <= egse.rmap.CRITICAL_AREA_END:
-            buffer = egse.rmap.create_rmap_verified_write_packet(
-                address, data, self.rmap_link.transaction_identifier)
-        else:
-            buffer = egse.rmap.create_rmap_unverified_write_packet(
-                address, data, length, self.rmap_link.transaction_identifier)
-
-        result = esl_write_packet(self.esl_link, buffer, len(buffer), constants.ESL_EOP)  # noqa
-        if result:
-            raise egse.rmap.RMAPError(f"Couldn't send data ({len(buffer)} bytes) within timeout of {timeout} ms.")
-
-        result = esl_flush(self.esl_link)
-        if result:
-            raise egse.rmap.RMAPError(f"Couldn't send data or flush buffers.")
-
-        # Read the write request reply message
-
-        _, rx_buffer = esl_read_packet(self.esl_link)
-
-        if rx_buffer:
-            reply_packet = SpaceWirePacket.create_packet(rx_buffer)
-            return reply_packet if isinstance(reply_packet, WriteRequestReply) else None
-
-        return None

egse/dsi/spw_state.py

@@ -1,29 +0,0 @@
-class SpaceWireLinkState:
-    def __init__(self):
-        self.linkDisabled = True
-        self.linkStart    = False
-        self.autoStart    = False
-        self.gotNULL      = False
-
-    def isEnabled(self):
-        return not self.linkDisabled and (self.linkStart or self.autoStart and self.gotNULL)
-
-    def setAutoStart(self):
-        self.autoStart = True
-
-    def unsetAutoStart(self):
-        self.autoStart = False
-
-    def setGotNull(self):
-        self.gotNULL = True
-
-    def unsetGotNULL(self):
-        self.gotNULL = False
-
-    def setLinkDisabled(self):
-        self.linkDisabled = True
-
-    def unsetLinkDisabled(self):
-        self.linkDisabled = False
-
-    

egse/dummy.py

@@ -1,318 +0,0 @@
-"""
-This module provides dummy implementation for classes of the Commanding chain.
-"""
-import logging
-import multiprocessing
-import pickle
-import random
-import sys
-import threading
-import time
-from functools import partial
-
-import click
-import zmq
-
-from egse.command import ClientServerCommand
-from egse.confman import is_configuration_manager_active
-from egse.control import ControlServer
-from egse.control import is_control_server_active
-from egse.decorators import dynamic_interface
-from egse.listener import Event
-from egse.listener import EventInterface
-from egse.protocol import CommandProtocol
-from egse.proxy import Proxy
-from egse.settings import Settings
-from egse.system import AttributeDict
-from egse.system import format_datetime
-from egse.zmq_ser import bind_address
-from egse.zmq_ser import connect_address
-
-logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-LOGGER = logging.getLogger("egse.dummy")
-
-# Especially DummyCommand and DummyController need to be defined in a known module
-# because those objects are pickled and when de-pickled at the clients side the class
-# definition must be known.
-
-# We use AttributeDict here to define the settings, because that is how the Settings.load() returns
-# settings loaded from a YAML file.
-
-ctrl_settings = AttributeDict(
-    {
-        'HOSTNAME': 'localhost',
-        'COMMANDING_PORT': 4443,
-        'SERVICE_PORT': 4444,
-        'MONITORING_PORT': 4445,
-        'PROTOCOL': 'tcp',
-        'TIMEOUT': 10,
-        'HK_DELAY': 1.0,
-    }
-)
-
-commands = AttributeDict(
-    {
-        'info': {
-            'description': 'Info on the Dummy Controller',
-            'response': 'handle_device_method'
-        },
-        'response': {
-            'description': 'send a command to the device and return it\'s response',
-            'device_method': 'response',
-            'cmd': '{one} {two} {fake}',
-            'response': 'handle_device_method'
-        },
-        'handle_event': {
-            'description': "Notification of an event",
-            'device_method': 'handle_event',
-            'cmd': '{event}',
-            'response': 'handle_device_method'
-        },
-    }
-)
-
-def is_dummy_cs_active():
-    return is_control_server_active(
-        endpoint=connect_address(ctrl_settings.PROTOCOL, ctrl_settings.HOSTNAME, ctrl_settings.COMMANDING_PORT)
-    )
-
-
-class DummyCommand(ClientServerCommand):
-    pass
-
-
-class DummyInterface:
-    @dynamic_interface
-    def info(self):
-        ...
-    @dynamic_interface
-    def response(self, *args, **kwargs):
-        ...
-
-
-class DummyProxy(Proxy, DummyInterface, EventInterface):
-    def __init__(self,
-                 protocol=ctrl_settings.PROTOCOL, hostname=ctrl_settings.HOSTNAME, port=ctrl_settings.COMMANDING_PORT):
-        """
-        Args:
-            protocol: the transport protocol [default is taken from settings file]
-            hostname: location of the control server (IP address) [default is taken from settings file]
-            port: TCP port on which the control server is listening for commands [default is taken from settings file]
-        """
-        super().__init__(connect_address(protocol, hostname, port), timeout=ctrl_settings.TIMEOUT)
-
-
-class DummyController(DummyInterface, EventInterface):
-    def __init__(self, control_server):
-        self._cs = control_server
-
-    def info(self):
-        return "method info() called on DummyController"
-
-    def response(self, *args, **kwargs):
-        return f"response({args}, {kwargs})"
-
-    def handle_event(self, event: Event) -> str:
-
-        _exec_in_thread = False
-
-        def _handle_event(event):
-            LOGGER.info(f"An event is received, {event=}")
-            LOGGER.info(f"CM CS active? {is_configuration_manager_active()}")
-            time.sleep(5.0)
-            LOGGER.info(f"CM CS active? {is_configuration_manager_active()}")
-            LOGGER.info(f"An event is processed, {event=}")
-
-        if _exec_in_thread:
-            # We execute this function in a daemon thread so the acknowledgment is
-            # sent back immediately (the ACK means 'command received and will be
-            # executed).
-
-            retry_thread = threading.Thread(target=_handle_event, args=(event,))
-            retry_thread.daemon = True
-            retry_thread.start()
-        else:
-            # An alternative to the daemon thread is to create a scheduled task that will be executed
-            # after the event is acknowledged.
-
-            self._cs.schedule_task(partial(_handle_event, event))
-
-        return "ACK"
-
-
-class DummyProtocol(CommandProtocol):
-
-    def __init__(self, control_server: ControlServer):
-        super().__init__()
-        self.control_server = control_server
-
-        self.device_controller = DummyController(control_server)
-
-        self.load_commands(commands, DummyCommand, DummyController)
-
-        self.build_device_method_lookup_table(self.device_controller)
-
-        self._count = 0
-
-    def get_bind_address(self):
-        return bind_address(self.control_server.get_communication_protocol(), self.control_server.get_commanding_port())
-
-    def get_status(self):
-        return super().get_status()
-
-    def get_housekeeping(self) -> dict:
-
-        # LOGGER.debug(f"Executing get_housekeeping function for {self.__class__.__name__}.")
-
-        self._count += 1
-
-        # use the sleep to test the responsiveness of the control server when even this get_housekeeping function takes
-        # a lot of time, i.e. up to several minutes in the case of data acquisition devices
-        # import time
-        # time.sleep(2.0)
-
-
-        return {
-            'timestamp': format_datetime(),
-            'COUNT': self._count,
-            'PI': 3.14159,  # just to have a constant parameter
-            'Random': random.randint(0, 100),  # just to have a variable parameter
-        }
-
-
-class DummyControlServer(ControlServer):
-    """
-    DummyControlServer - Command and monitor dummy device controllers.
-
-    The sever binds to the following ZeroMQ sockets:
-
-    * a REQ-REP socket that can be used as a command server. Any client can connect and
-      send a command to the dummy device controller.
-
-    * a PUB-SUP socket that serves as a monitoring server. It will send out status
-      information to all the connected clients every DELAY seconds.
-
-    """
-
-    def __init__(self):
-        multiprocessing.current_process().name = "dummy_cs"
-
-        super().__init__()
-
-        self.device_protocol = DummyProtocol(self)
-
-        self.logger.info(f"Binding ZeroMQ socket to {self.device_protocol.get_bind_address()}")
-
-        self.device_protocol.bind(self.dev_ctrl_cmd_sock)
-
-        self.poller.register(self.dev_ctrl_cmd_sock, zmq.POLLIN)
-
-        self.set_hk_delay(ctrl_settings.HK_DELAY)
-
-        from egse.confman import ConfigurationManagerProxy
-        from egse.listener import EVENT_ID
-
-        self.register_as_listener(
-            proxy=ConfigurationManagerProxy,
-            listener={'name': 'Dummy CS', 'proxy': DummyProxy, 'event_id': EVENT_ID.SETUP}
-        )
-
-
-    def get_communication_protocol(self):
-        return 'tcp'
-
-    def get_commanding_port(self):
-        return ctrl_settings.COMMANDING_PORT
-
-    def get_service_port(self):
-        return ctrl_settings.SERVICE_PORT
-
-    def get_monitoring_port(self):
-        return ctrl_settings.MONITORING_PORT
-
-    def get_storage_mnemonic(self):
-        return "DUMMY-HK"
-
-    def after_serve(self):
-        from egse.confman import ConfigurationManagerProxy
-
-        self.unregister_as_listener(proxy=ConfigurationManagerProxy, listener={'name': 'Dummy CS'})
-
-
-@click.group()
-def cli():
-    pass
-
-@click.group()
-def control_server():
-    pass
-
-cli.add_command(control_server)
-
-@control_server.command()
-def start():
-    """Start the dummy control server on localhost."""
-    from egse.dummy import DummyControlServer
-
-    try:
-        control_server = DummyControlServer()
-        control_server.serve()
-    except KeyboardInterrupt:
-        print("Shutdown requested...exiting")
-    except SystemExit as exit_code:
-        print("System Exit with code {}.".format(exit_code))
-        sys.exit(exit_code)
-    except Exception:
-        import traceback
-        traceback.print_exc(file=sys.stdout)
-
-@control_server.command()
-def stop():
-    """Send a quit service command to the dummy control server."""
-    with DummyProxy() as dummy:
-        sp = dummy.get_service_proxy()
-        sp.quit_server()
-
-
-@cli.command()
-@click.argument('hostname')
-@click.argument('port')
-@click.option('--pickle/--no-pickle', 'use_pickle', default=True)
-def monitoring(use_pickle: bool, hostname: str = 'localhost', port: int = None):
-    """Monitor the status of a control server on hostname.
-
-    The port number shall correspond to the port number on which the server is publishing
-    information with the ZeroMQ PUB-SUB protocol.
-
-    The response from the server (the data or string that was published) is logged at INFO level.
-
-    Arguments:
-
-        hostname: the IP address or hostname of the server
-
-        port: the port to connect to (this is the port to which the server binds)
-
-    Options:
-
-        --pickle or --no-pickle: use pickle to de-serialize the response
-    """
-    context = zmq.Context()
-
-    receiver = context.socket(zmq.SUB)
-    receiver.connect(f"tcp://{hostname}:{port}")
-    receiver.setsockopt_string(zmq.SUBSCRIBE, "")
-
-    while True:
-        try:
-            response = receiver.recv()
-            if use_pickle:
-                response = pickle.loads(response)
-
-            LOGGER.info(response)
-        except KeyboardInterrupt:
-            LOGGER.info("KeyboardInterrupt caught!")
-            break
-
-
-if __name__ == "__main__":
-    cli()