couchbase 3.0.0.alpha.2-universal-darwin-19 → 3.0.0-universal-darwin-19

data/ext/couchbase/error_map.hxx

@@ -20,12 +20,112 @@
 namespace couchbase
 {
 struct error_map {
+    enum class attribute {
+        /**
+         * The operation was successful for those situations where the error code is indicating successful (i.e. subdoc operations carried
+         * out on a deleted document)
+         */
+        success,
+
+        /**
+         * This attribute means that the error is related to a constraint failure regarding the item itself, i.e. the item does not exist,
+         * already exists, or its current value makes the current operation impossible. Retrying the operation when the item's value or
+         * status has changed may succeed.
+         */
+        item_only,
+
+        /**
+         * This attribute means that a user's input was invalid because it violates the semantics of the operation, or exceeds some
+         * predefined limit.
+         */
+        invalid_input,
+
+        /**
+         * The client's cluster map may be outdated and requires updating. The client should obtain a newer configuration.
+         */
+        fetch_config,
+
+        /**
+         * The current connection is no longer valid. The client must reconnect to the server. Note that the presence of other attributes
+         * may indicate an alternate remedy to fixing the connection without a disconnect, but without special remedial action a disconnect
+         * is needed.
+         */
+        conn_state_invalidated,
+
+        /**
+         * The operation failed because the client failed to authenticate or is not authorized to perform this operation. Note that this
+         * error in itself does not mean the connection is invalid, unless conn-state-invalidated is also present.
+         */
+        auth,
+
+        /**
+         * This error code must be handled specially. If it is not handled, the connection must be dropped.
+         */
+        special_handling,
+
+        /**
+         * The operation is not supported, possibly because the of server version, bucket type, or current user.
+         */
+        support,
+
+        /**
+         * This error is transient. Note that this does not mean the error is retriable.
+         */
+        temp,
+
+        /**
+         * This is an internal error in the server.
+         */
+        internal,
+
+        /**
+         * The operation may be retried immediately.
+         */
+        retry_now,
+
+        /**
+         * The operation may be retried after some time.
+         */
+        retry_later,
+
+        /**
+         * The error is related to the subdocument subsystem.
+         */
+        subdoc,
+
+        /**
+         * The error is related to the DCP subsystem.
+         */
+        dcp,
+
+        /**
+         * Use retry specifications from the server.
+         */
+        auto_retry,
+
+        /**
+         * This attribute specifies that the requested item is currently locked.
+         */
+        item_locked,
+
+        /**
+         * This attribute means that the error is related to operating on a soft-deleted document.
+         */
+        item_deleted,
+    };
+
     struct error_info {
         std::uint16_t code;
         std::string name;
         std::string description;
-        std::set<std::string> attributes;
+        std::set<attribute> attributes;
+
+        bool has_retry_attribute()
+        {
+            return attributes.find(attribute::retry_now) != attributes.end() || attributes.find(attribute::retry_later) != attributes.end();
+        }
     };
+
     uuid::uuid_t id;
     uint16_t version;
     uint16_t revision;
@@ -51,7 +151,44 @@ struct traits<couchbase::error_map> {
             ei.name = info.at("name").get_string();
             ei.description = info.at("desc").get_string();
             for (const auto& a : info.at("attrs").get_array()) {
-                ei.attributes.insert(a.get_string());
+                const std::string& attr_val = a.get_string();
+                if (attr_val == "success") {
+                    ei.attributes.insert(couchbase::error_map::attribute::success);
+                } else if (attr_val == "item-only") {
+                    ei.attributes.insert(couchbase::error_map::attribute::item_only);
+                } else if (attr_val == "invalid-input") {
+                    ei.attributes.insert(couchbase::error_map::attribute::invalid_input);
+                } else if (attr_val == "fetch-config") {
+                    ei.attributes.insert(couchbase::error_map::attribute::fetch_config);
+                } else if (attr_val == "conn-state-invalidated") {
+                    ei.attributes.insert(couchbase::error_map::attribute::conn_state_invalidated);
+                } else if (attr_val == "auth") {
+                    ei.attributes.insert(couchbase::error_map::attribute::auth);
+                } else if (attr_val == "special-handling") {
+                    ei.attributes.insert(couchbase::error_map::attribute::special_handling);
+                } else if (attr_val == "support") {
+                    ei.attributes.insert(couchbase::error_map::attribute::support);
+                } else if (attr_val == "temp") {
+                    ei.attributes.insert(couchbase::error_map::attribute::temp);
+                } else if (attr_val == "internal") {
+                    ei.attributes.insert(couchbase::error_map::attribute::internal);
+                } else if (attr_val == "retry-now") {
+                    ei.attributes.insert(couchbase::error_map::attribute::retry_now);
+                } else if (attr_val == "retry-later") {
+                    ei.attributes.insert(couchbase::error_map::attribute::retry_later);
+                } else if (attr_val == "subdoc") {
+                    ei.attributes.insert(couchbase::error_map::attribute::subdoc);
+                } else if (attr_val == "dcp") {
+                    ei.attributes.insert(couchbase::error_map::attribute::dcp);
+                } else if (attr_val == "auto-retry") {
+                    ei.attributes.insert(couchbase::error_map::attribute::auto_retry);
+                } else if (attr_val == "item-locked") {
+                    ei.attributes.insert(couchbase::error_map::attribute::item_locked);
+                } else if (attr_val == "item-deleted") {
+                    ei.attributes.insert(couchbase::error_map::attribute::item_deleted);
+                } else {
+                    spdlog::warn(R"(skipping unknown attribute "{}" in error map for code={} and name="{}")", attr_val, ei.code, ei.name);
+                }
             }
             result.errors.emplace(ei.code, ei);
         }
@@ -59,3 +196,66 @@ struct traits<couchbase::error_map> {
     }
 };
 } // namespace tao::json
