couchbase 3.1.1 → 3.2.0

data/ext/couchbase/utils/byteswap.hxx

@@ -19,7 +19,7 @@
 
 namespace couchbase::utils
 {
-static inline std::uint64_t
+static constexpr std::uint64_t
 byte_swap_64(std::uint64_t val)
 {
     std::uint64_t ret = 0U;

data/ext/couchbase/utils/connection_string.hxx

@@ -357,6 +357,26 @@ extract_options(connection_string& connstr)
                 } else if (param.second == "false" || param.second == "no" || param.second == "off") {
                     connstr.options.enable_compression = false;
                 }
+            } else if (param.first == "enable_tracing") {
+                /**
+                 * true - use threshold_logging_tracer
+                 * false - use noop_tracer
+                 */
+                if (param.second == "true" || param.second == "yes" || param.second == "on") {
+                    connstr.options.enable_tracing = true;
+                } else if (param.second == "false" || param.second == "no" || param.second == "off") {
+                    connstr.options.enable_tracing = false;
+                }
+            } else if (param.first == "enable_metrics") {
+                /**
+                 * true - use logging_meter
+                 * false - use noop_meter
+                 */
+                if (param.second == "true" || param.second == "yes" || param.second == "on") {
+                    connstr.options.enable_metrics = true;
+                } else if (param.second == "false" || param.second == "no" || param.second == "off") {
+                    connstr.options.enable_metrics = false;
+                }
             } else {
                 spdlog::warn(R"(unknown parameter "{}" in connection string (value "{}"))", param.first, param.second);
             }
