fix(nebula_hw_interfaces): handling http get post request exception

nebula_hw_interfaces/include/nebula_hw_interfaces/nebula_hw_interfaces_velodyne/velodyne_hw_interface.hpp

@@ -26,6 +26,7 @@
 #define BOOST_ALLOW_DEPRECATED_HEADERS
 #endif
 
+#include "nebula_common/util/expected.hpp"
 #include "nebula_hw_interfaces/nebula_hw_interfaces_common/nebula_hw_interface_base.hpp"
 
 #include <boost_tcp_driver/http_client_driver.hpp>
@@ -69,8 +70,9 @@ class VelodyneHwInterface
   std::string target_reset_{"/cgi/reset"};
   void string_callback(const std::string & str);
 
-  std::string http_get_request(const std::string & endpoint);
-  std::string http_post_request(const std::string & endpoint, const std::string & body);
+  nebula::util::expected<std::string, Status> http_get_request(const std::string & endpoint);
+  nebula::util::expected<std::string, Status> http_post_request(
+    const std::string & endpoint, const std::string & body);
 
   /// @brief Get a one-off HTTP client to communicate with the hardware
   /// @param ctx IO Context
@@ -152,13 +154,13 @@ class VelodyneHwInterface
   VelodyneStatus init_http_client();
   /// @brief Getting the current operational state and parameters of the sensor (sync)
   /// @return Resulting JSON string
-  std::string get_status();
+  nebula::util::expected<std::string, Status> get_status();
   /// @brief Getting diagnostic information from the sensor (sync)
   /// @return Resulting JSON string
-  std::string get_diag();
+  nebula::util::expected<std::string, Status> get_diag();
   /// @brief Getting current sensor configuration and status data (sync)
   /// @return Resulting JSON string
-  std::string get_snapshot();
+  nebula::util::expected<std::string, Status> get_snapshot();
   /// @brief Setting Motor RPM (sync)
   /// @param rpm the RPM of the motor
   /// @return Resulting status

nebula_hw_interfaces/src/nebula_velodyne_hw_interfaces/velodyne_hw_interface.cpp

@@ -17,29 +17,79 @@
 {
 }
 
