couchbase 3.0.0.alpha.5 → 3.0.3

data/ext/couchbase/operations/http_noop.hxx

@@ -0,0 +1,78 @@
+/* -*- 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 <tao/json.hpp>
+
+#include <version.hxx>
+#include <error_context/http.hxx>
+
+namespace couchbase::operations
+{
+struct http_noop_response {
+    error_context::http ctx;
+};
+
+struct http_noop_request {
+    using response_type = http_noop_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+    using error_context_type = error_context::http;
+
+    service_type type;
+    std::chrono::milliseconds timeout;
+
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    {
+        encoded.headers["connection"] = "keep-alive";
+        encoded.method = "GET";
+        switch (type) {
+            case service_type::query:
+                timeout = timeout_defaults::query_timeout;
+                encoded.path = "/admin/ping";
+                break;
+            case service_type::analytics:
+                timeout = timeout_defaults::analytics_timeout;
+                encoded.path = "/admin/ping";
+                break;
+            case service_type::search:
+                timeout = timeout_defaults::search_timeout;
+                encoded.path = "/api/ping";
+                break;
+            case service_type::views:
+                timeout = timeout_defaults::view_timeout;
+                encoded.path = "/";
+                break;
+            case service_type::management:
+            case service_type::kv:
+                return std::make_error_code(error::common_errc::feature_not_available);
+        }
+        return {};
+    }
+};
+
+http_noop_response
+make_response(error_context::http&& ctx, http_noop_request&, http_noop_request::encoded_response_type&&)
+{
+    http_noop_response response{ ctx };
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/mcbp_noop.hxx

@@ -0,0 +1,55 @@
+/* -*- 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 <document_id.hxx>
+#include <protocol/cmd_noop.hxx>
+#include <io/retry_context.hxx>
+
+namespace couchbase::operations
+{
+
+struct mcbp_noop_response {
+    error_context::key_value ctx;
+};
+
+struct mcbp_noop_request {
+    using encoded_request_type = protocol::client_request<protocol::mcbp_noop_request_body>;
+    using encoded_response_type = protocol::client_response<protocol::mcbp_noop_response_body>;
+
+    uint16_t partition{};
+    uint32_t opaque{};
+    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
+    io::retry_context<io::retry_strategy::best_effort> retries{ true };
+
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
+    {
+        encoded.opaque(opaque);
+        encoded.partition(partition);
+        return {};
+    }
+};
+
+mcbp_noop_response
+make_response(error_context::key_value&& ctx, mcbp_noop_request&, mcbp_noop_request::encoded_response_type&&)
+{
+    mcbp_noop_response response{ ctx };
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/query_index_build_deferred.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.
@@ -28,8 +28,7 @@ struct query_index_build_deferred_response {
         std::uint64_t code;
         std::string message;
     };
-    uuid::uuid_t client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::string status{};
     std::vector<query_problem> errors{};
 };
@@ -38,14 +37,15 @@ struct query_index_build_deferred_request {
     using response_type = query_index_build_deferred_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::query;
 
-    uuid::uuid_t client_context_id{ uuid::random() };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
     std::string bucket_name;
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    void encode_to(encoded_request_type& encoded)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.headers["content-type"] = "application/json";
         tao::json::value body{
@@ -53,22 +53,29 @@ struct query_index_build_deferred_request {
               fmt::format(R"(BUILD INDEX ON `{}` ((SELECT RAW name FROM system:indexes WHERE keyspace_id = "{}" AND state = "deferred")))",
                           bucket_name,
                           bucket_name) },
-            { "client_context_id", uuid::to_string(client_context_id) }
+            { "client_context_id", client_context_id }
         };
         encoded.method = "POST";
         encoded.path = "/query/service";
         encoded.body = tao::json::to_string(body);
+        return {};
     }
 };
 
 query_index_build_deferred_response
-make_response(std::error_code ec,
-              query_index_build_deferred_request& request,
-              query_index_build_deferred_request::encoded_response_type encoded)
+make_response(error_context::http&& ctx,
+              query_index_build_deferred_request&,
+              query_index_build_deferred_request::encoded_response_type&& encoded)
 {
-    query_index_build_deferred_response response{ request.client_context_id, ec };
-    if (!ec) {
-        auto payload = tao::json::from_string(encoded.body);
+    query_index_build_deferred_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;
+        }
         response.status = payload.at("status").get_string();
         if (response.status != "success") {
             for (const auto& entry : payload.at("errors").get_array()) {
@@ -77,7 +84,7 @@ make_response(std::error_code ec,
                 error.message = entry.at("msg").get_string();
                 response.errors.emplace_back(error);
             }
-            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/query_index_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.
@@ -28,8 +28,7 @@ struct query_index_create_response {
         std::uint64_t code;
         std::string message;
     };
-    uuid::uuid_t client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::string status{};
     std::vector<query_problem> errors{};
 };
@@ -38,11 +37,15 @@ struct query_index_create_request {
     using response_type = query_index_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::query;
 
-    uuid::uuid_t client_context_id{ uuid::random() };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+    static constexpr auto namespace_id = "default";
     std::string bucket_name;
+    std::string scope_name;
+    std::string collection_name;
     std::string index_name{};
     std::vector<std::string> fields;
     bool is_primary{ false };
@@ -52,7 +55,7 @@ struct query_index_create_request {
     std::optional<int> num_replicas{};
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    void encode_to(encoded_request_type& encoded)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.headers["content-type"] = "application/json";
         tao::json::value with{};
@@ -70,30 +73,44 @@ struct query_index_create_request {
         if (with) {
             with_clause = fmt::format("WITH {}", tao::json::to_string(with));
         }
+        std::string keyspace = fmt::format("{}:`{}`", namespace_id, bucket_name);
+        if (!scope_name.empty()) {
+            keyspace += ".`" + scope_name + "`";
+        }
+        if (!collection_name.empty()) {
+            keyspace += ".`" + collection_name + "`";
+        }
         tao::json::value body{ { "statement",
-                                 is_primary ? fmt::format(R"(CREATE PRIMARY INDEX {} ON `{}` USING GSI {})",
+                                 is_primary ? fmt::format(R"(CREATE PRIMARY INDEX {} ON {} USING GSI {})",
                                                           index_name.empty() ? "" : fmt::format("`{}`", index_name),
-                                                          bucket_name,
+                                                          keyspace,
                                                           with_clause)
-                                            : fmt::format(R"(CREATE INDEX `{}` ON `{}`({}) {} USING GSI {})",
+                                            : fmt::format(R"(CREATE INDEX `{}` ON {}({}) {} USING GSI {})",
                                                           index_name,
-                                                          bucket_name,
+                                                          keyspace,
                                                           fmt::join(fields, ", "),
                                                           where_clause,
                                                           with_clause) },
-                               { "client_context_id", uuid::to_string(client_context_id) } };
+                               { "client_context_id", client_context_id } };
         encoded.method = "POST";
         encoded.path = "/query/service";
         encoded.body = tao::json::to_string(body);
+        return {};
     }
 };
 
 query_index_create_response
-make_response(std::error_code ec, query_index_create_request& request, query_index_create_request::encoded_response_type encoded)
+make_response(error_context::http&& ctx, query_index_create_request& request, query_index_create_request::encoded_response_type&& encoded)
 {
-    query_index_create_response response{ request.client_context_id, ec };
-    if (!ec) {
-        auto payload = tao::json::from_string(encoded.body);
+    query_index_create_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;
+        }
         response.status = payload.at("status").get_string();
 
         if (response.status != "success") {
@@ -120,12 +137,12 @@ make_response(std::error_code ec, query_index_create_request& request, query_ind
             }
             if (index_already_exists) {
                 if (!request.ignore_if_exists) {
-                    response.ec = std::make_error_code(error::common_errc::index_exists);
+                    response.ctx.ec = std::make_error_code(error::common_errc::index_exists);
                 }
             } else if (bucket_not_found) {
-                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);
             } else if (!response.errors.empty()) {
-                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);
             }
         }
     }

data/ext/couchbase/operations/query_index_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.
@@ -28,8 +28,7 @@ struct query_index_drop_response {
         std::uint64_t code;
         std::string message;
     };
-    uuid::uuid_t client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::string status{};
     std::vector<query_problem> errors{};
 };
@@ -38,35 +37,53 @@ struct query_index_drop_request {
     using response_type = query_index_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::query;
 
-    uuid::uuid_t client_context_id{ uuid::random() };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+    static constexpr auto namespace_id = "default";
     std::string bucket_name;
+    std::string scope_name;
+    std::string collection_name;
     std::string index_name;
     bool is_primary{ false };
     bool ignore_if_does_not_exist{ false };
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    void encode_to(encoded_request_type& encoded)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.headers["content-type"] = "application/json";
+        std::string keyspace = fmt::format("`{}`", bucket_name);
+        if (!scope_name.empty()) {
+            keyspace += ".`" + scope_name + "`";
+        }
+        if (!collection_name.empty()) {
+            keyspace += ".`" + collection_name + "`";
+        }
         tao::json::value body{ { "statement",
-                                 is_primary ? fmt::format(R"(DROP PRIMARY INDEX ON `{}` USING GSI)", bucket_name)
-                                            : fmt::format(R"(DROP INDEX `{}`.`{}` USING GSI)", bucket_name, index_name) },
-                               { "client_context_id", uuid::to_string(client_context_id) } };
+                                 is_primary ? fmt::format(R"(DROP PRIMARY INDEX ON {} USING GSI)", keyspace)
+                                            : fmt::format(R"(DROP INDEX {}.`{}` USING GSI)", keyspace, index_name) },
+                               { "client_context_id", client_context_id } };
         encoded.method = "POST";
         encoded.path = "/query/service";
         encoded.body = tao::json::to_string(body);
+        return {};
     }
 };
 
 query_index_drop_response
-make_response(std::error_code ec, query_index_drop_request& request, query_index_drop_request::encoded_response_type encoded)
+make_response(error_context::http&& ctx, query_index_drop_request& request, query_index_drop_request::encoded_response_type&& encoded)
 {
-    query_index_drop_response response{ request.client_context_id, ec };
-    if (!ec) {
-        auto payload = tao::json::from_string(encoded.body);
+    query_index_drop_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;
+        }
         response.status = payload.at("status").get_string();
 
         if (response.status != "success") {
@@ -94,12 +111,12 @@ make_response(std::error_code ec, query_index_drop_request& request, query_index
             }
             if (index_not_found) {
                 if (!request.ignore_if_does_not_exist) {
-                    response.ec = std::make_error_code(error::common_errc::index_not_found);
+                    response.ctx.ec = std::make_error_code(error::common_errc::index_not_found);
                 }
             } else if (bucket_not_found) {
-                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);
             } else if (!response.errors.empty()) {
-                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);
             }
         }
     }

data/ext/couchbase/operations/query_index_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.
@@ -32,12 +32,14 @@ struct query_index_get_all_response {
         std::string datastore_id;
         std::string keyspace_id;
         std::string namespace_id;
+        std::string collection_name;
         std::string type;
         std::vector<std::string> index_key{};
         std::optional<std::string> condition{};
+        std::optional<std::string> bucket_id{};
+        std::optional<std::string> scope_id{};
     };
-    uuid::uuid_t client_context_id;
-    std::error_code ec;
+    error_context::http ctx;
     std::string status{};
     std::vector<query_index> indexes{};
 };
@@ -46,36 +48,45 @@ struct query_index_get_all_request {
     using response_type = query_index_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::query;
 
-    uuid::uuid_t client_context_id{ uuid::random() };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
     std::string bucket_name;
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    void encode_to(encoded_request_type& encoded)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.headers["content-type"] = "application/json";
         tao::json::value body{
             { "statement",
               fmt::format(
-                R"(SELECT idx.* FROM system:indexes AS idx WHERE keyspace_id = "{}" AND `using`="gsi" ORDER BY is_primary DESC, name ASC)",
+                R"(SELECT idx.* FROM system:indexes AS idx WHERE ((keyspace_id = "{}" AND bucket_id IS MISSING) OR (bucket_id = "{}")) AND `using`="gsi" ORDER BY is_primary DESC, name ASC)",
+                bucket_name,
                 bucket_name) },
-            { "client_context_id", uuid::to_string(client_context_id) }
+            { "client_context_id", client_context_id }
         };
         encoded.method = "POST";
         encoded.path = "/query/service";
         encoded.body = tao::json::to_string(body);
+        return {};
     }
 };
 
 query_index_get_all_response
-make_response(std::error_code ec, query_index_get_all_request& request, query_index_get_all_request::encoded_response_type encoded)
+make_response(error_context::http&& ctx, query_index_get_all_request&, query_index_get_all_request::encoded_response_type&& encoded)
 {
-    query_index_get_all_response response{ request.client_context_id, ec };
-    if (!ec) {
+    query_index_get_all_response response{ ctx };
+    if (!response.ctx.ec) {
         if (encoded.status_code == 200) {
-            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.status = payload.at("status").get_string();
             if (response.status == "success") {
                 for (const auto& entry : payload.at("results").get_array()) {
@@ -87,6 +98,12 @@ make_response(std::error_code ec, query_index_get_all_request& request, query_in
                     index.type = entry.at("using").get_string();
                     index.name = entry.at("name").get_string();
                     index.state = entry.at("state").get_string();
+                    if (const auto* prop = entry.find("bucket_id")) {
+                        index.bucket_id = prop->get_string();
+                    }
+                    if (const auto* prop = entry.find("scope_id")) {
+                        index.scope_id = prop->get_string();
+                    }
                     if (const auto* prop = entry.find("is_primary")) {
                         index.is_primary = prop->get_boolean();
                     }