ariel-facility 0.17.4__py3-none-any.whl

ariel_facility/cgse_explore.py

@@ -0,0 +1,19 @@
+__all__ = [
+    "show_processes",
+]
+
+import re
+
+from egse.process import ProcessInfo
+from egse.process import get_processes
+
+
+def show_processes():
+    """Returns of list of ProcessInfo data classes for matching processes from this package."""
+
+    def filter_procs(pi: ProcessInfo):
+        pattern = r"facility_hk"
+
+        return re.search(pattern, pi.command)
+
+    return get_processes(filter_procs)

ariel_facility/cgse_services.py

@@ -0,0 +1,46 @@
+import subprocess
+import sys
+
+import rich
+import typer
+
+from egse.system import all_logging_disabled
+from egse.system import redirect_output_to_log
+
+facility_hk = typer.Typer(name="facility_hk", help="Housekeeping from Facility Database")
+
+
+@facility_hk.command(name="start")
+def start_facility_hk():
+    """Starts the extraction of HK from the facility DB into TA-EGSE CSV files."""
+
+    rich.print("Starting the extraction of HK from the facility DB into TA-EGSE CSV files")
+
+    out = redirect_output_to_log("facility_hk.start.log")
+
+    cmd = [sys.executable, "-m", "egse.ariel.facility.hk", "start"]
+
+    subprocess.Popen(cmd, stdout=out, stderr=out, stdin=subprocess.DEVNULL, close_fds=True)
+
+
+@facility_hk.command(name="stop")
+def stop_facility_hk():
+    """Stops the extraction of HK from the facility DB into TA-EGSE CSV files."""
+
+    rich.print("Terminating the extraction of HK from the facility DB into TA-EGSE CSV files")
+
+    out = redirect_output_to_log("facility_hk.stop.log")
+
+    cmd = [sys.executable, "-m", "egse.ariel.facility.hk", "stop"]
+
+    subprocess.Popen(cmd, stdout=out, stderr=out, stdin=subprocess.DEVNULL, close_fds=True)
+
+
+@facility_hk.command(name="status")
+def status_facility_hk():
+    """Prints status information the extraction of HK from the facility DB into TA-EGSE CSV files."""
+
+    with all_logging_disabled():
+        from egse.ariel.facility import hk
+
+        hk.status()

ariel_facility/settings.yaml

@@ -0,0 +1,20 @@
+Facility HK:
+    HOSTNAME:                  localhost
+    PROTOCOL:                        tcp
+    COMMANDING_PORT:                   0     # Port on which the controller listens to commands (REQ-REP)
+    MONITORING_PORT:                   0     # Port on which the controller sends periodic status information about the device (PUB-SUB)
+    SERVICE_PORT:                      0     # Port on which the controller listens for configuration and administration (REQ-REP)
+    METRICS_PORT:                      0
+    STORAGE_MNEMONIC:           FACILITY
+    SERVICE_NAME:            FACILITY_HK
+    SERVICE_TYPE:            FACILITY_HK
+    TABLES:                                       # Table name: (storage mnemonic, server ID)
+        TABLE1:        (ORIGIN1, SERVER_ID_1)
+        TABLE2:        (ORIGIN2, SERVER_ID_2)
+
+
+Facility DB:
+    HOST:                      localhost
+    PORT:                           3306
+    USER:                            TBD
+    PASSWORD:                        TBD

ariel_facility-0.17.4.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: ariel-facility
+Version: 0.17.4
+Summary: Extract HK from MySQL Facility Database for Ariel
+Author: IVS KU Leuven
+Maintainer-email: Rik Huygen <rik.huygen@kuleuven.be>, Sara Regibo <sara.regibo@kuleuven.be>
+License-Expression: MIT
+Keywords: Ariel,facility,hardware testing,housekeeping,software framework
+Requires-Python: >=3.10
+Requires-Dist: cgse-common
+Requires-Dist: cgse-core
+Requires-Dist: cgse-gui
+Requires-Dist: crcmod>=1.7
+Requires-Dist: mysql-replication
+Requires-Dist: pyserial>=3.5

ariel_facility-0.17.4.dist-info/RECORD

