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

egse/fdir/fdir_manager_controller.py

@@ -1,136 +0,0 @@
-import logging
-import os
-import subprocess
-from datetime import datetime
-
-from egse.fdir import generate_popup
-from egse.fdir.fdir_remote import FdirRemoteProxy
-from egse.fdir.fdir_remote_interface import FdirRemoteInterface
-from egse.settings import Settings
-from egse.setup import load_setup
-from egse.system import replace_environment_variable
-
-logger = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("FDIR Manager Control Server")
-REMOTE_SETTINGS = Settings.load("FDIR Remote Control Server")
-
-
-class FdirException(Exception):
-    pass
-
-
-class FdirManagerController(FdirRemoteInterface):
-
-    def __init__(self):
-
-        self._state = ""
-        self._priority = -1
-        self._storage_path = replace_environment_variable(CTRL_SETTINGS.RECOVERY_SCRIPT_LOCATION)
-        self._logging_path = replace_environment_variable(CTRL_SETTINGS.LOGGING_LOCATION)
-        self._remote_proxy = FdirRemoteProxy()
-        # Check if the remote is online.
-        if not self._remote_proxy.is_cs_connected():
-            logger.warning("FDIR Manager could not connect to the FDIR remote CS")
-        else:
-            logger.info(f"connected to remote CS @ {REMOTE_SETTINGS.HOSTNAME}")
-
-        # Try to load fdir table.
-        try:
-            setup = load_setup()
-            self._fdir_table = setup.gse.fdir_manager.configuration.table
-        except AttributeError as ex:
-            raise FdirException("Could not FDIR table from current setup") from ex
-
-    def is_connected(self):
-        return True
-    
-    def is_simulator(self):
-        return False
-
-    def signal_fdir(self, fdir_code: str, script_args: list):
-
-        logger.info(f"Received FDIR code {fdir_code}: {script_args}.")
-
-        # try to get the mitigation script name and priority from the fdir table
-        try:
-            recovery_command = self._fdir_table[fdir_code]['script']
-            priority = self._fdir_table[fdir_code]['priority']
-            actions = self._fdir_table[fdir_code]['actions']
-        except:
-            logger.error(f"No mitigation script found in the fdir table for fdir code {fdir_code}.")
-            raise FdirException("Cannot find code in FDIR table")
-
-        if priority <= self._priority:
-            logger.warning(f"Received FDIR code with lower priority {fdir_code} ({priority}) "
-                           f"than current state {self._state} ({self._priority}).")
-            return
-
-        self._state = fdir_code
-        self._priority = priority
-
-        # open filewriter for fdir script output logging
-        timestring = datetime.now().strftime("%y-%m-%d_%H:%M:%S")
-        outfilename = f"{self._logging_path}/log/{timestring}_fdir_{fdir_code}"
-        os.makedirs(os.path.dirname(outfilename), exist_ok=True) # Create directories if they don't exist
-
-        # create list of strings used to call subprocess
-        exc_command = ["python3"]
-        exc_command.append(recovery_command) # read script path
-        exc_command[1] = f"{self._storage_path}{exc_command[1]}" # prepend path to script
-        exc_command.extend(script_args) # add script arguments
-        
-        # run recovery script
-        script_success = False
-        try:
-            outfile = open(outfilename, 'w')
-            p = subprocess.Popen(exc_command,
-                             stdout=outfile,
-                             stderr=outfile,
-                             shell=False,
-                             preexec_fn=os.setpgrp)
-            p.wait()
-        except Exception as e:
-            logger.error(f"failed to run {exc_command}: {e}")
-        else:
-            if p.returncode == 0:
-                logger.info(f"Executed recovery script '{recovery_command}'.")
-                script_success = True
-            else:
-                logger.info(f"Failed to execute script: '{recovery_command}'")
-                script_success = False
-        finally:
-            outfile.close()
-
-        # Create a single string representation of the actions list for the pop-up.
-        action_string = "\n".join([f"- {action}" for action in actions])
-
-        # Generate a pop-up on the remote machine (client).
-        if self._remote_proxy.is_cs_connected():
-            self._remote_proxy.generate_popup(
-                code=fdir_code, actions=action_string, success=script_success)
-        else:
-            generate_popup(code=fdir_code, actions=action_string, success=script_success)
-
-    def clear_fdir(self):
-        self._priority = 0
-        logger.info("Cleared FDIR state.")
-
-
-    def get_state(self):
-        return self._priority
-
-
-def main():
-    fmc = FdirManagerController()
-    fmc.register_script('localhost', 11111)
-    print("fdir_state =", fmc.get_state())
-    fmc.signal_fdir('FDIR_TEST')
-    fmc.signal_fdir('FDIR_TEST') # Should fail because of priority
-    print("fdir_state =", fmc.get_state())
-    fmc.clear_fdir()
-    fmc.signal_fdir('FDIR_TEST')
-    print("fdir_state =", fmc.get_state())
-
-if __name__ == "__main__":
-    main()

