Allow action servers without execute callback (#1219)

Signed-off-by: Tim Clephas <[email protected]>

Author: Timple

rclpy/rclpy/action/server.py

@@ -161,6 +161,16 @@ def _update_state(self, event: _rclpy.GoalEvent) -> None:
             if not self._goal_handle.is_active():
                 self._action_server.notify_goal_done()
 
+    def _set_result(self, response: Optional[ResultT]) -> None:
+        # Set result
+        result_response = self._action_server._action_type.Impl.GetResultService.Response()
+        result_response.status = self.status
+        if response is not None:
+            result_response.result = response
+        else:
+            result_response.result = self._action_server._action_type.Result()
+        self._action_server._result_futures[bytes(self.goal_id.uuid)].set_result(result_response)
+
     def execute(
         self,
         execute_callback: Optional[Callable[['ServerGoalHandle[GoalT, ResultT, FeedbackT]'],
@@ -170,7 +180,7 @@ def execute(
         # In this case we want to avoid the illegal state transition to EXECUTING
         # but still call the users execute callback to let them handle canceling the goal.
         if not self.is_cancel_requested:
-            self._update_state(_rclpy.GoalEvent.EXECUTE)
+            self.executing()
         self._action_server.notify_execute(self, execute_callback)
 
     def publish_feedback(self, feedback: FeedbackMessage[FeedbackT]) -> None:
@@ -191,14 +201,20 @@ def publish_feedback(self, feedback: FeedbackMessage[FeedbackT]) -> None:
             # Publish
             self._action_server._handle.publish_feedback(feedback_message)
 
-    def succeed(self) -> None:
+    def executing(self) -> None:
+        self._update_state(_rclpy.GoalEvent.EXECUTE)
+
+    def succeed(self, response: Optional[ResultT] = None) -> None:
         self._update_state(_rclpy.GoalEvent.SUCCEED)
+        self._set_result(response)
 
-    def abort(self) -> None:
+    def abort(self, response: Optional[ResultT] = None) -> None:
         self._update_state(_rclpy.GoalEvent.ABORT)
+        self._set_result(response)
 
-    def canceled(self) -> None:
+    def canceled(self, response: Optional[ResultT] = None) -> None:
         self._update_state(_rclpy.GoalEvent.CANCELED)
+        self._set_result(response)
 
     def destroy(self) -> None:
         with self._lock:
@@ -233,7 +249,8 @@ def __init__(
         node: 'Node',
         action_type: Type[Action],
         action_name: str,
-        execute_callback: Callable[[ServerGoalHandle[GoalT, ResultT, FeedbackT]], ResultT],
+        execute_callback: Optional[Callable[[ServerGoalHandle[GoalT, ResultT, FeedbackT]],
+                                            ResultT]] = None,
         *,
         callback_group: 'Optional[CallbackGroup]' = None,
         goal_callback: Callable[[CancelGoal.Request], GoalResponse] = default_goal_callback,
@@ -283,7 +300,11 @@ def __init__(
         self.register_handle_accepted_callback(handle_accepted_callback)
         self.register_goal_callback(goal_callback)
         self.register_cancel_callback(cancel_callback)
-        self.register_execute_callback(execute_callback)
+        if execute_callback:
+            self.register_execute_callback(execute_callback)
+        elif handle_accepted_callback is default_handle_accepted_callback:
+            self._logger.warning(
+                'Not handling nor executing the goal, this server will do nothing')
 
         # Import the typesupport for the action module if not already done
         check_for_type_support(action_type)

rclpy/test/test_action_server.py

@@ -766,6 +766,58 @@ def execute_with_feedback(goal_handle: ServerGoalHandle[Any, Fibonacci.Result, A
         finally:
             action_server.destroy()
 
+    def test_without_execute_cb(self) -> None:
+        # Just like test_execute_succeed, but without an execute callback
+        # Goal handle is stored and succeeded from outside the execute callback
+        stored_goal_handle = None
+
+        def handle_accepted_callback(goal_handle: ServerGoalHandle[Fibonacci.Goal,
+                                                                   Fibonacci.Result,
+                                                                   Fibonacci.Feedback]) -> None:
+            goal_handle.executing()
+            nonlocal stored_goal_handle
+            stored_goal_handle = goal_handle
+
+        executor = MultiThreadedExecutor(context=self.context)
+
+        action_server = ActionServer(
+            self.node,
+            Fibonacci,
+            'fibonacci',
+            handle_accepted_callback=handle_accepted_callback,
+        )
+
+        goal_uuid = UUID(uuid=list(uuid.uuid4().bytes))
+        goal_msg = Fibonacci.Impl.SendGoalService.Request()
+        goal_msg.goal_id = goal_uuid
+        goal_future = self.mock_action_client.send_goal(goal_msg)
+        rclpy.spin_until_future_complete(self.node, goal_future, executor)
+        goal_handle = goal_future.result()
+        assert goal_handle
+        self.assertTrue(goal_handle.accepted)
+
+        get_result_future = self.mock_action_client.get_result(goal_uuid)
+        self.assertFalse(get_result_future.done())
+
+        result = Fibonacci.Result()
+        result.sequence.extend([1, 1, 2, 3, 5])
+        assert stored_goal_handle
+        stored_goal_handle.succeed(result)
+
+        # Handle all callbacks
+        for _ in range(5):
+            rclpy.spin_once(self.node, executor=self.executor, timeout_sec=0.01)
+            if get_result_future.done():
+                break
+        self.assertTrue(get_result_future.done())
+
+        result_response = get_result_future.result()
+        assert result_response
+
+        self.assertEqual(result_response.status, GoalStatus.STATUS_SUCCEEDED)
+        self.assertEqual(result_response.result.sequence.tolist(), [1, 1, 2, 3, 5])
+        action_server.destroy()
+
     def test_action_introspection_default_status(self) -> None:
         goal_order = 10