couchbase 4.4.1 → 4.4.2

package/deps/couchbase-cxx-client/core/platform/dirutils.cc

@@ -24,8 +24,10 @@
 
 namespace couchbase::core::platform
 {
-static std::string
-split(const std::string& input, bool directory)
+namespace
+{
+auto
+split(const std::string& input, bool directory) -> std::string
 {
   const std::string::size_type path = input.find_last_of("\\/");
   std::string file;
@@ -52,15 +54,16 @@ split(const std::string& input, bool directory)
   }
   return file;
 }
+} // namespace
 
-std::string
-dirname(const std::string& dir)
+auto
+dirname(const std::string& dir) -> std::string
 {
   return split(dir, true);
 }
 
-std::string
-basename(const std::string& name)
+auto
+basename(const std::string& name) -> std::string
 {
   return split(name, false);
 }
@@ -96,12 +99,16 @@ find_files_with_prefix(const std::string& dir, const std::string& name)
   return files;
 }
 #else
-std::vector<std::string>
-find_files_with_prefix(const std::string& dir, const std::string& name)
+auto
+find_files_with_prefix(const std::string& dir, const std::string& name) -> std::vector<std::string>
 {
   std::vector<std::string> files;
+  // TODO(CXXCBC-549): clang-tidy-19 reports function is not thread safe
+  // NOLINTNEXTLINE(concurrency-mt-unsafe)
   if (DIR* dp = opendir(dir.c_str()); dp != nullptr) {
     const struct dirent* de = nullptr;
+    // TODO(CXXCBC-549): clang-tidy-19 reports function is not thread safe
+    // NOLINTNEXTLINE(concurrency-mt-unsafe)
     while ((de = readdir(dp)) != nullptr) {
       if (const std::string fnm(de->d_name); fnm == "." || fnm == "..") {
         continue;
@@ -120,8 +127,8 @@ find_files_with_prefix(const std::string& dir, const std::string& name)
 }
 #endif
 
-std::vector<std::string>
-find_files_with_prefix(const std::string& name)
+auto
+find_files_with_prefix(const std::string& name) -> std::vector<std::string>
 {
   return find_files_with_prefix(dirname(name), basename(name));
 }

package/deps/couchbase-cxx-client/core/platform/random.cc

@@ -27,7 +27,9 @@
 
 #ifdef WIN32
 // We need to include windows.h _before_ wincrypt.h
+#ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN
+#endif
 #include <windows.h>
 
 #include <wincrypt.h>
@@ -52,7 +54,7 @@ public:
                               "initialize random generator");
     }
 #else
-    if ((handle = open("/dev/urandom", O_RDONLY | O_CLOEXEC)) == -1) {
+    if (handle = open("/dev/urandom", O_RDONLY | O_CLOEXEC); handle == -1) {
       throw std::system_error(errno,
                               std::system_category(),
                               "RandomGeneratorProvider::Failed to "
@@ -60,6 +62,10 @@ public:
     }
 #endif
   }
+  RandomGeneratorProvider(const RandomGeneratorProvider&) = delete;
+  auto operator=(const RandomGeneratorProvider&) -> RandomGeneratorProvider& = delete;
+  RandomGeneratorProvider(RandomGeneratorProvider&&) = delete;
+  auto operator=(RandomGeneratorProvider&&) -> RandomGeneratorProvider& = delete;
 
   virtual ~RandomGeneratorProvider()
   {
@@ -70,7 +76,7 @@ public:
 #endif
   }
 
-  bool getBytes(void* dest, std::size_t size)
+  auto getBytes(void* dest, std::size_t size) -> bool
   {
     const std::lock_guard<std::mutex> lock(mutex);
 #ifdef WIN32
@@ -80,7 +86,7 @@ public:
 #endif
   }
 
-protected:
+private:
 #ifdef WIN32
   HCRYPTPROV handle{};
 #else
@@ -103,8 +109,8 @@ RandomGenerator::RandomGenerator()
   }
 }
 