egse/fdir/fdir_manager_cs.py

@@ -1,164 +0,0 @@
-import logging
-import multiprocessing
-import sys
-from pathlib import Path
-
-import click
-import zmq
-from prometheus_client import start_http_server
-
-from egse.settings import Settings
-from egse.control import ControlServer
-from egse.system import replace_environment_variable
-from egse.fdir.fdir_manager import FdirManagerProtocol, FdirManagerProxy
-
-logger = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("FDIR Manager Control Server")
-
-
-class FdirManagerControlServer(ControlServer):
-    """ The FDIR Manager Control Server is the centralized point of emergency mitigation.
-        In response to an FDIR signal from anywhere in the CGSE, this CS will terminate all running
-        control scripts and subsequently run a predefined recovery script. Terminating control
-        scripts on other hosts is done through a FDIR Remote CS, running on the other host(s).
-
-        The following functionality is provided:
-
-        * (de-)registering control scripts
-        * receiving FDIR codes
-        * automated killing of operational scripts
-        * automated running of recovery scripts
-        * handling priority between FDIR codes
-        * monitoring of the FDIR CS state
-    """
-
-    def __init__(self):
-        super().__init__()
-
-        self.device_protocol = FdirManagerProtocol(self)
-        self.logger.debug(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)
-
-    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_storage_mnemonic(self):
-        try:
-            return CTRL_SETTINGS.STORAGE_MNEMONIC
-        except AttributeError:
-            return "FM"
-
-    def before_serve(self):
-        start_http_server(CTRL_SETTINGS.METRICS_PORT)
-
-
-@click.group()
-def cli():
-    pass
-
-
-@cli.command()
-def start():
-    """ Starts the FDIR Control Server. """
-
-    multiprocessing.current_process().name = "fdir_manager_cs"
-
-    try:
-        check_prerequisites()
-    except RuntimeError as exc:
-        print(exc)
-        logger.error(exc)
-        return 0
-
-    try:
-        control_server = FdirManagerControlServer()
-        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)
-
-    return 0
-
-
-@cli.command()
-def stop():
-    """Send a 'quit_server' command to the Configuration Manager."""
-    with FdirManagerProxy() as fm:
-        sp = fm.get_service_proxy()
-        sp.quit_server()
-
-
-@cli.command()
-def status():
-    """Print the status of the control server."""
-    pass
-
-
-def check_prerequisites():
-    """ Checks if the recovery script location is defined and valid.
-
-        Raises:
-            RuntimeError.
-    """
-
-    location = CTRL_SETTINGS.RECOVERY_SCRIPT_LOCATION
-    location = replace_environment_variable(location)
-
-    if not location:
-        raise RuntimeError(
-            "The environment variable referenced in the Settings.yaml file for the "
-            "RECOVERY_SCRIPT_LOCATION of the FDIR control server does not exist, please set "
-            "the environment variable."
-        )
-
-    location = Path(location)
-
-    if not location.exists():
-        raise RuntimeError(
-            f"The directory {location} does not exist, provide a valid location for "
-            f"recovery scripts."
-        )
-
-    logger.debug(f"recovery script location = {location}")
-
-    location = CTRL_SETTINGS.LOGGING_LOCATION
-    location = replace_environment_variable(location)
-
-    if not location:
-        raise RuntimeError(
-            "The environment variable referenced in the Settings.yaml file for the "
-            "LOGGING_LOCATION of the FDIR control server does not exist, please set "
-            "the environment variable."
-        )
-
-    location = Path(location)
-
-    if not location.exists():
-        raise RuntimeError(
-            f"The directory {location} does not exist, provide a valid location for "
-            f"the log output of recovery scripts."
-        )
-
-    logger.debug(f"FDIR recovery script logging location = {location}")
-
-
-if __name__ == "__main__":
-
-    sys.exit(cli())

