couchbase 3.0.2 → 3.0.3

data/ext/couchbase/operations/bucket_get.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *     Copyright 2020 Couchbase, Inc.
+ *     Copyright 2020-2021 Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -19,15 +19,14 @@
 
 #include <tao/json.hpp>
 
-#include <version.hxx>
+#include <error_context/http.hxx>
 #include <operations/bucket_settings.hxx>
 
 namespace couchbase::operations
 {
 
 struct bucket_get_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     bucket_settings bucket{};
 };
 
@@ -35,6 +34,7 @@ struct bucket_get_request {
     using response_type = bucket_get_response;
     using encoded_request_type = io::http_request;
     using encoded_response_type = io::http_response;
+    using error_context_type = error_context::http;
 
     static const inline service_type type = service_type::management;
 
@@ -51,19 +51,24 @@ struct bucket_get_request {
 };
 
 bucket_get_response
-make_response(std::error_code ec, bucket_get_request& request, bucket_get_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, bucket_get_request&, bucket_get_request::encoded_response_type&& encoded)
 {
-    bucket_get_response response{ request.client_context_id, ec };
-    if (!ec) {
+    bucket_get_response response{ ctx };
+    if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 404:
-                response.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
                 break;
             case 200:
-                response.bucket = tao::json::from_string(encoded.body).as<bucket_settings>();
+                try {
+                    response.bucket = tao::json::from_string(encoded.body).as<bucket_settings>();
+                } catch (tao::json::pegtl::parse_error& e) {
+                    response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+                    return response;
+                }
                 break;
             default:
-                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
                 break;
         }
     }

data/ext/couchbase/operations/bucket_get_all.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *     Copyright 2020 Couchbase, Inc.
+ *     Copyright 2020-2021 Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -21,13 +21,13 @@
 
 #include <version.hxx>
 #include <operations/bucket_settings.hxx>
+#include <error_context/http.hxx>
 
 namespace couchbase::operations
 {
 
 struct bucket_get_all_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::vector<bucket_settings> buckets{};
 };
 
@@ -35,6 +35,7 @@ struct bucket_get_all_request {
     using response_type = bucket_get_all_response;
     using encoded_request_type = io::http_request;
     using encoded_response_type = io::http_response;
+    using error_context_type = error_context::http;
 
     static const inline service_type type = service_type::management;
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
@@ -49,11 +50,17 @@ struct bucket_get_all_request {
 };
 
 bucket_get_all_response
-make_response(std::error_code ec, bucket_get_all_request& request, bucket_get_all_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, bucket_get_all_request&, bucket_get_all_request::encoded_response_type&& encoded)
 {
-    bucket_get_all_response response{ request.client_context_id, ec };
-    if (!ec) {
-        auto payload = tao::json::from_string(encoded.body);
+    bucket_get_all_response response{ ctx };
+    if (!response.ctx.ec) {
+        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);
+            return response;
+        }
         const auto& entries = payload.get_array();
         response.buckets.reserve(entries.size());
         for (const auto& entry : entries) {

data/ext/couchbase/operations/bucket_settings.hxx

@@ -56,6 +56,7 @@ struct bucket_settings {
     std::uint64_t ram_quota_mb{ 100 };
     std::uint32_t max_expiry{ 0 };
     compression_mode compression_mode{ compression_mode::unknown };
+    std::optional<protocol::durability_level> minimum_durability_level{};
     std::uint32_t num_replicas{ 1 };
     bool replica_indexes{ false };
     bool flush_enabled{ false };
@@ -112,6 +113,21 @@ struct traits<couchbase::operations::bucket_settings> {
                 result.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::not_recently_used;
             }
         }
+        {
+            auto* min_level = v.find("durabilityMinLevel");
+            if (min_level != nullptr) {
+                auto& str = min_level->get_string();
+                if (str == "none") {
+                    result.minimum_durability_level = couchbase::protocol::durability_level::none;
+                } else if (str == "majority") {
+                    result.minimum_durability_level = couchbase::protocol::durability_level::majority;
+                } else if (str == "majorityAndPersistActive") {
+                    result.minimum_durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
+                } else if (str == "persistToMajority") {
+                    result.minimum_durability_level = couchbase::protocol::durability_level::persist_to_majority;
+                }
+            }
+        }
         {
             auto& str = v.at("conflictResolutionType").get_string();
             if (str == "lww") {

data/ext/couchbase/operations/bucket_update.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *     Copyright 2020 Couchbase, Inc.
+ *     Copyright 2020-2021 Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -27,8 +27,7 @@ namespace couchbase::operations
 {
 
 struct bucket_update_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     bucket_settings bucket{};
     std::string error_message{};
 };
@@ -37,6 +36,7 @@ struct bucket_update_request {
     using response_type = bucket_update_response;
     using encoded_request_type = io::http_request;
     using encoded_response_type = io::http_response;
+    using error_context_type = error_context::http;
 
     static const inline service_type type = service_type::management;
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
@@ -84,22 +84,44 @@ struct bucket_update_request {
             case bucket_settings::compression_mode::unknown:
                 break;
         }
+        if (bucket.minimum_durability_level) {
+            switch (bucket.minimum_durability_level.value()) {
+                case protocol::durability_level::none:
+                    encoded.body.append("&durabilityMinLevel=none");
+                    break;
+                case protocol::durability_level::majority:
+                    encoded.body.append("&durabilityMinLevel=majority");
+                    break;
+                case protocol::durability_level::majority_and_persist_to_active:
+                    encoded.body.append("&durabilityMinLevel=majorityAndPersistActive");
+                    break;
+                case protocol::durability_level::persist_to_majority:
+                    encoded.body.append("&durabilityMinLevel=persistToMajority");
+                    break;
+            }
+        }
         return {};
     }
 };
 
 bucket_update_response
-make_response(std::error_code ec, bucket_update_request& request, bucket_update_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, bucket_update_request& /* request */, bucket_update_request::encoded_response_type&& encoded)
 {
-    bucket_update_response response{ request.client_context_id, ec };
-    if (!ec) {
+    bucket_update_response response{ ctx };
+    if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 404:
-                response.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
                 break;
             case 400: {
-                response.ec = std::make_error_code(error::common_errc::invalid_argument);
-                auto payload = tao::json::from_string(encoded.body);
+                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);
+                    return response;
+                }
+                response.ctx.ec = std::make_error_code(error::common_errc::invalid_argument);
                 auto* errors = payload.find("errors");
                 if (errors != nullptr) {
                     std::vector<std::string> error_list{};
@@ -115,7 +137,7 @@ make_response(std::error_code ec, bucket_update_request& request, bucket_update_
             case 202:
                 break;
             default:
-                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
                 break;
         }
     }

data/ext/couchbase/operations/cluster_developer_preview_enable.hxx

@@ -26,14 +26,14 @@ namespace couchbase::operations
 {
 
 struct cluster_developer_preview_enable_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
 };
 
 struct cluster_developer_preview_enable_request {
     using response_type = cluster_developer_preview_enable_response;
     using encoded_request_type = io::http_request;
     using encoded_response_type = io::http_response;
+    using error_context_type = error_context::http;
 
     static const inline service_type type = service_type::management;
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
@@ -50,12 +50,12 @@ struct cluster_developer_preview_enable_request {
 };
 
 cluster_developer_preview_enable_response
-make_response(std::error_code ec, cluster_developer_preview_enable_request& request, scope_get_all_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, cluster_developer_preview_enable_request&, scope_get_all_request::encoded_response_type&& encoded)
 {
-    cluster_developer_preview_enable_response response{ request.client_context_id, ec };
-    if (!ec) {
+    cluster_developer_preview_enable_response response{ ctx };
+    if (!response.ctx.ec) {
         if (encoded.status_code != 200) {
-            response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+            response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
         }
     }
     return response;

data/ext/couchbase/operations/collection_create.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *     Copyright 2020 Couchbase, Inc.
+ *     Copyright 2020-2021 Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -27,8 +27,7 @@ namespace couchbase::operations
 {
 
 struct collection_create_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::uint64_t uid{ 0 };
 };
 
@@ -36,6 +35,7 @@ struct collection_create_request {
     using response_type = collection_create_response;
     using encoded_request_type = io::http_request;
     using encoded_response_type = io::http_response;
+    using error_context_type = error_context::http;
 
     static const inline service_type type = service_type::management;
 
@@ -60,33 +60,39 @@ struct collection_create_request {
 };
 
 collection_create_response
-make_response(std::error_code ec, collection_create_request& request, collection_create_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, collection_create_request&, collection_create_request::encoded_response_type&& encoded)
 {
-    collection_create_response response{ request.client_context_id, ec };
-    if (!ec) {
+    collection_create_response response{ ctx };
+    if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 400:
                 if (encoded.body.find("Collection with this name already exists") != std::string::npos) {
-                    response.ec = std::make_error_code(error::management_errc::collection_exists);
+                    response.ctx.ec = std::make_error_code(error::management_errc::collection_exists);
                 } else if (encoded.body.find("Not allowed on this version of cluster") != std::string::npos) {
-                    response.ec = std::make_error_code(error::common_errc::feature_not_available);
+                    response.ctx.ec = std::make_error_code(error::common_errc::feature_not_available);
                 } else {
-                    response.ec = std::make_error_code(error::common_errc::invalid_argument);
+                    response.ctx.ec = std::make_error_code(error::common_errc::invalid_argument);
                 }
                 break;
             case 404:
                 if (encoded.body.find("Scope with this name is not found") != std::string::npos) {
-                    response.ec = std::make_error_code(error::common_errc::scope_not_found);
+                    response.ctx.ec = std::make_error_code(error::common_errc::scope_not_found);
                 } else {
-                    response.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                    response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
                 }
                 break;
             case 200: {
-                tao::json::value payload = tao::json::from_string(encoded.body);
+                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);
+                    return response;
+                }
                 response.uid = std::stoull(payload.at("uid").get_string(), 0, 16);
             } break;
             default:
-                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
                 break;
         }
     }

data/ext/couchbase/operations/collection_drop.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *     Copyright 2020 Couchbase, Inc.
+ *     Copyright 2020-2021 Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -27,8 +27,7 @@ namespace couchbase::operations
 {
 
 struct collection_drop_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::uint64_t uid{ 0 };
 };
 
@@ -36,6 +35,7 @@ struct collection_drop_request {
     using response_type = collection_drop_response;
     using encoded_request_type = io::http_request;
     using encoded_response_type = io::http_response;
+    using error_context_type = error_context::http;
 
     static const inline service_type type = service_type::management;
 
@@ -54,29 +54,35 @@ struct collection_drop_request {
 };
 
 collection_drop_response
-make_response(std::error_code ec, collection_drop_request& request, collection_drop_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, collection_drop_request&, collection_drop_request::encoded_response_type&& encoded)
 {
-    collection_drop_response response{ request.client_context_id, ec };
-    if (!ec) {
+    collection_drop_response response{ ctx };
+    if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 400:
-                response.ec = std::make_error_code(error::common_errc::unsupported_operation);
+                response.ctx.ec = std::make_error_code(error::common_errc::unsupported_operation);
                 break;
             case 404:
                 if (encoded.body.find("Collection with this name is not found") != std::string::npos) {
-                    response.ec = std::make_error_code(error::common_errc::collection_not_found);
+                    response.ctx.ec = std::make_error_code(error::common_errc::collection_not_found);
                 } else if (encoded.body.find("Scope with this name is not found") != std::string::npos) {
-                    response.ec = std::make_error_code(error::common_errc::scope_not_found);
+                    response.ctx.ec = std::make_error_code(error::common_errc::scope_not_found);
                 } else {
-                    response.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                    response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
                 }
                 break;
             case 200: {
-                tao::json::value payload = tao::json::from_string(encoded.body);
+                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);
+                    return response;
+                }
                 response.uid = std::stoull(payload.at("uid").get_string(), 0, 16);
             } break;
             default:
-                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
                 break;
         }
     }

data/ext/couchbase/operations/collections_manifest_get.hxx

@@ -31,9 +31,7 @@ namespace couchbase::operations
 {
 
 struct collections_manifest_get_response {
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
+    error_context::key_value ctx;
     collections_manifest manifest{};
 };
 
@@ -55,15 +53,12 @@ struct collections_manifest_get_request {
 };
 
 collections_manifest_get_response
-make_response(std::error_code ec,
-              collections_manifest_get_request& request,
+make_response(error_context::key_value&& ctx,
+              collections_manifest_get_request&,
               collections_manifest_get_request::encoded_response_type&& encoded)
 {
-    collections_manifest_get_response response{ request.id, encoded.opaque(), ec };
-    if (ec && response.opaque == 0) {
-        response.opaque = request.opaque;
-    }
-    if (!ec) {
+    collections_manifest_get_response response{ ctx };
+    if (!response.ctx.ec) {
         response.manifest = encoded.body().manifest();
     }
     return response;

data/ext/couchbase/operations/document_analytics.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *     Copyright 2020 Couchbase, Inc.
+ *     Copyright 2020-2021 Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -31,6 +31,7 @@
 #include <platform/uuid.h>
 #include <timeout_defaults.hxx>
 #include <io/http_message.hxx>
+#include <error_context/analytics.hxx>
 
 namespace couchbase::operations
 {
@@ -139,8 +140,7 @@ struct traits<couchbase::operations::analytics_response_payload> {
 namespace couchbase::operations
 {
 struct analytics_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::analytics ctx;
     analytics_response_payload payload{};
 };
 
@@ -148,6 +148,7 @@ struct analytics_request {
     using response_type = analytics_response;
     using encoded_request_type = io::http_request;
     using encoded_response_type = io::http_response;
+    using error_context_type = error_context::analytics;
 
     enum class scan_consistency_type { not_bounded, request_plus };
 
@@ -159,6 +160,9 @@ struct analytics_request {
 
     bool readonly{ false };
     bool priority{ false };
+    std::optional<std::string> bucket_name{};
+    std::optional<std::string> scope_name{};
+    std::optional<std::string> scope_qualifier{};
 
     std::optional<scan_consistency_type> scan_consistency{};
 
@@ -166,6 +170,8 @@ struct analytics_request {
     std::vector<tao::json::value> positional_parameters{};
     std::map<std::string, tao::json::value> named_parameters{};
 
+    std::string body_str{};
+
     [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& context)
     {
         tao::json::value body{ { "statement", statement },
@@ -196,6 +202,14 @@ struct analytics_request {
                     break;
             }
         }
+        if (scope_qualifier) {
+            body["query_context"] = scope_qualifier;
+        } else if (scope_name) {
+            if (bucket_name) {
+                // for analytics bucket_name.scope_name is quoted as a single unit (unlike n1ql query)
+                body["query_context"] = fmt::format("default:`{}.{}`", *bucket_name, *scope_name);
+            }
+        }
         for (auto& param : raw) {
             body[param.first] = param.second;
         }
@@ -206,7 +220,8 @@ struct analytics_request {
         }
         encoded.method = "POST";
         encoded.path = "/query/service";
-        encoded.body = tao::json::to_string(body);
+        body_str = tao::json::to_string(body);
+        encoded.body = body_str;
         if (context.options.show_queries) {
             spdlog::info("ANALYTICS: {}", tao::json::to_string(body["statement"]));
         } else {
@@ -217,11 +232,18 @@ struct analytics_request {
 };
 
 analytics_response
-make_response(std::error_code ec, analytics_request& request, analytics_request::encoded_response_type&& encoded)
+make_response(error_context::analytics&& ctx, analytics_request& request, analytics_request::encoded_response_type&& encoded)
 {
-    analytics_response response{ request.client_context_id, ec };
-    if (!ec) {
-        response.payload = tao::json::from_string(encoded.body).as<analytics_response_payload>();
+    analytics_response response{ ctx };
+    response.ctx.statement = request.statement;
+    response.ctx.parameters = request.body_str;
+    if (!response.ctx.ec) {
+        try {
+            response.payload = tao::json::from_string(encoded.body).as<analytics_response_payload>();
+        } catch (tao::json::pegtl::parse_error& e) {
+            response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+            return response;
+        }
         Expects(response.payload.meta_data.client_context_id == request.client_context_id);
         if (response.payload.meta_data.status != "success") {
             bool server_timeout = false;
@@ -268,23 +290,23 @@ make_response(std::error_code ec, analytics_request& request, analytics_request:
                 }
             }
             if (compilation_failure) {
-                response.ec = std::make_error_code(error::analytics_errc::compilation_failure);
+                response.ctx.ec = std::make_error_code(error::analytics_errc::compilation_failure);
             } else if (link_not_found) {
-                response.ec = std::make_error_code(error::analytics_errc::link_not_found);
+                response.ctx.ec = std::make_error_code(error::analytics_errc::link_not_found);
             } else if (dataset_not_found) {
-                response.ec = std::make_error_code(error::analytics_errc::dataset_not_found);
+                response.ctx.ec = std::make_error_code(error::analytics_errc::dataset_not_found);
             } else if (dataverse_not_found) {
-                response.ec = std::make_error_code(error::analytics_errc::dataverse_not_found);
+                response.ctx.ec = std::make_error_code(error::analytics_errc::dataverse_not_found);
             } else if (server_timeout) {
-                response.ec = std::make_error_code(error::common_errc::unambiguous_timeout);
+                response.ctx.ec = std::make_error_code(error::common_errc::unambiguous_timeout);
             } else if (dataset_exists) {
-                response.ec = std::make_error_code(error::analytics_errc::dataset_exists);
+                response.ctx.ec = std::make_error_code(error::analytics_errc::dataset_exists);
             } else if (dataverse_exists) {
-                response.ec = std::make_error_code(error::analytics_errc::dataverse_exists);
+                response.ctx.ec = std::make_error_code(error::analytics_errc::dataverse_exists);
             } else if (job_queue_is_full) {
-                response.ec = std::make_error_code(error::analytics_errc::job_queue_full);
+                response.ctx.ec = std::make_error_code(error::analytics_errc::job_queue_full);
             } else {
-                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
             }
         }
     }