couchbase 3.0.0.alpha.3 → 3.0.0.alpha.4

data/ext/couchbase/operations/analytics_dataverse_drop.hxx

@@ -0,0 +1,104 @@
+/* -*- 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>
+
+namespace couchbase::operations
+{
+struct analytics_dataverse_drop_response {
+    struct problem {
+        std::uint32_t code;
+        std::string message;
+    };
+
+    std::string client_context_id;
+    std::error_code ec;
+    std::string status{};
+    std::vector<problem> errors{};
+};
+
+struct analytics_dataverse_drop_request {
+    using response_type = analytics_dataverse_drop_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+
+    static const inline service_type type = service_type::analytics;
+
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+
+    std::string dataverse_name;
+
+    bool ignore_if_does_not_exist{ false };
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        std::string if_exists_clause = ignore_if_does_not_exist ? "IF EXISTS" : "";
+
+        tao::json::value body{
+            { "statement", fmt::format("DROP DATAVERSE `{}` {}", dataverse_name, if_exists_clause) },
+        };
+        encoded.headers["content-type"] = "application/json";
+        encoded.method = "POST";
+        encoded.path = "/analytics/service";
+        encoded.body = tao::json::to_string(body);
+    }
+};
+
+analytics_dataverse_drop_response
+make_response(std::error_code ec,
+              analytics_dataverse_drop_request& request,
+              analytics_dataverse_drop_request::encoded_response_type encoded)
+{
+    analytics_dataverse_drop_response response{ request.client_context_id, ec };
+    if (!ec) {
+        auto payload = tao::json::from_string(encoded.body);
+        response.status = payload.at("status").get_string();
+
+        if (response.status != "success") {
+            bool dataverse_does_not_exist = false;
+
+            auto* errors = payload.find("errors");
+            if (errors != nullptr && errors->is_array()) {
+                for (const auto& error : errors->get_array()) {
+                    analytics_dataverse_drop_response::problem err{
+                        error.at("code").as<std::uint32_t>(),
+                        error.at("msg").get_string(),
+                    };
+                    switch (err.code) {
+                        case 24034: /* Cannot find dataverse with name [string] */
+                            dataverse_does_not_exist = true;
+                            break;
+                    }
+                    response.errors.emplace_back(err);
+                }
+            }
+            if (dataverse_does_not_exist) {
+                response.ec = std::make_error_code(error::analytics_errc::dataverse_not_found);
+            } else {
+                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+            }
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/analytics_get_pending_mutations.hxx

@@ -0,0 +1,91 @@
+/* -*- 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>
+
+namespace couchbase::operations
+{
+struct analytics_get_pending_mutations_response {
+    struct problem {
+        std::uint32_t code;
+        std::string message;
+    };
+
+    std::string client_context_id;
+    std::error_code ec;
+    std::string status{};
+    std::vector<problem> errors{};
+    std::map<std::string, std::uint64_t> stats{};
+};
+
+struct analytics_get_pending_mutations_request {
+    using response_type = analytics_get_pending_mutations_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+
+    static const inline service_type type = service_type::analytics;
+
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.method = "GET";
+        encoded.path = "/analytics/node/agg/stats/remaining";
+    }
+};
+
+analytics_get_pending_mutations_response
+make_response(std::error_code ec,
+              analytics_get_pending_mutations_request& request,
+              analytics_get_pending_mutations_request::encoded_response_type encoded)
+{
+    analytics_get_pending_mutations_response response{ request.client_context_id, ec };
+    if (!ec) {
+        auto payload = tao::json::from_string(encoded.body);
+        if (encoded.status_code == 200) {
+            if (payload.is_object()) {
+                for (const auto& entry : payload.get_object()) {
+                    std::string dataverse = entry.first + ".";
+                    for (const auto& stats : entry.second.get_object()) {
+                        std::string dataset = dataverse + stats.first;
+                        response.stats.emplace(dataset, stats.second.get_unsigned());
+                    }
+                }
+            }
+            return response;
+        }
+        auto* errors = payload.find("errors");
+        if (errors != nullptr && errors->is_array()) {
+            for (const auto& error : errors->get_array()) {
+                analytics_get_pending_mutations_response::problem err{
+                    error.at("code").as<std::uint32_t>(),
+                    error.at("msg").get_string(),
+                };
+                response.errors.emplace_back(err);
+            }
+        }
+        response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/analytics_index_create.hxx

@@ -0,0 +1,128 @@
+/* -*- 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>
+
+namespace couchbase::operations
+{
+struct analytics_index_create_response {
+    struct problem {
+        std::uint32_t code;
+        std::string message;
+    };
+
+    std::string client_context_id;
+    std::error_code ec;
+    std::string status{};
+    std::vector<problem> errors{};
+};
+
+struct analytics_index_create_request {
+    using response_type = analytics_index_create_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+
+    static const inline service_type type = service_type::analytics;
+
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+
+    std::string dataverse_name{ "Default" };
+    std::string dataset_name;
+    std::string index_name;
+    std::map<std::string, std::string> fields;
+
+    bool ignore_if_exists{ false };
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        std::string if_not_exists_clause = ignore_if_exists ? "IF NOT EXISTS" : "";
+        std::vector<std::string> field_specs;
+        field_specs.reserve(fields.size());
+        for (const auto& entry : fields) {
+            field_specs.emplace_back(entry.first + ": " + entry.second);
+        }
+
+        tao::json::value body{
+            { "statement",
+              fmt::format("CREATE INDEX {} `{}` ON `{}`.`{}` ({})",
+                          if_not_exists_clause,
+                          index_name,
+                          dataverse_name,
+                          dataset_name,
+                          fmt::join(field_specs, ",")) },
+        };
+        encoded.headers["content-type"] = "application/json";
+        encoded.method = "POST";
+        encoded.path = "/analytics/service";
+        encoded.body = tao::json::to_string(body);
+    }
+};
+
+analytics_index_create_response
+make_response(std::error_code ec, analytics_index_create_request& request, analytics_index_create_request::encoded_response_type encoded)
+{
+    analytics_index_create_response response{ request.client_context_id, ec };
+    if (!ec) {
+        auto payload = tao::json::from_string(encoded.body);
+        response.status = payload.at("status").get_string();
+
+        if (response.status != "success") {
+            bool index_exists = false;
+            bool dataset_not_found = false;
+            bool link_not_found = false;
+
+            auto* errors = payload.find("errors");
+            if (errors != nullptr && errors->is_array()) {
+                for (const auto& error : errors->get_array()) {
+                    analytics_index_create_response::problem err{
+                        error.at("code").as<std::uint32_t>(),
+                        error.at("msg").get_string(),
+                    };
+                    switch (err.code) {
+                        case 24048: /* An index with this name [string] already exists */
+                            index_exists = true;
+                            break;
+                        case 24025: /* Cannot find dataset with name [string] in dataverse [string] */
+                            dataset_not_found = true;
+                            break;
+                        case 24006: /* Link [string] does not exist */
+                            link_not_found = true;
+                            break;
+                    }
+                    response.errors.emplace_back(err);
+                }
+            }
+            if (index_exists) {
+                response.ec = std::make_error_code(error::common_errc::index_exists);
+            } else if (dataset_not_found) {
+                response.ec = std::make_error_code(error::analytics_errc::dataset_not_found);
+            } else if (link_not_found) {
+                response.ec = std::make_error_code(error::analytics_errc::link_not_found);
+            } else {
+                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+            }
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/analytics_index_drop.hxx