+
+template<>
+struct fmt::formatter<couchbase::error_map::attribute> : formatter<string_view> {
+    template<typename FormatContext>
+    auto format(couchbase::error_map::attribute attr, FormatContext& ctx)
+    {
+        string_view name = "unknown";
+        switch (attr) {
+            case couchbase::error_map::attribute::success:
+                name = "success";
+                break;
+            case couchbase::error_map::attribute::item_only:
+                name = "item-only";
+                break;
+            case couchbase::error_map::attribute::invalid_input:
+                name = "invalid-input";
+                break;
+            case couchbase::error_map::attribute::fetch_config:
+                name = "fetch-config";
+                break;
+            case couchbase::error_map::attribute::conn_state_invalidated:
+                name = "conn-state-invalidated";
+                break;
+            case couchbase::error_map::attribute::auth:
+                name = "auth";
+                break;
+            case couchbase::error_map::attribute::special_handling:
+                name = "special-handling";
+                break;
+            case couchbase::error_map::attribute::support:
+                name = "support";
+                break;
+            case couchbase::error_map::attribute::temp:
+                name = "temp";
+                break;
+            case couchbase::error_map::attribute::internal:
+                name = "internal";
+                break;
+            case couchbase::error_map::attribute::retry_now:
+                name = "retry-now";
+                break;
+            case couchbase::error_map::attribute::retry_later:
+                name = "retry-later";
+                break;
+            case couchbase::error_map::attribute::subdoc:
+                name = "subdoc";
+                break;
+            case couchbase::error_map::attribute::dcp:
+                name = "dcp";
+                break;
+            case couchbase::error_map::attribute::auto_retry:
+                name = "auto-retry";
+                break;
+            case couchbase::error_map::attribute::item_locked:
+                name = "item-locked";
+                break;
+            case couchbase::error_map::attribute::item_deleted:
+                name = "item-deleted";
+                break;
+        }
+        return formatter<string_view>::format(name, ctx);
+    }
+};

data/ext/couchbase/errors.hxx

@@ -247,7 +247,9 @@ enum class analytics_errc {
 };
 
 /// Errors related to Search service (CBFT)
-enum class search_errc {};
+enum class search_errc {
+    index_not_ready = 400,
+};
 
 /// Errors related to Views service (CAPI)
 enum class view_errc {
@@ -465,8 +467,12 @@ struct search_error_category : std::error_category {
         return "search";
     }
 
-    [[nodiscard]] std::string message(int) const noexcept override
+    [[nodiscard]] std::string message(int ev) const noexcept override
     {
+        switch (static_cast<search_errc>(ev)) {
+            case search_errc::index_not_ready:
+                return "index_not_ready";
+        }
         return "FIXME: unknown error code in search category (recompile with newer library)";
     }
 };

data/ext/couchbase/io/dns_client.hxx

@@ -0,0 +1,217 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <memory>
+#include <sstream>
+
+#include <io/dns_codec.hxx>
+#include <io/dns_config.hxx>
+
+#include <asio/read.hpp>
+
+namespace couchbase::io::dns
+{
+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({ std::make_error_code(error::common_errc::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{ fmt::format("{}", fmt::join(answer.target.labels, ".")), answer.port });
+                        }
+                        return handler(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<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 = std::make_error_code(error::common_errc::unambiguous_timeout);
+                            }
+                            return handler({ ec2 });
+                        }
+                        asio::async_read(self->tcp_,
+                                         asio::buffer(&self->recv_buf_size_, sizeof(self->recv_buf_size_)),
+                                         [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_ = ntohs(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{
+                                                         fmt::format("{}", fmt::join(answer.target.labels, ".")), answer.port });
+                                                   }
+                                                   return handler(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<uint8_t> send_buf_{};
+        std::uint16_t recv_buf_size_{ 0 };
+        std::vector<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, Handler&& handler)
+    {
+        dns_config& config = dns_config::get();
+        auto cmd = std::make_shared<dns_srv_command>(ctx_, name, service, config.address(), config.port());
+        cmd->execute(config.timeout(), std::forward<Handler>(handler));
+    }
+
+    asio::io_context& ctx_;
+};
+} // namespace couchbase::io::dns