couchbase 4.4.2 → 4.4.4

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

@@ -15,6 +15,9 @@
 
 #pragma once
 
+#include <couchbase/build_config.hxx>
+
+#include "core/impl/bootstrap_error.hxx"
 #include "service_type.hxx"
 #include "utils/movable_function.hxx"
 
@@ -101,8 +104,13 @@ private:
   std::shared_ptr<http_response_impl> impl_;
 };
 
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+using free_form_http_request_callback =
+  utils::movable_function<void(http_response response, couchbase::core::error_union err)>;
+#else
 using free_form_http_request_callback =
   utils::movable_function<void(http_response response, std::error_code ec)>;
+#endif
 
 class buffered_http_response_impl;
 

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

@@ -131,19 +131,22 @@ public:
     invoke_response_handler(errc::common::request_canceled, {});
   }
 
-  void invoke_response_handler(std::error_code ec, io::http_streaming_response resp)
-  {
-    deadline_.cancel();
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  void invoke_response_handler(error_union err, io::http_streaming_response resp)
+  {
     dispatch_deadline_.cancel();
+#else
+  void invoke_response_handler(std::error_code err, io::http_streaming_response resp)
+  {
 #endif
+    deadline_.cancel();
     free_form_http_request_callback callback{};
     {
       const std::scoped_lock lock(callback_mutex_);
       std::swap(callback, callback_);
     }
     if (callback) {
-      callback(http_response{ std::move(resp) }, ec);
+      callback(http_response{ std::move(resp) }, err);
     }
   }
 
@@ -157,12 +160,22 @@ public:
     auto start_op = [self = shared_from_this()]() {
       self->session_->write_and_stream(
         self->encoded_,
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+        [self](error_union err, io::http_streaming_response resp) {
+          if (std::holds_alternative<std::error_code>(err) &&
+              std::get<std::error_code>(err) == asio::error::operation_aborted) {
+            return;
+          }
+          self->invoke_response_handler(err, std::move(resp));
+        },
+#else
         [self](std::error_code ec, io::http_streaming_response resp) {
           if (ec == asio::error::operation_aborted) {
             return;
           }
           self->invoke_response_handler(ec, std::move(resp));
         },
+#endif
         [self]() {
           self->stream_end_callback_();
         });
@@ -409,8 +422,13 @@ public:
   {
   }
 
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  auto do_http_request(const http_request& request, free_form_http_request_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, error_union>
+#else
   auto do_http_request(const http_request& request, free_form_http_request_callback&& callback)
     -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
+#endif
   {
     std::shared_ptr<io::http_session_manager> session_manager;
     {
@@ -436,9 +454,9 @@ public:
     auto op =
       std::make_shared<pending_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 };
+      auto err = defer_command(op, session_manager, credentials, std::move(callback));
+      if (!std::holds_alternative<std::monostate>(err)) {
+        return tl::unexpected{ err };
       }
       return op;
     }
@@ -478,8 +496,11 @@ public:
     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) {
+      auto err = defer_command(op, session_manager, credentials, std::move(callback));
+      if (!std::holds_alternative<std::monostate>(err)) {
+        auto ec = std::holds_alternative<impl::bootstrap_error>(err)
+                    ? std::get<impl::bootstrap_error>(err).ec
+                    : std::get<std::error_code>(err);
         return tl::unexpected{ ec };
       }
       return op;
@@ -498,16 +519,19 @@ private:
                            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);
-    });
-
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    op->start([callback = std::move(callback)](auto resp, error_union err) mutable {
+      callback(std::move(resp), err);
+    });
     // 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;
     }
