couchbase 3.7.0 → 3.8.0

data/ext/couchbase/core/cluster.hxx

@@ -17,7 +17,9 @@
 
 #pragma once
 
+#include "deprecation_utils.hxx"
 #include "diagnostics.hxx"
+#include "error.hxx"
 #include "operations_fwd.hxx"
 #include "origin.hxx"
 #include "topology/configuration.hxx"
@@ -37,6 +39,17 @@ namespace couchbase::core
 {
 class crud_component;
 class cluster_impl;
+class cluster_label_listener;
+
+namespace tracing
+{
+class tracer_wrapper;
+} // namespace tracing
+
+namespace metrics
+{
+class meter_wrapper;
+} // namespace metrics
 
 namespace mcbp
 {
@@ -80,6 +93,8 @@ public:
     utils::movable_function<void(std::error_code, std::shared_ptr<topology::configuration>)>&&
       handler) const;
 
+  [[nodiscard]] auto update_credentials(const core::cluster_credentials& auth) const -> core::error;
+
   void execute(o::analytics_request request, mf<void(o::analytics_response)>&& handler) const;
   void execute(o::append_request request, mf<void(o::append_response)>&& handler) const;
   void execute(o::decrement_request request, mf<void(o::decrement_response)>&& handler) const;
@@ -129,6 +144,10 @@ public:
   void execute(o::replace_request_with_legacy_durability request,
                mf<void(o::replace_response)>&& handler) const;
 
+  COUCHBASE_DEPRECATED(
+    "1.3.0",
+    "Views are deprecated in Couchbase Server 7.0+. Instead of views, use the Query "
+    "Service (SQL++).")
   void execute(o::document_view_request request,
                mf<void(o::document_view_response)>&& handler) const;
   void execute(o::http_noop_request request, mf<void(o::http_noop_response)>&& handler) const;
@@ -273,6 +292,14 @@ public:
   void execute(impl::observe_seqno_request request,
                mf<void(impl::observe_seqno_response)>&& handler) const;
 
+  void execute(o::get_replica_request_with_cancellation request,
+               mf<void(impl::get_replica_response)>&& handler) const;
+  void execute(o::get_request_with_cancellation request, mf<void(o::get_response)>&& handler) const;
+  void execute(o::lookup_in_request_with_cancellation request,
+               mf<void(o::lookup_in_response)>&& handler) const;
+  void execute(o::lookup_in_replica_request_with_cancellation request,
+               mf<void(impl::lookup_in_replica_response)>&& handler) const;
+
   void execute(
     om::analytics_link_replace_request<management::analytics::azure_blob_external_link> request,
     mf<void(om::analytics_link_replace_response)>&& handler) const;
@@ -312,6 +339,11 @@ public:
 
   [[nodiscard]] auto to_string() const -> std::string;
 
+  [[nodiscard]] auto tracer() const -> const std::shared_ptr<tracing::tracer_wrapper>&;
+  [[nodiscard]] auto meter() const -> const std::shared_ptr<metrics::meter_wrapper>&;
+  [[nodiscard]] auto cluster_label_listener() const
+    -> const std::shared_ptr<cluster_label_listener>&;
+
 private:
   std::shared_ptr<cluster_impl> impl_;
 };

data/ext/couchbase/core/cluster_credentials.cxx

@@ -24,4 +24,29 @@ cluster_credentials::uses_certificate() const -> bool
 {
   return !certificate_path.empty();
 }
+
+auto
+cluster_credentials::requires_tls() const -> bool
+{
+  return uses_certificate() || uses_jwt();
+}
+
+auto
+cluster_credentials::uses_jwt() const -> bool
+{
+  return !jwt_token.empty();
+}
+
+auto
+cluster_credentials::uses_password() const -> bool
+{
+  return !username.empty() && !password.empty();
+}
+
+auto
+cluster_credentials::is_same_type(const cluster_credentials& other) const -> bool
+{
+  return uses_certificate() == other.uses_certificate() && uses_jwt() == other.uses_jwt() &&
+         uses_password() == other.uses_password();
+}
 } // namespace couchbase::core

data/ext/couchbase/core/cluster_credentials.hxx

@@ -28,9 +28,14 @@ struct cluster_credentials {
   std::string password{};
   std::string certificate_path{};
   std::string key_path{};
+  std::string jwt_token{};
   std::optional<std::vector<std::string>> allowed_sasl_mechanisms{};
 
   [[nodiscard]] auto uses_certificate() const -> bool;
+  [[nodiscard]] auto requires_tls() const -> bool;
+  [[nodiscard]] auto uses_jwt() const -> bool;
+  [[nodiscard]] auto uses_password() const -> bool;
+  [[nodiscard]] auto is_same_type(const cluster_credentials& other) const -> bool;
 };
 
 } // namespace couchbase::core