egse/fdir/fdir_manager_interface.py

@@ -1,15 +0,0 @@
-from egse.decorators import dynamic_interface
-
-class FdirManagerInterface:
-    """ Descriptions of the interface can be found in the corresponding yaml file. """
-    @dynamic_interface
-    def signal_fdir(self, fdir_code: int):
-        raise NotImplementedError
-
-    @dynamic_interface
-    def clear_fdir(self):
-        raise NotImplementedError
-
-    @dynamic_interface
-    def get_state(self):
-        raise NotImplementedError

egse/fdir/fdir_remote.py

@@ -1,73 +0,0 @@
-import logging
-
-from egse.command import ClientServerCommand
-from egse.control import ControlServer
-from egse.proxy import Proxy
-from egse.protocol import CommandProtocol
-from egse.settings import Settings
-from egse.zmq_ser import connect_address, bind_address
-from egse.system import format_datetime
-from egse.fdir.fdir_remote_interface import FdirRemoteInterface
-from egse.fdir.fdir_remote_controller import FdirRemoteController
-
-
-logger = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("FDIR Remote Control Server")
-DEVICE_SETTINGS = Settings.load(filename="fdir_remote.yaml")
-SITE_ID = Settings.load("SITE").ID
-
-
-class FdirRemoteCommand(ClientServerCommand):
-    pass
-
-
-class FdirRemoteProxy(Proxy, FdirRemoteInterface):
-    """ The FDIR Remote Proxy class is used to connect to the FDIR remote
-        control server. It should only be used by the fdir manager.
-    """
-
-    def __init__(
-        self,
-        protocol=CTRL_SETTINGS.PROTOCOL,
-        hostname=CTRL_SETTINGS.HOSTNAME,
-        port=CTRL_SETTINGS.COMMANDING_PORT,
-    ):
-        super().__init__(connect_address(protocol, hostname, port))
-
-
-class FdirRemoteProtocol(CommandProtocol):
-
-    def __init__(self, control_server: ControlServer):
-
-        super().__init__()
-
-        self.control_server = control_server
-        self.controller = FdirRemoteController()
-
-        self.load_commands(
-            DEVICE_SETTINGS.Commands,
-            FdirRemoteCommand,
-            FdirRemoteController,
-        )
-
-        self.build_device_method_lookup_table(self.controller)
-
-
-    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()
-
-
-    # The FDIR remote is stateless, so no HK.
-    def get_housekeeping(self):
-
-        return {"timestamp": format_datetime()}

egse/fdir/fdir_remote.yaml

@@ -1,30 +0,0 @@
-BaseClass:
-    egse.fdir.FdirRemoteInterface
-
-ProxyClass:
-    egse.fdir.FdirRemoteProxy
-
-ControlServerClass:
-    egse.alert.FdirRemoteControlServer
-
-ControlServer:
-    egse.fdir.fdir_remote_cs
-
-Commands:
-    is_connected:
-        description:
-        args:
-        cmd:                ""
-
-    is_simulator:
-        description:
-        args:
-        cmd:                ""
-
-    generate_popup:
-        description:        Generate a pop-up on the remote (client) machine to warn about an FDIR situation.
-        args:
-            code:           str | fdir code
-            actions:        str | list of actions performed (delimited by newlines)
-            success:        bool | whether the recovery script was executed successfuly
-        cmd:                "{code}{actions}{success}"