@@ -388,7 +408,7 @@ parse_connection_string(const std::string& input)
     try {
         connection_string::node node{};
         tao::json::pegtl::parse<priv::grammar, priv::action>(in, res, node);
-    } catch (tao::json::pegtl::parse_error& e) {
+    } catch (const tao::json::pegtl::parse_error& e) {
         for (const auto& position : e.positions()) {
             if (position.source == __FUNCTION__) {
                 res.error = fmt::format(

data/ext/couchbase/utils/name_codec.hxx

@@ -0,0 +1,41 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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 <sstream>
+#include <string>
+
+namespace couchbase::utils
+{
+struct analytics {
+    static std::string uncompound_name(const std::string& name)
+    {
+        std::stringstream ss;
+        ss << '`';
+        for (const auto symbol : name) {
+            if (symbol == '/') {
+                ss << "`.`";
+            } else {
+                ss << symbol;
+            }
+        }
+        ss << '`';
+        return ss.str();
+    }
+};
+} // namespace couchbase::utils

data/ext/couchbase/utils/url_codec.hxx

@@ -67,6 +67,17 @@ url_decode(std::string& s)
     return false;
 }
 
+std::string
+url_decode(const std::string& src)
+{
+    std::string dst{};
+    size_t n = 0;
+    if (url_decode(src.begin(), src.end(), dst.begin(), n)) {
+        dst.resize(n);
+    }
+    return dst;
+}
+
 namespace priv
 {
 inline bool
@@ -176,6 +187,14 @@ url_encode(const Tin& in, Tout& out)
     return url_encode(in.begin(), in.end(), out);
 }
 
+std::string
+url_encode(const std::string& src)
+{
+    std::string dst{};
+    url_encode(src.begin(), src.end(), dst);
+    return dst;
+}
+
 /* See: https://url.spec.whatwg.org/#urlencoded-serializing: */
 /*
  * 0x2A
@@ -222,4 +241,221 @@ form_encode(const std::string& src)
     return dst;
 }
 
+namespace v2
+{
+enum class encoding {
+    encode_path,
+    encode_path_segment,
+    encode_host,
+    encode_zone,
+    encode_user_password,
+    encode_query_component,
+    encode_fragment,
+};
+
+bool
+should_escape(char c, encoding mode)
+{
+    // §2.3 Unreserved characters (alphanum)
+    if (('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || ('0' <= c && c <= '9')) {
+        return false;
+    }
+
+    if (mode == encoding::encode_host || mode == encoding::encode_zone) {
+        // §3.2.2 Host allows
+        //	sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+        // as part of reg-name.
+        // We add : because we include :port as part of host.
+        // We add [ ] because we include [ipv6]:port as part of host.
+        // We add < > because they're the only characters left that we could possibly allow, and Parse will reject them if we escape them
+        // (because hosts can't use %-encoding for ASCII bytes).
+        switch (c) {
+            case '!':
+            case '$':
+            case '&':
+            case '\'':
+            case '(':
+            case ')':
+            case '*':
+            case '+':
+            case ',':
+            case ';':
+            case '=':
+            case ':':
+            case '[':
+            case ']':
+            case '<':
+            case '>':
+            case '"':
+                return false;
+
+            default:
+                break;
+        }
+    }
+
+    switch (c) {
+        case '-':
+        case '_':
+        case '.':
+        case '~':
+            // §2.3 Unreserved characters (mark)
+            return false;
+
+        case '$':
+        case '&':
+        case '+':
+        case ',':
+        case '/':
+        case ':':
+        case ';':
+        case '=':
+        case '?':
+        case '@':
+            // §2.2 Reserved characters (reserved)
+            // Different sections of the URL allow a few of
+            // the reserved characters to appear unescaped.
+            switch (mode) {
+                case encoding::encode_path: // §3.3
+                    // The RFC allows : @ & = + $ but saves / ; , for assigning meaning to individual path segments. This package only
+                    // manipulates the path as a whole, so we allow those last three as well. That leaves only ? to escape.
+                    return c == '?';
+
+                case encoding::encode_path_segment: // §3.3
+                    // The RFC allows : @ & = + $ but saves / ; , for assigning meaning to individual path segments.
+                    return c == '/' || c == ';' || c == ',' || c == '?';
+
+                case encoding::encode_user_password: // §3.2.1
+                    // The RFC allows ';', ':', '&', '=', '+', '$', and ',' in userinfo, so we must escape only '@', '/', and '?'. The
+                    // parsing of userinfo treats ':' as special so we must escape that too.
+                    return c == '@' || c == '/' || c == '?' || c == ':';
+
+                case encoding::encode_query_component: // §3.4
+                    // The RFC reserves (so we must escape) everything.
+                    return true;
+
+                case encoding::encode_fragment: // §4.1
+                    // The RFC text is silent but the grammar allows everything, so escape nothing.
+                    return false;
+
+                default:
+                    break;
+            }
+
+        default:
+            break;
+    }
+
+    if (mode == encoding::encode_fragment) {
+        // RFC 3986 §2.2 allows not escaping sub-delims. A subset of sub-delims are included in reserved from RFC 2396 §2.2. The remaining
+        // sub-delims do not need to be escaped. To minimize potential breakage, we apply two restrictions: (1) we always escape sub-delims
+        // outside of the fragment, and (2) we always escape single quote to avoid breaking callers that had previously assumed that single
+        // quotes would be escaped. See issue #19917.
+        switch (c) {
+            case '!':
+            case '(':
+            case ')':
+            case '*':
+                return false;
+
+            default:
+                break;
+        }
+    }
+
+    // Everything else must be escaped.
+    return true;
+}
+
+constexpr auto upper_hex = "0123456789ABCDEF";
+
+std::string
+escape(const std::string& s, encoding mode)
+{
+    std::size_t space_count{ 0 };
+    std::size_t hex_count{ 0 };
+
+    for (const auto& c : s) {
+        if (should_escape(c, mode)) {
+            if (c == ' ' && mode == encoding::encode_query_component) {
+                ++space_count;
+            } else {
+                ++hex_count;
+            }
+        }
+    }
+
+    if (space_count == 0 && hex_count == 0) {
+        return s;
+    }
+
+    std::size_t required = s.size() + 2 * hex_count;
+    std::string t;
+    t.resize(required);
+
+    if (hex_count == 0) {
+        for (std::size_t i = 0; i < s.size(); ++i) {
+            if (s[i] == ' ') {
+                t[i] = '+';
+            } else {
+                t[i] = s[i];
+            }
+        }
+        return t;
+    }
+
+    std::size_t j{ 0 };
+    for (const auto& c : s) {
+        if (c == ' ' && mode == encoding::encode_query_component) {
+            t[j++] = '+';
+        } else if (should_escape(c, mode)) {
+            t[j++] = '%';
+            t[j++] = upper_hex[(c >> 4U) & 0x0f];
+            t[j++] = upper_hex[c & 0x0f];
+        } else {
+            t[j++] = c;
+        }
+    }
+    return t;
+}
+
+/**
+ * Escapes the string so it can be safely placed inside a URL query.
+ *
+ * @param s
+ * @return
+ */
+std::string
+query_escape(const std::string& s)
+{
+    return escape(s, encoding::encode_query_component);
+}
+
+/**
+ * Escapes the string so it can be safely placed inside a URL path segment, replacing special characters (including /) with %XX sequences as
+ * needed.
+ */
+std::string
+path_escape(const std::string& s)
+{
+    return escape(s, encoding::encode_path);
+}
+
+std::string
+form_encode(const std::map<std::string, std::string>& values)
+{
+    std::stringstream ss;
+    bool first{ true };
+    for (const auto& [key, value] : values) {
+        if (first) {
+            first = false;
+        } else {
+            ss << '&';
+        }
+        ss << query_escape(key) << '=' << query_escape(value);
+    }
+    return ss.str();
+}
+} // namespace v2
+
 } // namespace couchbase::utils::string_codec

data/ext/couchbase/version.hxx

@@ -24,7 +24,7 @@
 namespace couchbase
 {
 constexpr auto BACKEND_VERSION_MAJOR = 1;
-constexpr auto BACKEND_VERSION_MINOR = 5;
+constexpr auto BACKEND_VERSION_MINOR = 6;
 constexpr auto BACKEND_VERSION_PATCH = 0;
 
 inline const std::string&

data/ext/test/CMakeLists.txt

@@ -1,5 +1,6 @@
 ruby_test(trivial_crud)
 ruby_test(trivial_query)
 native_test(trivial_crud)
+native_test(trivial_query)
 native_test(diagnostics)
 native_test(binary_operations)

data/ext/test/test_native_trivial_query.cxx

@@ -0,0 +1,60 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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.
+ */
+
+#include "test_helper_native.hxx"
+
+TEST_CASE("native: trivial non-data query", "[native]")
+{
+    auto ctx = test_context::load_from_environment();
+    native_init_logger();
+
+    auto connstr = couchbase::utils::parse_connection_string(ctx.connection_string);
+    couchbase::cluster_credentials auth{};
+    auth.username = ctx.username;
+    auth.password = ctx.password;
+
+    asio::io_context io;
+
+    couchbase::cluster cluster(io);
+    auto io_thread = std::thread([&io]() { io.run(); });
+
+    {
+        auto barrier = std::make_shared<std::promise<std::error_code>>();
+        auto f = barrier->get_future();
+        cluster.open(couchbase::origin(auth, connstr), [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
+        auto rc = f.get();
+        INFO(rc.message());
+        REQUIRE_FALSE(rc);
+    }
+    {
+        couchbase::operations::query_request req{ R"(SELECT "ruby rules" AS greeting)" };
+        auto barrier = std::make_shared<std::promise<couchbase::operations::query_response>>();
+        auto f = barrier->get_future();
+        cluster.execute_http(req, [barrier](couchbase::operations::query_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        INFO(resp.ctx.ec.message());
+        REQUIRE_FALSE(resp.ctx.ec);
+    }
+    {
+        auto barrier = std::make_shared<std::promise<void>>();
+        auto f = barrier->get_future();
+        cluster.close([barrier]() { barrier->set_value(); });
+        f.get();
+    }
+
+    io_thread.join();
+}

data/ext/third_party/hdr_histogram_c/CMakeLists.txt

@@ -0,0 +1,84 @@
+cmake_minimum_required(VERSION 3.5)
+
+project(hdr_histogram VERSION 0.10.0 LANGUAGES C)
+
+include(GNUInstallDirs)
+include(CMakePackageConfigHelpers)
+
+# Follow all steps below in order to calculate new ABI version when updating the library
+# NOTE: THIS IS UNRELATED to the actual project version
+#
+# 1. If the library source code has changed at all since the last update, then increment revision
+# 2. If any interfaces have been added, removed, or changed since the last update, increment current and set revision to 0.
+# 3. If any interfaces have been added since the last public release, then increment age.
+# 4. If any interfaces have been removed since the last public release, then set age to 0.
+
+set(HDR_SOVERSION_CURRENT   6)
+set(HDR_SOVERSION_AGE       1)
+set(HDR_SOVERSION_REVISION  1)
+
+set(HDR_VERSION ${HDR_SOVERSION_CURRENT}.${HDR_SOVERSION_AGE}.${HDR_SOVERSION_REVISION})
+set(HDR_SOVERSION ${HDR_SOVERSION_CURRENT})
+option(HDR_LOG_REQUIRED "HDR Logging component required" ON)
+
+set(CMAKE_C_STANDARD 99)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CMAKE_C_EXTENSIONS OFF)
+
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+if(UNIX)
+    add_compile_options(
+        -Wall
+        -Wno-unknown-pragmas
+        -Wextra
+        -Wshadow
+        -Winit-self
+        -Wpedantic
+        $<$<COMPILE_LANGUAGE:C>:-Wmissing-prototypes>)
+    add_definitions(-D_GNU_SOURCE)
+endif()
+
+find_package(ZLIB)
+find_package(Threads REQUIRED)
+
+set(HDR_LOG_ENABLED ${ZLIB_FOUND})
+if (${HDR_LOG_REQUIRED} AND NOT HDR_LOG_ENABLED)
+    message(SEND_ERROR "HDR_LOG_REQUIRED=ON and unable to find zlib library")
+endif()
+
+add_subdirectory(src)
+
+option(HDR_HISTOGRAM_BUILD_PROGRAMS "Build tests and examples" ON)
+if(HDR_HISTOGRAM_BUILD_PROGRAMS)
+    include(CTest)
+
+    if(BUILD_TESTING)
+        add_subdirectory(test)
+    endif()
+
+    add_subdirectory(examples)
+endif()
+
+write_basic_package_version_file(
+    ${PROJECT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake
+    VERSION ${PROJECT_VERSION}
+    COMPATIBILITY AnyNewerVersion)
+configure_file(
+    config.cmake.in
+    ${PROJECT_NAME}-config.cmake
+    @ONLY)
+install(
+    EXPORT ${PROJECT_NAME}-targets
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
+    NAMESPACE ${PROJECT_NAME}::)
+install(
+    FILES
+        ${PROJECT_BINARY_DIR}/${PROJECT_NAME}-config.cmake
+        ${PROJECT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
+
+set(CPACK_GENERATOR "TGZ")
+include(CPack)