@@ -0,0 +1,11 @@
+ariel_facility/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ariel_facility/cgse_explore.py,sha256=PoFRRhbdQ4p_pOOQV4f2QIDcDHlEZTKb_6VgNj15sY4,404
+ariel_facility/cgse_services.py,sha256=xL4n4zp1GqIfori0UTR7US5q-Qn2TrhF-icpv7p5mZE,1419
+ariel_facility/settings.yaml,sha256=zqqYdLLz4lJWE67_K1EtsNqMPJSb8YRZxR_zrp6T8Oo,997
+egse/ariel/facility/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+egse/ariel/facility/database.py,sha256=qBvZ6N6VDV4I_JY96xh7xlxIQbCcEoJCBEpjccIu_Qc,8609
+egse/ariel/facility/hk.py,sha256=kt9nQaBbVt2FC2pSOb1ZajC2Be34lrG9DrR80kOD_OM,12095
+ariel_facility-0.17.4.dist-info/METADATA,sha256=dVn8e6Cpbcxv-xMzqKNE52Rc7qht-VkBkliE_hJ84KI,520
+ariel_facility-0.17.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+ariel_facility-0.17.4.dist-info/entry_points.txt,sha256=D3dZ85nQSUbUdMRZYbFBKFL0xH39pNOCPXSg_tmflx8,330
+ariel_facility-0.17.4.dist-info/RECORD,,

ariel_facility-0.17.4.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

ariel_facility-0.17.4.dist-info/entry_points.txt

@@ -0,0 +1,14 @@
+[console_scripts]
+facility_hk = egse.ariel.facility.hk:app
+
+[cgse.explore]
+explore = ariel_facility.cgse_explore
+
+[cgse.service.device_command]
+facility_hk = ariel_facility.cgse_services:facility_hk
+
+[cgse.settings]
+ariel-facility = ariel_facility:settings.yaml
+
+[cgse.version]
+ariel-facility = egse.version:get_version_installed

egse/ariel/facility/database.py

