isar 1.20.2__py3-none-any.whl → 1.34.13__py3-none-any.whl

isar/apis/api.py

@@ -1,65 +1,70 @@
+import json
 import logging
+import time
+from datetime import datetime, timezone
 from http import HTTPStatus
 from logging import Logger
 from typing import List, Union
 
 import click
 import uvicorn
-from fastapi import FastAPI, Request, Security
+from fastapi import FastAPI, Security
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.routing import APIRouter
-from injector import inject
-from opencensus.ext.azure.trace_exporter import AzureExporter
-from opencensus.trace.attributes_helper import COMMON_ATTRIBUTES
-from opencensus.trace.samplers import ProbabilitySampler
-from opencensus.trace.span import SpanKind
-from opencensus.trace.tracer import Tracer
 from pydantic import AnyHttpUrl
 
 from isar.apis.models.models import ControlMissionResponse, StartMissionResponse
+from isar.apis.robot_control.robot_controller import RobotController
 from isar.apis.schedule.scheduling_controller import SchedulingController
 from isar.apis.security.authentication import Authenticator
-from isar.config.configuration_error import ConfigurationError
-from isar.config.keyvault.keyvault_error import KeyvaultError
 from isar.config.keyvault.keyvault_service import Keyvault
 from isar.config.settings import settings
-
-HTTP_URL = COMMON_ATTRIBUTES["HTTP_URL"]
-HTTP_STATUS_CODE = COMMON_ATTRIBUTES["HTTP_STATUS_CODE"]
+from robot_interface.telemetry.mqtt_client import MqttClientInterface
+from robot_interface.telemetry.payloads import StartUpMessagePayload
+from robot_interface.utilities.json_service import EnhancedJSONEncoder
 
 
 class API:
-    @inject
     def __init__(
         self,
         authenticator: Authenticator,
         scheduling_controller: SchedulingController,
-        keyvault_client: Keyvault,
+        robot_controller: RobotController,
+        keyvault: Keyvault,
+        mqtt_publisher: MqttClientInterface,
         port: int = settings.API_PORT,
-        azure_ai_logging_enabled: bool = settings.LOG_HANDLER_APPLICATION_INSIGHTS_ENABLED,
     ) -> None:
         self.authenticator: Authenticator = authenticator
         self.scheduling_controller: SchedulingController = scheduling_controller
-        self.keyvault_client: Keyvault = keyvault_client
+        self.robot_controller: RobotController = robot_controller
+        self.keyvault: Keyvault = keyvault
         self.host: str = "0.0.0.0"  # Locking uvicorn to use 0.0.0.0
         self.port: int = port
-        self.azure_ai_logging_enabled: bool = azure_ai_logging_enabled
+        self.mqtt_publisher: MqttClientInterface = mqtt_publisher
 
         self.logger: Logger = logging.getLogger("api")
 
         self.app: FastAPI = self._create_app()
+        self.server = self._setup_server()
 
     def get_app(self) -> FastAPI:
         return self.app
 
-    def run_app(self) -> None:
-        uvicorn.run(
+    def _setup_server(self) -> uvicorn.Server:
+        config = uvicorn.Config(
             self.app,
             port=self.port,
             host=self.host,
             reload=False,
             log_config=None,
         )
+        return uvicorn.Server(config)
+
+    def wait_for_api_server_ready(self) -> None:
+        while not self.server.started:
+            time.sleep(0.01)
+        self.logger.info("Uvicorn server has been started")
+        self._publish_startup_message()
 
     def _create_app(self) -> FastAPI:
         tags_metadata = [
@@ -70,7 +75,10 @@ class API:
         ]
         app = FastAPI(
             openapi_tags=tags_metadata,
-            on_startup=[self.authenticator.load_config, self._log_startup_message],
+            on_startup=[
+                self.authenticator.load_config,
+                self._log_startup_message,
+            ],
             swagger_ui_oauth2_redirect_url="/oauth2-redirect",
             swagger_ui_init_oauth={
                 "usePkceWithAuthorizationCodeGrant": True,
@@ -91,13 +99,12 @@ class API:
                 allow_headers=["*"],
             )
 
-        if self.azure_ai_logging_enabled:
-            self._add_request_logging_middleware(app)
-
         app.include_router(router=self._create_scheduler_router())
 
         app.include_router(router=self._create_info_router())
 
+        app.include_router(router=self._create_media_control_router())
+
         return app
 
     def _create_scheduler_router(self) -> APIRouter:
@@ -106,37 +113,39 @@ class API:
         authentication_dependency: Security = Security(self.authenticator.get_scheme())
 
         router.add_api_route(
-            path="/schedule/start-mission/{id}",
-            endpoint=self.scheduling_controller.start_mission_by_id,
+            path="/schedule/start-mission",
+            endpoint=self.scheduling_controller.start_mission,
             methods=["POST"],
-            deprecated=True,
             dependencies=[authentication_dependency],
-            summary="Start a mission with id='id' from the current mission planner",
+            summary="Start the mission provided in JSON format",
             responses={
                 HTTPStatus.OK.value: {
                     "description": "Mission succesfully started",
                     "model": StartMissionResponse,
                 },
-                HTTPStatus.NOT_FOUND.value: {
-                    "description": "Not found - Mission not found",
+                HTTPStatus.UNPROCESSABLE_ENTITY.value: {
+                    "description": "Invalid body - The JSON is incorrect",
                 },
                 HTTPStatus.CONFLICT.value: {
                     "description": "Conflict - Invalid command in the current state",
                 },
+                HTTPStatus.BAD_REQUEST.value: {
+                    "description": "Bad request - Robot does not have the capabilities to perform the mission",
+                },
                 HTTPStatus.INTERNAL_SERVER_ERROR.value: {
                     "description": "Internal Server Error - Current state of state machine unknown",
                 },
             },
         )
         router.add_api_route(
-            path="/schedule/start-mission",
-            endpoint=self.scheduling_controller.start_mission,
+            path="/schedule/return-home",
+            endpoint=self.scheduling_controller.return_home,
             methods=["POST"],
             dependencies=[authentication_dependency],
-            summary="Start the mission provided in JSON format",
+            summary="Start return home mission",
             responses={
                 HTTPStatus.OK.value: {
-                    "description": "Mission succesfully started",
+                    "description": "Return home mission succesfully started",
                     "model": StartMissionResponse,
                 },
                 HTTPStatus.UNPROCESSABLE_ENTITY.value: {
@@ -161,9 +170,15 @@ class API:
                     "description": "Mission succesfully stopped",
                     "model": ControlMissionResponse,
                 },
+                HTTPStatus.UNPROCESSABLE_ENTITY.value: {
+                    "description": "Invalid body - The JSON is incorrect",
+                },
                 HTTPStatus.CONFLICT.value: {
                     "description": "Conflict - Invalid command in the current state",
                 },
+                HTTPStatus.BAD_REQUEST.value: {
+                    "description": "Bad request - Robot does not have the capabilities to perform the mission",
+                },
                 HTTPStatus.INTERNAL_SERVER_ERROR.value: {
                     "description": "Internal Server Error - Current state of state machine unknown",
                 },
@@ -208,60 +223,86 @@ class API:
             },
         )
         router.add_api_route(
-            path="/schedule/drive-to",
-            endpoint=self.scheduling_controller.drive_to,
+            path="/schedule/lockdown",
+            endpoint=self.scheduling_controller.lockdown,
             methods=["POST"],
             dependencies=[authentication_dependency],
-            summary="Drive to the provided pose",
+            summary="Send the robot to dock and ensure that it stays there",
             responses={
-                HTTPStatus.OK.value: {
-                    "description": "Drive to succesfully started",
-                },
+                HTTPStatus.OK.value: {"description": "Robot going to dock"},
                 HTTPStatus.CONFLICT.value: {
-                    "description": "Conflict - Invalid command in the current state",
+                    "description": "Conflict - Invalid command in the current state"
                 },
                 HTTPStatus.INTERNAL_SERVER_ERROR.value: {
-                    "description": "Internal Server Error - Current state of state machine unknown",
+                    "description": "Internal Server Error - Current state of state machine unknown"
                 },
             },
         )
         router.add_api_route(
-            path="/schedule/start-localization-mission",
-            endpoint=self.scheduling_controller.start_localization_mission,
+            path="/schedule/release-lockdown",
+            endpoint=self.scheduling_controller.release_lockdown,
             methods=["POST"],
             dependencies=[authentication_dependency],
-            summary="Localize at the provided pose",
+            summary="Allow the robot to start missions again",
             responses={
                 HTTPStatus.OK.value: {
-                    "description": "Localization succesfully started",
+                    "description": "Robot is able to receive missions again"
                 },
                 HTTPStatus.CONFLICT.value: {
-                    "description": "Conflict - Invalid command in the current state",
+                    "description": "Conflict - Invalid command in the current state"
                 },
                 HTTPStatus.INTERNAL_SERVER_ERROR.value: {
-                    "description": "Internal Server Error - Current state of state machine unknown",
+                    "description": "Internal Server Error - Current state of state machine unknown"
                 },
             },
         )
         router.add_api_route(
-            path="/schedule/move_arm/{arm_pose_literal}",
-            endpoint=self.scheduling_controller.start_move_arm_mission,
+            path="/schedule/maintenance-mode",
+            endpoint=self.scheduling_controller.set_maintenance_mode,
             methods=["POST"],
             dependencies=[authentication_dependency],
-            summary="Move arm to the given arm pose literal",
+            summary="Place the robot in maintenance mode, where it will not run missions before begin released from maintenance mode",
             responses={
                 HTTPStatus.OK.value: {
-                    "description": "Move arm mission successfully started",
+                    "description": "Robot is in maintenance mode and cannot receive missions"
                 },
-                HTTPStatus.BAD_REQUEST.value: {
-                    "description": "A move arm mission was scheduled on a robot that "
-                    "does not support it or the input was incorrect",
+                HTTPStatus.CONFLICT.value: {"description": "Conflict"},
+                HTTPStatus.INTERNAL_SERVER_ERROR.value: {
+                    "description": "Internal Server Error"
+                },
+            },
+        )
+        router.add_api_route(
+            path="/schedule/release-maintenance-mode",
+            endpoint=self.scheduling_controller.release_maintenance_mode,
+            methods=["POST"],
+            dependencies=[authentication_dependency],
+            summary="Allow the robot to start missions again",
+            responses={
+                HTTPStatus.OK.value: {
+                    "description": "Robot is able to receive missions again"
+                },
+                HTTPStatus.CONFLICT.value: {"description": "Conflict"},
+                HTTPStatus.INTERNAL_SERVER_ERROR.value: {
+                    "description": "Internal Server Error"
+                },
+            },
+        )
+        router.add_api_route(
+            path="/schedule/release-intervention-needed",
+            endpoint=self.scheduling_controller.release_intervention_needed,
+            methods=["POST"],
+            dependencies=[authentication_dependency],
+            summary="Release the intervention needed state",
+            responses={
+                HTTPStatus.OK.value: {
+                    "description": "Robot released from intervention needed state"
                 },
                 HTTPStatus.CONFLICT.value: {
-                    "description": "Conflict - Invalid command in the current state",
+                    "description": "Conflict - Invalid command in the current state"
                 },
                 HTTPStatus.INTERNAL_SERVER_ERROR.value: {
-                    "description": "Internal Server Error - Current state of state machine unknown",
+                    "description": "Internal Server Error - Current state of state machine unknown"
                 },
             },
         )
@@ -275,7 +316,7 @@ class API:
 
         router.add_api_route(
             path="/info/robot-settings",
-            endpoint=self.scheduling_controller.get_info,
+            endpoint=self.robot_controller.get_info,
             methods=["GET"],
             dependencies=[authentication_dependency],
             summary="Information about the robot-settings",
@@ -283,6 +324,29 @@ class API:
 
         return router
 
+    def _create_media_control_router(self) -> APIRouter:
+        router: APIRouter = APIRouter(tags=["Media"])
+
+        authentication_dependency: Security = Security(self.authenticator.get_scheme())
+
+        router.add_api_route(
+            path="/media/media-stream-config",
+            endpoint=self.robot_controller.generate_media_config,
+            methods=["GET"],
+            dependencies=[authentication_dependency],
+            summary="Generates a media stream connection config",
+            responses={
+                HTTPStatus.OK.value: {
+                    "description": "Media stream was successfully generated",
+                },
+                HTTPStatus.NO_CONTENT.value: {
+                    "description": "Robot has no media config",
+                },
+            },
+        )
+
+        return router
+
     def _log_startup_message(self) -> None:
         address_format = "%s://%s:%d/docs"
         message = f"Uvicorn running on {address_format} (Press CTRL+C to quit)"
@@ -300,35 +364,20 @@ class API:
             extra={"color_message": color_message},
         )
 
-    def _add_request_logging_middleware(self, app: FastAPI) -> None:
-        connection_string: str
-        try:
-            connection_string = self.keyvault_client.get_secret(
-                "application-insights-connection-string"
-            ).value
-        except KeyvaultError:
-            message: str = (
-                "Missing connection string for Application Insights in key vault. "
-            )
-            self.logger.critical(message)
-            raise ConfigurationError(message)
-
-        @app.middleware("http")
-        async def middlewareOpencensus(request: Request, call_next):
-            tracer = Tracer(
-                exporter=AzureExporter(connection_string=connection_string),
-                sampler=ProbabilitySampler(1.0),
-            )
-            with tracer.span("main") as span:
-                span.span_kind = SpanKind.SERVER
+    def _publish_startup_message(self) -> None:
+        if not self.mqtt_publisher:
+            return
 
-                response = await call_next(request)
+        payload: StartUpMessagePayload = StartUpMessagePayload(
+            isar_id=settings.ISAR_ID,
+            timestamp=datetime.now(timezone.utc),
+        )
 
-                tracer.add_attribute_to_current_span(
-                    attribute_key=HTTP_STATUS_CODE, attribute_value=response.status_code
-                )
-                tracer.add_attribute_to_current_span(
-                    attribute_key=HTTP_URL, attribute_value=str(request.url)
-                )
+        self.logger.info("Publishing startup message to MQTT broker")
 
-            return response
+        self.mqtt_publisher.publish(
+            topic=settings.TOPIC_ISAR_STARTUP,
+            payload=json.dumps(payload, cls=EnhancedJSONEncoder),
+            qos=1,
+            retain=True,
+        )

isar/apis/models/__init__.py

@@ -1 +0,0 @@
-from .models import InputPose, StartMissionResponse

isar/apis/models/models.py

@@ -3,16 +3,14 @@ from typing import List, Optional
 from alitra import Frame, Orientation, Pose, Position
 from pydantic import BaseModel, Field
 
-
-class StepResponse(BaseModel):
-    id: str
-    type: str
+from robot_interface.models.mission.task import TaskTypes
 
 
 class TaskResponse(BaseModel):
     id: str
     tag_id: Optional[str] = None
-    steps: List[StepResponse]
+    inspection_id: Optional[str] = None
+    type: TaskTypes
 
 
 class StartMissionResponse(BaseModel):
@@ -21,12 +19,24 @@ class StartMissionResponse(BaseModel):
 
 
 class ControlMissionResponse(BaseModel):
-    mission_id: str
-    mission_status: str
-    task_id: str
-    task_status: str
-    step_id: str
-    step_status: str
+    success: bool
+    failure_reason: Optional[str] = None
+
+
+class MissionStartResponse(BaseModel):
+    mission_id: Optional[str] = None
+    mission_started: bool
+    mission_not_started_reason: Optional[str] = None
+
+
+class LockdownResponse(BaseModel):
+    lockdown_started: bool
+    failure_reason: Optional[str] = None
+
+
+class MaintenanceResponse(BaseModel):
+    is_maintenance_mode: bool
+    failure_reason: Optional[str] = None
 
 
 class RobotInfoResponse(BaseModel):