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

data/ext/couchbase/io/http_session.hxx

@@ -222,7 +222,11 @@ class http_session : public std::enable_shared_from_this
                   return;
               }
               if (ec && ec != asio::error::operation_aborted) {
-                  spdlog::error("IO error while reading from the socket: {}", ec.message());
+                  spdlog::error("[{}] [{}:{}] IO error while reading from the socket: {}",
+                                uuid::to_string(self->id_),
+                                self->endpoint_.address().to_string(),
+                                self->endpoint_.port(),
+                                ec.message());
                   return self->stop();
               }
 
@@ -235,10 +239,14 @@ class http_session : public std::enable_shared_from_this
                               handler({}, std::move(self->parser_.response));
                           }
                           self->parser_.reset();
-                          return;
+                          return self->stop();
                       }
                       return self->do_read();
                   case http_parser::status::failure:
+                      spdlog::error("[{}] [{}:{}] failed to parse HTTP response",
+                                    uuid::to_string(self->id_),
+                                    self->endpoint_.address().to_string(),
+                                    self->endpoint_.port());
                       return self->stop();
               }
           });
@@ -263,7 +271,11 @@ class http_session : public std::enable_shared_from_this
                 return;
             }
             if (ec) {
-                spdlog::error("IO error while writing to the socket: {}", ec.message());
+                spdlog::error("[{}] [{}:{}] IO error while writing to the socket: {}",
+                              uuid::to_string(self->id_),
+                              self->endpoint_.address().to_string(),
+                              self->endpoint_.port(),
+                              ec.message());
                 return self->stop();
             }
             self->writing_buffer_.clear();
@@ -301,4 +313,4 @@ class http_session : public std::enable_shared_from_this
     asio::ip::tcp::endpoint endpoint_{}; // connected endpoint
     asio::ip::tcp::resolver::results_type endpoints_;
 };
-} // namespace couchbase::io
+} // namespace couchbase::io

data/ext/couchbase/io/mcbp_session.hxx

@@ -790,9 +790,10 @@ class mcbp_session : public std::enable_shared_from_this
                                         return;
                                     }
                                     if (ec) {
-                                        spdlog::error("[{}] [{}] IO error while reading from the socket: {}",
+                                        spdlog::error("[{}] [{}:{}] IO error while reading from the socket: {}",
                                                       uuid::to_string(self->id_),
                                                       self->endpoint_.address().to_string(),
+                                                      self->endpoint_.port(),
                                                       ec.message());
                                         return self->stop();
                                     }

data/ext/couchbase/mutation_token.hxx

@@ -23,7 +23,7 @@ struct mutation_token {
     uint64_t partition_uuid{ 0 };
     uint64_t sequence_number{ 0 };
     uint16_t partition_id{ 0 };
-    std::string bucket_name {};
+    std::string bucket_name{};
 };
 } // namespace couchbase
 

data/ext/couchbase/operations.hxx

@@ -38,6 +38,8 @@
 
 #include <operations/document_query.hxx>
 #include <operations/document_search.hxx>
+#include <operations/document_analytics.hxx>
+#include <operations/document_view.hxx>
 
 #include <operations/bucket_get_all.hxx>
 #include <operations/bucket_get.hxx>
@@ -69,4 +71,21 @@
 #include <operations/search_index_control_plan_freeze.hxx>
 #include <operations/search_index_analyze_document.hxx>
 
+#include <operations/analytics_get_pending_mutations.hxx>
+#include <operations/analytics_dataverse_create.hxx>
+#include <operations/analytics_dataverse_drop.hxx>
+#include <operations/analytics_dataset_create.hxx>
+#include <operations/analytics_dataset_drop.hxx>
+#include <operations/analytics_dataset_get_all.hxx>
+#include <operations/analytics_index_get_all.hxx>
+#include <operations/analytics_index_create.hxx>
+#include <operations/analytics_index_drop.hxx>
+#include <operations/analytics_link_connect.hxx>
+#include <operations/analytics_link_disconnect.hxx>
+
+#include <operations/view_index_get_all.hxx>
+#include <operations/view_index_get.hxx>
+#include <operations/view_index_drop.hxx>
+#include <operations/view_index_upsert.hxx>
+
 #include <operations/command.hxx>

data/ext/couchbase/operations/analytics_dataset_create.hxx