@@ -0,0 +1,214 @@
+"""
+Part of the housekeeping acquired during the Ariel TA test campaign at CSL will be stored directly into the MySQL
+facility database.  This module enables watching specific tables in that database for new entries.  The goal is to
+store those into the dedicated CSV files for the TA-EGSE framework.
+"""
+
+import threading
+from datetime import datetime
+
+from egse.confman.confman_cs import load_setup
+from egse.hk import read_conversion_dict, convert_hk_names
+from egse.log import egse_logger
+from egse.system import str_to_datetime, format_datetime
+from egse.metrics import get_metrics_repo
+from egse.settings import Settings, get_site_id
+from pymysqlreplication import BinLogStreamReader
+from pymysqlreplication.row_event import WriteRowsEvent
+from urllib3.exceptions import NewConnectionError
+import os
+
+from egse.storage import StorageProxy
+
+LOGGER = egse_logger
+SITE_ID = get_site_id()
+FACILITY_DB_SETTINGS = Settings.load("Facility DB")
+
+ID_COLUMN_NAME = "measure_id"
+TIMESTAMP_COLUMN_NAME = "measure_timestamp"
+VALUE_COLUMN_NAME = "measure_value"
+
+
+class DatabaseTableWatcher:
+    def __init__(self, table_name: str, origin: str, server_id: int):
+        """Initialisation of a watcher for a specific table in the facility database.
+
+        The watcher is a daemon thread the watches the specified table in the facility database for new entries.  If
+        a new entry is encountered, it will be sent to the Storage Manager, which will store it in the HK file for the
+        given storage mnemonic.
+
+        Args:
+            table_name (str): Name of the table in the facility database.
+            origin (str): Storage mnemonic for the data in the TA-EGSE framework.
+            server_id (int): Unique identifier for the MySQL binlog stream reader.
+        """
+
+        self.table_name = table_name
+        self.origin = origin
+        self.server_id = server_id
+
+        # noinspection PyBroadException
+        try:
+            self.hk_conversion_dict = read_conversion_dict(self.origin, use_site=False, setup=load_setup())
+        except:
+            self.hk_conversion_dict = None
+
+        # Make a thread and let it start watching the specified table in the facility database
+
+        self.watch_thread = threading.Thread(target=self.watch_db_table)
+        self.watch_thread.daemon = True
+        self.keep_watching = True
+
+        # Metrics client
+
+        token = os.getenv("INFLUXDB3_AUTH_TOKEN")
+        project = os.getenv("PROJECT")
+
+        if project and token:
+            self.metrics_client = get_metrics_repo(
+                "influxdb", {"host": "http://localhost:8181", "database": project, "token": token}
+            )
+            self.metrics_client.connect()
+        else:
+            self.metrics_client = None
+            LOGGER.warning(
+                "INFLUXDB3_AUTH_TOKEN and/or PROJECT environment variable is not set.  Metrics will not be propagated "
+                "to InfluxDB."
+            )
+
+    def start_watching_db_table(self):
+        """Starts the thread that checks for new entries in the specified table in the facility database."""
+
+        self.keep_watching = True
+        self.watch_thread.start()
+
+    def stop_watching_db_table(self):
+        """Stops the thread that checks for new entries in the specified table in the facility database."""
+
+        self.keep_watching = False
+        self.watch_thread.join()
+
+    def watch_db_table(self):
+        """Lets the thread watch for new entries in the specified table in the facility database.
+
+        If a new entry is encountered, it will be sent to the Storage Manager, which will store it in the HK file for
+        the specified storage mnemonic.
+        """
+
+        # Connect to the (MySQL) facility database -> Start watching the specified table
+
+        mysql_settings = {
+            "host": FACILITY_DB_SETTINGS.HOST,
+            "port": FACILITY_DB_SETTINGS.PORT,
+            "user": FACILITY_DB_SETTINGS.USER,
+            "passwd": FACILITY_DB_SETTINGS.PASSWORD,
+        }
+
+        stream: BinLogStreamReader = BinLogStreamReader(
+            connection_settings=mysql_settings,
+            server_id=self.server_id,  # Unique identifier per Python client watching the MySQL facility database
+            blocking=True,
+            only_events=[WriteRowsEvent],  # Watch for new row entries
+            only_tables=[self.table_name],  # Watch for changes in the specified table
+        )
+
+        while self.keep_watching:
+            for bin_log_event in stream:
+                for row in bin_log_event.rows:
+                    values = row["values"]  # Dictionary with the column names (from the facility database) as keys
+                    hk = self.translate_parameter_names(values)  # Convert to TA-EGSE-consistent names
+                    self.store_housekeeping_information(hk)
+                    self.propagate_metrics(hk)
+
+        stream.close()
+
+    def translate_parameter_names(self, hk: dict):
+        """Converts the parameter names from the facility database to TA-EGSE-consistent names.
+
+        Args:
+            hk (dict): Dictionary with the column names (from the facility database) as keys.
+
+        Returns:
+            Dictionary with the TA-EGSE-consistent names as keys.
+        """
+
+        # Timestamp
+
+        # noinspection PyUnresolvedReferences
+        hk["timestamp"] = format_datetime(
+            datetime.datetime.fromtimestamp(hk[TIMESTAMP_COLUMN_NAME], datetime.UTC)
+        )  # Unix time -> datetime [UTC]
+        del hk[TIMESTAMP_COLUMN_NAME]
+
+        # Delete identifier of the entry
+
+        del hk[ID_COLUMN_NAME]
+
+        # Parameter value
+
+        hk[self.table_name] = hk[VALUE_COLUMN_NAME]
+        del hk[VALUE_COLUMN_NAME]
+
+        if self.hk_conversion_dict:
+            return convert_hk_names(hk, self.hk_conversion_dict)
+        else:
+            return hk
+
+    def store_housekeeping_information(self, hk: dict):
+        """Sends the given housekeeping information to the Storage Manager.
+
+        The housekeeping is passed as a dictionary, with the parameter names as keys.  There's also an entry for the
+        timestamp, which represents the date/time at which the value was received.
+
+        Args:
+            hk (dict): Housekeeping that was extracted from the facility database, after converting the parameter names
+                       to TA-EGSE-consistent names.
+        """
+
+        try:
+            with StorageProxy() as storage:
+                response = storage.save({"origin": self.origin, "data": hk})
+                if not response.successful:
+                    LOGGER.warning(
+                        f"Couldn't save facility data to the Storage manager for {self.origin}, cause: {response}"
+                    )
+        except ConnectionError as exc:
+            LOGGER.warning(
+                f"Couldn't connect to the Storage Manager to store facility housekeeping for {self.origin}: {exc}"
+            )
+            raise
+
+    def propagate_metrics(self, hk: dict):
+        """Propagates the given housekeeping information to the metrics database.
+
+        The housekeeping is passed as a dictionary, with the parameter names as keys.  There's also an entry for the
+        timestamp, which represents the date/time at which the value was received.  In case only the timestamp is
+        present in the dictionary, nothing will be written to the metrics database.
+
+        Args:
+            hk (dict): Housekeeping that was extracted from the facility database, after converting the parameter names
+                       to TA-EGSE-consistent names.
+        """
+
+        if not [x for x in hk if x != "timestamp"]:
+            LOGGER.debug(f"no metrics defined for {self.origin}")
+            return
+
+        try:
+            if self.metrics_client:
+                point = {
+                    "measurement": self.origin.lower(),
+                    "tags": {"site_id": SITE_ID, "origin": self.origin},
+                    "fields": {hk_name.lower(): hk[hk_name] for hk_name in hk if hk_name != "timestamp"},
+                    "time": str_to_datetime(hk["timestamp"]),
+                }
+                self.metrics_client.write(point)
+            else:
+                LOGGER.warning(
+                    f"Could not write {self.origin} metrics to the time series database (self.metrics_client is None)."
+                )
+        except NewConnectionError:
+            LOGGER.warning(
+                f"No connection to the time series database could be established to propagate {self.origin} metrics.  "
+                f"Check whether this service is (still) running."
+            )

