Fix robot status hang issue with best-effort publishing

- Replace blocking status publishing with non-blocking best-effort approach
- Remove complex retry logic and timeouts that could cause indefinite hangs
- Add get_state command handler to respond to InOrbit status requests
- Simplify implementation: direct client.publish() calls without threading
- InOrbit's multi-layer detection system handles status failures gracefully

Resolves connector hanging issues by eliminating wait_for_publish() calls
that could block indefinitely during network instability.

Author: Jehan Shah

inorbit_edge/robot.py

@@ -473,18 +473,22 @@ def _on_connect(self, client, userdata, flags, reason_code, properties):
             )
             return
 
-        # Send robot online status with retries
+        # Send robot online status (best effort)
+        # If this fails and InOrbit is getting data, it will detect discrepancy
+        # and request a status update.
         try:
-            self._retry_operation(
-                operation=lambda: self.send_robot_status(online=True),
-                operation_name="Send online status",
-                max_retries=3,
+            self.client.publish(
+                self._get_robot_subtopic(subtopic=MQTT_SUBTOPIC_STATE),
+                f"1|{self.robot_api_key}|{self.agent_version}|{self.robot_name}",
+                qos=1,
+                retain=True,
             )
+            self.logger.debug("Online status sent successfully")
         except Exception as e:
-            self.logger.error(f"Connection failed: unable to send online status: {e}")
-            # This will cause the connection to be considered failed
-            # The connector should catch this and restart
-            raise RuntimeError(f"Connection failed: unable to send online status: {e}")
+            self.logger.debug(
+                f"Online status failed: {e} - InOrbit will detect via data messages "
+                f"and request a status update"
+            )
 
         # Subscribe to interesting topics
         self.client.subscribe(
@@ -627,6 +631,8 @@ def _handle_in_cmd(self, msg):
             self._handle_load_module(args[1], args[2])
         if args[0] == "unload_module" and len(args) >= 2:
             self._handle_unload_module(args[1])
+        if args[0] == "get_state":
+            self._handle_get_state()
 
     def _handle_load_module(self, module_name, run_level):
         """Handles a load_module command"""
@@ -638,6 +644,26 @@ def _handle_unload_module(self, module_name):
         if module_name == INORBIT_MODULE_CAMERAS:
             self._stop_cameras_streaming()
 
+    def _handle_get_state(self):
+        """Handles a get_state command by re-sending online status.
+
+        This is called when InOrbit detects data from a robot marked as offline
+        and requests the robot to re-send its online status.
+        """
+        self.logger.info("Received request to re-send online status")
+
+        # Send online status directly (non-blocking, no threading needed)
+        try:
+            self.client.publish(
+                self._get_robot_subtopic(subtopic=MQTT_SUBTOPIC_STATE),
+                f"1|{self.robot_api_key}|{self.agent_version}|{self.robot_name}",
+                qos=1,
+                retain=True,
+            )
+            self.logger.debug("Online status response sent successfully")
+        except Exception as e:
+            self.logger.debug(f"Online status response failed: {e}")
+
     def _start_cameras_streaming(self):
         """Start streaming on all registered cameras"""
         with self.camera_streaming_mutex:
@@ -929,87 +955,6 @@ def _resend_modules(self):
             qos=1,
         )
 
-    def _retry_operation(self, operation, operation_name, max_retries=3, delay=0.5):
-        """Generic retry wrapper with fixed delay - keeps it simple and fast.
-
-        Args:
-            operation: Callable that performs the operation
-            operation_name: String describing the operation for logging
-            max_retries: Maximum number of attempts
-            delay: Delay between retries in seconds
-
-        Returns:
-            Result of the operation if successful
-
-        Raises:
-            RuntimeError: If all retry attempts fail
-        """
-        for attempt in range(max_retries):
-            try:
-                result = operation()
-                if attempt > 0:
-                    self.logger.debug(
-                        f"{operation_name} succeeded on attempt {attempt + 1}"
-                    )
-                return result
-            except Exception as e:
-                if attempt < max_retries - 1:
-                    self.logger.warning(
-                        f"{operation_name} failed "
-                        f"(attempt {attempt + 1}/{max_retries}): {e}. "
-                        f"Retrying in {delay}s..."
-                    )
-                    time.sleep(delay)
-                else:
-                    self.logger.error(
-                        f"{operation_name} failed after {max_retries} attempts: {e}"
-                    )
-                    raise RuntimeError(
-                        f"{operation_name} failed after {max_retries} attempts: {e}"
-                    )
-
-    def send_robot_status(self, online=True):
-        """Send robot online/offline status.
-
-        This method blocks until either the message
-        is sent, publish times out, or the client errors out.
-
-        Args:
-            online (bool): True to mark robot as online, False for offline.
-                Defaults to True.
-
-        Raises:
-            RuntimeError: If status message fails to publish.
-        """
-        robot_status = "1" if online else "0"
-
-        # Every time we connect or disconnect to the service, send
-        # updated status including online/offline bit
-        status_message = "{}|{}|{}|{}".format(
-            robot_status, self.robot_api_key, self.agent_version, self.robot_name
-        )
-        ret = self.publish(
-            self._get_robot_subtopic(subtopic=MQTT_SUBTOPIC_STATE),
-            status_message,
-            qos=1,
-            retain=True,
-        )
-        self.logger.info("Publishing status {}. ret = {}.".format(robot_status, ret))
-
-        try:
-            ret.wait_for_publish(timeout=5.0)
-            published = ret.is_published()
-        except Exception as e:
-            self.logger.warning(f"Failed to wait for status publish: {e}")
-            published = False
-
-        self.logger.info(
-            "Robot status '{}' published: {:b}.".format(robot_status, published)
-        )
-
-        if not published:
-            raise RuntimeError(f"Failed to publish robot status '{robot_status}'")
-
     def _is_connected(self):
         return self.client.is_connected()
 
@@ -1082,18 +1027,19 @@ def disconnect(self):
         self.logger.info("Ending robot session")
         self._stop_cameras_streaming()
 
-        # Try to send offline status with retries, but don't fail disconnect
-        # Offline status is best effort
+        # Send offline status (best effort, non-blocking)
+        # InOrbit will detect offline via data absence if this fails
         try:
-            self._retry_operation(
-                operation=lambda: self.send_robot_status(online=False),
-                operation_name="Send offline status",
-                max_retries=3,
+            self.client.publish(
+                self._get_robot_subtopic(subtopic=MQTT_SUBTOPIC_STATE),
+                f"0|{self.robot_api_key}|{self.agent_version}|{self.robot_name}",
+                qos=1,
+                retain=True,
             )
-            self.logger.info("Offline status sent successfully")
+            self.logger.debug("Offline status sent successfully")
         except Exception as e:
-            self.logger.warning(
-                f"Failed to send offline status during disconnect: {e}. "
+            self.logger.debug(
+                f"Offline status failed: {e} - InOrbit will detect via data absence"
             )
 
         # TODO: Unsubscribe from topics

inorbit_edge/tests/test_robot_session_callbacks.py

@@ -255,3 +255,40 @@ def test_robot_session_handles_map_requests(
     msg.payload = MapRequest(label="map_id", data_hash=123).SerializeToString()
     robot_session._on_message(None, None, msg)
     robot_session.client._publish_map_bytes.assert_not_called()
+
+
+def test_responds_to_status_request_from_inorbit(
+    mock_mqtt_client, mock_inorbit_api, mock_sleep
+):
+    """Test that robot responds when InOrbit requests status update."""
+    robot_session = RobotSession(
+        robot_id="id_123",
+        robot_name="name_123", 
+        api_key="apikey_123",
+    )
+    
+    # connect robot_session, so it populates properties with API response data
+    robot_session.connect()
+    robot_session._on_connect(None, None, None, 0, None)
+    
+    # Clear previous publish calls from connect
+    robot_session.client.publish.reset_mock()
+    
+    # Simulate InOrbit requesting status update
+    get_state_msg = b"get_state"
+    robot_session._handle_in_cmd(get_state_msg)
+    
+    # Should respond with current status
+    robot_session.client.publish.assert_called()
+    call_args = robot_session.client.publish.call_args
+    
+    # Verify response format
+    topic = call_args[0][0]
+    message = call_args[0][1]
+    
+    assert "state" in topic
+    assert message.startswith("1|")  # Should report online
+    assert call_args[1]["qos"] == 1
+    assert call_args[1]["retain"] is True
+
+