couchbase 3.5.2 → 3.5.3

data/ext/couchbase/core/io/mcbp_session.hxx

@@ -17,6 +17,8 @@
 
 #pragma once
 
+#include <couchbase/build_config.hxx>
+
 #include "core/protocol/hello_feature.hxx"
 #include "core/response_handler.hxx"
 #include "core/utils/movable_function.hxx"
@@ -46,6 +48,13 @@ namespace couchbase::core
 struct origin;
 class config_listener;
 
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+namespace columnar
+{
+class background_bootstrap_listener;
+} // namespace columnar
+#endif
+
 namespace topology
 {
 struct configuration;
@@ -59,6 +68,7 @@ struct endpoint_diag_info;
 
 namespace impl
 {
+struct bootstrap_error;
 class bootstrap_state_listener;
 } // namespace impl
 
@@ -79,14 +89,14 @@ public:
   mcbp_session(mcbp_session&& other) = default;
   auto operator=(mcbp_session&& other) -> mcbp_session& = default;
 
-  mcbp_session(std::string client_id,
+  mcbp_session(const std::string& client_id,
                asio::io_context& ctx,
                couchbase::core::origin origin,
                std::shared_ptr<impl::bootstrap_state_listener> state_listener,
                std::optional<std::string> bucket_name = {},
                std::vector<protocol::hello_feature> known_features = {});
 
-  mcbp_session(std::string client_id,
+  mcbp_session(const std::string& client_id,
                asio::io_context& ctx,
                asio::ssl::context& tls,
                couchbase::core::origin origin,
@@ -111,9 +121,11 @@ public:
   [[nodiscard]] auto bootstrap_hostname() const -> const std::string&;
   [[nodiscard]] auto bootstrap_port() const -> const std::string&;
   [[nodiscard]] auto bootstrap_port_number() const -> std::uint16_t;
+  [[nodiscard]] auto last_bootstrap_error() && -> std::optional<impl::bootstrap_error>;
+  [[nodiscard]] auto last_bootstrap_error() const& -> const std::optional<impl::bootstrap_error>&;
   void write_and_flush(std::vector<std::byte>&& buffer);
-  void write_and_subscribe(std::shared_ptr<mcbp::queue_request>,
-                           std::shared_ptr<response_handler> handler);
+  void write_and_subscribe(const std::shared_ptr<mcbp::queue_request>&,
+                           const std::shared_ptr<response_handler>& handler);
   void write_and_subscribe(std::uint32_t opaque,
                            std::vector<std::byte>&& data,
                            command_handler&& handler);
@@ -126,13 +138,17 @@ public:
   [[nodiscard]] auto config() const -> std::optional<topology::configuration>;
   [[nodiscard]] auto diag_info() const -> diag::endpoint_diag_info;
   void on_configuration_update(std::shared_ptr<config_listener> handler);
-  void ping(std::shared_ptr<diag::ping_reporter> handler,
+  void ping(const std::shared_ptr<diag::ping_reporter>& handler,
             std::optional<std::chrono::milliseconds> = {}) const;
   [[nodiscard]] auto supports_gcccp() const -> bool;
   [[nodiscard]] auto decode_error_code(std::uint16_t code)
     -> std::optional<key_value_error_map_info>;
   void handle_not_my_vbucket(const io::mcbp_message& msg) const;
   void update_collection_uid(const std::string& path, std::uint32_t uid);
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  void add_background_bootstrap_listener(
+    std::shared_ptr<columnar::background_bootstrap_listener> listener);
+#endif
 
 private:
   std::shared_ptr<mcbp_session_impl> impl_{ nullptr };

data/ext/couchbase/core/io/streams.hxx

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include "core/utils/movable_function.hxx"
 #include "ip_protocol.hxx"
 
 #include <asio.hpp>
@@ -44,7 +45,7 @@ async_resolve(ip_protocol protocol,
       return resolver.async_resolve(
         asio::ip::tcp::v6(), hostname, service, std::forward<Handler>(handler));
     case ip_protocol::any:
-      /* fall-through */
+      [[fallthrough]];
     default:
       /* use any protocol */
       break;
@@ -92,20 +93,22 @@ public:
 
   [[nodiscard]] virtual auto local_endpoint() const -> asio::ip::tcp::endpoint = 0;
 
-  virtual void close(std::function<void(std::error_code)>&& handler) = 0;
+  virtual void close(utils::movable_function<void(std::error_code)>&& handler) = 0;
 
   virtual void reopen() = 0;
 
   virtual void set_options() = 0;
 
   virtual void async_connect(const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
-                             std::function<void(std::error_code)>&& handler) = 0;
+                             utils::movable_function<void(std::error_code)>&& handler) = 0;
 
-  virtual void async_write(std::vector<asio::const_buffer>& buffers,
-                           std::function<void(std::error_code, std::size_t)>&& handler) = 0;
+  virtual void async_write(
+    std::vector<asio::const_buffer>& buffers,
+    utils::movable_function<void(std::error_code, std::size_t)>&& handler) = 0;
 
-  virtual void async_read_some(asio::mutable_buffer buffer,
-                               std::function<void(std::error_code, std::size_t)>&& handler) = 0;
+  virtual void async_read_some(
+    asio::mutable_buffer buffer,
+    utils::movable_function<void(std::error_code, std::size_t)>&& handler) = 0;
 };
 
 class plain_stream_impl : public stream_impl
@@ -130,7 +133,7 @@ public:
     return res;
   }
 
-  void close(std::function<void(std::error_code)>&& handler) override
+  void close(utils::movable_function<void(std::error_code)>&& handler) override
   {
     open_ = false;
     return asio::post(strand_, [stream = stream_, h = std::move(handler)]() {
@@ -160,7 +163,7 @@ public:
   }
 
   void async_connect(const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
-                     std::function<void(std::error_code)>&& handler) override
+                     utils::movable_function<void(std::error_code)>&& handler) override
   {
     return stream_->async_connect(endpoint, [this, h = std::move(handler)](std::error_code ec) {
       open_ = stream_->is_open();
@@ -169,13 +172,14 @@ public:
   }
 
   void async_write(std::vector<asio::const_buffer>& buffers,
-                   std::function<void(std::error_code, std::size_t)>&& handler) override
+                   utils::movable_function<void(std::error_code, std::size_t)>&& handler) override
   {
     return asio::async_write(*stream_, buffers, std::move(handler));
   }
 
-  void async_read_some(asio::mutable_buffer buffer,
-                       std::function<void(std::error_code, std::size_t)>&& handler) override
+  void async_read_some(
+    asio::mutable_buffer buffer,
+    utils::movable_function<void(std::error_code, std::size_t)>&& handler) override
   {
     return stream_->async_read_some(buffer, std::move(handler));
   }
@@ -207,7 +211,7 @@ public:
     return res;
   }
 
-  void close(std::function<void(std::error_code)>&& handler) override
+  void close(utils::movable_function<void(std::error_code)>&& handler) override
   {
     open_ = false;
     return asio::post(strand_, [stream = stream_, h = std::move(handler)]() {
@@ -238,10 +242,10 @@ public:
   }
 
   void async_connect(const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
-                     std::function<void(std::error_code)>&& handler) override
+                     utils::movable_function<void(std::error_code)>&& handler) override
   {
     return stream_->lowest_layer().async_connect(
-      endpoint, [this, handler](std::error_code ec_connect) mutable {
+      endpoint, [this, handler = std::move(handler)](std::error_code ec_connect) mutable {
         if (ec_connect == asio::error::operation_aborted) {
           return;
         }
@@ -249,24 +253,26 @@ public:
           return handler(ec_connect);
         }
         open_ = stream_->lowest_layer().is_open();
-        stream_->async_handshake(asio::ssl::stream_base::client,
-                                 [handler](std::error_code ec_handshake) mutable {
-                                   if (ec_handshake == asio::error::operation_aborted) {
-                                     return;
-                                   }
-                                   return handler(ec_handshake);
-                                 });
+        stream_->async_handshake(
+          asio::ssl::stream_base::client,
+          [handler = std::move(handler)](std::error_code ec_handshake) mutable {
+            if (ec_handshake == asio::error::operation_aborted) {
+              return;
+            }
+            return handler(ec_handshake);
+          });
       });
   }
 
   void async_write(std::vector<asio::const_buffer>& buffers,
-                   std::function<void(std::error_code, std::size_t)>&& handler) override
+                   utils::movable_function<void(std::error_code, std::size_t)>&& handler) override
   {
     return asio::async_write(*stream_, buffers, std::move(handler));
   }
 
-  void async_read_some(asio::mutable_buffer buffer,
-                       std::function<void(std::error_code, std::size_t)>&& handler) override
+  void async_read_some(
+    asio::mutable_buffer buffer,
+    utils::movable_function<void(std::error_code, std::size_t)>&& handler) override
   {
     return stream_->async_read_some(buffer, std::move(handler));
   }

data/ext/couchbase/core/logger/logger.cxx

@@ -12,17 +12,28 @@
 #include "logger.hxx"
 
 #include "configuration.hxx"
+#include "core/logger/level.hxx"
 #include "custom_rotating_file_sink.hxx"
 
-#include <chrono>
-#include <mutex>
 #include <spdlog/async.h>
 #include <spdlog/async_logger.h>
+#include <spdlog/common.h>
+#include <spdlog/details/os.h>
+#include <spdlog/logger.h>
 #include <spdlog/sinks/dist_sink.h>
 #include <spdlog/sinks/null_sink.h>
 #include <spdlog/sinks/stdout_color_sinks.h>
 #include <spdlog/spdlog.h>
 
+#include <atomic>
+#include <chrono>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <utility>
+
 static const std::string file_logger_name{ "couchbase_cxx_client_file_logger" };
 static const std::string protocol_logger_name{ "couchbase_cxx_client_protocol_logger" };
 
@@ -53,7 +64,7 @@ get_file_logger() -> std::shared_ptr<spdlog::logger>
   thread_local std::shared_ptr<spdlog::logger> logger{ nullptr };
   thread_local int version{ -1 };
   if (version != file_logger_version) {
-    std::scoped_lock lock(file_logger_mutex);
+    const std::scoped_lock lock(file_logger_mutex);
     logger = file_logger;
     version = file_logger_version;
   }
@@ -61,9 +72,9 @@ get_file_logger() -> std::shared_ptr<spdlog::logger>
 }
 
 void
-update_file_logger(std::shared_ptr<spdlog::logger> new_logger)
+update_file_logger(const std::shared_ptr<spdlog::logger>& new_logger)
 {
-  std::scoped_lock lock(file_logger_mutex);
+  const std::scoped_lock lock(file_logger_mutex);
   // delete if already exists
   spdlog::drop(file_logger_name);
   file_logger = new_logger;
@@ -184,19 +195,11 @@ is_initialized() -> bool
 }
 
 auto
-create_file_logger_impl(const std::string logger_name, const configuration& logger_settings)
+create_file_logger_impl(const std::string& logger_name, const configuration& logger_settings)
   -> std::pair<std::optional<std::string>, std::shared_ptr<spdlog::logger>>
 {
   std::shared_ptr<spdlog::logger> logger{};
 
-  auto fname = logger_settings.filename;
-  auto buffersz = logger_settings.buffer_size;
-  auto cyclesz = logger_settings.cycle_size;
-
-  if (!spdlog::details::os::getenv("COUCHBASE_CXX_CLIENT_MAXIMIZE_LOGGER_CYCLE_SIZE").empty()) {
-    cyclesz = 1024LLU * 1024 * 1024; // use up to 1 GB log file size
-  }
-
   try {
     // Initialise the loggers.
     //
@@ -228,7 +231,13 @@ create_file_logger_impl(const std::string logger_name, const configuration& logg
     auto sink = std::make_shared<spdlog::sinks::dist_sink_mt>();
     sink->set_level(spdlog::level::trace);
 
-    if (!fname.empty()) {
+    if (const auto& fname = logger_settings.filename; !fname.empty()) {
+      auto cyclesz = logger_settings.cycle_size;
+
+      if (!spdlog::details::os::getenv("COUCHBASE_CXX_CLIENT_MAXIMIZE_LOGGER_CYCLE_SIZE").empty()) {
+        cyclesz = 1024LLU * 1024 * 1024; // use up to 1 GB log file size
+      }
+
       auto fsink = std::make_shared<custom_rotating_file_sink_mt>(fname, cyclesz, log_pattern);
       fsink->set_level(spdlog::level::trace);
       sink->add_sink(fsink);
@@ -256,6 +265,7 @@ create_file_logger_impl(const std::string logger_name, const configuration& logg
     if (logger_settings.unit_test) {
       logger = std::make_shared<spdlog::logger>(logger_name, sink);
     } else {
+      auto buffersz = logger_settings.buffer_size;
       // Create the default thread pool for async logging
       spdlog::init_thread_pool(buffersz, 1);
 
@@ -366,7 +376,7 @@ create_console_logger()
 }
 
 void
-register_spdlog_logger(std::shared_ptr<spdlog::logger> l)
+register_spdlog_logger(const std::shared_ptr<spdlog::logger>& l)
 {
   try {
     get_file_logger()->debug("Registering logger {}", l->name());
@@ -392,7 +402,7 @@ check_log_levels(level lvl) -> bool
 {
   auto level = translate_level(lvl);
   bool correct = true;
-  spdlog::apply_all([level, &correct](std::shared_ptr<spdlog::logger> l) {
+  spdlog::apply_all([level, &correct](const std::shared_ptr<spdlog::logger>& l) {
     if (l->level() != level) {
       correct = false;
     }
@@ -405,7 +415,7 @@ set_log_levels(level lvl)
 {
   auto level = translate_level(lvl);
   // Apply the function to each registered spdlog::logger except protocol logger
-  spdlog::apply_all([level](std::shared_ptr<spdlog::logger> l) {
+  spdlog::apply_all([level](const std::shared_ptr<spdlog::logger>& l) {
     if (l->name() == protocol_logger_name) {
       l->set_level(spdlog::level::trace);
       return;

data/ext/couchbase/core/logger/logger.hxx

@@ -121,7 +121,7 @@ reset();
  * @param l spdlog::logger instance
  */
 void
-register_spdlog_logger(std::shared_ptr<spdlog::logger> l);
+register_spdlog_logger(const std::shared_ptr<spdlog::logger>& l);
 
 /**
  * Engines that create their own instances of an spdlog::logger should unregister

data/ext/couchbase/core/management/search_index.cxx

@@ -19,6 +19,8 @@
 
 #include "core/utils/json.hxx"
 
+#include <tao/json/value.hpp>
+
 namespace
 {
 auto
@@ -68,12 +70,9 @@ index::is_vector_index() const -> bool
   if (types == nullptr || !types->is_object()) {
     return false;
   }
-  for (const auto& [_, val] : types->get_object()) {
-    const auto* properties = val.find("properties");
-    if (properties != nullptr && has_vector_mapping_properties(*properties)) {
-      return true;
-    }
-  }
-  return false;
+  return std::any_of(types->get_object().begin(), types->get_object().end(), [](const auto& pair) {
+    const auto* properties = pair.second.find("properties");
+    return properties != nullptr && has_vector_mapping_properties(*properties);
+  });
 }
 } // namespace couchbase::core::management::search

data/ext/couchbase/core/mcbp/buffer_writer.cxx

@@ -30,7 +30,7 @@ buffer_writer::buffer_writer(std::size_t size)
 void
 buffer_writer::write(const std::vector<std::byte>& val)
 {
-  if (val.size() == 0 || val.data() == nullptr) {
+  if (val.empty() || val.data() == nullptr) {
     return;
   }
   std::memcpy(store_.data() + offset_, val.data(), val.size());

data/ext/couchbase/core/mcbp/codec.cxx

@@ -24,7 +24,9 @@
 #include "core/logger/logger.hxx"
 #include "core/utils/unsigned_leb128.hxx"
 
+#include <algorithm>
 #include <couchbase/error_codes.hxx>
+#include <cstdint>
 
 namespace couchbase::core::mcbp
 {
@@ -50,7 +52,7 @@ codec::is_feature_enabled(protocol::hello_feature feature) const -> bool
 }
 
 auto
-codec::encode_packet(const couchbase::core::mcbp::packet& packet)
+codec::encode_packet(const couchbase::core::mcbp::packet& packet) const
   -> tl::expected<std::vector<std::byte>, std::error_code>
 {
   auto encoded_key = packet.key_;
@@ -65,7 +67,7 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
       return tl::unexpected(errc::common::unsupported_operation);
     }
     if (supports_collection_id(packet.command_)) {
-      core::utils::unsigned_leb128<std::uint32_t> encoded(packet.collection_id_);
+      const core::utils::unsigned_leb128<std::uint32_t> encoded(packet.collection_id_);
       encoded_key.reserve(encoded_key.size() + encoded.size());
       encoded_key.insert(encoded_key.begin(), encoded.begin(), encoded.end());
     } else if (packet.command_ == protocol::client_opcode::get_random_key) {
@@ -81,9 +83,9 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
     }
   }
 
-  std::size_t ext_len = extras.size();
-  std::size_t key_len = encoded_key.size();
-  std::size_t val_len = packet.value_.size();
+  const std::size_t ext_len = extras.size();
+  const std::size_t key_len = encoded_key.size();
+  const std::size_t val_len = packet.value_.size();
   std::size_t frames_len = 0;
 
   if (packet.barrier_frame_) {
@@ -99,7 +101,7 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
     frames_len += 3;
   }
   if (packet.open_tracing_frame_) {
-    std::size_t trace_ctx_len = packet.open_tracing_frame_->trace_context.size();
+    const std::size_t trace_ctx_len = packet.open_tracing_frame_->trace_context.size();
     frames_len = trace_ctx_len;
     if (trace_ctx_len < 15) {
       frames_len += 1;
@@ -111,7 +113,7 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
     frames_len += 3;
   }
   if (packet.user_impersonation_frame_) {
-    std::size_t user_len = packet.user_impersonation_frame_->user.size();
+    const std::size_t user_len = packet.user_impersonation_frame_->user.size();
     frames_len += user_len;
     if (user_len < 15) {
       frames_len += 1;
@@ -143,7 +145,7 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
         return tl::unexpected(errc::common::unsupported_operation);
     }
   }
-  std::size_t packet_len = 24 + ext_len + frames_len + key_len + val_len;
+  const std::size_t packet_len = 24 + ext_len + frames_len + key_len + val_len;
   buffer_writer buffer{ packet_len };
   buffer.write_byte(static_cast<std::byte>(packet_magic));
   buffer.write_byte(static_cast<std::byte>(packet.command_));
@@ -209,10 +211,9 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
     }
 
     if (packet.durability_timeout_frame_) {
-      auto millis = packet.durability_timeout_frame_->timeout.count();
-      if (millis > 65535) {
-        millis = 65535;
-      }
+      std::int64_t millis = packet.durability_timeout_frame_->timeout.count();
+      millis =
+        std::min(millis, static_cast<std::int64_t>(std::numeric_limits<std::uint16_t>::max()));
       buffer.write_frame_header(mcbp::request_sync_durability, 3);
       buffer.write_byte(static_cast<std::byte>(packet.durability_level_frame_->level));
       buffer.write_uint16(static_cast<std::uint16_t>(millis));
@@ -243,7 +244,7 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
       return tl::unexpected(errc::common::feature_not_available);
     }
 
-    std::size_t trace_ctx_len = packet.open_tracing_frame_->trace_context.size();
+    const std::size_t trace_ctx_len = packet.open_tracing_frame_->trace_context.size();
     if (trace_ctx_len < 15) {
       buffer.write_frame_header(mcbp::request_open_tracing, trace_ctx_len);
       buffer.write(packet.open_tracing_frame_->trace_context);
@@ -273,7 +274,7 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
       return tl::unexpected(errc::common::invalid_argument);
     }
 
-    std::size_t user_len = packet.user_impersonation_frame_->user.size();
+    const std::size_t user_len = packet.user_impersonation_frame_->user.size();
     if (user_len < 15) {
       buffer.write_frame_header(mcbp::request_user_impersonation, user_len);
       buffer.write(packet.user_impersonation_frame_->user);
@@ -316,7 +317,8 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
 }
 
 auto
-codec::decode_packet(gsl::span<std::byte> input) -> std::tuple<packet, std::size_t, std::error_code>
+codec::decode_packet(gsl::span<std::byte> input) const
+  -> std::tuple<packet, std::size_t, std::error_code>
 {
   if (input.empty()) {
     return { {}, {}, errc::network::end_of_stream };
@@ -327,22 +329,22 @@ codec::decode_packet(gsl::span<std::byte> input) -> std::tuple<packet, std::size
   if (input.size() < header_len) {
     return { {}, {}, errc::network::need_more_data };
   }
-  gsl::span<std::byte> header{ input.data(), header_len };
+  const gsl::span<std::byte> header{ input.data(), header_len };
 
   // grab the length of the full body
-  std::uint32_t body_len = big_endian::read_uint32(header, 8);
+  const std::uint32_t body_len = big_endian::read_uint32(header, 8);
   // Read the remaining bytes of the body
   if (input.size() < header_len + body_len) {
     return { {}, {}, errc::network::need_more_data };
   }
-  gsl::span<std::byte> body{ input.data() + header_len, body_len };
+  const gsl::span<std::byte> body{ input.data() + header_len, body_len };
 
   return decode_packet(header, body);
 }
 
 auto
-codec::decode_packet(gsl::span<std::byte> header,
-                     gsl::span<std::byte> body) -> std::tuple<packet, std::size_t, std::error_code>
+codec::decode_packet(gsl::span<std::byte> header, gsl::span<std::byte> body) const
+  -> std::tuple<packet, std::size_t, std::error_code>
 {
   packet pkt;
 
@@ -376,7 +378,7 @@ codec::decode_packet(gsl::span<std::byte> header,
   pkt.opaque_ = big_endian::read_uint32(header, 12);
   pkt.cas_ = big_endian::read_uint64(header, 16);
 
-  std::size_t header_len = header.size();
+  const std::size_t header_len = header.size();
   std::size_t body_len = body.size();
   std::size_t ext_len = big_endian::read_uint8(header, 4);
   std::size_t key_len = big_endian::read_uint16(header, 2);
@@ -401,13 +403,13 @@ codec::decode_packet(gsl::span<std::byte> header,
                  body_len);
     return { {}, {}, errc::network::protocol_error };
   }
-  std::size_t value_len = body_len - (frames_len + ext_len + key_len);
+  const std::size_t value_len = body_len - (frames_len + ext_len + key_len);
 
   if (frames_len > 0) {
     std::size_t frame_offset = 0;
 
     while (frame_offset < frames_len) {
-      std::byte frame_header = body[frame_offset];
+      const std::byte frame_header = body[frame_offset];
       ++frame_offset;
 
       auto frame_type = std::to_integer<std::uint8_t>((frame_header & std::byte{ 0xf0 }) >> 4);

data/ext/couchbase/core/mcbp/codec.hxx

@@ -38,11 +38,12 @@ class codec
 public:
   explicit codec(std::set<protocol::hello_feature> enabled_features);
 
-  auto encode_packet(const packet& packet) -> tl::expected<std::vector<std::byte>, std::error_code>;
-  auto decode_packet(gsl::span<std::byte> input)
+  auto encode_packet(const packet& packet) const
+    -> tl::expected<std::vector<std::byte>, std::error_code>;
+  auto decode_packet(gsl::span<std::byte> input) const
+    -> std::tuple<packet, std::size_t, std::error_code>;
+  auto decode_packet(gsl::span<std::byte> header, gsl::span<std::byte> body) const
     -> std::tuple<packet, std::size_t, std::error_code>;
-  auto decode_packet(gsl::span<std::byte> header,
-                     gsl::span<std::byte> body) -> std::tuple<packet, std::size_t, std::error_code>;
   void enable_feature(protocol::hello_feature feature);
   [[nodiscard]] auto is_feature_enabled(protocol::hello_feature feature) const -> bool;
 

data/ext/couchbase/core/mcbp/operation_queue.cxx

@@ -26,6 +26,7 @@
 #include <fmt/core.h>
 
 #include <algorithm>
+#include <iterator>
 #include <memory>
 
 namespace couchbase::core::mcbp
@@ -33,7 +34,7 @@ namespace couchbase::core::mcbp
 auto
 operation_queue::debug_string() const -> std::string
 {
-  std::scoped_lock lock(mutex_);
+  const std::scoped_lock lock(mutex_);
   std::vector<char> out;
   fmt::format_to(
     std::back_insert_iterator(out), "num_items: {}, is_open: {}", items_.size(), is_open_);
@@ -47,9 +48,9 @@ operation_queue::consumer() -> std::shared_ptr<operation_consumer>
 }
 
 void
-operation_queue::close_consumer(std::shared_ptr<operation_consumer> consumer)
+operation_queue::close_consumer(const std::shared_ptr<operation_consumer>& consumer)
 {
-  std::scoped_lock lock(mutex_);
+  const std::scoped_lock lock(mutex_);
   consumer->close();
   signal_.notify_all();
 }
@@ -57,7 +58,7 @@ operation_queue::close_consumer(std::shared_ptr<operation_consumer> consumer)
 void
 operation_queue::close()
 {
-  std::scoped_lock lock(mutex_);
+  const std::scoped_lock lock(mutex_);
   is_open_ = false;
   signal_.notify_all();
 }
@@ -66,7 +67,7 @@ auto
 operation_queue::push(std::shared_ptr<queue_request> request,
                       std::size_t max_items) -> std::error_code
 {
-  std::scoped_lock lock(mutex_);
+  const std::scoped_lock lock(mutex_);
 
   if (!is_open_) {
     return errc::network::operation_queue_closed;
@@ -93,9 +94,9 @@ operation_queue::push(std::shared_ptr<queue_request> request,
 }
 
 auto
-operation_queue::remove(std::shared_ptr<queue_request> request) -> bool
+operation_queue::remove(const std::shared_ptr<queue_request>& request) -> bool
 {
-  std::scoped_lock lock(mutex_);
+  const std::scoped_lock lock(mutex_);
 
   if (!is_open_) {
     return false;
@@ -115,7 +116,8 @@ operation_queue::remove(std::shared_ptr<queue_request> request) -> bool
 }
 
 auto
-operation_queue::pop(std::shared_ptr<operation_consumer> consumer) -> std::shared_ptr<queue_request>
+operation_queue::pop(const std::shared_ptr<operation_consumer>& consumer)
+  -> std::shared_ptr<queue_request>
 {
   std::unique_lock lock(mutex_);
 
@@ -134,7 +136,7 @@ operation_queue::pop(std::shared_ptr<operation_consumer> consumer) -> std::share
 }
 
 void
-operation_queue::drain(operation_queue::drain_callback callback)
+operation_queue::drain(const operation_queue::drain_callback& callback)
 {
   for (const auto& request : items_to_drain()) {
     callback(request);
@@ -144,7 +146,7 @@ operation_queue::drain(operation_queue::drain_callback callback)
 auto
 operation_queue::items_to_drain() -> std::list<std::shared_ptr<queue_request>>
 {
-  std::scoped_lock lock(mutex_);
+  const std::scoped_lock lock(mutex_);
 
   if (is_open_) {
     CB_LOG_ERROR("attempted to drain open MCBP operation queue, ignoring");

data/ext/couchbase/core/mcbp/operation_queue.hxx

@@ -36,16 +36,16 @@ public:
 
   [[nodiscard]] auto push(std::shared_ptr<queue_request> request,
                           std::size_t max_items) -> std::error_code;
-  auto remove(std::shared_ptr<queue_request> request) -> bool;
-  void drain(drain_callback callback);
+  auto remove(const std::shared_ptr<queue_request>& request) -> bool;
+  void drain(const drain_callback& callback);
 
   [[nodiscard]] auto consumer() -> std::shared_ptr<operation_consumer>;
   void close();
   [[nodiscard]] auto debug_string() const -> std::string;
 
 private:
-  void close_consumer(std::shared_ptr<operation_consumer> consumer);
-  auto pop(std::shared_ptr<operation_consumer> consumer) -> std::shared_ptr<queue_request>;
+  void close_consumer(const std::shared_ptr<operation_consumer>& consumer);
+  auto pop(const std::shared_ptr<operation_consumer>& consumer) -> std::shared_ptr<queue_request>;
   auto items_to_drain() -> std::list<std::shared_ptr<queue_request>>;
 
   std::list<std::shared_ptr<queue_request>> items_{};