couchbase 4.0.0 → 4.1.0

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/analytics_scan_consistency.hxx

@@ -0,0 +1,26 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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
+
+namespace couchbase
+{
+enum class analytics_scan_consistency {
+    not_bounded = 0,
+    request_plus,
+};
+} // namespace couchbase

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/capella_ca.hxx

@@ -0,0 +1,43 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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
+
+namespace couchbase::default_ca
+{
+
+static const char* capellaCaCert = "-----BEGIN CERTIFICATE-----\n"
+                                   "MIIDFTCCAf2gAwIBAgIRANLVkgOvtaXiQJi0V6qeNtswDQYJKoZIhvcNAQELBQAw\n"
+                                   "JDESMBAGA1UECgwJQ291Y2hiYXNlMQ4wDAYDVQQLDAVDbG91ZDAeFw0xOTEyMDYy\n"
+                                   "MjEyNTlaFw0yOTEyMDYyMzEyNTlaMCQxEjAQBgNVBAoMCUNvdWNoYmFzZTEOMAwG\n"
+                                   "A1UECwwFQ2xvdWQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCfvOIi\n"
+                                   "enG4Dp+hJu9asdxEMRmH70hDyMXv5ZjBhbo39a42QwR59y/rC/sahLLQuNwqif85\n"
+                                   "Fod1DkqgO6Ng3vecSAwyYVkj5NKdycQu5tzsZkghlpSDAyI0xlIPSQjoORA/pCOU\n"
+                                   "WOpymA9dOjC1bo6rDyw0yWP2nFAI/KA4Z806XeqLREuB7292UnSsgFs4/5lqeil6\n"
+                                   "rL3ooAw/i0uxr/TQSaxi1l8t4iMt4/gU+W52+8Yol0JbXBTFX6itg62ppb/Eugmn\n"
+                                   "mQRMgL67ccZs7cJ9/A0wlXencX2ohZQOR3mtknfol3FH4+glQFn27Q4xBCzVkY9j\n"
+                                   "KQ20T1LgmGSngBInAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYE\n"
+                                   "FJQOBPvrkU2In1Sjoxt97Xy8+cKNMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0B\n"
+                                   "AQsFAAOCAQEARgM6XwcXPLSpFdSf0w8PtpNGehmdWijPM3wHb7WZiS47iNen3oq8\n"
+                                   "m2mm6V3Z57wbboPpfI+VEzbhiDcFfVnK1CXMC0tkF3fnOG1BDDvwt4jU95vBiNjY\n"
+                                   "xdzlTP/Z+qr0cnVbGBSZ+fbXstSiRaaAVcqQyv3BRvBadKBkCyPwo+7svQnScQ5P\n"
+                                   "Js7HEHKVms5tZTgKIw1fbmgR2XHleah1AcANB+MAPBCcTgqurqr5G7W2aPSBLLGA\n"
+                                   "fRIiVzm7VFLc7kWbp7ENH39HVG6TZzKnfl9zJYeiklo5vQQhGSMhzBsO70z4RRzi\n"
+                                   "DPFAN/4qZAgD5q3AFNIq2WWADFQGSwVJhg==\n"
+                                   "-----END CERTIFICATE-----\n";
+
+} // namespace couchbase::default_ca

package/deps/{couchbase-cxx-client/couchbase/protocol → couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase}/cas.hxx

@@ -19,7 +19,7 @@
 
 #include <cstdint>
 
-namespace couchbase::protocol
+namespace couchbase
 {
 /**
  * CAS is a special type that represented in protocol using unsigned 64-bit integer, but only equality checks allowed.
@@ -44,4 +44,4 @@ struct cas {
         return value == 0;
     }
 };
-} // namespace couchbase::protocol
+} // namespace couchbase

package/deps/{couchbase-cxx-client/couchbase/protocol → couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase}/cas_fmt.hxx

@@ -17,12 +17,12 @@
 
 #pragma once
 
-#include <couchbase/protocol/cas.hxx>
+#include <couchbase/cas.hxx>
 
 #include <fmt/core.h>
 
 template<>
-struct fmt::formatter<couchbase::protocol::cas> {
+struct fmt::formatter<couchbase::cas> {
     template<typename ParseContext>
     constexpr auto parse(ParseContext& ctx)
     {
@@ -30,7 +30,7 @@ struct fmt::formatter<couchbase::protocol::cas> {
     }
 
     template<typename FormatContext>
-    auto format(const couchbase::protocol::cas& cas, FormatContext& ctx) const
+    auto format(const couchbase::cas& cas, FormatContext& ctx) const
     {
         return format_to(ctx.out(), "{:x}", cas.value);
     }

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/cluster.hxx

@@ -18,6 +18,7 @@
 #pragma once
 
 #include <couchbase/bucket.hxx>
+#include <couchbase/capella_ca.hxx>
 #include <couchbase/diagnostics.hxx>
 #include <couchbase/io/dns_client.hxx>
 #include <couchbase/io/http_command.hxx>
@@ -128,7 +129,7 @@ class cluster : public std::enable_shared_from_this<cluster>
             if (ec) {
                 std::scoped_lock lock(self->buckets_mutex_);
                 self->buckets_.erase(bucket_name);
-            } else if (!self->session_->supports_gcccp()) {
+            } else if (self->session_ && !self->session_->supports_gcccp()) {
                 self->session_manager_->set_configuration(config, self->origin_.options());
             }
             handler(ec);
@@ -286,6 +287,25 @@ class cluster : public std::enable_shared_from_this<cluster>
     template<typename Handler>
     void do_open(Handler&& handler)
     {
+        // Warn users if they attempt to use Capella without TLS being enabled.
+        {
+            bool is_capella = false;
+            static std::string suffix = "cloud.couchbase.com";
+            auto nodes_list = origin_.get_nodes();
+            for (auto& node : nodes_list) {
+                if (auto pos = node.find(suffix); pos != std::string::npos && pos + suffix.size() == node.size()) {
+                    is_capella = true;
+                    break;
+                }
+            }
+
+            if (is_capella && !origin_.options().enable_tls) {
+                LOG_WARNING("[{}]: TLS is required when connecting to Couchbase Capella. Please enable TLS by prefixing "
+                            "the connection string with \"couchbases://\" (note the final 's').",
+                            id_);
+            }
+        }
+
         if (origin_.options().enable_tls) {
             tls_.set_options(asio::ssl::context::default_workarounds | asio::ssl::context::no_sslv2 | asio::ssl::context::no_sslv3);
             switch (origin_.options().tls_verify) {
@@ -305,6 +325,16 @@ class cluster : public std::enable_shared_from_this<cluster>
                     LOG_ERROR("[{}]: unable to load verify file \"{}\": {}", id_, origin_.options().trust_certificate, ec.message());
                     return handler(ec);
                 }
+            } else {
+                // add the cappela Root CA if no other CA was specified.
+                std::error_code ec{};
+                LOG_DEBUG(R"([{}]: use default CA for TLS verify)", id_);
+                tls_.add_certificate_authority(
+                  asio::const_buffer(couchbase::default_ca::capellaCaCert, strlen(couchbase::default_ca::capellaCaCert)), ec);
+                if (ec) {
+                    LOG_WARNING("[{}]: unable to load default CAs: {}", id_, ec.message());
+                    // we don't consider this fatal and try to continue without it
+                }
             }
 #ifdef COUCHBASE_CXX_CLIENT_TLS_KEY_LOG_FILE
             SSL_CTX_set_keylog_callback(tls_.native_handle(), [](const SSL* /* ssl */, const char* line) {

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/cluster_options.hxx

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include <couchbase/io/ip_protocol.hxx>
 #include <couchbase/metrics/logging_meter_options.hxx>
 #include <couchbase/service_type.hxx>
 #include <couchbase/timeout_defaults.hxx>
@@ -34,6 +35,7 @@ enum class tls_verify_mode {
 
 struct cluster_options {
     std::chrono::milliseconds bootstrap_timeout = timeout_defaults::bootstrap_timeout;
+    std::chrono::milliseconds resolve_timeout = timeout_defaults::resolve_timeout;
     std::chrono::milliseconds connect_timeout = timeout_defaults::connect_timeout;
     std::chrono::milliseconds key_value_timeout = timeout_defaults::key_value_timeout;
     std::chrono::milliseconds key_value_durable_timeout = timeout_defaults::key_value_durable_timeout;
@@ -48,7 +50,7 @@ struct cluster_options {
     std::string trust_certificate{};
     bool enable_mutation_tokens{ true };
     bool enable_tcp_keep_alive{ true };
-    bool force_ipv4{ false };
+    io::ip_protocol use_ip_protocol{ io::ip_protocol::any };
     bool enable_dns_srv{ true };
     bool show_queries{ false };
     bool enable_unordered_execution{ true };

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/design_document_namespace.hxx

@@ -0,0 +1,26 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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
+
+namespace couchbase
+{
+enum class design_document_namespace {
+    development = 0,
+    production,
+};
+} // namespace couchbase

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

@@ -19,6 +19,7 @@
 
 #include <couchbase/service_type.hxx>
 
+#include <array>
 #include <chrono>
 #include <map>
 #include <optional>

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/error_context/analytics.hxx

@@ -39,6 +39,8 @@ struct analytics {
     std::string path{};
     std::uint32_t http_status{};
     std::string http_body{};
+    std::string hostname{};
+    std::uint16_t port{};
 
     std::optional<std::string> last_dispatched_to{};
     std::optional<std::string> last_dispatched_from{};

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/error_context/http.hxx

@@ -35,6 +35,8 @@ struct http {
     std::string path{};
     std::uint32_t http_status{};
     std::string http_body{};
+    std::string hostname{};
+    std::uint16_t port{};
 
     std::optional<std::string> last_dispatched_to{};
     std::optional<std::string> last_dispatched_from{};

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/error_context/key_value.hxx

@@ -17,9 +17,9 @@
 
 #pragma once
 
+#include <couchbase/cas.hxx>
 #include <couchbase/document_id.hxx>
 #include <couchbase/io/retry_reason.hxx>
-#include <couchbase/protocol/cas.hxx>
 #include <couchbase/protocol/enhanced_error_info.hxx>
 #include <couchbase/protocol/status.hxx>
 #include <couchbase/topology/error_map.hxx>
@@ -36,7 +36,7 @@ struct key_value {
     document_id id;
     std::error_code ec{};
     std::uint32_t opaque{};
-    protocol::cas cas{};
+    couchbase::cas cas{};
     std::optional<protocol::status> status_code{};
     std::optional<error_map::error_info> error_map_info{};
     std::optional<protocol::enhanced_error_info> enhanced_error_info{};

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/error_context/query.hxx

@@ -39,6 +39,8 @@ struct query {
     std::string path{};
     std::uint32_t http_status{};
     std::string http_body{};
+    std::string hostname{};
+    std::uint16_t port{};
 
     std::optional<std::string> last_dispatched_to{};
     std::optional<std::string> last_dispatched_from{};

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/error_context/search.hxx

@@ -38,6 +38,8 @@ struct search {
     std::string path{};
     std::uint32_t http_status{};
     std::string http_body{};
+    std::string hostname{};
+    std::uint16_t port{};
 
     std::optional<std::string> last_dispatched_to{};
     std::optional<std::string> last_dispatched_from{};

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/error_context/view.hxx

@@ -39,6 +39,8 @@ struct view {
     std::string path{};
     std::uint32_t http_status{};
     std::string http_body{};
+    std::string hostname{};
+    std::uint16_t port{};
 
     std::optional<std::string> last_dispatched_to{};
     std::optional<std::string> last_dispatched_from{};

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/io/http_context.hxx

@@ -27,6 +27,8 @@ struct http_context {
     const topology::configuration& config;
     const cluster_options& options;
     query_cache& cache;
+    std::string hostname;
+    std::uint16_t port;
 };
 
 namespace priv

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/io/http_session.hxx

@@ -28,7 +28,6 @@
 #include <couchbase/origin.hxx>
 #include <couchbase/platform/base64.h>
 #include <couchbase/platform/uuid.h>
-#include <couchbase/timeout_defaults.hxx>
 #include <couchbase/utils/movable_function.hxx>
 
 #include <asio.hpp>
@@ -198,8 +197,11 @@ class http_session : public std::enable_shared_from_this<http_session>
     void start()
     {
         state_ = diag::endpoint_state::connecting;
-        resolver_.async_resolve(
-          hostname_, service_, std::bind(&http_session::on_resolve, shared_from_this(), std::placeholders::_1, std::placeholders::_2));
+        async_resolve(http_ctx_.options.use_ip_protocol,
+                      resolver_,
+                      hostname_,
+                      service_,
+                      std::bind(&http_session::on_resolve, shared_from_this(), std::placeholders::_1, std::placeholders::_2));
     }
 
     [[nodiscard]] std::string log_prefix()
@@ -350,7 +352,7 @@ class http_session : public std::enable_shared_from_this<http_session>
 
     void on_resolve(std::error_code ec, const asio::ip::tcp::resolver::results_type& endpoints)
     {
-        if (stopped_) {
+        if (ec == asio::error::operation_aborted || stopped_) {
             return;
         }
         if (ec) {
@@ -369,8 +371,12 @@ class http_session : public std::enable_shared_from_this<http_session>
             return;
         }
         if (it != endpoints_.end()) {
-            LOG_DEBUG("{} connecting to {}:{}", info_.log_prefix(), it->endpoint().address().to_string(), it->endpoint().port());
-            deadline_timer_.expires_after(timeout_defaults::connect_timeout);
+            LOG_DEBUG("{} connecting to {}:{}, timeout={}ms",
+                      info_.log_prefix(),
+                      it->endpoint().address().to_string(),
+                      it->endpoint().port(),
+                      http_ctx_.options.connect_timeout.count());
+            deadline_timer_.expires_after(http_ctx_.options.connect_timeout);
             stream_->async_connect(it->endpoint(), std::bind(&http_session::on_connect, shared_from_this(), std::placeholders::_1, it));
         } else {
             LOG_ERROR("{} no more endpoints left to connect", info_.log_prefix());
@@ -380,7 +386,7 @@ class http_session : public std::enable_shared_from_this<http_session>
 
     void on_connect(const std::error_code& ec, asio::ip::tcp::resolver::results_type::iterator it)
     {
-        if (stopped_) {
+        if (ec == asio::error::operation_aborted || stopped_) {
             return;
         }
         last_active_ = std::chrono::steady_clock::now();
@@ -408,10 +414,7 @@ class http_session : public std::enable_shared_from_this<http_session>
 
     void check_deadline(std::error_code ec)
     {
-        if (ec == asio::error::operation_aborted) {
-            return;
-        }
-        if (stopped_) {
+        if (ec == asio::error::operation_aborted || stopped_) {
             return;
         }
         if (deadline_timer_.expiry() <= asio::steady_timer::clock_type::now()) {

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/io/http_session_manager.hxx

@@ -113,21 +113,23 @@ class http_session_manager : public std::enable_shared_from_this<http_session_ma
                 std::uint16_t port = node.port_or(options_.network, type, options_.enable_tls, 0);
                 if (port != 0) {
                     std::shared_ptr<http_session> session;
-                    session = options_.enable_tls ? std::make_shared<http_session>(type,
-                                                                                   client_id_,
-                                                                                   ctx_,
-                                                                                   tls_,
-                                                                                   credentials,
-                                                                                   node.hostname_for(options_.network),
-                                                                                   std::to_string(port),
-                                                                                   http_context{ config_, options_, query_cache_ })
-                                                  : std::make_shared<http_session>(type,
-                                                                                   client_id_,
-                                                                                   ctx_,
-                                                                                   credentials,
-                                                                                   node.hostname_for(options_.network),
-                                                                                   std::to_string(port),
-                                                                                   http_context{ config_, options_, query_cache_ });
+                    const auto& hostname = node.hostname_for(options_.network);
+                    session = options_.enable_tls
+                                ? std::make_shared<http_session>(type,
+                                                                 client_id_,
+                                                                 ctx_,
+                                                                 tls_,
+                                                                 credentials,
+                                                                 hostname,
+                                                                 std::to_string(port),
+                                                                 http_context{ config_, options_, query_cache_, hostname, port })
+                                : std::make_shared<http_session>(type,
+                                                                 client_id_,
+                                                                 ctx_,
+                                                                 credentials,
+                                                                 hostname,
+                                                                 std::to_string(port),
+                                                                 http_context{ config_, options_, query_cache_, hostname, port });
                     session->start();
                     session->on_stop([type, id = session->id(), self = this->shared_from_this()]() {
                         std::scoped_lock lock(self->sessions_mutex_);
@@ -254,27 +256,30 @@ class http_session_manager : public std::enable_shared_from_this<http_session_ma
             using response_type = typename Request::encoded_response_type;
             return handler(request.make_response(std::move(ctx), response_type{}));
         }
+        const auto& http_ctx = session->http_context();
 
         auto cmd =
           std::make_shared<operations::http_command<Request>>(ctx_, request, tracer_, meter_, options_.default_timeout_for(request.type));
-        cmd->start(
-          [self = shared_from_this(), cmd, handler = std::forward<Handler>(handler)](std::error_code ec, io::http_response&& msg) mutable {
-              using command_type = typename decltype(cmd)::element_type;
-              using encoded_response_type = typename command_type::encoded_response_type;
-              using error_context_type = typename command_type::error_context_type;
-              encoded_response_type resp{ std::move(msg) };
-              error_context_type ctx{};
-              ctx.ec = ec;
-              ctx.client_context_id = cmd->client_context_id_;
-              ctx.method = cmd->encoded.method;
-              ctx.path = cmd->encoded.path;
-              ctx.last_dispatched_from = cmd->session_->local_address();
-              ctx.last_dispatched_to = cmd->session_->remote_address();
-              ctx.http_status = resp.status_code;
-              ctx.http_body = resp.body.data();
-              handler(cmd->request.make_response(std::move(ctx), std::move(resp)));
-              self->check_in(cmd->request.type, cmd->session_);
-          });
+        cmd->start([self = shared_from_this(), cmd, http_ctx, handler = std::forward<Handler>(handler)](std::error_code ec,
+                                                                                                        io::http_response&& msg) mutable {
+            using command_type = typename decltype(cmd)::element_type;
+            using encoded_response_type = typename command_type::encoded_response_type;
+            using error_context_type = typename command_type::error_context_type;
+            encoded_response_type resp{ std::move(msg) };
+            error_context_type ctx{};
+            ctx.ec = ec;
+            ctx.client_context_id = cmd->client_context_id_;
+            ctx.method = cmd->encoded.method;
+            ctx.path = cmd->encoded.path;
+            ctx.last_dispatched_from = cmd->session_->local_address();
+            ctx.last_dispatched_to = cmd->session_->remote_address();
+            ctx.http_status = resp.status_code;
+            ctx.http_body = resp.body.data();
+            ctx.hostname = http_ctx.hostname;
+            ctx.port = http_ctx.port;
+            handler(cmd->request.make_response(std::move(ctx), std::move(resp)));
+            self->check_in(cmd->request.type, cmd->session_);
+        });
         cmd->send_to(session);
     }
 
@@ -286,11 +291,22 @@ class http_session_manager : public std::enable_shared_from_this<http_session_ma
     {
         std::shared_ptr<http_session> session;
         if (options_.enable_tls) {
-            session = std::make_shared<http_session>(
-              type, client_id_, ctx_, tls_, credentials, hostname, std::to_string(port), http_context{ config_, options_, query_cache_ });
+            session = std::make_shared<http_session>(type,
+                                                     client_id_,
+                                                     ctx_,
+                                                     tls_,
+                                                     credentials,
+                                                     hostname,
+                                                     std::to_string(port),
+                                                     http_context{ config_, options_, query_cache_, hostname, port });
         } else {
-            session = std::make_shared<http_session>(
-              type, client_id_, ctx_, credentials, hostname, std::to_string(port), http_context{ config_, options_, query_cache_ });
+            session = std::make_shared<http_session>(type,
+                                                     client_id_,
+                                                     ctx_,
+                                                     credentials,
+                                                     hostname,
+                                                     std::to_string(port),
+                                                     http_context{ config_, options_, query_cache_, hostname, port });
         }
         session->start();
 

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/io/ip_protocol.hxx

@@ -0,0 +1,28 @@
+/* -*- 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
+
+namespace couchbase::io
+{
+enum class ip_protocol {
+    any,
+    force_ipv4,
+    force_ipv6,
+};
+
+} // namespace couchbase::io

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/io/mcbp_command.hxx

@@ -19,10 +19,12 @@
 
 #include <couchbase/document_id_fmt.hxx>
 #include <couchbase/io/mcbp_session.hxx>
+#include <couchbase/io/mcbp_traits.hxx>
 #include <couchbase/io/retry_orchestrator.hxx>
 #include <couchbase/metrics/meter.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/protocol/cmd_get_collection_id.hxx>
+#include <couchbase/protocol/durability_level.hxx>
 #include <couchbase/tracing/request_tracer.hxx>
 #include <couchbase/utils/movable_function.hxx>
 
@@ -36,6 +38,8 @@ using mcbp_command_handler = utils::movable_function<void(std::error_code, std::
 
 template<typename Manager, typename Request>
 struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager, Request>> {
+    static constexpr std::chrono::milliseconds durability_timeout_floor{ 1'500 };
+
     using encoded_request_type = typename Request::encoded_request_type;
     using encoded_response_type = typename Request::encoded_response_type;
     asio::steady_timer deadline;
@@ -57,6 +61,18 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
       , manager_(manager)
       , timeout_(request.timeout.value_or(default_timeout))
     {
+        if constexpr (io::mcbp_traits::supports_durability_v<Request>) {
+            if (request.durability_level != protocol::durability_level::none && timeout_ < durability_timeout_floor) {
+                LOG_DEBUG(
+                  R"({} Timeout is too low for operation with durability, increasing to sensible value. timeout={}ms, floor={}ms, id="{}")",
+                  session_->log_prefix(),
+                  request.id,
+                  timeout_.count(),
+                  durability_timeout_floor.count(),
+                  id_);
+                timeout_ = durability_timeout_floor;
+            }
+        }
     }
 
     void start(mcbp_command_handler&& handler)
@@ -186,6 +202,12 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
         if (auto ec = request.encode_to(encoded, session_->context()); ec) {
             return invoke_handler(ec);
         }
+        if constexpr (io::mcbp_traits::supports_durability_v<Request>) {
+            if (request.durability_level != protocol::durability_level::none) {
+                encoded.body().durability(request.durability_level,
+                                          static_cast<std::uint16_t>(static_cast<double>(timeout_.count()) * 0.9));
+            }
+        }
 
         session_->write_and_subscribe(
           request.opaque,