couchbase 4.6.1 → 4.7.0-dev.1

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

@@ -83,7 +83,7 @@ public:
   static auto dial(app_telemetry_address address,
                    cluster_options options,
                    asio::io_context& ctx,
-                   asio::ssl::context& tls,
+                   tls_context_provider& tls,
                    std::shared_ptr<connection_state_listener>&& handler)
     -> std::shared_ptr<telemetry_dialer>
   {
@@ -96,7 +96,7 @@ public:
   telemetry_dialer(app_telemetry_address address,
                    cluster_options options,
                    asio::io_context& ctx,
-                   asio::ssl::context& tls,
+                   tls_context_provider& tls,
                    std::shared_ptr<connection_state_listener>&& handler)
     : address_{ std::move(address) }
     , options_{ std::move(options) }
@@ -223,7 +223,7 @@ private:
   app_telemetry_address address_;
   cluster_options options_;
   asio::io_context& ctx_;
-  asio::ssl::context& tls_;
+  tls_context_provider& tls_;
   asio::steady_timer resolve_deadline_;
   asio::steady_timer connect_deadline_;
   asio::ip::tcp::resolver resolver_;
@@ -426,9 +426,17 @@ public:
 private:
   auto build_handshake_message() -> std::vector<std::byte>
   {
-    auto credentials = fmt::format("{}:{}", credentials_.username, credentials_.password);
+    std::string auth{};
+    if (credentials_.uses_jwt()) {
+      auth = fmt::format("Bearer {}", credentials_.jwt_token);
+    } else {
+      auto credentials = fmt::format("{}:{}", credentials_.username, credentials_.password);
+      auth = fmt::format(
+        "Basic {}",
+        base64::encode(gsl::as_bytes(gsl::span{ credentials.data(), credentials.size() })));
+    }
     auto message = fmt::format("GET {} HTTP/1.1\r\n"
-                               "Authorization: Basic {}\r\n"
+                               "Authorization: {}\r\n"
                                "Upgrade: websocket\r\n"
                                "Connection: Upgrade\r\n"
                                "Host: {}:{}\r\n"
@@ -436,10 +444,7 @@ private:
                                "Sec-WebSocket-Key: {}\r\n"
                                "\r\n",
                                address_.path,
-                               base64::encode(gsl::as_bytes(gsl::span{
-                                 credentials.data(),
-                                 credentials.size(),
-                               })),
+                               auth,
                                address_.hostname,
                                address_.service,
                                codec_.session_key());
@@ -671,30 +676,29 @@ class app_telemetry_reporter_impl
 {
 public:
   app_telemetry_reporter_impl(std::shared_ptr<app_telemetry_meter> meter,
-                              cluster_options options,
-                              cluster_credentials credentials,
+                              origin& origin,
                               asio::io_context& ctx,
-                              asio::ssl::context& tls)
+                              tls_context_provider& tls)
     : meter_{ std::move(meter) }
-    , options_{ std::move(options) }
-    , credentials_{ std::move(credentials) }
+    , origin_{ origin }
     , ctx_{ ctx }
     , tls_{ tls }
     , backoff_{ ctx }
     , exponential_backoff_calculator_{
       std::chrono::milliseconds{ 100 },
-      options_.app_telemetry_backoff_interval,
+      origin_.options().app_telemetry_backoff_interval,
       2 /* backoff factor */,
       0.5 /* jitter factor */,
     }
   {
-    if (options_.enable_app_telemetry) {
-      if (!options_.app_telemetry_endpoint.empty()) {
-        auto url = couchbase::core::utils::string_codec::url_parse(options_.app_telemetry_endpoint);
+    if (origin_.options().enable_app_telemetry) {
+      if (!origin_.options().app_telemetry_endpoint.empty()) {
+        auto url =
+          couchbase::core::utils::string_codec::url_parse(origin_.options().app_telemetry_endpoint);
         if (url.host.empty() || url.scheme != "ws") {
           CB_LOG_WARNING(
             "unable to use \"{}\" as a app telemetry endpoint (expected ws:// and hostname)",
-            options_.app_telemetry_endpoint);
+            origin_.options().app_telemetry_endpoint);
           return;
         }
         addresses_.push_back({
@@ -743,19 +747,19 @@ public:
     }
 
     websocket_state_ = connection_state::connected;
-    CB_LOG_WARNING("connected app telemetry endpoint.  {}",
-                   tao::json::to_string(tao::json::value{
-                     { "stream", stream->id() },
-                     { "hostname", address.hostname },
-                   }));
+    CB_LOG_DEBUG("connected app telemetry endpoint.  {}",
+                 tao::json::to_string(tao::json::value{
+                   { "stream", stream->id() },
+                   { "hostname", address.hostname },
+                 }));
     websocket_session_ = websocket_session::start(ctx_,
                                                   address,
-                                                  credentials_,
+                                                  origin_.credentials(),
                                                   std::move(stream),
                                                   meter_,
                                                   shared_from_this(),
-                                                  options_.app_telemetry_ping_interval,
-                                                  options_.app_telemetry_ping_timeout);
+                                                  origin_.options().app_telemetry_ping_interval,
+                                                  origin_.options().app_telemetry_ping_timeout);
     retry_backoff_calculator_ = &no_backoff_calculator_;
     ++next_address_index_;
   }
@@ -813,25 +817,27 @@ public:
           return;
         }
         if (self->websocket_state_ == connection_state::disconnected) {
-          self->dialer_ =
-            telemetry_dialer::dial(next_address, self->options_, self->ctx_, self->tls_, self);
+          self->dialer_ = telemetry_dialer::dial(
+            next_address, self->origin_.options(), self->ctx_, self->tls_, self);
         }
       });
       return;
     }
-    dialer_ = telemetry_dialer::dial(next_address, options_, ctx_, tls_, shared_from_this());
+    dialer_ =
+      telemetry_dialer::dial(next_address, origin_.options(), ctx_, tls_, shared_from_this());
   }
 
   void update_config(topology::configuration&& config)
   {
-    if (!options_.enable_app_telemetry) {
+    if (!origin_.options().enable_app_telemetry) {
       meter_->disable();
       return;
     }
     meter_->update_config(config);
 
-    if (options_.app_telemetry_endpoint.empty()) {
-      addresses_ = get_app_telemetry_addresses(config, options_.enable_tls, options_.network);
+    if (origin_.options().app_telemetry_endpoint.empty()) {
+      addresses_ = get_app_telemetry_addresses(
+        config, origin_.options().enable_tls, origin_.options().network);
       next_address_index_ = 0;
     }
 
@@ -841,17 +847,16 @@ public:
       meter_->enable();
       if (websocket_state_ == connection_state::disconnected) {
         dialer_ = telemetry_dialer::dial(
-          addresses_[next_address_index_], options_, ctx_, tls_, shared_from_this());
+          addresses_[next_address_index_], origin_.options(), ctx_, tls_, shared_from_this());
       }
     }
   }
 
 private:
   std::shared_ptr<app_telemetry_meter> meter_;
