couchbase 3.4.1 → 3.4.2

data/ext/couchbase/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_;
 };

data/ext/couchbase/core/transactions/active_transaction_record.hxx

@@ -153,7 +153,7 @@ class active_transaction_record
                 if (const auto* compat = val.find(ATR_FIELD_FORWARD_COMPAT); compat != nullptr) {
                     forward_compat = *compat;
                 }
-
+                std::optional<uint32_t> expires_after_msec = std::max(val.optional<int32_t>(ATR_FIELD_EXPIRES_AFTER_MSECS).value_or(0), 0);
                 entries.emplace_back(resp.ctx.bucket(),
                                      resp.ctx.id(),
                                      key,
@@ -163,7 +163,7 @@ class active_transaction_record
                                      parse_mutation_cas(val.optional<std::string>(ATR_FIELD_TIMESTAMP_COMPLETE).value_or("")),
                                      parse_mutation_cas(val.optional<std::string>(ATR_FIELD_TIMESTAMP_ROLLBACK_START).value_or("")),
                                      parse_mutation_cas(val.optional<std::string>(ATR_FIELD_TIMESTAMP_ROLLBACK_COMPLETE).value_or("")),
-                                     val.optional<std::uint32_t>(ATR_FIELD_EXPIRES_AFTER_MSECS),
+                                     expires_after_msec,
                                      process_document_ids(val, ATR_FIELD_DOCS_INSERTED),
                                      process_document_ids(val, ATR_FIELD_DOCS_REPLACED),
                                      process_document_ids(val, ATR_FIELD_DOCS_REMOVED),

data/ext/couchbase/core/transactions/attempt_context_impl.cxx

@@ -1147,6 +1147,9 @@ attempt_context_impl::get_with_query(const core::document_id& id, bool optional,
                                   // make a transaction_get_result from the row...
                                   try {
                                       if (resp.rows.empty()) {
+                                          if (optional) {
+                                              return op_completed_with_callback(std::move(cb), std::optional<transaction_get_result>());
+                                          }
                                           return op_completed_with_error(
                                             std::move(cb), transaction_operation_failed(FAIL_DOC_NOT_FOUND, "document not found"));
                                       }

data/ext/couchbase/core/transactions/attempt_context_impl.hxx

@@ -456,7 +456,7 @@ class attempt_context_impl
 
     void state(attempt_state s)
     {
-        overall_.current_attempt().state = s;
+        overall_.current_attempt_state(s);
     }
 
     [[nodiscard]] const std::string atr_id()

data/ext/couchbase/core/transactions/internal/transaction_context.hxx

@@ -49,30 +49,29 @@ class transaction_context
 
     [[nodiscard]] std::size_t num_attempts() const
     {
+        std::lock_guard<std::mutex> lock(mutex_);
         return attempts_.size();
     }
-    [[nodiscard]] const std::vector<transaction_attempt>& attempts() const
-    {
-        return attempts_;
-    }
-    [[nodiscard]] std::vector<transaction_attempt>& attempts()
-    {
-        return const_cast<std::vector<transaction_attempt>&>(const_cast<const transaction_context*>(this)->attempts());
-    }
     [[nodiscard]] const transaction_attempt& current_attempt() const
     {
+        std::lock_guard<std::mutex> lock(mutex_);
         if (attempts_.empty()) {
             throw std::runtime_error("transaction context has no attempts yet");
         }
         return attempts_.back();
     }
-    [[nodiscard]] transaction_attempt& current_attempt()
-    {
-        return const_cast<transaction_attempt&>(const_cast<const transaction_context*>(this)->current_attempt());
-    }
 
     void add_attempt();
 
+    void current_attempt_state(attempt_state s)
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        if (attempts_.empty()) {
+            throw std::runtime_error("transaction_context has no attempts yet");
+        }
+        attempts_.back().state = s;
+    }
+
     [[nodiscard]] std::shared_ptr<core::cluster> cluster_ref()
     {
         return transactions_.cluster_ref();
@@ -191,6 +190,7 @@ class transaction_context
     std::string atr_collection_;
     transactions_cleanup& cleanup_;
     std::shared_ptr<attempt_context_impl> current_attempt_context_;
+    mutable std::mutex mutex_;
 
     std::unique_ptr<exp_delay> delay_;
 };

data/ext/couchbase/core/transactions/internal/transactions_cleanup.hxx

@@ -145,6 +145,12 @@ class transactions_cleanup
 
     void attempts_loop();
 
+    bool is_running()
+    {
+        std::unique_lock<std::mutex> lock(mutex_);
+        return running_;
+    }
+
     template<class R, class P>
     bool interruptable_wait(std::chrono::duration<R, P> time);
 
@@ -153,7 +159,7 @@ class transactions_cleanup
     void create_client_record(const couchbase::transactions::transaction_keyspace& keyspace);
     const atr_cleanup_stats handle_atr_cleanup(const core::document_id& atr_id,
                                                std::vector<transactions_cleanup_attempt>* result = nullptr);
-    std::atomic<bool> running_{ false };
+    bool running_{ false };
 };
 } // namespace transactions
 } // namespace couchbase::core

data/ext/couchbase/core/transactions/transaction_context.cxx

@@ -45,6 +45,7 @@ void
 transaction_context::add_attempt()
 {
     transaction_attempt attempt{};
+    std::lock_guard<std::mutex> lock(mutex_);
     attempts_.push_back(attempt);
 }