couchbase 4.4.1 → 4.4.2

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

@@ -0,0 +1,56 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024. Couchbase, 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.
+ */
+
+#pragma once
+
+#include "core/pending_operation.hxx"
+#include "database_management_options.hxx"
+#include "error.hxx"
+
+#include <chrono>
+#include <memory>
+
+#include <tl/expected.hpp>
+
+namespace couchbase::core
+{
+class http_component;
+
+namespace columnar
+{
+class management_component_impl;
+
+class management_component
+{
+public:
+  management_component(http_component http, std::chrono::milliseconds default_timeout);
+
+  auto database_fetch_all(const fetch_all_databases_options& options,
+                          fetch_all_databases_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, error>;
+
+  auto database_drop(const drop_database_options& options, drop_database_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, error>;
+
+  auto database_create(const create_database_options& options, create_database_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, error>;
+
+private:
+  std::shared_ptr<management_component_impl> impl_;
+};
+} // namespace columnar
+} // namespace couchbase::core

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_ }
@@ -85,6 +86,12 @@ public:
           const std::scoped_lock lock{ self->pending_op_mutex_ };
           std::swap(op, self->pending_op_);
         }
+        if (ec) {
+          self->invoke_callback(
+            {},
+            { maybe_convert_error_code(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,17 +99,6 @@ 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 {
@@ -114,6 +110,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();
             }
 
@@ -154,6 +151,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 +160,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 +194,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));
@@ -249,10 +265,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 +291,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;
+      }
+    }
   }
 
   auto parse_error(const std::uint32_t& http_status_code,
@@ -381,8 +403,9 @@ private:
   }
 
   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

@@ -21,8 +21,8 @@
 #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