petal-user-journey-coordinator 0.1.8__tar.gz → 0.1.9__tar.gz

{petal_user_journey_coordinator-0.1.8 → petal_user_journey_coordinator-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: petal-user-journey-coordinator
-Version: 0.1.8
+Version: 0.1.9
 Summary: A petal for the DroneLeaf ecosystem
 Author-Email: Khalil Al Handawi <khalil.alhandawi@droneleaf.io>
 License: MIT

{petal_user_journey_coordinator-0.1.8 → petal_user_journey_coordinator-0.1.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "petal-user-journey-coordinator"
-version = "0.1.8"
+version = "0.1.9"
 description = "A petal for the DroneLeaf ecosystem"
 authors = [
     { name = "Khalil Al Handawi", email = "khalil.alhandawi@droneleaf.io" },

{petal_user_journey_coordinator-0.1.8 → petal_user_journey_coordinator-0.1.9}/src/petal_user_journey_coordinator/data_model.py

@@ -633,4 +633,27 @@ class BulkParameterResponse(BaseModel):
                 "timestamp": "2023-01-01T00:00:00Z"
             }
         }
+    }
+
+
+class RebootPX4StatusPayload(BaseModel):
+    """Payload for PX4 reboot status published via MQTT after reboot completes."""
+    reboot_initiated: bool = Field(..., description="Whether the reboot command was initiated")
+    reboot_success: Optional[bool] = Field(default=None, description="Whether the reboot completed successfully")
+    status: Literal["success", "failed"] = Field(..., description="Reboot status")
+    message: str = Field(..., description="Human-readable status message")
+    error_code: Optional[str] = Field(default=None, description="Error code if reboot failed")
+    timestamp: datetime = Field(..., description="Timestamp of the status update")
+    
+    model_config = {
+        "json_schema_extra": {
+            "example": {
+                "reboot_initiated": True,
+                "reboot_success": True,
+                "status": "success",
+                "message": "PX4 reboot completed successfully",
+                "error_code": None,
+                "timestamp": "2026-01-07T12:00:00Z"
+            }
+        }
     }

{petal_user_journey_coordinator-0.1.8 → petal_user_journey_coordinator-0.1.9}/src/petal_user_journey_coordinator/plugin.py

@@ -93,7 +93,10 @@ from .data_model import (
     OpticalFlowModulePayload,
     BulkParameterSetRequest,
     BulkParameterGetRequest,
-    BulkParameterResponse
+    BulkParameterResponse,
+
+    # Reboot status payload
+    RebootPX4StatusPayload
 )
 
 from petal_app_manager.models.mavlink import (
@@ -1940,13 +1943,22 @@ class PetalUserJourneyCoordinator(Petal):
 
     @http_action(method="POST", path="/mqtt/reboot_px4")
     async def _reboot_px4_message_handler(self, topic: str, message: Dict[str, Any]):
-        """Handle reboot PX4 MQTT messages."""
+        """
+        Handle reboot PX4 MQTT messages.
+        
+        Flow:
+        1. Validate message and check for active operations
+        2. Immediately send_command_response to acknowledge command received
+        3. Await reboot_autopilot to execute the reboot
+        4. Publish reboot status via MQTT publish_message
+        """
+        mqtt_msg = None
         try:
-            # Parse base MQTT message
+            # Parse and validate MQTT message
             mqtt_msg = MQTTMessage(**message)
             message_id = mqtt_msg.messageId
 
-            # Check if controller is in emergency mode
+            # Check if any controller has an active operation
             for controller in self._active_controllers.values():
                 if controller is not None and controller.is_active:
                     error_msg = "PX4 reboot blocked - Active operation in progress"
@@ -1960,61 +1972,137 @@ class PetalUserJourneyCoordinator(Petal):
                                 "error_code": "OPERATION_ACTIVE"
                             }
                         )
-
                     return
-                
-            logger.info(f"Restarting PX4 for {self.name} petal")
-            reboot_response = await self._mavlink_proxy.reboot_autopilot(
-                reboot_onboard_computer=False,
-                timeout=5.0
-            )
-
-            if not reboot_response.success:
-                error_msg = "PX4 reboot command failed or timed out"
-                logger.error(f"[{message_id}] {error_msg}")
-                if mqtt_msg.waitResponse:
-                    await self._mqtt_proxy.send_command_response(
-                        message_id=message_id,
-                        response_data={
-                            "status": "error",
-                            "message": error_msg,
-                            "error_code": "REBOOT_FAILED",
-                            "data": _json_safe(reboot_response.model_dump())
-                        }
-                    )
-                return
-            
-            logger.info(f"[{message_id}] PX4 reboot command successful")
 
+            # Step 1: Immediately respond to acknowledge command received
+            logger.info(f"[{message_id}] PX4 reboot command received, sending acknowledgement")
             if mqtt_msg.waitResponse:
                 await self._mqtt_proxy.send_command_response(
                     message_id=message_id,
                     response_data={
                         "status": "success",
-                        "message": "PX4 reboot command successful",
-                        "data": _json_safe(reboot_response.model_dump())
+                        "message": "PX4 reboot command initiated",
+                        "data": {
+                            "reboot_initiated": True,
+                            "message": "Reboot in progress, status will be published to command/web"
+                        }
                     }
                 )
