isar 1.25.9__py3-none-any.whl → 1.26.1__py3-none-any.whl

isar/state_machine/states/idle.py

@@ -1,16 +1,16 @@
 import logging
 import time
+from queue import Queue
 from typing import TYPE_CHECKING, Optional
 
 from transitions import State
 
-from isar.config.settings import settings
 from isar.models.communication.message import StartMissionMessage
-from isar.services.utilities.threaded_request import (
-    ThreadedRequest,
-    ThreadedRequestNotFinishedError,
+from isar.models.communication.queues.queue_utils import (
+    check_for_event,
+    check_shared_state,
 )
-from robot_interface.models.exceptions.robot_exceptions import RobotException
+from isar.models.communication.queues.status_queue import StatusQueue
 from robot_interface.models.mission.status import RobotStatus
 
 if TYPE_CHECKING:
@@ -22,82 +22,60 @@ class Idle(State):
         super().__init__(name="idle", on_enter=self.start, on_exit=self.stop)
         self.state_machine: "StateMachine" = state_machine
         self.logger = logging.getLogger("state_machine")
-        self.robot_status_thread: Optional[ThreadedRequest] = None
         self.last_robot_status_poll_time: float = time.time()
-        self.status_checked_at_least_once: bool = False
+        self.events = self.state_machine.events
+        self.shared_state = self.state_machine.shared_state
 
     def start(self) -> None:
         self.state_machine.update_state()
         self._run()
 
     def stop(self) -> None:
-        if self.robot_status_thread:
-            self.robot_status_thread.wait_for_thread()
-        self.robot_status_thread = None
-        self.status_checked_at_least_once = False
+        return
 
-    def _is_ready_to_poll_for_status(self) -> bool:
-        if not self.status_checked_at_least_once:
+    def _check_and_handle_stop_mission_event(self, event: Queue) -> bool:
+        if check_for_event(event):
+            self.state_machine.stop()  # type: ignore
             return True
-
-        time_since_last_robot_status_poll = (
-            time.time() - self.last_robot_status_poll_time
-        )
-        return (
-            time_since_last_robot_status_poll > settings.ROBOT_API_STATUS_POLL_INTERVAL
-        )
+        return False
+
+    def _check_and_handle_start_mission_event(
+        self, event: Queue[StartMissionMessage]
+    ) -> bool:
+        start_mission: Optional[StartMissionMessage] = check_for_event(event)
+        if start_mission:
+            self.state_machine.start_mission(mission=start_mission.mission)
+            self.state_machine.request_mission_start()  # type: ignore
+            return True
+        return False
+
+    def _check_and_handle_robot_status_event(
+        self, event: StatusQueue[RobotStatus]
+    ) -> bool:
+        robot_status: RobotStatus = check_shared_state(event)
+        if robot_status == RobotStatus.Offline:
+            self.state_machine.robot_turned_offline()  # type: ignore
+            return True
+        elif robot_status == RobotStatus.BlockedProtectiveStop:
+            self.state_machine.robot_protective_stop_engaged()  # type: ignore
+            return True
+        return False
 
     def _run(self) -> None:
         while True:
-            if self.state_machine.should_stop_mission():
-                transition = self.state_machine.stop  # type: ignore
+            if self._check_and_handle_stop_mission_event(
+                self.events.api_requests.stop_mission.input
+            ):
                 break
 
-            if self.status_checked_at_least_once:
-                start_mission: Optional[StartMissionMessage] = (
-                    self.state_machine.should_start_mission()
-                )
-                if start_mission:
-                    self.state_machine.start_mission(
-                        mission=start_mission.mission,
-                        initial_pose=start_mission.initial_pose,
-                    )
-                    transition = self.state_machine.mission_started  # type: ignore
-                    break
-                time.sleep(self.state_machine.sleep_time)
-
-            if not self._is_ready_to_poll_for_status():
-                continue
-
-            if not self.robot_status_thread:
-                self.robot_status_thread = ThreadedRequest(
-                    request_func=self.state_machine.robot.robot_status
-                )
-                self.robot_status_thread.start_thread(
-                    name="State Machine Offline Get Robot Status"
-                )
-
-            try:
-                robot_status: RobotStatus = self.robot_status_thread.get_output()
-                self.status_checked_at_least_once = True
-            except ThreadedRequestNotFinishedError:
-                time.sleep(self.state_machine.sleep_time)
-                continue
-
-            except RobotException as e:
-                self.logger.error(
-                    f"Failed to get robot status because: {e.error_description}"
-                )
-
-            self.last_robot_status_poll_time = time.time()
-
-            if robot_status == RobotStatus.Offline:
-                transition = self.state_machine.robot_turned_offline  # type: ignore
-                break
-            elif robot_status == RobotStatus.BlockedProtectiveStop:
-                transition = self.state_machine.robot_protective_stop_engaged  # type: ignore
+            if self._check_and_handle_start_mission_event(
+                self.events.api_requests.start_mission.input
+            ):
                 break
 
-            self.robot_status_thread = None
+            if self._check_and_handle_robot_status_event(
+                self.shared_state.robot_status
+            ):
+                break
 
-        transition()
+            time.sleep(self.state_machine.sleep_time)

isar/state_machine/states/monitor.py

@@ -1,23 +1,19 @@
 import logging
 import time
 from copy import deepcopy
-from typing import TYPE_CHECKING, Callable, Optional, Tuple, Union
+from queue import Queue
+from typing import TYPE_CHECKING, Optional, Tuple
 
 from injector import inject
 from transitions import State
 
 from isar.config.settings import settings
-from isar.services.utilities.threaded_request import (
-    ThreadedRequest,
-    ThreadedRequestNotFinishedError,
-)
+from isar.models.communication.queues.queue_utils import check_for_event, trigger_event
+from isar.services.utilities.threaded_request import ThreadedRequest
 from robot_interface.models.exceptions.robot_exceptions import (
     ErrorMessage,
-    RobotCommunicationException,
-    RobotCommunicationTimeoutException,
     RobotException,
     RobotRetrieveInspectionException,
-    RobotTaskStatusException,
 )
 from robot_interface.models.inspection.inspection import Inspection
 from robot_interface.models.mission.mission import Mission
@@ -33,131 +29,146 @@ class Monitor(State):
     def __init__(self, state_machine: "StateMachine") -> None:
         super().__init__(name="monitor", on_enter=self.start, on_exit=self.stop)
         self.state_machine: "StateMachine" = state_machine
-        self.request_status_failure_counter: int = 0
-        self.request_status_failure_counter_limit: int = (
-            settings.REQUEST_STATUS_FAILURE_COUNTER_LIMIT
-        )
 
         self.logger = logging.getLogger("state_machine")
-        self.task_status_thread: Optional[ThreadedRequest] = None
+        self.events = self.state_machine.events
+
+        self.awaiting_task_status: bool = False
 
     def start(self) -> None:
         self.state_machine.update_state()
         self._run()
 
     def stop(self) -> None:
-        if self.task_status_thread:
-            self.task_status_thread.wait_for_thread()
-        self.task_status_thread = None
+        self.state_machine.mission_ongoing = False
+        return
 
-    def _run(self) -> None:
-        transition: Callable
-        while True:
-            if self.state_machine.should_stop_mission():
-                transition = self.state_machine.stop  # type: ignore
-                break
+    def _check_and_handle_stop_mission_event(self, event: Queue) -> bool:
+        if check_for_event(event):
+            self.state_machine.stop()  # type: ignore
+            return True
+        return False
 
-            if self.state_machine.should_pause_mission():
-                transition = self.state_machine.pause  # type: ignore
-                break
+    def _check_and_handle_pause_mission_event(self, event: Queue) -> bool:
+        if check_for_event(event):
+            self.state_machine.pause()  # type: ignore
+            return True
+        return False
 
-            if not self.task_status_thread:
-                self._run_get_status_thread(
-                    status_function=self.state_machine.robot.task_status,
-                    function_argument=self.state_machine.current_task.id,
-                    thread_name="State Machine Monitor Get Task Status",
-                )
-            try:
-                status: TaskStatus = self.task_status_thread.get_output()
-                self.request_status_failure_counter = 0
-            except ThreadedRequestNotFinishedError:
-                time.sleep(self.state_machine.sleep_time)
-                continue
-            except (
-                RobotCommunicationTimeoutException,
-                RobotCommunicationException,
-            ) as e:
-                retry_limit_exceeded: bool = self._check_if_exceeded_retry_limit(e)
-                if retry_limit_exceeded:
-                    self.logger.error(
-                        f"Monitoring task {self.state_machine.current_task.id[:8]} failed "
-                        f"because: {e.error_description}"
-                    )
-                    status = TaskStatus.Failed
-                else:
-                    time.sleep(settings.REQUEST_STATUS_COMMUNICATION_RECONNECT_DELAY)
-                    continue
-
-            except RobotTaskStatusException as e:
-                self.state_machine.current_task.error_message = ErrorMessage(
-                    error_reason=e.error_reason, error_description=e.error_description
-                )
-                self.logger.error(
-                    f"Monitoring task {self.state_machine.current_task.id[:8]} failed "
-                    f"because: {e.error_description}"
-                )
-                status = TaskStatus.Failed
+    def _check_and_handle_mission_started_event(self, event: Queue) -> None:
+        if not self.state_machine.mission_ongoing:
+            if check_for_event(event):
+                self.state_machine.mission_ongoing = True
+
+    def _check_and_handle_mission_failed_event(self, event: Queue) -> bool:
+        mission_failed: Optional[ErrorMessage] = check_for_event(event)
+        if mission_failed is not None:
+            self.state_machine.logger.warning(
+                f"Failed to initiate mission "
+                f"{str(self.state_machine.current_mission.id)[:8]} because: "
+                f"{mission_failed.error_description}"
+            )
+            self.state_machine.current_mission.error_message = ErrorMessage(
+                error_reason=mission_failed.error_reason,
+                error_description=mission_failed.error_description,
+            )
 
-            except RobotException as e:
-                self._set_error_message(e)
-                status = TaskStatus.Failed
+            self.state_machine.mission_failed_to_start()  # type: ignore
+            return True
+        return False
 
-                self.logger.error(
-                    f"Retrieving the status failed because: {e.error_description}"
-                )
+    def _check_and_handle_task_status_failed_event(self, event: Queue) -> bool:
+        task_failure: Optional[ErrorMessage] = check_for_event(event)
+        if task_failure is not None:
+            self.awaiting_task_status = False
+            self.state_machine.current_task.error_message = task_failure
+            self.logger.error(
+                f"Monitoring task {self.state_machine.current_task.id[:8]} failed "
+                f"because: {task_failure.error_description}"
+            )
+            return self._handle_new_task_status(TaskStatus.Failed)
+        elif not self.awaiting_task_status:
+            trigger_event(
+                self.events.state_machine_events.task_status_request,
+                self.state_machine.current_task.id,
+            )
+            self.awaiting_task_status = True
+        return False
 
-            if not isinstance(status, TaskStatus):
-                self.logger.error(
-                    f"Received an invalid status update {status} when monitoring mission. "
-                    "Only TaskStatus is expected."
-                )
-                break
+    def _check_and_handle_task_status_event(self, event: Queue) -> bool:
+        status: Optional[TaskStatus] = check_for_event(event)
+        if status is not None:
+            self.awaiting_task_status = False
+            return self._handle_new_task_status(status)
+        elif not self.awaiting_task_status:
+            trigger_event(
+                self.events.state_machine_events.task_status_request,
+                self.state_machine.current_task.id,
+            )
+            self.awaiting_task_status = True
+        return False
+
+    def _handle_new_task_status(self, status: TaskStatus) -> bool:
+        if self.state_machine.current_task is None:
+            self.state_machine.iterate_current_task()
+
+        self.state_machine.current_task.status = status
 
+        if self._should_upload_inspections():
+            get_inspection_thread = ThreadedRequest(self._queue_inspections_for_upload)
+            get_inspection_thread.start_thread(
+                deepcopy(self.state_machine.current_mission),
+                deepcopy(self.state_machine.current_task),
+                name="State Machine Get Inspections",
+            )
+
+        if self.state_machine.current_task.is_finished():
+            self._report_task_status(self.state_machine.current_task)
+            self.state_machine.publish_task_status(task=self.state_machine.current_task)
+
+            self.state_machine.iterate_current_task()
             if self.state_machine.current_task is None:
-                self.state_machine.iterate_current_task()
+                self.state_machine.mission_finished()  # type: ignore
+                return True
 
-            self.state_machine.current_task.status = status
+            # Report and update next task
+            self.state_machine.current_task.update_task_status()
+            self.state_machine.publish_task_status(task=self.state_machine.current_task)
+        return False
 
-            if (
-                not settings.UPLOAD_INSPECTIONS_ASYNC
-                and self._should_upload_inspections()
+    def _run(self) -> None:
+        self.awaiting_task_status = False
+        while True:
+            if self._check_and_handle_stop_mission_event(
+                self.events.api_requests.stop_mission.input
             ):
-                get_inspection_thread = ThreadedRequest(
-                    self._queue_inspections_for_upload
-                )
-                get_inspection_thread.start_thread(
-                    deepcopy(self.state_machine.current_mission),
-                    deepcopy(self.state_machine.current_task),
-                    name="State Machine Get Inspections",
-                )
+                break
 
-            if self.state_machine.current_task.is_finished():
-                self._report_task_status(self.state_machine.current_task)
-                self.state_machine.publish_task_status(
-                    task=self.state_machine.current_task
-                )
+            if self._check_and_handle_pause_mission_event(
+                self.events.api_requests.pause_mission.input
+            ):
+                break
 
-                self.state_machine.iterate_current_task()
-                if self.state_machine.current_task is None:
-                    transition = self.state_machine.mission_finished  # type: ignore
-                    break
+            self._check_and_handle_mission_started_event(
+                self.events.robot_service_events.mission_started
+            )
 
-                # Report and update next task
-                self.state_machine.current_task.update_task_status()
-                self.state_machine.publish_task_status(
-                    task=self.state_machine.current_task
-                )
+            if self._check_and_handle_mission_failed_event(
+                self.events.robot_service_events.mission_failed
+            ):
+                break
 
-            self.task_status_thread = None
-            time.sleep(self.state_machine.sleep_time)
+            if self._check_and_handle_task_status_failed_event(
+                self.events.robot_service_events.task_status_failed
+            ):
+                break
 
-        transition()
+            if self._check_and_handle_task_status_event(
+                self.events.robot_service_events.task_status_updated
+            ):
+                break
 
-    def _run_get_status_thread(
-        self, status_function: Callable, function_argument: str, thread_name: str
-    ) -> None:
-        self.task_status_thread = ThreadedRequest(request_func=status_function)
-        self.task_status_thread.start_thread(function_argument, name=thread_name)
+            time.sleep(settings.FSM_SLEEP_TIME)
 
     def _queue_inspections_for_upload(
         self, mission: Mission, current_task: InspectionTask
@@ -180,6 +191,12 @@ class Monitor(State):
             )
             return
 
+        except Exception as e:
+            self.logger.error(
+                f"Failed to retrieve inspections because of unexpected error: {e}"
+            )
+            return
+
         if not inspection:
             self.logger.warning(
                 f"No inspection result data retrieved for task {str(current_task.id)[:8]}"
@@ -191,7 +208,7 @@ class Monitor(State):
             inspection,
             mission,
         )
-        self.state_machine.queues.upload_queue.put(message)
+        self.state_machine.events.upload_queue.put(message)
         self.logger.info(
             f"Inspection result: {str(inspection.id)[:8]} queued for upload"
         )
@@ -207,6 +224,9 @@ class Monitor(State):
             )
 
     def _should_upload_inspections(self) -> bool:
+        if settings.UPLOAD_INSPECTIONS_ASYNC:
+            return False
+
         return (
             self.state_machine.current_task.is_finished()
             and self.state_machine.current_task.status == TaskStatus.Successful
@@ -218,33 +238,3 @@ class Monitor(State):
             error_reason=e.error_reason, error_description=e.error_description
         )
         self.state_machine.current_task.error_message = error_message
-
-    def _check_if_exceeded_retry_limit(
-        self, e: Union[RobotCommunicationTimeoutException, RobotCommunicationException]
-    ) -> bool:
-        self.state_machine.current_mission.error_message = ErrorMessage(
-            error_reason=e.error_reason, error_description=e.error_description
-        )
-        self.task_status_thread = None
-        self.request_status_failure_counter += 1
-        self.logger.warning(
-            f"Monitoring task {self.state_machine.current_task.id} failed #: "
-            f"{self.request_status_failure_counter} failed because: {e.error_description}"
-        )
-
-        if (
-            self.request_status_failure_counter
-            >= self.request_status_failure_counter_limit
-        ):
-            self.state_machine.current_task.error_message = ErrorMessage(
-                error_reason=e.error_reason,
-                error_description=e.error_description,
-            )
-            self.logger.error(
-                f"Task will be cancelled after failing to get task status "
-                f"{self.request_status_failure_counter} times because: "
-                f"{e.error_description}"
-            )
-            return True
-
-        return False

isar/state_machine/states/offline.py

@@ -1,15 +1,10 @@
 import logging
 import time
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from transitions import State
 
-from isar.config.settings import settings
-from isar.services.utilities.threaded_request import (
-    ThreadedRequest,
-    ThreadedRequestNotFinishedError,
-)
-from robot_interface.models.exceptions.robot_exceptions import RobotException
+from isar.models.communication.queues.queue_utils import check_shared_state
 from robot_interface.models.mission.status import RobotStatus
 
 if TYPE_CHECKING:
@@ -21,43 +16,27 @@ class Offline(State):
         super().__init__(name="offline", on_enter=self.start, on_exit=self.stop)
         self.state_machine: "StateMachine" = state_machine
         self.logger = logging.getLogger("state_machine")
-        self.robot_status_thread: Optional[ThreadedRequest] = None
+        self.shared_state = self.state_machine.shared_state
 
     def start(self) -> None:
         self.state_machine.update_state()
         self._run()
 
     def stop(self) -> None:
-        if self.robot_status_thread:
-            self.robot_status_thread.wait_for_thread()
-        self.robot_status_thread = None
+        return
 
     def _run(self) -> None:
         while True:
-            if not self.robot_status_thread:
-                self.robot_status_thread = ThreadedRequest(
-                    request_func=self.state_machine.robot.robot_status
-                )
-                self.robot_status_thread.start_thread(
-                    name="State Machine Offline Get Robot Status"
-                )
-
-            try:
-                robot_status: RobotStatus = self.robot_status_thread.get_output()
-            except ThreadedRequestNotFinishedError:
-                time.sleep(self.state_machine.sleep_time)
-                continue
-
-            except RobotException as e:
-                self.logger.error(
-                    f"Failed to get robot status because: {e.error_description}"
-                )
-
-            if robot_status != RobotStatus.Offline:
+            robot_status: RobotStatus = check_shared_state(
+                self.shared_state.robot_status
+            )
+            if robot_status == RobotStatus.BlockedProtectiveStop:
+                transition = self.state_machine.robot_protective_stop_engaged  # type: ignore
+                break
+            elif robot_status != RobotStatus.Offline:
                 transition = self.state_machine.robot_turned_online  # type: ignore
                 break
 
-            self.robot_status_thread = None
-            time.sleep(settings.ROBOT_API_STATUS_POLL_INTERVAL)
+            time.sleep(self.state_machine.sleep_time)
 
         transition()

isar/state_machine/states/paused.py

@@ -1,9 +1,11 @@
 import logging
 import time
-from typing import Callable, TYPE_CHECKING
+from typing import TYPE_CHECKING, Callable
 
 from transitions import State
 
+from isar.models.communication.queues.queue_utils import check_for_event
+
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
@@ -13,6 +15,7 @@ class Paused(State):
         super().__init__(name="paused", on_enter=self.start)
         self.state_machine: "StateMachine" = state_machine
         self.logger = logging.getLogger("state_machine")
+        self.events = self.state_machine.events
 
     def start(self) -> None:
         self.state_machine.update_state()
@@ -21,11 +24,11 @@ class Paused(State):
     def _run(self) -> None:
         transition: Callable
         while True:
-            if self.state_machine.should_stop_mission():
+            if check_for_event(self.events.api_requests.pause_mission.input):
                 transition = self.state_machine.stop  # type: ignore
                 break
 
-            if self.state_machine.should_resume_mission():
+            if check_for_event(self.events.api_requests.resume_mission.input):
                 transition = self.state_machine.resume  # type: ignore
                 break