couchbase 3.0.0.alpha.4-universal-darwin-19 → 3.0.0.alpha.5-universal-darwin-19

data/ext/couchbase/operations/command.hxx

@@ -132,13 +132,24 @@ struct command : public std::enable_shared_from_this> {
     void send_to(std::shared_ptr<io::http_session> session, Handler&& handler)
     {
         request.encode_to(encoded);
-        session->write_and_subscribe(
-          encoded,
-          [self = this->shared_from_this(), handler = std::forward<Handler>(handler)](std::error_code ec, io::http_response&& msg) mutable {
-              encoded_response_type resp(msg);
-              self->deadline.cancel();
-              handler(make_response(ec, self->request, resp));
-          });
+        spdlog::trace("{} HTTP request: {}, method={}, path={}{:a}",
+                      session->log_prefix(),
+                      encoded.type,
+                      encoded.method,
+                      encoded.path,
+                      spdlog::to_hex(encoded.body));
+        session->write_and_subscribe(encoded,
+                                     [self = this->shared_from_this(), session, handler = std::forward<Handler>(handler)](
+                                       std::error_code ec, io::http_response&& msg) mutable {
+                                         encoded_response_type resp(msg);
+                                         self->deadline.cancel();
+                                         spdlog::trace("{} HTTP response: {}, status={}{:a}",
+                                                       session->log_prefix(),
+                                                       self->request.type,
+                                                       resp.status_code,
+                                                       spdlog::to_hex(resp.body));
+                                         handler(make_response(ec, self->request, resp));
+                                     });
         deadline.expires_after(request.timeout);
         deadline.async_wait([session](std::error_code ec) {
             if (ec == asio::error::operation_aborted) {

data/ext/couchbase/operations/document_analytics.hxx

@@ -169,10 +169,6 @@ struct analytics_request {
 
     void encode_to(encoded_request_type& encoded)
     {
-        encoded.headers["content-type"] = "application/json";
-        if (priority) {
-            encoded.headers["analytics-priority"] = "-1";
-        }
         tao::json::value body{ { "statement", statement },
                                { "client_context_id", client_context_id },
                                { "timeout", fmt::format("{}ms", timeout.count()) } };
@@ -207,10 +203,14 @@ struct analytics_request {
         for (auto& param : raw) {
             body[param.first] = param.second;
         }
+        encoded.type = type;
+        encoded.headers["content-type"] = "application/json";
+        if (priority) {
+            encoded.headers["analytics-priority"] = "-1";
+        }
         encoded.method = "POST";
         encoded.path = "/query/service";
         encoded.body = tao::json::to_string(body);
-        spdlog::trace("analytics request: {}", encoded.body);
     }
 };
 
@@ -219,7 +219,6 @@ make_response(std::error_code ec, analytics_request& request, analytics_request:
 {
     analytics_response response{ request.client_context_id, ec };
     if (!ec) {
-        spdlog::trace("analytics response: {}", encoded.body);
         response.payload = tao::json::from_string(encoded.body).as<analytics_response_payload>();
         Expects(response.payload.meta_data.client_context_id == request.client_context_id);
         if (response.payload.meta_data.status != "success") {

data/ext/couchbase/operations/document_decrement.hxx

@@ -25,6 +25,7 @@ namespace couchbase::operations
 
 struct decrement_response {
     document_id id;
+    std::uint32_t opaque;
     std::error_code ec{};
     std::uint64_t content{};
     std::uint64_t cas{};
@@ -67,7 +68,7 @@ struct decrement_request {
 decrement_response
 make_response(std::error_code ec, decrement_request& request, decrement_request::encoded_response_type encoded)
 {
-    decrement_response response{ request.id, ec };
+    decrement_response response{ request.id, encoded.opaque(), ec };
     if (!ec) {
         response.cas = encoded.cas();
         response.content = encoded.body().content();

data/ext/couchbase/operations/document_exists.hxx

@@ -27,6 +27,7 @@ struct exists_response {
     enum class observe_status { invalid, found, not_found, persisted, logically_deleted };
 
     document_id id;
+    std::uint32_t opaque;
     std::error_code ec{};
     std::uint16_t partition_id{};
     std::uint64_t cas{};
@@ -52,7 +53,7 @@ struct exists_request {
 exists_response
 make_response(std::error_code ec, exists_request& request, exists_request::encoded_response_type encoded)
 {
-    exists_response response{ request.id, ec, request.partition };
+    exists_response response{ request.id, encoded.opaque(), ec, request.partition };
     if (!ec) {
         response.cas = encoded.body().cas();
         response.partition_id = encoded.body().partition_id();

data/ext/couchbase/operations/document_get.hxx

@@ -25,6 +25,7 @@ namespace couchbase::operations
 
 struct get_response {
     document_id id;
+    std::uint32_t opaque;
     std::error_code ec{};
     std::string value{};
     std::uint64_t cas{};
@@ -51,7 +52,7 @@ struct get_request {
 get_response
 make_response(std::error_code ec, get_request& request, get_request::encoded_response_type encoded)
 {
-    get_response response{ request.id, ec };
+    get_response response{ request.id, encoded.opaque(), ec };
     if (!ec) {
         response.value = std::move(encoded.body().value());
         response.cas = encoded.cas();

data/ext/couchbase/operations/document_get_and_lock.hxx

@@ -25,6 +25,7 @@ namespace couchbase::operations
 
 struct get_and_lock_response {
     document_id id;
+    std::uint32_t opaque;
     std::error_code ec{};
     std::string value{};
     std::uint64_t cas{};
@@ -53,7 +54,7 @@ struct get_and_lock_request {
 get_and_lock_response
 make_response(std::error_code ec, get_and_lock_request& request, get_and_lock_request::encoded_response_type encoded)
 {
-    get_and_lock_response response{ request.id, ec };
+    get_and_lock_response response{ request.id, encoded.opaque(), ec };
     if (!ec) {
         response.value = std::move(encoded.body().value());
         response.cas = encoded.cas();

data/ext/couchbase/operations/document_get_and_touch.hxx

@@ -25,6 +25,7 @@ namespace couchbase::operations
 
 struct get_and_touch_response {
     document_id id;
+    std::uint32_t opaque;
     std::error_code ec{};
     std::string value{};
     std::uint64_t cas{};
@@ -53,7 +54,7 @@ struct get_and_touch_request {
 get_and_touch_response
 make_response(std::error_code ec, get_and_touch_request& request, get_and_touch_request::encoded_response_type encoded)
 {
-    get_and_touch_response response{ request.id, ec };
+    get_and_touch_response response{ request.id, encoded.opaque(), ec };
     if (!ec) {
         response.value = std::move(encoded.body().value());
         response.cas = encoded.cas();

data/ext/couchbase/operations/document_get_projected.hxx

@@ -25,6 +25,7 @@ namespace couchbase::operations
 
 struct get_projected_response {
     document_id id;
+    std::uint32_t opaque;
     std::error_code ec{};
     std::string value{};
     std::uint64_t cas{};
@@ -196,7 +197,7 @@ subdoc_apply_projection(tao::json::value& root, const std::string& path, tao::js
 get_projected_response
 make_response(std::error_code ec, get_projected_request& request, get_projected_request::encoded_response_type encoded)
 {
-    get_projected_response response{ request.id, ec };
+    get_projected_response response{ request.id, encoded.opaque(), ec };
     if (!ec) {
         response.cas = encoded.cas();
         if (request.with_expiration) {

data/ext/couchbase/operations/document_increment.hxx

@@ -27,6 +27,7 @@ namespace couchbase::operations
 
 struct increment_response {
     document_id id;
+    std::uint32_t opaque;
     std::error_code ec{};
     std::uint64_t content{};
     std::uint64_t cas{};
@@ -69,7 +70,7 @@ struct increment_request {
 increment_response
 make_response(std::error_code ec, increment_request& request, increment_request::encoded_response_type encoded)
 {
-    increment_response response{ request.id, ec };
+    increment_response response{ request.id, encoded.opaque(), ec };
     if (!ec) {
         response.cas = encoded.cas();
         response.content = encoded.body().content();

data/ext/couchbase/operations/document_insert.hxx

@@ -26,6 +26,7 @@ namespace couchbase::operations
 
 struct insert_response {
     document_id id;
+    std::uint32_t opaque;
     std::error_code ec{};
     std::uint64_t cas{};
     mutation_token token{};
@@ -62,7 +63,7 @@ struct insert_request {
 insert_response
 make_response(std::error_code ec, insert_request& request, insert_request::encoded_response_type encoded)
 {
-    insert_response response{ request.id, ec };
+    insert_response response{ request.id, encoded.opaque(), ec };
     if (!ec) {
         response.cas = encoded.cas();
         response.token = encoded.body().token();

data/ext/couchbase/operations/document_lookup_in.hxx

@@ -31,8 +31,10 @@ struct lookup_in_response {
         protocol::status status;
         std::string path;
         std::string value;
+        std::size_t original_index;
     };
     document_id id;
+    std::uint32_t opaque;
     std::error_code ec{};
     std::uint64_t cas{};
     std::vector<field> fields{};
@@ -51,6 +53,18 @@ struct lookup_in_request {
 
     void encode_to(encoded_request_type& encoded)
     {
+        for (std::size_t i = 0; i < specs.entries.size(); ++i) {
+            auto& entry = specs.entries[i];
+            entry.original_index = i;
+        }
+        std::stable_sort(specs.entries.begin(),
+                         specs.entries.end(),
+                         [](const protocol::lookup_in_request_body::lookup_in_specs::entry& lhs,
+                            const protocol::lookup_in_request_body::lookup_in_specs::entry& rhs) -> bool {
+                             return (lhs.flags & protocol::lookup_in_request_body::lookup_in_specs::path_flag_xattr) >
+                                    (rhs.flags & protocol::lookup_in_request_body::lookup_in_specs::path_flag_xattr);
+                         });
+
         encoded.opaque(opaque);
         encoded.partition(partition);
         encoded.body().id(id);
@@ -62,12 +76,13 @@ struct lookup_in_request {
 lookup_in_response
 make_response(std::error_code ec, lookup_in_request& request, lookup_in_request::encoded_response_type encoded)
 {
-    lookup_in_response response{ request.id, ec };
+    lookup_in_response response{ request.id, encoded.opaque(), ec };
     if (!ec) {
         response.cas = encoded.cas();
         response.fields.resize(request.specs.entries.size());
         for (size_t i = 0; i < request.specs.entries.size(); ++i) {
             auto& req_entry = request.specs.entries[i];
+            response.fields[i].original_index = req_entry.original_index;
             response.fields[i].opcode = static_cast<protocol::subdoc_opcode>(req_entry.opcode);
             response.fields[i].path = req_entry.path;
             response.fields[i].status = protocol::status::success;
@@ -79,6 +94,11 @@ make_response(std::error_code ec, lookup_in_request& request, lookup_in_request:
               res_entry.status == protocol::status::success || res_entry.status == protocol::status::subdoc_success_deleted;
             response.fields[i].value = res_entry.value;
         }
+        std::sort(response.fields.begin(),
+                  response.fields.end(),
+                  [](const lookup_in_response::field& lhs, const lookup_in_response::field& rhs) -> bool {
+                      return lhs.original_index < rhs.original_index;
+                  });
     }
     return response;
 }

data/ext/couchbase/operations/document_mutate_in.hxx

@@ -18,8 +18,17 @@
 #pragma once
 
 #include <gsl/gsl_assert>
-#include <document_id.hxx>
+#include <algorithm>
+
 #include <protocol/cmd_mutate_in.hxx>
+#include <protocol/status.hxx>
+#include <protocol/durability_level.hxx>
+#include <protocol/client_request.hxx>
+
+#include <mutation_token.hxx>
+#include <document_id.hxx>
+#include <timeout_defaults.hxx>
+#include <errors.hxx>
 
 namespace couchbase::operations
 {
@@ -30,8 +39,10 @@ struct mutate_in_response {
         protocol::status status;
         std::string path;
         std::string value;
+        std::size_t original_index;
     };
     document_id id;
+    std::uint32_t opaque;
     std::error_code ec{};
     std::uint64_t cas{};
     mutation_token token{};
@@ -46,7 +57,12 @@ struct mutate_in_request {
     document_id id;
     uint16_t partition{};
     uint32_t opaque{};
+    uint64_t cas{ 0 };
     bool access_deleted{ false };
+    std::optional<std::uint32_t> expiration{};
+    protocol::mutate_in_request_body::store_semantics_type store_semantics{
+        protocol::mutate_in_request_body::store_semantics_type::replace
+    };
     protocol::mutate_in_request_body::mutate_in_specs specs{};
     protocol::durability_level durability_level{ protocol::durability_level::none };
     std::optional<std::uint16_t> durability_timeout{};
@@ -54,10 +70,27 @@ struct mutate_in_request {
 
     void encode_to(encoded_request_type& encoded)
     {
+        for (std::size_t i = 0; i < specs.entries.size(); ++i) {
+            auto& entry = specs.entries[i];
+            entry.original_index = i;
+        }
+        std::stable_sort(specs.entries.begin(),
+                         specs.entries.end(),
+                         [](const protocol::mutate_in_request_body::mutate_in_specs::entry& lhs,
+                            const protocol::mutate_in_request_body::mutate_in_specs::entry& rhs) -> bool {
+                             return (lhs.flags & protocol::mutate_in_request_body::mutate_in_specs::path_flag_xattr) >
+                                    (rhs.flags & protocol::mutate_in_request_body::mutate_in_specs::path_flag_xattr);
+                         });
+
         encoded.opaque(opaque);
         encoded.partition(partition);
         encoded.body().id(id);
+        encoded.cas(cas);
+        if (expiration) {
+            encoded.body().expiration(*expiration);
+        }
         encoded.body().access_deleted(access_deleted);
+        encoded.body().store_semantics(store_semantics);
         encoded.body().specs(specs);
         if (durability_level != protocol::durability_level::none) {
             encoded.body().durability(durability_level, durability_timeout);
@@ -68,7 +101,7 @@ struct mutate_in_request {
 mutate_in_response
 make_response(std::error_code ec, mutate_in_request& request, mutate_in_request::encoded_response_type encoded)
 {
-    mutate_in_response response{ request.id, ec };
+    mutate_in_response response{ request.id, encoded.opaque(), ec };
     if (!ec) {
         response.cas = encoded.cas();
         response.token = encoded.body().token();
@@ -77,6 +110,7 @@ make_response(std::error_code ec, mutate_in_request& request, mutate_in_request:
         response.fields.resize(request.specs.entries.size());
         for (size_t i = 0; i < request.specs.entries.size(); ++i) {
             auto& req_entry = request.specs.entries[i];
+            response.fields[i].original_index = req_entry.original_index;
             response.fields[i].opcode = static_cast<protocol::subdoc_opcode>(req_entry.opcode);
             response.fields[i].path = req_entry.path;
             response.fields[i].status = protocol::status::success;
@@ -90,6 +124,14 @@ make_response(std::error_code ec, mutate_in_request& request, mutate_in_request:
                 break;
             }
         }
+        std::sort(response.fields.begin(),
+                  response.fields.end(),
+                  [](const mutate_in_response::field& lhs, const mutate_in_response::field& rhs) -> bool {
+                      return lhs.original_index < rhs.original_index;
+                  });
+    } else if (request.store_semantics == protocol::mutate_in_request_body::store_semantics_type::insert &&
+               ec == std::make_error_code(error::common_errc::cas_mismatch)) {
+        response.ec = std::make_error_code(error::key_value_errc::document_exists);
     }
     return response;
 }

data/ext/couchbase/operations/document_query.hxx

@@ -182,7 +182,6 @@ struct query_request {
 
     void encode_to(encoded_request_type& encoded)
     {
-        encoded.headers["content-type"] = "application/json";
         tao::json::value body{ { "statement", statement },
                                { "client_context_id", client_context_id },
                                { "timeout", fmt::format("{}ms", timeout.count()) } };
@@ -209,16 +208,16 @@ struct query_request {
                 break;
         }
         if (max_parallelism) {
-            body["max_parallelism"] = max_parallelism.value();
+            body["max_parallelism"] = std::to_string(max_parallelism.value());
         }
         if (pipeline_cap) {
-            body["pipeline_cap"] = pipeline_cap.value();
+            body["pipeline_cap"] = std::to_string(pipeline_cap.value());
         }
         if (pipeline_batch) {
-            body["pipeline_batch"] = pipeline_batch.value();
+            body["pipeline_batch"] = std::to_string(pipeline_batch.value());
         }
         if (scan_cap) {
-            body["scan_cap"] = scan_cap.value();
+            body["scan_cap"] = std::to_string(scan_cap.value());
         }
         if (!metrics) {
             body["metrics"] = false;
@@ -259,10 +258,11 @@ struct query_request {
         for (auto& param : raw) {
             body[param.first] = param.second;
         }
+        encoded.type = type;
+        encoded.headers["content-type"] = "application/json";
         encoded.method = "POST";
         encoded.path = "/query/service";
         encoded.body = tao::json::to_string(body);
-        spdlog::trace("query request: {}", encoded.body);
     }
 };
 
@@ -271,7 +271,6 @@ make_response(std::error_code ec, query_request& request, query_request::encoded
 {
     query_response response{ request.client_context_id, ec };
     if (!ec) {
-        spdlog::trace("query response: {}", encoded.body);
         response.payload = tao::json::from_string(encoded.body).as<query_response_payload>();
         Expects(response.payload.meta_data.client_context_id == request.client_context_id);
         if (response.payload.meta_data.status != "success") {

data/ext/couchbase/operations/document_remove.hxx

@@ -25,6 +25,7 @@ namespace couchbase::operations
 
 struct remove_response {
     document_id id;
+    std::uint32_t opaque;
     std::error_code ec{};
     std::uint64_t cas{};
     mutation_token token{};
@@ -55,7 +56,7 @@ struct remove_request {
 remove_response
 make_response(std::error_code ec, remove_request& request, remove_request::encoded_response_type encoded)
 {
-    remove_response response{ request.id, ec };
+    remove_response response{ request.id, encoded.opaque(), ec };
     if (!ec) {
         response.cas = encoded.cas();
         response.token = encoded.body().token();

data/ext/couchbase/operations/document_replace.hxx

@@ -26,6 +26,7 @@ namespace couchbase::operations
 
 struct replace_response {
     document_id id;
+    std::uint32_t opaque;
     std::error_code ec{};
     std::uint64_t cas{};
     mutation_token token{};
@@ -64,7 +65,7 @@ struct replace_request {
 replace_response
 make_response(std::error_code ec, replace_request& request, replace_request::encoded_response_type encoded)
 {
-    replace_response response{ request.id, ec };
+    replace_response response{ request.id, encoded.opaque(), ec };
     if (!ec) {
         response.cas = encoded.cas();
         response.token = encoded.body().token();

data/ext/couchbase/operations/document_search.hxx

@@ -129,8 +129,6 @@ struct search_request {
 
     void encode_to(encoded_request_type& encoded)
     {
-        encoded.headers["content-type"] = "application/json";
-        encoded.headers["client-context-id"] = client_context_id;
         tao::json::value body{
             { "query", query },
             { "explain", explain },
@@ -189,6 +187,9 @@ struct search_request {
             };
         }
 
+        encoded.type = type;
+        encoded.headers["content-type"] = "application/json";
+        encoded.headers["client-context-id"] = client_context_id;
         encoded.method = "POST";
         encoded.path = fmt::format("/api/index/{}/query", index_name);
         encoded.body = tao::json::to_string(body);