egse/fdir/fdir_remote_controller.py

@@ -1,30 +0,0 @@
-import os
-import logging
-import subprocess
-
-from egse.control import Response
-from egse.fdir.fdir_remote_interface import FdirRemoteInterface
-
-logger = logging.getLogger(__name__)
-
-
-class FdirRemoteController(FdirRemoteInterface):
-    def __init__(self):
-        self.dialog = None
-
-    def is_connected(self):
-        return True
-    
-    def is_simulator(self):
-        return False
-
-    def generate_popup(self, code: str, actions: str, success: bool) -> Response:
-        path = os.path.dirname(os.path.abspath(__file__))
-        subprocess.Popen(['python3', f'{path}/fdir_remote_popup.py', code, actions, str(success)])
-
-
-
-
-if __name__ == "__main__":
-    fdir = FdirRemoteController()
-    fdir.generate_popup("FDIR_CS_STOPPED", "rip", True)

egse/fdir/fdir_remote_cs.py

@@ -1,94 +0,0 @@
-import logging
-import multiprocessing
-import sys
-import click
-import zmq
-
-from prometheus_client import start_http_server
-
-from egse.settings import Settings
-from egse.control import ControlServer
-from egse.fdir.fdir_remote import FdirRemoteProtocol, FdirRemoteProxy
-
-logger = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("FDIR Remote Control Server")
-
-
-class FdirRemoteControlServer(ControlServer):
-
-
-    def __init__(self):
-        super().__init__()
-        self.device_protocol = FdirRemoteProtocol(self)
-        self.logger.debug(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)
-
-
-    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_storage_mnemonic(self):
-        try:
-            return CTRL_SETTINGS.STORAGE_MNEMONIC
-        except AttributeError:
-            return "FR"
-
-    def before_serve(self):
-        start_http_server(CTRL_SETTINGS.METRICS_PORT)
-
-
-@click.group()
-def cli():
-    pass
-
-
-@cli.command()
-def start():
-    """ Starts the FDIR Control Server. """
-
-    multiprocessing.current_process().name = "fdir_remote_cs"
-
-    try:
-        control_server = FdirRemoteControlServer()
-        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)
-
-    return 0
-
-
-@cli.command()
-def stop():
-    """Send a 'quit_server' command to the Configuration Manager."""
-    with FdirRemoteProxy() as fm:
-        sp = fm.get_service_proxy()
-        sp.quit_server()
-
-
-@cli.command()
-def status():
-    """Print the status of the control server."""
-    pass
-
-
-if __name__ == "__main__":
-
-    sys.exit(cli())

egse/fdir/fdir_remote_interface.py

@@ -1,9 +0,0 @@
-from egse.decorators import dynamic_interface
-from egse.control import Response
-
-
-class FdirRemoteInterface:
-    """ Descriptions of the interface can be found in the corresponding yaml file. """
-    @dynamic_interface
-    def generate_popup(self, code: int, actions, success) -> Response:
-        raise NotImplementedError

egse/fdir/fdir_remote_popup.py

@@ -1,26 +0,0 @@
-import logging
-import sys
-from argparse import ArgumentParser
-
-from egse.fdir import generate_popup
-
-# This function can be used generates a pop-up window when an FDIR situation was triggered.
-# This is put into a separate module to avoid having to run the QT thread in the control server
-# (where the popup is generated). There are probably better ways to do this but this works.
-def main():
-
-    logger = logging.getLogger(__name__)
-
-    parser = ArgumentParser()
-    parser.add_argument('code', type=str, help='FDIR code string')
-    parser.add_argument('success', type=str, help='recovery script success')
-    parser.add_argument('actions', type=str, help='actions taken')
-    args = parser.parse_args()
-    
-    generate_popup(args.code, args.success, args.actions)
-    
-
-
-if __name__ == '__main__':
-    main()
-    sys.exit()

egse/fee/__init__.py

