couchbase 4.2.2 → 4.2.3

package/deps/couchbase-cxx-client/core/impl/collection_query_index_manager.cxx

@@ -22,14 +22,14 @@ namespace couchbase
 {
 
 void
-collection_query_index_manager::get_all_indexes(const get_all_query_indexes_options& options, get_all_indexes_handler&& handler) const
+collection_query_index_manager::get_all_indexes(const get_all_query_indexes_options& options, get_all_query_indexes_handler&& handler) const
 {
     return core::impl::initiate_get_all_query_indexes(core_,
                                                       "",
                                                       options.build(),
                                                       core::query_context(bucket_name_, scope_name_),
                                                       collection_name_,
-                                                      std::forward<get_all_indexes_handler>(handler));
+                                                      std::forward<get_all_query_indexes_handler>(handler));
 }
 
 void
@@ -90,4 +90,4 @@ collection_query_index_manager::watch_indexes(std::vector<std::string> index_nam
     return core::impl::initiate_watch_query_indexes(
       core_, "", std::move(index_names), options.build(), { bucket_name_, scope_name_ }, collection_name_, std::move(handler));
 }
-} // namespace couchbase
+} // namespace couchbase

package/deps/couchbase-cxx-client/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",

package/deps/couchbase-cxx-client/core/impl/get_all_query_indexes.cxx

@@ -45,7 +45,7 @@ initiate_get_all_query_indexes(std::shared_ptr<couchbase::core::cluster> core,
                                couchbase::get_all_query_indexes_options::built options,
                                query_context query_ctx,
                                std::string collection_name,
-                               get_all_indexes_handler&& handler)
+                               get_all_query_indexes_handler&& handler)
 {
     core->execute(
       operations::management::query_index_get_all_request{
@@ -68,9 +68,9 @@ void
 initiate_get_all_query_indexes(std::shared_ptr<couchbase::core::cluster> core,
                                std::string bucket_name,
                                couchbase::get_all_query_indexes_options::built options,
-                               get_all_indexes_handler&& handler)
+                               get_all_query_indexes_handler&& handler)
 {
     initiate_get_all_query_indexes(core, std::move(bucket_name), options, {}, "", std::move(handler));
 }
 
-} // namespace couchbase::core::impl
+} // namespace couchbase::core::impl

package/deps/couchbase-cxx-client/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,
@@ -191,7 +191,7 @@ build_query_request(query_options::built options)
     return request;
 }
 
-couchbase::transactions::transaction_query_result
+std::pair<couchbase::transaction_op_error_context, couchbase::transactions::transaction_query_result>
 build_transaction_query_result(operations::query_response resp, std::error_code txn_ec /*defaults to 0*/)
 {
     if (resp.ctx.ec) {
@@ -204,24 +204,27 @@ build_transaction_query_result(operations::query_response resp, std::error_code
             txn_ec = errc::transaction_op::not_set;
         }
     }
-    return { query_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_profile(resp),
-             },
-             map_rows(resp),
-             { txn_ec, build_context(resp) } };
+    return {
+        { txn_ec, build_context(resp) },
+        { query_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_profile(resp),
+          },
+          map_rows(resp) },
+    };
 }
 
 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,
@@ -229,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);
     }

package/deps/couchbase-cxx-client/core/impl/subdoc/lookup_in_macro.cxx

@@ -18,6 +18,7 @@
 #include <couchbase/error_codes.hxx>
 #include <couchbase/subdoc/lookup_in_macro.hxx>
 
+#include <cstdint>
 #include <string>
 
 namespace couchbase::subdoc

package/deps/couchbase-cxx-client/core/impl/subdoc/mutate_in_macro.cxx

@@ -18,6 +18,7 @@
 #include <couchbase/error_codes.hxx>
 #include <couchbase/subdoc/mutate_in_macro.hxx>
 
+#include <cstdint>
 #include <string>
 
 namespace couchbase::subdoc

