couchbase 3.0.0.alpha.1 → 3.0.0.alpha.2

data/ext/couchbase/io/session_manager.hxx

@@ -52,7 +52,9 @@ class session_manager
             std::string hostname;
             std::uint16_t port = 0;
             std::tie(hostname, port) = next_node(type);
-            Expects(port != 0); // FIXME: service_not_available
+            if (port == 0) {
+                return nullptr;
+            }
             config_.nodes.size();
             auto session = std::make_shared<http_session>(client_id_, ctx_, username, password, hostname, std::to_string(port));
             busy_sessions_[type].push_back(session);
@@ -71,27 +73,40 @@ class session_manager
   private:
     std::pair<std::string, std::uint16_t> next_node(service_type type)
     {
-        auto cur_index = next_index_;
-        next_index_ = (next_index_ + 1) % config_.nodes.size();
-        auto& node = config_.nodes[cur_index];
-        switch (type) {
-            case service_type::query:
-                return { node.hostname, node.services_plain.query.value_or(0) };
-
-            case service_type::analytics:
-                return { node.hostname, node.services_plain.analytics.value_or(0) };
-
-            case service_type::search:
-                return { node.hostname, node.services_plain.search.value_or(0) };
-
-            case service_type::views:
-                return { node.hostname, node.services_plain.views.value_or(0) };
-
-            case service_type::management:
-                return { node.hostname, node.services_plain.management.value_or(0) };
-
-            case service_type::kv:
-                return { node.hostname, node.services_plain.key_value.value_or(0) };
+        auto candidates = config_.nodes.size();
+        while (candidates > 0) {
+            --candidates;
+            auto& node = config_.nodes[next_index_];
+            next_index_ = (next_index_ + 1) % config_.nodes.size();
+            std::uint16_t port = 0;
+            switch (type) {
+                case service_type::query:
+                    port = node.services_plain.query.value_or(0);
+                    break;
+
+                case service_type::analytics:
+                    port = node.services_plain.analytics.value_or(0);
+                    break;
+
+                case service_type::search:
+                    port = node.services_plain.search.value_or(0);
+                    break;
+
+                case service_type::views:
+                    port = node.services_plain.views.value_or(0);
+                    break;
+
+                case service_type::management:
+                    port = node.services_plain.management.value_or(0);
+                    break;
+
+                case service_type::kv:
+                    port = node.services_plain.key_value.value_or(0);
+                    break;
+            }
+            if (port != 0) {
+                return { node.hostname, port };
+            }
         }
         return { "", 0 };
     }

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 : formatter {
     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,43 @@
 
 #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 <operations/query.hxx>
+#include <document_id.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_query.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/command.hxx>

data/ext/couchbase/operations/bucket_create.hxx

@@ -0,0 +1,138 @@
+/* -*- 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 <operations/bucket_settings.hxx>
+#include <utils/url_codec.hxx>
+
+namespace couchbase::operations
+{
+
+struct bucket_create_response {
+    std::error_code ec;
+    std::string error_message{};
+};
+
+struct bucket_create_request {
+    using response_type = bucket_create_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+
+    static const inline service_type type = service_type::management;
+
+    bucket_settings bucket{};
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.method = "POST";
+        encoded.path = fmt::format("/pools/default/buckets");
+
+        encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+        encoded.body.append(fmt::format("name={}", utils::string_codec::form_encode(bucket.name)));
+        switch (bucket.bucket_type) {
+            case bucket_settings::bucket_type::couchbase:
+                encoded.body.append("&bucketType=couchbase");
+                break;
+            case bucket_settings::bucket_type::memcached:
+                encoded.body.append("&bucketType=memcached");
+                break;
+            case bucket_settings::bucket_type::ephemeral:
+                encoded.body.append("&bucketType=ephemeral");
+                break;
+            case bucket_settings::bucket_type::unknown:
+                break;
+        }
+        encoded.body.append(fmt::format("&ramQuotaMB={}", bucket.ram_quota_mb));
+        encoded.body.append(fmt::format("&replicaNumber={}", bucket.num_replicas));
+        encoded.body.append(fmt::format("&maxTTL={}", bucket.max_expiry));
+        encoded.body.append(fmt::format("&replicaIndex={}", bucket.replica_indexes ? "1" : "0"));
+        encoded.body.append(fmt::format("&flushEnabled={}", bucket.flush_enabled ? "1" : "0"));
+        switch (bucket.ejection_policy) {
+            case bucket_settings::ejection_policy::full:
+                encoded.body.append("&evictionPolicy=fullEviction");
+                break;
+            case bucket_settings::ejection_policy::value_only:
+                encoded.body.append("&evictionPolicy=valueOnly");
+                break;
+            case bucket_settings::ejection_policy::unknown:
+                break;
+        }
+        switch (bucket.compression_mode) {
+            case bucket_settings::compression_mode::off:
+                encoded.body.append("&compressionMode=off");
+                break;
+            case bucket_settings::compression_mode::active:
+                encoded.body.append("&compressionMode=active");
+                break;
+            case bucket_settings::compression_mode::passive:
+                encoded.body.append("&compressionMode=passive");
+                break;
+            case bucket_settings::compression_mode::unknown:
+                break;
+        }
+        switch (bucket.conflict_resolution_type) {
+            case bucket_settings::conflict_resolution_type::timestamp:
+                encoded.body.append("&conflictResolutionType=lww");
+                break;
+            case bucket_settings::conflict_resolution_type::sequence_number:
+                encoded.body.append("&conflictResolutionType=seqno");
+                break;
+            case bucket_settings::conflict_resolution_type::unknown:
+                break;
+        }
+    }
+};
+
+bucket_create_response
+make_response(std::error_code ec, bucket_create_request&, bucket_create_request::encoded_response_type encoded)
+{
+    bucket_create_response response{ ec };
+    if (!ec) {
+        switch (encoded.status_code) {
+            case 404:
+                response.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                break;
+            case 400: {
+                response.ec = std::make_error_code(error::common_errc::invalid_argument);
+                auto payload = tao::json::from_string(encoded.body);
+                auto* errors = payload.find("errors");
+                if (errors != nullptr) {
+                    std::vector<std::string> error_list{};
+                    for (auto& err : errors->get_object()) {
+                        error_list.emplace_back(err.second.get_string());
+                    }
+                    if (!error_list.empty()) {
+                        response.error_message = fmt::format("{}", fmt::join(error_list.begin(), error_list.end(), ". "));
+                    }
+                }
+            } break;
+            case 200:
+            case 202:
+                break;
+            default:
+                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                break;
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/bucket_drop.hxx

@@ -0,0 +1,65 @@
+/* -*- 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>
+
+namespace couchbase::operations
+{
+
+struct bucket_drop_response {
+    std::error_code ec;
+};
+
+struct bucket_drop_request {
+    using response_type = bucket_drop_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+
+    static const inline service_type type = service_type::management;
+
+    std::string name;
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.method = "DELETE";
+        encoded.path = fmt::format("/pools/default/buckets/{}", name);
+    }
+};
+
+bucket_drop_response
+make_response(std::error_code ec, bucket_drop_request&, bucket_drop_request::encoded_response_type encoded)
+{
+    bucket_drop_response response{ ec };
+    if (!ec) {
+        switch (encoded.status_code) {
+            case 404:
+                response.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                break;
+            case 200:
+                response.ec = {};
+                break;
+            default:
+                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                break;
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/bucket_flush.hxx

@@ -0,0 +1,65 @@
+/* -*- 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>
+
+namespace couchbase::operations
+{
+
+struct bucket_flush_response {
+    std::error_code ec;
+};
+
+struct bucket_flush_request {
+    using response_type = bucket_flush_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+
+    static const inline service_type type = service_type::management;
+
+    std::string name;
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.method = "POST";
+        encoded.path = fmt::format("/pools/default/buckets/{}/controller/doFlush", name);
+    }
+};
+
+bucket_flush_response
+make_response(std::error_code ec, bucket_flush_request&, bucket_flush_request::encoded_response_type encoded)
+{
+    bucket_flush_response response{ ec };
+    if (!ec) {
+        switch (encoded.status_code) {
+            case 404:
+                response.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                break;
+            case 200:
+                response.ec = {};
+                break;
+            default:
+                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                break;
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/bucket_get.hxx

@@ -0,0 +1,69 @@
+/* -*- 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 <operations/bucket_settings.hxx>
+
+namespace couchbase::operations
+{
+
+struct bucket_get_response {
+    std::error_code ec;
+    bucket_settings bucket{};
+};
+
+struct bucket_get_request {
+    using response_type = bucket_get_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+
+    static const inline service_type type = service_type::management;
+
+    std::string name;
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.method = "GET";
+        encoded.path = fmt::format("/pools/default/buckets/{}", name);
+    }
+};
+
+bucket_get_response
+make_response(std::error_code ec, bucket_get_request&, bucket_get_request::encoded_response_type encoded)
+{
+    bucket_get_response response{ ec };
+    if (!ec) {
+        switch (encoded.status_code) {
+            case 404:
+                response.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                break;
+            case 200:
+                response.bucket = tao::json::from_string(encoded.body).as<bucket_settings>();
+                break;
+            default:
+                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                break;
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations