couchbase 4.4.1 → 4.4.3

package/deps/couchbase-cxx-client/core/columnar/query_component.cxx

@@ -17,8 +17,6 @@
 
 #include "query_component.hxx"
 
-#include <couchbase/error_codes.hxx>
-
 #include "backoff_calculator.hxx"
 #include "core/free_form_http_request.hxx"
 #include "core/http_component.hxx"
@@ -35,6 +33,7 @@
 
 #include <asio/io_context.hpp>
 #include <asio/steady_timer.hpp>
+#include <fmt/chrono.h>
 #include <fmt/format.h>
 #include <gsl/util>
 #include <tao/json/value.hpp>
@@ -43,6 +42,7 @@
 #include <cstdint>
 #include <memory>
 #include <mutex>
+#include <string>
 #include <system_error>
 #include <utility>
 #include <vector>
@@ -59,8 +59,9 @@ public:
                           http_component& http,
                           std::chrono::milliseconds default_timeout)
     : client_context_id_{ uuid::to_string(uuid::random()) }
-    , http_req_{ build_query_request(options) }
     , timeout_{ options.timeout.value_or(default_timeout) }
+    , payload_(build_query_payload(options))
+    , http_req_{ build_query_request(options) }
     , io_{ io }
     , deadline_{ io_ }
     , retry_timer_{ io_ }
