WIP

Signed-off-by: Michel Hidalgo <[email protected]>

Author: mhidalgo-bdai

spot_driver/include/spot_driver/lease/lease_service.hpp renamed to spot_driver/include/spot_driver/lease/lease_manager.hpp

@@ -14,9 +14,9 @@
 namespace spot_ros2::lease {
 
 using spot_msgs::srv::AcquireLease;
-using spot_msgs::srv::ReleaseLease;
+using spot_msgs::srv::ReturnLease;
 
-class LeaseService {
+class LeaseManager {
  public:
   /**
    * This middleware handle is used to register a service and assign to it a
@@ -25,13 +25,16 @@ class LeaseService {
    */
   class MiddlewareHandle {
    public:
-    virtual void createAcquireService(std::string service_name,
-                                      std::function<void(const std::shared_ptr<AcquireLease::Request>,
-                                                         std::shared_ptr<AcquireLease::Response>)> callback) = 0;
+    virtual void createAcquireLeaseService(const std::string& service_name,
+                                           std::function<void(const std::shared_ptr<AcquireLease::Request>,
+                                                              std::shared_ptr<AcquireLease::Response>)> callback) = 0;
 
-    virtual void createReleaseService(std::string service_name,
-                                      std::function<void(const std::shared_ptr<ReleaseLease::Request>,
-                                                         std::shared_ptr<ReleaseLease::Response>)> callback) = 0;
+    virtual void createReturnLeaseService(const std::string& service_name,
+                                          std::function<void(const std::shared_ptr<ReturnLease::Request>,
+                                                             std::shared_ptr<ReturnLease::Response>)> callback) = 0;
+    virtual void createBond(const std::string& node_name) = 0;
+
+    virtual void destroyBond(const std::string& node_name) = 0;
 
     virtual ~MiddlewareHandle() = default;
   };
@@ -42,7 +45,7 @@ class LeaseService {
    * @param kinematic_api The Api to interact with the Spot SDK.
    * @param logger Logging interface.
    */
-   explicit LeaseService(std::shared_ptr<LeaseApi> lease_api,
+   explicit LeaseManager(std::shared_ptr<LeaseApi> lease_api,
                          std::shared_ptr<LoggerInterfaceBase> logger,
                          std::unique_ptr<MiddlewareHandle> middleware_handle);
 
@@ -57,8 +60,8 @@ class LeaseService {
   void acquireLease(const std::shared_ptr<AcquireLease::Request> request,
                     std::shared_ptr<AcquireLease::Response> response);
 
-  void releaseLease(const std::shared_ptr<ReleaseLease::Request> request,
-                    std::shared_ptr<ReleaseLease::Response> response);
+  void returnLease(const std::shared_ptr<ReleaseLease::Request> request,
+                   std::shared_ptr<ReleaseLease::Response> response);
 
  private:
   // The API to interact with Spot SDK.
@@ -69,5 +72,7 @@ class LeaseService {
 
   // The service provider.
   std::unique_ptr<MiddlewareHandle> middleware_handle_;
+
+  std::unordered_map<std::string, std::string>
 };
 }  // namespace spot_ros2::lease

spot_driver/src/api/default_lease_client.cpp

@@ -0,0 +1,26 @@
+// Copyright (c) 2025 Boston Dynamics AI Institute LLC. All rights reserved.
+
+#include <spot_driver/api/default_lease_api.hpp>
+
+namespace spot_ros2 {
+DefaultLeaseClient::DefaultLeaseClient(bosdyn::client::LeaseClient* lease_client)
+    : lease_client_{lease_client} {}
+
+tl::expected<InverseKinematicsResponse, std::string> DefaultKinematicApi::getSolutions(
+    InverseKinematicsRequest& request) {
+  try {
+    auto result = kinematic_client_->InverseKinematics(request);
+    if (result) {
+      return result.response;
+    }
+
+    const auto error_code = result.status.code().value();
+    const auto error_message = result.status.message();
+    return tl::make_unexpected("The InverseKinematics service returned with error code " + std::to_string(error_code) +
+                               ": " + error_message);
+  } catch (const std::exception& ex) {
+    return tl::make_unexpected("Failed to query the InverseKinematics service: " + std::string{ex.what()});
+  }
+}
+
+}  // namespace spot_ros2

spot_driver/src/lease/lease_service.cpp renamed to spot_driver/src/lease/lease_manager.cpp

@@ -11,32 +11,32 @@ constexpr auto kReleaseServiceName = "release_lease";
 }
 
 namespace spot_ros2::lease {
-LeaseService::LeaseService(std::shared_ptr<LeaseApi> kinematic_api,
-                                   std::shared_ptr<LoggerInterfaceBase> logger,
-                                   std::unique_ptr<MiddlewareHandle> middleware_handle)
+LeaseManager::LeaseManager(std::shared_ptr<LeaseClientInterface> lease_client_interface,
+                           std::shared_ptr<LoggerInterfaceBase> logger,
+                           std::unique_ptr<MiddlewareHandle> middleware_handle)
     : lease_api_{lease_api}, logger_{std::move(logger)}, middleware_handle_{std::move(middleware_handle)} {}
 
-void LeaseService::initialize() {
-  middleware_handle_->createAcquireService(kAcquireServiceName,
+void LeaseManager::initialize() {
+  middleware_handle_->createAcquireLeaseService(kAcquireLeaseServiceName,
                                            [this](const std::shared_ptr<AcquireLease::Request> request,
                                                   std::shared_ptr<AcquireLease::Response> response) {
                                                this->acquireLease(request, response);
                                            });
-  middleware_handle_->createReleaseService(kReleaseServiceName,
-                                           [this](const std::shared_ptr<ReleaseLease::Request> request,
-                                                  std::shared_ptr<ReleaseLease::Response> response) {
-                                               this->releaseLease(request, response);
+  middleware_handle_->createReturnLeaseService(kReleaseLeaseServiceName,
+                                               [this](const std::shared_ptr<ReturnLease::Request> request,
+                                                      std::shared_ptr<ReturnLease::Response> response) {
+                                                 this->returnLease(request, response);
                                            });
 }
 
-void LeaseService::acquireLease(const std::shared_ptr<AcquireLease::Request> request,
+void LeaseManager::acquireLease(const std::shared_ptr<AcquireLease::Request> request,
                                 std::shared_ptr<AcquireLease::Response> response) {
   auto ros_request = request->request;
 
   bosdyn::api::spot::InverseLeasesRequest proto_request;
   convertToProto(ros_request, proto_request);
 
-  auto expected = kinematic_api_->getSolutions(proto_request);
+  auto expected = default__api_->getSolutions(proto_request);
   if (!expected) {
     logger_->logError(std::string{"Error querying the Inverse Leases service: "}.append(expected.error()));
     response->response.status.value = bosdyn_spot_api_msgs::msg::InverseLeasesResponseStatus::STATUS_UNKNOWN;
@@ -45,8 +45,9 @@ void LeaseService::acquireLease(const std::shared_ptr<AcquireLease::Request> req
   }
 }
 
-void LeaseService::releaseLease(const std::shared_ptr<ReleaseLease::Request> request,
-                                std::shared_ptr<ReleaseLease::Response> response) {
+void LeaseManager::returnLease(const std::shared_ptr<ReturnLease::Request> request,
+                               std::shared_ptr<ReturnLease::Response> response) {
 
 }
+
 }  // namespace spot_ros2::lease

spot_msgs/srv/AcquireLease.srv

@@ -0,0 +1,6 @@
+string client_name
+string resource_name
+---
+bool success
+string message
+bosdyn_api_msgs/Lease lease

spot_msgs/srv/ReturnLease.srv

@@ -0,0 +1,4 @@
+bosdyn_api_msgs/Lease lease
+---
+bool success
+string message