couchbase 4.2.11-rc.1 → 4.3.0

package/deps/couchbase-cxx-client/core/operations/document_lookup_in_any_replica.hxx

@@ -62,123 +62,131 @@ struct lookup_in_any_replica_request {
     template<typename Core, typename Handler>
     void execute(Core core, Handler handler)
     {
-        core->with_bucket_configuration(
-          id.bucket(),
-          [core, id = id, timeout = timeout, specs = specs, parent_span = parent_span, h = std::forward<Handler>(handler)](
-            std::error_code ec, const topology::configuration& config) mutable {
-              if (!config.capabilities.supports_subdoc_read_replica()) {
-                  ec = errc::common::feature_not_available;
-              }
-              if (specs.size() > 16) {
-                  ec = errc::common::invalid_argument;
-              }
+        core->open_bucket(id.bucket(),
+                          [core, id = id, timeout = timeout, specs = specs, parent_span = parent_span, h = std::forward<Handler>(handler)](
+                            std::error_code ec) mutable {
+                              if (ec) {
+                                  std::optional<std::string> first_error_path{};
+                                  std::optional<std::size_t> first_error_index{};
+                                  h(response_type{ make_subdocument_error_context(
+                                    make_key_value_error_context(ec, id), ec, first_error_path, first_error_index, false) });
+                                  return;
+                              }
+                              return core->with_bucket_configuration(
+                                id.bucket(),
+                                [core, id = id, timeout = timeout, specs = specs, parent_span = parent_span, h = std::forward<Handler>(h)](
+                                  std::error_code ec, const topology::configuration& config) mutable {
+                                    if (!config.capabilities.supports_subdoc_read_replica()) {
+                                        ec = errc::common::feature_not_available;
+                                    }
 
-              if (ec) {
-                  std::optional<std::string> first_error_path{};
-                  std::optional<std::size_t> first_error_index{};
-                  return h(response_type{
-                    make_subdocument_error_context(make_key_value_error_context(ec, id), ec, first_error_path, first_error_index, false) });
-              }
-              using handler_type = utils::movable_function<void(response_type)>;
+                                    if (ec) {
+                                        std::optional<std::string> first_error_path{};
+                                        std::optional<std::size_t> first_error_index{};
+                                        return h(response_type{ make_subdocument_error_context(
+                                          make_key_value_error_context(ec, id), ec, first_error_path, first_error_index, false) });
+                                    }
+                                    using handler_type = utils::movable_function<void(response_type)>;
 
-              struct replica_context {
-                  replica_context(handler_type&& handler, std::uint32_t expected_responses)
-                    : handler_(std::move(handler))
-                    , expected_responses_(expected_responses)
-                  {
-                  }
+                                    struct replica_context {
+                                        replica_context(handler_type&& handler, std::uint32_t expected_responses)
+                                          : handler_(std::move(handler))
+                                          , expected_responses_(expected_responses)
+                                        {
+                                        }
 
-                  handler_type handler_;
-                  std::uint32_t expected_responses_;
-                  bool done_{ false };
-                  std::mutex mutex_{};
-              };
-              auto ctx = std::make_shared<replica_context>(std::move(h), config.num_replicas.value_or(0U) + 1U);
+                                        handler_type handler_;
+                                        std::uint32_t expected_responses_;
+                                        bool done_{ false };
+                                        std::mutex mutex_{};
+                                    };
+                                    auto ctx = std::make_shared<replica_context>(std::move(h), config.num_replicas.value_or(0U) + 1U);
 
-              for (std::size_t idx = 1U; idx <= config.num_replicas.value_or(0U); ++idx) {
-                  document_id replica_id{ id };
-                  replica_id.node_index(idx);
-                  core->execute(impl::lookup_in_replica_request{ std::move(replica_id), specs, timeout, parent_span },
-                                [ctx](impl::lookup_in_replica_response&& resp) {
-                                    handler_type local_handler;
-                                    {
-                                        std::scoped_lock lock(ctx->mutex_);
-                                        if (ctx->done_) {
-                                            return;
-                                        }
-                                        --ctx->expected_responses_;
-                                        if (resp.ctx.ec()) {
-                                            if (ctx->expected_responses_ > 0) {
-                                                // just ignore the response
+                                    for (std::size_t idx = 1U; idx <= config.num_replicas.value_or(0U); ++idx) {
+                                        document_id replica_id{ id };
+                                        replica_id.node_index(idx);
+                                        core->execute(impl::lookup_in_replica_request{ std::move(replica_id), specs, timeout, parent_span },
+                                                      [ctx](impl::lookup_in_replica_response&& resp) {
+                                                          handler_type local_handler;
+                                                          {
+                                                              std::scoped_lock lock(ctx->mutex_);
+                                                              if (ctx->done_) {
+                                                                  return;
+                                                              }
+                                                              --ctx->expected_responses_;
+                                                              if (resp.ctx.ec()) {
+                                                                  if (ctx->expected_responses_ > 0) {
+                                                                      // just ignore the response
+                                                                      return;
+                                                                  }
+                                                                  // consider document irretrievable and give up
+                                                                  resp.ctx.override_ec(errc::key_value::document_irretrievable);
+                                                              }
+                                                              ctx->done_ = true;
+                                                              std::swap(local_handler, ctx->handler_);
+                                                          }
+                                                          if (local_handler) {
+                                                              response_type res{};
+                                                              res.ctx = resp.ctx;
+                                                              res.cas = resp.cas;
+                                                              res.deleted = resp.deleted;
+                                                              res.is_replica = true;
+                                                              for (auto& field : resp.fields) {
+                                                                  auto lookup_in_entry = lookup_in_any_replica_response::entry{};
+                                                                  lookup_in_entry.path = field.path;
+                                                                  lookup_in_entry.value = field.value;
+                                                                  lookup_in_entry.status = field.status;
+                                                                  lookup_in_entry.ec = field.ec;
+                                                                  lookup_in_entry.exists = field.exists;
+                                                                  lookup_in_entry.original_index = field.original_index;
+                                                                  lookup_in_entry.opcode = field.opcode;
+                                                                  res.fields.emplace_back(lookup_in_entry);
+                                                              }
+                                                              return local_handler(res);
+                                                          }
+                                                      });
+                                    }
+                                    core->execute(lookup_in_request{ id, {}, {}, false, specs, timeout }, [ctx](lookup_in_response&& resp) {
+                                        handler_type local_handler{};
+                                        {
+                                            std::scoped_lock lock(ctx->mutex_);
+                                            if (ctx->done_) {
                                                 return;
                                             }
-                                            // consider document irretrievable and give up
-                                            resp.ctx.override_ec(errc::key_value::document_irretrievable);
+                                            --ctx->expected_responses_;
+                                            if (resp.ctx.ec()) {
+                                                if (ctx->expected_responses_ > 0) {
+                                                    // just ignore the response
+                                                    return;
+                                                }
+                                                // consider document irretrievable and give up
+                                                resp.ctx.override_ec(errc::key_value::document_irretrievable);
+                                            }
+                                            ctx->done_ = true;
+                                            std::swap(local_handler, ctx->handler_);
                                         }
-                                        ctx->done_ = true;
-                                        std::swap(local_handler, ctx->handler_);
-                                    }
-                                    if (local_handler) {
-                                        response_type res{};
-                                        res.ctx = resp.ctx;
-                                        res.cas = resp.cas;
-                                        res.deleted = resp.deleted;
-                                        res.is_replica = true;
-                                        for (auto& field : resp.fields) {
-                                            auto lookup_in_entry = lookup_in_any_replica_response::entry{};
-                                            lookup_in_entry.path = field.path;
-                                            lookup_in_entry.value = field.value;
-                                            lookup_in_entry.status = field.status;
-                                            lookup_in_entry.ec = field.ec;
-                                            lookup_in_entry.exists = field.exists;
-                                            lookup_in_entry.original_index = field.original_index;
-                                            lookup_in_entry.opcode = field.opcode;
-                                            res.fields.emplace_back(lookup_in_entry);
+                                        if (local_handler) {
+                                            auto res = response_type{};
+                                            res.ctx = resp.ctx;
+                                            res.cas = resp.cas;
+                                            res.deleted = resp.deleted;
+                                            res.is_replica = false;
+                                            for (auto& field : resp.fields) {
+                                                auto lookup_in_entry = lookup_in_any_replica_response::entry{};
+                                                lookup_in_entry.path = field.path;
+                                                lookup_in_entry.value = field.value;
+                                                lookup_in_entry.status = field.status;
+                                                lookup_in_entry.ec = field.ec;
+                                                lookup_in_entry.exists = field.exists;
+                                                lookup_in_entry.original_index = field.original_index;
+                                                lookup_in_entry.opcode = field.opcode;
+                                                res.fields.emplace_back(lookup_in_entry);
+                                            }
+                                            return local_handler(res);
                                         }
-                                        return local_handler(res);
-                                    }
+                                    });
                                 });
-              }
-              core->execute(lookup_in_request{ id, {}, {}, false, specs, timeout }, [ctx](lookup_in_response&& resp) {
-                  handler_type local_handler{};
-                  {
-                      std::scoped_lock lock(ctx->mutex_);
-                      if (ctx->done_) {
-                          return;
-                      }
-                      --ctx->expected_responses_;
-                      if (resp.ctx.ec()) {
-                          if (ctx->expected_responses_ > 0) {
-                              // just ignore the response
-                              return;
-                          }
-                          // consider document irretrievable and give up
-                          resp.ctx.override_ec(errc::key_value::document_irretrievable);
-                      }
-                      ctx->done_ = true;
-                      std::swap(local_handler, ctx->handler_);
-                  }
-                  if (local_handler) {
-                      auto res = response_type{};
-                      res.ctx = resp.ctx;
-                      res.cas = resp.cas;
-                      res.deleted = resp.deleted;
-                      res.is_replica = false;
-                      for (auto& field : resp.fields) {
-                          auto lookup_in_entry = lookup_in_any_replica_response::entry{};
-                          lookup_in_entry.path = field.path;
-                          lookup_in_entry.value = field.value;
-                          lookup_in_entry.status = field.status;
-                          lookup_in_entry.ec = field.ec;
-                          lookup_in_entry.exists = field.exists;
-                          lookup_in_entry.original_index = field.original_index;
-                          lookup_in_entry.opcode = field.opcode;
-                          res.fields.emplace_back(lookup_in_entry);
-                      }
-                      return local_handler(res);
-                  }
-              });
-          });
+                          });
     }
 };
 

package/deps/couchbase-cxx-client/core/operations/document_search.cxx

@@ -133,10 +133,10 @@ search_request::encode_to(search_request::encoded_request_type& encoded, http_co
     encoded.method = "POST";
     body_str = utils::json::generate(body);
     encoded.body = body_str;
-    if (context.options.show_queries) {
-        CB_LOG_INFO("SEARCH: {}", utils::json::generate(body["query"]));
+    if (context.options.show_queries || (log_request.has_value() && log_request.value())) {
+        CB_LOG_INFO("SEARCH: {}", utils::json::generate(body));
     } else {
-        CB_LOG_DEBUG("SEARCH: {}", utils::json::generate(body["query"]));
+        CB_LOG_DEBUG("SEARCH: {}", utils::json::generate(body));
     }
     if (row_callback) {
         encoded.streaming.emplace(couchbase::core::io::streaming_settings{
@@ -165,6 +165,9 @@ search_request::make_response(error_context::search&& ctx, const encoded_respons
                 response.ctx.ec = errc::common::parsing_failure;
                 return response;
             }
+            if (log_response.has_value() && log_response.value()) {
+                CB_LOG_INFO("SEARCH RESPONSE: {}", utils::json::generate(payload));
+            }
             response.meta.metrics.took = std::chrono::nanoseconds(payload.at("took").get_unsigned());
             response.meta.metrics.max_score = payload.at("max_score").as<double>();
             response.meta.metrics.total_rows = payload.at("total_hits").get_unsigned();
@@ -187,106 +190,119 @@ search_request::make_response(error_context::search&& ctx, const encoded_respons
                 return response;
             }
 
-            if (const auto* rows = payload.find("hits"); rows != nullptr && rows->is_array()) {
-                for (const auto& entry : rows->get_array()) {
-                    search_response::search_row row{};
-                    row.index = entry.at("index").get_string();
-                    row.id = entry.at("id").get_string();
-                    row.score = entry.at("score").as<double>();
-                    if (const auto* locations_map = entry.find("locations"); locations_map != nullptr && locations_map->is_object()) {
-                        for (const auto& [field, terms] : locations_map->get_object()) {
-                            for (const auto& [term, locations] : terms.get_object()) {
-                                for (const auto& loc : locations.get_array()) {
-                                    search_response::search_location location{};
-                                    location.field = field;
-                                    location.term = term;
-                                    location.position = loc.at("pos").get_unsigned();
-                                    location.start_offset = loc.at("start").get_unsigned();
-                                    location.end_offset = loc.at("end").get_unsigned();
-                                    if (const auto* array_positions = loc.find("array_positions");
-                                        array_positions != nullptr && array_positions->is_array()) {
-                                        location.array_positions.emplace(array_positions->as<std::vector<std::uint64_t>>());
+            try {
+                if (const auto* rows = payload.find("hits"); rows != nullptr && rows->is_array()) {
+                    for (const auto& entry : rows->get_array()) {
+                        search_response::search_row row{};
+                        row.index = entry.optional<std::string>("index").value_or(std::string());
+                        row.id = entry.optional<std::string>("id").value_or(std::string());
+                        row.score = entry.optional<double>("score").value_or(0);
+                        if (const auto* locations_map = entry.find("locations"); locations_map != nullptr && locations_map->is_object()) {
+                            for (const auto& [field, terms] : locations_map->get_object()) {
+                                for (const auto& [term, locations] : terms.get_object()) {
+                                    for (const auto& loc : locations.get_array()) {
+                                        search_response::search_location location{};
+                                        location.field = field;
+                                        location.term = term;
+                                        location.position = loc.at("pos").get_unsigned();
+                                        location.start_offset = loc.at("start").get_unsigned();
+                                        location.end_offset = loc.at("end").get_unsigned();
+                                        if (const auto* array_positions = loc.find("array_positions");
+                                            array_positions != nullptr && array_positions->is_array()) {
+                                            location.array_positions.emplace(array_positions->as<std::vector<std::uint64_t>>());
+                                        }
+                                        row.locations.emplace_back(location);
                                     }
-                                    row.locations.emplace_back(location);
                                 }
                             }
                         }
-                    }
 
-                    if (const auto* fragments_map = entry.find("fragments"); fragments_map != nullptr && fragments_map->is_object()) {
-                        for (const auto& [field, fragments] : fragments_map->get_object()) {
-                            row.fragments.try_emplace(field, fragments.as<std::vector<std::string>>());
+                        if (const auto* fragments_map = entry.find("fragments"); fragments_map != nullptr && fragments_map->is_object()) {
+                            for (const auto& [field, fragments] : fragments_map->get_object()) {
+                                row.fragments.try_emplace(field, fragments.as<std::vector<std::string>>());
+                            }
                         }
+                        if (const auto* response_fields = entry.find("fields");
+                            response_fields != nullptr && response_fields->is_object()) {
+                            row.fields = utils::json::generate(*response_fields);
+                        }
+                        if (const auto* explanation = entry.find("explanation"); explanation != nullptr && explanation->is_object()) {
+                            row.explanation = utils::json::generate(*explanation);
+                        }
+                        response.rows.emplace_back(row);
                     }
-                    if (const auto* response_fields = entry.find("fields"); response_fields != nullptr && response_fields->is_object()) {
-                        row.fields = utils::json::generate(*response_fields);
-                    }
-                    if (const auto* explanation = entry.find("explanation"); explanation != nullptr && explanation->is_object()) {
-                        row.explanation = utils::json::generate(*explanation);
-                    }
-                    response.rows.emplace_back(row);
                 }
+            } catch (const std::out_of_range& e) {
+                CB_LOG_ERROR("Error parsing search results. Error: {}.", e.what());
+                response.ctx.ec = errc::common::parsing_failure;
+                return response;
             }
 
-            if (const auto* response_facets = payload.find("facets"); response_facets != nullptr && response_facets->is_object()) {
-                for (const auto& [name, object] : response_facets->get_object()) {
-                    search_response::search_facet facet;
-                    facet.name = name;
-                    facet.field = object.at("field").get_string();
-                    facet.total = object.at("total").get_unsigned();
-                    facet.missing = object.at("missing").get_unsigned();
-                    facet.other = object.at("other").get_unsigned();
+            try {
+                if (const auto* response_facets = payload.find("facets"); response_facets != nullptr && response_facets->is_object()) {
+                    for (const auto& [name, object] : response_facets->get_object()) {
+                        search_response::search_facet facet;
+                        facet.name = name;
+                        facet.field = object.at("field").get_string();
+                        facet.total = object.at("total").get_unsigned();
+                        facet.missing = object.at("missing").get_unsigned();
+                        facet.other = object.at("other").get_unsigned();
 
-                    if (const auto* date_ranges = object.find("date_ranges"); date_ranges != nullptr && date_ranges->is_array()) {
-                        for (const auto& date_range : date_ranges->get_array()) {
-                            search_response::search_facet::date_range_facet date_range_facet;
-                            date_range_facet.name = date_range.at("name").get_string();
-                            date_range_facet.count = date_range.at("count").get_unsigned();
-                            if (const auto* start = date_range.find("start"); start != nullptr && start->is_string()) {
-                                date_range_facet.start = start->get_string();
-                            }
-                            if (const auto* end = date_range.find("end"); end != nullptr && end->is_string()) {
-                                date_range_facet.end = end->get_string();
+                        if (const auto* date_ranges = object.find("date_ranges"); date_ranges != nullptr && date_ranges->is_array()) {
+                            for (const auto& date_range : date_ranges->get_array()) {
+                                search_response::search_facet::date_range_facet date_range_facet;
+                                date_range_facet.name = date_range.at("name").get_string();
+                                date_range_facet.count = date_range.at("count").get_unsigned();
+                                if (const auto* start = date_range.find("start"); start != nullptr && start->is_string()) {
+                                    date_range_facet.start = start->get_string();
+                                }
+                                if (const auto* end = date_range.find("end"); end != nullptr && end->is_string()) {
+                                    date_range_facet.end = end->get_string();
+                                }
+                                facet.date_ranges.emplace_back(date_range_facet);
                             }
-                            facet.date_ranges.emplace_back(date_range_facet);
                         }
-                    }
 
-                    if (const auto& numeric_ranges = object.find("numeric_ranges");
-                        numeric_ranges != nullptr && numeric_ranges->is_array()) {
-                        for (const auto& numeric_range : numeric_ranges->get_array()) {
-                            search_response::search_facet::numeric_range_facet numeric_range_facet;
-                            numeric_range_facet.name = numeric_range.at("name").get_string();
-                            numeric_range_facet.count = numeric_range.at("count").get_unsigned();
-                            if (const auto* min = numeric_range.find("min"); min != nullptr) {
-                                if (min->is_double()) {
-                                    numeric_range_facet.min = min->as<double>();
-                                } else if (min->is_integer()) {
-                                    numeric_range_facet.min = min->get_unsigned();
+                        if (const auto& numeric_ranges = object.find("numeric_ranges");
+                            numeric_ranges != nullptr && numeric_ranges->is_array()) {
+                            for (const auto& numeric_range : numeric_ranges->get_array()) {
+                                search_response::search_facet::numeric_range_facet numeric_range_facet;
+                                numeric_range_facet.name = numeric_range.at("name").get_string();
+                                numeric_range_facet.count = numeric_range.at("count").get_unsigned();
+                                if (const auto* min = numeric_range.find("min"); min != nullptr) {
+                                    if (min->is_double()) {
+                                        numeric_range_facet.min = min->as<double>();
+                                    } else if (min->is_integer()) {
+                                        numeric_range_facet.min = min->get_unsigned();
+                                    }
                                 }
-                            }
-                            if (const auto* max = numeric_range.find("max"); max != nullptr) {
-                                if (max->is_double()) {
-                                    numeric_range_facet.max = max->as<double>();
-                                } else if (max->is_integer()) {
-                                    numeric_range_facet.max = max->get_unsigned();
+                                if (const auto* max = numeric_range.find("max"); max != nullptr) {
+                                    if (max->is_double()) {
+                                        numeric_range_facet.max = max->as<double>();
+                                    } else if (max->is_integer()) {
+                                        numeric_range_facet.max = max->get_unsigned();
+                                    }
                                 }
+                                facet.numeric_ranges.emplace_back(numeric_range_facet);
                             }
-                            facet.numeric_ranges.emplace_back(numeric_range_facet);
                         }
-                    }
 
-                    if (const auto* terms = object.find("terms"); terms != nullptr && terms->is_array()) {
-                        for (const auto& term : terms->get_array()) {
-                            search_response::search_facet::term_facet term_facet;
-                            term_facet.term = term.at("term").get_string();
-                            term_facet.count = term.at("count").get_unsigned();
-                            facet.terms.emplace_back(term_facet);
+                        if (const auto* terms = object.find("terms"); terms != nullptr && terms->is_array()) {
+                            for (const auto& term : terms->get_array()) {
+                                search_response::search_facet::term_facet term_facet;
+                                term_facet.term = term.at("term").get_string();
+                                term_facet.count = term.at("count").get_unsigned();
+                                facet.terms.emplace_back(term_facet);
+                            }
                         }
-                    }
 
-                    response.facets.emplace_back(facet);
+                        response.facets.emplace_back(facet);
+                    }
                 }
+            } catch (const std::out_of_range& e) {
+                CB_LOG_ERROR("Error parsing search facets. Error: {}.", e.what());
+                response.ctx.ec = errc::common::parsing_failure;
+                return response;
             }
             return response;
         }

package/deps/couchbase-cxx-client/core/operations/document_search.hxx

@@ -155,6 +155,11 @@ struct search_request {
     std::optional<std::function<utils::json::stream_control(std::string)>> row_callback{};
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};
+    /**
+     * UNCOMMITTED: If set to true, will log the request to and/or the response from the search service.
+     */
+    std::optional<bool> log_request{ false };
+    std::optional<bool> log_response{ false };
 
     [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& context);
 

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

@@ -0,0 +1,141 @@
+/* -*- 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 "range_scan_load_balancer.hxx"
+
+#include <algorithm>
+#include <limits>
+#include <map>
+#include <numeric>
+#include <queue>
+#include <random>
+#include <vector>
+
+namespace couchbase::core
+{
+range_scan_node_state::range_scan_node_state(std::queue<std::uint16_t> vbuckets)
+  : pending_vbuckets_{ std::move(vbuckets) }
+{
+}
+
+auto
+range_scan_node_state::fetch_vbucket_id() -> std::optional<std::uint16_t>
+{
+    std::lock_guard<std::mutex> const lock{ mutex_ };
+    if (pending_vbuckets_.empty()) {
+        return {};
+    }
+    active_stream_count_++;
+    auto vbucket_id = pending_vbuckets_.front();
+    pending_vbuckets_.pop();
+    return vbucket_id;
+}
+
+void
+range_scan_node_state::notify_stream_ended()
+{
+    std::lock_guard<std::mutex> const lock{ mutex_ };
+    active_stream_count_--;
+}
+
+void
+range_scan_node_state::enqueue_vbucket(std::uint16_t vbucket_id)
+{
+    std::lock_guard<std::mutex> const lock{ mutex_ };
+    pending_vbuckets_.push(vbucket_id);
+}
+
+auto
+range_scan_node_state::active_stream_count() -> std::uint16_t
+{
+    std::lock_guard<std::mutex> const lock{ mutex_ };
+    return active_stream_count_;
+}
+
+auto
+range_scan_node_state::pending_vbucket_count() -> std::size_t
+{
+    std::lock_guard<std::mutex> const lock{ mutex_ };
+    return pending_vbuckets_.size();
+}
+
+range_scan_load_balancer::range_scan_load_balancer(const topology::configuration::vbucket_map& vbucket_map,
+                                                   std::optional<std::uint64_t> seed)
+  : seed_{ seed }
+{
+    std::map<std::int16_t, std::queue<std::uint16_t>> node_to_vbucket_map{};
+    for (std::uint16_t vbucket_id = 0; vbucket_id < vbucket_map.size(); vbucket_id++) {
+        auto node_id = vbucket_map[vbucket_id][0];
+        node_to_vbucket_map[node_id].push(vbucket_id);
+    }
+    for (auto [node_id, vbucket_ids] : node_to_vbucket_map) {
+        nodes_.emplace(node_id, std::move(vbucket_ids));
+    }
+}
+
+void
+range_scan_load_balancer::seed(std::uint64_t seed)
+{
+    seed_ = seed;
+}
+
+auto
+range_scan_load_balancer::select_vbucket() -> std::optional<std::uint16_t>
+{
+    std::lock_guard<std::mutex> const lock{ select_vbucket_mutex_ };
+
+    auto min_stream_count = std::numeric_limits<std::uint16_t>::max();
+    std::optional<std::int16_t> selected_node_id{};
+
+    std::vector<std::map<int16_t, range_scan_node_state>::iterator> iterators{ nodes_.size() };
+
+    std::iota(iterators.begin(), iterators.end(), nodes_.begin());
+    std::mt19937_64 gen{ std::random_device{}() };
+    if (seed_.has_value()) {
+        gen.seed(seed_.value());
+    }
+    std::shuffle(iterators.begin(), iterators.end(), gen);
+
+    for (auto it : iterators) {
+        auto& [node_id, node_status] = *it;
+        auto stream_count = node_status.active_stream_count();
+
+        if (stream_count < min_stream_count && node_status.pending_vbucket_count() > 0) {
+            min_stream_count = stream_count;
+            selected_node_id = node_id;
+        }
+    }
+
+    if (!selected_node_id) {
+        return {};
+    }
+
+    return nodes_.at(selected_node_id.value()).fetch_vbucket_id();
+}
+
+void
+range_scan_load_balancer::notify_stream_ended(std::int16_t node_id)
+{
+    nodes_.at(node_id).notify_stream_ended();
+}
+
+void
+range_scan_load_balancer::enqueue_vbucket(std::int16_t node_id, std::uint16_t vbucket_id)
+{
+    nodes_.at(node_id).enqueue_vbucket(vbucket_id);
+}
+} // namespace couchbase::core