couchbase 3.5.6 → 3.6.0

data/ext/couchbase/core/transactions/staged_mutation.hxx

@@ -37,23 +37,15 @@ enum class staged_mutation_type {
 
 class staged_mutation
 {
-private:
-  transaction_get_result doc_;
-  staged_mutation_type type_;
-  codec::encoded_value content_;
-  std::string operation_id_;
-
 public:
-  staged_mutation(transaction_get_result doc,
-                  codec::encoded_value content,
-                  staged_mutation_type type,
-                  std::string operation_id = uid_generator::next())
-    : doc_(std::move(doc))
-    , type_(type)
-    , content_(std::move(content))
-    , operation_id_(std::move(operation_id))
-  {
-  }
+  staged_mutation(staged_mutation_type type,
+                  document_id doc_id,
+                  cas cas,
+                  std::optional<codec::binary> staged_content,
+                  std::uint32_t staged_flags,
+                  std::uint32_t current_user_flags,
+                  std::optional<document_metadata> doc_metadata,
+                  std::string operation_id = uid_generator::next());
 
   ~staged_mutation() = default;
   staged_mutation(const staged_mutation&) = delete;
@@ -61,68 +53,28 @@ public:
   auto operator=(const staged_mutation&) -> staged_mutation& = delete;
   auto operator=(staged_mutation&&) -> staged_mutation& = default;
 
-  [[nodiscard]] auto id() const -> const core::document_id&
-  {
-    return doc_.id();
-  }
-
-  [[nodiscard]] auto doc() const -> const transaction_get_result&
-  {
-    return doc_;
-  }
-
-  [[nodiscard]] auto doc() -> transaction_get_result&
-  {
-    return doc_;
-  }
-
-  [[nodiscard]] auto type() const -> const staged_mutation_type&
-  {
-    return type_;
-  }
-
-  void type(staged_mutation_type& type)
-  {
-    type_ = type;
-  }
-
+  [[nodiscard]] auto id() const -> const document_id&;
+  [[nodiscard]] auto cas() const -> const couchbase::cas&;
+  [[nodiscard]] auto type() const -> const staged_mutation_type&;
   [[nodiscard]] auto is_staged_binary() const -> bool;
+  [[nodiscard]] auto staged_content() const -> const std::optional<codec::binary>&;
+  [[nodiscard]] auto staged_flags() const -> std::uint32_t;
+  [[nodiscard]] auto current_user_flags() const -> std::uint32_t;
+  [[nodiscard]] auto doc_metadata() const -> const std::optional<document_metadata>&;
+  [[nodiscard]] auto operation_id() const -> const std::string&;
+  [[nodiscard]] auto type_as_string() const -> std::string;
+
+  void cas(couchbase::cas cas);
 
-  [[nodiscard]] auto content() const -> const codec::encoded_value&
-  {
-    return content_;
-  }
-
-  /**
-   * @return current user flags before the staging of the document
-   */
-  [[nodiscard]] auto current_user_flags() const -> std::uint32_t
-  {
-    return doc_.content().flags;
-  }
-
-  void content(const codec::encoded_value& content)
-  {
-    content_ = content;
-  }
-
-  [[nodiscard]] auto type_as_string() const -> std::string
-  {
-    switch (type_) {
-      case staged_mutation_type::INSERT:
-        return "INSERT";
-      case staged_mutation_type::REMOVE:
-        return "REMOVE";
-      case staged_mutation_type::REPLACE:
-        return "REPLACE";
-    }
-    throw std::runtime_error("unknown type of staged mutation");
-  }
-
-  [[nodiscard]] auto operation_id() const -> const std::string&
-  {
-    return operation_id_;
-  }
+private:
+  staged_mutation_type type_;
+  document_id doc_id_;
+  couchbase::cas cas_;
+  std::optional<codec::binary> staged_content_;
+  std::uint32_t staged_flags_;
+  std::uint32_t current_user_flags_;
+  std::optional<document_metadata> doc_metadata_;
+  std::string operation_id_;
 };
 
 struct unstaging_state {

data/ext/couchbase/core/transactions/transaction_context.cxx

@@ -91,6 +91,12 @@ transaction_context::remaining() const -> std::chrono::nanoseconds
   return config_.timeout - expired_nanos;
 }
 
+auto
+transaction_context::expiry_time() const -> std::chrono::steady_clock::time_point
+{
+  return start_time_client_ + config_.timeout;
+}
+
 [[nodiscard]] auto
 transaction_context::has_expired_client_side() -> bool
 {
@@ -175,6 +181,33 @@ transaction_context::get_replica_from_preferred_server_group(const core::documen
   throw transaction_operation_failed(FAIL_OTHER, "no current attempt context");
 }
 
+void
+transaction_context::get_multi_replicas_from_preferred_server_group(
+  const std::vector<core::document_id>& ids,
+  transaction_get_multi_replicas_from_preferred_server_group_mode mode,
+  std::function<
+    void(std::exception_ptr,
+         std::optional<transaction_get_multi_replicas_from_preferred_server_group_result>)>&& cb)
+{
+  if (current_attempt_context_) {
+    return current_attempt_context_->get_multi_replicas_from_preferred_server_group(
+      ids, mode, std::move(cb));
+  }
+  throw transaction_operation_failed(FAIL_OTHER, "no current attempt context");
+}
+
+void
+transaction_context::get_multi(
+  const std::vector<core::document_id>& ids,
+  transaction_get_multi_mode mode,
+  std::function<void(std::exception_ptr, std::optional<transaction_get_multi_result>)>&& cb)
+{
+  if (current_attempt_context_) {
+    return current_attempt_context_->get_multi(ids, mode, std::move(cb));
+  }
+  throw transaction_operation_failed(FAIL_OTHER, "no current attempt context");
+}
+
 void
 transaction_context::get_optional(const core::document_id& id, async_attempt_context::Callback&& cb)
 {

data/ext/couchbase/core/transactions/transaction_get_multi_mode.hxx

@@ -0,0 +1,28 @@
+/*
+ *     Copyright 2021-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 <cstdint>
+
+namespace couchbase::core::transactions
+{
+enum class transaction_get_multi_mode : std::uint8_t {
+  prioritise_latency,
+  disable_read_skew_detection,
+  prioritise_read_skew_detection,
+};
+
+} // namespace couchbase::core::transactions

data/ext/couchbase/core/transactions/transaction_get_multi_replicas_from_preferred_server_group_mode.hxx

@@ -0,0 +1,27 @@
+/*
+ *     Copyright 2021-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 <cstdint>
+
+namespace couchbase::core::transactions
+{
+enum class transaction_get_multi_replicas_from_preferred_server_group_mode : std::uint8_t {
+  prioritise_latency,
+  disable_read_skew_detection,
+  prioritise_read_skew_detection,
+};
+} // namespace couchbase::core::transactions

data/ext/couchbase/core/transactions/transaction_get_multi_replicas_from_preferred_server_group_result.hxx

@@ -0,0 +1,71 @@
+/*
+ *     Copyright 2021-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 <couchbase/codec/default_json_transcoder.hxx>
+
+#include <gsl/assert>
+
+#include <optional>
+#include <vector>
+
+namespace couchbase::core::transactions
+{
+class transaction_get_multi_replicas_from_preferred_server_group_result
+{
+public:
+  transaction_get_multi_replicas_from_preferred_server_group_result() = default;
+  ~transaction_get_multi_replicas_from_preferred_server_group_result() = default;
+  transaction_get_multi_replicas_from_preferred_server_group_result(
+    const transaction_get_multi_replicas_from_preferred_server_group_result&) = default;
+  transaction_get_multi_replicas_from_preferred_server_group_result(
+    transaction_get_multi_replicas_from_preferred_server_group_result&&) = default;
+  auto operator=(const transaction_get_multi_replicas_from_preferred_server_group_result&)
+    -> transaction_get_multi_replicas_from_preferred_server_group_result& = default;
+  auto operator=(transaction_get_multi_replicas_from_preferred_server_group_result&&)
+    -> transaction_get_multi_replicas_from_preferred_server_group_result& = default;
+
+  explicit transaction_get_multi_replicas_from_preferred_server_group_result(
+    std::vector<std::optional<codec::encoded_value>> content)
+    : content_{ std::move(content) }
+  {
+  }
+
+  [[nodiscard]] auto content(std::size_t spec_index) const -> const codec::encoded_value&
+  {
+    Expects(exists(spec_index));
+    return content_[spec_index].value();
+  }
+
+  [[nodiscard]] auto exists(std::size_t spec_index) const -> bool
+  {
+    return spec_index >= content_.size() && content_[spec_index].has_value();
+  }
+
+  [[nodiscard]] auto content() const -> const std::vector<std::optional<codec::encoded_value>>&
+  {
+    return content_;
+  }
+
+  [[nodiscard]] auto content() -> std::vector<std::optional<codec::encoded_value>>&&
+  {
+    return std::move(content_);
+  }
+
+private:
+  std::vector<std::optional<codec::encoded_value>> content_;
+};
+} // namespace couchbase::core::transactions

data/ext/couchbase/core/transactions/transaction_get_multi_result.hxx

@@ -0,0 +1,66 @@
+/*
+ *     Copyright 2021-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 <couchbase/codec/default_json_transcoder.hxx>
+
+#include <gsl/assert>
+
+#include <optional>
+#include <vector>
+
+namespace couchbase::core::transactions
+{
+class transaction_get_multi_result
+{
+public:
+  transaction_get_multi_result() = default;
+  ~transaction_get_multi_result() = default;
+  transaction_get_multi_result(const transaction_get_multi_result&) = default;
+  transaction_get_multi_result(transaction_get_multi_result&&) = default;
+  auto operator=(const transaction_get_multi_result&) -> transaction_get_multi_result& = default;
+  auto operator=(transaction_get_multi_result&&) -> transaction_get_multi_result& = default;
+
+  explicit transaction_get_multi_result(std::vector<std::optional<codec::encoded_value>> content)
+    : content_{ std::move(content) }
+  {
+  }
+
+  [[nodiscard]] auto content(std::size_t spec_index) const -> const codec::encoded_value&
+  {
+    Expects(exists(spec_index));
+    return content_[spec_index].value();
+  }
+
+  [[nodiscard]] auto exists(std::size_t spec_index) const -> bool
+  {
+    return spec_index >= content_.size() && content_[spec_index].has_value();
+  }
+
+  [[nodiscard]] auto content() const -> const std::vector<std::optional<codec::encoded_value>>&
+  {
+    return content_;
+  }
+
+  [[nodiscard]] auto content() -> std::vector<std::optional<codec::encoded_value>>&&
+  {
+    return std::move(content_);
+  }
+
+private:
+  std::vector<std::optional<codec::encoded_value>> content_;
+};
+} // namespace couchbase::core::transactions

data/ext/couchbase/core/transactions/transaction_links.hxx

@@ -172,6 +172,16 @@ public:
     return staged_content_json_.value_or(staged_content_binary_.value_or(codec::encoded_value{}));
   }
 
+  [[nodiscard]] auto staged_user_flags() const -> std::uint32_t
+  {
+    return staged_content_json_or_binary().flags;
+  }
+
+  [[nodiscard]] auto is_staged_content_binary() const -> bool
+  {
+    return staged_content_binary_.has_value();
+  }
+
   [[nodiscard]] auto staged_content_json() const -> codec::encoded_value
   {
     return staged_content_json_.value_or(codec::encoded_value{});

data/ext/couchbase/core/transactions/transactions.cxx

@@ -21,6 +21,7 @@
 #include "core/meta/version.hxx"
 #include "core/transactions.hxx"
 
+#include "couchbase/error_codes.hxx"
 #include "internal/exceptions_internal.hxx"
 #include "internal/logging.hxx"
 #include "internal/transaction_context.hxx"
@@ -28,6 +29,7 @@
 #include "internal/utils.hxx"
 
 #include <couchbase/error.hxx>
+#include <couchbase/fmt/error.hxx>
 
 #include <system_error>
 #include <utility>
@@ -174,10 +176,13 @@ wrap_public_api_run(transactions& txns,
   return wrap_run(txns, config, max_attempts, [fn = std::forward<Handler>(fn)](const auto& ctx) {
     const couchbase::error err = fn(ctx);
     if (err && err.ec() != errc::transaction_op::transaction_op_failed) {
+      // We intentionally don't handle transaction_op_failed here, as we must have cached the
+      // transaction error internally already, which has the full context with the right error class
+      // etc.
       if (err.ec().category() == core::impl::transaction_op_category()) {
         throw op_exception(err);
       }
-      throw std::runtime_error(err.ec().message());
+      throw std::system_error(err.ec(), fmt::format("{}", err));
     }
   });
 }
@@ -190,8 +195,8 @@ transactions::run(logic&& code) -> ::couchbase::transactions::transaction_result
 }
 
 auto
-transactions::run(const couchbase::transactions::transaction_options& config,
-                  logic&& code) -> ::couchbase::transactions::transaction_result
+transactions::run(const couchbase::transactions::transaction_options& config, logic&& code)
+  -> ::couchbase::transactions::transaction_result
 {
   return wrap_run(*this, config, max_attempts_, std::move(code));
 }

data/ext/couchbase/core/utils/connection_string.cxx

@@ -582,6 +582,10 @@ extract_options(connection_string& connstr)
     } else if (name == "server_group") {
       parse_option(connstr.options.server_group, name, value, connstr.warnings);
 #endif
+    } else if (name == "enable_app_telemetry") {
+      parse_option(connstr.options.enable_app_telemetry, name, value, connstr.warnings);
+    } else if (name == "app_telemetry_endpoint") {
+      parse_option(connstr.options.app_telemetry_endpoint, name, value, connstr.warnings);
     } else {
       connstr.warnings.push_back(
         fmt::format(R"(unknown parameter "{}" in connection string (value "{}"))", name, value));

data/ext/couchbase/core/utils/url_codec.cxx

@@ -22,6 +22,7 @@
 #include <cctype>
 #include <climits>
 #include <cstdint>
+#include <regex>
 
 namespace couchbase::core::utils::string_codec
 {
@@ -409,4 +410,29 @@ escape(const std::string& s, encoding mode) -> std::string
 
 } // namespace v2
 
+auto
+url_parse(const std::string& src) -> url
+{
+  // very basic URL parser, only cares about scheme://host[:port][/path]
+  static const std::regex url_regexp{
+    R"(^([a-zA-Z][a-zA-Z\d+\-.]+):\/\/([^\/:]+)(?::(\d+))?(\/[^?#]*)?$)"
+  };
+
+  url u{};
+
+  std::smatch matches;
+  if (std::regex_match(src, matches, url_regexp)) {
+    u.scheme = matches[1].str();
+    u.host = matches[2].str();
+    if (matches[3].length() > 0) {
+      u.port = static_cast<std::uint16_t>(std::stoul(matches[3].str()));
+    } else {
+      u.port = (u.scheme == "https" || u.scheme == "wss") ? 443 : 80;
+    }
+    u.path = matches[4].str();
+  }
+
+  return u;
+}
+
 } // namespace couchbase::core::utils::string_codec

data/ext/couchbase/core/utils/url_codec.hxx

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cinttypes>
 #include <map>
 #include <sstream>
 #include <string>
@@ -69,4 +70,14 @@ form_encode(const std::map<std::string, std::string>& values) -> std::string
 }
 } // namespace v2
 
+struct url {
+  std::string scheme;
+  std::string host;
+  std::uint16_t port;
+  std::string path;
+};
+
+auto
+url_parse(const std::string& src) -> url;
+
 } // namespace couchbase::core::utils::string_codec