egse/ariel/facility/hk.py

@@ -0,0 +1,341 @@
+from typing import Any
+
+import sys
+
+from egse.hk import read_conversion_dict
+from egse.log import egse_logger
+from egse.registry.client import RegistryClient
+from egse.settings import Settings
+import zmq
+import pickle
+from egse.ariel.facility.database import DatabaseTableWatcher
+import typer
+import rich
+
+from egse.setup import load_setup
+from egse.storage import register_to_storage_manager, TYPES, is_storage_manager_active, StorageProxy
+from egse.system import get_host_ip
+from egse.zmq_ser import connect_address, get_port_number, bind_address
+
+LOGGER = egse_logger
+CTRL_SETTINGS = Settings.load("Facility HK")
+
+TIMEOUT_RECV = 1.0  # seconds
+ORIGIN_LIST = {"TCU": "TCU_TABLE", "LAKESHORE": "LAKESHORE_TABLE"}
+
+
+class FacilityHousekeepingExporter:
+    def __init__(self):
+        """Initialisation of a facility HK exporter.
+
+        This process will extract HK from the facility database, store it in TA-EGSE-consistent CSV files and ingest it
+        into the metrics database.
+
+        Upon initialisation, the following actions are performed:
+
+            - From the settings file, we read which tables in the facility database have to be watched for new entries
+              (one table per sensor).  In this file, we also configure which is the corresponding storage mnemonic that
+              will be used by the Storage Manager.
+            - For each selected table, a dedicated watcher is defined.  It is the task of the watcher to keep an eye
+              on its database table, extract new entries, pass them to the Storage Manager (with the corresponding
+              storage mnemonics), and ingest it into the metrics database.
+            - Register the process to the registry client.  This way we can find back its host and ports (which is
+              required when using dynamic port allocation), and report its status.
+            - We will probably store the data from multiple sensors in the same file.  We therefore need to pass on to
+              the Storage Manager which origin will receives and store which column names.  If we don't do this, we end
+              up with corrupt CSV files.
+        """
+
+        self.watchers = {}
+
+        # Define a watcher for the tables listed in the settings
+        # Keep track of all (unique) storage mnemonics / origins (to collect the corresponding column names)
+
+        self.origins = []
+
+        for table_name in CTRL_SETTINGS.TABLES:
+            origin, server_id = CTRL_SETTINGS.TABLES[table_name]
+            self.origins.append(origin)
+            self.watchers[table_name] = DatabaseTableWatcher(table_name, origin, server_id)
+
+        self.origins = list(set(self.origins))  # Remove duplicates
+
+        self.keep_extracting = True
+        print(f"Keep extracting: {self.keep_extracting}")
+
+        # Create ZeroMQ socket for commanding
+
+        self.zmq_context = zmq.Context.instance()
+        self.cmd_socket = self.zmq_context.socket(zmq.REP)
+        endpoint = bind_address(CTRL_SETTINGS.PROTOCOL, CTRL_SETTINGS.COMMANDING_PORT)
+        self.cmd_socket.bind(endpoint)  # Bind the socket to the endpoint -> Port allocation happens here
+
+        # Registration to the registry client
+
+        self.registry = RegistryClient()
+        self.registry.connect()
+        self.register_service()
+
+        # Register to the Storage Manager (pass the columns names for each storage mnemonic)
+
+        self.register_to_storage_manager()
+
+    def run(self):
+        """Starts watching for changes in the specified tables in the facility database."""
+
+        watcher: DatabaseTableWatcher
+
+        poller = zmq.Poller()
+        poller.register(self.cmd_socket, zmq.POLLIN)
+
+        # Start watching the tables
+
+        for _, watcher in self.watchers.items():
+            watcher.start_watching_db_table()
+
+        try:
+            while self.keep_extracting:
+                print("Keep extracting")
+
+                # Keep on listening for `quit` command
+                if _check_commander_status(self.cmd_socket, poller):
+                    self.keep_extracting = False
+                    break
+
+        except KeyboardInterrupt:
+            LOGGER.info("KeyboardInterrupt caught")
+
+        self.keep_extracting = False
+
+        # De-registration from the registry client
+
+        self.deregister_service()
+
+        # Close the commanding socket
+
+        poller.unregister(self.cmd_socket)
+        self.cmd_socket.close(linger=0)
+
+        # Stop watching the tables listed in the settings
+
+        for _, watcher in self.watchers.items():
+            watcher.stop_watching_db_table()
+
+        # De-registration from the Storage Manager
+
+        self.unregister_from_storage_manager()
+
+    def register_service(self) -> None:
+        """Registers the FacilityHousekeepingExporter to the Registry Client."""
+
+        self.registry.stop_heartbeat()
+        self.registry.register(
+            name=CTRL_SETTINGS.SERVICE_NAME.lower(),
+            host=get_host_ip() or "127.0.0.1",
+            port=get_port_number(self.cmd_socket),
+            service_type=CTRL_SETTINGS.SERVICE_TYPE.lower(),
+        )
+        self.registry.start_heartbeat()
+
+    def deregister_service(self) -> None:
+        """De-registers the FacilityHousekeepingExporter from the Registry Client."""
+
+        if self.registry:
+            self.registry.stop_heartbeat()
+            self.registry.deregister()
+            self.registry.close()
+
+    @staticmethod
+    def register_to_storage_manager() -> None:
+        """Registers the origins to the Storage Manager.
+
+        Each sensor has its own table in the facility database.  In the TA-EGSE framework, we want to offer the option
+        to store data from multiple sensors in the same file.  Therefore we must register - for each storage
+        mnemonic - which are all the possible column names.  Note that the column names in the CSV files do not
+        necessarily correspond to the table names in the facility database.  This is configured in the telemetry
+        dictionary.
+        """
+
+        if is_storage_manager_active():
+            storage_registrations = {}
+
+            # Data from which table in the facility database should be extracted and stored under which storage mnemonic?
+
+            for table_name, (origin, _) in CTRL_SETTINGS.TABLES.items():
+                storage_registrations.setdefault(origin, []).append(table_name)
+
+            # The column names in the CSV files do not necessarily correspond to the table names in the facility
+            # database.  This is configured in the telemetry dictionary.
+
+            for origin, table_names in storage_registrations.items():
+                # noinspection PyBroadException
+                try:
+                    hk_conversion_dict = read_conversion_dict(origin, use_site=False, setup=load_setup())
+                    column_names = [hk_conversion_dict[table_name] for table_name in table_names]
+                except:
+                    column_names = table_names
+
+                # Make sure there is also a column (the first one) for the timestamp
+
+                column_names = ["timestamp"] + column_names
+
+                register_to_storage_manager(
+                    origin=origin,
+                    persistence_class=TYPES["CSV"],
+                    prep={
+                        "column_names": column_names,
+                        "mode": "a",
+                    },
+                )
+        else:
+            LOGGER.warning("The Storage Manager is not active")
+            raise
+
+    def unregister_from_storage_manager(self) -> None:
+        """De-registers all storage mnemonics for the facility database from the Storage Manager."""
+
+        if is_storage_manager_active():
+            try:
+                with StorageProxy() as proxy:
+                    for origin in self.origins:
+                        response = proxy.unregister({"origin": origin})
+                        if not response.successful:
+                            LOGGER.warning(f"Couldn't unregister {origin} from the Storage Manager: {response}")
+                        else:
+                            LOGGER.info(response)
+            except ConnectionError as exc:
+                LOGGER.warning(f"Couldn't connect to the Storage Manager for de-registration: {exc}")
+                raise
+        else:
+            LOGGER.warning("The Storage Manager is not active")
+            raise
+
+
+def _check_commander_status(commander, poller: zmq.Poller) -> bool:
+    """Checks the status of the commander.
+
+    Checks whether a command has been received by the given commander.
+
+    Args:
+        commander: Commanding socket for the FOV HK generation.
+        poller (zmq.Poller): Poller for the FOV HK generation.
+
+    Returns: True if a quit command was received; False otherwise.
+    """
+
+    socks = dict(poller.poll(timeout=5000))  # Timeout of 5s
+
+    if commander in socks:
+        pickle_string = commander.recv()
+        command = pickle.loads(pickle_string)
+
+        if command.lower() == "quit":
+            commander.send(pickle.dumps("ACK"))
+            return True
+
+        if command.lower() == "status":
+            response = dict(status="ACK", host=CTRL_SETTINGS.HOSTNAME, command_port=CTRL_SETTINGS.COMMANDING_PORT)
+            commander.send(pickle.dumps(response))
+
+        return False
+
+    return False
+
+
+def send_request(command_request: str) -> Any:
+    """Sends a request to the FacilityHousekeepingExporter process and wait for a response.
+
+    Args:
+        command_request (str): Request.
+
+    Returns: Response to the request.
+    """
+
+    with RegistryClient() as registry:
+        service = registry.discover_service(CTRL_SETTINGS.SERVICE_TYPE.lower())
+
+        if service:
+            protocol = service.get("protocol", "tcp")
+            hostname = service["host"]
+            port = service["port"]
+            endpoint = connect_address(protocol, hostname, port)
+
+            ctx = zmq.Context().instance()
+            socket = ctx.socket(zmq.REQ)
+            socket.connect(endpoint)
+
+            socket.send(pickle.dumps(command_request))
+            rlist, _, _ = zmq.select([socket], [], [], timeout=TIMEOUT_RECV)
+
+            if socket in rlist:
+                response = socket.recv()
+                response = pickle.loads(response)
+            else:
+                response = {"error": "Receive from ZeroMQ socket timed out for FacilityHousekeepingExporter."}
+            socket.close(linger=0)
+
+            return response
+
+        else:
+            return None
+
+
+app = typer.Typer()
+
+
+@app.command()
+def start() -> None:
+    """Starts the FacilityHousekeepingExporter."""
+
+    try:
+        rich.print("Starting the FacilityHousekeepingExporter")
+        FacilityHousekeepingExporter().run()
+    except KeyboardInterrupt:
+        print("Shutdown requested... exiting")
+    except SystemExit as exc:
+        exit_code = exc.code if hasattr(exc, "code") else 0
+        print(f"System Exit with code {exit_code}")
+        sys.exit(exit_code)
+    except Exception as exc:
+        LOGGER.exception(f"Cannot start FacilityHousekeepingExporter: {exc}")
+
+
+@app.command()
+def stop() -> None:
+    """Stops the FacilityHousekeepingExporter."""
+
+    response = send_request("quit")
+
+    if response == "ACK":
+        rich.print("FacilityHousekeepingExporter successfully terminated.")
+    else:
+        rich.print(f"[red] ERROR: {response}")
+
+
+@app.command()
+def status() -> None:
+    """Prints the status of the FacilityHousekeepingExporter."""
+
+    rich.print("FacilityHousekeepingExporter:")
+
+    response = send_request("status")
+
+    if response and response.get("status") == "ACK":
+        rich.print("  Status: [green]active")
+        rich.print(f"  Hostname: {response.get('host')}")
+        rich.print(f"  Commanding port: {response.get('command_port')}")
+    else:
+        rich.print("  Status: [red]not active")
+
+    with RegistryClient() as registry:
+        registry.list_services()
+
+
+if __name__ == "__main__":
+    import logging
+
+    from egse.logger import set_all_logger_levels
+
+    set_all_logger_levels(logging.DEBUG)
+
+    sys.exit(app())