couchbase 3.4.1 → 3.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 738d96522993c221d75dc83546dc6c9f5447309fbbe4969f6fb92719b0427e78
-  data.tar.gz: 5189c37096e7193f5756050a9713bd7d8f75acd8949e5afe2402fc1834ed538f
+  metadata.gz: 78899f9fd7614787a46a54ca185e869cc93a7714ff0a1ef4c38feef98d7d54be
+  data.tar.gz: f42e90dc0e70b2f690f9c4f7dffe3cd9675db7d8f9025bb5db315b6e59407199
 SHA512:
-  metadata.gz: 85632d1eea3c7139c246f80fadbe8135aacd4b550fdd49a0e33a98342846d39d7d1a7b45abd2d03f1ecbecb9fbdb3401d5ef16b2c52e4bfa3c08edcebfa976e3
-  data.tar.gz: 34202c48810d9ebc8c9930a1f860acafa9a97b4de8304a22e56fa811a9462f02a857d277fb3abf1572226244ed05aeaafd61d23689a74aad6cdae83c33669fca
+  metadata.gz: 804b0a4c05754a5349b19f4b06ee1017f62790e2f5f50696639d9cfc1b785d4f43d688cb05c325f5e10cb1e36fca1e4775c93f91cbf10ad600a5f4755a091a28
+  data.tar.gz: cbb64fe3e1c2f5925584032cd69bb626e87c9ff61c7735a570a7e291287874076e366e2282e15d432c18832b9853c749d806cab28aa65716dc91ab835910bd6b

data/README.md

