couchbase 3.0.0.alpha.3-universal-darwin-19 → 3.0.0.alpha.4-universal-darwin-19

data/ext/couchbase/operations/view_index_get_all.hxx

@@ -0,0 +1,125 @@
+/* -*- 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 <operations/design_document.hxx>
+
+namespace couchbase::operations
+{
+struct view_index_get_all_response {
+    std::string client_context_id;
+    std::error_code ec;
+    std::vector<design_document> design_documents{};
+};
+
+struct view_index_get_all_request {
+    using response_type = view_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::management;
+
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+
+    std::string bucket_name;
+    design_document::name_space name_space;
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.method = "GET";
+        encoded.path = fmt::format("/pools/default/buckets/{}/ddocs", bucket_name);
+    }
+};
+
+view_index_get_all_response
+make_response(std::error_code ec, view_index_get_all_request& request, view_index_get_all_request::encoded_response_type encoded)
+{
+    view_index_get_all_response response{ request.client_context_id, ec };
+    if (!ec) {
+        if (encoded.status_code == 200) {
+            auto payload = tao::json::from_string(encoded.body);
+            auto* rows = payload.find("rows");
+            if (rows != nullptr && rows->is_array()) {
+                for (const auto& entry : rows->get_array()) {
+                    const auto* dd = entry.find("doc");
+                    if (dd == nullptr || !dd->is_object()) {
+                        continue;
+                    }
+                    const auto* meta = dd->find("meta");
+                    if (meta == nullptr || !meta->is_object()) {
+                        continue;
+                    }
+
+                    design_document document{};
+                    document.rev = meta->at("rev").get_string();
+                    auto id = meta->at("id").get_string();
+                    static const std::string prefix = "_design/";
+                    if (id.find(prefix) == 0) {
+                        document.name = id.substr(prefix.size());
+                    } else {
+                        document.name = id; // fall back, should not happen
+                    }
+                    static const std::string name_space_prefix = "dev_";
+                    if (document.name.find(name_space_prefix) == 0) {
+                        document.name = document.name.substr(name_space_prefix.size());
+                        document.ns = couchbase::operations::design_document::name_space::development;
+                    } else {
+                        document.ns = couchbase::operations::design_document::name_space::production;
+                    }
+                    if (document.ns != request.name_space) {
+                        continue;
+                    }
+
+                    const auto *json = dd->find("json");
+                    if (json == nullptr || !json->is_object()) {
+                        continue;
+                    }
+                    const auto* views = json->find("views");
+                    if (views != nullptr && views->is_object()) {
+                        for (const auto& view_entry : views->get_object()) {
+                            couchbase::operations::design_document::view view;
+                            view.name = view_entry.first;
+                            if (view_entry.second.is_object()) {
+                                const auto* map = view_entry.second.find("map");
+                                if (map != nullptr && map->is_string()) {
+                                    view.map = map->get_string();
+                                }
+                                const auto* reduce = view_entry.second.find("reduce");
+                                if (reduce != nullptr && reduce->is_string()) {
+                                    view.reduce = reduce->get_string();
+                                }
+                            }
+                            document.views[view.name] = view;
+                        }
+                    }
+
+                    response.design_documents.emplace_back(document);
+                }
+            }
+        } else if (encoded.status_code == 404) {
+            response.ec = std::make_error_code(error::common_errc::bucket_not_found);
+        } else {
+            response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/view_index_upsert.hxx

@@ -0,0 +1,87 @@
+/* -*- 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 view_index_upsert_response {
+    std::string client_context_id;
+    std::error_code ec;
+};
+
+struct view_index_upsert_request {
+    using response_type = view_index_upsert_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+
+    static const inline service_type type = service_type::views;
+
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+
+    std::string bucket_name;
+    design_document document;
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        tao::json::value body;
+        body["views"] = tao::json::empty_object;
+        for (const auto& view : document.views) {
+            tao::json::value view_def;
+            if (view.second.map) {
+                view_def["map"] = *view.second.map;
+            }
+            if (view.second.reduce) {
+                view_def["reduce"] = *view.second.reduce;
+            }
+            body["views"][view.first] = view_def;
+        }
+
+        encoded.headers["content-type"] = "application/json";
+        encoded.method = "PUT";
+        encoded.path = fmt::format(
+          "/{}/_design/{}{}", bucket_name, document.ns == design_document::name_space::development ? "dev_" : "", document.name);
+        encoded.body = tao::json::to_string(body);
+    }
+};
+
+view_index_upsert_response
+make_response(std::error_code ec, view_index_upsert_request& request, view_index_upsert_request::encoded_response_type encoded)
+{
+    view_index_upsert_response response{ request.client_context_id, ec };
+    if (!ec) {
+        switch (encoded.status_code) {
+            case 200:
+            case 201:
+                break;
+            case 400:
+                response.ec = std::make_error_code(error::common_errc::invalid_argument);
+                break;
+            case 404:
+                response.ec = std::make_error_code(error::view_errc::design_document_not_found);
+                break;
+            default:
+                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/service_type.hxx

@@ -19,5 +19,42 @@
 
 namespace couchbase
 {
-enum class service_type { kv, query, analytics, search, views, management };
+enum class service_type {
+    kv,
+    query,
+    analytics,
+    search,
+    views,
+    management,
+};
 }
+
+template<>
+struct fmt::formatter<couchbase::service_type> : formatter<std::string_view> {
+    template<typename FormatContext>
+    auto format(couchbase::service_type type, FormatContext& ctx)
+    {
+        string_view name = "unknown";
+        switch (type) {
+            case couchbase::service_type::kv:
+                name = "kv";
+                break;
+            case couchbase::service_type::query:
+                name = "query";
+                break;
+            case couchbase::service_type::analytics:
+                name = "analytics";
+                break;
+            case couchbase::service_type::search:
+                name = "search";
+                break;
+            case couchbase::service_type::views:
+                name = "views";
+                break;
+            case couchbase::service_type::management:
+                name = "management";
+                break;
+        }
+        return formatter<string_view>::format(name, ctx);
+    }
+};

data/ext/couchbase/timeout_defaults.hxx

@@ -29,4 +29,6 @@ constexpr std::chrono::milliseconds query_timeout{ 75'000 };
 constexpr std::chrono::milliseconds analytics_timeout{ 75'000 };
 constexpr std::chrono::milliseconds search_timeout{ 75'000 };
 constexpr std::chrono::milliseconds management_timeout{ 75'000 };
-} // namespace couchbase::timeout_defaults
+
+constexpr std::chrono::milliseconds dns_srv_timeout{ 500 };
+} // namespace couchbase::timeout_defaults

data/ext/couchbase/utils/connection_string.hxx

@@ -0,0 +1,231 @@
+/* -*- 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 <string>
+
+#include <tao/json/external/pegtl.hpp>
+#include <tao/json/external/pegtl/contrib/uri.hpp>
+
+namespace couchbase::utils
+{
+
+struct connection_string {
+    enum class bootstrap_mode {
+        unspecified,
+        gcccp,
+        http,
+    };
+
+    enum class address_type {
+        ipv4,
+        ipv6,
+        dns,
+    };
+
+    struct node {
+        std::string address;
+        std::uint16_t port;
+        address_type type;
+        bootstrap_mode mode{ bootstrap_mode::unspecified };
+    };
+
+    std::string scheme{};
+    bool tls{ false };
+    std::map<std::string, std::string> params{};
+    std::vector<node> bootstrap_nodes{};
+
+    std::optional<std::string> default_bucket_name{};
+    bootstrap_mode default_mode{ bootstrap_mode::unspecified };
+    std::uint16_t default_port{ 0 };
+
+    std::optional<std::string> error{};
+};
+
+namespace priv
+{
+using namespace tao::json::pegtl;
+
+struct bucket_name : seq<uri::segment_nz> {
+};
+using param_key = star<sor<abnf::ALPHA, abnf::DIGIT, one<'_'>>>;
+using param_value = star<sor<minus<uri::pchar, one<'=', '&', '?'>>, one<'/'>>>;
+struct param : seq<param_key, one<'='>, param_value> {
+};
+
+using sub_delims = minus<uri::sub_delims, one<',', '='>>; // host and mode separators
+struct reg_name : star<sor<uri::unreserved, uri::pct_encoded, sub_delims>> {
+};
+struct host : sor<uri::IP_literal, uri::IPv4address, reg_name> {
+};
+
+struct mode : sor<istring<'c', 'c', 'c', 'p'>, istring<'g', 'c', 'c', 'c', 'p'>, istring<'h', 't', 't', 'p'>, istring<'m', 'c', 'd'>> {
+};
+using node = seq<host, opt<uri::colon, uri::port>, opt<one<'='>, mode>>;
+
+using opt_bucket_name = opt_must<one<'/'>, bucket_name>;
+using opt_params = opt_must<one<'?'>, list_must<param, one<'&'>>>;
+using opt_nodes = seq<list_must<node, one<',', ';'>>, opt_bucket_name>;
+
+using grammar = must<seq<uri::scheme, one<':'>, uri::dslash, opt_nodes, opt_params, eof>>;
+
+template<typename Rule>
+struct action {
+};
+
+template<>
+struct action<uri::scheme> {
+    template<typename ActionInput>
+    static void apply(const ActionInput& in, connection_string& cs, connection_string::node& /* cur_node */)
+    {
+        cs.scheme = in.string();
+        if (cs.scheme == "couchbase") {
+            cs.default_port = 11210;
+            cs.default_mode = connection_string::bootstrap_mode::gcccp;
+            cs.tls = false;
+        } else if (cs.scheme == "couchbases") {
+            cs.default_port = 11207;
+            cs.default_mode = connection_string::bootstrap_mode::gcccp;
+            cs.tls = true;
+        } else if (cs.scheme == "http") {
+            cs.default_port = 8091;
+            cs.default_mode = connection_string::bootstrap_mode::http;
+            cs.tls = false;
+        } else if (cs.scheme == "https") {
+            cs.default_port = 18091;
+            cs.default_mode = connection_string::bootstrap_mode::http;
+            cs.tls = true;
+        }
+    }
+};
+
+template<>
+struct action<param> {
+    template<typename ActionInput>
+    static void apply(const ActionInput& in, connection_string& cs, connection_string::node& /* cur_node */)
+    {
+        const auto& pair = in.string();
+        auto eq = pair.find('=');
+        std::string key = pair.substr(0, eq);
+        cs.params[key] = (eq == std::string::npos) ? "" : pair.substr(eq + 1);
+    }
+};
+
+template<>
+struct action<reg_name> {
+    template<typename ActionInput>
+    static void apply(const ActionInput& in, connection_string& /* cs */, connection_string::node& cur_node)
+    {
+        cur_node.type = connection_string::address_type::dns;
+        cur_node.address = in.string_view();
+    }
+};
+
+template<>
+struct action<uri::IPv4address> {
+    template<typename ActionInput>
+    static void apply(const ActionInput& in, connection_string& /* cs */, connection_string::node& cur_node)
+    {
+        cur_node.type = connection_string::address_type::ipv4;
+        cur_node.address = in.string_view();
+    }
+};
+
+template<>
+struct action<uri::IPv6address> {
+    template<typename ActionInput>
+    static void apply(const ActionInput& in, connection_string& /* cs */, connection_string::node& cur_node)
+    {
+        cur_node.type = connection_string::address_type::ipv6;
+        cur_node.address = in.string_view();
+    }
+};
+
+template<>
+struct action<node> {
+    template<typename ActionInput>
+    static void apply(const ActionInput& /* in */, connection_string& cs, connection_string::node& cur_node)
+    {
+        cs.bootstrap_nodes.push_back(cur_node);
+        cur_node = {};
+    }
+};
+
+template<>
+struct action<uri::port> {
+    template<typename ActionInput>
+    static void apply(const ActionInput& in, connection_string& /* cs */, connection_string::node& cur_node)
+    {
+        cur_node.port = static_cast<std::uint16_t>(std::stoul(in.string()));
+    }
+};
+
+template<>
+struct action<mode> {
+    template<typename ActionInput>
+    static void apply(const ActionInput& in, connection_string& /* cs */, connection_string::node& cur_node)
+    {
+        std::string mode = in.string();
+        std::transform(mode.begin(), mode.end(), mode.begin(), [](unsigned char c) { return std::tolower(c); });
+        if (mode == "mcd" || mode == "gcccp" || mode == "cccp") {
+            cur_node.mode = connection_string::bootstrap_mode::gcccp;
+        } else if (mode == "http") {
+            cur_node.mode = connection_string::bootstrap_mode::http;
+        }
+    }
+};
+
+template<>
+struct action<bucket_name> {
+    template<typename ActionInput>
+    static void apply(const ActionInput& in, connection_string& cs, connection_string::node& /* cur_node */)
+    {
+        cs.default_bucket_name = in.string();
+    }
+};
+} // namespace priv
+
+static connection_string
+parse_connection_string(const std::string& input)
+{
+    connection_string res;
+
+    if (input.empty()) {
+        res.error = "failed to parse connection string: empty input";
+        return res;
+    }
+
+    auto in = tao::json::pegtl::memory_input(input, __FUNCTION__);
+    try {
+        connection_string::node node{};
+        tao::json::pegtl::parse<priv::grammar, priv::action>(in, res, node);
+    } catch (tao::json::pegtl::parse_error& e) {
+        for (const auto& position : e.positions) {
+            if (position.source == __FUNCTION__) {
+                res.error = fmt::format(
+                  "failed to parse connection string (column: {}, trailer: \"{}\")", position.byte_in_line, input.substr(position.byte));
+                break;
+            }
+        }
+        if (!res.error) {
+            res.error = e.what();
+        }
+    }
+    return res;
+}
+} // namespace couchbase::utils