couchbase 3.5.3 → 3.5.4

data/ext/couchbase/core/io/http_streaming_response.cxx

@@ -16,6 +16,7 @@
  */
 
 #include "http_streaming_response.hxx"
+
 #include "core/utils/movable_function.hxx"
 #include "http_session.hxx"
 

data/ext/couchbase/core/io/mcbp_command.hxx

@@ -18,6 +18,8 @@
 #pragma once
 
 #include "core/document_id_fmt.hxx"
+#include "core/error_context/key_value_error_map_info.hxx"
+#include "core/metrics/meter_wrapper.hxx"
 #include "core/platform/uuid.h"
 #include "core/protocol/client_request.hxx"
 #include "core/protocol/client_response.hxx"
@@ -30,7 +32,6 @@
 #include "mcbp_traits.hxx"
 #include "retry_orchestrator.hxx"
 
-#include "core/error_context/key_value_error_map_info.hxx"
 #include <couchbase/durability_level.hxx>
 #include <couchbase/error_codes.hxx>
 
@@ -98,12 +99,12 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
 
   void start(mcbp_command_handler&& handler)
   {
-    span_ = manager_->tracer()->start_span(
+    span_ = manager_->tracer()->create_span(
       tracing::span_name_for_mcbp_command(encoded_request_type::body_type::opcode), parent_span);
-    if (span_->uses_tags())
+    if (span_->uses_tags()) {
       span_->add_tag(tracing::attributes::service, tracing::service::key_value);
-    if (span_->uses_tags())
       span_->add_tag(tracing::attributes::instance, request.id.bucket());
+    }
 
     handler_ = std::move(handler);
     deadline.expires_after(timeout_);
@@ -223,8 +224,9 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
   {
     opaque_ = session_->next_opaque();
     request.opaque = *opaque_;
-    if (span_->uses_tags())
+    if (span_->uses_tags()) {
       span_->add_tag(tracing::attributes::operation_id, fmt::format("0x{:x}", request.opaque));
+    }
     if (request.id.use_collections() && !request.id.is_collection_resolved()) {
       if (session_->supports_feature(protocol::hello_feature::collections)) {
         auto collection_id = session_->get_collection_uid(request.id.collection_path());
@@ -265,16 +267,15 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
         retry_reason reason,
         io::mcbp_message&& msg,
         std::optional<key_value_error_map_info> /* error_info */) mutable {
-        static std::string meter_name = "db.couchbase.operations";
-        static std::map<std::string, std::string> tags = {
-          { "db.couchbase.service", "kv" },
-          { "db.operation", fmt::format("{}", encoded_request_type::body_type::opcode) },
+        metrics::metric_attributes attrs{
+          service_type::key_value,
+          fmt::format("{}", encoded_request_type::body_type::opcode),
+          ec,
+          self->request.id.bucket(),
+          self->request.id.scope(),
+          self->request.id.collection(),
         };
-        self->manager_->meter()
-          ->get_value_recorder(meter_name, tags)
-          ->record_value(std::chrono::duration_cast<std::chrono::microseconds>(
-                           std::chrono::steady_clock::now() - start)
-                           .count());
+        self->manager_->meter()->record_value(std::move(attrs), start);
 
         self->retry_backoff.cancel();
         if (ec == asio::error::operation_aborted) {

data/ext/couchbase/core/io/mcbp_session.cxx

@@ -1084,20 +1084,20 @@ public:
       return;
     }
     bootstrapped_ = false;
-    if (bootstrap_handler_) {
-      last_bootstrap_error_ = std::move(bootstrap_handler_)->last_bootstrap_error();
+    if (auto handler = std::move(bootstrap_handler_); handler) {
+      last_bootstrap_error_ = handler->last_bootstrap_error();
     }
-    bootstrap_handler_ = nullptr;
     state_ = diag::endpoint_state::connecting;
     if (stream_->is_open()) {
-      std::string old_id = stream_->id();
-      stream_->reopen();
-      CB_LOG_TRACE(R"({} reopen socket connection "{}" -> "{}", host="{}", port={})",
-                   log_prefix_,
-                   old_id,
-                   stream_->id(),
-                   bootstrap_hostname_,
-                   bootstrap_port_);
+      return stream_->close([self = shared_from_this(), old_id = stream_->id()](std::error_code) {
+        CB_LOG_DEBUG(R"({} reopened socket connection "{}" -> "{}", host="{}", port={})",
+                     self->log_prefix_,
+                     old_id,
+                     self->stream_->id(),
+                     self->bootstrap_hostname_,
+                     self->bootstrap_port_);
+        return self->initiate_bootstrap();
+      });
     }
     if (origin_.exhausted()) {
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
@@ -1174,6 +1174,20 @@ public:
     if (stopped_) {
       return;
     }
+
+    if (reason == retry_reason::socket_closed_while_in_flight && !bootstrapped_) {
+      return stream_->close([self = shared_from_this(), old_id = stream_->id()](std::error_code) {
+        CB_LOG_DEBUG(
+          R"({} reopened socket connection due to IO error, "{}" -> "{}", host="{}", port={})",
+          self->log_prefix_,
+          old_id,
+          self->stream_->id(),
+          self->bootstrap_hostname_,
+          self->bootstrap_port_);
+        return self->initiate_bootstrap();
+      });
+    }
+
     state_ = diag::endpoint_state::disconnecting;
     CB_LOG_DEBUG("{} stop MCBP connection, reason={}", log_prefix_, reason);
     stopped_ = true;
@@ -1653,6 +1667,7 @@ public:
 private:
   void invoke_bootstrap_handler(std::error_code ec)
   {
+    connection_deadline_.cancel();
     retry_backoff_.cancel();
 
     if (ec && state_listener_) {
@@ -1716,6 +1731,7 @@ private:
     if (ec == asio::error::operation_aborted || stopped_) {
       return;
     }
+    connection_deadline_.cancel();
     last_active_ = std::chrono::steady_clock::now();
     if (ec) {
       CB_LOG_ERROR("{} error on resolve: {} ({})", log_prefix_, ec.value(), ec.message());
@@ -1734,9 +1750,7 @@ private:
       if (timer_ec == asio::error::operation_aborted || self->stopped_) {
         return;
       }
-      return self->stream_->close([self](std::error_code) {
-        self->initiate_bootstrap();
-      });
+      self->initiate_bootstrap();
     });
   }
 
@@ -1768,12 +1782,7 @@ private:
                        port,
                        self->bootstrap_hostname_,
                        self->bootstrap_port_);
-          return self->stream_->close([self](std::error_code ec) {
-            self->last_bootstrap_error_ = {
-              ec, ec.message(), self->bootstrap_hostname_, self->bootstrap_port_
-            };
-            self->initiate_bootstrap();
-          });
+          self->initiate_bootstrap();
         });
       stream_->async_connect(it->endpoint(), [capture0 = shared_from_this(), it](auto&& PH1) {
         capture0->on_connect(std::forward<decltype(PH1)>(PH1), it);
@@ -1801,6 +1810,7 @@ private:
     if (ec == asio::error::operation_aborted || stopped_) {
       return;
     }
+    connection_deadline_.cancel();
     last_active_ = std::chrono::steady_clock::now();
     if (!stream_->is_open() || ec) {
 #ifdef COUCHBASE_CXX_CLIENT_STATIC_BORINGSSL
@@ -1853,23 +1863,26 @@ private:
                                 connection_endpoints_.remote_address,
                                 connection_endpoints_.remote.port());
       parser_.reset();
+      {
+        const std::scoped_lock lock(output_buffer_mutex_);
+        output_buffer_.clear();
+      }
       bootstrap_handler_ = std::make_shared<bootstrap_handler>(shared_from_this());
-      connection_deadline_.cancel();
-    }
-  }
 
-  void check_deadline(std::error_code ec)
-  {
-    if (ec == asio::error::operation_aborted || stopped_) {
-      return;
-    }
-    if (connection_deadline_.expiry() <= asio::steady_timer::clock_type::now()) {
-      stream_->close([](std::error_code) {
+      connection_deadline_.expires_after(origin_.options().key_value_timeout);
+      connection_deadline_.async_wait([self = shared_from_this()](const auto timer_ec) {
+        if (timer_ec == asio::error::operation_aborted || self->stopped_) {
+          return;
+        }
+        CB_LOG_DEBUG("{} unable to boostrap single node at {}:{} (\"{}:{}\") in time, reconnecting",
+                     self->log_prefix_,
+                     self->connection_endpoints_.remote_address,
+                     self->connection_endpoints_.remote.port(),
+                     self->bootstrap_hostname_,
+                     self->bootstrap_port_);
+        return self->initiate_bootstrap();
       });
     }
-    connection_deadline_.async_wait([capture0 = shared_from_this()](auto&& PH1) {
-      capture0->check_deadline(std::forward<decltype(PH1)>(PH1));
-    });
   }
 
   void do_read()
@@ -1883,6 +1896,7 @@ private:
       [self = shared_from_this(), stream_id = stream_->id()](std::error_code ec,
                                                              std::size_t bytes_transferred) {
         if (ec == asio::error::operation_aborted || self->stopped_) {
+          self->reading_ = false;
           CB_LOG_PROTOCOL("[MCBP, IN] host=\"{}\", port={}, rc={}, bytes_received={}",
                           self->connection_endpoints_.remote_address,
                           self->connection_endpoints_.remote.port(),
@@ -1901,6 +1915,7 @@ private:
 
         self->last_active_ = std::chrono::steady_clock::now();
         if (ec) {
+          self->reading_ = false;
           if (stream_id != self->stream_->id()) {
             CB_LOG_ERROR(
               R"({} ignore IO error while reading from the socket: {} ({}), old_id="{}", new_id="{}")",

data/ext/couchbase/core/io/streams.cxx

@@ -0,0 +1,256 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2024 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.
+ */
+
+#include "streams.hxx"
+
+#include "core/platform/uuid.h"
+
+#include <asio.hpp>
+#include <asio/error.hpp>
+#include <asio/ssl.hpp>
+
+namespace couchbase::core::io
+{
+stream_impl::stream_impl(asio::io_context& ctx, bool is_tls)
+  : strand_(asio::make_strand(ctx))
+  , tls_(is_tls)
+  , id_(uuid::to_string(uuid::random()))
+{
+}
+
+auto
+stream_impl::log_prefix() const -> std::string_view
+{
+  return tls_ ? "tls" : "plain";
+}
+
+auto
+stream_impl::id() const -> const std::string&
+{
+  return id_;
+}
+
+plain_stream_impl::plain_stream_impl(asio::io_context& ctx)
+  : stream_impl(ctx, false)
+  , stream_(std::make_shared<asio::ip::tcp::socket>(strand_))
+{
+}
+
+auto
+plain_stream_impl::local_endpoint() const -> asio::ip::tcp::endpoint
+{
+  if (!stream_) {
+    return {};
+  }
+  std::error_code ec;
+  auto res = stream_->local_endpoint(ec);
+  if (ec) {
+    return {};
+  }
+  return res;
+}
+
+auto
+plain_stream_impl::is_open() const -> bool
+{
+  if (stream_) {
+    return stream_->is_open();
+  }
+  return false;
+}
+
+void
+plain_stream_impl::close(utils::movable_function<void(std::error_code)>&& handler)
+{
+  if (!stream_) {
+    return handler(asio::error::bad_descriptor);
+  }
+  return asio::post(strand_, [stream = std::move(stream_), handler = std::move(handler)]() {
+    asio::error_code ec{};
+    stream->shutdown(asio::socket_base::shutdown_both, ec);
+    stream->close(ec);
+    handler(ec);
+  });
+}
+
+void
+plain_stream_impl::set_options()
+{
+  if (!is_open()) {
+    return;
+  }
+  std::error_code ec{};
+  stream_->set_option(asio::ip::tcp::no_delay{ true }, ec);
+  stream_->set_option(asio::socket_base::keep_alive{ true }, ec);
+}
+
+void
+plain_stream_impl::async_connect(
+  const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
+  utils::movable_function<void(std::error_code)>&& handler)
+{
+  if (!stream_) {
+    id_ = uuid::to_string(uuid::random());
+    stream_ = std::make_shared<asio::ip::tcp::socket>(strand_);
+  }
+  return stream_->async_connect(endpoint,
+                                [stream = stream_, handler = std::move(handler)](auto ec) {
+                                  return handler(ec);
+                                });
+}
+
+void
+plain_stream_impl::async_write(
+  std::vector<asio::const_buffer>& buffers,
+  utils::movable_function<void(std::error_code, std::size_t)>&& handler)
+{
+  if (!is_open()) {
+    return handler(asio::error::bad_descriptor, {});
+  }
+  return asio::async_write(
+    *stream_,
+    buffers,
+    [stream = stream_, handler = std::move(handler)](auto ec, auto bytes_transferred) {
+      return handler(ec, bytes_transferred);
+    });
+}
+
+void
+plain_stream_impl::async_read_some(
+  asio::mutable_buffer buffer,
+  utils::movable_function<void(std::error_code, std::size_t)>&& handler)
+{
+  if (!is_open()) {
+    return handler(asio::error::bad_descriptor, {});
+  }
+  return stream_->async_read_some(buffer, std::move(handler));
+}
+
+tls_stream_impl::tls_stream_impl(asio::io_context& ctx, asio::ssl::context& tls)
+  : stream_impl(ctx, true)
+  , tls_(tls)
+  , stream_(
+      std::make_shared<asio::ssl::stream<asio::ip::tcp::socket>>(asio::ip::tcp::socket(strand_),
+                                                                 tls_))
+{
+}
+
+auto
+tls_stream_impl::local_endpoint() const -> asio::ip::tcp::endpoint
+{
+  if (!stream_) {
+    return {};
+  }
+  std::error_code ec;
+  auto res = stream_->lowest_layer().local_endpoint(ec);
+  if (ec) {
+    return {};
+  }
+  return res;
+}
+
+auto
+tls_stream_impl::is_open() const -> bool
+{
+  if (stream_) {
+    return stream_->lowest_layer().is_open();
+  }
+  return false;
+}
+
+void
+tls_stream_impl::close(utils::movable_function<void(std::error_code)>&& handler)
+{
+  if (!stream_) {
+    return handler(asio::error::bad_descriptor);
+  }
+  return asio::post(strand_, [stream = std::move(stream_), handler = std::move(handler)]() {
+    asio::error_code ec{};
+    stream->lowest_layer().shutdown(asio::socket_base::shutdown_both, ec);
+    stream->lowest_layer().close(ec);
+    handler(ec);
+  });
+}
+
+void
+tls_stream_impl::set_options()
+{
+  if (!is_open()) {
+    return;
+  }
+  std::error_code ec{};
+  stream_->lowest_layer().set_option(asio::ip::tcp::no_delay{ true }, ec);
+  stream_->lowest_layer().set_option(asio::socket_base::keep_alive{ true }, ec);
+}
+
+void
+tls_stream_impl::async_connect(const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
+                               utils::movable_function<void(std::error_code)>&& handler)
+{
+  if (!stream_) {
+    id_ = uuid::to_string(uuid::random());
+    stream_ = std::make_shared<asio::ssl::stream<asio::ip::tcp::socket>>(
+      asio::ip::tcp::socket(strand_), tls_);
+  }
+  return stream_->lowest_layer().async_connect(
+    endpoint, [stream = stream_, handler = std::move(handler)](std::error_code ec_connect) mutable {
+      if (ec_connect == asio::error::operation_aborted) {
+        return;
+      }
+      if (ec_connect) {
+        return handler(ec_connect);
+      }
+      stream->async_handshake(
+        asio::ssl::stream_base::client,
+        [stream, handler = std::move(handler)](std::error_code ec_handshake) mutable {
+          if (ec_handshake == asio::error::operation_aborted) {
+            return;
+          }
+          return handler(ec_handshake);
+        });
+    });
+}
+
+void
+tls_stream_impl::async_write(std::vector<asio::const_buffer>& buffers,
+                             utils::movable_function<void(std::error_code, std::size_t)>&& handler)
+{
+  if (!is_open()) {
+    return handler(asio::error::bad_descriptor, {});
+  }
+  return asio::async_write(
+    *stream_,
+    buffers,
+    [stream = stream_, handler = std::move(handler)](auto ec, auto bytes_transferred) {
+      return handler(ec, bytes_transferred);
+    });
+}
+
+void
+tls_stream_impl::async_read_some(
+  asio::mutable_buffer buffer,
+  utils::movable_function<void(std::error_code, std::size_t)>&& handler)
+{
+  if (!is_open()) {
+    return handler(asio::error::bad_descriptor, {});
+  }
+  return stream_->async_read_some(
+    buffer, [stream = stream_, handler = std::move(handler)](auto ec, auto bytes_transferred) {
+      return handler(ec, bytes_transferred);
+    });
+}
+} // namespace couchbase::core::io