couchbase 3.0.0.alpha.5 → 3.0.0.beta.1

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/operations.hxx

@@ -88,4 +88,4 @@
 #include <operations/view_index_drop.hxx>
 #include <operations/view_index_upsert.hxx>
 
-#include <operations/command.hxx>
+#include <io/mcbp_command.hxx>

data/ext/couchbase/operations/analytics_dataset_create.hxx

@@ -61,7 +61,7 @@ struct analytics_dataset_create_request {
         tao::json::value body{
             { "statement",
               fmt::format(
-                "CREATE DATASET `{}`.`{}` ON `{}` {} {}", dataverse_name, dataset_name, bucket_name, where_clause, if_not_exists_clause) },
+                "CREATE DATASET {} `{}`.`{}` ON `{}` {}", if_not_exists_clause, dataverse_name, dataset_name, bucket_name, where_clause) },
         };
         encoded.headers["content-type"] = "application/json";
         encoded.method = "POST";

data/ext/couchbase/operations/bucket_create.hxx

@@ -27,6 +27,7 @@ namespace couchbase::operations
 {
 
 struct bucket_create_response {
+    std::string client_context_id;
     std::error_code ec;
     std::string error_message{};
 };
@@ -40,6 +41,7 @@ struct bucket_create_request {
 
     bucket_settings bucket{};
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
 
     void encode_to(encoded_request_type& encoded)
     {
@@ -103,9 +105,9 @@ struct bucket_create_request {
 };
 
 bucket_create_response
-make_response(std::error_code ec, bucket_create_request&, bucket_create_request::encoded_response_type encoded)
+make_response(std::error_code ec, bucket_create_request& request, bucket_create_request::encoded_response_type encoded)
 {
-    bucket_create_response response{ ec };
+    bucket_create_response response{ request.client_context_id, ec };
     if (!ec) {
         switch (encoded.status_code) {
             case 404:

data/ext/couchbase/operations/bucket_drop.hxx

@@ -23,6 +23,7 @@ namespace couchbase::operations
 {
 
 struct bucket_drop_response {
+    std::string client_context_id;
     std::error_code ec;
 };
 
@@ -35,6 +36,7 @@ struct bucket_drop_request {
 
     std::string name;
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
 
     void encode_to(encoded_request_type& encoded)
     {
@@ -44,9 +46,9 @@ struct bucket_drop_request {
 };
 
 bucket_drop_response
-make_response(std::error_code ec, bucket_drop_request&, bucket_drop_request::encoded_response_type encoded)
+make_response(std::error_code ec, bucket_drop_request& request, bucket_drop_request::encoded_response_type encoded)
 {
-    bucket_drop_response response{ ec };
+    bucket_drop_response response{ request.client_context_id, ec };
     if (!ec) {
         switch (encoded.status_code) {
             case 404:

data/ext/couchbase/operations/bucket_flush.hxx

@@ -23,6 +23,7 @@ namespace couchbase::operations
 {
 
 struct bucket_flush_response {
+    std::string client_context_id;
     std::error_code ec;
 };
 
@@ -35,6 +36,7 @@ struct bucket_flush_request {
 
     std::string name;
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
 
     void encode_to(encoded_request_type& encoded)
     {
@@ -44,9 +46,9 @@ struct bucket_flush_request {
 };
 
 bucket_flush_response
-make_response(std::error_code ec, bucket_flush_request&, bucket_flush_request::encoded_response_type encoded)
+make_response(std::error_code ec, bucket_flush_request& request, bucket_flush_request::encoded_response_type encoded)
 {
-    bucket_flush_response response{ ec };
+    bucket_flush_response response{ request.client_context_id, ec };
     if (!ec) {
         switch (encoded.status_code) {
             case 404:

data/ext/couchbase/operations/bucket_get.hxx

@@ -26,6 +26,7 @@ namespace couchbase::operations
 {
 
 struct bucket_get_response {
+    std::string client_context_id;
     std::error_code ec;
     bucket_settings bucket{};
 };
@@ -39,6 +40,7 @@ struct bucket_get_request {
 
     std::string name;
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
 
     void encode_to(encoded_request_type& encoded)
     {
@@ -48,9 +50,9 @@ struct bucket_get_request {
 };
 
 bucket_get_response
-make_response(std::error_code ec, bucket_get_request&, bucket_get_request::encoded_response_type encoded)
+make_response(std::error_code ec, bucket_get_request& request, bucket_get_request::encoded_response_type encoded)
 {
-    bucket_get_response response{ ec };
+    bucket_get_response response{ request.client_context_id, ec };
     if (!ec) {
         switch (encoded.status_code) {
             case 404:

data/ext/couchbase/operations/bucket_get_all.hxx

@@ -26,6 +26,7 @@ namespace couchbase::operations
 {
 
 struct bucket_get_all_response {
+    std::string client_context_id;
     std::error_code ec;
     std::vector<bucket_settings> buckets{};
 };
@@ -37,6 +38,7 @@ struct bucket_get_all_request {
 
     static const inline service_type type = service_type::management;
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
 
     void encode_to(encoded_request_type& encoded)
     {
@@ -46,9 +48,9 @@ struct bucket_get_all_request {
 };
 
 bucket_get_all_response
-make_response(std::error_code ec, bucket_get_all_request&, bucket_get_all_request::encoded_response_type encoded)
+make_response(std::error_code ec, bucket_get_all_request& request, bucket_get_all_request::encoded_response_type encoded)
 {
-    bucket_get_all_response response{ ec };
+    bucket_get_all_response response{ request.client_context_id, ec };
     if (!ec) {
         auto payload = tao::json::from_string(encoded.body);
         const auto& entries = payload.get_array();

data/ext/couchbase/operations/bucket_update.hxx

@@ -27,6 +27,7 @@ namespace couchbase::operations
 {
 
 struct bucket_update_response {
+    std::string client_context_id;
     std::error_code ec;
     bucket_settings bucket{};
     std::string error_message{};
@@ -39,6 +40,7 @@ struct bucket_update_request {
 
     static const inline service_type type = service_type::management;
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
 
     bucket_settings bucket{};
 
@@ -80,9 +82,9 @@ struct bucket_update_request {
 };
 
 bucket_update_response
-make_response(std::error_code ec, bucket_update_request&, bucket_update_request::encoded_response_type encoded)
+make_response(std::error_code ec, bucket_update_request& request, bucket_update_request::encoded_response_type encoded)
 {
-    bucket_update_response response{ ec };
+    bucket_update_response response{ request.client_context_id, ec };
     if (!ec) {
         switch (encoded.status_code) {
             case 404:

data/ext/couchbase/operations/cluster_developer_preview_enable.hxx

@@ -26,6 +26,7 @@ namespace couchbase::operations
 {
 
 struct cluster_developer_preview_enable_response {
+    std::string client_context_id;
     std::error_code ec;
 };
 
@@ -36,6 +37,7 @@ struct cluster_developer_preview_enable_request {
 
     static const inline service_type type = service_type::management;
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
 
     void encode_to(encoded_request_type& encoded)
     {
@@ -47,9 +49,9 @@ struct cluster_developer_preview_enable_request {
 };
 
 cluster_developer_preview_enable_response
-make_response(std::error_code ec, cluster_developer_preview_enable_request&, scope_get_all_request::encoded_response_type encoded)
+make_response(std::error_code ec, cluster_developer_preview_enable_request& request, scope_get_all_request::encoded_response_type encoded)
 {
-    cluster_developer_preview_enable_response response{ ec };
+    cluster_developer_preview_enable_response response{ request.client_context_id, ec };
     if (!ec) {
         if (encoded.status_code != 200) {
             response.ec = std::make_error_code(error::common_errc::internal_server_failure);

data/ext/couchbase/operations/collection_create.hxx

@@ -27,6 +27,7 @@ namespace couchbase::operations
 {
 
 struct collection_create_response {
+    std::string client_context_id;
     std::error_code ec;
     std::uint64_t uid{ 0 };
 };
@@ -43,6 +44,7 @@ struct collection_create_request {
     std::string collection_name;
     std::uint32_t max_expiry{ 0 };
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
 
     void encode_to(encoded_request_type& encoded)
     {
@@ -57,9 +59,9 @@ struct collection_create_request {
 };
 
 collection_create_response
-make_response(std::error_code ec, collection_create_request&, collection_create_request::encoded_response_type encoded)
+make_response(std::error_code ec, collection_create_request& request, collection_create_request::encoded_response_type encoded)
 {
-    collection_create_response response{ ec };
+    collection_create_response response{ request.client_context_id, ec };
     if (!ec) {
         switch (encoded.status_code) {
             case 400:

data/ext/couchbase/operations/collection_drop.hxx

@@ -27,6 +27,7 @@ namespace couchbase::operations
 {
 
 struct collection_drop_response {
+    std::string client_context_id;
     std::error_code ec;
     std::uint64_t uid{ 0 };
 };
@@ -42,6 +43,7 @@ struct collection_drop_request {
     std::string scope_name;
     std::string collection_name;
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
 
     void encode_to(encoded_request_type& encoded)
     {
@@ -51,9 +53,9 @@ struct collection_drop_request {
 };
 
 collection_drop_response
-make_response(std::error_code ec, collection_drop_request&, collection_drop_request::encoded_response_type encoded)
+make_response(std::error_code ec, collection_drop_request& request, collection_drop_request::encoded_response_type encoded)
 {
-    collection_drop_response response{ ec };
+    collection_drop_response response{ request.client_context_id, ec };
     if (!ec) {
         switch (encoded.status_code) {
             case 400:

data/ext/couchbase/operations/document_analytics.hxx

@@ -161,7 +161,6 @@ struct analytics_request {
     bool priority{ false };
 
     std::optional<scan_consistency_type> scan_consistency{};
-    std::optional<std::uint64_t> scan_wait{};
 
     std::map<std::string, tao::json::value> raw{};
     std::vector<tao::json::value> positional_parameters{};
@@ -196,9 +195,6 @@ struct analytics_request {
                     body["scan_consistency"] = "request_plus";
                     break;
             }
-            if (scan_wait) {
-                body["scan_wait"] = fmt::format("{}ms", scan_wait.value());
-            }
         }
         for (auto& param : raw) {
             body[param.first] = param.second;