couchbase 3.0.1 → 3.0.2

data/ext/couchbase/protocol/durability_level.hxx

@@ -22,9 +22,25 @@
 namespace couchbase::protocol
 {
 enum class durability_level : uint8_t {
+    /**
+     * no enhanced durability required for the mutation
+     */
     none = 0x00,
+
+    /**
+     * the mutation must be replicated to a majority of the Data Service nodes (that is, held in the memory allocated to the bucket)
+     */
     majority = 0x01,
+
+    /**
+     * The mutation must be replicated to a majority of the Data Service nodes. Additionally, it must be persisted (that is, written and
+     * synchronised to disk) on the node hosting the active partition (vBucket) for the data.
+     */
     majority_and_persist_to_active = 0x02,
+
+    /**
+     * The mutation must be persisted to a majority of the Data Service nodes. Accordingly, it will be written to disk on those nodes.
+     */
     persist_to_majority = 0x03,
 };
 

data/ext/couchbase/protocol/hello_feature.hxx

@@ -145,6 +145,11 @@ enum class hello_feature : uint16_t {
      * Does the server support the subdoc mutation flag create_as_deleted
      */
     subdoc_create_as_deleted = 0x17,
+
+    /**
+     * Does the server support using the virtual $document attributes in macro expansion ("${document.CAS}" etc)
+     */
+    subdoc_document_macro_support = 0x18,
 };
 
 constexpr inline bool
@@ -172,6 +177,7 @@ is_valid_hello_feature(uint16_t code)
         case hello_feature::tcp_delay:
         case hello_feature::tracing:
         case hello_feature::subdoc_create_as_deleted:
+        case hello_feature::subdoc_document_macro_support:
             return true;
     }
     return false;
@@ -249,6 +255,9 @@ struct fmt::formatter<couchbase::protocol::hello_feature> : formatter<string_vie
             case couchbase::protocol::hello_feature::subdoc_create_as_deleted:
                 name = "subdoc_create_as_deleted";
                 break;
+            case couchbase::protocol::hello_feature::subdoc_document_macro_support:
+                name = "subdoc_document_macro_support";
+                break;
         }
         return formatter<string_view>::format(name, ctx);
     }

data/ext/couchbase/protocol/unsigned_leb128.h