-std::uint64_t
-RandomGenerator::next()
+auto
+RandomGenerator::next() -> std::uint64_t
 {
   std::uint64_t ret = 0;
   if (getBytes(&ret, sizeof(ret))) {
@@ -114,8 +120,8 @@ RandomGenerator::next()
   return static_cast<std::uint64_t>(std::chrono::steady_clock::now().time_since_epoch().count());
 }
 
-bool
-RandomGenerator::getBytes(void* dest, std::size_t size)
+auto
+RandomGenerator::getBytes(void* dest, std::size_t size) -> bool
 {
   return shared_provider->getBytes(dest, size);
 }

package/deps/couchbase-cxx-client/core/platform/string_hex.cc

@@ -17,6 +17,7 @@
 
 #include "string_hex.h"
 
+#include <array>
 #include <cinttypes>
 #include <cstdint>
 #include <cstdio>
@@ -27,8 +28,10 @@
 #include <string>
 #include <string_view>
 
-static inline std::uint8_t
-from_hex_digit(char c)
+namespace
+{
+inline auto
+from_hex_digit(char c) -> std::uint8_t
 {
   if ('0' <= c && c <= '9') {
     return static_cast<std::uint8_t>(c - '0');
@@ -42,9 +45,10 @@ from_hex_digit(char c)
   throw std::invalid_argument(
     "couchbase::core::from_hex_digit: character was not in hexadecimal range");
 }
+} // namespace
 
-std::uint64_t
-couchbase::core::from_hex(std::string_view buffer)
+auto
+couchbase::core::from_hex(std::string_view buffer) -> std::uint64_t
 {
   std::uint64_t ret = 0;
   if (buffer.size() > 16) {
@@ -59,40 +63,40 @@ couchbase::core::from_hex(std::string_view buffer)
   return ret;
 }
 
-std::string
-couchbase::core::to_hex(std::uint8_t val)
+auto
+couchbase::core::to_hex(std::uint8_t val) -> std::string
 {
-  char buf[32];
-  snprintf(buf, sizeof(buf), "0x%02" PRIx8, val);
-  return std::string{ buf };
+  std::array<char, 32> buf{};
+  snprintf(buf.data(), buf.size(), "0x%02" PRIx8, val);
+  return std::string{ buf.data() };
 }
 
-std::string
-couchbase::core::to_hex(std::uint16_t val)
+auto
+couchbase::core::to_hex(std::uint16_t val) -> std::string
 {
-  char buf[32];
-  snprintf(buf, sizeof(buf), "0x%04" PRIx16, val);
-  return std::string{ buf };
+  std::array<char, 32> buf{};
+  snprintf(buf.data(), buf.size(), "0x%04" PRIx16, val);
+  return std::string{ buf.data() };
 }
 
-std::string
-couchbase::core::to_hex(std::uint32_t val)
+auto
+couchbase::core::to_hex(std::uint32_t val) -> std::string
 {
-  char buf[32];
-  snprintf(buf, sizeof(buf), "0x%08" PRIx32, val);
-  return std::string{ buf };
+  std::array<char, 32> buf{};
+  snprintf(buf.data(), buf.size(), "0x%08" PRIx32, val);
+  return std::string{ buf.data() };
 }
 
-std::string
-couchbase::core::to_hex(std::uint64_t val)
+auto
+couchbase::core::to_hex(std::uint64_t val) -> std::string
 {
-  char buf[32];
-  snprintf(buf, sizeof(buf), "0x%016" PRIx64, val);
-  return std::string{ buf };
+  std::array<char, 32> buf{};
+  snprintf(buf.data(), buf.size(), "0x%016" PRIx64, val);
+  return std::string{ buf.data() };
 }
 
-std::string
-couchbase::core::to_hex(std::string_view buffer)
+auto
+couchbase::core::to_hex(std::string_view buffer) -> std::string
 {
   if (buffer.empty()) {
     return "";

package/deps/couchbase-cxx-client/core/platform/string_hex.h

@@ -17,6 +17,7 @@
 #pragma once
 
 #include <cstdint>
+#include <string>
 #include <string_view>
 
 namespace couchbase::core

package/deps/couchbase-cxx-client/core/platform/terminate_handler.cc

@@ -21,18 +21,21 @@
 #include "core/logger/logger.hxx"
 #include "core/meta/version.hxx"
 
+#include <array>
 #include <cstdio>
 #include <cstdlib>
 #include <exception>
 
 namespace couchbase::core::platform
 {
-static bool should_include_backtrace = true;
-static std::terminate_handler default_terminate_handler = nullptr;
+namespace
+{
+bool should_include_backtrace = true;
+std::terminate_handler default_terminate_handler = nullptr;
 
 // Logs details on the handled exception. Attempts to log to
 // `terminate_logger` if non-null; otherwise prints to stderr.
-static void
+void
 log_handled_exception()
 {
 #ifdef WIN32
@@ -58,18 +61,16 @@ log_handled_exception()
 }
 
 // Log the symbolified backtrace to this point.
-static void
+void
 log_backtrace()
 {
-  static const char format_str[] = "Call stack:\n%s";
-
-  char buffer[8192];
-  if (print_backtrace_to_buffer("    ", buffer, sizeof(buffer))) {
-    CB_LOG_CRITICAL("Call stack:\n{}", buffer);
+  std::array<char, 8192> buffer{};
+  if (print_backtrace_to_buffer("    ", buffer.data(), buffer.size())) {
+    CB_LOG_CRITICAL("Call stack:\n{}", buffer.data());
   } else {
     // Exceeded buffer space - print directly to stderr FD (requires no
     // buffering, but has the disadvantage that we don't get it in the log).
-    fprintf(stderr, format_str, "");
+    fprintf(stderr, "Call stack:\n%s", "");
     print_backtrace_to_file(stderr);
     fflush(stderr);
     CB_LOG_CRITICAL_RAW("Call stack exceeds 8k, rendered to STDERR");
@@ -78,7 +79,7 @@ log_backtrace()
 
 // Replacement terminate_handler which prints the exception's what() and a
 // backtrace of the current stack before chaining to the default handler.
-static void
+void
 backtrace_terminate_handler()
 {
   static bool meta_reported = false;
@@ -108,6 +109,7 @@ backtrace_terminate_handler()
 
   std::abort();
 }
+} // namespace
 
 void
 install_backtrace_terminate_handler()

package/deps/couchbase-cxx-client/core/platform/uuid.cc

@@ -42,16 +42,16 @@ couchbase::core::uuid::random(couchbase::core::uuid::uuid_t& uuid)
   uuid[6] |= 0x40;
 }
 
-couchbase::core::uuid::uuid_t
-couchbase::core::uuid::random()
+auto
+couchbase::core::uuid::random() -> couchbase::core::uuid::uuid_t
 {
   uuid_t ret;
   random(ret);
   return ret;
 }
 
-couchbase::core::uuid::uuid_t
-couchbase::core::uuid::from_string(std::string_view str)
+auto
+couchbase::core::uuid::from_string(std::string_view str) -> couchbase::core::uuid::uuid_t
 {
   uuid_t ret;
   if (str.size() != 36) {
@@ -73,14 +73,16 @@ couchbase::core::uuid::from_string(std::string_view str)
         ++ii;
         [[fallthrough]];
       default:
+        // TODO(CXXCBC-549): clang-tidy-19 reports issue with subscript
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-constant-array-index)
         ret[jj++] = static_cast<std::uint8_t>(from_hex({ str.data() + ii, 2 }));
     }
   }
   return ret;
 }
 
-inline char
-to_char(std::uint8_t c)
+inline auto
+to_char(std::uint8_t c) -> char
 {
   if (c <= 9) {
     return static_cast<char>('0' + c);
@@ -88,8 +90,8 @@ to_char(std::uint8_t c)
   return static_cast<char>('a' + (c - 10));
 }
 
-std::string
-couchbase::core::uuid::to_string(const couchbase::core::uuid::uuid_t& uuid)
+auto
+couchbase::core::uuid::to_string(const couchbase::core::uuid::uuid_t& uuid) -> std::string
 {
   std::string ret(36, '-');
   std::size_t i = 0;

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

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

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

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

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

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

package/deps/couchbase-cxx-client/core/tracing/threshold_logging_tracer.cxx

@@ -32,6 +32,7 @@
 #include <chrono>
 #include <mutex>
 #include <queue>
+#include <utility>
 
 namespace couchbase::core::tracing
 {
@@ -68,7 +69,7 @@ public:
   threshold_logging_span(std::string name,
                          std::shared_ptr<threshold_logging_tracer> tracer,
                          std::shared_ptr<request_span> parent = nullptr)
-    : request_span(std::move(name), parent)
+    : request_span(std::move(name), std::move(parent))
     , tracer_{ std::move(tracer) }
   {
   }
@@ -168,21 +169,11 @@ public:
   {
   }
 
-  concurrent_fixed_queue(concurrent_fixed_queue& other)
-  {
-    std::unique_lock<std::mutex> lock(other.mutex_);
-    data_ = other.data_;
-    capacity_ = other.capacity_;
-  }
-
-  concurrent_fixed_queue(const concurrent_fixed_queue& other) = delete;
-
-  concurrent_fixed_queue(concurrent_fixed_queue&& other) noexcept
-  {
-    std::unique_lock<std::mutex> lock(other.mutex_);
-    std::swap(data_, other.data_);
-    std::swap(capacity_, other.capacity_);
-  }
+  concurrent_fixed_queue(const concurrent_fixed_queue&) = delete;
+  concurrent_fixed_queue(concurrent_fixed_queue&&) = delete;
+  auto operator=(const concurrent_fixed_queue&) -> concurrent_fixed_queue& = delete;
+  auto operator=(concurrent_fixed_queue&&) -> concurrent_fixed_queue& = delete;
+  ~concurrent_fixed_queue() = default;
 
   void pop()
   {
@@ -198,13 +189,13 @@ public:
 
   auto empty() -> bool
   {
-    std::unique_lock<std::mutex> lock(mutex_);
+    const std::unique_lock<std::mutex> lock(mutex_);
     return data_.empty();
   }
 
   void emplace(const T&& item)
   {
-    std::unique_lock<std::mutex> lock(mutex_);
+    const std::unique_lock<std::mutex> lock(mutex_);
     data_.emplace(std::forward<const T>(item));
     if (data_.size() > capacity_) {
       data_.pop();
@@ -214,7 +205,7 @@ public:
   auto steal_data() -> std::priority_queue<T>
   {
     std::priority_queue<T> data;
-    std::unique_lock<std::mutex> lock(mutex_);
+    const std::unique_lock<std::mutex> lock(mutex_);
     std::swap(data, data_);
     return data;
   }
@@ -223,7 +214,7 @@ public:
 using fixed_span_queue = concurrent_fixed_queue<reported_span>;
 
 auto
-convert(std::shared_ptr<threshold_logging_span> span) -> reported_span
+convert(const std::shared_ptr<threshold_logging_span>& span) -> reported_span
 {
   tao::json::value entry{
     { "operation_name", span->name() },
@@ -276,6 +267,11 @@ public:
     threshold_queues_.try_emplace(service_type::management, options.threshold_sample_size);
   }
 
+  threshold_logging_tracer_impl(const threshold_logging_tracer_impl&) = delete;
+  threshold_logging_tracer_impl(threshold_logging_tracer_impl&&) = delete;
+  auto operator=(const threshold_logging_tracer_impl&) -> threshold_logging_tracer_impl& = delete;
+  auto operator=(threshold_logging_tracer_impl&&) -> threshold_logging_tracer_impl& = delete;
+
   ~threshold_logging_tracer_impl()
   {
     emit_orphan_report_.cancel();
@@ -297,12 +293,12 @@ public:
     emit_threshold_report_.cancel();
   }
 
-  void add_orphan(std::shared_ptr<threshold_logging_span> span)
+  void add_orphan(const std::shared_ptr<threshold_logging_span>& span)
   {
-    orphan_queue_.emplace(convert(std::move(span)));
+    orphan_queue_.emplace(convert(span));
   }
 
-  void check_threshold(std::shared_ptr<threshold_logging_span> span)
+  void check_threshold(const std::shared_ptr<threshold_logging_span>& span)
   {
     auto service = span->service();
     if (!service.has_value()) {
@@ -409,12 +405,12 @@ threshold_logging_tracer::start_span(std::string name,
 }
 
 void
-threshold_logging_tracer::report(std::shared_ptr<threshold_logging_span> span)
+threshold_logging_tracer::report(const std::shared_ptr<threshold_logging_span>& span)
 {
   if (span->orphan()) {
-    impl_->add_orphan(std::move(span));
+    impl_->add_orphan(span);
   } else {
-    impl_->check_threshold(std::move(span));
+    impl_->check_threshold(span);
   }
 }