Feature/action

CHANGELOG.md

@@ -7,19 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
-### Added
+### Removed 
+
+- Callback-based ServiceClient::call overload
+- ServiceClient::cancel because it does not cancel the timeout timer correctly
 
+### Added
+
+- Support for actions
 - Multi-threaded executor support for the async/await API
 
 ### Fixed
 
 - Correct result type implementation
+- Missing request cleanup in ServiceClientImpl::our_to_real_req_id_
+- Added missing cancellation of timeout timer in Promise destruction
 
 ## 0.3.0 
 
 ### Fixed
-
-- This release enables to use nested coroutines and fixes a coroutine state memory leak issue.
+- enables nested coroutines and with it fixes coroutine state memory leak
 
 ## 0.2.0 
 

README.md

@@ -1,10 +1,11 @@
 <p align="center">
-  <img src="icey/doc/source/_static/icey_logo.png" alt="Project Logo" width="1000rem"/>
+  <img src="icey/doc/source/_static/icey_logo.png" alt="Project Logo" width="400rem"/>
 </p>
 
 ---
 
 <p align="center" height="30rem">
+  <img src="https://img.shields.io/github/actions/workflow/status/iv461/icey/build.yml?branch=main&job=build_and_test_ros2_kilted%20(kilted)&label=ROS%202%20Kilted&style=for-the-badge" alt="ROS 2 Humble Kilted Status" />
   <img src="https://img.shields.io/github/actions/workflow/status/iv461/icey/build.yml?branch=main&job=build_and_test_ros2_jazzy%20(jazzy)&label=ROS%202%20Jazzy&style=for-the-badge" alt="ROS 2 Jazzy Build Status"/>
   <img src="https://img.shields.io/github/actions/workflow/status/iv461/icey/build.yml?branch=main&job=build_and_test_ros2_humble%20(humble)&label=ROS%202%20Humble&style=for-the-badge" alt="ROS 2 Humble Build Status" />
 </p>
@@ -18,7 +19,7 @@ ICEY is a new client API for modern asynchronous programming in the Robot Operat
  - A consistent async/await-based API for all asynchronous operations, including service calls and TF lookup.
  - Topic synchronization without boilerplate code
 
-ICEY is fully compatible with the ROS 2 API since it is built on top of rclcpp. This allows for gradual adoption. It supports all major ROS features: parameters, subscriptions, publishers, timers, services, clients, and TF. Additionally, ICEY supports lifecycle nodes using a single API.
+ICEY is fully compatible with the ROS 2 API since it is built on top of rclcpp. This allows for gradual adoption. It supports all major ROS features: parameters, subscriptions, publishers, timers, services, clients, actions and TF. Additionally, ICEY supports lifecycle nodes using a single API.
 ICEY operates smoothly with the message_filters package, using it for synchronization. ICEY is also extensible, as demonstrated by its support for image transport camera subscription/publishers.
 
 ICEY supports ROS 2 Humble and ROS 2 Jazzy.
@@ -194,7 +195,7 @@ icey_context_->create_subscription<geometry_msgs::PoseStamped>("ego_pose")
 # Dependencies: 
 
 - C++20 
-- ROS 2 Humble or Jazzy
+- ROS 2 Humble, Jazzy or Kilted
 - Boost (Hana, typeinfo), not required if you need async/await only
 - FMT
 

icey/CMakeLists.txt

@@ -9,7 +9,7 @@ if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
 endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX)
-  add_compile_options(-Werror=return-local-addr -fmax-errors=1)
+  add_compile_options(-Werror=return-local-addr)
 endif()
 if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
   add_compile_options(-Werror=return-stack-address)
@@ -24,21 +24,30 @@ include_directories(
     include
 )
 
