isar 1.31.0__py3-none-any.whl → 1.31.1__py3-none-any.whl

isar/config/open_telemetry.py

@@ -1,6 +1,5 @@
 import logging
 
-from azure.identity import ManagedIdentityCredential
 from azure.monitor.opentelemetry.exporter import (
     AzureMonitorLogExporter,
     AzureMonitorTraceExporter,
@@ -57,12 +56,7 @@ def get_azure_monitor_exporters() -> (
     Else use Azure Managed Identity to create Azure Monitor Exporters.
     """
     connection_string = settings.APPLICATIONINSIGHTS_CONNECTION_STRING
-    if connection_string:
-        trace_exporter = AzureMonitorTraceExporter(connection_string=connection_string)
-        log_exporter = AzureMonitorLogExporter(connection_string=connection_string)
-    else:
-        credential = ManagedIdentityCredential()
-        trace_exporter = AzureMonitorTraceExporter(credential=credential)
-        log_exporter = AzureMonitorLogExporter(credential=credential)
+    trace_exporter = AzureMonitorTraceExporter(connection_string=connection_string)
+    log_exporter = AzureMonitorLogExporter(connection_string=connection_string)
 
     return trace_exporter, log_exporter

isar/eventhandlers/eventhandler.py

@@ -0,0 +1,93 @@
+import logging
+import time
+from copy import deepcopy
+from dataclasses import dataclass
+from threading import Event as ThreadEvent
+from typing import TYPE_CHECKING, Callable, Generic, List, Optional, TypeVar
+
+from transitions import State
+
+from isar.config.settings import settings
+from isar.models.events import Event
+
+T = TypeVar("T")
+
+
+@dataclass
+class EventHandlerMapping(Generic[T]):
+    name: str
+    event: Event[T]
+    handler: Callable[[Event[T]], Optional[Callable]]
+
+
+@dataclass
+class TimeoutHandlerMapping:
+    name: str
+    timeout_in_seconds: float
+    handler: Callable[[], Optional[Callable]]
+
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class EventHandlerBase(State):
+    def __init__(
+        self,
+        state_machine: "StateMachine",
+        state_name: str,
+        event_handler_mappings: List[EventHandlerMapping],
+        timers: List[TimeoutHandlerMapping] = [],
+    ) -> None:
+
+        super().__init__(name=state_name, on_enter=self.start)
+        self.state_machine: "StateMachine" = state_machine
+        self.logger = logging.getLogger("state_machine")
+        self.events = state_machine.events
+        self.signal_state_machine_to_stop: ThreadEvent = (
+            state_machine.signal_state_machine_to_stop
+        )
+        self.event_handler_mappings = event_handler_mappings
+        self.state_name: str = state_name
+        self.timers = timers
+
+    def start(self) -> None:
+        self.state_machine.update_state()
+        self._run()
+
+    def stop(self) -> None:
+        return
+
+    def _run(self) -> None:
+        should_exit_state: bool = False
+        timers = deepcopy(self.timers)
+        entered_time = time.time()
+        while True:
+            if self.signal_state_machine_to_stop.is_set():
+                self.logger.info(
+                    "Stopping state machine from %s state", self.state_name
+                )
+                break
+
+            for timer in timers:
+                if time.time() - entered_time > timer.timeout_in_seconds:
+                    transition_func = timer.handler()
+                    timers.remove(timer)
+                    if transition_func is not None:
+                        transition_func()
+                        should_exit_state = True
+                        break
+
+            if should_exit_state:
+                break
+
+            for handler_mapping in self.event_handler_mappings:
+                transition_func = handler_mapping.handler(handler_mapping.event)
+                if transition_func is not None:
+                    transition_func()
+                    should_exit_state = True
+                    break
+
+            if should_exit_state:
+                break
+            time.sleep(settings.FSM_SLEEP_TIME)

isar/models/events.py

@@ -0,0 +1,118 @@
+from collections import deque
+from queue import Empty, Queue
+from typing import Generic, Optional, TypeVar
+
+from transitions import State
+
+from isar.apis.models.models import ControlMissionResponse
+from isar.config.settings import settings
+from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
+from robot_interface.models.mission.mission import Mission
+from robot_interface.models.mission.status import RobotStatus, TaskStatus
+from robot_interface.models.mission.task import TASKS
+
+T = TypeVar("T")
+T1 = TypeVar("T1")
+T2 = TypeVar("T2")
+
+
+class Event(Queue[T]):
+    def __init__(self) -> None:
+        super().__init__(maxsize=1)
+
+    def trigger_event(self, data: T) -> None:
+        self.put(data)
+
+    def consume_event(self, timeout: int = None) -> Optional[T]:
+        try:
+            return self.get(block=timeout is not None, timeout=timeout)
+        except Empty:
+            if timeout is not None:
+                raise EventTimeoutError
+            return None
+
+    def clear_event(self) -> None:
+        while True:
+            try:
+                self.get(block=False)
+            except Empty:
+                break
+
+    def has_event(self) -> bool:
+        return (
+            self.qsize() != 0
+        )  # Queue size is not reliable, but should be sufficient for this case
+
+    def check(self) -> Optional[T]:
+        if not self._qsize():
+            return None
+        with self.mutex:
+            queueList = list(self.queue)
+            return queueList.pop()
+
+    def update(self, item: T):
+        with self.mutex:
+            self.queue: deque[T] = deque()
+            self.queue.append(item)
+
+
+class Events:
+    def __init__(self) -> None:
+        self.api_requests: APIRequests = APIRequests()
+        self.state_machine_events: StateMachineEvents = StateMachineEvents()
+        self.robot_service_events: RobotServiceEvents = RobotServiceEvents()
+
+        self.upload_queue: Queue = Queue(maxsize=10)
+
+        if settings.MQTT_ENABLED:
+            self.mqtt_queue: Queue = Queue()
+
+
+class APIEvent(Generic[T1, T2]):
+    """
+    Creates input and output event. The events are defined such that the input is from
+    api to state machine while the output is from state machine to api.
+    """
+
+    def __init__(self):
+        self.input: Event[T1] = Event()
+        self.output: Event[T2] = Event()
+
+
+class APIRequests:
+    def __init__(self) -> None:
+        self.start_mission: APIEvent[Mission, bool] = APIEvent()
+        self.stop_mission: APIEvent[str, ControlMissionResponse] = APIEvent()
+        self.pause_mission: APIEvent[bool, ControlMissionResponse] = APIEvent()
+        self.resume_mission: APIEvent[bool, ControlMissionResponse] = APIEvent()
+        self.return_home: APIEvent[bool, bool] = APIEvent()
+
+
+class StateMachineEvents:
+    def __init__(self) -> None:
+        self.start_mission: Event[Mission] = Event()
+        self.stop_mission: Event[bool] = Event()
+        self.pause_mission: Event[bool] = Event()
+        self.task_status_request: Event[str] = Event()
+
+
+class RobotServiceEvents:
+    def __init__(self) -> None:
+        self.task_status_updated: Event[TaskStatus] = Event()
+        self.task_status_failed: Event[ErrorMessage] = Event()
+        self.mission_started: Event[bool] = Event()
+        self.mission_failed: Event[ErrorMessage] = Event()
+        self.robot_status_changed: Event[bool] = Event()
+        self.mission_failed_to_stop: Event[ErrorMessage] = Event()
+        self.mission_successfully_stopped: Event[bool] = Event()
+
+
+class SharedState:
+    def __init__(self) -> None:
+        self.state: Event[State] = Event()
+        self.robot_status: Event[RobotStatus] = Event()
+        self.state_machine_current_task: Event[TASKS] = Event()
+
+
+class EventTimeoutError(Exception):
+    pass

isar/modules.py

@@ -12,7 +12,7 @@ from isar.config.settings import settings
 from isar.mission_planner.local_planner import LocalPlanner
 from isar.mission_planner.sequential_task_selector import SequentialTaskSelector
 from isar.mission_planner.task_selector_interface import TaskSelectorInterface
-from isar.models.communication.queues.events import Events, SharedState
+from isar.models.events import Events, SharedState
 from isar.robot.robot import Robot
 from isar.services.utilities.robot_utilities import RobotUtilities
 from isar.services.utilities.scheduling_utilities import SchedulingUtilities

isar/robot/robot.py

@@ -1,20 +1,20 @@
 import logging
-from queue import Queue
-from threading import Event
+from threading import Event as ThreadEvent
 from typing import Optional
 
-from isar.models.communication.queues.events import (
+from isar.models.events import (
+    Event,
     Events,
     RobotServiceEvents,
     SharedState,
     StateMachineEvents,
 )
-from isar.models.communication.queues.queue_utils import check_for_event, trigger_event
 from isar.robot.robot_start_mission import RobotStartMissionThread
 from isar.robot.robot_status import RobotStatusThread
 from isar.robot.robot_stop_mission import RobotStopMissionThread
 from isar.robot.robot_task_status import RobotTaskStatusThread
 from robot_interface.models.exceptions.robot_exceptions import ErrorMessage, ErrorReason
+from robot_interface.models.mission.mission import Mission
 from robot_interface.robot_interface import RobotInterface
 
 
@@ -31,7 +31,7 @@ class Robot(object):
         self.robot_status_thread: Optional[RobotStatusThread] = None
         self.robot_task_status_thread: Optional[RobotTaskStatusThread] = None
         self.stop_mission_thread: Optional[RobotStopMissionThread] = None
-        self.signal_thread_quitting: Event = Event()
+        self.signal_thread_quitting: ThreadEvent = ThreadEvent()
 
     def stop(self) -> None:
         self.signal_thread_quitting.set()
@@ -53,8 +53,8 @@ class Robot(object):
         self.robot_task_status_thread = None
         self.start_mission_thread = None
 
-    def _check_and_handle_start_mission(self, event: Queue) -> None:
-        start_mission = check_for_event(event)
+    def _start_mission_event_handler(self, event: Event[Mission]) -> None:
+        start_mission = event.consume_event()
         if start_mission is not None:
             if (
                 self.start_mission_thread is not None
@@ -72,8 +72,8 @@ class Robot(object):
             )
             self.start_mission_thread.start()
 
-    def _check_and_handle_task_status_request(self, event: Queue[str]) -> None:
-        task_id: str = check_for_event(event)
+    def _task_status_request_handler(self, event: Event[str]) -> None:
+        task_id: str = event.consume_event()
         if task_id:
             self.robot_task_status_thread = RobotTaskStatusThread(
                 self.robot_service_events,
@@ -83,8 +83,8 @@ class Robot(object):
             )
             self.robot_task_status_thread.start()
 
-    def _check_and_handle_stop_mission(self, event: Queue) -> None:
-        if check_for_event(event):
+    def _stop_mission_request_handler(self, event: Event[bool]) -> None:
+        if event.consume_event():
             if (
                 self.stop_mission_thread is not None
                 and self.stop_mission_thread.is_alive()
@@ -102,8 +102,8 @@ class Robot(object):
                     error_reason=ErrorReason.RobotStillStartingMissionException,
                     error_description=error_description,
                 )
-                trigger_event(
-                    self.robot_service_events.mission_failed_to_stop, error_message
+                self.robot_service_events.mission_failed_to_stop.trigger_event(
+                    error_message
                 )
                 return
             self.stop_mission_thread = RobotStopMissionThread(
@@ -118,14 +118,12 @@ class Robot(object):
         self.robot_status_thread.start()
 
         while not self.signal_thread_quitting.wait(0):
-            self._check_and_handle_start_mission(
-                self.state_machine_events.start_mission
-            )
+            self._start_mission_event_handler(self.state_machine_events.start_mission)
 
-            self._check_and_handle_task_status_request(
+            self._task_status_request_handler(
                 self.state_machine_events.task_status_request
             )
 
-            self._check_and_handle_stop_mission(self.state_machine_events.stop_mission)
+            self._stop_mission_request_handler(self.state_machine_events.stop_mission)
 
         self.logger.info("Exiting robot service main thread")

isar/robot/robot_start_mission.py

@@ -2,11 +2,7 @@ import logging
 from threading import Event, Thread
 
 from isar.config.settings import settings
-from isar.models.communication.queues.events import RobotServiceEvents
-from isar.models.communication.queues.queue_utils import (
-    trigger_event,
-    trigger_event_without_data,
-)
+from isar.models.events import RobotServiceEvents
 from robot_interface.models.exceptions.robot_exceptions import (
     ErrorMessage,
     RobotException,
@@ -44,13 +40,13 @@ class RobotStartMissionThread(Thread):
                     self.logger.error(
                         f"Mission is infeasible and cannot be scheduled because: {e.error_description}"
                     )
-                    trigger_event(
-                        self.robot_service_events.mission_failed,
+                    self.robot_service_events.mission_failed.trigger_event(
                         ErrorMessage(
                             error_reason=e.error_reason,
                             error_description=e.error_description,
-                        ),
+                        )
                     )
+
                     break
                 except RobotException as e:
                     retries += 1
@@ -66,12 +62,11 @@ class RobotStartMissionThread(Thread):
                             f"{e.error_description}"
                         )
 
-                        trigger_event(
-                            self.robot_service_events.mission_failed,
+                        self.robot_service_events.mission_failed.trigger_event(
                             ErrorMessage(
                                 error_reason=e.error_reason,
                                 error_description=e.error_description,
-                            ),
+                            )
                         )
                         break
 
@@ -79,12 +74,11 @@ class RobotStartMissionThread(Thread):
 
                 started_mission = True
         except RobotInfeasibleMissionException as e:
-            trigger_event(
-                self.robot_service_events.mission_failed,
+            self.robot_service_events.mission_failed.trigger_event(
                 ErrorMessage(
                     error_reason=e.error_reason, error_description=e.error_description
                 ),
             )
 
         if started_mission:
-            trigger_event_without_data(self.robot_service_events.mission_started)
+            self.robot_service_events.mission_started.trigger_event(True)

isar/robot/robot_status.py

@@ -3,8 +3,7 @@ import time
 from threading import Event, Thread
 
 from isar.config.settings import settings
-from isar.models.communication.queues.events import SharedState
-from isar.models.communication.queues.queue_utils import update_shared_state
+from isar.models.events import SharedState
 from robot_interface.models.exceptions.robot_exceptions import RobotException
 from robot_interface.robot_interface import RobotInterface
 
@@ -49,7 +48,7 @@ class RobotStatusThread(Thread):
                 self.last_robot_status_poll_time = time.time()
 
                 robot_status = self.robot.robot_status()
-                update_shared_state(self.shared_state.robot_status, robot_status)
+                self.shared_state.robot_status.update(robot_status)
             except RobotException as e:
                 self.logger.error(f"Failed to retrieve robot status: {e}")
                 continue

isar/robot/robot_stop_mission.py

@@ -4,11 +4,7 @@ from threading import Event, Thread
 from typing import Optional
 
 from isar.config.settings import settings
-from isar.models.communication.queues.events import RobotServiceEvents
-from isar.models.communication.queues.queue_utils import (
-    trigger_event,
-    trigger_event_without_data,
-)
+from isar.models.events import RobotServiceEvents
 from robot_interface.models.exceptions.robot_exceptions import (
     ErrorMessage,
     RobotActionException,
@@ -51,9 +47,7 @@ class RobotStopMissionThread(Thread):
                 time.sleep(settings.FSM_SLEEP_TIME)
                 continue
 
-            trigger_event_without_data(
-                self.robot_service_events.mission_successfully_stopped
-            )
+            self.robot_service_events.mission_successfully_stopped.trigger_event(True)
             return
 
         error_description = (
@@ -68,4 +62,4 @@ class RobotStopMissionThread(Thread):
             error_description=error_description,
         )
 
-        trigger_event(self.robot_service_events.mission_failed_to_stop, error_message)
+        self.robot_service_events.mission_failed_to_stop.trigger_event(error_message)

isar/robot/robot_task_status.py

@@ -4,8 +4,7 @@ from threading import Event, Thread
 from typing import Optional
 
 from isar.config.settings import settings
-from isar.models.communication.queues.events import RobotServiceEvents
-from isar.models.communication.queues.queue_utils import trigger_event
+from isar.models.events import RobotServiceEvents
 from isar.services.utilities.threaded_request import ThreadedRequest
 from robot_interface.models.exceptions.robot_exceptions import (
     ErrorMessage,
@@ -82,10 +81,7 @@ class RobotTaskStatusThread(Thread):
                 )
                 break
 
-            trigger_event(self.robot_service_events.task_status_updated, task_status)
+            self.robot_service_events.task_status_updated.trigger_event(task_status)
             return
 
-        trigger_event(
-            self.robot_service_events.task_status_failed,
-            failed_task_error,
-        )
+        self.robot_service_events.task_status_failed.trigger_event(failed_task_error)

isar/script.py

@@ -10,7 +10,7 @@ from isar.apis.api import API
 from isar.config.log import setup_loggers
 from isar.config.open_telemetry import setup_open_telemetry
 from isar.config.settings import robot_settings, settings
-from isar.models.communication.queues.events import Events
+from isar.models.events import Events
 from isar.modules import ApplicationContainer, get_injector
 from isar.robot.robot import Robot
 from isar.services.service_connections.mqtt.mqtt_client import MqttClient
@@ -69,6 +69,7 @@ def print_startup_info():
     print_setting("Mission planner", settings.MISSION_PLANNER)
     print_setting("Using local storage", settings.STORAGE_LOCAL_ENABLED)
     print_setting("Using blob storage", settings.STORAGE_BLOB_ENABLED)
+    print_setting("Blob storage account", settings.BLOB_STORAGE_ACCOUNT)
     print_setting("Using async inspection uploading", settings.UPLOAD_INSPECTIONS_ASYNC)
     print_setting("Plant code", settings.PLANT_CODE)
     print_setting("Plant name", settings.PLANT_NAME)

isar/services/utilities/scheduling_utilities.py

@@ -1,8 +1,7 @@
 import logging
 from copy import deepcopy
 from http import HTTPStatus
-from queue import Empty
-from typing import Any, List
+from typing import List, TypeVar
 
 from fastapi import HTTPException
 from requests import HTTPError
@@ -14,15 +13,20 @@ from isar.mission_planner.mission_planner_interface import (
     MissionPlannerError,
     MissionPlannerInterface,
 )
-from isar.models.communication.message import StartMissionMessage
-from isar.models.communication.queues.events import APIRequests, Events, SharedState
-from isar.models.communication.queues.queue_io import QueueIO
-from isar.models.communication.queues.queue_timeout_error import QueueTimeoutError
-from isar.services.utilities.queue_utilities import QueueUtilities
+from isar.models.events import (
+    APIEvent,
+    APIRequests,
+    Events,
+    EventTimeoutError,
+    SharedState,
+)
 from isar.state_machine.states_enum import States
 from robot_interface.models.mission.mission import Mission
 from robot_interface.models.mission.status import MissionStatus
 
+T1 = TypeVar("T1")
+T2 = TypeVar("T2")
+
 
 class SchedulingUtilities:
     """
@@ -51,9 +55,8 @@ class SchedulingUtilities:
         HTTPException 500 Internal Server Error
             If the current state is not available on the queue
         """
-        try:
-            return self.shared_state.state.check()
-        except Empty:
+        current_state = self.shared_state.state.check()
+        if current_state is None:
             error_message: str = (
                 "Internal Server Error - Current state of the state machine is unknown"
             )
@@ -61,6 +64,7 @@ class SchedulingUtilities:
             raise HTTPException(
                 status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=error_message
             )
+        return current_state
 
     def get_mission(self, mission_id: str) -> Mission:
         """Get the mission with mission_id from the current mission planner
@@ -173,10 +177,10 @@ class SchedulingUtilities:
         """
         try:
             self._send_command(
-                StartMissionMessage(mission=deepcopy(mission)),
+                deepcopy(mission),
                 self.api_events.start_mission,
             )
-        except QueueTimeoutError:
+        except EventTimeoutError:
             error_message = "Internal Server Error - Failed to start mission in ISAR"
             self.logger.error(error_message)
             raise HTTPException(
@@ -199,7 +203,7 @@ class SchedulingUtilities:
                 True,
                 self.api_events.return_home,
             )
-        except QueueTimeoutError:
+        except EventTimeoutError:
             error_message = (
                 "Internal Server Error - Failed to start return home mission in ISAR"
             )
@@ -221,7 +225,7 @@ class SchedulingUtilities:
             response = self._send_command(True, self.api_events.pause_mission)
             self.logger.info("OK - Mission successfully paused")
             return response
-        except QueueTimeoutError:
+        except EventTimeoutError:
             error_message = "Internal Server Error - Failed to pause mission"
             self.logger.error(error_message)
             raise HTTPException(
@@ -240,7 +244,7 @@ class SchedulingUtilities:
             response = self._send_command(True, self.api_events.resume_mission)
             self.logger.info("OK - Mission successfully resumed")
             return response
-        except QueueTimeoutError:
+        except EventTimeoutError:
             error_message = "Internal Server Error - Failed to resume mission"
             self.logger.error(error_message)
             raise HTTPException(
@@ -277,7 +281,7 @@ class SchedulingUtilities:
                 raise HTTPException(
                     status_code=HTTPStatus.CONFLICT, detail=error_message
                 )
-        except QueueTimeoutError:
+        except EventTimeoutError:
             error_message = "Internal Server Error - Failed to stop mission"
             self.logger.error(error_message)
             raise HTTPException(
@@ -286,14 +290,12 @@ class SchedulingUtilities:
         self.logger.info("OK - Mission successfully stopped")
         return stop_mission_response
 
-    def _send_command(self, input: Any, queueio: QueueIO) -> Any:
-        queueio.input.put(input)
+    def _send_command(self, input: T1, api_event: APIEvent[T1, T2]) -> T2:
+        api_event.input.trigger_event(input)
         try:
-            return QueueUtilities.check_queue(
-                queueio.output,
-                self.queue_timeout,
-            )
-        except QueueTimeoutError as e:
-            QueueUtilities.clear_queue(queueio.input)
+            return api_event.output.consume_event(timeout=self.queue_timeout)
+        except EventTimeoutError as e:
+            self.logger.error("Queue timed out")
+            api_event.input.clear_event()
             self.logger.error("No output received for command to state machine")
             raise e