@@ -1,106 +0,0 @@
-"""
-This module defines all functionality with respect to the FEE. It defines the structure of the FEE
-internal register map and the FEE housekeeping packet. The module also provides the FEE Simulator.
-
-Currently, only the N-FEE functionality is implemented in this module.
-"""
-from enum import IntEnum
-from typing import List
-
-from egse.setup import SetupError
-from egse.state import GlobalState
-
-
-def convert_ccd_order_list(value: List[int]):
-    """
-    Convert a list of CCD numbers into their binary representation that is used by the
-    register map of the N-FEE.
-
-    Examples:
-        >>> bin(convert_ccd_order_list([1,2,3,4]))
-        '0b1001110'
-        >>> bin(convert_ccd_order_list([2,2,4,4]))
-        '0b1011111'
-
-    Args:
-        value (List): a list of four CCD numbers in the range [1-4]
-
-    Returns:
-        The binary representation of the ccd_readout_order.
-
-    """
-    if len(value) != 4:
-        raise ValueError(f"Expected a list of four CCD numbers, got {value}")
-    if min(value) < 1 or max(value) > 4:
-        raise ValueError(f"Expected all CCD numbers in the range [1-4], got {value}")
-    try:
-        return sum(GlobalState.setup.camera.fee.ccd_numbering.CCD_ID_TO_BIN[ccd] << idx * 2
-                   for idx, ccd in enumerate(value))
-    except AttributeError:
-        raise SetupError("No entry in the setup for camera.fee.ccd_numbering.CCD_ID_TO_BIN")
-
-
-def convert_ccd_order_value(value: int):
-    """
-    Convert a binary representation of the CCD readout order (ccd_readout_order) into a list
-    of CCD numbers.
-
-    Examples:
-        >>> convert_ccd_order_value(228)
-        [3, 4, 1, 2]
-        >>> convert_ccd_order_value(0x4E)
-        [1, 2, 3, 4]
-
-    Args:
-        value (int): the CCD readout order as returned by the N-FEE
-
-    Returns:
-        A list of CCD numbers.
-    """
-
-    try:
-        return [GlobalState.setup.camera.fee.ccd_numbering.CCD_BIN_TO_ID[(value >> x) & 0b11] for x in [0, 2, 4, 6]]
-    except AttributeError:
-        raise SetupError("No entry in the setup for camera.fee.ccd_numbering.CCD_BIN_TO_ID")
-
-
-# The name of the of the enum class `fee_mode` is deliberately chosen in snake case,
-# although PEP8 prescribes the use of CamelCase for class names. The reason for this choice
-# is readability because the members of the enum are in all caps anyway.
-#
-# fee_mode.ON_MODE is more readable than NFEEMode.ON_MODE (IMHO)
-
-# noinspection PyPep8Naming
-
-# noinspection PyPep8Naming
-class fee_sync_mode(IntEnum):
-    """
-    The sync mode defines if the FEE is using external or internal synchronisation signals.
-    """
-
-    EXTERNAL = 0
-    INTERNAL = 1
-
-
-# noinspection PyPep8Naming
-class n_fee_mode(IntEnum):
-    """
-    Enumeration of the operating modes for the N-FEE.
-    """
-
-    ON_MODE = 0x0
-    FULL_IMAGE_PATTERN_MODE = 0x1
-    WINDOWING_PATTERN_MODE = 0x2
-    # NOT_DEFINED_MODE = 0x3
-    STAND_BY_MODE = 0x4
-    FULL_IMAGE_MODE = 0x5
-    WINDOWING_MODE = 0x6
-    PERFORMANCE_TEST_MODE = 0x7
-    IMMEDIATE_ON_MODE = 0x8
-    PARALLEL_TRAP_PUMPING_1_MODE = 0x9
-    PARALLEL_TRAP_PUMPING_2_MODE = 0xA
-    SERIAL_TRAP_PUMPING_1_MODE = 0xB
-    SERIAL_TRAP_PUMPING_2_MODE = 0xC
-    # RESERVED_MODE = 0xD
-    # RESERVED_MODE = 0xE
-    # RESERVED_MODE = 0xF