+#else
+    op->start([callback = std::move(callback)](auto resp, auto ec) mutable {
+      callback(std::move(resp), ec);
+    });
 #endif
     std::shared_ptr<io::http_session> session;
     {
@@ -592,10 +616,10 @@ private:
   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,
-                     Callback&& callback) -> std::error_code
+                     Callback&& callback) -> error_union
   {
     if (auto last_error = session_manager->last_bootstrap_error(); last_error.has_value()) {
-      return last_error->ec;
+      return last_error.value();
     }
     CB_LOG_DEBUG(
       R"(Adding pending HTTP operation to deferred queue: service={}, client_context_id={})",
@@ -605,26 +629,26 @@ private:
                                             callback = std::forward<Callback>(callback),
                                             op = std::move(pending_op),
                                             session_manager,
-                                            credentials](std::error_code ec) mutable {
-      if (ec) {
+                                            credentials](error_union err) mutable {
+      if (!std::holds_alternative<std::monostate>(err)) {
         // The deferred operation was cancelled - currently this can happen due to closing the
         // cluster
-        return callback({}, ec);
+        return callback({}, err);
       }
 
       return send_http_operation(
         op, session_manager, credentials, std::forward<Callback>(callback));
     });
-    return {};
+    return std::monostate{};
   }
 
   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
+                     buffered_free_form_http_request_callback&& callback) -> error_union
   {
     if (auto last_error = session_manager->last_bootstrap_error(); last_error.has_value()) {
-      return last_error->ec;
+      return last_error.value();
     }
     CB_LOG_DEBUG(
       R"(Adding pending HTTP operation to deferred queue: service={}, client_context_id={})",
@@ -634,8 +658,11 @@ private:
                                             callback = std::move(callback),
                                             op = std::move(pending_op),
                                             session_manager,
-                                            credentials](std::error_code ec) mutable {
-      if (ec) {
+                                            credentials](error_union err) mutable {
+      if (!std::holds_alternative<std::monostate>(err)) {
+        auto ec = std::holds_alternative<impl::bootstrap_error>(err)
+                    ? std::get<impl::bootstrap_error>(err).ec
+                    : std::get<std::error_code>(err);
         // The deferred operation was cancelled - currently this can happen due to closing the
         // cluster
         return callback({}, ec);
@@ -643,7 +670,7 @@ private:
 
       return send_http_operation(op, session_manager, credentials, std::move(callback));
     });
-    return {};
+    return std::monostate{};
   }
 #endif
 
@@ -664,7 +691,11 @@ http_component::http_component(asio::io_context& io,
 auto
 http_component::do_http_request(const http_request& request,
                                 free_form_http_request_callback&& callback)
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  -> tl::expected<std::shared_ptr<pending_operation>, error_union>
+#else
   -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
+#endif
 {
   return impl_->do_http_request(request, std::move(callback));
 }

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

@@ -49,7 +49,11 @@ public:
                  std::shared_ptr<retry_strategy> default_retry_strategy = {});
 
   auto do_http_request(const http_request& request, free_form_http_request_callback&& callback)
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    -> tl::expected<std::shared_ptr<pending_operation>, error_union>;
+#else
     -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>;
+#endif
 
   auto do_http_request_buffered(const http_request& request,
                                 buffered_free_form_http_request_callback&& callback)

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

@@ -167,6 +167,7 @@ build_analytics_request(std::string statement,
     std::move(options.client_context_id),
     options.timeout,
   };
+  request.parent_span = options.parent_span;
   if (!options.raw.empty()) {
     for (auto& [name, value] : options.raw) {
       request.raw[name] = std::move(value);

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

@@ -159,7 +159,7 @@ public:
         {},
         options.timeout,
       },
-      [dataverse_name, handler = std::move(handler)](auto resp) {
+      [dataverse_name, handler = std::move(handler)](const auto& resp) {
         CB_LOG_DEBUG(
           "Dataverse create for {} error code = {}", dataverse_name, resp.ctx.ec.value());
         handler(core::impl::make_error(resp.ctx));
@@ -177,7 +177,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) {
+      [handler = std::move(handler)](const auto& resp) {
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -197,7 +197,7 @@ public:
         options.timeout,
         options.ignore_if_exists,
       },
-      [handler = std::move(handler)](auto resp) {
+      [handler = std::move(handler)](const auto& resp) {
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -214,7 +214,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) {
+      [handler = std::move(handler)](const auto& resp) {
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -262,7 +262,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) {
+      [handler = std::move(handler)](const auto& resp) {
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -281,7 +281,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) {
+      [handler = std::move(handler)](const auto& resp) {
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -324,7 +324,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) {
+      [handler = std::move(handler)](const auto& resp) {
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -339,7 +339,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) {
+      [handler = std::move(handler)](const auto& resp) {
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -386,7 +386,7 @@ public:
             {},
             options.timeout,
           },
-          [handler = std::move(handler)](auto resp) {
+          [handler = std::move(handler)](const auto& resp) {
             handler(core::impl::make_error(resp.ctx));
           });
 
@@ -398,7 +398,7 @@ public:
             {},
             options.timeout,
           },
-          [handler = std::move(handler)](auto resp) {
+          [handler = std::move(handler)](const auto& resp) {
             handler(core::impl::make_error(resp.ctx));
           });
 
@@ -410,7 +410,7 @@ public:
             {},
             options.timeout,
           },
-          [handler = std::move(handler)](auto resp) {
+          [handler = std::move(handler)](const auto& resp) {
             handler(core::impl::make_error(resp.ctx));
           });
     }
@@ -429,7 +429,7 @@ public:
             {},
             options.timeout,
           },
-          [handler = std::move(handler)](auto resp) {
+          [handler = std::move(handler)](const auto& resp) {
             handler(core::impl::make_error(resp.ctx));
           });
 
@@ -441,7 +441,7 @@ public:
             {},
             options.timeout,
           },
-          [handler = std::move(handler)](auto resp) {
+          [handler = std::move(handler)](const auto& resp) {
             handler(core::impl::make_error(resp.ctx));
           });
 
@@ -453,7 +453,7 @@ public:
             {},
             options.timeout,
           },
-          [handler = std::move(handler)](auto resp) {
+          [handler = std::move(handler)](const auto& resp) {
             handler(core::impl::make_error(resp.ctx));
           });
     }
@@ -471,7 +471,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) {
+      [handler = std::move(handler)](const auto& resp) {
         handler(core::impl::make_error(resp.ctx));
       });
   }

package/deps/couchbase-cxx-client/core/impl/bootstrap_error.hxx

@@ -20,8 +20,12 @@
 #include <optional>
 #include <string>
 #include <system_error>
+#include <variant>
 
-namespace couchbase::core::impl
+namespace couchbase::core
+{
+
+namespace impl
 {
 
 struct bootstrap_error {
@@ -31,4 +35,8 @@ struct bootstrap_error {
   std::optional<std::string> port;
 };
 
-} // namespace couchbase::core::impl
+} // namespace impl
+
+using error_union = std::variant<std::monostate, std::error_code, impl::bootstrap_error>;
+
+} // namespace couchbase::core

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

@@ -59,7 +59,7 @@ public:
                       name_,
                       core::impl::to_core_service_types(options.service_types),
                       options.timeout,
-                      [handler = std::move(handler)](auto resp) mutable {
+                      [handler = std::move(handler)](const auto& resp) mutable {
                         return handler({}, core::impl::build_result(resp));
                       });
   }

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

