simulator.py

Go to the documentation of this file.

"""
@file
@ingroup daq_sim_recif
@copyright 2021 ESO - European Southern Observatory
 
@brief Implements simulation of recdaqif
"""
# pylint: disable=no-name-in-module,import-error,no-self-use,redefined-builtin
import os
import json
import logging
import inspect
 
from ModRecif.Recif import (
    RecStatus,
    RecStatusNames,
    RecProperties,
    RecWaitSpec,
    RecWaitStatus,
    RecWaitStatusNames,
    ExceptionErr,
)
 
from ModRecif.Recif.RecCmds import RecCmdsSyncService
from ModDaqsimif.Daqsimif import Error as SimCtlError
 
 
class Recording:  # pylint: disable=too-many-instance-attributes,invalid-name
    """Holds simulated status for recording"""
 
    def __init__(self, id):
        self.id = id
        self.dp_files = []
        self.files_generated = 0
        self.start_time = 1.0
        self.end_time = 1.0
        self.time_elapsed = 0.0
        self.remaining_time = 1.0
        self.frames_processed = 0
        self.frames_remaining = 1
        self.size_recorded = 0
        self.info = ""
        self.status = RecStatusNames.Undefined
 
 
class Simulator:  # pylint: disable=invalid-name
    """Simulator that implements RecCmdsSyncService and sets up
    simulation behaviour for Simulator.
 
    Registered hooks are run once and then removed before executed.
    Each hook is a callable that takes the result from the default implementation
    as well as the arguments given to the original implementation.
    The hook can then choose to modify the existing result or replace it.
    """
 
    def __init__(self, name, mal):
        self.name = name
        self.mal = mal
        self.current_rec = None
        self.recordings = {}  # id: status
        # Oneshot commands
        self.sim_hooks = {}
 
    def RecStart(self, properties: RecProperties) -> RecStatus:
        """@implements RecCmds.StartDaq"""
        rec_id = properties.getId()
        logging.info("Request: StartDaq(%s)", rec_id)
        if rec_id in self.recordings:
            raise ExceptionErr(rec_id, "Recording with id already exist")
        self.current_rec = rec = Recording(rec_id)
        logging.info("Request: StartDaq(%s) ref=%s", rec_id, id(rec))
        rec.status = RecStatusNames.Active
        self.recordings[rec_id] = rec
        result = self.make_rec_status(rec_id)
        return self.run_sim_hook(result, rec_id)
 
    def RecStop(self) -> RecStatus:
        """@implements RecCmds.RecStop"""
        if not self.current_rec:
            raise ExceptionErr(1234, "No current recording active")
        rec_id = self.current_rec.id
        logging.info("Request: RecStop(%s)", rec_id)
 
        rec = self.get_recording(rec_id)
        if rec.status in (RecStatusNames.Completed, RecStatusNames.Stopped):
            logging.info(
                "Request: RecStop(%s): Recording already complete. Returning error", rec_id
            )
            # todo: MAL has not implemented exceptions yet so I cannot throw!
            # raise ExceptionErr(rec_id, "Recording already stopped '%s'" % rec_id)
            logging.info(
                "Request: RecStop(%s): ... NOT because MAL bug prevents me to", rec_id
            )
 
        rec.dp_files = ["/tmp/%s.fits" % rec_id]
        rec.status = RecStatusNames.Stopped
 
        result = self.make_rec_status(rec_id)
        # Due to MAL bug we have to continue keeping the current recording alive...
        # self.current_rec = None
        return self.run_sim_hook(result, rec_id)
 
    def RecAbort(self) -> str:
        """@implements RecCmds.RecAbort"""
        if not self.current_rec:
            raise ExceptionErr(1234, "No current recording active")
 
        rec_id = self.current_rec.id
        logging.info("Request: RecAbort(%s)", rec_id)
        rec = self.get_recording(rec_id)
        rec.status = RecStatusNames.Aborted
        self.recordings[rec_id] = rec
        result = ""
        self.current_rec = None
        return self.run_sim_hook(result, rec_id)
 
    def RecWait(self, spec: RecWaitSpec) -> RecStatus:  # pylint: disable=unused-argument
        """@implements RecCmds.RecWait
 
        For the moment we simply simulate that the recording was completed
        as soon as this request was received.
        """
        rec_id = self.current_rec.id
        logging.info("Request: RecWait(%s)", rec_id)
        result = self.make_rec_wait_status(rec_id)
        return self.run_sim_hook(result, rec_id)
 
    def RecStatus(self, rec_id: str) -> RecStatus:
        """@implements RecCmds.RecStatus"""
        logging.info("Request: RecStatus(%s)", rec_id)
        result = self.make_rec_status(rec_id)
        return self.run_sim_hook(result, rec_id)
 
    def get_recording(self, rec_id) -> Recording:
        """Get recording or raise ExceptionErr."""
        if rec_id in self.recordings:
            return self.recordings[rec_id]
        raise ExceptionErr(rec_id, "Unknown recording id '%s'" % rec_id)
 
    def make_rec_status(self, rec_id) -> RecStatus:
        """
        <struct name="RecStatus">
            <member name="dpFiles" type="string" arrayDimensions="(32)"/>
            <member name="endTime" type="double"/>
            <member name="filesGenerated" type="int32_t"/>
            <member name="framesProcessed" type="int32_t"/>
            <member name="framesRemaining" type="int32_t"/>
            <member name="id" type="string"/>
            <member name="info" type="string"/>
            <member name="remainingTime" type="double"/>
            <member name="sizeRecorded" type="int32_t"/>
            <member name="startTime" type="double"/>
            <member name="status" type="nonBasic" nonBasicTypeName="RecStatusNames"/>
            <member name="timeElapsed" type="double"/>
        </struct>
        """
        logging.debug("Creating return type: RecStatus")
        rec = self.get_recording(rec_id)
        status = self.mal.createDataEntity(RecStatus)
        self.populate_rec_status(rec, status)
        return status
 
    def populate_rec_status(self, rec: Recording, status: RecStatus) -> RecStatus:
        """Populates RecStatus from status"""
        logging.debug("Populating return type: RecStatus: id=%s, status=%r", rec.id, rec.status)
        status.setDpFiles(rec.dp_files)
        status.setEndTime(rec.end_time)
        status.setFilesGenerated(rec.files_generated)
        status.setFramesProcessed(rec.frames_processed)
        status.setFramesRemaining(rec.frames_remaining)
        status.setId(rec.id)
        status.setInfo(rec.info)
        status.setRemainingTime(rec.remaining_time)
        status.setSizeRecorded(rec.size_recorded)
        status.setStartTime(rec.start_time)
        status.setStatus(rec.status)
        status.setTimeElapsed(rec.time_elapsed)
 
    def make_rec_wait_status(self, rec_id) -> RecWaitStatus:
        """Creates RecWaitStatus and populates attributes"""
        logging.debug("Creating return type: RecWaitStatus")
        rec = self.get_recording(rec_id)
        status = self.mal.createDataEntity(RecWaitStatus)
        self.populate_rec_status(rec, status.getRecStatus())
        if rec.status in (RecStatusNames.Completed, RecStatusNames.Stopped):
            logging.debug("Recording is Completed or Stopped, RecWaitStatus set to success")
            status.setStatus(RecWaitStatusNames.Success)
        else:
            status.setStatus(RecWaitStatusNames.Timeout)
        return status
 
    def add_sim_hook(self, cmd_name: str, hook):
        """Add the simulation hook `hook` for the specified command `cmd_name` (e.g.
        "RecStart").
 
        Any previous hooks will be replaced.
        """
        self.sim_hooks[cmd_name] = hook
 
    def reset(self):
        """Reset simulator to initial default state."""
        self.clear_sim_hooks()
        self.recordings = {}
        self.current_rec = None
 
    def clear_sim_hooks(self):
        """Remove all simulation hooks."""
        self.sim_hooks = {}
 
    def run_sim_hook(self, result, *args):
        """Runs simulation hook that may modify or replace the default implementation.
 
        The hook to execute is automatically determined from the call stack, so
        this should only ever be executed directly from the service command
        implementation method.
        """
        cmd_name = inspect.stack()[1][3]
        hook = self.sim_hooks.get(cmd_name)
        logging.debug("Checking for hook for command %s", cmd_name)
        if hook:
            logging.debug("Running simulation hook for command %s", cmd_name)
            del self.sim_hooks[cmd_name]
            return hook(result, *args)
        return result
 
 