-std::string VelodyneHwInterface::http_get_request(const std::string & endpoint)
+nebula::util::expected<std::string, Status> VelodyneHwInterface::http_get_request(
+  const std::string & endpoint)
 {
   std::lock_guard lock(mtx_inflight_request_);
-  if (!http_client_driver_->client()->isOpen()) {
-    http_client_driver_->client()->open();
+  constexpr int max_retries = 3;
+  constexpr int retry_delay_ms = 100;
+
+  for (int retry = 0; retry < max_retries; ++retry) {
+    try {
+      if (!http_client_driver_->client()->isOpen()) {
+        http_client_driver_->client()->open();
+      }
+
+      std::string response = http_client_driver_->get(endpoint);
+      http_client_driver_->client()->close();
+      return nebula::util::expected<std::string, Status>(response);
+    } catch (const std::exception & ex) {
+      if (retry == max_retries - 1) {
+        return nebula::util::expected<std::string, Status>(Status::HTTP_CONNECTION_ERROR);
+      }
+
+      if (http_client_driver_->client()->isOpen()) {
+        try {
+          http_client_driver_->client()->close();
+        } catch (const std::exception & ex) {
+          return nebula::util::expected<std::string, Status>(Status::HTTP_CONNECTION_ERROR);
+        }
+      }
+
+      std::this_thread::sleep_for(std::chrono::milliseconds(retry_delay_ms));
+    }
   }
 
-  std::string response = http_client_driver_->get(endpoint);
-  http_client_driver_->client()->close();
-  return response;
+  return nebula::util::expected<std::string, Status>(Status::HTTP_CONNECTION_ERROR);
 }
 
-std::string VelodyneHwInterface::http_post_request(
+nebula::util::expected<std::string, Status> VelodyneHwInterface::http_post_request(
   const std::string & endpoint, const std::string & body)
 {
   std::lock_guard lock(mtx_inflight_request_);
-  if (!http_client_driver_->client()->isOpen()) {
-    http_client_driver_->client()->open();
+  constexpr int max_retries = 3;
+  constexpr int retry_delay_ms = 100;
+
+  for (int retry = 0; retry < max_retries; ++retry) {
+    try {
+      if (!http_client_driver_->client()->isOpen()) {
+        http_client_driver_->client()->open();
+      }
+
+      std::string response = http_client_driver_->post(endpoint, body);
+      http_client_driver_->client()->close();
+      return nebula::util::expected<std::string, Status>(response);
+    } catch (const std::exception & ex) {
+      if (retry == max_retries - 1) {
+        return nebula::util::expected<std::string, Status>(Status::HTTP_CONNECTION_ERROR);
+      }
+      print_debug(
+        "HTTP POST retry " + std::to_string(retry + 1) + "/" + std::to_string(max_retries) + ": " +
+        std::string(ex.what()));
+
+      if (http_client_driver_->client()->isOpen()) {
+        try {
+          http_client_driver_->client()->close();
+        } catch (const std::exception & ex) {
+          return nebula::util::expected<std::string, Status>(Status::HTTP_CONNECTION_ERROR);
+        }
+      }
+
+      std::this_thread::sleep_for(std::chrono::milliseconds(retry_delay_ms));
+    }
   }
 
-  std::string response = http_client_driver_->post(endpoint, body);
-  http_client_driver_->client()->close();
-  return response;
+  return nebula::util::expected<std::string, Status>(Status::HTTP_CONNECTION_ERROR);
 }
 
 Status VelodyneHwInterface::initialize_sensor_configuration(
@@ -53,7 +103,10 @@
   std::shared_ptr<const VelodyneSensorConfiguration> sensor_configuration)
 {
   auto snapshot = get_snapshot();
-  auto tree = parse_json(snapshot);
+  if (!snapshot.has_value()) {
+    return Status::HTTP_CONNECTION_ERROR;
+  }
+  auto tree = parse_json(snapshot.value());
   VelodyneStatus status = check_and_set_config(sensor_configuration, tree);
 
   return status;
@@ -102,7 +155,7 @@
   std::stringstream ss;
   ss << sensor_configuration;
   print_debug(ss.str());
-  return Status::ERROR_1;
+  return Status::HTTP_CONNECTION_ERROR;
 }
 
 VelodyneStatus VelodyneHwInterface::init_http_client()
@@ -243,19 +296,21 @@
 
 // sync
 
-std::string VelodyneHwInterface::get_status()
+nebula::util::expected<std::string, Status> VelodyneHwInterface::get_status()
 {
   return http_get_request(target_status_);
 }
 
-std::string VelodyneHwInterface::get_diag()
+nebula::util::expected<std::string, Status> VelodyneHwInterface::get_diag()
 {
-  auto rt = http_get_request(target_diag_);
-  std::cout << "read_response: " << rt << std::endl;
-  return rt;
+  auto response = http_get_request(target_diag_);
+  if (response.has_value()) {
+    std::cout << "read_response: " << response.value() << std::endl;
+  }
+  return response;
 }
 
-std::string VelodyneHwInterface::get_snapshot()
+nebula::util::expected<std::string, Status> VelodyneHwInterface::get_snapshot()
 {
   return http_get_request(target_snapshot_);
 }
@@ -266,7 +321,10 @@
     return VelodyneStatus::INVALID_RPM_ERROR;
   }
   auto rt = http_post_request(target_setting_, (boost::format("rpm=%d") % rpm).str());
-  string_callback(rt);
+  if (!rt.has_value()) {
+    return Status::HTTP_CONNECTION_ERROR;
+  }
+  string_callback(rt.value());
   return Status::OK;
 }
 
@@ -276,7 +334,10 @@
     return VelodyneStatus::INVALID_FOV_ERROR;
   }
   auto rt = http_post_request(target_fov_, (boost::format("start=%d") % fov_start).str());
-  string_callback(rt);
+  if (!rt.has_value()) {
+    return Status::HTTP_CONNECTION_ERROR;
+  }
+  string_callback(rt.value());
   return Status::OK;
 }
 
@@ -286,7 +347,10 @@
     return VelodyneStatus::INVALID_FOV_ERROR;
   }
   auto rt = http_post_request(target_fov_, (boost::format("end=%d") % fov_end).str());
-  string_callback(rt);
+  if (!rt.has_value()) {
+    return Status::HTTP_CONNECTION_ERROR;
+  }
+  string_callback(rt.value());
   return Status::OK;
 }
 
@@ -307,97 +371,136 @@
       return VelodyneStatus::INVALID_RETURN_MODE_ERROR;
   }
   auto rt = http_post_request(target_setting_, body_str);
