couchbase 3.0.0 → 3.0.1

data/ext/test/test_helper.hxx

@@ -0,0 +1,141 @@
+/* -*- 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 <test_config.hxx>
+
+#include <string>
+#include <regex>
+#include <cstdlib>
+
+#define CATCH_CONFIG_MAIN
+#include <catch2/catch.hpp>
+
+struct test_server_version {
+    unsigned long major;
+    unsigned long minor;
+    unsigned long micro{ 0 };
+    unsigned long build{ 0 };
+    bool developer_preview{ false };
+
+    static test_server_version parse(const std::string& str)
+    {
+        std::regex version_regex(R"((\d+).(\d+).(\d+(-(\d+))?)?)");
+        std::smatch version_match;
+        test_server_version ver{};
+        if (std::regex_match(str, version_match, version_regex) && version_match.ready()) {
+            ver.major = std::stoul(version_match[1]);
+            ver.minor = std::stoul(version_match[2]);
+            if (version_match.length(3) > 0) {
+                ver.micro = std::stoul(version_match[3]);
+                if (version_match.length(5) > 0) {
+                    ver.build = std::stoul(version_match[5]);
+                }
+            }
+        } else {
+            ver.major = 6;
+            ver.minor = 6;
+            ver.micro = 0;
+        }
+        return ver;
+    }
+
+    [[nodiscard]] bool is_alice() const
+    {
+        // [6.0.0, 6.5.0)
+        return major == 6 && minor < 5;
+    }
+
+    [[nodiscard]] bool is_mad_hatter() const
+    {
+        // [6.5.0, 7.0.0)
+        return major == 6 && minor >= 5;
+    }
+
+    [[nodiscard]] bool is_cheshire_cat() const
+    {
+        // [7.0.0, inf)
+        return major >= 7;
+    }
+
+    [[nodiscard]] bool supports_gcccp() const
+    {
+        return is_mad_hatter() || is_cheshire_cat();
+    }
+
+    [[nodiscard]] bool supports_sync_replication() const
+    {
+        return is_mad_hatter() || is_cheshire_cat();
+    }
+
+    [[nodiscard]] bool supports_scoped_queries() const
+    {
+        return is_cheshire_cat();
+    }
+
+    [[nodiscard]] bool supports_collections() const
+    {
+        return (is_mad_hatter() && developer_preview) || is_cheshire_cat();
+    }
+};
+
+struct test_context {
+    std::string connection_string{ "couchbase://127.0.0.1" };
+    std::string username{ "Administrator" };
+    std::string password{ "password" };
+    std::string bucket{ "default" };
+    test_server_version version{ 6, 6, 0 };
+
+    static test_context load_from_environment()
+    {
+        test_context ctx{};
+
+        const char* var = nullptr;
+
+        var = getenv("TEST_CONNECTION_STRING");
+        if (var != nullptr) {
+            ctx.connection_string = var;
+        }
+        var = getenv("TEST_USERNAME");
+        if (var != nullptr) {
+            ctx.username = var;
+        }
+        var = getenv("TEST_PASSWORD");
+        if (var != nullptr) {
+            ctx.password = var;
+        }
+        var = getenv("TEST_BUCKET");
+        if (var != nullptr) {
+            ctx.bucket = var;
+        }
+        var = getenv("TEST_SERVER_VERSION");
+        if (var != nullptr) {
+            ctx.bucket = var;
+        }
+        var = getenv("TEST_DEVELOPER_PREVIEW");
+        if (var != nullptr) {
+            if (strcmp(var, "true") == 0 || strcmp(var, "yes") == 0 || strcmp(var, "1") == 0) {
+                ctx.version.developer_preview = true;
+            } else if (strcmp(var, "false") == 0 || strcmp(var, "no") == 0 || strcmp(var, "0") == 0) {
+                ctx.version.developer_preview = false;
+            }
+        }
+
+        return ctx;
+    }
+};

data/ext/test/test_helper_native.hxx

@@ -0,0 +1,59 @@
+/* -*- 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 "test_helper.hxx"
+
+#include <build_config.hxx>
+
+#include <asio/version.hpp>
+
+#include <spdlog/spdlog.h>
+#include <spdlog/cfg/env.h>
+
+#include <http_parser.h>
+
+#include <snappy.h>
+
+#include <version.hxx>
+
+#include <cluster.hxx>
+#include <operations.hxx>
+
+#include <io/dns_client.hxx>
+#include <utils/connection_string.hxx>
+
+void
+native_init_logger()
+{
+    static bool initialized = false;
+
+    if (!initialized) {
+        spdlog::set_pattern("[%Y-%m-%d %T.%e] [%P,%t] [%^%l%$] %oms, %v");
+
+        auto env_val = spdlog::details::os::getenv("COUCHBASE_BACKEND_LOG_LEVEL");
+        if (env_val.empty()) {
+            spdlog::set_level(spdlog::level::warn);
+        } else {
+            auto levels = spdlog::cfg::helpers::extract_levels(env_val);
+            spdlog::details::registry::instance().update_levels(std::move(levels));
+        }
+
+        initialized = true;
+    }
+}

data/ext/test/test_helper_ruby.hxx

@@ -0,0 +1,72 @@
+/* -*- 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 "test_helper.hxx"
+#include <optional>
+
+#include <ruby.h>
+
+extern "C" {
+void
+rb_encdb_declare(const char* name);
+int
+rb_encdb_alias(const char* alias, const char* orig);
+}
+
+struct ruby_context {
+    ruby_context()
+    {
+        ruby_init();
+        ruby_init_loadpath();
+
+        rb_encdb_declare("ASCII-8BIT");
+        rb_encdb_declare("US-ASCII");
+        rb_encdb_declare("UTF-8");
+        rb_encdb_alias("BINARY", "ASCII-8BIT");
+        rb_encdb_alias("ASCII", "US-ASCII");
+        rb_require("rubygems");
+        rb_require("json");
+        rb_require(LIBCOUCHBASE_EXT_PATH);
+    }
+
+    ~ruby_context()
+    {
+        ruby_cleanup(0);
+    }
+
+    std::optional<std::string> eval_script(test_context& ctx, const std::string& input)
+    {
+        int status = 0;
+        std::string script = input;
+        script = std::regex_replace(script, std::regex("CONNECTION_STRING"), '"' + ctx.connection_string + '"');
+        script = std::regex_replace(script, std::regex("USERNAME"), '"' + ctx.username + '"');
+        script = std::regex_replace(script, std::regex("PASSWORD"), '"' + ctx.password + '"');
+        script = std::regex_replace(script, std::regex("BUCKET"), '"' + ctx.bucket + '"');
+        rb_eval_string_protect(script.c_str(), &status);
+        if (status != 0) {
+            VALUE rbError = rb_funcall(rb_gv_get("$!"), rb_intern("message"), 0);
+            return std::string(StringValuePtr(rbError));
+        }
+        return {};
+    }
+};
+
+#define TEST_PREAMBLE_RUBY                                                                                                                 \
+    RUBY_INIT_STACK;                                                                                                                       \
+    ruby_context ruby{};

data/ext/test/test_native_diagnostics.cxx

@@ -0,0 +1,385 @@
+/* -*- 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.
+ */
+
+#include "test_helper_native.hxx"
+
+#include <diagnostics.hxx>
+
+using namespace std::literals::chrono_literals;
+
+TEST_CASE("native: serializing diagnostics report", "[native]")
+{
+    couchbase::diag::diagnostics_result res{
+        "0xdeadbeef",
+        "ruby/1.0.0",
+        {
+          {
+            {
+              couchbase::service_type::search,
+              {
+                {
+                  couchbase::service_type::search,
+                  "0x1415F11",
+                  1182000us,
+                  "centos7-lx1.home.ingenthron.org:8094",
+                  "127.0.0.1:54669",
+                  couchbase::diag::endpoint_state::connecting,
+                  std::nullopt,
+                  "RECONNECTING, backoff for 4096ms from Fri Sep  1 00:03:44 PDT 2017",
+                },
+              },
+            },
+            {
+              couchbase::service_type::kv,
+              {
+                {
+                  couchbase::service_type::kv,
+                  "0x1415F12",
+                  1182000us,
+                  "centos7-lx1.home.ingenthron.org:11210",
+                  "127.0.0.1:54670",
+                  couchbase::diag::endpoint_state::connected,
+                  "bucketname",
+                },
+              },
+            },
+            {
+              couchbase::service_type::query,
+              {
+                {
+                  couchbase::service_type::query,
+                  "0x1415F13",
+                  1182000us,
+                  "centos7-lx1.home.ingenthron.org:8093",
+                  "127.0.0.1:54671",
+                  couchbase::diag::endpoint_state::connected,
+                },
+                {
+                  couchbase::service_type::query,
+                  "0x1415F14",
+                  1182000us,
+                  "centos7-lx2.home.ingenthron.org:8095",
+                  "127.0.0.1:54682",
+                  couchbase::diag::endpoint_state::disconnected,
+                },
+              },
+            },
+            {
+              couchbase::service_type::analytics,
+              {
+                {
+                  couchbase::service_type::analytics,
+                  "0x1415F15",
+                  1182000us,
+                  "centos7-lx1.home.ingenthron.org:8095",
+                  "127.0.0.1:54675",
+                  couchbase::diag::endpoint_state::connected,
+                },
+              },
+            },
+            {
+              couchbase::service_type::views,
+              {
+                {
+                  couchbase::service_type::views,
+                  "0x1415F16",
+                  1182000us,
+                  "centos7-lx1.home.ingenthron.org:8092",
+                  "127.0.0.1:54672",
+                  couchbase::diag::endpoint_state::connected,
+                },
+              },
+            },
+          },
+        },
+    };
+
+    auto expected = tao::json::from_string(R"(
+{
+  "version": 2,
+  "id": "0xdeadbeef",
+  "sdk": "ruby/1.0.0",
+  "services": {
+    "kv": [
+      {
+        "id": "0x1415F12",
+        "last_activity_us": 1182000,
+        "remote": "centos7-lx1.home.ingenthron.org:11210",
+        "local": "127.0.0.1:54670",
+        "state": "connected",
+        "namespace": "bucketname"
+      }
+    ],
+    "search": [
+      {
+        "id": "0x1415F11",
+        "last_activity_us": 1182000,
+        "remote": "centos7-lx1.home.ingenthron.org:8094",
+        "local": "127.0.0.1:54669",
+        "state": "connecting",
+        "details": "RECONNECTING, backoff for 4096ms from Fri Sep  1 00:03:44 PDT 2017"
+      }
+    ],
+    "query": [
+      {
+        "id": "0x1415F13",
+        "last_activity_us": 1182000,
+        "remote": "centos7-lx1.home.ingenthron.org:8093",
+        "local": "127.0.0.1:54671",
+        "state": "connected"
+      },
+      {
+        "id": "0x1415F14",
+        "last_activity_us": 1182000,
+        "remote": "centos7-lx2.home.ingenthron.org:8095",
+        "local": "127.0.0.1:54682",
+        "state": "disconnected"
+      }
+    ],
+    "analytics": [
+      {
+        "id": "0x1415F15",
+        "last_activity_us": 1182000,
+        "remote": "centos7-lx1.home.ingenthron.org:8095",
+        "local": "127.0.0.1:54675",
+        "state": "connected"
+      }
+    ],
+    "views": [
+      {
+        "id": "0x1415F16",
+        "last_activity_us": 1182000,
+        "remote": "centos7-lx1.home.ingenthron.org:8092",
+        "local": "127.0.0.1:54672",
+        "state": "connected"
+      }
+    ]
+  }
+}
+)");
+    auto report = tao::json::value(res);
+    REQUIRE(report == expected);
+}
+
+TEST_CASE("native: serializing ping report", "[native]")
+{
+    auto ctx = test_context::load_from_environment();
+    native_init_logger();
+
+    couchbase::diag::ping_result res{
+        "0xdeadbeef",
+        "ruby/1.0.0",
+        53,
+        {
+          {
+            {
+              couchbase::service_type::search,
+              {
+                {
+                  couchbase::service_type::search,
+                  "0x1415F11",
+                  877909us,
+                  "centos7-lx1.home.ingenthron.org:8094",
+                  "127.0.0.1:54669",
+                  couchbase::diag::ping_state::ok,
+                },
+              },
+            },
+            {
+              couchbase::service_type::kv,
+              {
+                {
+                  couchbase::service_type::kv,
+                  "0x1415F12",
+                  1182000us,
+                  "centos7-lx1.home.ingenthron.org:11210",
+                  "127.0.0.1:54670",
+                  couchbase::diag::ping_state::ok,
+                  "bucketname",
+                },
+              },
+            },
+            {
+              couchbase::service_type::query,
+              {
+                {
+                  couchbase::service_type::query,
+                  "0x1415F14",
+                  2213us,
+                  "centos7-lx2.home.ingenthron.org:8095",
+                  "127.0.0.1:54682",
+                  couchbase::diag::ping_state::timeout,
+                },
+              },
+            },
+            {
+              couchbase::service_type::analytics,
+              {
+                {
+                  couchbase::service_type::analytics,
+                  "0x1415F15",
+                  2213us,
+                  "centos7-lx1.home.ingenthron.org:8095",
+                  "127.0.0.1:54675",
+                  couchbase::diag::ping_state::error,
+                  std::nullopt,
+                  "endpoint returned HTTP code 500!",
+                },
+              },
+            },
+            {
+              couchbase::service_type::views,
+              {
+                {
+                  couchbase::service_type::views,
+                  "0x1415F16",
+                  45585us,
+                  "centos7-lx1.home.ingenthron.org:8092",
+                  "127.0.0.1:54672",
+                  couchbase::diag::ping_state::ok,
+                },
+              },
+            },
+          },
+        },
+    };
+
+    auto expected = tao::json::from_string(R"(
+{
+  "version": 2,
+  "id": "0xdeadbeef",
+  "config_rev": 53,
+  "sdk": "ruby/1.0.0",
+  "services": {
+    "search": [
+      {
+        "id": "0x1415F11",
+        "latency_us": 877909,
+        "remote": "centos7-lx1.home.ingenthron.org:8094",
+        "local": "127.0.0.1:54669",
+        "state": "ok"
+      }
+    ],
+    "kv": [
+      {
+        "id": "0x1415F12",
+        "latency_us": 1182000,
+        "remote": "centos7-lx1.home.ingenthron.org:11210",
+        "local": "127.0.0.1:54670",
+        "state": "ok",
+        "namespace": "bucketname"
+      }
+    ],
+    "query": [
+      {
+        "id": "0x1415F14",
+        "latency_us": 2213,
+        "remote": "centos7-lx2.home.ingenthron.org:8095",
+        "local": "127.0.0.1:54682",
+        "state": "timeout"
+      }
+    ],
+    "analytics": [
+      {
+        "id": "0x1415F15",
+        "latency_us": 2213,
+        "remote": "centos7-lx1.home.ingenthron.org:8095",
+        "local": "127.0.0.1:54675",
+        "state": "error",
+        "error": "endpoint returned HTTP code 500!"
+      }
+    ],
+    "views": [
+      {
+        "id": "0x1415F16",
+        "latency_us": 45585,
+        "remote": "centos7-lx1.home.ingenthron.org:8092",
+        "local": "127.0.0.1:54672",
+        "state": "ok"
+      }
+    ]
+  }
+}
+)");
+    auto report = tao::json::value(res);
+    REQUIRE(report == expected);
+}
+
+TEST_CASE("native: fetch diagnostics after N1QL 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);
+    }
+    {
+        auto barrier = std::make_shared<std::promise<std::error_code>>();
+        auto f = barrier->get_future();
+        cluster.open_bucket(ctx.bucket, [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{ "SELECT 'hello, couchbase' AS greetings" };
+        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.ec.message());
+        REQUIRE_FALSE(resp.ec);
+        INFO("rows.size() =" << resp.payload.rows.size());
+        REQUIRE(resp.payload.rows.size() == 1);
+        INFO("row=" << resp.payload.rows[0]);
+        REQUIRE(resp.payload.rows[0] == R"({"greetings":"hello, couchbase"})");
+    }
+    {
+        auto barrier = std::make_shared<std::promise<couchbase::diag::diagnostics_result>>();
+        auto f = barrier->get_future();
+        cluster.diagnostics("my_report_id", [barrier](couchbase::diag::diagnostics_result resp) mutable { barrier->set_value(resp); });
+        auto res = f.get();
+        REQUIRE(res.id == "my_report_id");
+        REQUIRE(res.sdk.find("ruby/") == 0);
+        REQUIRE(res.services[couchbase::service_type::kv].size() > 1);
+        REQUIRE(res.services[couchbase::service_type::query].size() == 1);
+        REQUIRE(res.services[couchbase::service_type::query][0].state == couchbase::diag::endpoint_state::connected);
+    }
+    {
+        auto barrier = std::make_shared<std::promise<void>>();
+        auto f = barrier->get_future();
+        cluster.close([barrier]() { barrier->set_value(); });
+        f.get();
+    }
+
+    io_thread.join();
+}