class SimulatorCtl:  # pylint: disable=invalid-name
    """Simulator controller that implements ModDaqsimif and sets up
    simulation behaviour for Simulator.
    """
 
    def __init__(self, name, mal, server):
        self.name = name
        self.mal = mal
        self.server = server
 
        self.sim = Simulator(name, mal)
        logging.info("Registering service 'rec'")
        self.server.registerService("rec", RecCmdsSyncService, self.sim)
 
    def Setup(self, spec):
        """@implements SimCtl.Setup."""
        logging.info('SimCtl.Setup: spec="%s"', spec)
        s = json.loads(spec)
        try:
            cmd = s.get("command", "")
            action = s.get("action", "")
            if action == "complete-recording":
                # finish current recording
                rec = self.sim.current_rec
                logging.info("SimCtl.Setup: Marking %s as Completed ref=%s", rec.id, id(rec))
                rec.status = RecStatusNames.Completed
                rec.dp_files = ["/tmp/auto-%s.fits" % rec.id]
            elif action == "throw":
 
                def throw(res, *args):
                    raise ExceptionErr(self.sim.current_rec.id, "Simulated error")
 
                self.sim.add_sim_hook(cmd, throw)
            else:
                raise SimCtlError("Unknown action '%s' provided" % action)
            logging.info("SimCtl.Setup: Returning empty string")
            return json.dumps("")
        except SimCtlError:
            raise
        except Exception as e:
            raise SimCtlError('"%s"' % str(e))
 
    def Reset(self):
        """@implements SimCtl.Reset"""
        try:
            self.sim.reset()
        except Exception as e:
            raise SimCtlError(str(e))
 
    def ForceExit(self):
        """@implements SimCtl.ForceExit."""
        # Notify main thread that it should exit
        logging.warning("Force Exiting without cleanup!")
        os._exit()  # pylint: disable=protected-access