couchbase 4.4.1-dev.1 → 4.4.1

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

@@ -94,7 +94,7 @@ public:
                     std::int16_t node_id,
                     range_scan_create_options create_options,
                     range_scan_continue_options continue_options,
-                    std::shared_ptr<scan_stream_manager> stream_manager)
+                    std::weak_ptr<scan_stream_manager> stream_manager)
     : agent_{ std::move(kv_provider) }
     , io_{ io }
     , vbucket_id_{ vbucket_id }
@@ -116,8 +116,10 @@ public:
           "stream for vbucket_id {} cannot be retried because it has exceeded the timeout",
           vbucket_id_);
         state_ = failed{ errc::common::unambiguous_timeout, !is_sampling_scan() };
-        stream_manager_->stream_failed(
-          node_id_, vbucket_id_, errc::common::unambiguous_timeout, error_is_fatal());
+        if (auto mgr = stream_manager_.lock(); mgr != nullptr) {
+          mgr->stream_failed(
+            node_id_, vbucket_id_, errc::common::unambiguous_timeout, error_is_fatal());
+        }
         return;
       }
     } else {
@@ -138,22 +140,25 @@ public:
             CB_LOG_TRACE("ignoring vbucket_id {} because no documents exist for it",
                          self->vbucket_id_);
             self->state_ = failed{ ec, false };
-            self->stream_manager_->stream_failed(
-              self->node_id_, self->vbucket_id_, ec, self->error_is_fatal());
+            if (auto mgr = self->stream_manager_.lock(); mgr != nullptr) {
+              mgr->stream_failed(self->node_id_, self->vbucket_id_, ec, self->error_is_fatal());
+            }
           } else if (ec == errc::common::temporary_failure) {
             // Retryable error - server is overwhelmed, retry after reducing concurrency
             CB_LOG_DEBUG("received busy status during scan from vbucket with ID {} - reducing "
                          "concurrency & retrying",
                          self->vbucket_id_);
             self->state_ = std::monostate{};
-            self->stream_manager_->stream_start_failed_awaiting_retry(self->node_id_,
-                                                                      self->vbucket_id_);
+            if (auto mgr = self->stream_manager_.lock(); mgr != nullptr) {
+              mgr->stream_start_failed_awaiting_retry(self->node_id_, self->vbucket_id_);
+            }
           } else if (ec == errc::common::internal_server_failure ||
                      ec == errc::common::collection_not_found) {
             // Fatal errors
             self->state_ = failed{ ec, true };
-            self->stream_manager_->stream_failed(
-              self->node_id_, self->vbucket_id_, ec, self->error_is_fatal());
+            if (auto mgr = self->stream_manager_.lock(); mgr != nullptr) {
+              mgr->stream_failed(self->node_id_, self->vbucket_id_, ec, self->error_is_fatal());
+            }
           } else {
             // Unexpected errors
             CB_LOG_DEBUG("received unexpected error {} from stream for vbucket {} during range "
@@ -162,8 +167,9 @@ public:
                          self->vbucket_id_,
                          ec.message());
             self->state_ = failed{ ec, true };
-            self->stream_manager_->stream_failed(
-              self->node_id_, self->vbucket_id_, ec, self->error_is_fatal());
+            if (auto mgr = self->stream_manager_.lock(); mgr != nullptr) {
+              mgr->stream_failed(self->node_id_, self->vbucket_id_, ec, self->error_is_fatal());
+            }
           }
           return;
         }
@@ -191,7 +197,7 @@ private:
       return;
     }
 
-    bool fatal;
+    bool fatal = false;
     if (ec == errc::key_value::document_not_found || ec == errc::common::authentication_failure ||
         ec == errc::common::collection_not_found || ec == errc::common::request_canceled) {
       // Errors that are fatal unless this is a sampling scan
@@ -211,7 +217,9 @@ private:
     }
 
     state_ = failed{ ec, fatal };
-    stream_manager_->stream_failed(node_id_, vbucket_id_, ec, fatal);
+    if (auto mgr = stream_manager_.lock(); mgr != nullptr) {
+      mgr->stream_failed(node_id_, vbucket_id_, ec, fatal);
+    }
   }
 
   void complete()
@@ -220,7 +228,9 @@ private:
       return;
     }
 
-    stream_manager_->stream_completed(node_id_, vbucket_id_);
+    if (auto mgr = stream_manager_.lock(); mgr != nullptr) {
+      mgr->stream_completed(node_id_, vbucket_id_);
+    }
     state_ = completed{};
   }
 
@@ -275,7 +285,9 @@ private:
             return;
           }
           self->last_seen_key_ = item.key;