+ament_auto_add_library(icey 
+  src/actions/client.cpp 
+  src/actions/server.cpp 
+  src/actions/server_goal_handle.cpp  
+  )
 
 if(BUILD_TESTING)
   find_package(ament_cmake_gtest REQUIRED)
 
   ament_auto_add_gtest(test_main
     test/entities_test.cpp
     test/entities_async_await_test.cpp
+    test/action_server_test.cpp
+    test/action_client_test.cpp
+    test/node_tasks_test.cpp
     test/test_main.cpp
     test/filters_test.cpp
     test/callback_lifetime_test.cpp
     test/context_test.cpp
     test/promise_test.cpp
     test/nested_coroutines.cpp
-  )
+  )  
   target_link_libraries(test_main fmt::fmt)
+  set_tests_properties(test_main PROPERTIES TIMEOUT 180)
 
 endif()
 

icey/doc/source/api_async_primitives.md

@@ -14,7 +14,10 @@ The asynchronous primitives like `Promise` and `Stream` are the building blocks
 ```{doxygenclass} icey::Stream
 ```
 
-```{doxygenclass} icey::PromiseBase
+```{doxygenclass} icey::impl::PromiseBase
+```
+
+```{doxygenclass} icey::impl::Promise
 ```
 
 ```{doxygenclass} icey::Promise

icey/doc/source/api_entities.md

@@ -3,6 +3,18 @@
 All the ROS entities (subscriptions, publishers, timers etc.) are wrapped so that they are either `Stream`s or provide an asynchronous interface with `icey::Promise` (service client, TF).
 
 
+```{doxygenstruct} icey::ServiceClient
+```
+
+```{doxygenstruct} icey::TransformBuffer
+```
+
+```{doxygenstruct} icey::ActionClient
+```
+
+```{doxygenstruct} icey::AsyncGoalHandle
+```
+
 ```{doxygenstruct} icey::ParameterStream
 ```
 
@@ -14,15 +26,10 @@ All the ROS entities (subscriptions, publishers, timers etc.) are wrapped so tha
 ```{doxygenstruct} icey::PublisherStream
 ```
 
-```{doxygenstruct} icey::ServiceClient
-```
 
 ```{doxygenstruct} icey::TransformSubscriptionStream
 ```
 
-```{doxygenstruct} icey::TransformBuffer
-```
-
 ```{doxygenstruct} icey::TransformPublisherStream
 ```
 

icey/doc/source/index.md

@@ -27,6 +27,7 @@ async_flow
 coroutine_basics
 using_services
 using_tf
