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

egse/fdir/fdir_manager_controller.py

@@ -1,228 +0,0 @@
-import os
-import re
-import logging
-import psutil
-import subprocess
-
-from threading import Thread
-from datetime import datetime
-
-import yaml
-
-from PyQt5.QtWidgets import QMessageBox, QApplication, QDialog, QLabel, QVBoxLayout
-
-from egse.setup import load_setup
-from egse.settings import Settings
-from egse.setup import get_setup
-from egse.system import replace_environment_variable
-from egse.control import Success
-from egse.fdir.fdir_remote_interface import FdirRemoteInterface
-from egse.fdir.fdir_remote import FdirRemoteProxy
-from egse.fdir import generate_popup
-
-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._local_pids = []
-        self._remote_pids = []
-        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")
-            # raise RuntimeError("FDIR Manager could not connect the the FDIR Remote CS")
-        else:
-            logger.info(f"connected to remote CS @ {REMOTE_SETTINGS.HOSTNAME}")
-
-        # Try to load fdir table.
-        try:
-            self._fdir_table = load_setup().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 register_script(self, host: str, pid: int):
-
-        if self._state != 0:
-            logger.error(f"Attempt to register script while state is not idle ({self._state}).")
-            raise FdirException(
-                f"Cannot register script because FDIR state is not idle ({self._state}).")
-
-        elif host in ['localhost', os.uname()[1]]:
-
-            if pid in self._local_pids:
-                logger.error(f"Attempt to register existing PID {pid} @ localhost.")
-                raise FdirException("PID is already registered.")
-            else:
-                self._local_pids.append(pid)
-                logger.info(f"Successful registration of PID {pid} @ localhost.")
-
-        elif host == REMOTE_SETTINGS.HOSTNAME:
-
-            if pid in self._remote_pids:
-                logger.error(f"Attempt to register existing PID {pid} @ {host}.")
-                raise FdirException("PID is already registered.")
-            else:
-                self._remote_pids.append(pid)
-                logger.info(f"Successful registration of PID {pid} @ {host}.")
-
-        else:
-            logger.error(f"Attempt to register a script with unknown hostname ({host})")
-            raise FdirException("unknown hostname")
-
-
-    def deregister_script(self, host: str, pid: int):
-
-        if host in ['localhost', os.uname()[1]]:
-
-            if pid not in self._local_pids[host]:
-                logger.error(f"Attempt to deregister unknown PID {pid} @ localhost.")
-                raise FdirException("PID is unknown.")
-            else:
-                self._pids[host].remove(pid)
-                logger.info(f"Successful deregistration of PID {pid} @ localhost.")
-
-        if host == REMOTE_SETTINGS.HOSTNAME:
-
-            if pid not in self._local_pids[host]:
-                logger.error(f"Attempt to deregister unknown PID {pid} @ {host}.")
-                raise FdirException("PID is unknown.")
-            else:
-                self._pids[host].remove(pid)
-                logger.info(f"Successful deregistration of PID {pid} @ {host}.")
-
-        else:
-            logger.error(f"attempt to deregister a script with unknown hostname ({host})")
-            raise FdirException("unknown hostname")
-
-
-    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
-
-        # kill registered local scripts
-        for pid in self._local_pids:
-            try:
-                process = psutil.Process(pid)
-            except psutil.NoSuchProcess:
-                logger.warning(
-                    f"Could not find a process with PID {pid} @ localhost.")
-            else:
-                process.kill()
-                logger.info(f"Killed registered script with PID {pid} @ localhost.")
-
-        # Kill registered remote scripts
-        for pid in self._remote_pids:
-            response = self._remote_proxy.kill_process(pid)
-            if isinstance(response, Success):
-                logger.info(f"Killed registered script with PID {pid} @ {REMOTE_SETTINGS.HOSTNAME}.")
-            else:
-                logger.warning(
-                    f"Could not kill process with PID {pid} @ {REMOTE_SETTINGS.HOSTNAME}.")
-
-        # Clear all stored PIDs
-        self._local_pids = []
-        self._remote_pids = []
-
-        # 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,25 +0,0 @@
-from egse.decorators import dynamic_interface
-from egse.control import Response, Success
-
-class FdirManagerInterface:
-    """ Descriptions of the interface can be found in the corresponding yaml file. """
-
-    @dynamic_interface
-    def register_script(self, host: str, pid: int):
-        raise NotImplementedError
-
-    @dynamic_interface
-    def deregister_script(self, host: str, pid: int):
-        raise NotImplementedError
-
-    @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,37 +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:                ""
-
-    kill_process:
-        description:        Instruct the CS to kill a process (test script).
-        args:
-            pid:            int | process ID of the script
-        cmd:                "{pid}"
-
-
-    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,50 +0,0 @@
-import os
-import sys
-import logging
-import psutil
-import subprocess
-import threading
-import time
-
-from PyQt5.QtWidgets import QMessageBox, QApplication
-
-from egse.control import Response, Success, Failure
-from egse.fdir.fdir_remote_interface import FdirRemoteInterface
-# from egse.fdir.fdir_manager import FdirManagerProxy
-
-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 kill_process(self, pid: int) -> Response:
-
-        try:
-            process = psutil.Process(pid)
-        except psutil.NoSuchProcess:
-            logger.warning(f"Could not find a process with PID {pid}.")
-            return Failure(f"Could not find a process with PID {pid}.")
-        else:
-            process.kill()
-            logger.info(f"Killed registered script with PID {pid}.")
-            return Success("")
-
-    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,97 +0,0 @@
-import logging
-import multiprocessing
-import sys
-from pathlib import Path
-
-from PyQt5.QtWidgets import QApplication
-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_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,14 +0,0 @@
-from egse.decorators import dynamic_interface
-from egse.control import Response, Success
-
-
-class FdirRemoteInterface:
-    """ Descriptions of the interface can be found in the corresponding yaml file. """
-
-    @dynamic_interface
-    def kill_process(self, pid: int) -> Response:
-        raise NotImplementedError
-
-    @dynamic_interface
-    def generate_popup(self, code: int, actions, success) -> Response:
-        raise NotImplementedError