package/deps/couchbase-cxx-client/core/impl/transaction_get_result.cxx

@@ -0,0 +1,54 @@
+
+
+#include <core/transactions/transaction_get_result.hxx>
+#include <couchbase/transactions/transaction_get_result.hxx>
+
+namespace couchbase::transactions
+{
+
+transaction_get_result::transaction_get_result()
+  : base_(std::make_shared<couchbase::core::transactions::transaction_get_result>())
+{
+}
+
+const std::vector<std::byte>&
+transaction_get_result::content() const
+{
+    return base_->content();
+}
+void
+transaction_get_result::content(std::vector<std::byte> content)
+{
+    return base_->content(content);
+}
+void
+transaction_get_result::content(std::vector<std::byte>&& content)
+{
+    return base_->content(content);
+}
+const std::string
+transaction_get_result::key() const
+{
+    return base_->key();
+}
+const std::string
+transaction_get_result::bucket() const
+{
+    return base_->bucket();
+}
+const std::string
+transaction_get_result::scope() const
+{
+    return base_->scope();
+}
+const std::string
+transaction_get_result::collection() const
+{
+    return base_->collection();
+}
+const couchbase::cas
+transaction_get_result::cas() const
+{
+    return base_->cas();
+}
+} // namespace couchbase::transactions

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

package/deps/couchbase-cxx-client/core/io/dns_client.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *   Copyright 2020-2021 Couchbase, Inc.
+ *   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.
@@ -17,207 +17,38 @@
 
 #pragma once
 
-#include "core/utils/join_strings.hxx"
-#include "dns_codec.hxx"
+#include "core/utils/movable_function.hxx"
 #include "dns_config.hxx"
 
-#include <couchbase/error_codes.hxx>
+#include <asio/io_context.hpp>
 
