couchbase 3.5.2 → 3.5.3

data/ext/couchbase/core/platform/random.cc

@@ -19,6 +19,8 @@
 
 #include <cerrno>
 #include <chrono>
+#include <cstddef>
+#include <cstdint>
 #include <memory>
 #include <mutex>
 #include <system_error>
@@ -50,7 +52,7 @@ public:
                               "initialize random generator");
     }
 #else
-    if ((handle = open("/dev/urandom", O_RDONLY)) == -1) {
+    if ((handle = open("/dev/urandom", O_RDONLY | O_CLOEXEC)) == -1) {
       throw std::system_error(errno,
                               std::system_category(),
                               "RandomGeneratorProvider::Failed to "
@@ -68,13 +70,13 @@ public:
 #endif
   }
 
-  bool getBytes(void* dest, size_t size)
+  bool getBytes(void* dest, std::size_t size)
   {
-    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
   }
 
@@ -94,8 +96,8 @@ 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>();
     }
   }
@@ -104,7 +106,7 @@ RandomGenerator::RandomGenerator()
 std::uint64_t
 RandomGenerator::next()
 {
-  std::uint64_t ret;
+  std::uint64_t ret = 0;
   if (getBytes(&ret, sizeof(ret))) {
     return ret;
   }
@@ -113,7 +115,7 @@ RandomGenerator::next()
 }
 
 bool
-RandomGenerator::getBytes(void* dest, size_t size)
+RandomGenerator::getBytes(void* dest, std::size_t size)
 {
   return shared_provider->getBytes(dest, size);
 }

data/ext/couchbase/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

data/ext/couchbase/core/platform/string_hex.cc

@@ -18,10 +18,14 @@
 #include "string_hex.h"
 
 #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)
@@ -48,7 +52,7 @@ 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);
   }
 
@@ -95,7 +99,8 @@ couchbase::core::to_hex(std::string_view buffer)
   }
   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);

data/ext/couchbase/core/platform/terminate_handler.cc

@@ -21,6 +21,7 @@
 #include "core/logger/logger.hxx"
 #include "core/meta/version.hxx"
 
+#include <cstdio>
 #include <cstdlib>
 #include <exception>
 
@@ -46,7 +47,7 @@ log_handled_exception()
     // try once to re-throw currently active exception (so we can print
     // its what() message).
     if (tried_throw++ == 0) {
-      throw;
+      std::rethrow_exception(std::current_exception());
     }
   } catch (const std::exception& e) {
     CB_LOG_CRITICAL("Caught unhandled std::exception-derived exception. what(): {}", e.what());

data/ext/couchbase/core/platform/uuid.cc

@@ -19,8 +19,12 @@
 
 #include "string_hex.h"
 
-#include <iomanip>
+#include <cstddef>
+#include <cstdint>
 #include <random>
+#include <stdexcept>
+#include <string>
+#include <string_view>
 
 void
 couchbase::core::uuid::random(couchbase::core::uuid::uuid_t& uuid)
@@ -66,9 +70,10 @@ couchbase::core::uuid::from_string(std::string_view str)
           throw std::invalid_argument("couchbase::core::uuid::from_string: hyphen not found where "
                                       "expected");
         }
-        ++ii; // fall-through
+        ++ii;
+        [[fallthrough]];
       default:
-        ret[jj++] = std::uint8_t(from_hex({ str.data() + ii, 2 }));
+        ret[jj++] = static_cast<std::uint8_t>(from_hex({ str.data() + ii, 2 }));
     }
   }
   return ret;

data/ext/couchbase/core/protocol/client_request.cxx

@@ -29,7 +29,7 @@ compress_value(const std::vector<std::byte>& value,
   static const double min_ratio = 0.83;
 
   std::string compressed;
-  std::size_t compressed_size =
+  const std::size_t compressed_size =
     snappy::Compress(reinterpret_cast<const char*>(value.data()), value.size(), &compressed);
   if (gsl::narrow_cast<double>(compressed_size) / gsl::narrow_cast<double>(value.size()) <
       min_ratio) {

data/ext/couchbase/core/protocol/client_request.hxx

@@ -29,8 +29,6 @@
 #include <cstring>
 #include <gsl/util>
 
-#include <iostream>
-
 namespace couchbase::core::protocol
 {
 auto
@@ -127,7 +125,7 @@ private:
     std::vector<std::byte> payload(header_size + body_.size(), std::byte{});
     payload[0] = static_cast<std::byte>(magic_);
     payload[1] = static_cast<std::byte>(opcode_);
-#if defined(__GNUC__) && __GNUC__ == 8
+#if defined(__GNUC__) && __GNUC__ >= 8 && __GNUC__ < 12
 #pragma GCC diagnostic pop
 #endif
     const auto& framing_extras = body_.framing_extras();

data/ext/couchbase/core/protocol/client_response.cxx

@@ -21,6 +21,7 @@
 
 #include <cstring>
 #include <gsl/assert>
+#include <tao/json/value.hpp>
 
 namespace couchbase::core::protocol
 {

data/ext/couchbase/core/protocol/cmd_cluster_map_change_notification.cxx

@@ -21,9 +21,11 @@
 #include "core/utils/byteswap.hxx"
 #include "core/utils/json.hxx"
 
-#include <cstring>
 #include <gsl/assert>
 
+#include <cstddef>
+#include <cstring>
+
 namespace couchbase::core::protocol
 {
 auto
@@ -47,8 +49,8 @@ cluster_map_change_notification_request_body::parse(const header_buffer& header,
   bucket_.assign(data_ptr + offset, data_ptr + offset + key_size);
   offset += key_size;
   if (body.size() > static_cast<std::size_t>(offset)) {
-    std::string_view config_text{ data_ptr + offset,
-                                  body.size() - static_cast<std::size_t>(offset) };
+    const std::string_view config_text{ data_ptr + offset,
+                                        body.size() - static_cast<std::size_t>(offset) };
     config_ = parse_config(config_text, info.endpoint_address, info.endpoint_port);
     config_text_.emplace(config_text);
   }

data/ext/couchbase/core/protocol/cmd_get_and_lock.hxx

@@ -63,7 +63,7 @@ public:
 
 private:
   std::vector<std::byte> key_;
-  std::uint32_t lock_time_;
+  std::uint32_t lock_time_{ 0 };
   std::vector<std::byte> extras_{};
 
 public:

data/ext/couchbase/core/protocol/cmd_get_and_touch.hxx

@@ -63,7 +63,7 @@ public:
 
 private:
   std::vector<std::byte> key_;
-  std::uint32_t expiry_;
+  std::uint32_t expiry_{ 0 };
   std::vector<std::byte> extras_{};
 
 public:

data/ext/couchbase/core/protocol/cmd_get_cluster_config.cxx

@@ -22,6 +22,7 @@
 #include "core/utils/json.hxx"
 
 #include <gsl/assert>
+#include <tao/json/value.hpp>
 
 namespace couchbase::core::protocol
 {
@@ -74,7 +75,7 @@ get_cluster_config_response_body::parse(key_value_status_code status,
 {
   Expects(header[1] == static_cast<std::byte>(opcode));
   if (status == key_value_status_code::success) {
-    std::vector<std::uint8_t>::difference_type offset =
+    const std::vector<std::uint8_t>::difference_type offset =
       framing_extras_size + key_size + extras_size;
     std::string_view config_text{ reinterpret_cast<const char*>(body.data()) + offset,
                                   body.size() - static_cast<std::size_t>(offset) };

data/ext/couchbase/core/protocol/cmd_get_cluster_config.hxx

@@ -43,9 +43,9 @@ private:
   std::optional<std::string_view> config_text_;
 
 public:
-  [[nodiscard]] auto config() -> topology::configuration&&
+  [[nodiscard]] auto config() -> const topology::configuration&
   {
-    return std::move(config_);
+    return config_;
   }
 
   [[nodiscard]] auto config_text() const -> const std::optional<std::string_view>&

data/ext/couchbase/core/protocol/cmd_get_collections_manifest.cxx

@@ -22,6 +22,7 @@
 #include "core/utils/json.hxx"
 
 #include <gsl/assert>
+#include <tao/json/value.hpp>
 
 namespace couchbase::core::protocol
 {
@@ -36,7 +37,7 @@ get_collections_manifest_response_body::parse(key_value_status_code status,
 {
   Expects(header[1] == static_cast<std::byte>(opcode));
   if (status == key_value_status_code::success) {
-    std::vector<std::uint8_t>::difference_type offset =
+    const std::vector<std::uint8_t>::difference_type offset =
       framing_extras_size + key_size + extras_size;
     std::string_view manifest_text{ reinterpret_cast<const char*>(body.data()) + offset,
                                     body.size() - static_cast<std::size_t>(offset) };

data/ext/couchbase/core/protocol/cmd_get_error_map.cxx

@@ -24,6 +24,7 @@
 
 #include <cstring>
 #include <gsl/assert>
+#include <tao/json/value.hpp>
 
 namespace couchbase::core::protocol
 {
@@ -38,7 +39,7 @@ get_error_map_response_body::parse(key_value_status_code status,
 {
   Expects(header[1] == static_cast<std::byte>(opcode));
   if (status == key_value_status_code::success) {
-    std::vector<std::uint8_t>::difference_type offset =
+    const std::vector<std::uint8_t>::difference_type offset =
       framing_extras_size + key_size + extras_size;
     std::string_view error_map_text{ reinterpret_cast<const char*>(body.data()) + offset,
                                      body.size() - static_cast<std::size_t>(offset) };

data/ext/couchbase/core/protocol/cmd_hello.cxx

@@ -38,16 +38,16 @@ hello_response_body::parse(key_value_status_code status,
 {
   Expects(header[1] == static_cast<std::byte>(opcode));
   if (status == key_value_status_code::success) {
-    std::vector<std::uint8_t>::difference_type offset =
+    const std::vector<std::uint8_t>::difference_type offset =
       framing_extras_size + key_size + extras_size;
-    size_t value_size = body.size() - static_cast<std::size_t>(offset);
+    const size_t value_size = body.size() - static_cast<std::size_t>(offset);
     Expects(value_size % 2 == 0);
-    size_t num_features = value_size / 2;
+    const size_t num_features = value_size / 2;
     supported_features_.reserve(num_features);
     const auto* value = body.data() + offset;
     for (size_t i = 0; i < num_features; i++) {
       std::uint16_t field = 0;
-      std::memcpy(&field, value + i * 2, sizeof(std::uint16_t));
+      std::memcpy(&field, value + (i * 2), sizeof(std::uint16_t));
       field = utils::byte_swap(field);
       if (is_valid_hello_feature(field)) {
         supported_features_.push_back(static_cast<hello_feature>(field));
@@ -64,7 +64,7 @@ hello_request_body::fill_body()
   value_.resize(2 * features_.size());
   for (std::size_t idx = 0; idx < features_.size(); idx++) {
     value_[idx * 2] = std::byte{ 0 }; // we don't need this byte while feature codes fit the 8-bit
-    value_[idx * 2 + 1] = static_cast<std::byte>(features_[idx]);
+    value_[(idx * 2) + 1] = static_cast<std::byte>(features_[idx]);
   }
 }
 

data/ext/couchbase/core/protocol/cmd_mutate_in.cxx

@@ -121,13 +121,13 @@ mutate_in_request_body::fill_extras()
     memcpy(extras_.data(), &field, sizeof(field));
   }
   if (user_flags_) {
-    std::size_t offset = extras_.size();
+    const std::size_t offset = extras_.size();
     extras_.resize(offset + sizeof(std::uint32_t));
     std::uint32_t field = utils::byte_swap(user_flags_.value());
     memcpy(extras_.data() + offset, &field, sizeof(field));
   }
   if (flags_ != std::byte{ 0U }) {
-    std::size_t offset = extras_.size();
+    const std::size_t offset = extras_.size();
     extras_.resize(offset + sizeof(flags_));
     extras_[offset] = std::byte{ flags_ };
   }

data/ext/couchbase/core/protocol/cmd_observe_seqno.cxx

@@ -40,7 +40,8 @@ observe_seqno_response_body::parse(key_value_status_code status,
     using offset_type = std::vector<std::byte>::difference_type;
     offset_type offset = framing_extras_size + extras_size + key_size;
 
-    bool failover = std::to_integer<std::uint8_t>(body[static_cast<std::size_t>(offset)]) != 0U;
+    const bool failover =
+      std::to_integer<std::uint8_t>(body[static_cast<std::size_t>(offset)]) != 0U;
     ++offset;
 
     memcpy(&partition_id_, body.data() + offset, sizeof(partition_id_));
@@ -84,7 +85,7 @@ observe_seqno_request_body::partition_uuid(const uint64_t& uuid)
 void
 observe_seqno_request_body::fill_body()
 {
-  std::vector<std::byte>::size_type offset = 0;
+  const std::vector<std::byte>::size_type offset = 0;
 
   value_.resize(sizeof(std::uint64_t));
 

data/ext/couchbase/core/protocol/cmd_observe_seqno.hxx

@@ -88,7 +88,7 @@ public:
   static const inline client_opcode opcode = client_opcode::observe_seqno;
 
 private:
-  std::uint64_t partition_uuid_;
+  std::uint64_t partition_uuid_{};
   std::vector<std::byte> value_{};
 
 public:

data/ext/couchbase/core/protocol/status.cxx

@@ -201,7 +201,6 @@ map_status_code(protocol::client_opcode opcode, std::uint16_t status) -> std::er
       return errc::key_value::mutation_token_outdated;
 
     case key_value_status_code::unknown:
-      break;
     case key_value_status_code::config_only:
       break;
   }

data/ext/couchbase/core/range_scan_load_balancer.cxx

@@ -18,6 +18,7 @@
 #include "range_scan_load_balancer.hxx"
 
 #include <algorithm>
+#include <gsl/util>
 #include <limits>
 #include <map>
 #include <numeric>
@@ -35,7 +36,7 @@ range_scan_node_state::range_scan_node_state(std::queue<std::uint16_t> vbuckets)
 auto
 range_scan_node_state::fetch_vbucket_id() -> std::optional<std::uint16_t>
 {
-  std::lock_guard<std::mutex> const lock{ mutex_ };
+  const std::lock_guard<std::mutex> lock{ mutex_ };
   if (pending_vbuckets_.empty()) {
     return {};
   }
@@ -48,28 +49,28 @@ range_scan_node_state::fetch_vbucket_id() -> std::optional<std::uint16_t>
 void
 range_scan_node_state::notify_stream_ended()
 {
-  std::lock_guard<std::mutex> const lock{ mutex_ };
+  const std::lock_guard<std::mutex> 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_ };
+  const std::lock_guard<std::mutex> 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_ };
+  const std::lock_guard<std::mutex> 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_ };
+  const std::lock_guard<std::mutex> lock{ mutex_ };
   return pending_vbuckets_.size();
 }
 
@@ -79,9 +80,9 @@ range_scan_load_balancer::range_scan_load_balancer(
   : 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++) {
+  for (std::size_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);
+    node_to_vbucket_map[node_id].push(gsl::narrow_cast<std::uint16_t>(vbucket_id));
   }
   for (auto [node_id, vbucket_ids] : node_to_vbucket_map) {
     nodes_.emplace(node_id, std::move(vbucket_ids));
@@ -97,7 +98,7 @@ range_scan_load_balancer::seed(std::uint64_t seed)
 auto
 range_scan_load_balancer::select_vbucket() -> std::optional<std::uint16_t>
 {
-  std::lock_guard<std::mutex> const lock{ select_vbucket_mutex_ };
+  const std::lock_guard<std::mutex> lock{ select_vbucket_mutex_ };
 
   auto min_stream_count = std::numeric_limits<std::uint16_t>::max();
   std::optional<std::int16_t> selected_node_id{};
@@ -112,7 +113,7 @@ range_scan_load_balancer::select_vbucket() -> std::optional<std::uint16_t>
   std::shuffle(iterators.begin(), iterators.end(), gen);
 
   for (auto it : iterators) {
-    auto& [node_id, node_status] = *it;
+    auto& [node_id, node_status] = *it; // cppcheck-suppress variableScope
     auto stream_count = node_status.active_stream_count();
 
     if (stream_count < min_stream_count && node_status.pending_vbucket_count() > 0) {

data/ext/couchbase/core/range_scan_load_balancer.hxx

@@ -15,7 +15,6 @@
  *   limitations under the License.
  */
 
-#include "core/logger/logger.hxx"
 #include "core/topology/configuration.hxx"
 
 #include <mutex>
@@ -26,7 +25,7 @@ namespace couchbase::core
 class range_scan_node_state
 {
 public:
-  range_scan_node_state(std::queue<std::uint16_t> vbuckets);
+  explicit range_scan_node_state(std::queue<std::uint16_t> vbuckets);
 
   auto fetch_vbucket_id() -> std::optional<std::uint16_t>;
   void notify_stream_ended();
@@ -43,8 +42,8 @@ private:
 class range_scan_load_balancer
 {
 public:
-  range_scan_load_balancer(const topology::configuration::vbucket_map& vbucket_map,
-                           std::optional<std::uint64_t> seed = {});
+  explicit range_scan_load_balancer(const topology::configuration::vbucket_map& vbucket_map,
+                                    std::optional<std::uint64_t> seed = {});
 
   void seed(std::uint64_t seed);