-  cluster_options options_;
-  cluster_credentials credentials_;
+  origin& origin_;
   asio::io_context& ctx_;
-  asio::ssl::context& tls_;
+  tls_context_provider& tls_;
   asio::steady_timer backoff_;
   const exponential_backoff_with_jitter exponential_backoff_calculator_;
 
@@ -868,13 +873,10 @@ private:
 };
 
 app_telemetry_reporter::app_telemetry_reporter(std::shared_ptr<app_telemetry_meter> meter,
-                                               const cluster_options& options,
-                                               const cluster_credentials& credentials,
+                                               origin& origin,
                                                asio::io_context& ctx,
-                                               asio::ssl::context& tls)
-  : impl_{
-    std::make_shared<app_telemetry_reporter_impl>(std::move(meter), options, credentials, ctx, tls)
-  }
+                                               tls_context_provider& tls)
+  : impl_{ std::make_shared<app_telemetry_reporter_impl>(std::move(meter), origin, ctx, tls) }
 {
 }
 

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

@@ -15,7 +15,9 @@
 
 #pragma once
 
+#include "cluster.hxx"
 #include "config_listener.hxx"
+#include "tls_context_provider.hxx"
 
 #include <memory>
 
@@ -45,10 +47,9 @@ public:
   auto operator=(const app_telemetry_reporter&) -> app_telemetry_reporter& = delete;
 
   app_telemetry_reporter(std::shared_ptr<app_telemetry_meter> meter,
-                         const cluster_options& options,
-                         const cluster_credentials& credentials,
+                         origin& origin,
                          asio::io_context& ctx,
-                         asio::ssl::context& tls);
+                         tls_context_provider& tls);
   ~app_telemetry_reporter() override;
   void update_config(topology::configuration config) override;
   void stop();

package/deps/couchbase-cxx-client/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

package/deps/couchbase-cxx-client/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;