-  string_callback(rt);
+  if (!rt.has_value()) {
+    return Status::HTTP_CONNECTION_ERROR;
+  }
+  string_callback(rt.value());
   return Status::OK;
 }
 
 VelodyneStatus VelodyneHwInterface::save_config()
 {
   std::string body_str = "submit";
   auto rt = http_post_request(target_save_, body_str);
-  string_callback(rt);
+  if (!rt.has_value()) {
+    return Status::HTTP_CONNECTION_ERROR;
+  }
+  string_callback(rt.value());
   return Status::OK;
 }
 
 VelodyneStatus VelodyneHwInterface::reset_system()
 {
   std::string body_str = "reset_system";
   auto rt = http_post_request(target_reset_, body_str);
-  string_callback(rt);
+  if (!rt.has_value()) {
+    return Status::HTTP_CONNECTION_ERROR;
+  }
+  string_callback(rt.value());
   return Status::OK;
 }
 
 VelodyneStatus VelodyneHwInterface::laser_on()
 {
   std::string body_str = "laser=on";
   auto rt = http_post_request(target_setting_, body_str);
-  string_callback(rt);
+  if (!rt.has_value()) {
+    return Status::HTTP_CONNECTION_ERROR;
+  }
+  string_callback(rt.value());
   return Status::OK;
 }
 
 VelodyneStatus VelodyneHwInterface::laser_off()
 {
   std::string body_str = "laser=off";
   auto rt = http_post_request(target_setting_, body_str);
-  string_callback(rt);
+  if (!rt.has_value()) {
+    return Status::HTTP_CONNECTION_ERROR;
+  }
+  string_callback(rt.value());
   return Status::OK;
 }
 
 VelodyneStatus VelodyneHwInterface::laser_on_off(bool on)
 {
   std::string body_str = (boost::format("laser=%s") % (on ? "on" : "off")).str();
   auto rt = http_post_request(target_setting_, body_str);
-  string_callback(rt);
+  if (!rt.has_value()) {
+    return Status::HTTP_CONNECTION_ERROR;
+  }
+  string_callback(rt.value());
   return Status::OK;
 }
 
 VelodyneStatus VelodyneHwInterface::set_host_addr(std::string addr)
 {
   auto rt = http_post_request(target_host_, (boost::format("addr=%s") % addr).str());
-  string_callback(rt);
+  if (!rt.has_value()) {
+    return Status::HTTP_CONNECTION_ERROR;
+  }
+  string_callback(rt.value());
   return Status::OK;
 }
 
 VelodyneStatus VelodyneHwInterface::set_host_dport(uint16_t dport)
 {
   auto rt = http_post_request(target_host_, (boost::format("dport=%d") % dport).str());
-  string_callback(rt);
+  if (!rt.has_value()) {
+    return Status::HTTP_CONNECTION_ERROR;
+  }
+  string_callback(rt.value());
   return Status::OK;
 }
 
 VelodyneStatus VelodyneHwInterface::set_host_tport(uint16_t tport)
 {
   auto rt = http_post_request(target_host_, (boost::format("tport=%d") % tport).str());
-  string_callback(rt);
+  if (!rt.has_value()) {
+    return Status::HTTP_CONNECTION_ERROR;
+  }
+  string_callback(rt.value());
   return Status::OK;
 }
 
 VelodyneStatus VelodyneHwInterface::set_net_addr(std::string addr)
 {
   auto rt = http_post_request(target_net_, (boost::format("addr=%s") % addr).str());
-  string_callback(rt);
+  if (!rt.has_value()) {
+    return Status::HTTP_CONNECTION_ERROR;
+  }
+  string_callback(rt.value());
   return Status::OK;
 }
 
 VelodyneStatus VelodyneHwInterface::set_net_mask(std::string mask)
 {
   auto rt = http_post_request(target_net_, (boost::format("mask=%s") % mask).str());
-  string_callback(rt);
+  if (!rt.has_value()) {
+    return Status::HTTP_CONNECTION_ERROR;
+  }
+  string_callback(rt.value());
   return Status::OK;
 }
 
 VelodyneStatus VelodyneHwInterface::set_net_gateway(std::string gateway)
 {
   auto rt = http_post_request(target_net_, (boost::format("gateway=%s") % gateway).str());
-  string_callback(rt);
+  if (!rt.has_value()) {
+    return Status::HTTP_CONNECTION_ERROR;
+  }
+  string_callback(rt.value());
   return Status::OK;
 }
 
 VelodyneStatus VelodyneHwInterface::set_net_dhcp(bool use_dhcp)
 {
   auto rt =
     http_post_request(target_net_, (boost::format("dhcp=%s") % (use_dhcp ? "on" : "off")).str());
-  string_callback(rt);
+  if (!rt.has_value()) {
+    return Status::HTTP_CONNECTION_ERROR;
+  }
+  string_callback(rt.value());
   return Status::OK;
 }