couchbase 4.4.1-dev.2 → 4.4.2

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

@@ -16,6 +16,7 @@
  */
 
 #include "origin.hxx"
+#include <couchbase/build_config.hxx>
 
 #include "core/utils/connection_string.hxx"
 #include "topology/configuration.hxx"
@@ -24,6 +25,7 @@
 #include <fmt/core.h>
 
 #include <tao/json.hpp>
+#include <utility>
 
 namespace tao::json
 {
@@ -220,6 +222,9 @@ origin::to_json() const -> std::string
       "options",
       {
         { "bootstrap_timeout", options_.bootstrap_timeout },
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+        { "dispatch_timeout", options_.dispatch_timeout },
+#endif
         { "resolve_timeout", options_.resolve_timeout },
         { "connect_timeout", options_.connect_timeout },
         { "key_value_timeout", options_.key_value_timeout },
@@ -272,8 +277,8 @@ origin::to_json() const -> std::string
   return tao::json::to_string(json);
 }
 
-bool
-cluster_credentials::uses_certificate() const
+auto
+cluster_credentials::uses_certificate() const -> bool
 {
   return !certificate_path.empty();
 }
@@ -287,8 +292,8 @@ couchbase::core::origin::origin(const couchbase::core::origin& other)
 {
 }
 
-couchbase::core::origin::origin(const origin& other, const topology::configuration& config)
-  : origin(other)
+couchbase::core::origin::origin(origin other, const topology::configuration& config)
+  : origin(std::move(other))
 {
   set_nodes_from_config(config);
 }
@@ -326,8 +331,8 @@ couchbase::core::origin::origin(couchbase::core::cluster_credentials auth,
   }
   next_node_ = nodes_.begin();
 }
-couchbase::core::origin&
-couchbase::core::origin::operator=(const couchbase::core::origin& other)
+auto
+couchbase::core::origin::operator=(const couchbase::core::origin& other) -> couchbase::core::origin&
 {
   if (this != &other) {
     options_ = other.options_;
@@ -338,28 +343,28 @@ couchbase::core::origin::operator=(const couchbase::core::origin& other)
   }
   return *this;
 }
-const std::string&
-couchbase::core::origin::username() const
+auto
+couchbase::core::origin::username() const -> const std::string&
 {
   return credentials_.username;
 }
-const std::string&
-couchbase::core::origin::password() const
+auto
+couchbase::core::origin::password() const -> const std::string&
 {
   return credentials_.password;
 }
-const std::string&
-couchbase::core::origin::certificate_path() const
+auto
+couchbase::core::origin::certificate_path() const -> const std::string&
 {
   return credentials_.certificate_path;
 }
-const std::string&
-couchbase::core::origin::key_path() const
+auto
+couchbase::core::origin::key_path() const -> const std::string&
 {
   return credentials_.key_path;
 }
-std::vector<std::string>
-couchbase::core::origin::get_hostnames() const
+auto
+couchbase::core::origin::get_hostnames() const -> std::vector<std::string>
 {
   std::vector<std::string> res;
   res.reserve(nodes_.size());
@@ -368,8 +373,8 @@ couchbase::core::origin::get_hostnames() const
   }
   return res;
 }
-std::vector<std::string>
-couchbase::core::origin::get_nodes() const
+auto
+couchbase::core::origin::get_nodes() const -> std::vector<std::string>
 {
   std::vector<std::string> res;
   res.reserve(nodes_.size());
@@ -409,8 +414,8 @@ couchbase::core::origin::set_nodes_from_config(const topology::configuration& co
   }
   next_node_ = nodes_.begin();
 }
-std::pair<std::string, std::string>
-couchbase::core::origin::next_address()
+auto
+couchbase::core::origin::next_address() -> std::pair<std::string, std::string>
 {
   if (exhausted_) {
     restart();
@@ -422,8 +427,8 @@ couchbase::core::origin::next_address()
   }
   return address;
 }
-bool
-couchbase::core::origin::exhausted() const
+auto
+couchbase::core::origin::exhausted() const -> bool
 {
   return exhausted_;
 }
@@ -433,18 +438,18 @@ couchbase::core::origin::restart()
   exhausted_ = false;
   next_node_ = nodes_.begin();
 }
-const couchbase::core::cluster_options&
-couchbase::core::origin::options() const
+auto
+couchbase::core::origin::options() const -> const couchbase::core::cluster_options&
 {
   return options_;
 }
-couchbase::core::cluster_options&
-couchbase::core::origin::options()
+auto
+couchbase::core::origin::options() -> couchbase::core::cluster_options&
 {
   return options_;
 }
-const couchbase::core::cluster_credentials&
-couchbase::core::origin::credentials() const
+auto
+couchbase::core::origin::credentials() const -> const couchbase::core::cluster_credentials&
 {
   return credentials_;
 }

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

@@ -54,7 +54,7 @@ struct origin {
 
   origin(origin&& other) = default;
   origin(const origin& other);
-  origin(const origin& other, const topology::configuration& config);
+  origin(origin other, const topology::configuration& config);
   origin(cluster_credentials auth,
          const std::string& hostname,
          std::uint16_t port,

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

@@ -0,0 +1,32 @@
+/* -*- 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 <string>
+
+namespace couchbase::core
+{
+class pending_operation_connection_info
+{
+public:
+  virtual ~pending_operation_connection_info() = default;
+  [[nodiscard]] virtual auto dispatched_to() const -> std::string = 0;
+  [[nodiscard]] virtual auto dispatched_to_host() const -> std::string = 0;
+  [[nodiscard]] virtual auto dispatched_from() const -> std::string = 0;
+};
+} // namespace couchbase::core

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

@@ -2,22 +2,3 @@ add_library(couchbase_backtrace OBJECT backtrace.c)
 target_include_directories(couchbase_backtrace PRIVATE ${PROJECT_BINARY_DIR}/generated ../..)
 target_link_libraries(couchbase_backtrace PRIVATE ${PLATFORM_LIBRARIES})
 set_target_properties(couchbase_backtrace PROPERTIES POSITION_INDEPENDENT_CODE ON)
-
-add_library(
-  couchbase_platform STATIC
-  dirutils.cc
-  random.cc
-  string_hex.cc
-  uuid.cc
-  base64.cc
-  terminate_handler.cc)
-set_target_properties(couchbase_platform PROPERTIES POSITION_INDEPENDENT_CODE ON)
-target_include_directories(couchbase_platform PRIVATE ${PROJECT_BINARY_DIR}/generated ../..)
-target_link_libraries(
-  couchbase_platform
-  PRIVATE project_options
-          project_warnings
-          couchbase_backtrace
-          fmt::fmt
-          spdlog::spdlog
-          Microsoft.GSL::GSL)

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

@@ -23,22 +23,27 @@
 
 #include "base64.h"
 
-#include <algorithm>
+#include <gsl/span>
+
 #include <array>
 #include <cctype>
+#include <cstddef>
 #include <cstdint>
 #include <stdexcept>
 #include <string>
+#include <string_view>
 #include <vector>
 
+namespace
+{
 /**
  * An array of the legal characters used for direct lookup
  */
-static const std::array codemap{ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
-                                 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
-                                 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
-                                 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
-                                 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/' };
+const std::array codemap{ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+                          'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+                          'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+                          'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+                          '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/' };
 
 /**
  * A method to map the code back to the value
@@ -46,8 +51,8 @@ static const std::array codemap{ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J
  * @param code the code to map
  * @return the byte value for the code character
  */
-static std::uint32_t
-code2val(const char code)
+auto
+code2val(const char code) -> std::uint32_t
 {
   if (code >= 'A' && code <= 'Z') {
     return static_cast<std::uint32_t>(code) - static_cast<std::uint32_t>('A');
@@ -67,6 +72,8 @@ code2val(const char code)
   throw std::invalid_argument("couchbase::core::base64::code2val Invalid input character");
 }
 
+// TODO(CXXCBC-549): clang-tidy-19 reports subscript with non-const index
+// NOLINTBEGIN(cppcoreguidelines-pro-bounds-constant-array-index)
 /**
  * Encode up to 3 characters to 4 output character.
  *
@@ -74,10 +81,10 @@ code2val(const char code)
  * @param d pointer to the output stream
  * @param num the number of characters from s to encode
  */
-static void
+void
 encode_rest(const std::byte* s, std::string& result, size_t num)
 {
-  std::uint32_t val;
+  std::uint32_t val = 0;
 
   switch (num) {
     case 2:
@@ -106,7 +113,7 @@ encode_rest(const std::byte* s, std::string& result, size_t num)
  * @param s pointer to the input stream
  * @param d pointer to the output stream
  */
-static void
+void
 encode_triplet(const std::byte* s, std::string& str)
 {
   auto val = (static_cast<std::uint32_t>(*s) << 16U) |      //
@@ -117,6 +124,7 @@ encode_triplet(const std::byte* s, std::string& str)
   str.push_back(codemap[(val >> 6U) & 63]);
   str.push_back(codemap[val & 63]);
 }
+// NOLINTEND(cppcoreguidelines-pro-bounds-constant-array-index)
 
 /**
  * decode 4 input characters to up to two output bytes
@@ -125,8 +133,8 @@ encode_triplet(const std::byte* s, std::string& str)
  * @param d destination
  * @return the number of characters inserted
  */
-static int
-decode_quad(const char* s, std::vector<std::byte>& d)
+auto
+decode_quad(const char* s, std::vector<std::byte>& d) -> int
 {
   std::uint32_t value = code2val(s[0]) << 18U;
   value |= code2val(s[1]) << 12U;
@@ -154,11 +162,12 @@ decode_quad(const char* s, std::vector<std::byte>& d)
 
   return ret;
 }
+} // namespace
 
 namespace couchbase::core::base64
 {
-std::string
-encode(gsl::span<const std::byte> blob, bool pretty_print)
+auto
+encode(gsl::span<const std::byte> blob, bool pretty_print) -> std::string
 {
   // base64 encodes up to 3 input characters to 4 output
   // characters in the alphabet above.
@@ -201,8 +210,8 @@ encode(gsl::span<const std::byte> blob, bool pretty_print)
   return result;
 }
 
-std::vector<std::byte>
-decode(std::string_view blob)
+auto
+decode(std::string_view blob) -> std::vector<std::byte>
 {
   std::vector<std::byte> destination;
 
@@ -213,7 +222,7 @@ decode(std::string_view blob)
   // To reduce the number of reallocations, start by reserving an
   // output buffer of 75% of the input size (and add 3 to avoid dealing
   // with zero)
-  size_t estimate = blob.size() / 100 * 75;
+  const size_t estimate = blob.size() / 100 * 75;
   destination.reserve(estimate + 3);
 
   const auto* in = blob.data();
@@ -238,15 +247,15 @@ decode(std::string_view blob)
   return destination;
 }
 
-std::string
-decode_to_string(std::string_view blob)
+auto
+decode_to_string(std::string_view blob) -> std::string
 {
   auto decoded = decode(blob);
   return { reinterpret_cast<const char*>(decoded.data()), decoded.size() };
 }
 
-std::string
-encode(std::string_view blob, bool pretty_print)
+auto
+encode(std::string_view blob, bool pretty_print) -> std::string
 {
   return encode(gsl::as_bytes(gsl::span{ blob.data(), blob.size() }), pretty_print);
 }

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

@@ -11,6 +11,9 @@
 #include "dirutils.h"
 
 #include <cstring>
+#include <string>
+#include <vector>
+
 #ifdef _MSC_VER
 #include <filesystem>
 
@@ -21,10 +24,12 @@
 
 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
 {
-  std::string::size_type path = input.find_last_of("\\/");
+  const std::string::size_type path = input.find_last_of("\\/");
   std::string file;
   std::string dir;
 
@@ -33,7 +38,7 @@ split(const std::string& input, bool directory)
     file = input;
   } else {
     dir = input.substr(0, path);
-    if (dir.length() == 0) {
+    if (dir.empty()) {
       dir = input.substr(0, 1);
     }
 
@@ -49,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);
 }
@@ -93,14 +99,18 @@ 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;
+    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 (std::string fnm(de->d_name); fnm == "." || fnm == "..") {
+      if (const std::string fnm(de->d_name); fnm == "." || fnm == "..") {
         continue;
       }
       if (strncmp(de->d_name, name.c_str(), name.length()) == 0) {
@@ -117,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

@@ -19,13 +19,17 @@
 
 #include <cerrno>
 #include <chrono>
+#include <cstddef>
+#include <cstdint>
 #include <memory>
 #include <mutex>
 #include <system_error>
 
 #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>
@@ -50,7 +54,7 @@ public:
                               "initialize random generator");
     }
 #else
-    if ((handle = open("/dev/urandom", O_RDONLY)) == -1) {
+    if (handle = open("/dev/urandom", O_RDONLY | O_CLOEXEC); handle == -1) {
       throw std::system_error(errno,
                               std::system_category(),
                               "RandomGeneratorProvider::Failed to "
@@ -58,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()
   {
@@ -68,17 +76,17 @@ public:
 #endif
   }
 
-  bool getBytes(void* dest, size_t size)
+  auto getBytes(void* dest, std::size_t size) -> bool
   {
-    std::lock_guard<std::mutex> lock(mutex);
+    const std::lock_guard<std::mutex> lock(mutex);
 #ifdef WIN32
     return CryptGenRandom(handle, (DWORD)size, static_cast<BYTE*>(dest));
 #else
-    return size_t(read(handle, dest, size)) == size;
+    return static_cast<std::size_t>(read(handle, dest, size)) == size;
 #endif
   }
 
-protected:
+private:
 #ifdef WIN32
   HCRYPTPROV handle{};
 #else
@@ -94,17 +102,17 @@ RandomGenerator::RandomGenerator()
 {
   if (!shared_provider) {
     // This might be the first one, lets lock and create
-    std::lock_guard<std::mutex> guard(shared_provider_lock);
-    if (!shared_provider) {
+    const std::lock_guard<std::mutex> guard(shared_provider_lock);
+    if (!shared_provider) { // cppcheck-suppress identicalInnerCondition; DCLP
       shared_provider = std::make_unique<RandomGeneratorProvider>();
     }
   }
 }
 
-std::uint64_t
-RandomGenerator::next()
+auto
+RandomGenerator::next() -> std::uint64_t
 {
-  std::uint64_t ret;
+  std::uint64_t ret = 0;
   if (getBytes(&ret, sizeof(ret))) {
     return ret;
   }
@@ -112,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, 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/random.h

@@ -34,6 +34,6 @@ public:
 
   std::uint64_t next();
 
-  bool getBytes(void* dest, size_t size);
+  static bool getBytes(void* dest, size_t size);
 };
 } // namespace couchbase::core

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

@@ -17,14 +17,21 @@
 
 #include "string_hex.h"
 
+#include <array>
 #include <cinttypes>
+#include <cstdint>
+#include <cstdio>
 #include <iomanip>
+#include <ios>
 #include <sstream>
 #include <stdexcept>
 #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');
@@ -38,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) {
@@ -48,54 +56,55 @@ couchbase::core::from_hex(std::string_view buffer)
                               std::to_string(buffer.size()));
   }
 
-  for (char digit : buffer) {
+  for (const char digit : buffer) {
     ret = (ret << 4) | from_hex_digit(digit);
   }
 
   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 "";
   }
   std::stringstream ss;
   for (const auto& c : buffer) {
-    ss << "0x" << std::hex << std::setfill('0') << std::setw(2) << std::uint32_t(c) << " ";
+    ss << "0x" << std::hex << std::setfill('0') << std::setw(2) << static_cast<std::uint32_t>(c)
+       << " ";
   }
   auto ret = ss.str();
   ret.resize(ret.size() - 1);

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