couchbase 3.1.1-universal-darwin-20 → 3.2.0-universal-darwin-20

data/ext/couchbase/operations/view_index_drop.hxx

@@ -31,7 +31,7 @@ struct view_index_drop_request {
     using encoded_response_type = io::http_response;
     using error_context_type = error_context::http;
 
-    static const inline service_type type = service_type::views;
+    static const inline service_type type = service_type::view;
 
     std::string client_context_id{ uuid::to_string(uuid::random()) };
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
@@ -40,7 +40,7 @@ struct view_index_drop_request {
     std::string document_name;
     design_document::name_space name_space;
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         encoded.method = "DELETE";
         encoded.path =
@@ -50,16 +50,16 @@ struct view_index_drop_request {
 };
 
 view_index_drop_response
-make_response(error_context::http&& ctx, view_index_drop_request&, view_index_drop_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx,
+              const view_index_drop_request& /* request */,
+              view_index_drop_request::encoded_response_type&& encoded)
 {
-    view_index_drop_response response{ ctx };
+    view_index_drop_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
-        if (encoded.status_code == 200) {
-
-        } else if (encoded.status_code == 404) {
-            response.ctx.ec = std::make_error_code(error::view_errc::design_document_not_found);
-        } else {
-            response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+        if (encoded.status_code == 404) {
+            response.ctx.ec = error::view_errc::design_document_not_found;
+        } else if (encoded.status_code != 200) {
+            response.ctx.ec = error::common_errc::internal_server_failure;
         }
     }
     return response;

data/ext/couchbase/operations/view_index_get.hxx

@@ -33,7 +33,7 @@ struct view_index_get_request {
     using encoded_response_type = io::http_response;
     using error_context_type = error_context::http;
 
-    static const inline service_type type = service_type::views;
+    static const inline service_type type = service_type::view;
 
     std::string client_context_id{ uuid::to_string(uuid::random()) };
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
@@ -42,7 +42,7 @@ struct view_index_get_request {
     std::string document_name;
     design_document::name_space name_space;
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         encoded.method = "GET";
         encoded.path =
@@ -52,9 +52,9 @@ struct view_index_get_request {
 };
 
 view_index_get_response
-make_response(error_context::http&& ctx, view_index_get_request& request, view_index_get_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, const view_index_get_request& request, view_index_get_request::encoded_response_type&& encoded)
 {
-    view_index_get_response response{ ctx };
+    view_index_get_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         if (encoded.status_code == 200) {
             response.document.name = request.document_name;
@@ -63,22 +63,20 @@ make_response(error_context::http&& ctx, view_index_get_request& request, view_i
             tao::json::value payload{};
             try {
                 payload = tao::json::from_string(encoded.body);
-            } catch (tao::json::pegtl::parse_error& e) {
-                response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+            } catch (const tao::json::pegtl::parse_error& e) {
+                response.ctx.ec = error::common_errc::parsing_failure;
                 return response;
             }
             const auto* views = payload.find("views");
             if (views != nullptr && views->is_object()) {
-                for (const auto& view_entry : views->get_object()) {
+                for (const auto& [name, view_entry] : views->get_object()) {
                     couchbase::operations::design_document::view view;
-                    view.name = view_entry.first;
-                    if (view_entry.second.is_object()) {
-                        const auto* map = view_entry.second.find("map");
-                        if (map != nullptr && map->is_string()) {
+                    view.name = name;
+                    if (view_entry.is_object()) {
+                        if (const auto* map = view_entry.find("map"); map != nullptr && map->is_string()) {
                             view.map = map->get_string();
                         }
-                        const auto* reduce = view_entry.second.find("reduce");
-                        if (reduce != nullptr && reduce->is_string()) {
+                        if (const auto* reduce = view_entry.find("reduce"); reduce != nullptr && reduce->is_string()) {
                             view.reduce = reduce->get_string();
                         }
                     }
@@ -86,9 +84,9 @@ make_response(error_context::http&& ctx, view_index_get_request& request, view_i
                 }
             }
         } else if (encoded.status_code == 404) {
-            response.ctx.ec = std::make_error_code(error::view_errc::design_document_not_found);
+            response.ctx.ec = error::view_errc::design_document_not_found;
         } else {
-            response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+            response.ctx.ec = error::common_errc::internal_server_failure;
         }
     }
     return response;

data/ext/couchbase/operations/view_index_get_all.hxx

@@ -41,7 +41,7 @@ struct view_index_get_all_request {
     std::string bucket_name;
     design_document::name_space name_space;
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         encoded.method = "GET";
         encoded.path = fmt::format("/pools/default/buckets/{}/ddocs", bucket_name);
@@ -50,16 +50,18 @@ struct view_index_get_all_request {
 };
 
 view_index_get_all_response
-make_response(error_context::http&& ctx, view_index_get_all_request& request, view_index_get_all_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx,
+              const view_index_get_all_request& request,
+              view_index_get_all_request::encoded_response_type&& encoded)
 {
-    view_index_get_all_response response{ ctx };
+    view_index_get_all_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         if (encoded.status_code == 200) {
             tao::json::value payload{};
             try {
                 payload = tao::json::from_string(encoded.body);
-            } catch (tao::json::pegtl::parse_error& e) {
-                response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+            } catch (const tao::json::pegtl::parse_error& e) {
+                response.ctx.ec = error::common_errc::parsing_failure;
                 return response;
             }
             auto* rows = payload.find("rows");
@@ -77,14 +79,12 @@ make_response(error_context::http&& ctx, view_index_get_all_request& request, vi
                     design_document document{};
                     document.rev = meta->at("rev").get_string();
                     auto id = meta->at("id").get_string();
-                    static const std::string prefix = "_design/";
-                    if (id.find(prefix) == 0) {
+                    if (static const std::string prefix = "_design/"; id.find(prefix) == 0) {
                         document.name = id.substr(prefix.size());
                     } else {
                         document.name = id; // fall back, should not happen
                     }
-                    static const std::string name_space_prefix = "dev_";
-                    if (document.name.find(name_space_prefix) == 0) {
+                    if (static const std::string name_space_prefix = "dev_"; document.name.find(name_space_prefix) == 0) {
                         document.name = document.name.substr(name_space_prefix.size());
                         document.ns = couchbase::operations::design_document::name_space::development;
                     } else {
@@ -98,18 +98,15 @@ make_response(error_context::http&& ctx, view_index_get_all_request& request, vi
                     if (json == nullptr || !json->is_object()) {
                         continue;
                     }
-                    const auto* views = json->find("views");
-                    if (views != nullptr && views->is_object()) {
-                        for (const auto& view_entry : views->get_object()) {
+                    if (const auto* views = json->find("views"); views != nullptr && views->is_object()) {
+                        for (const auto& [name, view_entry] : views->get_object()) {
                             couchbase::operations::design_document::view view;
-                            view.name = view_entry.first;
-                            if (view_entry.second.is_object()) {
-                                const auto* map = view_entry.second.find("map");
-                                if (map != nullptr && map->is_string()) {
+                            view.name = name;
+                            if (view_entry.is_object()) {
+                                if (const auto* map = view_entry.find("map"); map != nullptr && map->is_string()) {
                                     view.map = map->get_string();
                                 }
-                                const auto* reduce = view_entry.second.find("reduce");
-                                if (reduce != nullptr && reduce->is_string()) {
+                                if (const auto* reduce = view_entry.find("reduce"); reduce != nullptr && reduce->is_string()) {
                                     view.reduce = reduce->get_string();
                                 }
                             }
@@ -121,9 +118,9 @@ make_response(error_context::http&& ctx, view_index_get_all_request& request, vi
                 }
             }
         } else if (encoded.status_code == 404) {
-            response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
+            response.ctx.ec = error::common_errc::bucket_not_found;
         } else {
-            response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+            response.ctx.ec = error::common_errc::internal_server_failure;
         }
     }
     return response;

data/ext/couchbase/operations/view_index_upsert.hxx

@@ -31,7 +31,7 @@ struct view_index_upsert_request {
     using encoded_response_type = io::http_response;
     using error_context_type = error_context::http;
 
-    static const inline service_type type = service_type::views;
+    static const inline service_type type = service_type::view;
 
     std::string client_context_id{ uuid::to_string(uuid::random()) };
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
@@ -39,7 +39,7 @@ struct view_index_upsert_request {
     std::string bucket_name;
     design_document document;
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         tao::json::value body;
         body["views"] = tao::json::empty_object;
@@ -64,22 +64,24 @@ struct view_index_upsert_request {
 };
 
 view_index_upsert_response
-make_response(error_context::http&& ctx, view_index_upsert_request&, view_index_upsert_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx,
+              const view_index_upsert_request& /* request */,
+              view_index_upsert_request::encoded_response_type&& encoded)
 {
-    view_index_upsert_response response{ ctx };
+    view_index_upsert_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 200:
             case 201:
                 break;
             case 400:
-                response.ctx.ec = std::make_error_code(error::common_errc::invalid_argument);
+                response.ctx.ec = error::common_errc::invalid_argument;
                 break;
             case 404:
-                response.ctx.ec = std::make_error_code(error::view_errc::design_document_not_found);
+                response.ctx.ec = error::view_errc::design_document_not_found;
                 break;
             default:
-                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = error::common_errc::internal_server_failure;
         }
     }
     return response;

data/ext/couchbase/origin.hxx

@@ -19,6 +19,7 @@
 
 #include <string>
 
+#include <utility>
 #include <utils/connection_string.hxx>
 
 namespace couchbase
@@ -28,7 +29,7 @@ struct cluster_credentials {
     std::string password{};
     std::string certificate_path{};
     std::string key_path{};
-    std::vector<std::string> allowed_sasl_mechanisms{};
+    std::vector<std::string> allowed_sasl_mechanisms{ "SCRAM-SHA512", "SCRAM-SHA256", "SCRAM-SHA1", "PLAIN" };
 
     [[nodiscard]] bool uses_certificate() const
     {
@@ -42,26 +43,28 @@ struct origin {
 
     origin() = default;
 
+    ~origin() = default;
+
     origin(origin&& other) = default;
 
     origin(const origin& other)
       : options_(other.options_)
-      , credentials_(std::move(other.credentials_))
+      , credentials_(other.credentials_)
       , nodes_(other.nodes_)
       , next_node_(nodes_.begin())
     {
     }
 
-    origin(cluster_credentials auth, const std::string& hostname, std::uint16_t port, const cluster_options& options)
-      : options_(options)
+    origin(cluster_credentials auth, const std::string& hostname, std::uint16_t port, cluster_options options)
+      : options_(std::move(options))
       , credentials_(std::move(auth))
       , nodes_{ { hostname, std::to_string(port) } }
       , next_node_(nodes_.begin())
     {
     }
 
-    origin(cluster_credentials auth, const std::string& hostname, const std::string& port, const cluster_options& options)
-      : options_(options)
+    origin(cluster_credentials auth, const std::string& hostname, const std::string& port, cluster_options options)
+      : options_(std::move(options))
       , credentials_(std::move(auth))
       , nodes_{ { hostname, port } }
       , next_node_(nodes_.begin())
@@ -74,12 +77,13 @@ struct origin {
     {
         nodes_.reserve(connstr.bootstrap_nodes.size());
         for (const auto& node : connstr.bootstrap_nodes) {
-            nodes_.emplace_back(
-              std::make_pair(node.address, node.port > 0 ? std::to_string(node.port) : std::to_string(connstr.default_port)));
+            nodes_.emplace_back(std::pair(node.address, node.port > 0 ? std::to_string(node.port) : std::to_string(connstr.default_port)));
         }
         next_node_ = nodes_.begin();
     }
 
+    origin& operator=(origin&& other) = default;
+
     origin& operator=(const origin& other)
     {
         if (this != &other) {
@@ -116,8 +120,8 @@ struct origin {
     {
         std::vector<std::string> res;
         res.reserve(nodes_.size());
-        for (const auto& node : nodes_) {
-            res.emplace_back(fmt::format("\"{}:{}\"", node.first, node.second));
+        for (const auto& [hostname, port] : nodes_) {
+            res.emplace_back(fmt::format("\"{}:{}\"", hostname, port));
         }
         return res;
     }

data/ext/couchbase/platform/backtrace.c

@@ -62,7 +62,7 @@ describe_address(char* msg, size_t len, void* addr)
         // No symbol found.
         snprintf(msg, len, "[0x%p]", addr);
     }
-#else // !WIN32
+#else  // !WIN32
     Dl_info info;
     int status = dladdr(addr, &info);
 

data/ext/couchbase/platform/base64.cc

@@ -121,19 +121,19 @@ encode_triplet(const std::uint8_t* s, std::string& str)
 static int
 decode_quad(const std::uint8_t* s, std::string& d)
 {
-    uint32_t value = code2val(static_cast<std::uint8_t>(s[0])) << 18U;
-    value |= code2val(static_cast<std::uint8_t>(s[1])) << 12U;
+    uint32_t value = code2val(s[0]) << 18U;
+    value |= code2val(s[1]) << 12U;
 
     int ret = 3;
 
     if (s[2] == '=') {
         ret = 1;
     } else {
-        value |= code2val(static_cast<std::uint8_t>(s[2])) << 6U;
+        value |= code2val(s[2]) << 6U;
         if (s[3] == '=') {
             ret = 2;
         } else {
-            value |= code2val(static_cast<std::uint8_t>(s[3]));
+            value |= code2val(s[3]);
         }
     }
 
@@ -171,7 +171,7 @@ encode(const std::string_view blob, bool prettyprint)
         result.reserve(chunks * 4);
     }
 
-    const std::uint8_t* in = reinterpret_cast<const std::uint8_t*>(blob.data());
+    const auto* in = reinterpret_cast<const std::uint8_t*>(blob.data());
 
     chunks = 0;
     for (size_t ii = 0; ii < triplets; ++ii) {

data/ext/couchbase/platform/base64.h

@@ -19,9 +19,7 @@
 #include <string>
 #include <vector>
 
-namespace couchbase
-{
-namespace base64
+namespace couchbase::base64
 {
 
 /**
@@ -43,5 +41,4 @@ encode(std::string_view blob, bool prettyprint = false);
 std::string
 decode(std::string_view blob);
 
-} // namespace base64
-} // namespace couchbase
+} // namespace couchbase::base64

data/ext/couchbase/protocol/client_opcode.hxx

@@ -249,10 +249,10 @@ enum class subdoc_opcode : uint8_t {
     replace_body_with_xattr = 0xd3,
 };
 
-constexpr inline bool
+constexpr bool
 is_valid_client_opcode(uint8_t code)
 {
-    switch (static_cast<client_opcode>(code)) {
+    switch (client_opcode(code)) {
         case client_opcode::get:
         case client_opcode::upsert:
         case client_opcode::insert:
@@ -328,10 +328,10 @@ is_valid_client_opcode(uint8_t code)
     return false;
 }
 
-constexpr inline bool
+constexpr bool
 is_valid_subdoc_opcode(uint8_t code)
 {
-    switch (static_cast<subdoc_opcode>(code)) {
+    switch (subdoc_opcode(code)) {
         case subdoc_opcode::get:
         case subdoc_opcode::exists:
         case subdoc_opcode::dict_add:
@@ -352,6 +352,9 @@ is_valid_subdoc_opcode(uint8_t code)
     }
     return false;
 }
+
+const inline static std::vector<std::uint8_t> empty_buffer;
+const inline static std::string empty_string;
 } // namespace couchbase::protocol
 
 template<>

data/ext/couchbase/protocol/client_request.hxx

@@ -50,7 +50,7 @@ class client_request
     std::vector<std::uint8_t> payload_;
 
   public:
-    client_opcode opcode()
+    [[nodiscard]] client_opcode opcode() const
     {
         return opcode_;
     }
@@ -65,7 +65,7 @@ class client_request
         cas_ = utils::byte_swap_64(val);
     }
 
-    std::uint32_t opaque()
+    [[nodiscard]] std::uint32_t opaque() const
     {
         return opaque_;
     }

data/ext/couchbase/protocol/client_response.hxx

@@ -33,6 +33,34 @@
 namespace couchbase::protocol
 {
 
+double
+parse_server_duration_us(const io::mcbp_message& msg)
+{
+    if (msg.header.magic != static_cast<std::uint8_t>(magic::alt_client_response)) {
+        return 0;
+    }
+    std::uint8_t framing_extras_size = static_cast<std::uint8_t>(msg.header.keylen & 0xfU);
+    if (framing_extras_size == 0) {
+        return 0;
+    }
+    std::size_t offset = 0;
+    while (offset < framing_extras_size) {
+        std::uint8_t frame_size = static_cast<std::uint8_t>(msg.body[offset] & 0xfU);
+        std::uint8_t frame_id = static_cast<std::uint8_t>((static_cast<std::uint32_t>(msg.body[offset]) >> 4U) & 0xfU);
+        offset++;
+        if (frame_id == static_cast<std::uint8_t>(response_frame_info_id::server_duration)) {
+            if (frame_size == 2 && framing_extras_size - offset >= frame_size) {
+                std::uint16_t encoded_duration{};
+                std::memcpy(&encoded_duration, msg.body.data() + offset, sizeof(encoded_duration));
+                encoded_duration = ntohs(encoded_duration);
+                return std::pow(encoded_duration, 1.74) / 2;
+            }
+        }
+        offset += frame_size;
+    }
+    return 0;
+}
+
 template<typename Body>
 class client_response
 {
@@ -55,7 +83,7 @@ class client_response
 
   public:
     client_response() = default;
-    explicit client_response(io::mcbp_message& msg)
+    explicit client_response(io::mcbp_message&& msg)
     {
         header_ = msg.header_data();
         data_ = std::move(msg.body);
@@ -108,15 +136,15 @@ class client_response
         Expects(header_[0] == static_cast<std::uint8_t>(magic::alt_client_response) ||
                 header_[0] == static_cast<std::uint8_t>(magic::client_response));
         Expects(header_[1] == static_cast<std::uint8_t>(Body::opcode));
-        magic_ = static_cast<magic>(header_[0]);
-        opcode_ = static_cast<client_opcode>(header_[1]);
+        magic_ = magic(header_[0]);
+        opcode_ = client_opcode(header_[1]);
         data_type_ = header_[5];
 
         uint16_t status = 0;
         memcpy(&status, header_.data() + 6, sizeof(status));
         status = ntohs(status);
         Expects(protocol::is_valid_status(status));
-        status_ = static_cast<protocol::status>(status);
+        status_ = protocol::status(status);
 
         extras_size_ = header_[4];
         if (magic_ == magic::alt_client_response) {
@@ -143,7 +171,7 @@ class client_response
         return error_;
     }
 
-    [[nodiscard]] std::string error_message()
+    [[nodiscard]] std::string error_message() const
     {
         if (error_) {
             return fmt::format(R"(magic={}, opcode={}, status={}, error={})", magic_, opcode_, status_, *error_);
@@ -161,12 +189,10 @@ class client_response
                 auto& err_obj = error["error"];
                 if (err_obj.is_object()) {
                     enhanced_error_info err{};
-                    auto& ref = err_obj["ref"];
-                    if (ref.is_string()) {
+                    if (auto& ref = err_obj["ref"]; ref.is_string()) {
                         err.reference = ref.get_string();
                     }
-                    auto& ctx = err_obj["context"];
-                    if (ctx.is_string()) {
+                    if (auto& ctx = err_obj["context"]; ctx.is_string()) {
                         err.context = ctx.get_string();
                     }
                     error_.emplace(err);
@@ -185,13 +211,12 @@ class client_response
             std::uint8_t frame_size = data_[offset] & 0xfU;
             std::uint8_t frame_id = (static_cast<std::uint32_t>(data_[offset]) >> 4U) & 0xfU;
             offset++;
-            if (frame_id == static_cast<std::uint8_t>(response_frame_info_id::server_duration)) {
-                if (frame_size == 2 && framing_extras_size_ - offset >= frame_size) {
-                    std::uint16_t encoded_duration{};
-                    std::memcpy(&encoded_duration, data_.data() + offset, sizeof(encoded_duration));
-                    encoded_duration = ntohs(encoded_duration);
-                    info_.server_duration_us = std::pow(encoded_duration, 1.74) / 2;
-                }
+            if (frame_id == static_cast<std::uint8_t>(response_frame_info_id::server_duration) && frame_size == 2 &&
+                framing_extras_size_ - offset >= frame_size) {
+                std::uint16_t encoded_duration{};
+                std::memcpy(&encoded_duration, data_.data() + offset, sizeof(encoded_duration));
+                encoded_duration = ntohs(encoded_duration);
+                info_.server_duration_us = std::pow(encoded_duration, 1.74) / 2;
             }
             offset += frame_size;
         }