+
         except ValidationError as ve:
-            error_msg = f"Invalid PX4 reboot payload: {ve}"
+            error_msg = f"Invalid PX4 reboot message: {ve}"
             logger.error(f"PX4 reboot validation error: {error_msg}")
-            if mqtt_msg.waitResponse:
+            if mqtt_msg and mqtt_msg.waitResponse:
                 await self._mqtt_proxy.send_command_response(
-                    message_id=message_id,
+                    message_id=mqtt_msg.messageId,
                     response_data={
                         "status": "error",
                         "message": error_msg,
                         "error_code": "VALIDATION_ERROR"
                     }
                 )
+            return
         except Exception as e:
-            logger.error(f"Error handling PX4 reboot message: {e}")
+            error_msg = f"PX4 reboot message handler error: {str(e)}"
+            logger.error(f"Unexpected PX4 reboot error: {error_msg}")
             if mqtt_msg and mqtt_msg.waitResponse:
                 await self._mqtt_proxy.send_command_response(
                     message_id=mqtt_msg.messageId,
-                    response_data={"status": "error", "message": str(e)}
+                    response_data={
+                        "status": "error",
+                        "message": error_msg,
+                        "error_code": "HANDLER_ERROR"
+                    }
                 )
-                return
+            return
+
+        try:
+            # Step 2: Await the actual reboot operation
+            logger.info(f"[{message_id}] Executing PX4 reboot for {self.name} petal")
+            reboot_response: RebootAutopilotResponse = await self._mavlink_proxy.reboot_autopilot(
+                reboot_onboard_computer=False,
+                timeout=5.0
+            )
+
+            # Step 3: Build and publish reboot status via MQTT
+            if reboot_response.success:
+                logger.info(f"[{message_id}] PX4 reboot successful: {reboot_response.reason}")
+                status_payload = RebootPX4StatusPayload(
+                    reboot_initiated=True,
+                    reboot_success=True,
+                    status="success",
+                    message=reboot_response.reason,
+                    error_code=None,
+                    timestamp=datetime.now(timezone.utc)
+                )
+            else:
+                logger.error(f"[{message_id}] PX4 reboot failed: {reboot_response.reason}")
+                status_payload = RebootPX4StatusPayload(
+                    reboot_initiated=True,
+                    reboot_success=False,
+                    status="failed",
+                    message=reboot_response.reason,
+                    error_code=reboot_response.status_code.value,
+                    timestamp=datetime.now(timezone.utc)
+                )
+
+            # Publish reboot status via MQTT
+            mqtt_message = {
+                "messageId": message_id,
+                "command": f"/{self.name}/reboot_px4_status",
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "payload": status_payload.model_dump(mode="json")
+            }
+            await self._mqtt_proxy.publish_message(payload=mqtt_message)
+            logger.info(f"[{message_id}] Published reboot status to command/web")
+
+        except ValidationError as ve:
+            error_msg = f"PX4 reboot status payload validation error: {ve}"
+            logger.error(f"[{mqtt_msg.messageId if mqtt_msg else 'unknown'}] {error_msg}")
+            # Try to publish error status if we got past validation
+            if mqtt_msg:
+                try:
+                    error_payload = RebootPX4StatusPayload(
+                        reboot_initiated=True,
+                        reboot_success=False,
+                        status="failed",
+                        message=error_msg,
+                        error_code="PAYLOAD_VALIDATION_ERROR",
+                        timestamp=datetime.now(timezone.utc)
+                    )
+                    mqtt_message = {
+                        "messageId": mqtt_msg.messageId,
+                        "command": f"/{self.name}/reboot_px4_status",
+                        "timestamp": datetime.now(timezone.utc).isoformat(),
+                        "payload": error_payload.model_dump(mode="json")
+                    }
+                    await self._mqtt_proxy.publish_message(payload=mqtt_message)
+                except Exception as publish_error:
+                    logger.error(f"[{mqtt_msg.messageId}] Failed to publish error status: {publish_error}")
+
+        except Exception as e:
+            error_msg = f"PX4 reboot error: {str(e)}"
+            logger.error(f"[{mqtt_msg.messageId if mqtt_msg else 'unknown'}] {error_msg}")
+            # Try to publish error status if we got past validation
+            if mqtt_msg:
+                try:
+                    error_payload = RebootPX4StatusPayload(
+                        reboot_initiated=True,
+                        reboot_success=False,
+                        status="failed",
+                        message=error_msg,
+                        error_code="EXECUTION_ERROR",
+                        timestamp=datetime.now(timezone.utc)
+                    )
+                    mqtt_message = {
+                        "messageId": mqtt_msg.messageId,
+                        "command": f"/{self.name}/reboot_px4_status",
+                        "timestamp": datetime.now(timezone.utc).isoformat(),
+                        "payload": error_payload.model_dump(mode="json")
+                    }
+                    await self._mqtt_proxy.publish_message(payload=mqtt_message)
+                except Exception as publish_error:
+                    logger.error(f"[{mqtt_msg.messageId}] Failed to publish error status: {publish_error}")
 
     def _create_parameter_message_handler(self, handler_key: str, config_type: str):
         """