entrypoint.py

Go to the documentation of this file.

"""
@file
@ingroup daq_metadaqifsim
@copyright 2021 ESO - European Southern Observatory
"""
# pylint: disable=no-name-in-module,import-error,invalid-name
import argparse
import signal
import logging
import threading
import elt.pymal as pymal
 
from ModDaqsimif.Daqsimif.SimCtl import SimCtlSyncService
 
from . import __version__
from . import simulator
 
 
def LoadMalForUri(uri, malSpecificProperties):
    """Load MAL mapping based on the first three characters of the uri
       @param uri string uri
       @param malSpecificProperties map of properties to use to initialize mapping
       @return reference to mal.CiiFactory instance
       @throw RuntimeError when mapping could not be loaded
    """
    scheme = uri[0:3]
    malName = scheme
    if malName == 'opc':
        malName = 'opcua'
    mal = pymal.loadMal(malName, malSpecificProperties)
    factory = pymal.CiiFactory.getInstance()
    factory.registerMal(scheme, mal)
    return mal, factory
 
 
def main(args):  # pylint: disable=unused-argument,too-many-locals
    """Main entrypoint for simulator
    """
    logger = logging.getLogger("metadaqsim")
 
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--version",
        action="version",
        version="%(prog)s " "{version}".format(version=__version__),
        help="print version number and exit",
    )
    parser.add_argument(
        "-v",
        "--verbose",
        action="count",
        default=0,
        help="set the verbosity level: -v INFO, -vv DEBUG",
    )
    parser.add_argument(
        "name",
        help="server process name/id",
    )
    parser.add_argument(
        "uri",
        help="server URI where simulator will accept requests, without the service path",
    )
 
    # Parse basic arguments to set up logging
    main_args, _ = parser.parse_known_args()
    verbose = main_args.verbose
    level = logging.WARNING
    if verbose >= 1:
        level = logging.INFO
    if verbose >= 2:
        level = logging.DEBUG
    # Configure console logging:
    if main_args.verbose > 0 and False:
        chdlr = logging.StreamHandler()
        if verbose == 1:
            chdlr.setFormatter(logging.Formatter("%(levelname)s: %(message)s"))
        else:
            chdlr.setFormatter(
                logging.Formatter("%(name)s: %(levelname)s: %(message)s")
            )
        chdlr.setLevel(level)
        logging.getLogger().addHandler(chdlr)
 
    logging.basicConfig(level=level, format="%(levelname)s: %(message)s")
    logger.info("Started metadaqsim %s", __version__)
 
    name = main_args.name
    uri = main_args.uri
    mal, factory = LoadMalForUri(uri, {})
 
    logger.info("Creating server mal")
    with factory.createServer(uri, pymal.rr.qos.DEFAULT, {}) as server:
        try:
            def shutdown(signum, frame):  # pylint: disable=unused-argument
                logger.info("Closing server due to signal %d", signum)
                server.close()
 
            signal.signal(signal.SIGINT, shutdown)
            signal.signal(signal.SIGTERM, shutdown)
 
            sim_ctl = simulator.SimulatorCtl(name, mal, server)
 
            try:
                logger.info("Registering service 'simctl' on %s", uri)
                server.registerService("simctl", SimCtlSyncService, sim_ctl)
 
                logger.info("Running server...")
 
                # Run mal in different thread to avoid it stealing signals.
                # In addition it deadlocks when trying to shut down.
                def run():
                    server.run()
 
                thr = threading.Thread(target=run, daemon=True)
                thr.start()
                thr.join()
                logger.info("Server done.")
                return 0
            except Exception:
                logging.exception("Exception")
                return -2
        except Exception:
            logging.exception("Exception")
            return -1