-#include <asio/ip/tcp.hpp>
-#include <asio/read.hpp>
-#include <asio/write.hpp>
-
-#include <memory>
-#include <sstream>
+#include <cinttypes>
+#include <string>
+#include <vector>
 
 namespace couchbase::core::io::dns
 {
+struct dns_srv_response {
+    struct address {
+        std::string hostname;
+        std::uint16_t port;
+    };
+    std::error_code ec;
+    std::vector<address> targets{};
+};
+
 class dns_client
 {
   public:
-    struct dns_srv_response {
-        struct address {
-            std::string hostname;
-            std::uint16_t port;
-        };
-        std::error_code ec;
-        std::vector<address> targets{};
-    };
-
-    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)
-          : deadline_(ctx)
-          , udp_(ctx)
-          , tcp_(ctx)
-          , address_(address)
-          , port_(port)
-        {
-            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);
-        }
-
-        template<class Handler>
-        void execute(std::chrono::milliseconds timeout, Handler&& handler)
-        {
-            asio::ip::udp::endpoint endpoint(address_, port_);
-            udp_.open(endpoint.protocol());
-            udp_.async_send_to(asio::buffer(send_buf_),
-                               endpoint,
-                               [self = shared_from_this(), handler = std::forward<Handler>(handler)](
-                                 std::error_code ec1, std::size_t /* bytes_transferred */) mutable {
-                                   if (ec1 == asio::error::operation_aborted) {
-                                       self->deadline_.cancel();
-                                       return handler({ errc::common::unambiguous_timeout });
-                                   }
-                                   if (ec1) {
-                                       self->deadline_.cancel();
-                                       return handler({ ec1 });
-                                   }
-
-                                   self->recv_buf_.resize(512);
-                                   self->udp_.async_receive_from(asio::buffer(self->recv_buf_),
-                                                                 self->udp_sender_,
-                                                                 [self, handler = std::forward<Handler>(handler)](
-                                                                   std::error_code ec2, std::size_t bytes_transferred) mutable {
-                                                                     self->deadline_.cancel();
-                                                                     if (ec2) {
-                                                                         return handler({ ec2 });
-                                                                     }
-                                                                     self->recv_buf_.resize(bytes_transferred);
-                                                                     dns_message message = dns_codec::decode(self->recv_buf_);
-                                                                     if (message.header.flags.tc == truncation::yes) {
-                                                                         self->udp_.close();
-                                                                         return self->retry_with_tcp(std::forward<Handler>(handler));
-                                                                     }
-                                                                     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 });
-                                                                     }
-                                                                     return handler(std::move(resp));
-                                                                 });
-                               });
-            deadline_.expires_after(timeout);
-            deadline_.async_wait([self = shared_from_this()](std::error_code ec) {
-                if (ec == asio::error::operation_aborted) {
-                    return;
-                }
-                self->udp_.cancel();
-                if (self->tcp_.is_open()) {
-                    self->tcp_.cancel();
-                }
-            });
-        }
-
-      private:
-        template<class Handler>
-        void retry_with_tcp(Handler&& handler)
-        {
-            asio::ip::tcp::no_delay no_delay(true);
-            std::error_code ignore_ec;
-            tcp_.set_option(no_delay, ignore_ec);
-            asio::ip::tcp::endpoint endpoint(address_, port_);
-            tcp_.async_connect(
-              endpoint, [self = shared_from_this(), handler = std::forward<Handler>(handler)](std::error_code ec1) mutable {
-                  if (ec1) {
-                      self->deadline_.cancel();
-                      return handler({ ec1 });
-                  }
-                  auto send_size = static_cast<std::uint16_t>(self->send_buf_.size());
-                  self->send_buf_.insert(self->send_buf_.begin(), std::uint8_t(send_size & 0xffU));
-                  self->send_buf_.insert(self->send_buf_.begin(), std::uint8_t(send_size >> 8U));
-                  asio::async_write(
-                    self->tcp_,
-                    asio::buffer(self->send_buf_),
-                    [self, handler = std::forward<Handler>(handler)](std::error_code ec2, std::size_t /* bytes_transferred */) mutable {
-                        if (ec2) {
-                            self->deadline_.cancel();
-                            if (ec2 == asio::error::operation_aborted) {
-                                ec2 = errc::common::unambiguous_timeout;
-                            }
-                            return handler({ ec2 });
-                        }
-                        asio::async_read(self->tcp_,
-                                         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) {
-                                                 self->deadline_.cancel();
-                                                 return handler({ ec3 });
-                                             }
-                                             self->recv_buf_size_ = utils::byte_swap(self->recv_buf_size_);
-                                             self->recv_buf_.resize(self->recv_buf_size_);
-                                             asio::async_read(self->tcp_,
-                                                              asio::buffer(self->recv_buf_),
-                                                              [self, handler = std::forward<Handler>(handler)](
-                                                                std::error_code ec4, std::size_t bytes_transferred) mutable {
-                                                                  self->deadline_.cancel();
-                                                                  if (ec4) {
-                                                                      return handler({ ec4 });
-                                                                  }
-                                                                  self->recv_buf_.resize(bytes_transferred);
-                                                                  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 });
-                                                                  }
-                                                                  return handler(std::move(resp));
-                                                              });
-                                         });
-                    });
-              });
-        }
-
-        asio::steady_timer 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_;
-
-        std::vector<std::uint8_t> send_buf_{};
-        std::uint16_t recv_buf_size_{ 0 };
-        std::vector<std::uint8_t> recv_buf_{};
-    };
-
     explicit dns_client(asio::io_context& ctx)
       : ctx_(ctx)
     {
     }
 
-    template<class Handler>
-    void query_srv(const std::string& name, const std::string& service, const dns_config& config, Handler&& 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());
-        cmd->execute(config.timeout(), std::forward<Handler>(handler));
-    }
+    void query_srv(const std::string& name,
+                   const std::string& service,
+                   const dns_config& config,
+                   utils::movable_function<void(couchbase::core::io::dns::dns_srv_response&& resp)>&& handler);
 
     asio::io_context& ctx_;
 };