@@ -51,11 +51,11 @@ decode_unsigned_leb128(std::string_view buf, struct Leb128NoThrow)
 {
     T rv = static_cast<uint8_t>(buf[0]) & 0x7fULL;
     size_t end = 0;
-    if ((buf[0] & 0x80) == 0x80ULL) {
+    if ((static_cast<uint8_t>(buf[0]) & 0x80ULL) == 0x80ULL) {
         T shift = 7;
         // shift in the remaining data
         for (end = 1; end < buf.size(); end++) {
-            rv |= (buf[end] & 0x7fULL) << shift;
+            rv |= (static_cast<uint8_t>(buf[end]) & 0x7fULL) << shift;
             if ((static_cast<uint8_t>(buf[end]) & 0x80ULL) == 0) {
                 break; // no more
             }

data/ext/couchbase/service_type.hxx

@@ -27,7 +27,7 @@ enum class service_type {
     views,
     management,
 };
-}
+} // namespace couchbase
 
 template<>
 struct fmt::formatter<couchbase::service_type> : formatter<std::string_view> {

data/ext/couchbase/version.hxx

@@ -17,8 +17,22 @@
 
 #pragma once
 
-#define BACKEND_VERSION_MAJOR 1
-#define BACKEND_VERSION_MINOR 1
-#define BACKEND_VERSION_PATCH 0
-
 #include <build_version.hxx>
+
+#include <string>
+
+namespace couchbase
+{
+constexpr auto BACKEND_VERSION_MAJOR = 1;
+constexpr auto BACKEND_VERSION_MINOR = 2;
+constexpr auto BACKEND_VERSION_PATCH = 0;
+
+inline const std::string&
+sdk_id()
+{
+    static const std::string identifier{ std::string("ruby/") + std::to_string(BACKEND_VERSION_MAJOR) + "/" +
+                                         std::to_string(BACKEND_VERSION_MINOR) + "/" + std::to_string(BACKEND_VERSION_PATCH) + "/" +
+                                         BACKEND_GIT_REVISION };
+    return identifier;
+}
+} // namespace couchbase

data/ext/extconf.rb

@@ -15,13 +15,14 @@
 require "mkmf"
 require "tempfile"
 
-require_relative "../lib/couchbase/version"
+lib = File.expand_path("../lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "couchbase/version"
+
 SDK_VERSION = Couchbase::VERSION[:sdk]
 
 cmake = find_executable("cmake")
-if `#{cmake} --version`[/cmake version (\d+\.\d+)/, 1].to_f < 3.15
-  cmake = find_executable("cmake3")
-end
+cmake = find_executable("cmake3") if `#{cmake} --version`[/cmake version (\d+\.\d+)/, 1].to_f < 3.15
 abort "ERROR: CMake is required to build couchbase extension." unless cmake
 puts "-- #{`#{cmake} --version`.split("\n").first}"
 
@@ -64,7 +65,8 @@ FileUtils.mkdir_p(build_dir, verbose: true)
 Dir.chdir(build_dir) do
   puts "-- build #{build_type} extension #{SDK_VERSION} for ruby #{RUBY_VERSION}-#{RUBY_PATCHLEVEL}-#{RUBY_PLATFORM}"
   sys(cmake, *cmake_flags, project_path)
-  sys("make -j4 VERBOSE=1")
+  number_of_jobs = (ENV["CB_NUMBER_OF_JOBS"] || 4).to_s
+  sys(cmake, "--build", build_dir, "--parallel", number_of_jobs,  "--verbose")
 end
 extension_name = "libcouchbase.#{RbConfig::CONFIG['SOEXT'] || RbConfig::CONFIG['DLEXT']}"
 extension_path = File.expand_path(File.join(build_dir, extension_name))
@@ -77,9 +79,10 @@ ext_directory = File.expand_path(__dir__)
 create_makefile("libcouchbase")
 if ENV["CB_REMOVE_EXT_DIRECTORY"]
   puts "-- CB_REMOVE_EXT_DIRECTORY is set, remove #{ext_directory}"
+  exceptions = %w[. .. extconf.rb]
   Dir
     .glob("#{ext_directory}/*", File::FNM_DOTMATCH)
-    .reject { |path| %w[. .. extconf.rb].include?(File.basename(path)) || File.basename(path).start_with?(".gem") }
+    .reject { |path| exceptions.include?(File.basename(path)) || File.basename(path).start_with?(".gem") }
     .each do |entry|
     puts "-- remove #{entry}"
     FileUtils.rm_rf(entry, verbose: true)

data/ext/test/CMakeLists.txt

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

data/ext/test/test_helper.hxx

@@ -19,9 +19,9 @@
 
 #include <test_config.hxx>
 
-#include <string>
-#include <regex>
 #include <cstdlib>
+#include <regex>
+#include <string>
 
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
@@ -36,7 +36,7 @@ struct test_server_version {
     static test_server_version parse(const std::string& str)
     {
         std::regex version_regex(R"((\d+).(\d+).(\d+(-(\d+))?)?)");
-        std::smatch version_match;
+        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]);

data/ext/test/test_helper_native.hxx

@@ -19,12 +19,10 @@
 
 #include "test_helper.hxx"
 
-#include <build_config.hxx>
-
 #include <asio/version.hpp>
 
-#include <spdlog/spdlog.h>
 #include <spdlog/cfg/env.h>
+#include <spdlog/spdlog.h>
 
 #include <http_parser.h>
 
@@ -50,8 +48,7 @@ native_init_logger()
         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));
+            spdlog::cfg::helpers::load_levels(env_val);
         }
 
         initialized = true;

data/ext/test/test_native_binary_operations.cxx

@@ -0,0 +1,186 @@
+/* -*- 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"
+
+std::string
+uniq_id(const std::string& prefix)
+{
+    return fmt::format("{}_{}", prefix, std::chrono::steady_clock::now().time_since_epoch().count());
+}
+
+TEST_CASE("native: append", "[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::document_id id{ ctx.bucket, "_default._default", uniq_id("foo") };
+    {
+        couchbase::operations::upsert_request req{ id, "world" };
+        auto barrier = std::make_shared<std::promise<couchbase::operations::upsert_response>>();
+        auto f = barrier->get_future();
+        cluster.execute(req, [barrier](couchbase::operations::upsert_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        INFO(resp.ec.message());
+        REQUIRE_FALSE(resp.ec);
+        INFO("rc=" << resp.cas);
+        REQUIRE(resp.cas != 0);
+        INFO("seqno=" << resp.token.sequence_number);
+        REQUIRE(resp.token.sequence_number != 0);
+    }
+    {
+        couchbase::operations::append_request req{ id, "!" };
+        auto barrier = std::make_shared<std::promise<couchbase::operations::append_response>>();
+        auto f = barrier->get_future();
+        cluster.execute(req, [barrier](couchbase::operations::append_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        INFO(resp.ec.message());
+        REQUIRE_FALSE(resp.ec);
+        INFO("rc=" << resp.cas);
+        REQUIRE(resp.cas != 0);
+        INFO("seqno=" << resp.token.sequence_number);
+        REQUIRE(resp.token.sequence_number != 0);
+    }
+    {
+        couchbase::operations::get_request req{ id };
+        auto barrier = std::make_shared<std::promise<couchbase::operations::get_response>>();
+        auto f = barrier->get_future();
+        cluster.execute(req, [barrier](couchbase::operations::get_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        INFO(resp.ec.message());
+        REQUIRE_FALSE(resp.ec);
+        INFO("rc=" << resp.cas);
+        REQUIRE(resp.cas != 0);
+        INFO("value=" << resp.value);
+        REQUIRE(resp.value == "world!");
+    }
+    {
+        auto barrier = std::make_shared<std::promise<void>>();
+        auto f = barrier->get_future();
+        cluster.close([barrier]() { barrier->set_value(); });
+        f.get();
+    }
+
+    io_thread.join();
+}
+
+TEST_CASE("native: prepend", "[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::document_id id{ ctx.bucket, "_default._default", uniq_id("foo") };
+    {
+        couchbase::operations::upsert_request req{ id, "world" };
+        auto barrier = std::make_shared<std::promise<couchbase::operations::upsert_response>>();
+        auto f = barrier->get_future();
+        cluster.execute(req, [barrier](couchbase::operations::upsert_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        INFO(resp.ec.message());
+        REQUIRE_FALSE(resp.ec);
+        INFO("rc=" << resp.cas);
+        REQUIRE(resp.cas != 0);
+        INFO("seqno=" << resp.token.sequence_number);
+        REQUIRE(resp.token.sequence_number != 0);
+    }
+    {
+        couchbase::operations::prepend_request req{ id, "Hello, " };
+        auto barrier = std::make_shared<std::promise<couchbase::operations::prepend_response>>();
+        auto f = barrier->get_future();
+        cluster.execute(req, [barrier](couchbase::operations::prepend_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        INFO(resp.ec.message());
+        REQUIRE_FALSE(resp.ec);
+        INFO("rc=" << resp.cas);
+        REQUIRE(resp.cas != 0);
+        INFO("seqno=" << resp.token.sequence_number);
+        REQUIRE(resp.token.sequence_number != 0);
+    }
+    {
+        couchbase::operations::get_request req{ id };
+        auto barrier = std::make_shared<std::promise<couchbase::operations::get_response>>();
+        auto f = barrier->get_future();
+        cluster.execute(req, [barrier](couchbase::operations::get_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        INFO(resp.ec.message());
+        REQUIRE_FALSE(resp.ec);
+        INFO("rc=" << resp.cas);
+        REQUIRE(resp.cas != 0);
+        INFO("value=" << resp.value);
+        REQUIRE(resp.value == "Hello, world");
+    }
+    {
+        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/test/test_native_diagnostics.cxx

@@ -183,7 +183,6 @@ TEST_CASE("native: serializing ping report", "[native]")
     couchbase::diag::ping_result res{
         "0xdeadbeef",
         "ruby/1.0.0",
-        53,
         {
           {
             {
@@ -354,7 +353,7 @@ TEST_CASE("native: fetch diagnostics after N1QL query", "[native]")
         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); });
+        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);
@@ -366,7 +365,7 @@ TEST_CASE("native: fetch diagnostics after N1QL query", "[native]")
     {
         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); });
+        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);
@@ -383,3 +382,55 @@ TEST_CASE("native: fetch diagnostics after N1QL query", "[native]")
 
     io_thread.join();
 }
+
+TEST_CASE("native: ping", "[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);
+    }
+    {
+        auto barrier = std::make_shared<std::promise<couchbase::diag::ping_result>>();
+        auto f = barrier->get_future();
+        cluster.ping("my_report_id", {}, {}, [barrier](couchbase::diag::ping_result&& resp) mutable { barrier->set_value(resp); });
+        auto res = f.get();
+        REQUIRE(res.id == "my_report_id");
+        REQUIRE(res.sdk.find("ruby/") == 0);
+
+        auto report = tao::json::value(res);
+        spdlog::critical("XXX {}", tao::json::to_string(report));
+    }
+    {
+        auto barrier = std::make_shared<std::promise<void>>();
+        auto f = barrier->get_future();
+        cluster.close([barrier]() { barrier->set_value(); });
+        f.get();
+    }
+
+    io_thread.join();
+}