openpectus 0.1.10__tar.gz

openpectus-0.1.10/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.3
+Name: openpectus
+Version: 0.1.10
+Summary: Pectus is a process control system for Unit Operations such as filtration, chromatography, precipitation,
+Author-email: Eskild Schroll-Fleischer <eyfl@novonordisk.com>, Morten Passow Odgaard <mpo@mjolner.dk>, "Jan H. Knudsen" <jhk@mjolner.dk>
+Description-Content-Type: text/markdown
+Requires-Dist: antlr4-python3-runtime==4.13.1
+Requires-Dist: pint==0.22
+Requires-Dist: typing_extensions==4.8.0
+Requires-Dist: pydantic==1.10.13
+Requires-Dist: fastapi==0.103.2
+Requires-Dist: uvicorn[standard]==0.23.2
+Requires-Dist: httpx==0.25.0
+Requires-Dist: fastapi_websocket_rpc==0.1.25
+Requires-Dist: fastapi_websocket_pubsub==0.3.8
+Requires-Dist: colorlog==6.7.0
+Requires-Dist: sqlalchemy==2.0.23
+Requires-Dist: asyncua==1.0.6
+Requires-Dist: labjack-ljm==1.23.0
+Requires-Dist: pyright==1.1.381
+Requires-Dist: alembic==1.13.1
+Requires-Dist: sentry-sdk==2.1.1
+Requires-Dist: PyJWT==2.10.0
+Requires-Dist: flake8==6.1.0 ; extra == "development"
+Requires-Dist: black==23.3.0 ; extra == "development"
+Requires-Dist: build==0.10.0 ; extra == "development"
+Provides-Extra: development
+
+# Open Pectus
+Pectus is a process control system for Unit Operations such as filtration, chromatography, precipitation, solubilization and refolding. Pectus implements a language called P-code which is used to write methods and control components on the Unit Operation.
+
+General documentation about case, architecture and P-Code is available at [Read the Docs](https://open-pectus.readthedocs.io/en/latest/).
+
+Documentation for developers is available in the [DEVELOPMENT.md](DEVELOPMENT.md) file.
+

openpectus-0.1.10/README.md

@@ -0,0 +1,6 @@
+# Open Pectus
+Pectus is a process control system for Unit Operations such as filtration, chromatography, precipitation, solubilization and refolding. Pectus implements a language called P-code which is used to write methods and control components on the Unit Operation.
+
+General documentation about case, architecture and P-Code is available at [Read the Docs](https://open-pectus.readthedocs.io/en/latest/).
+
+Documentation for developers is available in the [DEVELOPMENT.md](DEVELOPMENT.md) file.

openpectus-0.1.10/openpectus/__init__.py

@@ -0,0 +1,28 @@
+""" Pectus is a process control system for Unit Operations such as filtration, chromatography, precipitation,
+solubilization and refolding. Pectus implements a language called P-code which is used to write methods and
+control components on the Unit Operation. """
+__version__ = "0.1.10"
+
+import logging
+import json
+import os
+
+import colorlog
+
+build_number = "build_number not set"
+build_info = {}
+
+path = os.path.dirname(os.path.realpath(__file__))
+with open(os.path.join(path, "build.json")) as file:
+    dct = json.load(file)
+    build_info = dct
+    build_number = dct["build_number"]
+
+
+def log_setup_colorlog(root_loglevel: int = logging.INFO):
+    handler = colorlog.StreamHandler()
+    handler.setFormatter(colorlog.ColoredFormatter('%(log_color)s%(levelname)s:%(name)s:%(message)s'))
+
+    logging.root.setLevel(root_loglevel)
+    logging.root.handlers.clear()
+    logging.root.addHandler(handler)

openpectus-0.1.10/openpectus/aggregator/aggregator.py

@@ -0,0 +1,334 @@
+import asyncio
+import logging
+from datetime import datetime, timezone
+
+import openpectus.aggregator.models as Mdl
+from openpectus.protocol.aggregator_dispatcher import AggregatorDispatcher
+import openpectus.protocol.aggregator_messages as AM
+import openpectus.protocol.engine_messages as EM
+import openpectus.protocol.messages as M
+from openpectus.aggregator.data import database
+from openpectus.aggregator.data.repository import RecentRunRepository, PlotLogRepository, RecentEngineRepository
+from openpectus.aggregator.frontend_publisher import FrontendPublisher
+from openpectus.aggregator.models import EngineData
+from openpectus.protocol.models import SystemTagName, MethodStatusEnum
+
+logger = logging.getLogger(__name__)
+
+EngineDataMap = dict[str, EngineData]
+persistance_threshold_seconds = 5
+
+
+class FromEngine:
+    def __init__(self, engine_data_map: EngineDataMap, publisher: FrontendPublisher):
+        self._engine_data_map = engine_data_map
+        self.publisher = publisher
+
+    def register_engine_data(self, engine_data: EngineData):
+        logger.debug(f"Data for engine {engine_data.engine_id} registered")
+        self._engine_data_map[engine_data.engine_id] = engine_data
+        asyncio.create_task(self.publisher.publish_process_units_changed())
+        asyncio.create_task(self.publisher.publish_control_state_changed(engine_data.engine_id))
+
+    def engine_connected(self, engine_id: str):
+        logger.debug("engine_connected")
+
+    def engine_disconnected(self, engine_id: str):
+        logger.debug("engine_disconnected")
+        engine_data = self._engine_data_map.get(engine_id)
+        if engine_data is not None:
+            with database.create_scope():
+                repo = RecentEngineRepository(database.scoped_session())
+                repo.store_recent_engine(engine_data)
+            logger.info("Recent engine saved")
+            del self._engine_data_map[engine_id]
+            asyncio.create_task(self.publisher.publish_process_units_changed())
+        else:
+            logger.warning("No data to save for engine " + engine_id)
+
+    def engine_reconnected(self, msg: EM.ReconnectedMsg):
+        logger.info(f"Engine_reconnected. Processing ReconnectedMsg {msg.ident}")
+        engine_id = msg.engine_id
+        engine_data = self._engine_data_map.get(engine_id)
+        if engine_data is None:
+            logger.error("No engine data available on reconnect for engine " + engine_id)
+            return
+
+        # Use this to debug reconnect msg timestamps/older tags
+        # created_time = datetime.fromtimestamp(msg.created_tick).strftime("%H:%M:%S")
+        # logger.debug(f"ReconnectedMsg created_tick_time: {created_time})")
+
+        # ft02 = next((tag for tag in msg.tags if tag.name == "FT02"))
+        # ft02_time = datetime.fromtimestamp(ft02.tick_time).strftime("%H:%M:%S")
+        # logger.debug(f"ReconnectedMsg ft02_time: {ft02_time})")
+
+
+        # apply the state from msg to the current state
+        engine_data.method = msg.method
+        run_id_tag = next((tag for tag in msg.tags if tag.name == SystemTagName.RUN_ID), None)
+        # verify consistent message
+        if msg.run_id is None:
+            if run_id_tag is not None and run_id_tag.value is not None:
+                logger.error(f"Mismatch in ReconnectedMsg, tag run_id {run_id_tag.value}, msg run_id {msg.run_id}")
+                return
+        else:
+            if run_id_tag is None or run_id_tag.value is None:
+                logger.error(f"Mismatch in ReconnectedMsg, tag run_id {None}, msg run_id {msg.run_id}")
+                return
+            engine_data.run_data.run_started = datetime.fromtimestamp(msg.run_started_tick) \
+                if msg.run_started_tick is not None else None
+            engine_data.tags_info.upsert(run_id_tag)  # sets engine_data.run_id
+
+        # handle possible change to recent engine
+        with database.create_scope():
+            repo = RecentEngineRepository(database.scoped_session())
+            recent_engine = repo.get_recent_engine_by_engine_id(engine_id)
+            if recent_engine is None:
+                logger.info(f"Reconnected engine {engine_id} has no recent engine data")
+            else:
+                if recent_engine.run_id != msg.run_id and recent_engine.run_id is not None:
+                    logger.info("Marking recent engine stopped ")
+                    repo.mark_recent_engine_stopped(engine_data)
+
+        # process tag values normally
+        self.tag_values_changed(engine_id, msg.tags)
+        logger.info(f"Done processing ReconnectedMsg {msg.ident}")
+
+    def run_started(self):  # to replace run_id_changed guessing
+        raise NotImplementedError()
+
+    def run_stopped(self):
+        raise NotImplementedError()
+
+    def uod_info_changed(
+            self,
+            engine_id: str,
+            readings: list[Mdl.ReadingInfo],
+            commands: list[Mdl.CommandInfo],
+            plot_configuration: Mdl.PlotConfiguration,
+            hardware_str: str,
+            required_roles: set[str]):
+        try:
+            self._engine_data_map[engine_id].readings = readings
+            self._engine_data_map[engine_id].commands = commands
+            self._engine_data_map[engine_id].plot_configuration = plot_configuration
+            self._engine_data_map[engine_id].hardware_str = hardware_str
+            self._engine_data_map[engine_id].required_roles = required_roles
+        except KeyError:
+            logger.error(f'No engine registered under id {engine_id} when trying to set uod info.')
+
+    def tag_values_changed(self, engine_id: str, changed_tag_values: list[Mdl.TagValue]):
+        with database.create_scope():
+            plot_log_repo = PlotLogRepository(database.scoped_session())
+            recent_run_repo = RecentRunRepository(database.scoped_session())
+
+            engine_data = self._engine_data_map.get(engine_id)
+            if engine_data is None:
+                logger.error(f'No engine registered under id {engine_id} when trying to upsert tag values.')
+                return
+
+            for changed_tag_value in changed_tag_values:
+                if changed_tag_value.name == SystemTagName.METHOD_STATUS.value:
+                    if changed_tag_value.value == MethodStatusEnum.ERROR:
+                        engine_data.run_data.interrupted_by_error = True
+                    else:
+                        engine_data.run_data.interrupted_by_error = False
+
+                if changed_tag_value.name == SystemTagName.RUN_ID.value:
+                    self._run_id_changed(plot_log_repo, recent_run_repo, engine_data, changed_tag_value)
+
+                was_inserted = engine_data.tags_info.upsert(changed_tag_value)
+
+                if changed_tag_value.name in [
+                    SystemTagName.METHOD_STATUS.value,
+                    SystemTagName.SYSTEM_STATE.value,
+                    SystemTagName.RUN_ID.value,
+                ]:
+                    asyncio.create_task(self.publisher.publish_process_units_changed())
+
+                # if a tag doesn't appear with value until after start and run_id, we need to store the info here
+                if was_inserted and engine_data.run_id is not None:
+                    plot_log_repo.store_new_tag_info(engine_data.engine_id, engine_data.run_id, changed_tag_value)
+
+            self._persist_tag_values(engine_data, plot_log_repo)
+
+    def _run_id_changed(
+            self,
+            plot_log_repo: PlotLogRepository,
+            recent_run_repo: RecentRunRepository,
+            engine_data: EngineData,
+            run_id_tag: Mdl.TagValue):
+        """ Handles persistance related to start and end of a run """
+
+        logger.info(f"RunId changed from {engine_data.run_id} to {run_id_tag.value}, Engine: {engine_data.engine_id}")
+        if run_id_tag.value is None and engine_data.run_id is None:
+            logger.info("Engine has no active run")
+        elif run_id_tag.value is None and engine_data.run_id is not None:
+            # Run stopped
+            logger.info(f"Run was stopped. Saving Recent Run. Engine: {engine_data.engine_id}")
+            recent_run_repo.store_recent_run(engine_data)
+            engine_data.run_data.error_log = Mdl.AggregatedErrorLog.empty()
+            asyncio.create_task(self.publisher.publish_error_log_changed(engine_data.engine_id))
+        elif run_id_tag.value is not None and engine_data.run_id is not None:
+            # Ongoing run. run_id was only detected as changed because of complete tags set,
+            # caused by e.g. an aggregator restart
+            if run_id_tag.value != engine_data.run_id:
+                logger.error(f"Run_Id inconsistent, run_id tag {run_id_tag.value}, engine_data {engine_data.run_id}")
+            else:
+                logger.info(f"Run {run_id_tag.value} resumed")
+        else:
+            # Run started
+            logger.info(f"A new Run was started, Engine: {engine_data.engine_id}, Run_Id: {str(run_id_tag.value)}")
+            engine_data.run_data.run_started = datetime.fromtimestamp(run_id_tag.tick_time, timezone.utc)
+            plot_log_repo.create_plot_log(engine_data, str(run_id_tag.value))
+
+    def _persist_tag_values(self, engine_data: EngineData, plot_log_repo: PlotLogRepository):
+        latest_persisted_tick_time = engine_data.run_data.latest_persisted_tick_time
+        tag_values = engine_data.tags_info.map.values()
+        latest_tag_tick_time = max([tag.tick_time for tag in tag_values]) if len(tag_values) > 0 else 0
+        time_threshold_exceeded = latest_persisted_tick_time is None \
+            or latest_tag_tick_time - latest_persisted_tick_time > persistance_threshold_seconds
+        # time_threshold_exceeded = latest_persisted_tick_time is None \
+        #     or time.time() - latest_persisted_tick_time > persistance_threshold_seconds
+        if engine_data.run_id is not None and time_threshold_exceeded:
+            tag_values_to_persist = [tag_value.copy() for tag_value in engine_data.tags_info.map.values()
+                                     if latest_persisted_tick_time is None
+                                     or tag_value.tick_time > latest_persisted_tick_time]
+            """
+            We manipulate the tick_time of the tagValues we persist. But it's not changing it to something that didn't
+            exist in the engine, because we change the tick_time to a tick_time that comes from an actual later reading
+            where those tagValues we manipulate was read and simply had not changed value since the value we have been
+            reported.
+            It's difficult to explain, but after this manipulation, the tagValues will still match an actual tagValue
+            read in the engine, just not one reported.
+            We do this because it solves a lot of issues when we later try to match values based on the tick_time.
+            """
+            highest_tick_time_to_persist = max([tag_Value.tick_time for tag_Value in tag_values_to_persist])
+            for tag_value_to_persist in tag_values_to_persist:
+                tag_value_to_persist.tick_time = highest_tick_time_to_persist
+
+            # Note: to store tag values, the run_id is needed
+            plot_log_repo.store_tag_values(engine_data.engine_id, engine_data.run_id, tag_values_to_persist)
+            engine_data.run_data.latest_persisted_tick_time = highest_tick_time_to_persist
+            engine_data.run_data.latest_tag_time = highest_tick_time_to_persist
+
+    def runlog_changed(self, engine_id: str, runlog: Mdl.RunLog):
+        try:
+            engine_data = self._engine_data_map[engine_id]
+            if engine_data.run_data.runlog != runlog:
+                engine_data.run_data.runlog = runlog
+                asyncio.create_task(self.publisher.publish_run_log_changed(engine_id))
+        except KeyError:
+            logger.error(f'No engine registered under id {engine_id} when trying to set run log.')
+
+    def control_state_changed(self, engine_id: str, control_state: Mdl.ControlState):
+        try:
+            engine_data = self._engine_data_map[engine_id]
+            if engine_data.control_state != control_state:
+                engine_data.control_state = control_state
+                asyncio.create_task(self.publisher.publish_control_state_changed(engine_id))
+        except KeyError:
+            logger.error(f'No engine registered under id {engine_id} when trying to set control state.')
+
+    def method_state_changed(self, engine_id: str, method_state: Mdl.MethodState):
+        try:
+            engine_data = self._engine_data_map[engine_id]
+            if engine_data.run_data.method_state != method_state:
+                engine_data.run_data.method_state = method_state
+                asyncio.create_task(self.publisher.publish_method_state_changed(engine_id))
+        except KeyError:
+            logger.error(f'No engine registered under id {engine_id} when trying to set control state.')
+
+    def error_log_changed(self, engine_id: str, error_log: Mdl.ErrorLog):
+        try:
+            engine_data = self._engine_data_map[engine_id]
+            engine_data.run_data.error_log.aggregate_with(error_log)
+            asyncio.create_task(self.publisher.publish_error_log_changed(engine_id))
+        except KeyError:
+            logger.error(f'No engine registered under id {engine_id} when trying to set error log.')
+
+
+class FromFrontend:
+    def __init__(self, engine_data_map: EngineDataMap, dispatcher: AggregatorDispatcher):
+        self._engine_data_map = engine_data_map
+        self.dispatcher = dispatcher
+
+    async def method_saved(self, engine_id: str, method: Mdl.Method, user_name: str) -> bool:
+        try:
+            response = await self.dispatcher.rpc_call(engine_id, message=AM.MethodMsg(method=method))
+            if isinstance(response, M.ErrorMessage):
+                logger.error(f"Failed to set method. Engine response: {response.message}")
+                return False
+        except Exception:
+            logger.error("Failed to set method", exc_info=True)
+            return False
+
+        # update local method state
+        engine_data = self._engine_data_map.get(engine_id)
+        if engine_data is not None:
+            engine_data.method = method
+            engine_data.contributors.add(user_name)
+        return True
+
+    async def request_cancel(self, engine_id, line_id: str, user_name: str) -> bool:
+        engine_data = self._engine_data_map.get(engine_id)
+        if engine_data is None:
+            logger.warning(f"Cannot request cancel, engine {engine_id} not found")
+            return False
+        try:
+            response = await self.dispatcher.rpc_call(engine_id, message=AM.CancelMsg(exec_id=line_id))
+            if isinstance(response, M.ErrorMessage):
+                logger.error(f"Cancel request failed. Engine response: {response.message}")
+                return False
+        except Exception:
+            logger.error("Cancel request failed with exception", exc_info=True)
+            return False
+        engine_data.contributors.add(user_name)
+        return True
+
+    async def request_force(self, engine_id, line_id: str, user_name: str) -> bool:
+        engine_data = self._engine_data_map.get(engine_id)
+        if engine_data is None:
+            logger.warning(f"Cannot request force, engine {engine_id} not found")
+            return False
+        try:
+            response = await self.dispatcher.rpc_call(engine_id, message=AM.ForceMsg(exec_id=line_id))
+            if isinstance(response, M.ErrorMessage):
+                logger.error(f"Force request failed. Engine response: {response.message}")
+                return False
+        except Exception:
+            logger.error("Force request failed with exception", exc_info=True)
+            return False
+        engine_data.contributors.add(user_name)
+        return True
+
+
+class Aggregator:
+    def __init__(self, dispatcher: AggregatorDispatcher, publisher: FrontendPublisher) -> None:
+        self._engine_data_map: EngineDataMap = {}
+        """ all client data except channels, indexed by engine_id """
+        self.dispatcher = dispatcher
+        self.from_frontend = FromFrontend(self._engine_data_map, dispatcher)
+        self.from_engine = FromEngine(self._engine_data_map, publisher)
+
+    def create_engine_id(self, register_engine_msg: EM.RegisterEngineMsg):
+        """ Defines the generation of the engine_id that is uniquely assigned to each engine.
+
+        TODO: Considerations:
+            - engine name should be machine name
+            - uod hash should probably be included
+
+        Implications of the registration process
+        - historical data; we should not corrupt historical data by accidentially reusing engine_id
+        - number of cards shown; we should not show many irrelevant cards in frontend of superseeded engine_ids
+        """
+        return register_engine_msg.computer_name + "_" + register_engine_msg.uod_name
+
+    def get_registered_engine_data(self, engine_id: str):
+        return self._engine_data_map.get(engine_id)
+
+    def get_all_registered_engine_data(self) -> list[EngineData]:
+        return list(self._engine_data_map.values())
+
+    def has_registered_engine_id(self, engine_id: str) -> bool:
+        return engine_id in self._engine_data_map.keys()

openpectus-0.1.10/openpectus/aggregator/aggregator_message_handlers.py

@@ -0,0 +1,128 @@
+import logging
+
+import openpectus.protocol.aggregator_messages as AM
+import openpectus.protocol.engine_messages as EM
+import openpectus.aggregator.models as Mdl
+from openpectus.aggregator.aggregator import Aggregator
+
+logger = logging.getLogger(__name__)
+
+
+class AggregatorMessageHandlers:
+    def __init__(self, aggregator: Aggregator):
+        self.aggregator = aggregator
+        aggregator.dispatcher.set_register_handler(self.handle_RegisterEngineMsg)
+        aggregator.dispatcher.set_disconnect_handler(self.handle_EngineDisconnected)
+        aggregator.dispatcher.set_connect_handler(self.handle_EngineConnected)
+        aggregator.dispatcher.set_message_handler(EM.ReconnectedMsg, self.handle_ReconnectedMsg)
+        aggregator.dispatcher.set_message_handler(EM.UodInfoMsg, self.handle_UodInfoMsg)
+        aggregator.dispatcher.set_message_handler(EM.TagsUpdatedMsg, self.handle_TagsUpdatedMsg)
+        aggregator.dispatcher.set_message_handler(EM.RunLogMsg, self.handle_RunLogMsg)
+        aggregator.dispatcher.set_message_handler(EM.ControlStateMsg, self.handle_ControlStateMsg)
+        aggregator.dispatcher.set_message_handler(EM.MethodStateMsg, self.handle_MethodStateMsg)
+        aggregator.dispatcher.set_message_handler(EM.ErrorLogMsg, self.handle_ErrorLogMsg)
+
+    async def handle_RegisterEngineMsg(self, register_engine_msg: EM.RegisterEngineMsg) -> AM.RegisterEngineReplyMsg:
+        """ Registers engine """
+        engine_id = self.aggregator.create_engine_id(register_engine_msg)
+        if self.aggregator.dispatcher.has_connected_engine_id(engine_id):
+            logger.error(
+                f"""Registration failed for engine_id {engine_id}. An engine with that engine_id already
+                has a websocket connection. """
+            )
+            return AM.RegisterEngineReplyMsg(success=False, engine_id=engine_id)
+
+        # TODO consider how to handle registrations
+        # - disconnect/reconnect should work
+        # - client kill/reconnect should work
+        # - engine_id reused with "same uod" should take over session, else fail as misconfigured client
+        # - add machine name + uod secret
+
+        # initialize client data
+        if not self.aggregator.has_registered_engine_id(engine_id):
+            self.aggregator.from_engine.register_engine_data(
+                Mdl.EngineData(
+                    engine_id=engine_id,
+                    computer_name=register_engine_msg.computer_name,
+                    uod_name=register_engine_msg.uod_name,
+                    uod_author_name=register_engine_msg.uod_author_name,
+                    uod_author_email=register_engine_msg.uod_author_email,
+                    uod_filename=register_engine_msg.uod_filename,
+                    location=register_engine_msg.location,
+                    engine_version=register_engine_msg.engine_version
+                )
+            )
+
+        logger.info(f"Registration of engine {engine_id} successful")
+        return AM.RegisterEngineReplyMsg(success=True, engine_id=engine_id)
+
+    async def handle_EngineConnected(self, engine_id: str):
+        self.aggregator.from_engine.engine_connected(engine_id)
+
+    async def handle_EngineDisconnected(self, engine_id: str):
+        self.aggregator.from_engine.engine_disconnected(engine_id)
+
+    async def handle_ReconnectedMsg(self, msg: EM.ReconnectedMsg):
+        self.aggregator.from_engine.engine_reconnected(msg)
+        return AM.SuccessMessage()
+
+    def validate_msg(self, msg: EM.EngineMessage):
+        if not self.aggregator.has_registered_engine_id(msg.engine_id):
+            return AM.ErrorMessage(message=f'No engine registered under id {msg.engine_id}')
+        # possibly more validations...
+        return None
+
+    async def handle_UodInfoMsg(self, msg: EM.UodInfoMsg) -> AM.SuccessMessage | AM.ErrorMessage:
+        validation_errors = self.validate_msg(msg)
+        if validation_errors is not None:
+            return validation_errors
+
+        logger.debug(f"Got UodInfo from client: {str(msg)}")
+        self.aggregator.from_engine.uod_info_changed(
+            msg.engine_id, msg.readings, msg.commands, msg.plot_configuration, msg.hardware_str, msg.required_roles)
+        return AM.SuccessMessage()
+
+    async def handle_TagsUpdatedMsg(self, msg: EM.TagsUpdatedMsg) -> AM.SuccessMessage | AM.ErrorMessage:
+        validation_errors = self.validate_msg(msg)
+        if validation_errors is not None:
+            return validation_errors
+
+        logger.debug(f"Got tags update from client: {str(msg)}")
+        self.aggregator.from_engine.tag_values_changed(msg.engine_id, msg.tags)
+        return AM.SuccessMessage()
+
+    async def handle_RunLogMsg(self, msg: EM.RunLogMsg) -> AM.SuccessMessage | AM.ErrorMessage:
+        validation_errors = self.validate_msg(msg)
+        if validation_errors is not None:
+            return validation_errors
+
+        logger.debug(f"Got run log from client: {str(msg)}")
+        self.aggregator.from_engine.runlog_changed(msg.engine_id, msg.runlog)
+        return AM.SuccessMessage()
+
+    async def handle_ControlStateMsg(self, msg: EM.ControlStateMsg) -> AM.SuccessMessage | AM.ErrorMessage:
+        validation_errors = self.validate_msg(msg)
+        if validation_errors is not None:
+            return validation_errors
+
+        logger.debug(f"Got control state from client: {str(msg)}")
+        self.aggregator.from_engine.control_state_changed(msg.engine_id, msg.control_state)
+        return AM.SuccessMessage()
+
+    async def handle_MethodStateMsg(self, msg: EM.MethodStateMsg):
+        validation_errors = self.validate_msg(msg)
+        if validation_errors is not None:
+            return validation_errors
+
+        logger.debug(f"Got method state from client: {str(msg)}")
+        self.aggregator.from_engine.method_state_changed(msg.engine_id, msg.method_state)
+        return AM.SuccessMessage()
+
+    async def handle_ErrorLogMsg(self, msg: EM.ErrorLogMsg):
+        validation_errors = self.validate_msg(msg)
+        if validation_errors is not None:
+            return validation_errors
+
+        logger.debug(f'error log message from engine: {msg.log}')
+        self.aggregator.from_engine.error_log_changed(msg.engine_id, msg.log)
+        return AM.SuccessMessage()

openpectus-0.1.10/openpectus/aggregator/aggregator_server.py

@@ -0,0 +1,69 @@
+import logging
+import os
+
+import uvicorn
+from openpectus.aggregator.routers.auth import UserRolesDependency
+from alembic.config import Config
+from fastapi import FastAPI, APIRouter
+from fastapi.routing import APIRoute
+from openpectus.aggregator.aggregator_message_handlers import AggregatorMessageHandlers
+from openpectus.aggregator.data import database
+from openpectus.aggregator.deps import _create_aggregator
+from openpectus.aggregator.frontend_publisher import FrontendPublisher
+from openpectus.aggregator.routers import process_unit, recent_runs, auth, version
+from openpectus.aggregator.spa import SinglePageApplication
+from openpectus.protocol.aggregator_dispatcher import AggregatorDispatcher
+
+
+class AggregatorServer:
+    default_title = "Pectus Aggregator"
+    default_frontend_dist_dir = os.path.join(os.path.dirname(__file__), "frontend-dist")
+    # default_frontend_dist_dir = ".\\openpectus\\frontend\\dist"
+    default_host = "127.0.0.1"
+    default_port = 9800
+
+    def __init__(self, title: str = default_title, host: str = default_host, port: int = default_port,
+                 frontend_dist_dir: str = default_frontend_dist_dir):
+        self.title = title
+        self.host = host
+        self.port = port
+        self.frontend_dist_dir = frontend_dist_dir
+        self.dispatcher = AggregatorDispatcher()
+        self.publisher = FrontendPublisher()
+        self.aggregator = _create_aggregator(self.dispatcher, self.publisher)
+        _ = AggregatorMessageHandlers(self.aggregator)
+        self.setup_fastapi([self.dispatcher.router, self.publisher.router, version.router])
+        self.init_db()
+
+    def setup_fastapi(self, additional_routers: list[APIRouter] = []):
+        api_prefix = "/api"
+
+        def custom_generate_unique_id(route: APIRoute):
+            return f"{route.name}"
+
+        self.fastapi = FastAPI(title=self.title,
+                               generate_unique_id_function=custom_generate_unique_id,
+                               on_shutdown=[self.on_shutdown])
+        self.fastapi.include_router(process_unit.router, prefix=api_prefix, dependencies=[UserRolesDependency])
+        self.fastapi.include_router(recent_runs.router, prefix=api_prefix, dependencies=[UserRolesDependency])
+        self.fastapi.include_router(auth.router, prefix='/auth')
+        for route in additional_routers:
+            self.fastapi.include_router(route)
+        if not os.path.exists(self.frontend_dist_dir):
+            raise FileNotFoundError("frontend_dist_dir not found: " + self.frontend_dist_dir)
+        self.fastapi.mount("/", SinglePageApplication(directory=self.frontend_dist_dir))
+
+    def init_db(self):
+        alembic_ini_file_path = os.path.join(os.path.dirname(__file__), "alembic.ini")
+        sqlalchemy_url = Config(alembic_ini_file_path).get_main_option('sqlalchemy.url')
+        if sqlalchemy_url is None:
+            raise ValueError('sqlalchemy.url not set in alembic.ini file')
+        database.configure_db(sqlalchemy_url)
+        self.fastapi.add_middleware(database.DBSessionMiddleware)
+
+    def start(self):
+        print(f"Serving frontend at http://{self.host}:{self.port}")
+        uvicorn.run(self.fastapi, host=self.host, port=self.port, log_level=logging.WARNING)
+
+    async def on_shutdown(self):
+        await self.dispatcher.shutdown()