@@ -0,0 +1,110 @@
+/* -*- 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>
+
+namespace couchbase::operations
+{
+struct analytics_index_drop_response {
+    struct problem {
+        std::uint32_t code;
+        std::string message;
+    };
+
+    std::string client_context_id;
+    std::error_code ec;
+    std::string status{};
+    std::vector<problem> errors{};
+};
+
+struct analytics_index_drop_request {
+    using response_type = analytics_index_drop_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+
+    static const inline service_type type = service_type::analytics;
+
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+
+    std::string dataverse_name{ "Default" };
+    std::string dataset_name;
+    std::string index_name;
+
+    bool ignore_if_does_not_exist{ false };
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        std::string if_exists_clause = ignore_if_does_not_exist ? "IF EXISTS" : "";
+
+        tao::json::value body{
+            { "statement", fmt::format("DROP INDEX `{}`.`{}`.`{}` {}", dataverse_name, dataset_name, index_name, if_exists_clause) },
+        };
+        encoded.headers["content-type"] = "application/json";
+        encoded.method = "POST";
+        encoded.path = "/analytics/service";
+        encoded.body = tao::json::to_string(body);
+    }
+};
+
+analytics_index_drop_response
+make_response(std::error_code ec, analytics_index_drop_request& request, analytics_index_drop_request::encoded_response_type encoded)
+{
+    analytics_index_drop_response response{ request.client_context_id, ec };
+    if (!ec) {
+        auto payload = tao::json::from_string(encoded.body);
+        response.status = payload.at("status").get_string();
+
+        if (response.status != "success") {
+            bool index_does_not_exist = false;
+            bool dataset_not_found = false;
+
+            auto* errors = payload.find("errors");
+            if (errors != nullptr && errors->is_array()) {
+                for (const auto& error : errors->get_array()) {
+                    analytics_index_drop_response::problem err{
+                        error.at("code").as<std::uint32_t>(),
+                        error.at("msg").get_string(),
+                    };
+                    switch (err.code) {
+                        case 24047: /* Cannot find index with name [string] */
+                            index_does_not_exist = true;
+                            break;
+                        case 24025: /* Cannot find dataset with name [string] in dataverse [string] */
+                            dataset_not_found = true;
+                            break;
+                    }
+                    response.errors.emplace_back(err);
+                }
+            }
+            if (index_does_not_exist) {
+                response.ec = std::make_error_code(error::common_errc::index_not_found);
+            } else if (dataset_not_found) {
+                response.ec = std::make_error_code(error::analytics_errc::dataset_not_found);
+            } else {
+                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+            }
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/analytics_index_get_all.hxx

@@ -0,0 +1,106 @@
+/* -*- 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>
+
+namespace couchbase::operations
+{
+struct analytics_index_get_all_response {
+    struct index {
+        std::string name;
+        std::string dataverse_name;
+        std::string dataset_name;
+        bool is_primary;
+    };
+
+    struct problem {
+        std::uint32_t code;
+        std::string message;
+    };
+
+    std::string client_context_id;
+    std::error_code ec;
+    std::string status{};
+    std::vector<index> indexes{};
+    std::vector<problem> errors{};
+};
+
+struct analytics_index_get_all_request {
+    using response_type = analytics_index_get_all_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+
+    static const inline service_type type = service_type::analytics;
+
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        tao::json::value body{
+            { "statement", "SELECT d.* FROM Metadata.`Index` d WHERE d.DataverseName <> \"Metadata\"" },
+        };
+
+        encoded.headers["content-type"] = "application/json";
+        encoded.method = "POST";
+        encoded.path = "/analytics/service";
+        encoded.body = tao::json::to_string(body);
+    }
+};
+
+analytics_index_get_all_response
+make_response(std::error_code ec, analytics_index_get_all_request& request, analytics_index_get_all_request::encoded_response_type encoded)
+{
+    analytics_index_get_all_response response{ request.client_context_id, ec };
+
+    if (!ec) {
+        auto payload = tao::json::from_string(encoded.body);
+        response.status = payload.at("status").get_string();
+        if (response.status == "success") {
+            auto* results = payload.find("results");
+            if (results != nullptr && results->is_array()) {
+                for (const auto& res : results->get_array()) {
+                    analytics_index_get_all_response::index idx;
+                    idx.name = res.at("IndexName").get_string();
+                    idx.dataverse_name = res.at("DataverseName").get_string();
+                    idx.dataset_name = res.at("DatasetName").get_string();
+                    idx.is_primary = res.at("IsPrimary").get_boolean();
+                    response.indexes.emplace_back(idx);
+                }
+            }
+        } else {
+            auto* errors = payload.find("errors");
+            if (errors != nullptr && errors->is_array()) {
+                for (const auto& error : errors->get_array()) {
+                    analytics_index_get_all_response::problem err{
+                        error.at("code").as<std::uint32_t>(),
+                        error.at("msg").get_string(),
+                    };
+                    response.errors.emplace_back(err);
+                }
+            }
+            response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations