couchbase 4.4.1 → 4.4.2

package/deps/couchbase-cxx-client/core/http_component.cxx

@@ -25,6 +25,7 @@
 #include <couchbase/build_config.hxx>
 
 #include <asio/error.hpp>
+#include <fmt/chrono.h>
 #include <tl/expected.hpp>
 
 #include <memory>
@@ -32,6 +33,17 @@
 
 namespace couchbase::core
 {
+namespace
+{
+auto
+encode_http_request(const http_request& req) -> io::http_request
+{
+  return io::http_request{
+    req.service, req.method, req.path, req.headers, req.body, {}, req.client_context_id,
+  };
+}
+} // namespace
+
 class pending_http_operation
   : public std::enable_shared_from_this<pending_http_operation>
   , public pending_operation
@@ -46,30 +58,14 @@ public:
     , dispatch_deadline_{ io }
     , dispatch_timeout_{ dispatch_timeout }
     , request_{ std::move(request) }
-    , encoded_{ io::http_request {
-      request_.service,
-      request_.method,
-      request_.path,
-      request_.headers,
-      request_.body,
-      {},
-      request_.client_context_id,
-    } }
+    , encoded_{ encode_http_request(request_) }
   {
   }
 #else
   pending_http_operation(asio::io_context& io, http_request request)
     : deadline_{ io }
     , request_{ std::move(request) }
-    , encoded_{ io::http_request{
-        request_.service,
-        request_.method,
-        request_.path,
-        request_.headers,
-        request_.body,
-        {},
-        {},
-      } }
+    , encoded_{ encode_http_request(request_) }
   {
   }
 #endif
@@ -90,34 +86,36 @@ public:
       if (ec == asio::error::operation_aborted) {
         return;
       }
-      CB_LOG_DEBUG(R"(HTTP request timed out: {}, method={}, path="{}", client_context_id={})",
-                   self->encoded_.type,
-                   self->encoded_.method,
-                   self->encoded_.path,
-                   self->encoded_.client_context_id);
+      CB_LOG_DEBUG(
+        R"(HTTP request timed out (dispatch): {}, method={}, path="{}", dispatch_timeout={}, client_context_id={})",
+        self->encoded_.type,
+        self->encoded_.method,
+        self->encoded_.path,
+        self->dispatch_timeout_,
+        self->encoded_.client_context_id);
       self->trigger_timeout();
       if (self->session_) {
         self->session_->stop();
       }
     });
 #endif
-    if (request_.timeout.has_value()) {
-      deadline_.expires_after(request_.timeout.value());
-      deadline_.async_wait([self = shared_from_this()](auto ec) {
-        if (ec == asio::error::operation_aborted) {
-          return;
-        }
-        CB_LOG_DEBUG(R"(HTTP request timed out: {}, method={}, path="{}", client_context_id={})",
-                     self->encoded_.type,
-                     self->encoded_.method,
-                     self->encoded_.path,
-                     self->encoded_.client_context_id);
-        self->trigger_timeout();
-        if (self->session_) {
-          self->session_->stop();
-        }
-      });
-    }
+    deadline_.expires_after(request_.timeout);
+    deadline_.async_wait([self = shared_from_this()](auto ec) {
+      if (ec == asio::error::operation_aborted) {
+        return;
+      }
+      CB_LOG_DEBUG(
+        R"(HTTP request timed out: {}, method={}, path="{}", timeout={}, client_context_id={})",
+        self->encoded_.type,
+        self->encoded_.method,
+        self->encoded_.path,
+        self->request_.timeout,
+        self->encoded_.client_context_id);
+      self->trigger_timeout();
+      if (self->session_) {
+        self->session_->stop();
+      }
+    });
   }
 
   void set_stream_end_callback(utils::movable_function<void()>&& stream_end_callback)
@@ -179,18 +177,17 @@ public:
   }
 
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-
   [[nodiscard]] auto dispatch_deadline_expiry() const
     -> std::chrono::time_point<std::chrono::steady_clock>
   {
     return dispatch_deadline_.expiry();
   }
+#endif
 
   [[nodiscard]] auto request() const -> http_request
   {
     return request_;
   }
-#endif
 
   [[nodiscard]] auto dispatched_to() const -> std::string override
   {
@@ -230,6 +227,176 @@ private:
   std::mutex callback_mutex_;
 };
 