data/ext/couchbase/core/cluster_label_listener.cxx

@@ -0,0 +1,72 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2025-Present 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.
+ */
+
+#include "cluster_label_listener.hxx"
+
+#include <mutex>
+#include <shared_mutex>
+
+namespace couchbase::core
+{
+class cluster_label_listener_impl
+{
+public:
+  cluster_label_listener_impl() = default;
+
+  void update_config(topology::configuration config)
+  {
+    const std::scoped_lock lock(mutex_);
+    if (config.cluster_name.has_value() && (cluster_name_ != config.cluster_name)) {
+      cluster_name_ = std::move(config.cluster_name);
+    }
+    if (config.cluster_uuid.has_value() && (cluster_uuid_ != config.cluster_uuid)) {
+      cluster_uuid_ = std::move(config.cluster_uuid);
+    }
+  }
+
+  auto cluster_labels() -> cluster_label_listener::labels
+  {
+    const std::shared_lock lock(mutex_);
+    return cluster_label_listener::labels{
+      cluster_name_,
+      cluster_uuid_,
+    };
+  }
+
+private:
+  std::shared_mutex mutex_{};
+  std::optional<std::string> cluster_name_{};
+  std::optional<std::string> cluster_uuid_{};
+};
+
+cluster_label_listener::cluster_label_listener()
+  : impl_{ std::make_shared<cluster_label_listener_impl>() }
+{
+}
+
+void
+cluster_label_listener::update_config(topology::configuration config)
+{
+  impl_->update_config(std::move(config));
+}
+
+auto
+cluster_label_listener::cluster_labels() const -> labels
+{
+  return impl_->cluster_labels();
+}
+} // namespace couchbase::core

data/ext/couchbase/core/cluster_label_listener.hxx

@@ -0,0 +1,46 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2025-Present 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 "config_listener.hxx"
+
+#include <memory>
+#include <optional>
+#include <string>
+
+namespace couchbase::core
+{
+class cluster_label_listener_impl;
+
+class cluster_label_listener : public config_listener
+{
+public:
+  cluster_label_listener();
+  void update_config(topology::configuration config) override;
+
+  struct labels {
+    std::optional<std::string> cluster_name;
+    std::optional<std::string> cluster_uuid;
+  };
+
+  [[nodiscard]] auto cluster_labels() const -> labels;
+
+private:
+  std::shared_ptr<cluster_label_listener_impl> impl_;
+};
+} // namespace couchbase::core

data/ext/couchbase/core/cluster_options.hxx

@@ -21,6 +21,7 @@
 #include "core/io/dns_config.hxx"
 #include "core/io/ip_protocol.hxx"
 #include "core/metrics/logging_meter_options.hxx"
+#include "core/orphan_reporter.hxx"
 #include "core/tracing/threshold_logging_options.hxx"
 #include "service_type.hxx"
 #include "timeout_defaults.hxx"
@@ -72,9 +73,11 @@ public:
   bool enable_compression{ true };
   bool enable_tracing{ true };
   bool enable_metrics{ true };
+  bool enable_orphan_reporting{ true };
   std::string network{ "auto" };
   tracing::threshold_logging_options tracing_options{};
   metrics::logging_meter_options metrics_options{};
+  orphan_reporter_options orphan_options{};
   tls_verify_mode tls_verify{ tls_verify_mode::peer };
   std::shared_ptr<couchbase::tracing::request_tracer> tracer{ nullptr };
   std::shared_ptr<couchbase::metrics::meter> meter{ nullptr };
@@ -110,6 +113,7 @@ public:
   };
   bool preserve_bootstrap_nodes_order{ false };
   bool allow_enterprise_analytics{ false };
+  bool enable_lazy_connections{ false };
 };
 
 } // namespace couchbase::core

data/ext/couchbase/core/deprecation_utils.hxx

@@ -0,0 +1,26 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-Present 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
+
+#ifndef COUCHBASE_DEPRECATED
+#ifdef COUCHBASE_CXX_CLIENT_IGNORE_CORE_DEPRECATIONS
+#define COUCHBASE_DEPRECATED(version, msg)
+#else
+#define COUCHBASE_DEPRECATED(version, msg) [[deprecated("Since SDK " version ". " msg)]]
+#endif
+#endif

data/ext/couchbase/core/error.hxx

@@ -0,0 +1,27 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ * Copyright 2022-Present 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
+ *
+ *     https://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 <string>
+#include <system_error>
+
+namespace couchbase::core
+{
+struct error {
+  std::error_code ec;
+  std::string message;
+};
+} // namespace couchbase::core

data/ext/couchbase/core/free_form_http_request.hxx

@@ -48,8 +48,6 @@ public:
   std::string method{};
   std::string endpoint{};
   std::string path{};
-  std::string username{};
-  std::string password{};
   std::string body{};
   std::map<std::string, std::string> headers{};
   std::string content_type{};

data/ext/couchbase/core/http_component.cxx

@@ -444,23 +444,11 @@ public:
       }
       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_http_operation>(io_, request, session_manager->dispatch_timeout());
     if (!session_manager->is_configured()) {
-      auto err = defer_command(op, session_manager, credentials, std::move(callback));
+      auto err = defer_command(op, session_manager, std::move(callback));
       if (!std::holds_alternative<std::monostate>(err)) {
         return tl::unexpected{ err };
       }
@@ -470,7 +458,7 @@ public:
     auto op = std::make_shared<pending_http_operation>(io_, request);
 #endif
 
-    send_http_operation(op, session_manager, credentials, std::move(callback));
+    send_http_operation(op, session_manager, std::move(callback));
     return op;
   }
 
@@ -487,22 +475,11 @@ public:
       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 err = defer_command(op, session_manager, credentials, std::move(callback));
+      auto err = defer_command(op, session_manager, 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
@@ -515,14 +492,13 @@ public:
     auto op = std::make_shared<pending_buffered_http_operation>(io_, request);
 #endif
 
-    send_http_operation(op, session_manager, credentials, std::move(callback));
+    send_http_operation(op, session_manager, 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)
   {
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
@@ -541,11 +517,8 @@ private:
 #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);
+      auto [check_out_ec, s] = session_manager->check_out(
+        op->request().service, op->request().endpoint, op->request().internal.undesired_endpoint);
       if (check_out_ec) {
         return op->invoke_response_handler(check_out_ec, {});
       }
@@ -576,16 +549,12 @@ 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);
+      auto [check_out_ec, s] = session_manager->check_out(
+        op->request().service, op->request().endpoint, op->request().internal.undesired_endpoint);
       if (check_out_ec) {
         return op->invoke_response_handler(check_out_ec, {});
       }
@@ -621,7 +590,6 @@ private:
   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,
                      Callback&& callback) -> error_union
   {
     if (auto last_error = session_manager->last_bootstrap_error(); last_error.has_value()) {
@@ -634,23 +602,20 @@ private:
     session_manager->add_to_deferred_queue([this,
                                             callback = std::forward<Callback>(callback),
                                             op = std::move(pending_op),
-                                            session_manager,
-                                            credentials](error_union err) mutable {
+                                            session_manager](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({}, err);
       }
 
-      return send_http_operation(
-        op, session_manager, credentials, std::forward<Callback>(callback));
+      return send_http_operation(op, session_manager, std::forward<Callback>(callback));
     });
     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) -> error_union
   {
     if (auto last_error = session_manager->last_bootstrap_error(); last_error.has_value()) {
@@ -663,8 +628,7 @@ private:
     session_manager->add_to_deferred_queue([this,
                                             callback = std::move(callback),
                                             op = std::move(pending_op),
-                                            session_manager,
-                                            credentials](error_union err) mutable {
+                                            session_manager](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
@@ -674,7 +638,7 @@ private:
         return callback({}, ec);
       }
 
-      return send_http_operation(op, session_manager, credentials, std::move(callback));
+      return send_http_operation(op, session_manager, std::move(callback));
     });
     return std::monostate{};
   }

data/ext/couchbase/core/impl/analytics.cxx

@@ -149,7 +149,8 @@ auto
 build_analytics_request(std::string statement,
                         analytics_options::built options,
                         std::optional<std::string> bucket_name,
-                        std::optional<std::string> scope_name)
+                        std::optional<std::string> scope_name,
+                        std::shared_ptr<couchbase::tracing::request_span> op_span)
   -> core::operations::analytics_request
 {
   core::operations::analytics_request request{
@@ -167,7 +168,7 @@ build_analytics_request(std::string statement,
     std::move(options.client_context_id),
     options.timeout,
   };
-  request.parent_span = options.parent_span;
+  request.parent_span = std::move(op_span);
   if (!options.raw.empty()) {
     for (auto& [name, value] : options.raw) {
       request.raw[name] = std::move(value);

data/ext/couchbase/core/impl/analytics.hxx

@@ -33,6 +33,7 @@ auto
 build_analytics_request(std::string statement,
                         analytics_options::built options,
                         std::optional<std::string> bucket_name,
-                        std::optional<std::string> scope_name)
+                        std::optional<std::string> scope_name,
+                        std::shared_ptr<couchbase::tracing::request_span> op_span)
   -> core::operations::analytics_request;
 } // namespace couchbase::core::impl