couchbase 3.5.2 → 3.5.4

data/ext/couchbase/core/row_streamer.cxx

@@ -0,0 +1,239 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024. 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 "row_streamer.hxx"
+
+#include <couchbase/error_codes.hxx>
+
+#include "free_form_http_request.hxx"
+#include "logger/logger.hxx"
+#include "utils/json.hxx"
+#include "utils/json_stream_control.hxx"
+#include "utils/json_streaming_lexer.hxx"
+#include "utils/movable_function.hxx"
+
+#include <asio/experimental/channel_error.hpp>
+#include <asio/experimental/concurrent_channel.hpp>
+#include <asio/io_context.hpp>
+
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <system_error>
+#include <utility>
+#include <variant>
+
+namespace couchbase::core
+{
+struct row_stream_end_signal {
+  std::error_code ec{};
+  std::string metadata{};
+};
+
+class row_streamer_impl : public std::enable_shared_from_this<row_streamer_impl>
+{
+public:
+  static constexpr std::size_t ROW_BUFFER_SIZE{ 100 };
+  static constexpr std::size_t ROW_BUFFER_FEED_THRESHOLD{ ROW_BUFFER_SIZE * 3 / 4 };
+  static constexpr std::uint32_t LEXER_DEPTH{ 4 };
+
+  row_streamer_impl(asio::io_context& io,
+                    http_response_body body,
+                    const std::string& pointer_expression)
+    : io_{ io }
+    , body_{ std::move(body) }
+    , rows_{ io_, ROW_BUFFER_SIZE }
+    , lexer_{ pointer_expression, LEXER_DEPTH }
+  {
+  }
+
+  void start(utils::movable_function<void(std::string, std::error_code)>&& handler)
+  {
+    lexer_.on_metadata_header_complete(
+      [handler = std::move(handler)](auto ec, auto meta_header) mutable {
+        // Trim any whitespace from the end
+        meta_header.erase(meta_header.find_last_not_of(" \t\f\v\n\r") + 1);
+
+        // The metadata header can end with an open `[` (opening bracket for pointer expression
+        // array). If that's the case, close the array and the response object
+        if (meta_header[meta_header.length() - 1] == '[') {
+          meta_header.append("]}");
+        }
+        handler(meta_header, ec);
+      });
+    lexer_.on_row([self = shared_from_this()](std::string&& row) -> utils::json::stream_control {
+      self->rows_.async_send({}, std::move(row), [self](auto ec) {
+        self->buffered_row_count_++;
+        if (ec) {
+          if (ec != asio::experimental::error::channel_closed &&
+              ec != asio::experimental::error::channel_cancelled) {
+            CB_LOG_WARNING(
+              "unexpected error while sending to row channel: {} ({})", ec.value(), ec.message());
+          }
+          return;
+        }
+      });
+      return utils::json::stream_control::next_row;
+    });
+    lexer_.on_complete([self = shared_from_this()](
+                         std::error_code ec, std::size_t /*number_of_rows*/, std::string&& meta) {
+      row_stream_end_signal signal{ ec, std::move(meta) };
+      self->rows_.async_send({}, std::move(signal), [self](auto ec) {
+        if (ec) {
+          if (ec != asio::experimental::error::channel_closed &&
+              ec != asio::experimental::error::channel_cancelled) {
+            CB_LOG_WARNING(
+              "unexpected error while sending to row channel: {} ({})", ec.value(), ec.message());
+          }
+          return;
+        }
+      });
+    });
+    maybe_feed_lexer();
+  }
+
+  void next_row(utils::movable_function<void(std::string, std::error_code)>&& handler)
+  {
+    if (!rows_.is_open()) {
+      handler({}, errc::common::request_canceled);
+      return;
+    }
+    rows_.async_receive(
+      [self = shared_from_this(), handler = std::move(handler)](auto ec, auto row) mutable {
+        self->buffered_row_count_--;
+        if (ec) {
+          if (ec == asio::experimental::error::channel_closed ||
+              ec == asio::experimental::error::channel_cancelled) {
+            return handler({}, errc::common::request_canceled);
+          }
+          return handler({}, ec);
+        }
+        if (std::holds_alternative<row_stream_end_signal>(row)) {
+          auto signal = std::get<row_stream_end_signal>(row);
+          if (!signal.metadata.empty()) {
+            std::lock_guard<std::mutex> const lock{ self->metadata_mutex_ };
+            self->metadata_ = std::move(signal.metadata);
+          }
+          return handler({}, signal.ec);
+        }
+        auto row_content = std::get<std::string>(row);
+        handler(std::move(row_content), {});
+
+        // After receiving a row check if more data needs to be fed into the lexer
+        self->maybe_feed_lexer();
+        return;
+      });
+  }
+
+  void cancel()
+  {
+    body_.cancel();
+    rows_.cancel();
+    rows_.close();
+  }
+
+  auto metadata() -> std::optional<std::string>
+  {
+    std::lock_guard<std::mutex> const lock{ metadata_mutex_ };
+    return metadata_;
+  }
+
+private:
+  void maybe_feed_lexer()
+  {
+    if (feeding_ || received_all_data_ || buffered_row_count_ > ROW_BUFFER_FEED_THRESHOLD) {
+      return;
+    }
+
+    feeding_ = true;
+
+    body_.next([self = shared_from_this()](const auto& data, auto ec) mutable {
+      if (ec) {
+        self->received_all_data_ = true;
+        auto signal = row_stream_end_signal{ ec };
+        return self->rows_.async_send({}, std::move(signal), [self](auto ec) {
+          if (!ec || ec == asio::experimental::error::channel_cancelled ||
+              ec == asio::experimental::error::channel_closed) {
+            return;
+          }
+          CB_LOG_WARNING("unexpected error while sending row stream end signal: {} ({})",
+                         ec.value(),
+                         ec.message());
+        });
+      }
+      if (data.empty()) {
+        self->received_all_data_ = true;
+        return;
+      }
+      {
+        const std::lock_guard<std::mutex> lock{ self->data_feed_mutex_ };
+        self->lexer_.feed(data);
+      }
+
+      self->feeding_ = false;
+
+      return self->maybe_feed_lexer();
+    });
+  }
+
+  asio::io_context& io_;
+  http_response_body body_;
+  asio::experimental::concurrent_channel<void(std::error_code,
+                                              std::variant<std::string, row_stream_end_signal>)>
+    rows_;
+  std::atomic_size_t buffered_row_count_{ 0 };
+  std::atomic_bool received_all_data_{ false };
+  std::atomic_bool feeding_{ false };
+  std::optional<std::string> metadata_header_;
+  std::optional<std::string> metadata_;
+  utils::json::streaming_lexer lexer_;
+  std::mutex data_feed_mutex_{};
+  std::mutex metadata_mutex_{};
+};
+
+row_streamer::row_streamer(asio::io_context& io,
+                           couchbase::core::http_response_body body,
+                           const std::string& pointer_expression)
+  : impl_{ std::make_shared<row_streamer_impl>(io, std::move(body), pointer_expression) }
+{
+}
+
+void
+row_streamer::start(utils::movable_function<void(std::string, std::error_code)>&& handler)
+{
+  impl_->start(std::move(handler));
+}
+
+void
+row_streamer::next_row(utils::movable_function<void(std::string, std::error_code)>&& handler)
+{
+  impl_->next_row(std::move(handler));
+}
+
+void
+row_streamer::cancel()
+{
+  impl_->cancel();
+}
+
+auto
+row_streamer::metadata() -> std::optional<std::string>
+{
+  return impl_->metadata();
+}
+} // namespace couchbase::core

