couchbase 3.0.0.alpha.1-universal-darwin-19 → 3.0.0.beta.1-universal-darwin-19

data/ext/couchbase/io/streams.hxx

@@ -0,0 +1,165 @@
+/* -*- 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 <functional>
+
+#include <asio.hpp>
+#include <asio/ssl.hpp>
+
+namespace couchbase::io
+{
+
+class stream_impl
+{
+  protected:
+    asio::strand<asio::io_context::executor_type> strand_;
+    bool tls_;
+
+  public:
+    stream_impl(asio::io_context& ctx, bool is_tls)
+      : strand_(asio::make_strand(ctx))
+      , tls_(is_tls)
+    {
+    }
+
+    virtual ~stream_impl() = default;
+
+    [[nodiscard]] std::string_view log_prefix() const
+    {
+        return tls_ ? "tls" : "plain";
+    }
+
+    [[nodiscard]] virtual bool is_open() const = 0;
+
+    virtual void close() = 0;
+
+    virtual void set_options() = 0;
+
+    virtual void async_connect(const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
+                               std::function<void(std::error_code)>&& handler) = 0;
+
+    virtual void async_write(std::vector<asio::const_buffer>& buffers, std::function<void(std::error_code, std::size_t)>&& handler) = 0;
+
+    virtual void async_read_some(asio::mutable_buffer buffer, std::function<void(std::error_code, std::size_t)>&& handler) = 0;
+};
+
+class plain_stream_impl : public stream_impl
+{
+  private:
+    asio::ip::tcp::socket stream_;
+
+  public:
+    explicit plain_stream_impl(asio::io_context& ctx)
+      : stream_impl(ctx, false)
+      , stream_(strand_)
+    {
+    }
+
+    [[nodiscard]] bool is_open() const override
+    {
+        return stream_.is_open();
+    }
+
+    void close() override
+    {
+        stream_.close();
+    }
+
+    void set_options() override
+    {
+        stream_.set_option(asio::ip::tcp::no_delay{ true });
+        stream_.set_option(asio::socket_base::keep_alive{ true });
+    }
+
+    void async_connect(const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
+                       std::function<void(std::error_code)>&& handler) override
+    {
+        return stream_.async_connect(endpoint, handler);
+    }
+
+    void async_write(std::vector<asio::const_buffer>& buffers, std::function<void(std::error_code, std::size_t)>&& handler) override
+    {
+        return asio::async_write(stream_, buffers, handler);
+    }
+
+    void async_read_some(asio::mutable_buffer buffer, std::function<void(std::error_code, std::size_t)>&& handler) override
+    {
+        return stream_.async_read_some(buffer, handler);
+    }
+};
+
+class tls_stream_impl : public stream_impl
+{
+  private:
+    asio::ssl::stream<asio::ip::tcp::socket> stream_;
+
+  public:
+    tls_stream_impl(asio::io_context& ctx, asio::ssl::context& tls)
+      : stream_impl(ctx, true)
+      , stream_(ctx, tls)
+    {
+    }
+
+    [[nodiscard]] bool is_open() const override
+    {
+        return stream_.lowest_layer().is_open();
+    }
+
+    void close() override
+    {
+        stream_.lowest_layer().close();
+    }
+
+    void set_options() override
+    {
+        stream_.lowest_layer().set_option(asio::ip::tcp::no_delay{ true });
+        stream_.lowest_layer().set_option(asio::socket_base::keep_alive{ true });
+    }
+
+    void async_connect(const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
+                       std::function<void(std::error_code)>&& handler) override
+    {
+        return stream_.lowest_layer().async_connect(endpoint, [this, handler](std::error_code ec_connect) mutable {
+            if (ec_connect == asio::error::operation_aborted) {
+                return;
+            }
+            if (ec_connect) {
+                return handler(ec_connect);
+            }
+            stream_.async_handshake(asio::ssl::stream_base::client, [handler](std::error_code ec_handshake) mutable {
+                if (ec_handshake == asio::error::operation_aborted) {
+                    return;
+                }
+                return handler(ec_handshake);
+            });
+        });
+    }
+
+    void async_write(std::vector<asio::const_buffer>& buffers, std::function<void(std::error_code, std::size_t)>&& handler) override
+    {
+        return asio::async_write(stream_, buffers, handler);
+    }
+
+    void async_read_some(asio::mutable_buffer buffer, std::function<void(std::error_code, std::size_t)>&& handler) override
+    {
+        return stream_.async_read_some(buffer, handler);
+    }
+};
+
+} // namespace couchbase::io

data/ext/couchbase/mutation_token.hxx

@@ -23,6 +23,7 @@ struct mutation_token {
     uint64_t partition_uuid{ 0 };
     uint64_t sequence_number{ 0 };
     uint16_t partition_id{ 0 };
+    std::string bucket_name{};
 };
 } // namespace couchbase
 
@@ -31,7 +32,7 @@ struct fmt::formatter<couchbase::mutation_token> : formatter<std::string> {
     template<typename FormatContext>
     auto format(const couchbase::mutation_token& token, FormatContext& ctx)
     {
-        format_to(ctx.out(), "{}:{}:{}", token.partition_id, token.partition_uuid, token.sequence_number);
+        format_to(ctx.out(), "{}:{}:{}:{}", token.bucket_name, token.partition_id, token.partition_uuid, token.sequence_number);
         return formatter<std::string>::format("", ctx);
     }
 };

data/ext/couchbase/operations.hxx

@@ -17,13 +17,75 @@
 
 #pragma once
 
-#include <operations/document_id.hxx>
-#include <operations/get.hxx>
-#include <operations/upsert.hxx>
-#include <operations/remove.hxx>
-#include <operations/lookup_in.hxx>
-#include <operations/mutate_in.hxx>
+#include <document_id.hxx>
+#include <timeout_defaults.hxx>
 
-#include <operations/query.hxx>
+#include <operations/document_get.hxx>
+#include <operations/document_get_and_lock.hxx>
+#include <operations/document_get_and_touch.hxx>
+#include <operations/document_insert.hxx>
+#include <operations/document_upsert.hxx>
+#include <operations/document_replace.hxx>
+#include <operations/document_remove.hxx>
+#include <operations/document_lookup_in.hxx>
+#include <operations/document_mutate_in.hxx>
+#include <operations/document_touch.hxx>
+#include <operations/document_exists.hxx>
+#include <operations/document_unlock.hxx>
+#include <operations/document_increment.hxx>
+#include <operations/document_decrement.hxx>
+#include <operations/document_get_projected.hxx>
 
-#include <operations/command.hxx>
+#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>
+#include <operations/bucket_drop.hxx>
+#include <operations/bucket_flush.hxx>
+#include <operations/bucket_create.hxx>
+#include <operations/bucket_update.hxx>
+
+#include <operations/scope_get_all.hxx>
+#include <operations/scope_create.hxx>
+#include <operations/scope_drop.hxx>
+#include <operations/collection_create.hxx>
+#include <operations/collection_drop.hxx>
+
+#include <operations/cluster_developer_preview_enable.hxx>
+
+#include <operations/query_index_get_all.hxx>
+#include <operations/query_index_drop.hxx>
+#include <operations/query_index_create.hxx>
+#include <operations/query_index_build_deferred.hxx>
+
+#include <operations/search_index_get_all.hxx>
+#include <operations/search_index_get.hxx>
+#include <operations/search_index_get_documents_count.hxx>
+#include <operations/search_index_upsert.hxx>
+#include <operations/search_index_drop.hxx>
+#include <operations/search_index_control_ingest.hxx>
+#include <operations/search_index_control_query.hxx>
+#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 <io/mcbp_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 `{}` {}", if_not_exists_clause, dataverse_name, dataset_name, bucket_name, where_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