couchbase 4.0.0 → 4.1.2

package/deps/couchbase-cxx-client/couchbase/crypto/cbcrypto.cc

@@ -50,7 +50,7 @@ hash(std::string_view key, std::string_view data, LPCWSTR algorithm, int flags)
     DWORD cbHashObject = 0;
 
     // calculate the size of the buffer to hold the hash object
-    status = BCryptGetProperty(hAlg, BCRYPT_OBJECT_LENGTH, (PBYTE)&cbHashObject, sizeof(DWORD), &pcbResult, 0);
+    status = BCryptGetProperty(hAlg, BCRYPT_OBJECT_LENGTH, reinterpret_cast<PBYTE>(&cbHashObject), sizeof(DWORD), &pcbResult, 0);
     if (status < 0) {
         BCryptCloseAlgorithmProvider(hAlg, 0);
         throw std::runtime_error("digest: BCryptGetProperty return: " + std::to_string(status));
@@ -58,14 +58,14 @@ hash(std::string_view key, std::string_view data, LPCWSTR algorithm, int flags)
 
     // calculate the length of the hash
     DWORD cbHash = 0;
-    status = BCryptGetProperty(hAlg, BCRYPT_HASH_LENGTH, (PBYTE)&cbHash, sizeof(DWORD), &pcbResult, 0);
+    status = BCryptGetProperty(hAlg, BCRYPT_HASH_LENGTH, reinterpret_cast<PBYTE>(&cbHash), sizeof(DWORD), &pcbResult, 0);
     if (status < 0) {
         BCryptCloseAlgorithmProvider(hAlg, 0);
         throw std::runtime_error("digest: BCryptGetProperty return: " + std::to_string(status));
     }
 
     // allocate the hash object on the heap
-    uniqueHeapPtr pbHashObject((PBYTE)HeapAlloc(GetProcessHeap(), 0, cbHashObject));
+    uniqueHeapPtr pbHashObject(static_cast<PBYTE>(HeapAlloc(GetProcessHeap(), 0, cbHashObject)));
     if (!pbHashObject) {
         BCryptCloseAlgorithmProvider(hAlg, 0);
         throw std::bad_alloc();
@@ -76,13 +76,13 @@ hash(std::string_view key, std::string_view data, LPCWSTR algorithm, int flags)
 
     // create the hash
     BCRYPT_HASH_HANDLE hHash;
-    status = BCryptCreateHash(hAlg, &hHash, pbHashObject.get(), cbHashObject, (PUCHAR)key.data(), ULONG(key.size()), 0);
+    status = BCryptCreateHash(hAlg, &hHash, pbHashObject.get(), cbHashObject, (PUCHAR)key.data(), static_cast<ULONG>(key.size()), 0);
     if (status < 0) {
         BCryptCloseAlgorithmProvider(hAlg, 0);
         throw std::runtime_error("digest: BCryptCreateHash return: " + std::to_string(status));
     }
 
-    status = BCryptHashData(hHash, (PBYTE)data.data(), ULONG(data.size()), 0);
+    status = BCryptHashData(hHash, (PBYTE)data.data(), static_cast<ULONG>(data.size()), 0);
     if (status < 0) {
         BCryptCloseAlgorithmProvider(hAlg, 0);
         BCryptDestroyHash(hHash);

package/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/operations/management/design_document_fmt.hxx → couchbase-cxx-client/couchbase/design_document_namespace_fmt.hxx}

@@ -17,12 +17,12 @@
 
 #pragma once
 
-#include <couchbase/operations/management/design_document.hxx>
+#include <couchbase/design_document_namespace.hxx>
 
 #include <fmt/core.h>
 
 template<>
-struct fmt::formatter<couchbase::operations::design_document::name_space> {
+struct fmt::formatter<couchbase::design_document_namespace> {
     template<typename ParseContext>
     constexpr auto parse(ParseContext& ctx)
     {
@@ -30,15 +30,15 @@ struct fmt::formatter<couchbase::operations::design_document::name_space> {
     }
 
     template<typename FormatContext>
-    auto format(couchbase::operations::design_document::name_space ns, FormatContext& ctx) const
+    auto format(couchbase::design_document_namespace ns, FormatContext& ctx) const
     {
         string_view name = "unknown";
         switch (ns) {
-            case couchbase::operations::design_document::name_space::development:
+            case couchbase::design_document_namespace::development:
                 name = "development";
                 break;
 
-            case couchbase::operations::design_document::name_space::production:
+            case couchbase::design_document_namespace::production:
                 name = "production";
                 break;
         }

package/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-cxx-client/couchbase/document_id.cxx

@@ -17,6 +17,9 @@
 
 #include <couchbase/document_id.hxx>
 
+#include <couchbase/utils/binary.hxx>
+#include <couchbase/utils/unsigned_leb128.hxx>
+
 #include <fmt/core.h>
 
 #include <algorithm>
@@ -25,9 +28,9 @@
 namespace couchbase
 {
 document_id::document_id()
-  : scope_("_default")
-  , collection_("_default")
-  , collection_path_("_default._default")
+  : scope_{ "_default" }
+  , collection_{ "_default" }
+  , collection_path_{ "_default._default" }
 {
 }
 
@@ -86,4 +89,18 @@ document_id::has_default_collection() const
 {
     return !use_collections_ || collection_path_ == "_default._default";
 }
+
+std::vector<std::byte>
+make_protocol_key(const document_id& id)
+{
+    std::vector<std::byte> key{};
+    if (id.is_collection_resolved()) {
+        utils::unsigned_leb128<std::uint32_t> encoded(id.collection_uid());
+        key.reserve(encoded.size());
+        key.insert(key.end(), encoded.begin(), encoded.end());
+    }
+    key.reserve(key.size() + id.key().size());
+    couchbase::utils::to_binary(id.key(), std::back_insert_iterator(key));
+    return key;
+}
 } // namespace couchbase

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

@@ -20,6 +20,7 @@
 #include <cstdint>
 #include <optional>
 #include <string>
+#include <vector>
 
 namespace couchbase
 {
@@ -99,4 +100,8 @@ struct document_id {
     bool use_collections_{ true };
     bool use_any_session_{ false };
 };
+
+[[nodiscard]] std::vector<std::byte>
+make_protocol_key(const document_id& id);
+
 } // namespace couchbase

package/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-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-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-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-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-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-cxx-client/couchbase/io/dns_client.hxx

@@ -154,7 +154,7 @@ class dns_client
                             return handler({ ec2 });
                         }
                         asio::async_read(self->tcp_,
-                                         asio::buffer(&self->recv_buf_size_, sizeof(self->recv_buf_size_)),
+                                         asio::buffer(&self->recv_buf_size_, sizeof(std::uint16_t)),
                                          [self, handler = std::forward<Handler>(handler)](std::error_code ec3,
                                                                                           std::size_t /* bytes_transferred */) mutable {
                                              if (ec3) {

package/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-cxx-client/couchbase/io/http_parser.cxx

@@ -125,7 +125,7 @@ http_parser::error_message() const
 
     switch (state_->parser_.http_errno) {
         HTTP_ERRNO_MAP(HTTP_ERRNO_GEN)
-    };
+    }
 #undef HTTP_ERRNO_GEN
     return "unknown error: " + std::to_string(state_->parser_.http_errno);
 }

package/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();
@@ -391,7 +397,11 @@ class http_session : public std::enable_shared_from_this<http_session>
                         it->endpoint().port(),
                         ec.message(),
                         (ec == asio::error::connection_refused) ? ", check server ports and cluster encryption setting" : "");
-            do_connect(++it);
+            if (stream_->is_open()) {
+                stream_->close(std::bind(&http_session::do_connect, shared_from_this(), ++it));
+            } else {
+                do_connect(++it);
+            }
         } else {
             state_ = diag::endpoint_state::connected;
             connected_ = true;
@@ -400,7 +410,6 @@ class http_session : public std::enable_shared_from_this<http_session>
                 std::scoped_lock lock(info_mutex_);
                 info_ = http_session_info(client_id_, id_, stream_->local_endpoint(), it->endpoint());
             }
-            deadline_timer_.expires_at(asio::steady_timer::time_point::max());
             deadline_timer_.cancel();
             flush();
         }
@@ -408,15 +417,13 @@ 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()) {
             stream_->close([](std::error_code) {});
-            deadline_timer_.expires_at(asio::steady_timer::time_point::max());
+            deadline_timer_.cancel();
+            return;
         }
         deadline_timer_.async_wait(std::bind(&http_session::check_deadline, shared_from_this(), std::placeholders::_1));
     }

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

@@ -99,7 +99,10 @@ class http_session_manager : public std::enable_shared_from_this<http_session_ma
     template<typename Collector>
     void ping(std::set<service_type> services, std::shared_ptr<Collector> collector, const couchbase::cluster_credentials& credentials)
     {
-        std::array<service_type, 4> known_types{ service_type::query, service_type::analytics, service_type::search, service_type::view };
+        std::array known_types{
+            service_type::query, service_type::analytics, service_type::search,
+            service_type::view,  service_type::eventing,  service_type::management,
+        };
         std::vector<topology::configuration::node> nodes{};
         {
             std::scoped_lock lock(config_mutex_);
@@ -113,21 +116,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_);
@@ -227,6 +232,7 @@ class http_session_manager : public std::enable_shared_from_this<http_session_ma
 
     void close()
     {
+        std::scoped_lock lock(sessions_mutex_);
         for (auto& [type, sessions] : idle_sessions_) {
             for (auto& s : sessions) {
                 if (s) {
@@ -254,27 +260,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 +295,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-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-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,
@@ -217,12 +239,12 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
               protocol::status status = protocol::status::invalid;
               std::optional<error_map::error_info> error_code{};
               if (protocol::is_valid_status(msg.header.status())) {
-                  status = protocol::status(msg.header.status());
+                  status = static_cast<protocol::status>(msg.header.status());
               } else {
                   error_code = self->session_->decode_error_code(msg.header.status());
               }
               if (status == protocol::status::not_my_vbucket) {
-                  self->session_->handle_not_my_vbucket(std::move(msg));
+                  self->session_->handle_not_my_vbucket(msg);
                   return io::retry_orchestrator::maybe_retry(self->manager_, self, io::retry_reason::kv_not_my_vbucket, ec);
               }
               if (status == protocol::status::unknown_collection) {

package/deps/couchbase-cxx-client/couchbase/io/mcbp_message.hxx

@@ -26,7 +26,7 @@ namespace couchbase
 namespace protocol
 {
 static const std::size_t header_size = 24;
-using header_buffer = std::array<std::uint8_t, header_size>;
+using header_buffer = std::array<std::byte, header_size>;
 } // namespace protocol
 
 namespace io
@@ -47,7 +47,7 @@ struct binary_header {
 
 struct mcbp_message {
     binary_header header;
-    std::vector<std::uint8_t> body;
+    std::vector<std::byte> body;
 
     [[nodiscard]] protocol::header_buffer header_data() const;
 };