data/ext/couchbase/core/row_streamer.hxx

@@ -0,0 +1,68 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024. 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 "utils/movable_function.hxx"
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <system_error>
+
+namespace asio
+{
+class io_context;
+} // namespace asio
+
+namespace couchbase::core
+{
+class row_streamer_impl;
+class http_response_body;
+
+class row_streamer
+{
+public:
+  row_streamer(asio::io_context& io,
+               http_response_body body,
+               const std::string& pointer_expression);
+
+  /**
+   *  Starts the row stream and returns all the metadata preceding the first row. This typically
+   * includes errors, if available.
+   */
+  void start(utils::movable_function<void(std::string, std::error_code)>&& handler);
+
+  /**
+   * Retrieves the next row
+   */
+  void next_row(utils::movable_function<void(std::string, std::error_code)>&& handler);
+
+  /**
+   * Cancels the row stream & closes the HTTP connection
+   */
+  void cancel();
+
+  /**
+   * If all rows have been streamed, returns the metadata encoded as JSON.
+   */
+  auto metadata() -> std::optional<std::string>;
+
+private:
+  std::shared_ptr<row_streamer_impl> impl_;
+};
+} // namespace couchbase::core

data/ext/couchbase/core/sasl/context.cc

@@ -22,8 +22,8 @@
 namespace couchbase::core::sasl
 {
 
-const std::string&
-Context::get_uuid()
+auto
+Context::get_uuid() -> const std::string&
 {
   if (uuid.empty()) {
     uuid = uuid::to_string(uuid::random());

data/ext/couchbase/core/sasl/mechanism.cc

@@ -18,14 +18,12 @@
 #include "mechanism.h"
 
 #include <algorithm>
-#include <iterator>
-#include <vector>
 
 namespace couchbase::core::sasl
 {
 
-Mechanism
-select_mechanism(const std::vector<std::string>& available_mechanisms)
+auto
+select_mechanism(const std::vector<std::string>& available_mechanisms) -> Mechanism
 {
   // Search what we've got backends for
   const std::vector<std::pair<std::string, Mechanism>> mechs = {
@@ -42,7 +40,7 @@ select_mechanism(const std::vector<std::string>& available_mechanisms)
     }
   }
 
-  throw unknown_mechanism("unknown mechanism"); // TODO: avoid this exception
+  throw unknown_mechanism("unknown mechanism"); // TODO(SA): avoid this exception
 }
 
 } // namespace couchbase::core::sasl

data/ext/couchbase/core/sasl/mechanism.h

@@ -48,10 +48,7 @@ public:
  * @throws unknown_mechanism if no supported mechanism is listed in the
  *                           available mechanisms
  */
-Mechanism
-select_mechanism(const std::vector<std::string>& available_mechanisms);
+auto
+select_mechanism(const std::vector<std::string>& available_mechanisms) -> Mechanism;
 
 } // namespace couchbase::core::sasl
-
-std::string
-to_string(couchbase::core::sasl::Mechanism mechanism);

data/ext/couchbase/core/sasl/plain/plain.cc

@@ -21,8 +21,8 @@
 namespace couchbase::core::sasl::mechanism::plain
 {
 
-std::pair<error, std::string_view>
-ClientBackend::start()
+auto
+ClientBackend::start() -> std::pair<error, std::string_view>
 {
   auto usernm = usernameCallback();
   auto passwd = passwordCallback();

data/ext/couchbase/core/sasl/scram-sha/scram-sha.cc

@@ -36,6 +36,8 @@ namespace couchbase::core::sasl::mechanism::scram
 
 using AttributeMap = std::map<char, std::string>;
 
+namespace
+{
 /**
  * Decode the attribute list into a set. The attribute list looks like:
  * "k=value,y=value" etc
@@ -44,8 +46,8 @@ using AttributeMap = std::map<char, std::string>;
  * @param attributes where to store the attributes
  * @return true if success, false otherwise
  */
-static bool
-decodeAttributeList(const std::string& list, AttributeMap& attributes)
+auto
+decodeAttributeList(const std::string& list, AttributeMap& attributes) -> bool
 {
   size_t pos = 0;
 
@@ -85,12 +87,13 @@ decodeAttributeList(const std::string& list, AttributeMap& attributes)
 
   return true;
 }
+} // namespace
 
 /********************************************************************
  * Common API
  *******************************************************************/
-std::string
-ScramShaBackend::getAuthMessage()
+auto
+ScramShaBackend::getAuthMessage() -> std::string
 {
   if (client_first_message_bare.empty()) {
     throw std::logic_error("can't call getAuthMessage without client_first_message_bare is set");
@@ -168,8 +171,6 @@ ScramShaBackend::addAttribute(std::ostream& out, char key, int value, bool more)
 {
   out << key << '=';
 
-  std::string base64_encoded;
-
   switch (key) {
     case 'n': // username ..
     case 'r': // client nonce.. printable characters
@@ -201,8 +202,8 @@ ScramShaBackend::addAttribute(std::ostream& out, char key, int value, bool more)
  * ServerKey       := HMAC(SaltedPassword, "Server Key")
  * ServerSignature := HMAC(ServerKey, AuthMessage)
  */
-std::string
-ScramShaBackend::getServerSignature()
+auto
+ScramShaBackend::getServerSignature() -> std::string
 {
   auto serverKey = couchbase::core::crypto::CBC_HMAC(algorithm, getSaltedPassword(), "Server Key");
 
@@ -221,12 +222,12 @@ ScramShaBackend::getServerSignature()
  * ClientSignature := HMAC(StoredKey, AuthMessage)
  * ClientProof     := ClientKey XOR ClientSignature
  */
-std::string
-ScramShaBackend::getClientProof()
+auto
+ScramShaBackend::getClientProof() -> std::string
 {
   auto clientKey = couchbase::core::crypto::CBC_HMAC(algorithm, getSaltedPassword(), "Client Key");
   auto storedKey = couchbase::core::crypto::digest(algorithm, clientKey);
-  std::string authMessage = getAuthMessage();
+  const std::string authMessage = getAuthMessage();
   auto clientSignature = couchbase::core::crypto::CBC_HMAC(algorithm, storedKey, authMessage);
 
   // Client Proof is ClientKey XOR ClientSignature
@@ -238,7 +239,7 @@ ScramShaBackend::getClientProof()
 
   auto total = proof.size();
   for (std::size_t ii = 0; ii < total; ++ii) {
-    proof[ii] = ck[ii] ^ cs[ii];
+    proof[ii] = static_cast<char>(ck[ii] ^ cs[ii]);
   }
 
   return proof;
@@ -252,10 +253,10 @@ ClientBackend::ClientBackend(GetUsernameCallback& user_cb,
   : MechanismBackend(user_cb, password_cb, ctx)
   , ScramShaBackend(mech, algo)
 {
-  couchbase::core::RandomGenerator randomGenerator;
+  const couchbase::core::RandomGenerator randomGenerator;
 
   std::array<char, 8> nonce{};
-  if (!randomGenerator.getBytes(nonce.data(), nonce.size())) {
+  if (!couchbase::core::RandomGenerator::getBytes(nonce.data(), nonce.size())) {
     CB_LOG_ERROR_RAW("failed to generate server nonce");
     throw std::bad_alloc();
   }
@@ -263,8 +264,8 @@ ClientBackend::ClientBackend(GetUsernameCallback& user_cb,
   clientNonce = couchbase::core::to_hex({ nonce.data(), nonce.size() });
 }
 
-std::pair<error, std::string_view>
-ClientBackend::start()
+auto
+ClientBackend::start() -> std::pair<error, std::string_view>
 {
   std::stringstream out;
   out << "n,,";
@@ -277,8 +278,8 @@ ClientBackend::start()
   return { error::OK, client_first_message };
 }
 
-std::pair<error, std::string_view>
-ClientBackend::step(std::string_view input)
+auto
+ClientBackend::step(std::string_view input) -> std::pair<error, std::string_view>
 {
   if (input.empty()) {
     return { error::BAD_PARAM, {} };
@@ -365,8 +366,8 @@ ClientBackend::step(std::string_view input)
   return { error::OK, {} };
 }
 
-bool
-ClientBackend::generateSaltedPassword(const std::string& secret)
+auto
+ClientBackend::generateSaltedPassword(const std::string& secret) -> bool
 {
   try {
     saltedPassword = couchbase::core::crypto::PBKDF2_HMAC(algorithm, secret, salt, iterationCount);

data/ext/couchbase/core/sasl/scram-sha/stringutils.cc

@@ -43,8 +43,8 @@ namespace couchbase::core::sasl::mechanism::scram
  *         [StringPrep, C.8]
  *       - Tagging characters [StringPrep, C.9]
  */
-const std::string&
-sasl_prep(const std::string& string)
+auto
+sasl_prep(const std::string& string) -> std::string
 {
   for (const auto& c : string) {
     if ((static_cast<unsigned int>(c) & 0x80U) != 0) {
@@ -61,8 +61,8 @@ sasl_prep(const std::string& string)
   return string;
 }
 
-std::string
-encode_username(const std::string& username)
+auto
+encode_username(const std::string& username) -> std::string
 {
   std::string ret(username);
 

data/ext/couchbase/core/sasl/scram-sha/stringutils.h

@@ -32,8 +32,8 @@ namespace couchbase::core::sasl::mechanism::scram
  * @return a sasl_prep'd string
  * @throws std::runtime_error if we encounter a multibyte character
  */
-const std::string&
-sasl_prep(const std::string& string);
+auto
+sasl_prep(const std::string& string) -> std::string;
 
 /**
  * According to https://www.ietf.org/rfc/rfc5802.txt all occurrences
@@ -42,7 +42,7 @@ sasl_prep(const std::string& string);
  * @param username the username to encode
  * @return the escaped string
  */
-std::string
-encode_username(const std::string& username);
+auto
+encode_username(const std::string& username) -> std::string;
 
 } // namespace couchbase::core::sasl::mechanism::scram

data/ext/couchbase/core/scan_result.cxx

@@ -62,7 +62,7 @@ scan_result::scan_result(std::shared_ptr<range_scan_item_iterator> iterator)
 auto
 scan_result::next() const -> tl::expected<range_scan_item, std::error_code>
 {
-  if (impl_) {
+  if (impl_ != nullptr) {
     return impl_->next();
   }
   return tl::unexpected{ errc::common::request_canceled };
@@ -71,7 +71,7 @@ scan_result::next() const -> tl::expected<range_scan_item, std::error_code>
 void
 scan_result::next(utils::movable_function<void(range_scan_item, std::error_code)> callback) const
 {
-  if (impl_) {
+  if (impl_ != nullptr) {
     return impl_->next(std::move(callback));
   }
   callback({}, errc::common::request_canceled);
@@ -80,7 +80,7 @@ scan_result::next(utils::movable_function<void(range_scan_item, std::error_code)
 void
 scan_result::cancel()
 {
-  if (impl_) {
+  if (impl_ != nullptr) {
     return impl_->cancel();
   }
 }
@@ -88,7 +88,7 @@ scan_result::cancel()
 auto
 scan_result::is_cancelled() -> bool
 {
-  if (impl_) {
+  if (impl_ != nullptr) {
     return impl_->is_cancelled();
   }
   return true;

data/ext/couchbase/core/scan_result.hxx

@@ -34,7 +34,7 @@ public:
   virtual auto next() -> std::future<tl::expected<range_scan_item, std::error_code>> = 0;
   virtual void next(utils::movable_function<void(range_scan_item, std::error_code)> callback) = 0;
   virtual void cancel() = 0;
-  virtual bool is_cancelled() = 0;
+  virtual auto is_cancelled() -> bool = 0;
 };
 
 class scan_result

data/ext/couchbase/core/timeout_defaults.hxx

@@ -22,6 +22,7 @@
 namespace couchbase::core::timeout_defaults
 {
 constexpr std::chrono::milliseconds bootstrap_timeout{ 10'000 };
+constexpr std::chrono::milliseconds dispatch_timeout{ 30'000 };
 
 constexpr std::chrono::milliseconds resolve_timeout{ 2'000 };
 constexpr std::chrono::milliseconds connect_timeout{ 2'000 };

data/ext/couchbase/core/topology/collections_manifest.hxx

@@ -26,20 +26,20 @@ namespace couchbase::core::topology
 {
 struct collections_manifest {
   struct collection {
-    std::uint64_t uid;
+    std::uint64_t uid{};
     std::string name;
     std::int32_t max_expiry{ 0 };
     std::optional<bool> history{};
   };
 
   struct scope {
-    std::uint64_t uid;
+    std::uint64_t uid{};
     std::string name;
     std::vector<collection> collections;
   };
 
   uuid::uuid_t id;
-  std::uint64_t uid;
+  std::uint64_t uid{};
   std::vector<scope> scopes;
 };
 } // namespace couchbase::core::topology

data/ext/couchbase/core/topology/configuration.hxx

@@ -100,6 +100,8 @@ struct configuration {
   std::optional<std::uint64_t> collections_manifest_uid{};
   configuration_capabilities capabilities{};
   node_locator_type node_locator{ node_locator_type::unknown };
+  std::optional<std::string> cluster_name{};
+  std::optional<std::string> cluster_uuid{};
   bool force{ false };
 
   auto operator==(const configuration& other) const -> bool

data/ext/couchbase/core/topology/configuration_json.hxx

@@ -111,8 +111,8 @@ struct traits<couchbase::core::topology::configuration> {
         const auto* m = v.find("vBucketServerMap");
         const auto& nodes = v.at("nodes").get_array();
         if (m != nullptr) {
-          size_t index = 0;
           if (const auto* s = m->find("serverList"); s != nullptr && s->is_array()) {
+            std::size_t index = 0;
             for (const auto& j : s->get_array()) {
               couchbase::core::topology::configuration::node n;
               n.index = index++;
@@ -155,7 +155,7 @@ struct traits<couchbase::core::topology::configuration> {
           }
         }
       } else {
-        size_t index = 0;
+        std::size_t index = 0;
         for (const auto& node : v.at("nodes").get_array()) {
           couchbase::core::topology::configuration::node n;
           n.index = index++;
@@ -319,6 +319,14 @@ struct traits<couchbase::core::topology::configuration> {
         }
       }
     }
+
+    if (const auto n = v.find("clusterName"); n != nullptr) {
+      result.cluster_name = n->get_string();
+    }
+    if (const auto u = v.find("clusterUUID"); u != nullptr) {
+      result.cluster_uuid = u->get_string();
+    }
+
     return result;
   }
 };

data/ext/couchbase/core/tracing/constants.hxx

@@ -78,6 +78,9 @@ constexpr auto mcbp_internal = "cb.internal";
 namespace attributes
 {
 constexpr auto system = "db.system";
+constexpr auto cluster_name = "db.couchbase.cluster_name";
+constexpr auto cluster_uuid = "db.couchbase.cluster_uuid";
+
 constexpr auto span_kind = "span.kind";
 constexpr auto component = "db.couchbase.component";
 constexpr auto instance = "db.instance";