couchbase 4.4.1-dev.2 → 4.4.2

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/scan_result.cxx

@@ -62,7 +62,7 @@ scan_result::scan_result(std::shared_ptr<range_scan_item_iterator> iterator)
 auto
 scan_result::next() const -> tl::expected<range_scan_item, std::error_code>
 {
-  if (impl_) {
+  if (impl_ != nullptr) {
     return impl_->next();
   }
   return tl::unexpected{ errc::common::request_canceled };
@@ -71,7 +71,7 @@ scan_result::next() const -> tl::expected<range_scan_item, std::error_code>
 void
 scan_result::next(utils::movable_function<void(range_scan_item, std::error_code)> callback) const
 {
-  if (impl_) {
+  if (impl_ != nullptr) {
     return impl_->next(std::move(callback));
   }
   callback({}, errc::common::request_canceled);
@@ -80,7 +80,7 @@ scan_result::next(utils::movable_function<void(range_scan_item, std::error_code)
 void
 scan_result::cancel()
 {
-  if (impl_) {
+  if (impl_ != nullptr) {
     return impl_->cancel();
   }
 }
@@ -88,7 +88,7 @@ scan_result::cancel()
 auto
 scan_result::is_cancelled() -> bool
 {
-  if (impl_) {
+  if (impl_ != nullptr) {
     return impl_->is_cancelled();
   }
   return true;

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

@@ -34,7 +34,7 @@ public:
   virtual auto next() -> std::future<tl::expected<range_scan_item, std::error_code>> = 0;
   virtual void next(utils::movable_function<void(range_scan_item, std::error_code)> callback) = 0;
   virtual void cancel() = 0;
-  virtual bool is_cancelled() = 0;
+  virtual auto is_cancelled() -> bool = 0;
 };
 
 class scan_result

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

@@ -22,6 +22,7 @@
 namespace couchbase::core::timeout_defaults
 {
 constexpr std::chrono::milliseconds bootstrap_timeout{ 10'000 };
+constexpr std::chrono::milliseconds dispatch_timeout{ 30'000 };
 
 constexpr std::chrono::milliseconds resolve_timeout{ 2'000 };
 constexpr std::chrono::milliseconds connect_timeout{ 2'000 };

package/deps/couchbase-cxx-client/core/topology/collections_manifest.hxx

@@ -26,20 +26,20 @@ namespace couchbase::core::topology
 {
 struct collections_manifest {
   struct collection {
-    std::uint64_t uid;
+    std::uint64_t uid{};
     std::string name;
     std::int32_t max_expiry{ 0 };
     std::optional<bool> history{};
   };
 
   struct scope {
-    std::uint64_t uid;
+    std::uint64_t uid{};
     std::string name;
     std::vector<collection> collections;
   };
 
   uuid::uuid_t id;
-  std::uint64_t uid;
+  std::uint64_t uid{};
   std::vector<scope> scopes;
 };
 } // namespace couchbase::core::topology

package/deps/couchbase-cxx-client/core/topology/configuration_json.hxx

@@ -111,8 +111,8 @@ struct traits<couchbase::core::topology::configuration> {
         const auto* m = v.find("vBucketServerMap");
         const auto& nodes = v.at("nodes").get_array();
         if (m != nullptr) {
-          size_t index = 0;
           if (const auto* s = m->find("serverList"); s != nullptr && s->is_array()) {
+            std::size_t index = 0;
             for (const auto& j : s->get_array()) {
               couchbase::core::topology::configuration::node n;
               n.index = index++;
@@ -155,7 +155,7 @@ struct traits<couchbase::core::topology::configuration> {
           }
         }
       } else {
-        size_t index = 0;
+        std::size_t index = 0;
         for (const auto& node : v.at("nodes").get_array()) {
           couchbase::core::topology::configuration::node n;
           n.index = index++;

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);
   }
 }
 

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

@@ -40,7 +40,7 @@ public:
 
   auto start_span(std::string name, std::shared_ptr<couchbase::tracing::request_span> parent)
     -> std::shared_ptr<couchbase::tracing::request_span> override;
-  void report(std::shared_ptr<threshold_logging_span> span);
+  void report(const std::shared_ptr<threshold_logging_span>& span);
   void start() override;
   void stop() override;
 

package/deps/couchbase-cxx-client/core/transactions/active_transaction_record.cxx

@@ -54,12 +54,12 @@ parse_mutation_cas(const std::string& cas) -> std::uint64_t
 
   std::uint64_t val = stoull(cas, nullptr, 16);
   /* byteswap */
-  std::size_t ii;
+  std::size_t ii = 0;
   std::uint64_t ret = 0;
   for (ii = 0; ii < sizeof(std::uint64_t); ii++) {
-    ret <<= 8ull;
-    ret |= val & 0xffull;
-    val >>= 8ull;
+    ret <<= 8ULL;
+    ret |= val & 0xffULL;
+    val >>= 8ULL;
   }
   return ret / 1000000;
 }
@@ -94,7 +94,7 @@ map_to_atr(const operations::lookup_in_response& resp) -> active_transaction_rec
       if (const auto* compat = val.find(ATR_FIELD_FORWARD_COMPAT); compat != nullptr) {
         forward_compat = *compat;
       }
-      std::optional<std::uint32_t> expires_after_msec =
+      const std::optional<std::uint32_t> expires_after_msec =
         std::max(val.optional<std::int32_t>(ATR_FIELD_EXPIRES_AFTER_MSECS).value_or(0), 0);
       entries.emplace_back(
         resp.ctx.bucket(),
@@ -117,10 +117,9 @@ map_to_atr(const operations::lookup_in_response& resp) -> active_transaction_rec
         val.optional<std::string>(ATR_FIELD_DURABILITY_LEVEL));
     }
   }
-  return active_transaction_record(
-    { resp.ctx.bucket(), resp.ctx.scope(), resp.ctx.collection(), resp.ctx.id() },
-    resp.cas.value(),
-    std::move(entries));
+  return { { resp.ctx.bucket(), resp.ctx.scope(), resp.ctx.collection(), resp.ctx.id() },
+           resp.cas.value(),
+           std::move(entries) };
 }
 
 auto
@@ -151,28 +150,28 @@ active_transaction_record::get_atr(
       lookup_in_specs::get(subdoc::lookup_in_macro::vbucket).xattr(),
     }
       .specs();
-  cluster.execute(req,
-                  [atr_id, cb = std::move(cb)](core::operations::lookup_in_response resp) mutable {
-                    try {
-                      if (resp.ctx.ec() == couchbase::errc::key_value::document_not_found) {
-                        // that's ok, just return an empty one.
-                        return cb({}, {});
-                      }
-                      if (!resp.ctx.ec()) {
-                        // success
-                        return cb(resp.ctx.ec(), map_to_atr(resp));
-                      }
-                      // otherwise, raise an error.
-                      cb(resp.ctx.ec(), {});
-                    } catch (const std::exception&) {
-                      // ok - we have a corrupt ATR.  The question is:  what should we return
-                      // for an error? Turns out, we don't much care in the code what this error
-                      // is.  Since we cannot parse the atr, but there wasn't an error, lets
-                      // select this one for now.
-                      // TODO: consider a different mechanism - not an error_code.  Or, perhaps
-                      // we need txn-specific error codes?
-                      cb(couchbase::errc::key_value::path_invalid, std::nullopt);
-                    }
-                  });
+  cluster.execute(
+    req, [atr_id, cb = std::move(cb)](const core::operations::lookup_in_response& resp) mutable {
+      try {
+        if (resp.ctx.ec() == couchbase::errc::key_value::document_not_found) {
+          // that's ok, just return an empty one.
+          return cb({}, {});
+        }
+        if (!resp.ctx.ec()) {
+          // success
+          return cb(resp.ctx.ec(), map_to_atr(resp));
+        }
+        // otherwise, raise an error.
+        cb(resp.ctx.ec(), {});
+      } catch (const std::exception&) {
+        // ok - we have a corrupt ATR.  The question is:  what should we return
+        // for an error? Turns out, we don't much care in the code what this error
+        // is.  Since we cannot parse the atr, but there wasn't an error, lets
+        // select this one for now.
+        // TODO(SA): consider a different mechanism - not an error_code.  Or, perhaps
+        // we need txn-specific error codes?
+        cb(couchbase::errc::key_value::path_invalid, std::nullopt);
+      }
+    });
 }
 } // namespace couchbase::core::transactions

package/deps/couchbase-cxx-client/core/transactions/async_attempt_context.hxx

@@ -16,12 +16,12 @@
 #pragma once
 
 #include "core/error_context/subdocument_error_context.hxx"
-#include "couchbase/cluster.hxx"
-#include "couchbase/transactions/transaction_query_options.hxx"
+#include "core/operations/document_query.hxx"
 #include "exceptions.hxx"
 #include "transaction_get_result.hxx"
 
-#include "core/operations/document_query.hxx"
+#include <couchbase/transactions/transaction_query_options.hxx>
+
 #include <future>
 #include <optional>
 #include <string>