couchbase 4.0.0 → 4.1.2

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/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-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_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-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();
@@ -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-transactions-cxx/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-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,
@@ -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-transactions-cxx/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;
 };

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/io/mcbp_parser.cxx

@@ -22,11 +22,12 @@
 #include <couchbase/protocol/magic.hxx>
 #include <couchbase/utils/byteswap.hxx>
 
-#include <cstring>
-#include <gsl/assert>
 #include <snappy.h>
 #include <spdlog/fmt/bin_to_hex.h>
 
+#include <algorithm>
+#include <cstring>
+
 namespace couchbase::io
 {
 mcbp_parser::result
@@ -44,22 +45,23 @@ mcbp_parser::next(mcbp_message& msg)
     msg.body.clear();
     msg.body.reserve(body_size);
     std::uint32_t key_size = utils::byte_swap(msg.header.keylen);
-    std::uint32_t prefix_size = std::uint32_t(msg.header.extlen) + key_size;
+    std::uint32_t prefix_size = static_cast<std::uint32_t>(msg.header.extlen) + key_size;
     if (msg.header.magic == static_cast<uint8_t>(protocol::magic::alt_client_response)) {
         std::uint8_t framing_extras_size = msg.header.keylen & 0xfU;
         key_size = (msg.header.keylen & 0xf0U) >> 8U;
-        prefix_size = std::uint32_t(framing_extras_size) + std::uint32_t(msg.header.extlen) + key_size;
+        prefix_size = static_cast<std::uint32_t>(framing_extras_size) + static_cast<std::uint32_t>(msg.header.extlen) + key_size;
     }
     std::copy(buf.begin() + header_size, buf.begin() + header_size + prefix_size, std::back_insert_iterator(msg.body));
 
-    bool is_compressed = (msg.header.datatype & static_cast<uint8_t>(protocol::datatype::snappy)) != 0;
+    bool is_compressed = (msg.header.datatype & static_cast<std::uint8_t>(protocol::datatype::snappy)) != 0;
     bool use_raw_value = true;
     if (is_compressed) {
         std::string uncompressed;
         size_t offset = header_size + prefix_size;
-        bool success = snappy::Uncompress(reinterpret_cast<const char*>(buf.data() + offset), body_size - prefix_size, &uncompressed);
-        if (success) {
-            std::copy(uncompressed.begin(), uncompressed.end(), std::back_insert_iterator(msg.body));
+        if (snappy::Uncompress(reinterpret_cast<const char*>(buf.data() + offset), body_size - prefix_size, &uncompressed)) {
+            std::transform(uncompressed.begin(), uncompressed.end(), std::back_insert_iterator(msg.body), [](auto ch) {
+                return static_cast<std::byte>(ch);
+            });
             use_raw_value = false;
             // patch header with new body size
             msg.header.bodylen = utils::byte_swap(static_cast<std::uint32_t>(prefix_size + uncompressed.size()));
@@ -69,7 +71,7 @@ mcbp_parser::next(mcbp_message& msg)
         std::copy(buf.begin() + header_size + prefix_size, buf.begin() + header_size + body_size, std::back_insert_iterator(msg.body));
     }
     buf.erase(buf.begin(), buf.begin() + header_size + body_size);
-    if (!buf.empty() && !protocol::is_valid_magic(buf[0])) {
+    if (!buf.empty() && !protocol::is_valid_magic(std::to_integer<std::uint8_t>(buf[0]))) {
         LOG_WARNING("parsed frame for magic={:x}, opcode={:x}, opaque={}, body_len={}. Invalid magic of the next frame: {:x}, {} "
                     "bytes to parse{}",
                     msg.header.magic,

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

@@ -40,6 +40,6 @@ struct mcbp_parser {
 
     result next(mcbp_message& msg);
 
-    std::vector<std::uint8_t> buf;
+    std::vector<std::byte> buf;
 };
 } // namespace couchbase::io