@@ -23,7 +23,7 @@ The library has been tested with MRI 3.0, 3.1 and 3.2. Supported platforms are L
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "couchbase", "3.4.1"
+gem "couchbase", "3.4.2"
 ```
 
 And then execute:
@@ -139,7 +139,7 @@ Now the API reference is accessible using a web browser (where `VERSION` is the
 
 The gem is available as open source under the terms of the [Apache2 License](https://opensource.org/licenses/Apache-2.0).
 
-    Copyright 2011-2021 Couchbase, Inc.
+    Copyright 2011-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.

data/ext/couchbase/CMakeLists.txt

@@ -255,6 +255,7 @@ set(couchbase_cxx_client_FILES
         core/utils/mutation_token.cxx
         core/utils/split_string.cxx
         core/utils/url_codec.cxx
+        core/impl/analytics.cxx
         core/impl/analytics_error_category.cxx
         core/impl/append.cxx
         core/impl/best_effort_retry_strategy.cxx
@@ -321,6 +322,7 @@ set(couchbase_cxx_client_FILES
         core/impl/upsert.cxx
         core/impl/view_error_category.cxx
         core/impl/watch_query_indexes.cxx
+        core/io/dns_client.cxx
         core/io/dns_config.cxx
         core/io/http_parser.cxx
         core/io/mcbp_message.cxx

data/ext/couchbase/cmake/ThirdPartyDependencies.cmake

@@ -18,6 +18,10 @@ set(PEGTL_BUILD_TESTS OFF CACHE BOOL "" FORCE)
 set(PEGTL_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
 add_subdirectory(${PROJECT_SOURCE_DIR}/third_party/snappy)
 set_target_properties(snappy PROPERTIES POSITION_INDEPENDENT_CODE ON)
+if(NOT MSVC)
+  # https://github.com/google/snappy/pull/156
+  target_compile_options(snappy PRIVATE -Wno-sign-compare)
+endif()
 
 set(HDR_LOG_REQUIRED OFF CACHE BOOL "" FORCE)
 set(HDR_HISTOGRAM_BUILD_SHARED OFF CACHE BOOL "" FORCE)

data/ext/couchbase/core/cluster_options.hxx

@@ -53,7 +53,6 @@ struct cluster_options {
     std::chrono::milliseconds analytics_timeout = timeout_defaults::analytics_timeout;
     std::chrono::milliseconds search_timeout = timeout_defaults::search_timeout;
     std::chrono::milliseconds management_timeout = timeout_defaults::management_timeout;
-    std::chrono::milliseconds dns_srv_timeout = timeout_defaults::dns_srv_timeout;
 
     bool enable_tls{ false };
     std::string trust_certificate{};

data/ext/couchbase/core/config_profile.cxx

@@ -22,4 +22,26 @@ couchbase::core::known_profiles()
 {
     static couchbase::core::config_profiles profiles{};
     return profiles;
-}
+}
+
+void
+couchbase::core::development_profile::apply(couchbase::core::cluster_options& opts)
+{
+    opts.key_value_timeout = std::chrono::seconds(20);
+    opts.key_value_durable_timeout = std::chrono::seconds(20);
+    opts.connect_timeout = std::chrono::seconds(20);
+    opts.view_timeout = std::chrono::minutes(2);
+    opts.query_timeout = std::chrono::minutes(2);
+    opts.analytics_timeout = std::chrono::minutes(2);
+    opts.search_timeout = std::chrono::minutes(2);
+    opts.management_timeout = std::chrono::minutes(2);
+
+    // C++SDK specific
+    opts.dns_config = couchbase::core::io::dns::dns_config{
+        opts.dns_config.nameserver(),
+        opts.dns_config.port(),
+        std::chrono::seconds(20), // timeout to make DNS-SRV query
+    };
+    opts.resolve_timeout = std::chrono::seconds(20);  // timeout to resolve hostnames
+    opts.bootstrap_timeout = std::chrono::minutes(2); // overall timeout to bootstrap
+}

data/ext/couchbase/core/config_profile.hxx

@@ -36,17 +36,7 @@ class config_profile
 class development_profile : public config_profile
 {
   public:
-    void apply(couchbase::core::cluster_options& opts) override
-    {
-        opts.key_value_timeout = std::chrono::milliseconds(20000); // 20 sec kv timeout.
-        opts.key_value_durable_timeout = std::chrono::milliseconds(20000); // 20 sec durable kv timeout.
-        opts.connect_timeout = std::chrono::milliseconds(20000);           // 20 sec connect timeout.
-        opts.view_timeout = std::chrono::milliseconds(120000);             // 2 minute view timeout
-        opts.query_timeout = std::chrono::milliseconds(120000);            // 2 minute query timeout
-        opts.analytics_timeout = std::chrono::milliseconds(120000);        // 2 minute analytics timeout
-        opts.search_timeout = std::chrono::milliseconds(120000);           // 2 minute search timeout
-        opts.management_timeout = std::chrono::milliseconds(120000);       // 2 minute management timeout
-    }
+    void apply(couchbase::core::cluster_options& opts) override;
 };
 
 // this class just registers the known profiles defined above, and allows access to them.
@@ -89,4 +79,4 @@ class config_profiles
 config_profiles&
 known_profiles();
 
-} // namespace couchbase::core
+} // namespace couchbase::core

data/ext/couchbase/core/impl/analytics.cxx

@@ -0,0 +1,236 @@
+/* -*- 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.
+ */
+
+#include <couchbase/cluster.hxx>
+#include <couchbase/error_codes.hxx>
+
+#include "core/cluster.hxx"
+#include "core/operations/document_analytics.hxx"
+
+namespace couchbase
+{
+static analytics_error_context
+build_context(core::operations::analytics_response& resp)
+{
+    return {
+        resp.ctx.ec,
+        resp.ctx.last_dispatched_to,
+        resp.ctx.last_dispatched_from,
+        resp.ctx.retry_attempts,
+        std::move(resp.ctx.retry_reasons),
+        resp.ctx.first_error_code,
+        std::move(resp.ctx.first_error_message),
+        std::move(resp.ctx.client_context_id),
+        std::move(resp.ctx.statement),
+        std::move(resp.ctx.parameters),
+        std::move(resp.ctx.method),
+        std::move(resp.ctx.path),
+        resp.ctx.http_status,
+        std::move(resp.ctx.http_body),
+        std::move(resp.ctx.hostname),
+        resp.ctx.port,
+    };
+}
+
+static analytics_status
+map_status(core::operations::analytics_response::analytics_status status)
+{
+    switch (status) {
+        case core::operations::analytics_response::running:
+            return analytics_status::running;
+        case core::operations::analytics_response::success:
+            return analytics_status::success;
+        case core::operations::analytics_response::errors:
+            return analytics_status::errors;
+        case core::operations::analytics_response::completed:
+            return analytics_status::completed;
+        case core::operations::analytics_response::stopped:
+            return analytics_status::stopped;
+        case core::operations::analytics_response::timedout:
+            return analytics_status::timeout;
+        case core::operations::analytics_response::closed:
+            return analytics_status::closed;
+        case core::operations::analytics_response::fatal:
+            return analytics_status::fatal;
+        case core::operations::analytics_response::aborted:
+            return analytics_status::aborted;
+        case core::operations::analytics_response::unknown:
+            return analytics_status::unknown;
+    }
+    return analytics_status::unknown;
+}
+
+static std::optional<couchbase::core::analytics_scan_consistency>
+map_scan_consistency(std::optional<couchbase::analytics_scan_consistency> consistency)
+{
+    if (consistency.has_value()) {
+        switch (consistency.value()) {
+            case analytics_scan_consistency::not_bounded:
+                return couchbase::core::analytics_scan_consistency::not_bounded;
+            case analytics_scan_consistency::request_plus:
+                return couchbase::core::analytics_scan_consistency::request_plus;
+        }
+    }
+    return {};
+}
+
+static std::vector<codec::binary>
+map_rows(const core::operations::analytics_response& resp)
+{
+    std::vector<codec::binary> rows;
+    rows.reserve(resp.rows.size());
+    for (const auto& row : resp.rows) {
+        rows.emplace_back(core::utils::to_binary(row));
+    }
+    return rows;
+}
+
+static std::vector<analytics_warning>
+map_warnings(core::operations::analytics_response& resp)
+{
+    if (resp.meta.warnings.empty()) {
+        return {};
+    }
+    std::vector<analytics_warning> warnings;
+    warnings.reserve(resp.meta.warnings.size());
+    for (auto& warning : resp.meta.warnings) {
+        warnings.emplace_back(warning.code, std::move(warning.message));
+    }
+    return warnings;
+}
+
+static analytics_metrics
+map_metrics(const core::operations::analytics_response& resp)
+{
+    return analytics_metrics{
+        resp.meta.metrics.elapsed_time,  resp.meta.metrics.execution_time,    resp.meta.metrics.result_count,
+        resp.meta.metrics.result_size,   resp.meta.metrics.processed_objects, resp.meta.metrics.error_count,
+        resp.meta.metrics.warning_count,
+    };
+}
+
+static std::optional<std::vector<std::byte>>
+map_signature(core::operations::analytics_response& resp)
+{
+    if (!resp.meta.signature) {
+        return {};
+    }
+    return core::utils::to_binary(resp.meta.signature.value());
+}
+
+static analytics_result
+build_result(core::operations::analytics_response& resp)
+{
+    return {
+        analytics_meta_data{
+          std::move(resp.meta.request_id),
+          std::move(resp.meta.client_context_id),
+          map_status(resp.meta.status),
+          map_warnings(resp),
+          map_metrics(resp),
+          map_signature(resp),
+        },
+        map_rows(resp),
+    };
+}
+
+static core::operations::analytics_request
+build_analytics_request(std::string statement,
+                        analytics_options::built options,
+                        std::optional<std::string> bucket_name,
+                        std::optional<std::string> scope_name)
+{
+    core::operations::analytics_request request{
+        std::move(statement),
+        options.readonly,
+        options.priority,
+        std::move(bucket_name),
+        std::move(scope_name),
+        {},
+        map_scan_consistency(options.scan_consistency),
+        {},
+        {},
+        {},
+        {},
+        std::move(options.client_context_id),
+        options.timeout,
+    };
+    if (!options.raw.empty()) {
+        for (auto& [name, value] : options.raw) {
+            request.raw[name] = std::move(value);
+        }
+    }
+    if (!options.positional_parameters.empty()) {
+        for (auto& value : options.positional_parameters) {
+            request.positional_parameters.emplace_back(std::move(value));
+        }
+    }
+    if (!options.named_parameters.empty()) {
+        for (auto& [name, value] : options.named_parameters) {
+            request.named_parameters[name] = std::move(value);
+        }
+    }
+    return request;
+}
+
+void
+cluster::analytics_query(std::string statement, const analytics_options& options, analytics_handler&& handler) const
+{
+    auto request = build_analytics_request(std::move(statement), options.build(), {}, {});
+
+    core_->execute(std::move(request), [handler = std::move(handler)](core::operations::analytics_response resp) mutable {
+        auto r = std::move(resp);
+        return handler(build_context(r), build_result(r));
+    });
+}
+
+auto
+cluster::analytics_query(std::string statement, const analytics_options& options) const
+  -> std::future<std::pair<analytics_error_context, analytics_result>>
+{
+    auto barrier = std::make_shared<std::promise<std::pair<analytics_error_context, analytics_result>>>();
+    auto future = barrier->get_future();
+    analytics_query(std::move(statement), options, [barrier](auto ctx, auto result) {
+        barrier->set_value({ std::move(ctx), std::move(result) });
+    });
+    return future;
+}
+
+void
+scope::analytics_query(std::string statement, const analytics_options& options, analytics_handler&& handler) const
+{
+    auto request = build_analytics_request(std::move(statement), options.build(), bucket_name_, name_);
+
+    core_->execute(std::move(request), [handler = std::move(handler)](core::operations::analytics_response resp) mutable {
+        auto r = std::move(resp);
+        return handler(build_context(r), build_result(r));
+    });
+}
+
+auto
+scope::analytics_query(std::string statement, const analytics_options& options) const
+  -> std::future<std::pair<analytics_error_context, analytics_result>>
+{
+    auto barrier = std::make_shared<std::promise<std::pair<analytics_error_context, analytics_result>>>();
+    auto future = barrier->get_future();
+    analytics_query(std::move(statement), options, [barrier](auto ctx, auto result) {
+        barrier->set_value({ std::move(ctx), std::move(result) });
+    });
+    return future;
+}
+
+} // namespace couchbase

data/ext/couchbase/core/impl/cluster.cxx

@@ -95,7 +95,6 @@ options_to_origin(const std::string& connection_string, const couchbase::cluster
     if (opts.dns.nameserver) {
         user_options.dns_config =
           io::dns::dns_config(opts.dns.nameserver.value(), opts.dns.port.value_or(io::dns::dns_config::default_port), opts.dns.timeout);
-        user_options.dns_srv_timeout = opts.dns.timeout;
     }
     user_options.enable_clustermap_notification = opts.behavior.enable_clustermap_notification;
     user_options.show_queries = opts.behavior.show_queries;

data/ext/couchbase/core/impl/dns_srv_tracker.cxx

@@ -16,11 +16,13 @@
  */
 
 #include "dns_srv_tracker.hxx"
-#include "../logger/logger.hxx"
-#include "../topology/configuration.hxx"
+
+#include "core/logger/logger.hxx"
+#include "core/utils/join_strings.hxx"
 
 #include <asio/bind_executor.hpp>
 #include <asio/io_context.hpp>
+#include <asio/post.hpp>
 
 #include <memory>
 
@@ -44,7 +46,7 @@ dns_srv_tracker::get_srv_nodes(utils::movable_function<void(origin::node_list, s
       address_,
       service_,
       config_,
-      [self = shared_from_this(), callback = std::move(callback)](couchbase::core::io::dns::dns_client::dns_srv_response&& resp) mutable {
+      [self = shared_from_this(), callback = std::move(callback)](couchbase::core::io::dns::dns_srv_response&& resp) mutable {
           origin::node_list nodes;
           if (resp.ec) {
               CB_LOG_WARNING("failed to fetch DNS SRV records for \"{}\" ({}), assuming that cluster is listening this address",

data/ext/couchbase/core/impl/query.cxx

@@ -152,10 +152,10 @@ build_result(operations::query_response& resp)
 }
 
 static core::operations::query_request
-build_query_request(query_options::built options)
+build_query_request(std::string statement, query_options::built options)
 {
     operations::query_request request{
-        "",
+        std::move(statement),
         options.adhoc,
         options.metrics,
         options.readonly,
@@ -222,8 +222,9 @@ build_transaction_query_result(operations::query_response resp, std::error_code
 core::operations::query_request
 build_transaction_query_request(query_options::built opts)
 {
-    return build_query_request(opts);
+    return build_query_request("", opts);
 }
+
 void
 initiate_query_operation(std::shared_ptr<couchbase::core::cluster> core,
                          std::string statement,
@@ -231,8 +232,7 @@ initiate_query_operation(std::shared_ptr<couchbase::core::cluster> core,
                          query_options::built options,
                          query_handler&& handler)
 {
-    auto request = build_query_request(options);
-    request.statement = std::move(statement);
+    auto request = build_query_request(std::move(statement), options);
     if (query_context) {
         request.query_context = std::move(query_context);
     }

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

@@ -0,0 +1,225 @@
+/* -*- 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.
+ */
+
+#include "dns_client.hxx"
+
+#include "core/logger/logger.hxx"
+#include "core/utils/join_strings.hxx"
+#include "dns_codec.hxx"
+#include "dns_config.hxx"
+
+#include <couchbase/error_codes.hxx>
+
+#include <asio/ip/tcp.hpp>
+#include <asio/read.hpp>
+#include <asio/write.hpp>
+
+#include <memory>
+#include <sstream>
+
+namespace couchbase::core::io::dns
+{
+class dns_srv_command : public std::enable_shared_from_this<dns_srv_command>
+{
+  public:
+    dns_srv_command(asio::io_context& ctx,
+                    const std::string& name,
+                    const std::string& service,
+                    const asio::ip::address& address,
+                    std::uint16_t port,
+                    utils::movable_function<void(couchbase::core::io::dns::dns_srv_response&& resp)> handler)
+      : deadline_(ctx)
+      , udp_deadline_(ctx)
+      , udp_(ctx)
+      , tcp_(ctx)
+      , address_(address)
+      , port_(port)
+      , handler_(std::move(handler))
+    {
+        static std::string protocol{ "_tcp" };
+        dns_message request{};
+        question_record qr;
+        qr.klass = resource_class::in;
+        qr.type = resource_type::srv;
+        qr.name.labels.push_back(service);
+        qr.name.labels.push_back(protocol);
+        std::string label;
+        std::istringstream name_stream(name);
+        while (std::getline(name_stream, label, '.')) {
+            qr.name.labels.push_back(label);
+        }
+        request.questions.emplace_back(qr);
+        send_buf_ = dns_codec::encode(request);
+    }
+
+    void execute(std::chrono::milliseconds total_timeout, std::chrono::milliseconds udp_timeout)
+    {
+        asio::ip::udp::endpoint endpoint(address_, port_);
+        udp_.open(endpoint.protocol());
+        udp_.async_send_to(
+          asio::buffer(send_buf_), endpoint, [self = shared_from_this()](std::error_code ec1, std::size_t /* bytes_transferred */) mutable {
+              if (ec1) {
+                  self->udp_deadline_.cancel();
+                  CB_LOG_DEBUG("DNS UDP write operation has got error {}, retrying with TCP", ec1.message());
+                  return self->retry_with_tcp();
+              }
+
+              self->recv_buf_.resize(512);
+              self->udp_.async_receive_from(
+                asio::buffer(self->recv_buf_), self->udp_sender_, [self](std::error_code ec2, std::size_t bytes_transferred) mutable {
+                    self->udp_deadline_.cancel();
+                    if (ec2) {
+                        CB_LOG_DEBUG("DNS UDP read operation has got error {}, retrying with TCP", ec2.message());
+                        return self->retry_with_tcp();
+                    }
+                    self->recv_buf_.resize(bytes_transferred);
+                    const dns_message message = dns_codec::decode(self->recv_buf_);
+                    if (message.header.flags.tc == truncation::yes) {
+                        self->udp_.close();
+                        CB_LOG_DEBUG("DNS UDP read operation returned truncated response, retrying with TCP");
+                        return self->retry_with_tcp();
+                    }
+                    self->deadline_.cancel();
+                    dns_srv_response resp{ ec2 };
+                    resp.targets.reserve(message.answers.size());
+                    for (const auto& answer : message.answers) {
+                        resp.targets.emplace_back(dns_srv_response::address{ utils::join_strings(answer.target.labels, "."), answer.port });
+                    }
+                    CB_LOG_DEBUG("DNS UDP returned {} records", resp.targets.size());
+                    return self->handler_(std::move(resp));
+                });
+          });
+        udp_deadline_.expires_after(udp_timeout);
+        deadline_.async_wait([self = shared_from_this()](std::error_code ec) {
+            if (ec == asio::error::operation_aborted) {
+                return;
+            }
+            CB_LOG_DEBUG("DNS UDP deadline has been reached, cancelling UDP operation and fall back to TCP");
+            self->udp_.cancel();
+            return self->retry_with_tcp();
+        });
+
+        deadline_.expires_after(total_timeout);
+        deadline_.async_wait([self = shared_from_this()](std::error_code ec) {
+            if (ec == asio::error::operation_aborted) {
+                return;
+            }
+            CB_LOG_DEBUG("DNS deadline has been reached, cancelling in-flight operations (tcp.is_open={})", self->tcp_.is_open());
+            self->udp_.cancel();
+            if (self->tcp_.is_open()) {
+                self->tcp_.cancel();
+            }
+        });
+    }
+
+  private:
+    void retry_with_tcp()
+    {
+        if (bool expected_state{ false }; !retrying_with_tcp_.compare_exchange_strong(expected_state, true)) {
+            return;
+        }
+
+        const asio::ip::tcp::no_delay no_delay(true);
+        std::error_code ignore_ec;
+        tcp_.set_option(no_delay, ignore_ec);
+        const asio::ip::tcp::endpoint endpoint(address_, port_);
+        tcp_.async_connect(endpoint, [self = shared_from_this()](std::error_code ec1) mutable {
+            if (ec1) {
+                self->deadline_.cancel();
+                CB_LOG_DEBUG("DNS TCP connection has been aborted, {}", ec1.message());
+                return self->handler_({ ec1 });
+            }
+            auto send_size = static_cast<std::uint16_t>(self->send_buf_.size());
+            self->send_buf_.insert(self->send_buf_.begin(), static_cast<std::uint8_t>(send_size & 0xffU));
+            self->send_buf_.insert(self->send_buf_.begin(), static_cast<std::uint8_t>(send_size >> 8U));
+            asio::async_write(
+              self->tcp_, asio::buffer(self->send_buf_), [self](std::error_code ec2, std::size_t /* bytes_transferred */) mutable {
+                  if (ec2) {
+                      CB_LOG_DEBUG("DNS TCP write operation has been aborted, {}", ec2.message());
+                      self->deadline_.cancel();
+                      if (ec2 == asio::error::operation_aborted) {
+                          ec2 = errc::common::unambiguous_timeout;
+                      }
+                      return self->handler_({ ec2 });
+                  }
+                  asio::async_read(self->tcp_,
+                                   asio::buffer(&self->recv_buf_size_, sizeof(std::uint16_t)),
+                                   [self](std::error_code ec3, std::size_t /* bytes_transferred */) mutable {
+                                       if (ec3) {
+                                           CB_LOG_DEBUG("DNS TCP buf size read operation has been aborted, {}", ec3.message());
+                                           self->deadline_.cancel();
+                                           return self->handler_({ ec3 });
+                                       }
+                                       self->recv_buf_size_ = utils::byte_swap(self->recv_buf_size_);
+                                       self->recv_buf_.resize(self->recv_buf_size_);
+                                       CB_LOG_DEBUG("DNS TCP schedule read of {} bytes", self->recv_buf_size_);
+                                       asio::async_read(self->tcp_,
+                                                        asio::buffer(self->recv_buf_),
+                                                        [self](std::error_code ec4, std::size_t bytes_transferred) mutable {
+                                                            self->deadline_.cancel();
+                                                            if (ec4) {
+                                                                CB_LOG_DEBUG("DNS TCP read operation has been aborted, {}", ec4.message());
+                                                                return self->handler_({ ec4 });
+                                                            }
+                                                            self->recv_buf_.resize(bytes_transferred);
+                                                            const dns_message message = dns_codec::decode(self->recv_buf_);
+                                                            dns_srv_response resp{ ec4 };
+                                                            resp.targets.reserve(message.answers.size());
+                                                            for (const auto& answer : message.answers) {
+                                                                resp.targets.emplace_back(dns_srv_response::address{
+                                                                  utils::join_strings(answer.target.labels, "."), answer.port });
+                                                            }
+                                                            CB_LOG_DEBUG("DNS TCP returned {} records", resp.targets.size());
+                                                            return self->handler_(std::move(resp));
+                                                        });
+                                   });
+              });
+        });
+    }
+
+    asio::steady_timer deadline_;
+    asio::steady_timer udp_deadline_;
+    asio::ip::udp::socket udp_;
+    asio::ip::udp::endpoint udp_sender_{};
+    asio::ip::tcp::socket tcp_;
+
+    asio::ip::address address_;
+    std::uint16_t port_;
+    utils::movable_function<void(couchbase::core::io::dns::dns_srv_response&& resp)> handler_;
+
+    std::vector<std::uint8_t> send_buf_{};
+    std::uint16_t recv_buf_size_{ 0 };
+    std::vector<std::uint8_t> recv_buf_{};
+
+    std::atomic_bool retrying_with_tcp_{ false };
+};
+
+void
+dns_client::query_srv(const std::string& name,
+                      const std::string& service,
+                      const dns_config& config,
+                      utils::movable_function<void(dns_srv_response&&)>&& handler)
+{
+    std::error_code ec;
+    auto address = asio::ip::address::from_string(config.nameserver(), ec);
+    if (ec) {
+        return handler({ ec });
+    }
+    auto cmd = std::make_shared<dns_srv_command>(ctx_, name, service, address, config.port(), std::move(handler));
+    return cmd->execute(config.timeout(), config.timeout() / 2);
+}
+} // namespace couchbase::core::io::dns