couchbase 3.7.0 → 3.8.1

data/ext/couchbase/couchbase/collection.hxx

@@ -35,6 +35,8 @@
 #include <couchbase/lookup_in_specs.hxx>
 #include <couchbase/mutate_in_options.hxx>
 #include <couchbase/mutate_in_specs.hxx>
+#include <couchbase/node_id_for_options.hxx>
+#include <couchbase/node_ids_options.hxx>
 #include <couchbase/query_options.hxx>
 #include <couchbase/remove_options.hxx>
 #include <couchbase/replace_options.hxx>
@@ -463,8 +465,10 @@ public:
               const upsert_options& options,
               upsert_handler&& handler) const
   {
-    return upsert(
-      std::move(document_id), encode_document<Transcoder>(document), options, std::move(handler));
+    return upsert(std::move(document_id),
+                  create_encode_fn<Transcoder, Document>(std::move(document)),
+                  options,
+                  std::move(handler));
   }
 
   /**
@@ -506,11 +510,12 @@ public:
    */
   template<typename Transcoder = codec::default_json_transcoder, typename Document>
   [[nodiscard]] auto upsert(std::string document_id,
-                            const Document& document,
+                            Document document,
                             const upsert_options& options = {}) const
     -> std::future<std::pair<error, mutation_result>>
   {
-    return upsert(std::move(document_id), encode_document<Transcoder>(document), options);
+    return upsert(
+      std::move(document_id), create_encode_fn<Transcoder, Document>(std::move(document)), options);
   }
 
   /**
@@ -559,8 +564,10 @@ public:
               const insert_options& options,
               insert_handler&& handler) const
   {
-    return insert(
-      std::move(document_id), encode_document<Transcoder>(document), options, std::move(handler));
+    return insert(std::move(document_id),
+                  create_encode_fn<Transcoder, Document>(std::move(document)),
+                  options,
+                  std::move(handler));
   }
 
   /**
@@ -605,11 +612,12 @@ public:
            typename Document,
            std::enable_if_t<!std::is_same_v<codec::encoded_value, Document>, bool> = true>
   [[nodiscard]] auto insert(std::string document_id,
-                            const Document& document,
+                            Document document,
                             const insert_options& options = {}) const
     -> std::future<std::pair<error, mutation_result>>
   {
-    return insert(std::move(document_id), encode_document<Transcoder>(document), options);
+    return insert(
+      std::move(document_id), create_encode_fn<Transcoder, Document>(std::move(document)), options);
   }
 
   /**
@@ -660,8 +668,10 @@ public:
                const replace_options& options,
                replace_handler&& handler) const
   {
-    return replace(
-      std::move(document_id), encode_document<Transcoder>(document), options, std::move(handler));
+    return replace(std::move(document_id),
+                   create_encode_fn<Transcoder, Document>(std::move(document)),
+                   options,
+                   std::move(handler));
   }
 
   /**
@@ -708,11 +718,12 @@ public:
            typename Document,
            std::enable_if_t<!std::is_same_v<codec::encoded_value, Document>, bool> = true>
   [[nodiscard]] auto replace(std::string document_id,
-                             const Document& document,
+                             Document document,
                              const replace_options& options = {}) const
     -> std::future<std::pair<error, mutation_result>>
   {
-    return replace(std::move(document_id), encode_document<Transcoder>(document), options);
+    return replace(
+      std::move(document_id), create_encode_fn<Transcoder, Document>(std::move(document)), options);
   }
 
   /**
@@ -1081,6 +1092,77 @@ public:
   [[nodiscard]] auto scan(const scan_type& scan_type, const scan_options& options = {}) const
     -> std::future<std::pair<error, scan_result>>;
 
+  /**
+   * Resolves a document key to the identity of the cluster node that currently
+   * owns it, using the client-side vBucket map (no network round-trip).
+   *
+   * @param document_id the document id to resolve
+   * @param options options to customize the request
+   * @param handler the handler that receives the result
+   *
+   * @since 1.3.2
+   * @uncommitted
+   */
+  void node_id_for(std::string document_id,
+                   const node_id_for_options& options,
+                   node_id_for_handler&& handler) const;
+
+  /**
+   * Resolves a document key to the identity of the cluster node that currently
+   * owns it, using the client-side vBucket map (no network round-trip).
+   *
+   * @param document_id the document id to resolve
+   * @param options options to customize the request
+   * @return future carrying the error (if any) and node_id
+   *
+   * @since 1.3.2
+   * @uncommitted
+   */
+  [[nodiscard]] auto node_id_for(std::string document_id,
+                                 const node_id_for_options& options = {}) const
+    -> std::future<std::pair<error, node_id>>;
+
+  /**
+   * Returns the set of cluster nodes that currently serve key-value
+   * traffic for this collection's bucket, drawn from the client-side
+   * topology snapshot (no network round-trip).
+   *
+   * Each entry corresponds to one cluster node and is the same node_id
+   * the SDK reports on KV results and errors that touched that node, so
+   * the returned set is directly comparable to the keys of any
+   * application-side state that is keyed by node_id (e.g. a per-node
+   * circuit breaker registry). A periodic sweep that diffs the
+   * registry's keys against this set is the canonical way to retire
+   * tracker state for a node that has been removed from the cluster
+   * topology.
+   *
+   * Nodes that do not expose a key-value port for the configured
+   * transport (TLS or plain) are excluded from the returned set, since
+   * they do not serve KV operations and therefore have no meaningful
+   * identity from the SDK's point of view.
+   *
+   * @param options options to customize the request
+   * @param handler the handler that receives the result
+   *
+   * @since 1.3.2
+   * @uncommitted
+   */
+  void node_ids(const node_ids_options& options, node_ids_handler&& handler) const;
+
+  /**
+   * Returns the set of cluster nodes that currently serve key-value
+   * traffic for this collection's bucket, drawn from the client-side
+   * topology snapshot (no network round-trip).
+   *
+   * @param options options to customize the request
+   * @return future carrying the error (if any) and the set of node_ids
+   *
+   * @since 1.3.2
+   * @uncommitted
+   */
+  [[nodiscard]] auto node_ids(const node_ids_options& options = {}) const
+    -> std::future<std::pair<error, std::vector<node_id>>>;
+
   [[nodiscard]] auto query_indexes() const -> collection_query_index_manager;
 
 private:
@@ -1090,15 +1172,51 @@ private:
   [[nodiscard]] auto crypto_manager() const -> const std::shared_ptr<crypto::manager>&;
 
   template<typename Transcoder, typename Document>
-  [[nodiscard]] auto encode_document(const Document& document) const -> codec::encoded_value
+  [[nodiscard]] auto create_encode_fn(Document document) const
+    -> std::function<codec::encoded_value()>
   {
     if constexpr (codec::is_crypto_transcoder_v<Transcoder>) {
-      return Transcoder::encode(document, crypto_manager());
+      return [crypto_manager = crypto_manager(),
+              document = std::move(document)]() -> codec::encoded_value {
+        return Transcoder::encode(document, crypto_manager);
+      };
     } else {
-      return Transcoder::encode(document);
+      return [document = std::move(document)]() -> codec::encoded_value {
+        return Transcoder::encode(document);
+      };
     }
   }
 
+  void replace(std::string document_id,
+               std::function<codec::encoded_value()> document_fn,
+               const replace_options& options,
+               replace_handler&& handler) const;
+
+  auto replace(std::string document_id,
+               std::function<codec::encoded_value()> document_fn,
+               const replace_options& options) const
+    -> std::future<std::pair<error, mutation_result>>;
+
+  void upsert(std::string document_id,
+              std::function<codec::encoded_value()> document_fn,
+              const upsert_options& options,
+              upsert_handler&& handler) const;
+
+  auto upsert(std::string document_id,
+              std::function<codec::encoded_value()> document_fn,
+              const upsert_options& options) const
+    -> std::future<std::pair<error, mutation_result>>;
+
+  void insert(std::string document_id,
+              std::function<codec::encoded_value()> document_fn,
+              const insert_options& options,
+              insert_handler&& handler) const;
+
+  auto insert(std::string document_id,
+              std::function<codec::encoded_value()> document_fn,
+              const insert_options& options) const
+    -> std::future<std::pair<error, mutation_result>>;
+
   collection(core::cluster core,
              std::string_view bucket_name,
              std::string_view scope_name,

data/ext/couchbase/couchbase/error.hxx

@@ -18,6 +18,7 @@
 #pragma once
 
 #include <couchbase/error_context.hxx>
+#include <couchbase/node_id.hxx>
 
 #include <memory>
 #include <optional>
@@ -32,12 +33,26 @@ public:
   error() = default;
   error(std::error_code ec, std::string message = {}, error_context ctx = {});
   error(std::error_code ec, std::string message, error_context ctx, error cause);
+  error(std::error_code ec, std::string message, error_context ctx, couchbase::node_id node_id);
 
   [[nodiscard]] auto ec() const -> std::error_code;
   [[nodiscard]] auto message() const -> const std::string&;
   [[nodiscard]] auto ctx() const -> const error_context&;
   [[nodiscard]] auto cause() const -> std::optional<error>;
 
+  /**
+   * Returns the identity of the cluster node where the error occurred.
+   *
+   * The returned node_id is default-constructed (falsy) when the node
+   * could not be determined (e.g. for non-KV errors).
+   *
+   * @return identity of the node that returned the error
+   *
+   * @since 1.3.2
+   * @uncommitted
+   */
+  [[nodiscard]] auto node_id() const -> const couchbase::node_id&;
+
   explicit operator bool() const;
   auto operator==(const error& other) const -> bool;
 
@@ -46,6 +61,7 @@ private:
   std::string message_{};
   error_context ctx_{};
   std::shared_ptr<error> cause_{};
+  couchbase::node_id node_id_{};
 };
 
 } // namespace couchbase

data/ext/couchbase/couchbase/error_codes.hxx

@@ -24,41 +24,41 @@ namespace couchbase
 #ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
 namespace core::impl
 {
-const std::error_category&
-common_category() noexcept;
+auto
+common_category() noexcept -> const std::error_category&;
 
-const std::error_category&
-key_value_category() noexcept;
+auto
+key_value_category() noexcept -> const std::error_category&;
 
-const std::error_category&
-query_category() noexcept;
+auto
+query_category() noexcept -> const std::error_category&;
 
-const std::error_category&
-analytics_category() noexcept;
+auto
+analytics_category() noexcept -> const std::error_category&;
 
-const std::error_category&
-search_category() noexcept;
+auto
+search_category() noexcept -> const std::error_category&;
 
-const std::error_category&
-view_category() noexcept;
+auto
+view_category() noexcept -> const std::error_category&;
 
-const std::error_category&
-management_category() noexcept;
+auto
+management_category() noexcept -> const std::error_category&;
 
-const std::error_category&
-field_level_encryption_category() noexcept;
+auto
+field_level_encryption_category() noexcept -> const std::error_category&;
 
-const std::error_category&
-network_category() noexcept;
+auto
+network_category() noexcept -> const std::error_category&;
 
-const std::error_category&
-streaming_json_lexer_category() noexcept;
+auto
+streaming_json_lexer_category() noexcept -> const std::error_category&;
 
-const std::error_category&
-transaction_category() noexcept;
+auto
+transaction_category() noexcept -> const std::error_category&;
 
-const std::error_category&
-transaction_op_category() noexcept;
+auto
+transaction_op_category() noexcept -> const std::error_category&;
 
 } // namespace core::impl
 #endif
@@ -1151,74 +1151,74 @@ enum class transaction_op {
 };
 
 #ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-inline std::error_code
-make_error_code(common e) noexcept
+inline auto
+make_error_code(common e) noexcept -> std::error_code
 {
   return { static_cast<int>(e), core::impl::common_category() };
 }
 
-inline std::error_code
-make_error_code(key_value e)
+inline auto
+make_error_code(key_value e) -> std::error_code
 {
   return { static_cast<int>(e), core::impl::key_value_category() };
 }
 
-inline std::error_code
-make_error_code(query e)
+inline auto
+make_error_code(query e) -> std::error_code
 {
   return { static_cast<int>(e), core::impl::query_category() };
 }
 
-inline std::error_code
-make_error_code(search e)
+inline auto
+make_error_code(search e) -> std::error_code
 {
   return { static_cast<int>(e), core::impl::search_category() };
 }
 
-inline std::error_code
-make_error_code(view e)
+inline auto
+make_error_code(view e) -> std::error_code
 {
   return { static_cast<int>(e), core::impl::view_category() };
 }
 
-inline std::error_code
-make_error_code(analytics e)
+inline auto
+make_error_code(analytics e) -> std::error_code
 {
   return { static_cast<int>(e), core::impl::analytics_category() };
 }
 
-inline std::error_code
-make_error_code(management e)
+inline auto
+make_error_code(management e) -> std::error_code
 {
   return { static_cast<int>(e), core::impl::management_category() };
 }
 
-inline std::error_code
-make_error_code(network e)
+inline auto
+make_error_code(network e) -> std::error_code
 {
   return { static_cast<int>(e), core::impl::network_category() };
 }
 
-inline std::error_code
-make_error_code(field_level_encryption e)
+inline auto
+make_error_code(field_level_encryption e) -> std::error_code
 {
   return { static_cast<int>(e), core::impl::field_level_encryption_category() };
 }
 
-inline std::error_code
-make_error_code(streaming_json_lexer e)
+inline auto
+make_error_code(streaming_json_lexer e) -> std::error_code
 {
   return { static_cast<int>(e), core::impl::streaming_json_lexer_category() };
 }
 
-inline std::error_code
-make_error_code(transaction e)
+inline auto
+make_error_code(transaction e) -> std::error_code
 {
   return { static_cast<int>(e), core::impl::transaction_category() };
 }
 
-inline std::error_code
-make_error_code(transaction_op e)
+inline auto
+make_error_code(transaction_op e) -> std::error_code
 {
   return { static_cast<int>(e), core::impl::transaction_op_category() };
 }

data/ext/couchbase/couchbase/jwt_authenticator.hxx

@@ -0,0 +1,52 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-Present 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
+{
+/**
+ * A JWT authenticator which uses a JSON Web Token (JWT) to authenticate with the cluster.
+ *
+ * @since 1.3.0
+ * @uncommitted
+ */
+class jwt_authenticator
+{
+public:
+  /**
+   * Creates a JWT authenticator with the provided token.
+   *
+   * @param token the JWT
+   *
+   * @since 1.3.0
+   * @uncommitted
+   */
+  explicit jwt_authenticator(std::string token)
+    : token_{ std::move(token) }
+  {
+  }
+
+private:
+  std::string token_;
+
+  friend class cluster_options;
+  friend class cluster;
+};
+} // namespace couchbase

data/ext/couchbase/couchbase/metrics/meter.hxx

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include <cstdint>
 #include <map>
 #include <memory>
 #include <string>
@@ -33,7 +34,7 @@ public:
   auto operator=(value_recorder&& other) -> value_recorder& = default;
   virtual ~value_recorder() = default;
 
-  virtual void record_value(int64_t value) = 0;
+  virtual void record_value(std::int64_t value) = 0;
 };
 
 class meter