@@ -269,7 +269,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx), map_bucket_settings(resp.bucket));
       });
   }
@@ -282,7 +282,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx), map_all_bucket_settings(resp.buckets));
       });
   }
@@ -297,7 +297,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -312,7 +312,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -327,7 +327,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -342,7 +342,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }

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

@@ -230,21 +230,8 @@ public:
     // We cannot use close() method here, as it is capturing self as a shared
     // pointer to extend lifetime for the user's callback. Here the reference
     // counter has reached zero already, so we can only capture `*this`.
-    std::thread([this, &barrier]() mutable {
-      if (auto txns = std::move(transactions_); txns != nullptr) {
-        // blocks until cleanup is finished
-        txns->close();
-      }
-      std::promise<void> core_stopped;
-      auto f = core_stopped.get_future();
-      core_.close([&core_stopped]() {
-        core_stopped.set_value();
-      });
-      f.get();
-      io_.stop();
-      if (io_thread_.joinable()) {
-        io_thread_.join();
-      }
+    std::thread([this, barrier = std::move(barrier)]() mutable {
+      do_close();
       barrier.set_value();
     }).detach();
 
@@ -291,7 +278,7 @@ public:
                 }));
               return;
             }
-            impl->transactions_ = txns;
+            impl->transactions_ = std::move(txns);
             handler(ec, couchbase::cluster(std::move(impl)));
           });
       });