+using_actions
 lifecycle_nodes
 ```
 

icey/doc/source/using_actions.md

@@ -0,0 +1,116 @@
+# Actions with async/await
+
+ICEY wraps `rclcpp_action` with coroutine-friendly APIs so goal flow stays linear instead of callback-driven.
+
+References:
+- `icey_examples/src/action_client_async_await.cpp`
+- `icey_examples/src/action_server_async_await.cpp`
+
+## Client API in three operations
+
+Create client once:
+
+```c++
+auto ctx = std::make_shared<icey::ContextAsyncAwait>(node.get());
+auto client = ctx->create_action_client<Fibonacci>("/icey_test_action_fibonacci");
+```
+
+### 1) Send goal (`send_goal`)
+
+```c++
+Fibonacci::Goal goal;
+goal.order = 7;
+
+auto maybe_handle = co_await client.send_goal(
+    goal,
+    5s,  // acceptance timeout
+    [node](auto, auto) { RCLCPP_INFO(node->get_logger(), "feedback"); });
+
+if (maybe_handle.has_error()) {
+  // e.g. "TIMEOUT", "GOAL REJECTED"
+  co_return;
+}
+
+auto handle = maybe_handle.value();
+```
+
+What you get:
+- `icey::Result<icey::AsyncGoalHandle<ActionT>, std::string>`
+- explicit timeout for acceptance
+
+### 2) Await result (`result`)
+
+```c++
+auto maybe_result = co_await handle.result(20s);  // result timeout
+if (maybe_result.has_error()) {
+  // e.g. "RESULT TIMEOUT", "FAILED"
+  co_return;
+}
+
+const auto &wrapped = maybe_result.value();
+if (wrapped.code == rclcpp_action::ResultCode::SUCCEEDED) {
+  // wrapped.result is ActionT::Result
+}
+```
+
+What you get:
+- `icey::Result<typename ClientGoalHandle::WrappedResult, std::string>`
+- result timeout and cleanup handled by ICEY
+
+### 3) Cancel goal (`cancel`)
+
+```c++
+auto maybe_cancel = co_await handle.cancel(2s);
+if (maybe_cancel.has_error()) {
+  // timeout / invalid-handle style errors
+  co_return;
+}
+```
+
+What you get:
+- `icey::Result<CancelResponse::SharedPtr, std::string>`
+
+Important:
+- `cancel(...)` must be awaited immediately (do not fire-and-forget it).
+
+## Server API
+
+`create_action_server` accepts synchronous or coroutine callbacks for `handle_goal`, `handle_cancel` and `handle_accepted `.
+
+```c++
+auto handle_goal = [](const rclcpp_action::GoalUUID &, std::shared_ptr<const Fibonacci::Goal>)
+    -> icey::Promise<rclcpp_action::GoalResponse> {
+  // can await service calls, timers, etc.
+  co_return rclcpp_action::GoalResponse::ACCEPT_AND_EXECUTE;
+};
+
+auto handle_cancel = [](std::shared_ptr<ServerGoalHandleFibonacci>) {
+  return rclcpp_action::CancelResponse::REJECT;
+};
+
+auto handle_accepted = [](std::shared_ptr<ServerGoalHandleFibonacci> gh) {
+  gh->succeed(std::make_shared<Fibonacci::Result>());
+};
+
+ctx->create_action_server<Fibonacci>("/icey_test_action_fibonacci",
+                                     handle_goal,
+                                     handle_cancel,
+                                     handle_accepted);
+```
+
+## What this enables (beyond syntactic sugar)
+
+1. Compose action stages directly:
+`send_goal -> result -> conditional cancel/retry` in one coroutine.
+2. Perform async prechecks in server callbacks:
+await service calls or timers before accepting/rejecting a goal.
+3. Keep timeout policy close to business logic:
+acceptance/result/cancel each have separate timeouts.
+4. Write deterministic control flow:
+less shared mutable callback state, fewer manually managed request IDs.
+
+## Plain ROS 2 vs ICEY
+
+Plain `rclcpp_action` commonly needs manual `SendGoalOptions`, multiple callbacks, and external state to connect acceptance/result/cancel steps.
+
+ICEY keeps the same ROS executor model (`rclcpp::spin(...)`) but lets you express those steps with typed `co_await` operations and explicit per-step timeout handling.

icey/include/icey/action/action.hpp

@@ -0,0 +1,41 @@
+// Copyright 2018 Open Source Robotics Foundation, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/** \mainpage rclcpp_action: ROS Action Client Library for C++
+ *
+ * `rclcpp_action` provides the canonical C++ API for interacting with ROS Actions.
+ * It consists of these main components:
+ *
+ * - Action Client
+ *   - rclcpp_action/client.hpp
+ *   - rclcpp_action/create_client.hpp
+ *   - rclcpp_action/client_goal_handle.hpp
+ * - Action Server
+ *   - rclcpp_action/server.hpp
+ *   - rclcpp_action/create_server.hpp
+ *   - rclcpp_action/server_goal_handle.hpp
+ */
+
+#pragma once
+
+#include <csignal>
+#include <icey/action/client.hpp>
+#include <icey/action/create_client.hpp>
+#include <icey/action/create_server.hpp>
+#include <icey/action/server.hpp>
+#include <icey/action/server_goal_handle.hpp>
+#include <icey/action/client_goal_handle.hpp>
+#include <memory>
+
+#include "rclcpp_action/visibility_control.hpp"