+class pending_buffered_http_operation
+  : public std::enable_shared_from_this<pending_buffered_http_operation>
+  , public pending_operation
+  , public pending_operation_connection_info
+{
+public:
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  pending_buffered_http_operation(asio::io_context& io,
+                                  http_request request,
+                                  std::chrono::milliseconds dispatch_timeout)
+    : deadline_{ io }
+    , dispatch_deadline_{ io }
+    , dispatch_timeout_{ dispatch_timeout }
+    , request_{ std::move(request) }
+    , encoded_{ encode_http_request(request_) }
+  {
+  }
+#else
+  pending_buffered_http_operation(asio::io_context& io, http_request request)
+    : deadline_{ io }
+    , request_{ std::move(request) }
+    , encoded_{ encode_http_request(request_) }
+  {
+  }
+#endif
+
+  ~pending_buffered_http_operation() override = default;
+  pending_buffered_http_operation(const pending_buffered_http_operation&) = delete;
+  pending_buffered_http_operation(pending_buffered_http_operation&&) = delete;
+  auto operator=(const pending_buffered_http_operation&) -> pending_buffered_http_operation =
+                                                              delete;
+  auto operator=(pending_buffered_http_operation&&) -> pending_buffered_http_operation = delete;
+
+  void start(buffered_free_form_http_request_callback&& callback)
+  {
+    callback_ = std::move(callback);
+    encoded_.headers["client-context-id"] = request_.client_context_id;
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    dispatch_deadline_.expires_after(dispatch_timeout_);
+    dispatch_deadline_.async_wait([self = shared_from_this()](auto ec) {
+      if (ec == asio::error::operation_aborted) {
+        return;
+      }
+      CB_LOG_DEBUG(
+        R"(HTTP request timed out (dispatch): {}, method={}, path="{}", dispatch_timeout={}, client_context_id={})",
+        self->encoded_.type,
+        self->encoded_.method,
+        self->encoded_.path,
+        self->dispatch_timeout_,
+        self->encoded_.client_context_id);
+      self->trigger_timeout();
+      if (self->session_) {
+        self->session_->stop();
+      }
+    });
+#endif
+    deadline_.expires_after(request_.timeout);
+    deadline_.async_wait([self = shared_from_this()](auto ec) {
+      if (ec == asio::error::operation_aborted) {
+        return;
+      }
+      CB_LOG_DEBUG(
+        R"(HTTP request timed out: {}, method={}, path="{}", timeout={}, client_context_id={})",
+        self->encoded_.type,
+        self->encoded_.method,
+        self->encoded_.path,
+        self->request_.timeout,
+        self->encoded_.client_context_id);
+      self->trigger_timeout();
+      if (self->session_) {
+        self->session_->stop();
+      }
+    });
+  }
+
+  void cancel() override
+  {
+    if (session_) {
+      session_->stop();
+    }
+    invoke_response_handler(errc::common::request_canceled, {});
+  }
+
+  void invoke_response_handler(std::error_code ec, io::http_response resp)
+  {
+    deadline_.cancel();
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    dispatch_deadline_.cancel();
+#endif
+    buffered_free_form_http_request_callback callback{};
+    {
+      const std::scoped_lock lock(callback_mutex_);
+      std::swap(callback, callback_);
+    }
+    if (callback) {
+      callback(buffered_http_response{ std::move(resp) }, ec);
+    }
+  }
+
+  void send_to(std::shared_ptr<io::http_session> session)
+  {
+    if (!callback_) {
+      return;
+    }
+    session_ = std::move(session);
+
+    session_->write_and_subscribe(
+      encoded_, [self = shared_from_this()](std::error_code ec, io::http_response resp) {
+        if (ec == asio::error::operation_aborted) {
+          return;
+        }
+        self->invoke_response_handler(ec, std::move(resp));
+      });
+  }
+
+  [[nodiscard]] auto deadline_expiry() const -> std::chrono::time_point<std::chrono::steady_clock>
+  {
+    return deadline_.expiry();
+  }
+
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  [[nodiscard]] auto dispatch_deadline_expiry() const
+    -> std::chrono::time_point<std::chrono::steady_clock>
+  {
+    return dispatch_deadline_.expiry();
+  }
+#endif
+
+  [[nodiscard]] auto request() const -> http_request
+  {
+    return request_;
+  }
+
+  [[nodiscard]] auto dispatched_to() const -> std::string override
+  {
+    return session_->remote_address();
+  }
+
+  [[nodiscard]] auto dispatched_from() const -> std::string override
+  {
+    return session_->local_address();
+  }
+
+  [[nodiscard]] auto dispatched_to_host() const -> std::string override
+  {
+    return fmt::format("{}:{}", session_->hostname(), session_->port());
+  }
+
+private:
+  void trigger_timeout()
+  {
+    // TODO(JC):  if triggered from the dispatch timeout, should only be
+    // errc::common::unambiguous_timeout?
+    auto ec =
+      request_.is_read_only ? errc::common::unambiguous_timeout : errc::common::ambiguous_timeout;
+    invoke_response_handler(ec, {});
+  }
+
+  asio::steady_timer deadline_;
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  asio::steady_timer dispatch_deadline_;
+  std::chrono::milliseconds dispatch_timeout_;
+#endif
+  http_request request_;
+  io::http_request encoded_;
+  buffered_free_form_http_request_callback callback_;
+  std::shared_ptr<io::http_session> session_;
+  std::mutex callback_mutex_;
+};
+
 class http_component_impl
 {
 public:
@@ -269,29 +436,95 @@ public:
     auto op =
       std::make_shared<pending_http_operation>(io_, request, session_manager->dispatch_timeout());
     if (!session_manager->is_configured()) {
-      return defer_command(op, session_manager, credentials, std::move(callback));
+      auto ec = defer_command(op, session_manager, credentials, std::move(callback));
+      if (ec) {
+        return tl::unexpected{ ec };
+      }
+      return op;
     }
 #else
     auto op = std::make_shared<pending_http_operation>(io_, request);
 #endif
 
-    std::shared_ptr<io::http_session> session;
+    send_http_operation(op, session_manager, credentials, std::move(callback));
+    return op;
+  }
+
+  auto do_http_request_buffered(const http_request& request,
+                                buffered_free_form_http_request_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
+  {
+    std::shared_ptr<io::http_session_manager> session_manager;
     {
-      auto [ec, s] = session_manager->check_out(
-        request.service, credentials, request.endpoint, request.internal.undesired_endpoint);
+      auto [ec, sm] = shim_.cluster.http_session_manager();
       if (ec) {
         return tl::unexpected(ec);
       }
-      session = std::move(s);
+      session_manager = std::move(sm);
     }
 
+    cluster_credentials credentials;
+    if (request.username.empty() && request.password.empty()) {
+      auto [ec, origin] = shim_.cluster.origin();
+      if (ec) {
+        return tl::unexpected(ec);
+      }
+      credentials = origin.credentials();
+    } else {
+      credentials = cluster_credentials{ request.username, request.password };
+    }
+
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    auto op = std::make_shared<pending_buffered_http_operation>(
+      io_, request, session_manager->dispatch_timeout());
+    if (!session_manager->is_configured()) {
+      auto ec = defer_command(op, session_manager, credentials, std::move(callback));
+      if (ec) {
+        return tl::unexpected{ ec };
+      }
+      return op;
+    }
+#else
+    auto op = std::make_shared<pending_buffered_http_operation>(io_, request);
+#endif
+
+    send_http_operation(op, session_manager, credentials, std::move(callback));
+    return op;
+  }
+
+private:
+  void send_http_operation(const std::shared_ptr<pending_http_operation>& op,
+                           const std::shared_ptr<io::http_session_manager>& session_manager,
+                           const couchbase::core::cluster_credentials& credentials,
+                           free_form_http_request_callback&& callback)
+  {
     op->start([callback = std::move(callback)](auto resp, auto ec) mutable {
       callback(std::move(resp), ec);
     });
-    op->set_stream_end_callback([session_manager, session, service = request.service]() mutable {
-      session_manager->check_in(service, session);
-    });
 
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    // don't do anything if the op wasn't dispatched or has already timed out
+    auto now = std::chrono::steady_clock::now();
+    if (op->dispatch_deadline_expiry() < now || op->deadline_expiry() < now) {
+      return;
+    }
+#endif
+    std::shared_ptr<io::http_session> session;
+    {
+      auto [check_out_ec, s] =
+        session_manager->check_out(op->request().service,
+                                   credentials,
+                                   op->request().endpoint,
+                                   op->request().internal.undesired_endpoint);
+      if (check_out_ec) {
+        return op->invoke_response_handler(check_out_ec, {});
+      }
+      session = std::move(s);
+    }
+    op->set_stream_end_callback(
+      [session_manager, session, service = op->request().service]() mutable {
+        session_manager->check_in(service, session);
+      });
     if (!session->is_connected()) {
       session_manager->connect_then_send_pending_op(
         session,
@@ -309,73 +542,108 @@ public:
     } else {
       op->send_to(session);
     }
-    return op;
   }
 
-private:
+  void send_http_operation(const std::shared_ptr<pending_buffered_http_operation>& op,
+                           const std::shared_ptr<io::http_session_manager>& session_manager,
+                           const couchbase::core::cluster_credentials& credentials,
+                           buffered_free_form_http_request_callback&& callback)
+  {
+    std::shared_ptr<io::http_session> session;
+    {
+      auto [check_out_ec, s] =
+        session_manager->check_out(op->request().service,
+                                   credentials,
+                                   op->request().endpoint,
+                                   op->request().internal.undesired_endpoint);
+      if (check_out_ec) {
+        return op->invoke_response_handler(check_out_ec, {});
+      }
+      session = std::move(s);
+    }
+    op->start(
+      [callback = std::move(callback), session_manager, session, service = op->request().service](
+        auto resp, auto ec) mutable {
+        callback(std::move(resp), ec);
+        session_manager->check_in(service, session);
+      });
+
+    if (!session->is_connected()) {
+      session_manager->connect_then_send_pending_op(
+        session,
+        {},
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-  auto defer_command(std::shared_ptr<pending_http_operation> pending_op,
+        op->dispatch_deadline_expiry(),
+#endif
+        op->deadline_expiry(),
+        [op](std::error_code ec, std::shared_ptr<io::http_session> http_session) {
+          if (ec) {
+            return op->invoke_response_handler(ec, {});
+          }
+          op->send_to(std::move(http_session));
+        });
+    } else {
+      op->send_to(session);
+    }
+  }
+
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  template<typename Callback, typename PendingHttpOp>
+  auto defer_command(std::shared_ptr<PendingHttpOp> pending_op,
                      const std::shared_ptr<io::http_session_manager>& session_manager,
                      const couchbase::core::cluster_credentials& credentials,
-                     free_form_http_request_callback&& callback)
-    -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
+                     Callback&& callback) -> std::error_code
   {
     if (auto last_error = session_manager->last_bootstrap_error(); last_error.has_value()) {
-      return tl::unexpected(last_error->ec);
+      return last_error->ec;
     }
-    pending_op->start([callback = std::move(callback)](auto resp, auto ec) mutable {
-      callback(std::move(resp), ec);
+    CB_LOG_DEBUG(
+      R"(Adding pending HTTP operation to deferred queue: service={}, client_context_id={})",
+      pending_op->request().service,
+      pending_op->request().client_context_id);
+    session_manager->add_to_deferred_queue([this,
+                                            callback = std::forward<Callback>(callback),
+                                            op = std::move(pending_op),
+                                            session_manager,
+                                            credentials](std::error_code ec) mutable {
+      if (ec) {
+        // The deferred operation was cancelled - currently this can happen due to closing the
+        // cluster
+        return callback({}, ec);
+      }
+
+      return send_http_operation(
+        op, session_manager, credentials, std::forward<Callback>(callback));
     });
+    return {};
+  }
+
+  auto defer_command(std::shared_ptr<pending_buffered_http_operation> pending_op,
+                     const std::shared_ptr<io::http_session_manager>& session_manager,
+                     const couchbase::core::cluster_credentials& credentials,
+                     buffered_free_form_http_request_callback&& callback) -> std::error_code
+  {
+    if (auto last_error = session_manager->last_bootstrap_error(); last_error.has_value()) {
+      return last_error->ec;
+    }
     CB_LOG_DEBUG(
       R"(Adding pending HTTP operation to deferred queue: service={}, client_context_id={})",
       pending_op->request().service,
       pending_op->request().client_context_id);
-    session_manager->add_to_deferred_queue(
-      [op = pending_op, session_manager, credentials](std::error_code ec) mutable {
-        if (ec) {
-          // The deferred operation was cancelled - currently this can happen due to closing the
-          // cluster
-          return op->invoke_response_handler(ec, {});
-        }
+    session_manager->add_to_deferred_queue([this,
+                                            callback = std::move(callback),
+                                            op = std::move(pending_op),
+                                            session_manager,
+                                            credentials](std::error_code ec) mutable {
+      if (ec) {
+        // The deferred operation was cancelled - currently this can happen due to closing the
+        // cluster
+        return callback({}, ec);
+      }
 
-        // don't do anything if the op wasn't dispatched or has already timed out
-        auto now = std::chrono::steady_clock::now();
-        if (op->dispatch_deadline_expiry() < now || op->deadline_expiry() < now) {
-          return;
-        }
-        std::shared_ptr<io::http_session> session;
-        {
-          auto [check_out_ec, s] =
-            session_manager->check_out(op->request().service,
-                                       credentials,
-                                       op->request().endpoint,
-                                       op->request().internal.undesired_endpoint);
-          if (check_out_ec) {
-            return op->invoke_response_handler(check_out_ec, {});
-          }
-          session = std::move(s);
-        }
-        op->set_stream_end_callback(
-          [session_manager, session, service = op->request().service]() mutable {
-            session_manager->check_in(service, session);
-          });
-        if (!session->is_connected()) {
-          session_manager->connect_then_send_pending_op(
-            session,
-            {},
-            op->dispatch_deadline_expiry(),
-            op->deadline_expiry(),
-            [op](std::error_code ec, std::shared_ptr<io::http_session> http_session) {
-              if (ec) {
-                return op->invoke_response_handler(ec, {});
-              }
-              op->send_to(std::move(http_session));
-            });
-        } else {
-          op->send_to(session);
-        }
-      });
-    return pending_op;
+      return send_http_operation(op, session_manager, credentials, std::move(callback));
+    });
+    return {};
   }
 #endif
 
@@ -401,4 +669,12 @@ http_component::do_http_request(const http_request& request,
   return impl_->do_http_request(request, std::move(callback));
 }
 
+auto
+http_component::do_http_request_buffered(const couchbase::core::http_request& request,
+                                         buffered_free_form_http_request_callback&& callback)
+  -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
+{
+  return impl_->do_http_request_buffered(request, std::move(callback));
+}
+
 } // namespace couchbase::core

package/deps/couchbase-cxx-client/core/http_component.hxx

@@ -51,6 +51,10 @@ public:
   auto do_http_request(const http_request& request, free_form_http_request_callback&& callback)
     -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>;
 
+  auto do_http_request_buffered(const http_request& request,
+                                buffered_free_form_http_request_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>;
+
 private:
   std::shared_ptr<http_component_impl> impl_;
 };

package/deps/couchbase-cxx-client/core/impl/cluster.cxx

@@ -140,7 +140,6 @@ options_to_origin(const std::string& connection_string,
   user_options.enable_mutation_tokens = opts.behavior.enable_mutation_tokens;
   user_options.enable_unordered_execution = opts.behavior.enable_unordered_execution;
   user_options.user_agent_extra = opts.behavior.user_agent_extra;
-  user_options.network = opts.behavior.network;
 
   user_options.server_group = opts.network.server_group;
   user_options.enable_tcp_keep_alive = opts.network.enable_tcp_keep_alive;
@@ -150,8 +149,10 @@ options_to_origin(const std::string& connection_string,
   if (opts.network.max_http_connections) {
     user_options.max_http_connections = opts.network.max_http_connections.value();
   }
-  if (!opts.network.network.empty()) {
-    user_options.network = opts.network.network;
+  user_options.network = opts.network.network;
+  if (user_options.network.empty()) {
+    // this is deprecated option, but use it in case main options is empty
+    user_options.network = opts.behavior.network;
   }
   switch (opts.network.ip_protocol) {
     case ip_protocol::any:

package/deps/couchbase-cxx-client/core/impl/lookup_in_replica.cxx

@@ -16,10 +16,14 @@
  */
 
 #include "lookup_in_replica.hxx"
+
 #include "core/impl/subdoc/path_flags.hxx"
+#include "core/utils/json.hxx"
 
 #include <couchbase/error_codes.hxx>
 
+#include <tao/json/value.hpp>
+
 namespace couchbase::core::impl
 {
 auto