@@ -323,16 +310,17 @@ public:
                       {},
                       core::impl::to_core_service_types(options.service_types),
                       options.timeout,
-                      [handler = std::move(handler)](auto resp) mutable {
+                      [handler = std::move(handler)](const auto& resp) mutable {
                         return handler({}, core::impl::build_result(resp));
                       });
   };
 
   void diagnostics(const diagnostics_options::built& options, diagnostics_handler&& handler) const
   {
-    return core_.diagnostics(options.report_id, [handler = std::move(handler)](auto resp) mutable {
-      return handler({}, core::impl::build_result(resp));
-    });
+    return core_.diagnostics(options.report_id,
+                             [handler = std::move(handler)](const auto& resp) mutable {
+                               return handler({}, core::impl::build_result(resp));
+                             });
   }
 
   void search(std::string index_name,
@@ -342,7 +330,7 @@ public:
   {
     return core_.execute(
       core::impl::build_search_request(std::move(index_name), std::move(request), options, {}, {}),
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx),
                        search_result{ internal_search_result{ resp } });
       });
@@ -371,20 +359,7 @@ public:
   {
     // Spawn new thread to avoid joining IO thread from the same thread
     std::thread([self = shared_from_this(), handler = std::move(handler)]() mutable {
-      if (auto txns = std::move(self->transactions_); txns != nullptr) {
-        // blocks until cleanup is finished
-        txns->close();
-      }
-      std::promise<void> barrier;
-      auto future = barrier.get_future();
-      self->core_.close([&barrier]() {
-        barrier.set_value();
-      });
-      future.get();
-      self->io_.stop();
-      if (self->io_thread_.joinable()) {
-        self->io_thread_.join();
-      }
+      self->do_close();
       handler();
     }).detach();
   }
@@ -400,7 +375,25 @@ public:
   }
 
 private:
-  asio::io_context io_{ ASIO_CONCURRENCY_HINT_1 };
+  void do_close()
+  {
+    if (auto txns = std::move(transactions_); txns != nullptr) {
+      // blocks until cleanup is finished
+      txns->close();
+    }
+    std::promise<void> core_stopped;
+    auto f = core_stopped.get_future();
+    core_.close([core_stopped = std::move(core_stopped)]() mutable {
+      core_stopped.set_value();
+    });
+    f.get();
+    io_.stop();
+    if (io_thread_.joinable()) {
+      io_thread_.join();
+    }
+  }
+
+  asio::io_context io_{ ASIO_CONCURRENCY_HINT_SAFE };
   core::cluster core_{ io_ };
   std::shared_ptr<core::transactions::transactions> transactions_{ nullptr };
   std::thread io_thread_{ [&io = io_] {
@@ -539,12 +532,15 @@ cluster::connect(const std::string& connection_string,
   // Spawn new thread for connection to ensure that cluster_impl pointer will
   // not be deallocated in IO thread in case of error.
   std::thread([connection_string, options, handler = std::move(handler)]() {
-    auto impl = std::make_shared<cluster_impl>();
     auto barrier = std::make_shared<std::promise<std::pair<error, cluster>>>();
     auto future = barrier->get_future();
-    impl->open(connection_string, options, [barrier](auto err, auto c) {
-      barrier->set_value({ std::move(err), std::move(c) });
-    });
+    {
+      auto impl = std::make_shared<cluster_impl>();
+      impl->open(connection_string, options, [barrier](auto err, auto c) {
+        barrier->set_value({ std::move(err), std::move(c) });
+      });
+    }
+
     auto [err, c] = future.get();
     handler(std::move(err), std::move(c));
   }).detach();