-          self->stream_manager_->stream_received_item(std::move(item));
+          if (auto mgr = self->stream_manager_.lock(); mgr != nullptr) {
+            mgr->stream_received_item(std::move(item));
+          }
         },
         [self](auto res, auto ec) {
           if (ec) {
@@ -327,7 +339,7 @@ private:
   std::int16_t node_id_;
   range_scan_create_options create_options_;
   range_scan_continue_options continue_options_;
-  std::shared_ptr<scan_stream_manager> stream_manager_;
+  std::weak_ptr<scan_stream_manager> stream_manager_;
   std::string last_seen_key_{};
   std::variant<std::monostate, failed, running, completed> state_{};
   std::atomic<bool> should_cancel_{ false };
@@ -379,11 +391,11 @@ public:
 
   void scan(scan_callback&& cb)
   {
-    if (item_limit_ == 0 || concurrency_ <= 0) {
+    if (item_limit_ == 0 || concurrency_ == 0) {
       return cb(errc::common::invalid_argument, {});
     }
 
-    get_collection_id_options const get_cid_options{ options_.retry_strategy,
+    const get_collection_id_options get_cid_options{ options_.retry_strategy,
                                                      options_.timeout,
                                                      options_.parent_span };
     agent_.get_collection_id(
@@ -398,7 +410,7 @@ public:
 
         auto batch_time_limit =
           std::chrono::duration_cast<std::chrono::milliseconds>(0.9 * self->options_.timeout);
-        range_scan_continue_options const continue_options{
+        const range_scan_continue_options continue_options{
           self->options_.batch_item_limit, self->options_.batch_byte_limit, batch_time_limit,
           self->options_.timeout,          self->options_.retry_strategy,
         };
@@ -428,7 +440,8 @@ public:
           self->streams_[vbucket] = stream;
         }
         self->start_streams(self->concurrency_);
-        return cb({}, scan_result(self));
+        // Transferring ownership of the range_scan_orchestrator impl to the scan_result
+        return cb({}, scan_result(std::move(self)));
       });
   }
 
@@ -440,7 +453,7 @@ public:
     }
   }
 
-  bool is_cancelled() override
+  auto is_cancelled() -> bool override
   {
     return cancelled_;
   }
@@ -460,12 +473,13 @@ public:
 
   void next(utils::movable_function<void(range_scan_item, std::error_code)> callback) override
   {
-    if (item_limit_ == 0 || item_limit_-- == 0) {
+    if (item_limit_ == 0) {
       callback({}, errc::key_value::range_scan_completed);
       cancel();
-    } else {
-      next_item(std::move(callback));
+      return;
     }
+    --item_limit_;
+    next_item(std::move(callback));
   }
 
   template<typename Handler>
@@ -493,7 +507,7 @@ public:
           } else {
             // Empty signal means that stream has completed
             {
-              std::lock_guard<std::mutex> const lock{ self->stream_map_mutex_ };
+              const std::lock_guard<std::mutex> lock{ self->stream_map_mutex_ };
               self->streams_.erase(signal.vbucket_id);
             }
             return asio::post(asio::bind_executor(
@@ -523,7 +537,7 @@ public:
       auto v = vbucket_id.value();
       std::shared_ptr<range_scan_stream> stream{};
       {
-        std::lock_guard<std::mutex> const lock{ stream_map_mutex_ };
+        const std::lock_guard<std::mutex> lock{ stream_map_mutex_ };
         stream = streams_.at(v);
       }
       CB_LOG_TRACE("scanning vbucket {} at node {}", vbucket_id.value(), stream->node_id());
@@ -650,6 +664,9 @@ range_scan_orchestrator::scan() -> tl::expected<scan_result, std::error_code>
 void
 range_scan_orchestrator::scan(couchbase::core::scan_callback&& cb)
 {
-  return impl_->scan(std::move(cb));
+  if (impl_) {
+    return impl_->scan(std::move(cb));
+  }
+  cb(errc::common::request_canceled, {});
 }
 } // namespace couchbase::core

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

@@ -26,7 +26,7 @@
 namespace couchbase::core
 {
 auto
-retry_orchestrator::should_retry(std::shared_ptr<mcbp::queue_request> request,
+retry_orchestrator::should_retry(const std::shared_ptr<mcbp::queue_request>& request,
                                  retry_reason reason) -> retry_action
 {
   if (always_retry(reason)) {

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

@@ -30,7 +30,7 @@ class queue_request;
 class retry_orchestrator
 {
 public:
-  [[nodiscard]] static auto should_retry(std::shared_ptr<mcbp::queue_request> request,
+  [[nodiscard]] static auto should_retry(const std::shared_ptr<mcbp::queue_request>& request,
                                          retry_reason reason) -> retry_action;
 };
 } // namespace couchbase::core

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

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

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

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

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

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

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

package/deps/couchbase-cxx-client/core/tracing/CMakeLists.txt

@@ -9,4 +9,6 @@ target_link_libraries(
           taocpp::json
           fmt::fmt
           spdlog::spdlog)
-target_include_directories(couchbase_tracing PRIVATE ${PROJECT_BINARY_DIR}/generated ${PROJECT_SOURCE_DIR})
+target_include_directories(couchbase_tracing PRIVATE ${PROJECT_BINARY_DIR}/generated
+                                                     ${PROJECT_BINARY_DIR}/generated_$<CONFIG>
+                                                     ${PROJECT_SOURCE_DIR})