@@ -0,0 +1,117 @@
+/* -*- 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_dataset_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_dataset_create_request {
+    using response_type = analytics_dataset_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 bucket_name;
+
+    std::optional<std::string> condition{};
+
+    bool ignore_if_exists{ false };
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        std::string where_clause = condition ? fmt::format("WHERE {}", *condition) : "";
+        std::string if_not_exists_clause = ignore_if_exists ? "IF NOT EXISTS" : "";
+
+        tao::json::value body{
+            { "statement",
+              fmt::format(
+                "CREATE DATASET `{}`.`{}` ON `{}` {} {}", dataverse_name, dataset_name, bucket_name, where_clause, if_not_exists_clause) },
+        };
+        encoded.headers["content-type"] = "application/json";
+        encoded.method = "POST";
+        encoded.path = "/analytics/service";
+        encoded.body = tao::json::to_string(body);
+    }
+};
+
+analytics_dataset_create_response
+make_response(std::error_code ec,
+              analytics_dataset_create_request& request,
+              analytics_dataset_create_request::encoded_response_type encoded)
+{
+    analytics_dataset_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 dataset_exists = 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_dataset_create_response::problem err{
+                        error.at("code").as<std::uint32_t>(),
+                        error.at("msg").get_string(),
+                    };
+                    switch (err.code) {
+                        case 24040: /* A dataset with name [string] already exists in dataverse [string] */
+                            dataset_exists = true;
+                            break;
+                        case 24006: /* Link [string] does not exist */
+                            link_not_found = true;
+                            break;
+                    }
+                    response.errors.emplace_back(err);
+                }
+            }
+            if (dataset_exists) {
+                response.ec = std::make_error_code(error::analytics_errc::dataset_exists);
+            } 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_dataset_drop.hxx

@@ -0,0 +1,103 @@
+/* -*- 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_dataset_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_dataset_drop_request {
+    using response_type = analytics_dataset_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;
+
+    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 DATASET `{}`.`{}` {}", dataverse_name, dataset_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_dataset_drop_response
+make_response(std::error_code ec, analytics_dataset_drop_request& request, analytics_dataset_drop_request::encoded_response_type encoded)
+{
+    analytics_dataset_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 dataset_does_not_exist = false;
+
+            auto* errors = payload.find("errors");
+            if (errors != nullptr && errors->is_array()) {
+                for (const auto& error : errors->get_array()) {
+                    analytics_dataset_drop_response::problem err{
+                        error.at("code").as<std::uint32_t>(),
+                        error.at("msg").get_string(),
+                    };
+                    switch (err.code) {
+                        case 24025: /* Cannot find dataset with name [string] in dataverse [string] */
+                            dataset_does_not_exist = true;
+                            break;
+                    }
+                    response.errors.emplace_back(err);
+                }
+            }
+            if (dataset_does_not_exist) {
+                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_dataset_get_all.hxx

@@ -0,0 +1,107 @@
+/* -*- 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_dataset_get_all_response {
+    struct dataset {
+        std::string name;
+        std::string dataverse_name;
+        std::string link_name;
+        std::string bucket_name;
+    };
+
+    struct problem {
+        std::uint32_t code;
+        std::string message;
+    };
+
+    std::string client_context_id;
+    std::error_code ec;
+    std::string status{};
+    std::vector<dataset> datasets{};
+    std::vector<problem> errors{};
+};
+
+struct analytics_dataset_get_all_request {
+    using response_type = analytics_dataset_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.`Dataset` 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_dataset_get_all_response
+make_response(std::error_code ec,
+              analytics_dataset_get_all_request& request,
+              analytics_dataset_get_all_request::encoded_response_type encoded)
+{
+    analytics_dataset_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_dataset_get_all_response::dataset ds;
+                    ds.name = res.at("DatasetName").get_string();
+                    ds.dataverse_name = res.at("DataverseName").get_string();
+                    ds.link_name = res.at("LinkName").get_string();
+                    ds.bucket_name = res.at("BucketName").get_string();
+                    response.datasets.emplace_back(ds);
+                }
+            }
+        } else {
+            auto* errors = payload.find("errors");
+            if (errors != nullptr && errors->is_array()) {
+                for (const auto& error : errors->get_array()) {
+                    analytics_dataset_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

data/ext/couchbase/operations/analytics_dataverse_create.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_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_dataverse_create_request {
+    using response_type = analytics_dataverse_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;
+
+    bool ignore_if_exists{ false };
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        std::string if_not_exists_clause = ignore_if_exists ? "IF NOT EXISTS" : "";
+
+        tao::json::value body{
+            { "statement", fmt::format("CREATE DATAVERSE `{}` {}", dataverse_name, if_not_exists_clause) },
+        };
+        encoded.headers["content-type"] = "application/json";
+        encoded.method = "POST";
+        encoded.path = "/analytics/service";
+        encoded.body = tao::json::to_string(body);
+    }
+};
+
+analytics_dataverse_create_response
+make_response(std::error_code ec,
+              analytics_dataverse_create_request& request,
+              analytics_dataverse_create_request::encoded_response_type encoded)
+{
+    analytics_dataverse_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 dataverse_exists = false;
+
+            auto* errors = payload.find("errors");
+            if (errors != nullptr && errors->is_array()) {
+                for (const auto& error : errors->get_array()) {
+                    analytics_dataverse_create_response::problem err{
+                        error.at("code").as<std::uint32_t>(),
+                        error.at("msg").get_string(),
+                    };
+                    switch (err.code) {
+                        case 24039: /* A dataverse with this name [string] already exists. */
+                            dataverse_exists = true;
+                            break;
+                    }
+                    response.errors.emplace_back(err);
+                }
+            }
+            if (dataverse_exists) {
+                response.ec = std::make_error_code(error::analytics_errc::dataverse_exists);
+            } else {
+                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+            }
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations