couchbase 3.7.0 → 3.8.0

data/ext/couchbase/core/bucket.cxx

@@ -19,6 +19,7 @@
 
 #include "collection_id_cache_entry.hxx"
 #include "core/app_telemetry_meter.hxx"
+#include "core/cluster_options.hxx"
 #include "core/config_listener.hxx"
 #include "core/document_id.hxx"
 #include "core/error_context/key_value_error_map_info.hxx"
@@ -85,20 +86,22 @@ public:
               couchbase::core::origin origin,
               std::shared_ptr<tracing::tracer_wrapper> tracer,
               std::shared_ptr<metrics::meter_wrapper> meter,
+              std::shared_ptr<orphan_reporter> orphan_reporter,
               std::shared_ptr<core::app_telemetry_meter> app_telemetry,
               std::vector<protocol::hello_feature> known_features,
               std::shared_ptr<impl::bootstrap_state_listener> state_listener,
               asio::io_context& ctx,
-              asio::ssl::context& tls)
+              tls_context_provider& tls)
     : client_id_{ std::move(client_id) }
     , name_{ std::move(name) }
     , log_prefix_{ fmt::format("[{}/{}]", client_id_, name_) }
-    , origin_{ std::move(origin) }
     , tracer_{ std::move(tracer) }
     , meter_{ std::move(meter) }
+    , orphan_reporter_{ std::move(orphan_reporter) }
     , app_telemetry_meter_{ std::move(app_telemetry) }
     , known_features_{ std::move(known_features) }
     , state_listener_{ std::move(state_listener) }
+    , origin_{ std::move(origin) }
     , codec_{ { known_features_.begin(), known_features_.end() } }
     , ctx_{ ctx }
     , tls_{ tls }
@@ -117,11 +120,13 @@ public:
                         std::optional<key_value_error_map_info> error_info)
   {
     // TODO(SA): copy from mcbp_command, subject to refactor later
+#ifdef COUCHBASE_CXX_CLIENT_CREATE_OPERATION_SPAN_IN_CORE
     metrics::metric_attributes attrs{
       service_type::key_value, fmt::format("{}", req->command_), ec, name_, req->scope_name_,
       req->collection_name_,
     };
     meter_->record_value(std::move(attrs), req->dispatched_time_);
+#endif
 
     if (ec == asio::error::operation_aborted) {
       // TODO(SA): fix tracing
@@ -317,11 +322,11 @@ public:
   {
     if (req->key_.empty()) {
       if (auto server = server_by_vbucket(req->vbucket_, req->replica_index_); server) {
-        return find_session_by_index(server.value());
+        return find_or_connect_session_by_index(server.value());
       }
     } else if (auto [partition, server] = map_id(req->key_, req->replica_index_); server) {
       req->vbucket_ = partition;
-      return find_session_by_index(server.value());
+      return find_or_connect_session_by_index(server.value());
     }
     return std::nullopt;
   }
@@ -365,6 +370,53 @@ public:
     return { 0, std::nullopt };
   }
 
+  void connect_session(std::size_t index)
+  {
+    const std::scoped_lock lock(config_mutex_, sessions_mutex_);
+    if (!config_) {
+      return;
+    }
+
+    const auto& node = config_->nodes[index];
+
+    const auto& hostname = node.hostname_for(origin_.options().network);
+    auto port = node.port_or(
+      origin_.options().network, service_type::key_value, origin_.options().enable_tls, 0);
+    if (port == 0) {
+      return;
+    }
+
+    const couchbase::core::origin origin(origin_.credentials(), hostname, port, origin_.options());
+    io::mcbp_session session =
+      origin_.options().enable_tls
+        ? io::mcbp_session(
+            client_id_, node.node_uuid, ctx_, tls_, origin, state_listener_, name_, known_features_)
+        : io::mcbp_session(
+            client_id_, node.node_uuid, ctx_, origin, state_listener_, name_, known_features_);
+    CB_LOG_DEBUG(R"({} rev={}, connect idx={}, session="{}", address="{}:{}")",
+                 log_prefix_,
+                 config_->rev_str(),
+                 node.index,
+                 session.id(),
+                 hostname,
+                 port);
+    session.bootstrap(
+      [self = shared_from_this(), session](std::error_code err,
+                                           topology::configuration cfg) mutable -> void {
+        if (err) {
+          return self->remove_session(session.id());
+        }
+        self->update_config(std::move(cfg));
+        session.on_configuration_update(self);
+        session.on_stop([id = session.id(), self]() -> void {
+          self->remove_session(id);
+        });
+        self->drain_deferred_queue({});
+      },
+      true);
+    sessions_.insert_or_assign(index, std::move(session));
+  }
+
   void restart_sessions()
   {
     const std::scoped_lock lock(config_mutex_, sessions_mutex_);
@@ -594,9 +646,9 @@ public:
     {
       const std::scoped_lock lock(sessions_mutex_);
       if (sessions_.empty()) {
-        CB_LOG_WARNING(R"({} unable to find connected session (sessions_ is empty), retry in {})",
-                       log_prefix_,
-                       heartbeat_interval_);
+        CB_LOG_DEBUG(R"({} unable to find connected session (sessions_ is empty), retry in {})",
+                     log_prefix_,
+                     heartbeat_interval_);
         return;
       }
 
@@ -616,9 +668,9 @@ public:
       req.opaque(session->next_opaque());
       session->write_and_flush(req.data());
     } else {
-      CB_LOG_WARNING(R"({} unable to find connected session with GCCCP support, retry in {})",
-                     log_prefix_,
-                     heartbeat_interval_);
+      CB_LOG_DEBUG(R"({} unable to find connected session with GCCCP support, retry in {})",
+                   log_prefix_,
+                   heartbeat_interval_);
     }
   }
 
@@ -698,6 +750,11 @@ public:
     }
   }
 
+  void update_credentials(cluster_credentials credentials)
+  {
+    origin_.update_credentials(std::move(credentials));
+  }
+
   void update_config(topology::configuration config) override
   {
     std::vector<topology::configuration::node> added{};
@@ -810,6 +867,10 @@ public:
           continue;
         }
 
+        if (origin_.options().enable_lazy_connections) {
+          ++next_index;
+          continue;
+        }
         const couchbase::core::origin origin(
           origin_.credentials(), hostname, port, origin_.options());
         io::mcbp_session session =
@@ -883,6 +944,16 @@ public:
     return {};
   }
 
+  [[nodiscard]] auto find_or_connect_session_by_index(std::size_t index)
+    -> std::optional<io::mcbp_session>
+  {
+    if (auto session = find_session_by_index(index); session) {
+      return session;
+    }
+    connect_session(index);
+    return {};
+  }
+
   [[nodiscard]] auto next_session_index() -> std::size_t
   {
     const std::scoped_lock lock(sessions_mutex_);
@@ -929,6 +1000,11 @@ public:
     return meter_;
   }
 
+  [[nodiscard]] auto orphan_reporter() const -> std::shared_ptr<core::orphan_reporter>
+  {
+    return orphan_reporter_;
+  }
+
   [[nodiscard]] auto app_telemetry_meter() const -> std::shared_ptr<core::app_telemetry_meter>
   {
     return app_telemetry_meter_;
@@ -977,20 +1053,33 @@ public:
     return {};
   }
 
+  void for_each_session(utils::movable_function<void(io::mcbp_session&)> handler)
+  {
+    std::map<size_t, io::mcbp_session> sessions;
+    {
+      const std::scoped_lock lock(sessions_mutex_);
+      sessions = sessions_;
+    }
+    for (auto& [index, session] : sessions) {
+      handler(session);
+    }
+  }
+
 private:
   const std::string client_id_;
   const std::string name_;
   const std::string log_prefix_;
-  const origin origin_;
   const std::shared_ptr<tracing::tracer_wrapper> tracer_;
   const std::shared_ptr<metrics::meter_wrapper> meter_;
+  const std::shared_ptr<core::orphan_reporter> orphan_reporter_;
   const std::shared_ptr<core::app_telemetry_meter> app_telemetry_meter_;
   const std::vector<protocol::hello_feature> known_features_;
   const std::shared_ptr<impl::bootstrap_state_listener> state_listener_;
+  origin origin_;
   mcbp::codec codec_;
 
   asio::io_context& ctx_;
-  asio::ssl::context& tls_;
+  tls_context_provider& tls_;
 
   asio::steady_timer heartbeat_timer_;
   std::chrono::milliseconds heartbeat_interval_;
@@ -1015,9 +1104,10 @@ private:
 
 bucket::bucket(std::string client_id,
                asio::io_context& ctx,
-               asio::ssl::context& tls,
+               tls_context_provider& tls,
                std::shared_ptr<tracing::tracer_wrapper> tracer,
                std::shared_ptr<metrics::meter_wrapper> meter,
+               std::shared_ptr<core::orphan_reporter> orphan_reporter,
                std::shared_ptr<core::app_telemetry_meter> app_telemetry_meter,
                std::string name,
                couchbase::core::origin origin,
@@ -1030,6 +1120,7 @@ bucket::bucket(std::string client_id,
                                          std::move(origin),
                                          std::move(tracer),
                                          std::move(meter),
+                                         std::move(orphan_reporter),
                                          std::move(app_telemetry_meter),
                                          std::move(known_features),
                                          std::move(state_listener),
@@ -1068,6 +1159,12 @@ bucket::update_config(topology::configuration config)
   return impl_->update_config(std::move(config));
 }
 
+void
+bucket::update_credentials(cluster_credentials credentials)
+{
+  return impl_->update_credentials(std::move(credentials));
+}
+
 auto
 bucket::name() const -> const std::string&
 {
@@ -1098,6 +1195,12 @@ bucket::meter() const -> std::shared_ptr<metrics::meter_wrapper>
   return impl_->meter();
 }
 
+auto
+bucket::orphan_reporter() const -> std::shared_ptr<core::orphan_reporter>
+{
+  return impl_->orphan_reporter();
+}
+
 auto
 bucket::app_telemetry_meter() const -> std::shared_ptr<core::app_telemetry_meter>
 {
@@ -1148,6 +1251,12 @@ bucket::defer_command(utils::movable_function<void(std::error_code)> command)
   impl_->defer_command(std::move(command));
 }
 
+void
+bucket::for_each_session(utils::movable_function<void(io::mcbp_session&)> handler)
+{
+  impl_->for_each_session(std::move(handler));
+}
+
 auto
 bucket::default_timeout() const -> std::chrono::milliseconds
 {
@@ -1190,4 +1299,10 @@ bucket::direct_re_queue(const std::shared_ptr<mcbp::queue_request>& req, bool is
 {
   return impl_->direct_re_queue(req, is_retry);
 }
+
+void
+bucket::connect_session(std::size_t index)
+{
+  return impl_->connect_session(index);
+}
 } // namespace couchbase::core

data/ext/couchbase/core/bucket.hxx

@@ -20,6 +20,7 @@
 #include "config_listener.hxx"
 #include "io/mcbp_command.hxx"
 #include "operations.hxx"
+#include "tls_context_provider.hxx"
 
 #include <asio/bind_executor.hpp>
 #include <asio/io_context.hpp>
@@ -67,10 +68,11 @@ class bucket
 public:
   bucket(std::string client_id,
          asio::io_context& ctx,
-         asio::ssl::context& tls,
+         tls_context_provider& tls,
          std::shared_ptr<tracing::tracer_wrapper> tracer,
          std::shared_ptr<metrics::meter_wrapper> meter,
-         std::shared_ptr<core::app_telemetry_meter> app_telemetry_meter,
+         std::shared_ptr<orphan_reporter> orphan_reporter,
+         std::shared_ptr<app_telemetry_meter> app_telemetry_meter,
          std::string name,
          couchbase::core::origin origin,
          std::vector<protocol::hello_feature> known_features,
@@ -104,6 +106,8 @@ public:
     });
   }
 
+  void connect_session(std::size_t index);
+
   template<typename Request>
   void map_and_send(std::shared_ptr<operations::mcbp_command<bucket, Request>> cmd)
   {
@@ -141,6 +145,9 @@ public:
         session.has_value() ? session->bootstrap_address() : "",
         session.has_value() && session->has_config(),
         config_rev());
+      if (!session) {
+        connect_session(index);
+      }
       return defer_command([self = shared_from_this(), cmd](std::error_code ec) {
         if (ec == errc::common::request_canceled) {
           return cmd->cancel(retry_reason::do_not_retry);
@@ -194,6 +201,7 @@ public:
 
   void fetch_config();
   void update_config(topology::configuration config) override;
+  void update_credentials(cluster_credentials credentials);
   void bootstrap(utils::movable_function<void(std::error_code, topology::configuration)>&& handler);
   void with_configuration(
     utils::movable_function<void(std::error_code, std::shared_ptr<topology::configuration>)>&&
@@ -205,11 +213,13 @@ public:
   void ping(const std::shared_ptr<diag::ping_collector>& collector,
             std::optional<std::chrono::milliseconds> timeout);
   void defer_command(utils::movable_function<void(std::error_code)> command);
+  void for_each_session(utils::movable_function<void(io::mcbp_session&)> handler);
 
   [[nodiscard]] auto name() const -> const std::string&;
   [[nodiscard]] auto log_prefix() const -> const std::string&;
   [[nodiscard]] auto tracer() const -> std::shared_ptr<tracing::tracer_wrapper>;
   [[nodiscard]] auto meter() const -> std::shared_ptr<metrics::meter_wrapper>;
+  [[nodiscard]] auto orphan_reporter() const -> std::shared_ptr<orphan_reporter>;
   [[nodiscard]] auto app_telemetry_meter() const -> std::shared_ptr<app_telemetry_meter>;
   [[nodiscard]] auto default_retry_strategy() const -> std::shared_ptr<couchbase::retry_strategy>;
   [[nodiscard]] auto is_closed() const -> bool;