isar 1.25.8__py3-none-any.whl → 1.26.0__py3-none-any.whl

isar/robot/robot_status.py

@@ -0,0 +1,46 @@
+import logging
+import time
+from threading import Event, Thread
+
+from isar.config.settings import settings
+from isar.models.communication.queues.queue_utils import update_shared_state
+from isar.models.communication.queues.queues import Queues
+from robot_interface.robot_interface import RobotInterface
+
+
+class RobotStatusThread(Thread):
+
+    def __init__(
+        self, queues: Queues, robot: RobotInterface, signal_thread_quitting: Event
+    ):
+        self.logger = logging.getLogger("robot")
+        self.queues: Queues = queues
+        self.robot: RobotInterface = robot
+        self.signal_thread_quitting: Event = signal_thread_quitting
+        self.last_robot_status_poll_time: float = time.time()
+        Thread.__init__(self, name="Robot status thread", daemon=True)
+
+    def stop(self) -> None:
+        return
+
+    def _is_ready_to_poll_for_status(self) -> bool:
+        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
+        )
+
+    def run(self):
+        while True:
+            if self.signal_thread_quitting.is_set():
+                break
+
+            if not self._is_ready_to_poll_for_status():
+                continue
+
+            robot_status = self.robot.robot_status()
+
+            update_shared_state(self.queues.robot_status, robot_status)
+            self.last_robot_status_poll_time = time.time()
+        self.logger.info("Exiting robot status thread")

isar/robot/robot_task_status.py

@@ -0,0 +1,92 @@
+import logging
+import time
+from threading import Event, Thread
+from typing import Optional
+
+from isar.config.settings import settings
+from isar.models.communication.queues.queue_utils import trigger_event
+from isar.models.communication.queues.queues import Queues
+from isar.services.utilities.threaded_request import ThreadedRequest
+from robot_interface.models.exceptions.robot_exceptions import (
+    ErrorMessage,
+    RobotCommunicationException,
+    RobotCommunicationTimeoutException,
+    RobotException,
+    RobotTaskStatusException,
+)
+from robot_interface.models.mission.status import TaskStatus
+from robot_interface.robot_interface import RobotInterface
+
+
+class RobotTaskStatusThread(Thread):
+
+    def __init__(
+        self,
+        queues: Queues,
+        robot: RobotInterface,
+        signal_thread_quitting: Event,
+        task_id: str,
+    ):
+        self.logger = logging.getLogger("robot")
+        self.queues: Queues = queues
+        self.robot: RobotInterface = robot
+        self.start_mission_thread: Optional[ThreadedRequest] = None
+        self.signal_thread_quitting: Event = signal_thread_quitting
+        self.task_id: str = task_id
+        Thread.__init__(self, name="Robot task status thread")
+
+    def run(self):
+        task_status: TaskStatus = TaskStatus.NotStarted
+        failed_task_error: Optional[ErrorMessage] = None
+        request_status_failure_counter: int = 0
+
+        while (
+            request_status_failure_counter
+            < settings.REQUEST_STATUS_FAILURE_COUNTER_LIMIT
+        ):
+            if self.signal_thread_quitting.wait(0):
+                return
+            if request_status_failure_counter > 0:
+                time.sleep(settings.REQUEST_STATUS_COMMUNICATION_RECONNECT_DELAY)
+
+            try:
+                task_status = self.robot.task_status(self.task_id)
+                self.request_status_failure_counter = 0
+            except (
+                RobotCommunicationTimeoutException,
+                RobotCommunicationException,
+            ) as e:
+                self.request_status_failure_counter += 1
+                self.logger.error(
+                    f"Failed to get task status "
+                    f"{self.request_status_failure_counter} times because: "
+                    f"{e.error_description}"
+                )
+
+                failed_task_error = ErrorMessage(
+                    error_reason=e.error_reason,
+                    error_description=e.error_description,
+                )
+                continue
+
+            except RobotTaskStatusException as e:
+                failed_task_error = ErrorMessage(
+                    error_reason=e.error_reason,
+                    error_description=e.error_description,
+                )
+                break
+
+            except RobotException as e:
+                failed_task_error = ErrorMessage(
+                    error_reason=e.error_reason,
+                    error_description=e.error_description,
+                )
+                break
+
+            trigger_event(self.queues.robot_task_status, task_status)
+            return
+
+        trigger_event(
+            self.queues.robot_task_status_failed,
+            failed_task_error,
+        )

isar/script.py

@@ -14,6 +14,7 @@ from isar.config.log import setup_loggers
 from isar.config.settings import robot_settings, settings
 from isar.models.communication.queues.queues import Queues
 from isar.modules import get_injector
+from isar.robot.robot import Robot
 from isar.services.service_connections.mqtt.mqtt_client import MqttClient
 from isar.services.service_connections.mqtt.robot_heartbeat_publisher import (
     RobotHeartbeatPublisher,
@@ -94,6 +95,7 @@ def start() -> None:
     uploader: Uploader = injector.get(Uploader)
     robot: RobotInterface = injector.get(RobotInterface)
     queues: Queues = injector.get(Queues)
+    robot_service: Robot = injector.get(Robot)
 
     threads: List[Thread] = []
 
@@ -107,6 +109,11 @@ def start() -> None:
     )
     threads.append(uploader_thread)
 
+    robot_service_thread: Thread = Thread(
+        target=robot_service.run, name="Robot service", daemon=True
+    )
+    threads.append(robot_service_thread)
+
     if settings.UPLOAD_INSPECTIONS_ASYNC:
 
         def inspections_callback(inspection: Inspection, mission: Mission):

isar/services/utilities/scheduling_utilities.py

@@ -2,9 +2,8 @@ import logging
 from copy import deepcopy
 from http import HTTPStatus
 from queue import Empty
-from typing import Any, List, Optional, Set
+from typing import Any, List
 
-from alitra import Pose
 from fastapi import HTTPException
 from injector import inject
 from requests import HTTPError
@@ -18,10 +17,8 @@ from isar.mission_planner.mission_planner_interface import (
 )
 from isar.models.communication.message import StartMissionMessage
 from isar.models.communication.queues.queue_io import QueueIO
+from isar.models.communication.queues.queue_timeout_error import QueueTimeoutError
 from isar.models.communication.queues.queues import Queues
-from isar.models.communication.queues.queue_timeout_error import (
-    QueueTimeoutError,
-)
 from isar.services.utilities.queue_utilities import QueueUtilities
 from isar.state_machine.states_enum import States
 from robot_interface.models.mission.mission import Mission
@@ -102,14 +99,11 @@ class SchedulingUtilities:
         HTTPException 400 Bad request
             If the robot is not capable of performing mission
         """
-        is_capable: bool = True
-        missing_capabilities: Set[str] = set()
-        for task in mission.tasks:
-            if task.type not in robot_capabilities:
-                is_capable = False
-                missing_capabilities.add(task.type)
-
-        if not is_capable:
+        missing_capabilities = {
+            task.type for task in mission.tasks if task.type not in robot_capabilities
+        }
+
+        if missing_capabilities:
             error_message = (
                 f"Bad Request - Robot is not capable of performing mission."
                 f" Missing functionalities: {missing_capabilities}."
@@ -120,7 +114,7 @@ class SchedulingUtilities:
                 detail=error_message,
             )
 
-        return is_capable
+        return True
 
     def verify_state_machine_ready_to_receive_mission(self, state: States) -> bool:
         """Verify that the state machine is idle and ready to receive a mission
@@ -130,18 +124,16 @@ class SchedulingUtilities:
         HTTPException 409 Conflict
             If state machine is not idle and therefore can not start a new mission
         """
-        is_state_machine_ready_to_receive_mission = state == States.Idle
-        if not is_state_machine_ready_to_receive_mission:
+        if state != States.Idle:
             error_message = f"Conflict - Robot is not idle - State: {state}"
             self.logger.warning(error_message)
             raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
 
-        return is_state_machine_ready_to_receive_mission
+        return True
 
     def start_mission(
         self,
         mission: Mission,
-        initial_pose: Optional[Pose],
     ) -> None:
         """Start mission
 
@@ -152,11 +144,8 @@ class SchedulingUtilities:
         """
         try:
             self._send_command(
-                StartMissionMessage(
-                    mission=deepcopy(mission),
-                    initial_pose=initial_pose,
-                ),
-                self.queues.start_mission,
+                StartMissionMessage(mission=deepcopy(mission)),
+                self.queues.api_start_mission,
             )
         except QueueTimeoutError:
             error_message = "Internal Server Error - Failed to start mission in ISAR"
@@ -175,7 +164,7 @@ class SchedulingUtilities:
             If there is a timeout while communicating with the state machine
         """
         try:
-            return self._send_command(True, self.queues.pause_mission)
+            return self._send_command(True, self.queues.api_pause_mission)
         except QueueTimeoutError:
             error_message = "Internal Server Error - Failed to pause mission"
             self.logger.error(error_message)
@@ -194,7 +183,7 @@ class SchedulingUtilities:
             If there is a timeout while communicating with the state machine
         """
         try:
-            return self._send_command(True, self.queues.resume_mission)
+            return self._send_command(True, self.queues.api_resume_mission)
         except QueueTimeoutError:
             error_message = "Internal Server Error - Failed to resume mission"
             self.logger.error(error_message)
@@ -214,7 +203,7 @@ class SchedulingUtilities:
         """
         try:
             stop_mission_response: ControlMissionResponse = self._send_command(
-                True, self.queues.stop_mission
+                True, self.queues.api_stop_mission
             )
         except QueueTimeoutError:
             error_message = "Internal Server Error - Failed to stop mission"