couchbase 4.4.1-dev.2 → 4.4.2

package/deps/couchbase-cxx-client/core/crypto/cbcrypto.h

@@ -27,8 +27,8 @@ enum class Algorithm {
   ALG_SHA512
 };
 
-bool
-isSupported(Algorithm algorithm);
+auto
+isSupported(Algorithm algorithm) -> bool;
 
 const int SHA1_DIGEST_SIZE = 20;
 const int SHA256_DIGEST_SIZE = 32;
@@ -41,8 +41,8 @@ const int SHA512_DIGEST_SIZE = 64;
  * @throws std::invalid_argument - unsupported algorithm
  *         std::runtime_error - Failures generating the HMAC
  */
-std::string
-CBC_HMAC(Algorithm algorithm, std::string_view key, std::string_view data);
+auto
+CBC_HMAC(Algorithm algorithm, std::string_view key, std::string_view data) -> std::string;
 
 /**
  * Generate a PBKDF2_HMAC digest of the key and data by using the given
@@ -51,24 +51,24 @@ CBC_HMAC(Algorithm algorithm, std::string_view key, std::string_view data);
  * @throws std::invalid_argument - unsupported algorithm
  *         std::runtime_error - Failures generating the HMAC
  */
-std::string
+auto
 PBKDF2_HMAC(Algorithm algorithm,
             const std::string& pass,
             std::string_view salt,
-            unsigned int iterationCount);
+            unsigned int iterationCount) -> std::string;
 
 /**
  * Generate a digest by using the requested algorithm
  */
-std::string
-digest(Algorithm algorithm, std::string_view data);
+auto
+digest(Algorithm algorithm, std::string_view data) -> std::string;
 
 enum class Cipher {
   AES_256_cbc
 };
 
-Cipher
-to_cipher(const std::string& str);
+auto
+to_cipher(const std::string& str) -> Cipher;
 
 /**
  * Encrypt the specified data by using a given cipher
@@ -79,8 +79,9 @@ to_cipher(const std::string& str);
  * @param data The Pointer to the data to encrypt
  * @return The encrypted data
  */
-std::string
-encrypt(Cipher cipher, std::string_view key, std::string_view iv, std::string_view data);
+auto
+encrypt(Cipher cipher, std::string_view key, std::string_view iv, std::string_view data)
+  -> std::string;
 
 /**
  * Decrypt the specified data by using a given cipher
@@ -91,7 +92,8 @@ encrypt(Cipher cipher, std::string_view key, std::string_view iv, std::string_vi
  * @param data The data to decrypt
  * @return The decrypted data
  */
-std::string
-decrypt(Cipher cipher, std::string_view key, std::string_view iv, std::string_view data);
+auto
+decrypt(Cipher cipher, std::string_view key, std::string_view iv, std::string_view data)
+  -> std::string;
 
 } // namespace couchbase::core::crypto

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

@@ -48,12 +48,12 @@ enum class endpoint_state {
 };
 
 struct endpoint_diag_info {
-  service_type type;
+  service_type type{};
   std::string id;
   std::optional<std::chrono::microseconds> last_activity{};
   std::string remote;
   std::string local;
-  endpoint_state state;
+  endpoint_state state{};
   /** serialized as "namespace" */
   std::optional<std::string> bucket{};
   std::optional<std::string> details{};
@@ -74,7 +74,7 @@ enum class ping_state {
 };
 
 struct endpoint_ping_info {
-  service_type type;
+  service_type type{};
   std::string id;
   std::chrono::microseconds latency;
   std::string remote;

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

@@ -22,7 +22,7 @@
 #include "diagnostics_fmt.hxx"
 #include "service_type_fmt.hxx"
 
-#include <tao/json/forward.hpp>
+#include <tao/json/value.hpp>
 
 namespace tao::json
 {

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

@@ -16,6 +16,12 @@
 #include "dispatcher.hxx"
 
 #include "cluster.hxx"
+#include "core/core_sdk_shim.hxx"
+
+#include <memory>
+#include <string>
+#include <system_error>
+#include <utility>
 
 namespace couchbase::core
 {
@@ -24,11 +30,13 @@ dispatcher::dispatcher(std::string bucket_name, core_sdk_shim shim)
   , shim_{ std::move(shim) }
 {
 }
+
 auto
 dispatcher::direct_dispatch(std::shared_ptr<mcbp::queue_request> req) const -> std::error_code
 {
   return shim_.cluster.direct_dispatch(bucket_name_, std::move(req));
 }
+
 auto
 dispatcher::direct_re_queue(std::shared_ptr<mcbp::queue_request> req,
                             bool is_retry) const -> std::error_code

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

@@ -20,15 +20,25 @@
 #include "core/utils/binary.hxx"
 #include "core/utils/unsigned_leb128.hxx"
 
-#include <fmt/core.h>
+#include <fmt/format.h>
 
 #include <algorithm>
-#include <stdexcept>
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
 
 namespace couchbase::core
 {
-static bool
-is_valid_collection_char(char ch)
+namespace
+{
+// FIXME(SA): maybe we still need these functions to enforce correctness
+// of the names
+[[maybe_unused]] auto
+is_valid_collection_char(char ch) -> bool
 {
   if (ch >= 'A' && ch <= 'Z') {
     return true;
@@ -49,8 +59,9 @@ is_valid_collection_char(char ch)
   }
 }
 
-bool
-is_valid_collection_element(std::string_view element)
+// FIXME(SA): meaningful function, but is not used anywhere for some reason?
+[[maybe_unused]] auto
+is_valid_collection_element(std::string_view element) -> bool
 {
   if (element.empty() || element.size() > 251) {
     return false;
@@ -58,11 +69,12 @@ is_valid_collection_element(std::string_view element)
   return std::all_of(element.begin(), element.end(), is_valid_collection_char);
 }
 
-[[nodiscard]] static std::string
-compile_collection_path(const std::string& scope, const std::string& collection)
+[[nodiscard]] auto
+compile_collection_path(const std::string& scope, const std::string& collection) -> std::string
 {
   return fmt::format("{}.{}", scope, collection);
 }
+} // namespace
 
 document_id::document_id(std::string bucket, std::string key)
   : bucket_(std::move(bucket))
@@ -83,18 +95,18 @@ document_id::document_id(std::string bucket,
   collection_path_ = compile_collection_path(scope_, collection_);
 }
 
-bool
-document_id::has_default_collection() const
+auto
+document_id::has_default_collection() const -> bool
 {
   return !use_collections_ || collection_path_ == "_default._default";
 }
 
-std::vector<std::byte>
-make_protocol_key(const document_id& id)
+auto
+make_protocol_key(const document_id& id) -> std::vector<std::byte>
 {
   std::vector<std::byte> key{};
   if (id.is_collection_resolved()) {
-    utils::unsigned_leb128<std::uint32_t> encoded(id.collection_uid());
+    const utils::unsigned_leb128<std::uint32_t> encoded(id.collection_uid());
     key.reserve(encoded.size());
     key.insert(key.end(), encoded.begin(), encoded.end());
   }

package/deps/couchbase-cxx-client/core/error_context/analytics_json.hxx

@@ -17,8 +17,8 @@
 
 #pragma once
 
-#include <core/error_context/analytics.hxx>
-#include <core/impl/retry_reason.hxx>
+#include "core/error_context/analytics.hxx"
+#include "core/impl/retry_reason.hxx"
 
 #include <couchbase/error_codes.hxx>
 #include <couchbase/fmt/retry_reason.hxx>

package/deps/couchbase-cxx-client/core/error_context/http_json.hxx

@@ -17,13 +17,12 @@
 
 #pragma once
 
-#include <core/error_context/http.hxx>
-#include <core/impl/retry_reason.hxx>
+#include "core/error_context/http.hxx"
+#include "core/impl/retry_reason.hxx"
 
 #include <couchbase/error_codes.hxx>
 #include <couchbase/fmt/retry_reason.hxx>
 
-#include <tao/json/forward.hpp>
 #include <tao/json/value.hpp>
 
 namespace tao::json

package/deps/couchbase-cxx-client/core/error_context/key_value.cxx

@@ -17,6 +17,15 @@
 
 #include "key_value.hxx"
 
+#include "core/document_id.hxx"
+#include "core/error_context/key_value_error_context.hxx"
+#include "core/error_context/subdocument_error_context.hxx"
+
+#include <cstdint>
+#include <optional>
+#include <system_error>
+#include <utility>
+
 namespace couchbase::core
 {
 

package/deps/couchbase-cxx-client/core/error_context/query_json.hxx

@@ -17,8 +17,8 @@
 
 #pragma once
 
-#include <core/error_context/query.hxx>
-#include <core/impl/retry_reason.hxx>
+#include "core/error_context/query.hxx"
+#include "core/impl/retry_reason.hxx"
 
 #include <couchbase/error_codes.hxx>
 #include <couchbase/fmt/retry_reason.hxx>

package/deps/couchbase-cxx-client/core/error_context/query_public_json.hxx

@@ -18,6 +18,7 @@
 #pragma once
 
 #include "query_error_context.hxx"
+
 #include <couchbase/fmt/retry_reason.hxx>
 
 #include <fmt/format.h>

package/deps/couchbase-cxx-client/core/error_context/search_json.hxx

@@ -17,8 +17,8 @@
 
 #pragma once
 
-#include <core/error_context/search.hxx>
-#include <core/impl/retry_reason.hxx>
+#include "core/error_context/search.hxx"
+#include "core/impl/retry_reason.hxx"
 
 #include <couchbase/error_codes.hxx>
 #include <couchbase/fmt/retry_reason.hxx>

package/deps/couchbase-cxx-client/core/error_context/subdocument_json.hxx

@@ -17,11 +17,10 @@
 
 #pragma once
 
-#include <couchbase/fmt/retry_reason.hxx>
-
-#include "core/fmt/key_value_status_code.hxx"
 #include "subdocument_error_context.hxx"
 
+#include <couchbase/fmt/retry_reason.hxx>
+
 #include <fmt/format.h>
 #include <tao/json/forward.hpp>
 

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

@@ -15,67 +15,171 @@
 
 #include "free_form_http_request.hxx"
 
+#include "io/http_message.hxx"
+#include "io/http_streaming_response.hxx"
+#include "utils/movable_function.hxx"
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <system_error>
+#include <utility>
+
 namespace couchbase::core
 {
 class http_response_impl
 {
 public:
-  auto endpoint() -> std::string
+  http_response_impl() = default;
+
+  explicit http_response_impl(io::http_streaming_response streaming_resp)
+    : streaming_resp_{ std::move(streaming_resp) }
   {
-    return {};
   }
 
-  auto status_code() -> std::uint32_t
+  [[nodiscard]] auto endpoint() const -> std::string
   {
     return {};
   }
 
-  auto content_length() -> std::size_t
+  [[nodiscard]] auto status_code() const -> std::uint32_t
   {
-    return {};
+    return streaming_resp_.status_code();
   }
 
-  auto body() -> std::vector<std::byte>
+  [[nodiscard]] auto content_length() const -> std::size_t
+  {
+    if (streaming_resp_.headers().find("content-length") == streaming_resp_.headers().end()) {
+      return 0;
+    }
+    return std::stoul(streaming_resp_.headers().at("content-length"));
+  }
+
+  void next_body(utils::movable_function<void(std::string, std::error_code)> callback)
+  {
+    return streaming_resp_.body().next(std::move(callback));
+  }
+
+  void close_body()
+  {
+    return streaming_resp_.body().close();
+  }
+
+private:
+  io::http_streaming_response streaming_resp_;
+};
+
+class buffered_http_response_impl
+{
+public:
+  explicit buffered_http_response_impl(io::http_response resp)
+    : resp_{ std::move(resp) }
   {
-    return {};
   }
 
-  auto close() -> std::error_code
+  [[nodiscard]] auto endpoint() const -> std::string
   {
     return {};
   }
+
+  [[nodiscard]] auto status_code() const -> std::uint32_t
+  {
+    return resp_.status_code;
+  }
+
+  [[nodiscard]] auto content_length() const -> std::size_t
+  {
+    if (resp_.headers.find("content-length") == resp_.headers.end()) {
+      return 0;
+    }
+    return std::stoul(resp_.headers.at("content-length"));
+  }
+
+  [[nodiscard]] auto body() const -> std::string
+  {
+    return resp_.body.data();
+  }
+
+private:
+  io::http_response resp_;
 };
 
-http_response::http_response()
-  : impl_{ std::make_shared<http_response_impl>() }
+http_response::http_response(io::http_streaming_response resp)
+  : impl_{ std::make_shared<http_response_impl>(std::move(resp)) }
 {
 }
 
 auto
-http_response::endpoint() -> std::string
+http_response::endpoint() const -> std::string
 {
   return impl_->endpoint();
 }
 auto
-http_response::status_code() -> std::uint32_t
+http_response::status_code() const -> std::uint32_t
 {
   return impl_->status_code();
 }
 auto
-http_response::content_length() -> std::size_t
+http_response::content_length() const -> std::size_t
 {
   return impl_->content_length();
 }
 
 auto
-http_response::body() -> std::vector<std::byte>
+http_response::body() const -> http_response_body
+{
+  return http_response_body{ impl_ };
+}
+
+void
+http_response::close()
+{
+  return impl_->close_body();
+}
+
+http_response_body::http_response_body(std::shared_ptr<http_response_impl> impl)
+  : impl_{ std::move(impl) }
+{
+}
+
+void
+http_response_body::cancel()
+{
+  return impl_->close_body();
+}
+
+void
+http_response_body::next(utils::movable_function<void(std::string, std::error_code)> callback)
+{
+  return impl_->next_body(std::move(callback));
+}
+
+buffered_http_response::buffered_http_response(io::http_response resp)
+  : impl_{ std::make_shared<buffered_http_response_impl>(std::move(resp)) }
 {
-  return impl_->body();
 }
 
 auto
-http_response::close() -> std::error_code
+buffered_http_response::endpoint() const -> std::string
 {
-  return impl_->close();
+  return impl_->endpoint();
+}
+auto
+buffered_http_response::status_code() const -> std::uint32_t
+{
+  return impl_->status_code();
 }
+auto
+buffered_http_response::content_length() const -> std::size_t
+{
+  return impl_->content_length();
+}
+
+auto
+buffered_http_response::body() -> std::string
+{
+  return impl_->body();
+}
+
 } // namespace couchbase::core

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

@@ -15,12 +15,14 @@
 
 #pragma once
 
+#include "service_type.hxx"
 #include "utils/movable_function.hxx"
 
 #include <chrono>
 #include <cinttypes>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 #include <system_error>
 #include <vector>
@@ -36,27 +38,21 @@ class request_span;
 
 namespace couchbase::core
 {
-enum class http_service_type {
-  management,
-  capi,
-  n1ql,
-  search,
-  analytics,
-};
-
 class http_request
 {
 public:
-  http_service_type service;
+  service_type service{};
   std::string method{};
   std::string endpoint{};
   std::string path{};
   std::string username{};
   std::string password{};
-  std::vector<std::byte> body{};
+  std::string body{};
   std::map<std::string, std::string> headers{};
   std::string content_type{};
+  std::string client_context_id{};
   bool is_idempotent{};
+  bool is_read_only{};
   std::string unique_id{};
   std::shared_ptr<couchbase::retry_strategy> retry_strategy{};
   std::chrono::milliseconds timeout{};
@@ -64,22 +60,42 @@ public:
 
   struct {
     std::string user{};
+    std::string undesired_endpoint{};
   } internal{};
 };
 
+namespace io
+{
+class http_streaming_response;
+struct http_response;
+} // namespace io
+
 class http_response_impl;
 
+class http_response_body
+{
+public:
+  explicit http_response_body(std::shared_ptr<http_response_impl> impl);
+
+  void next(utils::movable_function<void(std::string, std::error_code)> callback);
+  void cancel();
+
+private:
+  std::shared_ptr<http_response_impl> impl_;
+};
+
 class http_response
 {
 public:
-  http_response();
+  http_response() = default;
+  explicit http_response(io::http_streaming_response resp);
 
-  auto endpoint() -> std::string;
-  auto status_code() -> std::uint32_t;
-  auto content_length() -> std::size_t;
+  [[nodiscard]] auto endpoint() const -> std::string;
+  [[nodiscard]] auto status_code() const -> std::uint32_t;
+  [[nodiscard]] auto content_length() const -> std::size_t;
 
-  auto body() -> std::vector<std::byte>;
-  auto close() -> std::error_code;
+  [[nodiscard]] auto body() const -> http_response_body;
+  void close();
 
 private:
   std::shared_ptr<http_response_impl> impl_;
@@ -88,4 +104,24 @@ private:
 using free_form_http_request_callback =
   utils::movable_function<void(http_response response, std::error_code ec)>;
 
+class buffered_http_response_impl;
+
+class buffered_http_response
+{
+public:
+  buffered_http_response() = default;
+  explicit buffered_http_response(io::http_response resp);
+
+  [[nodiscard]] auto endpoint() const -> std::string;
+  [[nodiscard]] auto status_code() const -> std::uint32_t;
+  [[nodiscard]] auto content_length() const -> std::size_t;
+
+  [[nodiscard]] auto body() -> std::string;
+
+private:
+  std::shared_ptr<buffered_http_response_impl> impl_;
+};
+
+using buffered_free_form_http_request_callback =
+  utils::movable_function<void(buffered_http_response response, std::error_code ec)>;
 } // namespace couchbase::core