@@ -78,13 +79,30 @@ public:
 
   auto dispatch() -> error
   {
-    auto op =
-      http_.do_http_request(http_req_, [self = shared_from_this()](auto resp, auto ec) mutable {
+    auto op = http_.do_http_request(
+      http_req_, [self = shared_from_this()](auto resp, error_union err) mutable {
         std::shared_ptr<pending_operation> op;
         {
           const std::scoped_lock lock{ self->pending_op_mutex_ };
           std::swap(op, self->pending_op_);
         }
+        if (!std::holds_alternative<std::monostate>(err)) {
+          if (std::holds_alternative<impl::bootstrap_error>(err)) {
+            auto bootstrap_error = std::get<impl::bootstrap_error>(err);
+            auto message = fmt::format(
+              "Failed to execute the HTTP request for the query due to a bootstrap error.  "
+              "See logs for further details.  bootstrap_error.message={}",
+              bootstrap_error.error_message);
+            self->invoke_callback({}, { maybe_convert_error_code(bootstrap_error.ec), message });
+          } else {
+            auto ec = maybe_convert_error_code(std::get<std::error_code>(err));
+            if (ec == errc::timeout) {
+              return self->trigger_timeout();
+            }
+            self->invoke_callback({}, { ec, "Failed to execute the HTTP request for the query" });
+          }
+          return;
+        }
         // op can be null if the pending_query_operation was cancelled.
         if (op) {
           auto op_info = std::dynamic_pointer_cast<pending_operation_connection_info>(op);
@@ -92,20 +110,9 @@ public:
           self->retry_info_.last_dispatched_to = op_info->dispatched_to();
           self->retry_info_.last_dispatched_to_host = op_info->dispatched_to_host();
         }
-
-        if (ec) {
-          if (ec == couchbase::errc::common::request_canceled) {
-            self->invoke_callback(
-              {},
-              { couchbase::core::columnar::errc::generic, "The query operation was canceled." });
-            return;
-          }
-          self->invoke_callback({}, { maybe_convert_error_code(ec) });
-          return;
-        }
         auto streamer = std::make_shared<row_streamer>(self->io_, resp.body(), "/results/^");
         return streamer->start(
-          [self, streamer, resp = std::move(resp)](auto metadata_header, auto ec) mutable {
+          [self, streamer, resp = std::move(resp)](const auto& metadata_header, auto ec) mutable {
             if (ec) {
               self->invoke_callback({}, { maybe_convert_error_code(ec) });
               return;
@@ -114,6 +121,7 @@ public:
               self->parse_error(resp.status_code(), utils::json::parse(metadata_header));
 
             if (error_parse_res.retriable) {
+              self->retry_info_.last_error = error_parse_res.err;
               return self->maybe_retry();
             }
 
@@ -130,7 +138,27 @@ public:
       pending_op_ = op.value();
       return {};
     }
-    return error{ op.error() };
+    retry_timer_.cancel();
+    deadline_.cancel();
+    error return_error{};
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    if (std::holds_alternative<impl::bootstrap_error>(op.error())) {
+      auto bootstrap_error = std::get<impl::bootstrap_error>(op.error());
+      auto message =
+        fmt::format("Failed to create the HTTP pending operation due to a bootstrap error.  "
+                    "See logs for further details.  bootstrap_error.message={}",
+                    bootstrap_error.error_message);
+      return_error.ec = bootstrap_error.ec;
+      return_error.message = message;
+    } else {
+      return_error.ec = std::get<std::error_code>(op.error());
+      return_error.message = "Failed to create the HTTP pending operation.";
+    }
+#else
+    return_error.ec = op.error();
+#endif
+    invoke_callback({}, return_error);
+    return return_error;
   }
 
   auto start(query_callback&& callback) -> error
@@ -154,6 +182,7 @@ public:
   {
     cancelled_ = true;
     retry_timer_.cancel();
+    deadline_.cancel();
     std::shared_ptr<pending_operation> op;
     {
       const std::scoped_lock lock{ pending_op_mutex_ };
@@ -162,12 +191,23 @@ public:
     if (op) {
       op->cancel();
     }
-    // This will only call the callback if it has not already been called.
-    invoke_callback(
-      {}, { couchbase::core::columnar::errc::generic, "The query operation was canceled." });
+    // This will only call the callback if it has not already been called (e.g. in the case of a
+    // timeout).
+    invoke_callback({},
+                    { couchbase::core::columnar::client_errc::canceled,
+                      "The query operation was canceled by the caller." });
   }
 
 private:
+  void update_http_request_timeout()
+  {
+    http_req_.timeout = std::chrono::duration_cast<std::chrono::milliseconds>(
+      deadline_.expiry() - std::chrono::steady_clock::now());
+    const auto server_timeout = http_req_.timeout + std::chrono::seconds(5);
+    payload_["timeout"] = fmt::format("{}ms", server_timeout.count());
+    http_req_.body = couchbase::core::utils::json::generate(payload_);
+  }
+
   void maybe_retry()
   {
     if (cancelled_) {
@@ -185,6 +225,13 @@ private:
       }
       self->retry_info_.retry_attempts++;
       self->http_req_.internal.undesired_endpoint = self->retry_info_.last_dispatched_to;
+      self->update_http_request_timeout();
+      CB_LOG_DEBUG(
+        "Retrying Query: client_context_id={}, http_timeout={}, retry_attempt={}, errors={}",
+        self->client_context_id_,
+        self->http_req_.timeout,
+        self->retry_info_.retry_attempts,
+        utils::json::generate(self->retry_info_.last_error.ctx["errors"]));
       auto err = self->dispatch();
       if (err) {
         self->invoke_callback({}, std::move(err));
@@ -236,11 +283,13 @@ private:
           break;
       }
     }
+
+    const std::chrono::milliseconds server_timeout = timeout_ + std::chrono::seconds(5);
+    payload["timeout"] = fmt::format("{}ms", server_timeout.count());
+
     for (const auto& [key, val] : options.raw) {
       payload[key] = utils::json::parse(val);
     }
-    const std::chrono::milliseconds server_timeout = timeout_ + std::chrono::seconds(5);
-    payload["timeout"] = fmt::format("{}ms", server_timeout.count());
 
     return payload;
   }
@@ -249,10 +298,8 @@ private:
   {
     http_request req{ service_type::analytics, "POST" };
     req.path = "/api/v1/request";
-    req.body = utils::json::generate(build_query_payload(options));
-    if (options.timeout.has_value()) {
-      req.timeout = options.timeout.value();
-    }
+    req.body = utils::json::generate(payload_);
+    req.timeout = timeout_;
 
     req.client_context_id = client_context_id_;
     req.headers["connection"] = "keep-alive";
@@ -277,6 +324,14 @@ private:
     err.ctx["retry_attempts"] = retry_info_.retry_attempts;
     err.ctx["last_dispatched_to"] = retry_info_.last_dispatched_to;
     err.ctx["last_dispatched_from"] = retry_info_.last_dispatched_from;
+
+    // When reporting a timeout that is a result of an operation being retried, the last set of
+    // retryable errors should be listed.
+    if (err.ec == errc::timeout && retry_info_.last_error) {
+      if (const auto* e = retry_info_.last_error.ctx.find("errors"); e != nullptr) {
+        err.ctx["last_errors"] = e->get_array();
+      }
+    }
   }
 
   auto parse_error(const std::uint32_t& http_status_code,
@@ -312,53 +367,71 @@ private:
     std::int32_t first_error_code{ 0 };
     std::string first_error_msg{};
 
+    std::int32_t first_non_retr_error_code{ 0 };
+    std::string first_non_retr_error_msg{};
+
     for (auto error_json : errors_json->get_array()) {
-      auto* retr = error_json.find("retriable");
-      if (retr == nullptr) {
-        // An error is assumed to not be retriable if the field is missing
-        res.retriable = false;
-      } else if (!retr->is_boolean()) {
-        return { { errc::generic,
-                   "Could not parse error from server response - 'retriable' was not boolean" } };
-      } else {
-        // Operation is retriable iff all errors are retriable
-        res.retriable = res.retriable && retr->get_boolean();
+      bool retr{ false }; // An error is assumed to not be retriable if the field is missing
+      {
+        auto* r = error_json.find("retriable");
+        if (r != nullptr) {
+          if (!r->is_boolean()) {
+            return {
+              { errc::generic,
+                "Could not parse error from server response - 'retriable' was not boolean" }
+            };
+          }
+          retr = r->get_boolean();
+        }
       }
 
-      auto* msg = error_json.find("msg");
-      if (msg == nullptr) {
-        return { { errc::generic,
-                   "Could not parse error from server response - could not find 'msg' field" } };
-      }
-      if (!msg->is_string()) {
-        return { { errc::generic,
-                   "Could not parse error from server response - 'msg' field was not string" } };
-      }
+      // Operation is retriable iff all errors are retriable
+      res.retriable = res.retriable && retr;
 
-      auto* c = error_json.find("code");
-      if (c == nullptr) {
-        return { { errc::generic,
-                   "Could not parse error from server response - could not find 'code' field" } };
-      }
-      if (!(c->is_unsigned() || c->is_signed())) {
-        return {
-          { errc::generic,
-            "Could not parse error from server response - 'code' field was not an integer" }
-        };
+      std::string msg{};
+      {
+        auto* m = error_json.find("msg");
+        if (m == nullptr) {
+          return { { errc::generic,
+                     "Could not parse error from server response - could not find 'msg' field" } };
+        }
+        if (!m->is_string()) {
+          return { { errc::generic,
+                     "Could not parse error from server response - 'msg' field was not string" } };
+        }
+        msg = m->get_string();
       }
 
-      std::int32_t code = c->is_signed() ? gsl::narrow_cast<std::int32_t>(c->get_signed())
-                                         : gsl::narrow_cast<std::int32_t>(c->get_unsigned());
+      std::int32_t code{};
+      {
+        auto* c = error_json.find("code");
+        if (c == nullptr) {
+          return { { errc::generic,
+                     "Could not parse error from server response - could not find 'code' field" } };
+        }
+        if (!(c->is_unsigned() || c->is_signed())) {
+          return {
+            { errc::generic,
+              "Could not parse error from server response - 'code' field was not an integer" }
+          };
+        }
+        code = c->is_signed() ? gsl::narrow_cast<std::int32_t>(c->get_signed())
+                              : gsl::narrow_cast<std::int32_t>(c->get_unsigned());
+      }
 
       tao::json::value error = {
         { "code", code },
-        { "msg", msg->get_string() },
+        { "msg", msg },
       };
       res.err.ctx["errors"].get_array().emplace_back(std::move(error));
 
       if (first_error_code == 0) {
         first_error_code = code;
-        first_error_msg = msg->get_string();
+        first_error_msg = msg;
+      }
+      if (!retr && first_non_retr_error_code == 0) {
+        first_non_retr_error_code = code;
+        first_non_retr_error_msg = msg;
       }
 
       switch (code) {
@@ -374,15 +447,23 @@ private:
     }
 
     if (res.err.ec == errc::query_error) {
-      res.err.properties = query_error_properties{ first_error_code, first_error_msg };
+      // If any of the errors is not retriable, report the first non-retriable code/message in the
+      // error properties
+      if (first_non_retr_error_code != 0) {
+        res.err.properties =
+          query_error_properties{ first_non_retr_error_code, first_non_retr_error_msg };
+      } else {
+        res.err.properties = query_error_properties{ first_error_code, first_error_msg };
+      }
     }
 
     return res;
   }
 
   std::string client_context_id_;
-  http_request http_req_;
   std::chrono::milliseconds timeout_;
+  tao::json::value payload_;
+  http_request http_req_;
   asio::io_context& io_;
   asio::steady_timer deadline_;
   asio::steady_timer retry_timer_;

package/deps/couchbase-cxx-client/core/columnar/query_component.hxx

@@ -17,12 +17,13 @@
 
 #pragma once
 
+#include "core/impl/bootstrap_error.hxx"
 #include "core/pending_operation.hxx"
 #include "error.hxx"
 #include "query_options.hxx"
 
+#include <chrono>
 #include <memory>
-#include <system_error>
 
 #include <tl/expected.hpp>
 

package/deps/couchbase-cxx-client/core/columnar/query_options.hxx

@@ -30,11 +30,6 @@
 #include <system_error>
 #include <vector>
 
-namespace couchbase
-{
-class retry_strategy;
-} // namespace couchbase
-
 namespace couchbase::core::columnar
 {
 enum class query_scan_consistency : std::uint8_t {

package/deps/couchbase-cxx-client/core/columnar/query_result.cxx

@@ -43,9 +43,6 @@ public:
     return rows_.next_row(
       [handler = std::move(handler)](const std::string& content, std::error_code ec) {
         if (ec) {
-          if (ec == couchbase::errc::common::request_canceled) {
-            return handler(query_result_end{}, {});
-          }
           return handler({}, { maybe_convert_error_code(ec) });
         }
         if (content.empty()) {

package/deps/couchbase-cxx-client/core/columnar/retry_info.hxx

@@ -17,6 +17,8 @@
 
 #pragma once
 
+#include "error.hxx"
+
 #include <cstddef>
 #include <string>
 
@@ -27,5 +29,6 @@ struct retry_info {
   std::string last_dispatched_to{};
   std::string last_dispatched_from{};
   std::string last_dispatched_to_host{};
+  error last_error{};
 };
 } // namespace couchbase::core::columnar