Hammer/fix dangling delivery alerts

packages/api-server/api_server/gateway.py

@@ -215,7 +215,12 @@ def convert_delivery_alert(delivery_alert: RmfDeliveryAlert):
             RmfDeliveryAlert,
             "delivery_alert_request",
             lambda msg: rmf_events.delivery_alerts.on_next(convert_delivery_alert(msg)),
-            10,
+            rclpy.qos.QoSProfile(
+                history=rclpy.qos.HistoryPolicy.KEEP_LAST,
+                depth=10,
+                reliability=rclpy.qos.ReliabilityPolicy.RELIABLE,
+                durability=rclpy.qos.DurabilityPolicy.TRANSIENT_LOCAL,
+            ),
         )
         self._subscriptions.append(delivery_alert_request_sub)
 

packages/api-server/api_server/routes/delivery_alerts.py

@@ -9,6 +9,8 @@
 
 from api_server.fast_io import FastIORouter, SubscriptionRequest
 from api_server.gateway import rmf_gateway
+from api_server.logger import logger
+from api_server.models import FleetState
 from api_server.models import tortoise_models as ttm
 from api_server.models.delivery_alerts import (
     DeliveryAlert,
@@ -58,16 +60,59 @@ async def query_delivery_alerts(
 
     try:
         delivery_alerts = await ttm.DeliveryAlert.filter(**filters)
-        return [
+        delivery_alerts_pydantic = [
             await ttm.DeliveryAlertPydantic.from_tortoise_orm(a)
             for a in delivery_alerts
         ]
     except FieldError as e:
         raise HTTPException(422, str(e)) from e
 
+    ongoing_delivery_alerts = []
+    # Check for dangling delivery alerts, where none of the fleets are still
+    # performing the task
+    current_task_ids = []
+    try:
+        db_states = await ttm.FleetState.all().values_list("data", flat=True)
+        fleets = [FleetState(**s) for s in db_states]
+        for f in fleets:
+            if f.robots is None:
+                continue
+            for robot in f.robots.values():
+                if robot.task_id is not None and len(robot.task_id) != 0:
+                    current_task_ids.append(robot.task_id)
+    except Exception as e:  # pylint: disable=broad-except
+        logger.error(f"Failed to retrieve current running task IDs: {e}")
+        return []
+
+    logger.info(f"Current running task IDs: {current_task_ids}")
+    for d in delivery_alerts_pydantic:
+        if (
+            d.task_id is not None
+            and len(d.task_id) != 0
+            and d.task_id not in current_task_ids
+        ):
+            logger.info(f"Found a dangling alert: {d}")
+            try:
+                dangling_alert = await ttm.DeliveryAlert.get_or_none(id=d.id)
+                if dangling_alert is None:
+                    logger.error(f"Failed to retrieve dangling alert {d.id}")
+                    continue
+                dangling_alert.update_from_dict({"action": "resume"})
+                await dangling_alert.save()
+            except Exception as e:  # pylint: disable=broad-except
+                logger.error(f"Failed to resolve dangling alert ID {d.id}: {e}")
+                continue
+            logger.info(
+                f"Resolved dangling alert ID {d.id} by updating action to resume"
+            )
+        else:
+            ongoing_delivery_alerts.append(d)
+    return ongoing_delivery_alerts
+
 
 @router.get("/{delivery_alert_id}", response_model=ttm.DeliveryAlertPydantic)
 async def get_delivery_alert(delivery_alert_id: str):
+
     delivery_alert = await ttm.DeliveryAlert.get_or_none(id=delivery_alert_id)
     if delivery_alert is None:
         raise HTTPException(