cgse 2023.38.0__py3-none-any.whl → 2024.1.4__py3-none-any.whl

egse/tcs/tcs.yaml

@@ -1,14 +0,0 @@
-BaseClass:
-    egse.tcs.TCSInterface
-
-ProxyClass:
-    egse.tcs.TCSProxy
-
-ControlServerClass:
-    egse.tcs.TCSControlServer
-
-ControlServer:
-    egse.tcs.tcs_cs
-
-UserInterface:
-    egse.tcs.tcs_ui

egse/tcs/tcs_cs.py

@@ -1,202 +0,0 @@
-"""
-The Control Server that connects to the PLATO TCS EGSE Hardware Controller.
-
-Start the control server from the terminal as follows:
-
-```bash
-$ tcs_cs start
-```
-or when you don't have the device available, start the control server in simulator mode. That
-will make the control server connect to a device software simulator:
-```bash
-$ tcs_cs start --sim
-```
-When you need to kill or stop the TCS control server, sue the stop command:
-```bash
-$ tcs_cs stop
-```
-Please note that software simulators are intended for simple test purposes and will not simulate
-all device behavior correctly, e.g. timing, error conditions, etc.
-
-"""
-import logging
-import multiprocessing
-import sys
-import time
-
-from prometheus_client import start_http_server
-
-multiprocessing.current_process().name = "tcs_cs"
-
-import click
-import invoke
-import rich
-import zmq
-
-from egse.control import ControlServer
-from egse.control import is_control_server_active
-from egse.settings import Settings
-from egse.tcs.tcs import TCSProxy
-from egse.tcs.tcs import is_tcs_cs_active
-from egse.tcs.tcs_protocol import TCSProtocol
-from egse.zmq_ser import connect_address
-
-
-logger = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("TCS Control Server")
-
-
-def is_tcs_cs_active(timeout: float = 2.0):
-    """
-    Checks whether the TCS EGSE Control Server is running.
-
-    Args:
-        timeout (float): Timeout when waiting for a reply [seconds, default=2.0]
-
-    Returns:
-        True if the TCS EGSE CS is running and replied with the expected answer.
-    """
-
-    endpoint = connect_address(
-        CTRL_SETTINGS.PROTOCOL, CTRL_SETTINGS.HOSTNAME, CTRL_SETTINGS.COMMANDING_PORT
-    )
-
-    return is_control_server_active(endpoint, timeout)
-
-
-class TCSControlServer(ControlServer):
-    """TCSControlServer - Command and monitor the TCS EGSE hardware.
-
-    This class works as a command and monitoring server to control the TCS EGSE.
-    This control server shall be used as the single point access for controlling the hardware
-    device. Monitoring access should be done preferably through this control server also.
-
-    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 TCS EGSE.
-
-    * a PUB-SUP socket that serves as a monitoring server. It will send out TCS EGSE status
-      information to all the connected clients every TBD seconds.
-
-    """
-
-    def __init__(self):
-        super().__init__()
-
-        self.device_protocol = TCSProtocol(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_delay(CTRL_SETTINGS.ST_DELAY)
-        self.set_hk_delay(CTRL_SETTINGS.HK_DELAY)
-
-    def get_communication_protocol(self):
-        return CTRL_SETTINGS.PROTOCOL
-
-    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_metrics_port(self):
-        return CTRL_SETTINGS.METRICS_PORT
-
-    def get_storage_mnemonic(self):
-        try:
-            return CTRL_SETTINGS.STORAGE_MNEMONIC
-        except AttributeError:
-            return "TCS"
-
-    def before_serve(self):
-        start_http_server(CTRL_SETTINGS.CS_METRICS_PORT)
-
-
-@click.group()
-def cli():
-    pass
-
-
-@cli.command()
-@click.option(
-    "--simulator", "--sim", is_flag=True, help="Start the TCS EGSE Simulator as the backend."
-)
-def start(simulator):
-    """Start the TCS EGSE Control Server."""
-
-    if simulator:
-        Settings.set_simulation_mode(True)
-
-    try:
-        controller = TCSControlServer()
-        controller.serve()
-    except KeyboardInterrupt:
-        print("Shutdown requested...exiting")
-    except SystemExit as exit_code:
-        print(f"System Exit with code {exit_code}.")
-        sys.exit(exit_code)
-    except Exception as exc:
-        logger.exception(f"Cannot start the TCS EGSE Control Server: {exc}")
-
-    time.sleep(3.0)  # Give the process and sub-process (TCSTelemetry) time to start
-
-    return 0
-
-
-@cli.command()
-def start_bg():
-    """Start the TCS EGSE Control Server in the background."""
-    invoke.run("tcs_cs start", disown=True)
-
-
-@cli.command()
-def stop():
-    """Send a 'quit_server' command to the TCS EGSE Control Server."""
-
-    if not is_tcs_cs_active():
-        rich.print("[red]I couldn't find the TCS Control Server, no action taken.")
-        return
-
-    with TCSProxy() as proxy:
-
-        sp = proxy.get_service_proxy()
-        sp.quit_server()
-
-
-@cli.command()
-def status():
-    """Request status information from the Control Server."""
-
-    protocol = CTRL_SETTINGS.PROTOCOL
-    hostname = CTRL_SETTINGS.HOSTNAME
-    port = CTRL_SETTINGS.COMMANDING_PORT
-
-    endpoint = connect_address(protocol, hostname, port)
-
-    if is_control_server_active(endpoint):
-        rich.print("TCS CS: [green]active")
-        with TCSProxy() as tcs:
-            sim = tcs.is_simulator()
-            connected = tcs.is_connected()
-            ip = tcs.get_ip_address()
-            rich.print(f"mode: {'simulator' if sim else 'device'}"
-                       f"{' not' if not connected else ''} connected")
-            rich.print(f"hostname: {ip}")
-    else:
-        rich.print('TCS CS: [red]not active')
-
-
-if __name__ == "__main__":
-
-    logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-
-    sys.exit(cli())

egse/tcs/tcs_devif.py

@@ -1,292 +0,0 @@
-import logging
-import socket
-import sys
-
-from egse.device import DeviceConnectionError
-from egse.device import DeviceConnectionInterface
-from egse.device import DeviceTimeoutError
-from egse.device import DeviceTransport
-from egse.settings import Settings
-from egse.system import Timer
-from egse.system import format_datetime
-
-logger = logging.getLogger(__name__)
-
-IDENTIFICATION_QUERY = "*IDN?"
-
-READ_TIMEOUT = 5.0  # seconds
-WRITE_TIMEOUT = 1.0  # seconds
-CONNECT_TIMEOUT = 3.0  # seconds
-
-DEVICE_SETTINGS = Settings.load("TCS Controller")
-DEVICE_NAME = "TCS EGSE"
-
-
-class TCSEthernetInterface(DeviceConnectionInterface, DeviceTransport):
-    """Defines the low-level interface to the Keithley DAQ6510 Controller."""
-
-    def __init__(self, hostname=None, port=None):
-        """
-        Args:
-            hostname (str): the IP address or fully qualified hostname of the TCS EGSE hardware
-                controller. The default is defined in the 'settings.yaml' configuration file.
-
-            port (int): the IP port number to connect to. The default is defined in the
-                'settings.yaml' configuration file.
-        """
-        super().__init__()
-
-        self.hostname = hostname or DEVICE_SETTINGS.HOSTNAME
-        self.port = port or DEVICE_SETTINGS.COMMANDING_PORT
-        self.sock = None
-
-        self.is_connection_open = False
-
-    def connect(self):
-        """Connect the device.
-
-        Raises:
-            DeviceConnectionError: When the connection could not be established. Check the logging
-            messages for more detail.
-
-            DeviceTimeoutError: When the connection timed out.
-
-            ValueError: When hostname or port number are not provided.
-        """
-
-        # Sanity checks
-
-        if self.is_connection_open:
-            logger.warning(f"{DEVICE_NAME}: trying to connect to an already connected socket.")
-            return
-
-        if self.hostname in (None, ""):
-            raise ValueError(f"{DEVICE_NAME}: hostname is not initialized.")
-
-        if self.port in (None, 0):
-            raise ValueError(f"{DEVICE_NAME}: port number is not initialized.")
-
-        # Create a new socket instance
-
-        try:
-            self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        except socket.error as e_socket:
-            raise DeviceConnectionError(DEVICE_NAME, "Failed to create socket.") from e_socket
-
-        # Attempt to establish a connection to the remote host
-
-        # FIXME: Socket shall be closed on exception?
-
-        # We set a timeout of CONNECT_TIMEOUT sec before connecting and reset to None
-        # (=blocking) after the connect. The reason for this is because when no
-        # device is available, e.g during testing, the timeout will take about
-        # two minutes which is way too long. It needs to be evaluated if this
-        # approach is acceptable and not causing problems during production.
-
-        try:
-            logger.debug(f'Connecting a socket to host "{self.hostname}" using port {self.port}')
-            self.sock.settimeout(CONNECT_TIMEOUT)
-            self.sock.connect((self.hostname, self.port))
-            self.sock.settimeout(None)
-        except ConnectionRefusedError as exc:
-            raise DeviceConnectionError(
-                DEVICE_NAME, f"Connection refused to {self.hostname}:{self.port}."
-            ) from exc
-        except TimeoutError as exc:
-            raise DeviceTimeoutError(
-                DEVICE_NAME, f"Connection to {self.hostname}:{self.port} timed out."
-            ) from exc
-        except socket.gaierror as exc:
-            raise DeviceConnectionError(
-                DEVICE_NAME, f"socket address info error for {self.hostname}"
-            ) from exc
-        except socket.herror as exc:
-            raise DeviceConnectionError(
-                DEVICE_NAME, f"socket host address error for {self.hostname}"
-            ) from exc
-        except socket.timeout as exc:
-            raise DeviceTimeoutError(
-                DEVICE_NAME, f"socket timeout error for {self.hostname}:{self.port}"
-            ) from exc
-        except OSError as exc:
-            raise DeviceConnectionError(DEVICE_NAME, f"OSError caught ({exc}).") from exc
-
-        self.is_connection_open = True
-
-    def disconnect(self):
-        """Disconnect from the Ethernet connection.
-
-        Raises:
-            DeviceConnectionError when the socket could not be closed.
-        """
-
-        try:
-            if self.is_connection_open:
-                logger.debug(f"Disconnecting from {self.hostname}")
-                self.sock.close()
-                self.is_connection_open = False
-        except Exception as e_exc:
-            raise DeviceConnectionError(
-                DEVICE_NAME, f"Could not close socket to {self.hostname}") from e_exc
-
-    def reconnect(self):
-        """
-        Reconnect to the device. If the connection is open, this function will first disconnect
-        and then connect again.
-        """
-
-        if self.is_connection_open:
-            self.disconnect()
-        self.connect()
-
-    def is_connected(self) -> bool:
-        """
-        Check if the device is connected.
-
-        Returns:
-             True is the device is connected, False otherwise.
-        """
-
-        return bool(self.is_connection_open)
-
-    def read(self) -> bytes:
-        """
-        Read a response from the device.
-
-        Returns:
-            A bytes object containing the response from the device. No processing is done
-            on the response.
-        Raises:
-            A DeviceTimeoutError when the read operation timed out.
-        """
-        idx, n_total = 0, 0
-        buf_size = 1024 * 10
-        response = bytes()
-
-        # Set a timeout of READ_TIMEOUT to the socket.recv
-
-        saved_timeout = self.sock.gettimeout()
-        self.sock.settimeout(READ_TIMEOUT)
-
-        try:
-            for idx in range(100):
-                data = self.sock.recv(buf_size)
-                n = len(data)
-                n_total += n
-                response += data
-                if b'\x03' in response:
-                    break
-        except socket.timeout as e_timeout:
-            logger.warning(f"Socket timeout error: {e_timeout}")
-            raise DeviceTimeoutError(DEVICE_NAME, "Socket timeout error") from e_timeout
-        finally:
-            self.sock.settimeout(saved_timeout)
-
-        # logger.info(f"Total number of bytes received is {n_total}, idx={idx}")
-        # logger.info(f"> {len(response)=}")
-        # logger.info(f"> {response[:80]=}")
-
-        return response
-
-    def write(self, command: str):
-        """
-        Send a command to the device.
-
-        No processing is done on the command string, except for the encoding into a bytes object.
-
-        Args:
-            command: the command string including terminators.
-
-        Raises:
-            A DeviceTimeoutError when the send timed out, and a DeviceConnectionError if
-            there was a socket related error.
-        """
-
-        try:
-            self.sock.sendall(command.encode())
-        except socket.timeout as e_timeout:
-            raise DeviceTimeoutError(DEVICE_NAME, "Socket timeout error") from e_timeout
-        except socket.error as e_socket:
-            # Interpret any socket-related error as an I/O error
-            raise DeviceConnectionError(DEVICE_NAME, "Socket communication error.") from e_socket
-
-    def trans(self, command: str):
-        """
-        Send a command to the device and wait for the response.
-
-        No processing is done on the command string, except for the encoding into a bytes object.
-
-        Args:
-            command: the command string including terminators.
-
-        Returns:
-            A bytes object containing the response from the device. No processing is done
-            on the response.
-
-        Raises:
-            A DeviceTimeoutError when the send timed out, and a DeviceConnectionError if
-            there was a socket related error.
-        """
-
-        try:
-            # Attempt to send the complete command
-
-            self.sock.sendall(command.encode())
-
-            # wait for, read and return the response (will be at most TBD chars)
-
-            return_string = self.read()
-
-            return return_string
-
-        except socket.timeout as e_timeout:
-            raise DeviceTimeoutError(DEVICE_NAME, "Socket timeout error") from e_timeout
-        except socket.error as e_socket:
-            # Interpret any socket-related error as an I/O error
-            raise DeviceConnectionError(DEVICE_NAME, "Socket communication error.") from e_socket
-
-
-if __name__ == "__main__":
-
-    from rich import print
-
-    def send_command(cmd):
-        cmd = cmd.rstrip()
-        with Timer("TCS EGSE Query"):
-            response = tcs.query(cmd + "\n")
-        logger.debug(f"{format_datetime()} Response for {cmd:>20s}: {response.rstrip()}")
-        return response.decode()
-
-    tcs = TCSEthernetInterface(hostname='localhost')
-
-    print("-" * 10, end="")
-    print("Connecting to the device.")
-
-    try:
-        tcs.connect()
-    except DeviceTimeoutError as exc:
-        print(f"[red]{exc}[/red]")
-        sys.exit(-1)
-
-    print("-"*10, end='')
-    print("Requesting remote operations.")
-
-    response = send_command("request_remote_operation")
-    print(f"{response=}")
-
-    if "not_active" in response:
-        print("[red]Remote operation was rejected from the TCS EGSE.[/red]")
-
-    print("Set operation mode .")
-
-    response = send_command("set_parameter operation_mode 6")  # Extended operation mode
-    print(f"{response=}")
-
-    print("Stopping remote operations.")
-
-    response = send_command("quit_remote_operation")  # !!!! no response expected !!!!
-    print(f"{response=}")
-
-    print("Disconnecting from the device.")
-
-    tcs.disconnect()

egse/tcs/tcs_protocol.py

@@ -1,177 +0,0 @@
-import datetime
-import logging
-import multiprocessing
-from typing import List
-
-from egse.command import ClientServerCommand
-from egse.control import ControlServer
-from egse.control import Failure
-from egse.device import DeviceConnectionState
-from egse.device import DeviceTimeoutError
-from egse.metrics import define_metrics
-from egse.protocol import DynamicCommandProtocol
-from egse.settings import Settings
-from egse.system import format_datetime
-from egse.tcs.tcs import TCSController
-from egse.tcs.tcs import TCSParameterNaming
-from egse.tcs.tcs import TCSSimulator
-from egse.tcs.tcs import TCSTelemetry
-
-MODULE_LOGGER = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("TCS Control Server")
-PUNA_SETTINGS = Settings.load(filename="tcs.yaml")
-
-
-class TCSCommand(ClientServerCommand):
-    def get_cmd_string(self, *args, **kwargs) -> str:
-        out = super().get_cmd_string(*args, **kwargs)
-        return out + chr(3)  # end the string with the ASCII character EOT
-
-
-class TCSMetrics:
-    """Defines the metrics for the TCS EGSE that are maintained by the TCSProtocol class."""
-    def __init__(self, origin: str, dashboard: str):
-        self.metrics = define_metrics(origin=origin, dashboard=dashboard)
-
-    def __contains__(self, item):
-        return self.metrics.__contains__(item)
-
-    def names(self):
-        return self.metrics.keys()
-
-    def update_metrics(self, name: str, value: str):
-        """Update the TCS metric parameter with the given value."""
-        if name in self.metrics:
-            self.metrics[name].set(float(value))
-
-
-class TCSProtocol(DynamicCommandProtocol):
-    def __init__(self, control_server: ControlServer):
-        super().__init__(control_server)
-
-        # Read the configuration metrics from the tm-dictionary
-
-        self._metrics = TCSMetrics(origin=control_server.get_storage_mnemonic(),
-                                   dashboard="TCS_CONFIGURATION_MON")
-
-        # Device naming is different from CGSE naming, the conversion is handled in the
-        # TCSParameterNaming class.
-
-        self._hk_names = TCSParameterNaming(origin=control_server.get_storage_mnemonic())
-
-        # Set up two queue's to communicate with the TCS Telemetry Process.
-        # The command queue is joinable because the Controller needs to wait for a response in
-        # the response queue.
-
-        self.command_queue = multiprocessing.Queue()
-        self.response_queue = multiprocessing.Queue()
-
-        # Start a separate Process to handle the TCS EGSE Telemetry
-
-        self.processor = TCSTelemetry(self.command_queue, self.response_queue)
-        self.processor.name = "tcs.telemetry"
-        self.processor.start()
-
-        self.device = TCSSimulator() if Settings.simulation_mode() else TCSController()
-
-        try:
-            self.device.connect()
-        except (ConnectionError, DeviceTimeoutError) as exc:
-            MODULE_LOGGER.warning(
-                f"Couldn't establish a connection to the TCS EGSE ({exc}).")
-
-        self._dt_of_last_error = datetime.datetime.now(tz=datetime.timezone.utc)
-
-    def quit(self):
-        self.processor.terminate()
-
-    def get_device(self):
-        return self.device
-
-    def get_status(self):
-
-        status = super().get_status()
-
-        # TODO (rik): add status information for the monitoring service here
-
-        if self.state == DeviceConnectionState.DEVICE_CONNECTED or Settings.simulation_mode():
-            # Collect status information here
-            pass
-
-        return status
-
-    def get_housekeeping(self) -> dict:
-
-        self.log_new_errors()
-
-        result = {"timestamp": format_datetime()}
-
-        # Put in NaN as a default value, this will be updated with the actual real values
-        # when the TCS EGSE is in remote control mode and the configuration can be obtained.
-        # This 'initialisation' is also needed because the column names are determined when
-        # the TCS EGSE is not in remote control mode.
-
-        result.update(
-            {name: float('nan') for name in self._metrics.names()}
-        )
-
-        # if self.state == DeviceConnectionState.DEVICE_CONNECTED:
-        #     # Collect housekeeping information here
-        #     pass
-
-        configuration = self.device.get_configuration()
-
-        if isinstance(configuration, Failure):
-            [self._metrics.update_metrics(name, 'nan') for name in self._metrics.names()]
-            return result
-
-        # update the housekeeping table with the actual values for the Storage
-
-        result.update(
-            {
-                self._hk_names.get_cgse_name(name): value
-                for name, value in configuration.items()
-                if self._hk_names.get_cgse_name(name) in self._metrics
-            }
-        )
-
-        # update the recorded metrics for Prometheus/Grafana
-
-        for name, value in configuration.items():
-            self._metrics.update_metrics(self._hk_names.get_cgse_name(name), value)
-
-        return result
-
-    def log_new_errors(self):
-
-        errors = new_errors = None
-        try:
-            errors = self.device.get_error()
-            new_errors = self._extract_last_error(errors)
-            for error in new_errors:
-                MODULE_LOGGER.error(f"TCS EGSE: {error}")
-        except Exception as exc:
-            MODULE_LOGGER.error(f"Exception caught: {exc=}")
-            MODULE_LOGGER.debug(f"{errors=}")
-            MODULE_LOGGER.debug(f"{new_errors=}")
-
-    def _extract_last_error(self, errors: List):
-
-        new_errors = []
-
-        for error_msg in errors:
-            if 'remote_mode_not_active' in error_msg:
-                MODULE_LOGGER.warning("TCS EGSE: Remote mode is not active")
-                break
-            if 'no errors' in error_msg:
-                break
-            dt_error_str, *_, msg = error_msg.split('\t')
-            dt_error = datetime.datetime.strptime(dt_error_str, "%Y/%m/%d %H:%M:%S.%f UTC")
-            dt_error = dt_error.replace(tzinfo=datetime.timezone.utc)
-            if dt_error > self._dt_of_last_error:
-                new_errors.append((format_datetime(dt_error), msg))
-
-        self._dt_of_last_error = datetime.datetime.now(tz=datetime.timezone.utc)
-
-        return new_errors