couchbase 3.0.0.alpha.5-universal-darwin-19 → 3.0.0.beta.1-universal-darwin-19

data/ext/couchbase/protocol/cmd_get_and_touch.hxx

@@ -79,7 +79,7 @@ class get_and_touch_request_body
 
   private:
     std::string key_;
-    std::uint32_t expiration_;
+    std::uint32_t expiry_;
     std::vector<std::uint8_t> extras_{};
 
   public:
@@ -92,9 +92,9 @@ class get_and_touch_request_body
         }
     }
 
-    void expiration(std::uint32_t seconds)
+    void expiry(std::uint32_t seconds)
     {
-        expiration_ = seconds;
+        expiry_ = seconds;
     }
 
     const std::string& key()
@@ -133,8 +133,8 @@ class get_and_touch_request_body
   private:
     void fill_extras()
     {
-        extras_.resize(sizeof(expiration_));
-        uint32_t field = htonl(expiration_);
+        extras_.resize(sizeof(expiry_));
+        uint32_t field = htonl(expiry_);
         memcpy(extras_.data(), &field, sizeof(field));
     }
 };

data/ext/couchbase/protocol/cmd_get_cluster_config.hxx

@@ -67,17 +67,12 @@ class get_cluster_config_response_body
                std::uint16_t key_size,
                std::uint8_t extras_size,
                const std::vector<uint8_t>& body,
-               const cmd_info& info)
+               const cmd_info&)
     {
         Expects(header[1] == static_cast<uint8_t>(opcode));
         if (status == protocol::status::success) {
             std::vector<uint8_t>::difference_type offset = framing_extras_size + key_size + extras_size;
             config_ = tao::json::from_string<deduplicate_keys>(std::string(body.begin() + offset, body.end())).as<configuration>();
-            for (auto& node : config_.nodes) {
-                if (node.this_node && node.hostname.empty()) {
-                    node.hostname = info.remote_endpoint.address().to_string();
-                }
-            }
             return true;
         }
         return false;

data/ext/couchbase/protocol/cmd_increment.hxx

@@ -85,7 +85,7 @@ class increment_request_body
     std::vector<std::uint8_t> framing_extras_{};
     std::uint64_t delta_{ 1 };
     std::uint64_t initial_value_{ 0 };
-    std::uint32_t expiration_{ 0 };
+    std::uint32_t expiry_{ 0 };
     std::vector<std::uint8_t> extras_{};
 
   public:
@@ -108,9 +108,9 @@ class increment_request_body
         initial_value_ = value;
     }
 
-    void expiration(std::uint32_t value)
+    void expiry(std::uint32_t value)
     {
-        expiration_ = value;
+        expiry_ = value;
     }
 
     void durability(protocol::durability_level level, std::optional<std::uint16_t> timeout)
@@ -167,7 +167,7 @@ class increment_request_body
   private:
     void fill_extras()
     {
-        extras_.resize(sizeof(delta_) + sizeof(initial_value_) + sizeof(expiration_));
+        extras_.resize(sizeof(delta_) + sizeof(initial_value_) + sizeof(expiry_));
         using offset_type = std::vector<uint8_t>::difference_type;
         offset_type offset = 0;
 
@@ -179,7 +179,7 @@ class increment_request_body
         memcpy(extras_.data() + offset, &num, sizeof(num));
         offset += static_cast<offset_type>(sizeof(delta_));
 
-        std::uint32_t ttl = htonl(expiration_);
+        std::uint32_t ttl = htonl(expiry_);
         memcpy(extras_.data() + offset, &ttl, sizeof(ttl));
     }
 };

data/ext/couchbase/protocol/cmd_info.hxx

@@ -20,17 +20,6 @@
 namespace couchbase::protocol
 {
 struct cmd_info {
-    asio::ip::tcp::endpoint local_endpoint{};
-    asio::ip::tcp::endpoint remote_endpoint{};
     double server_duration_us{ 0 };
-
-    template<class AsyncStream>
-    void extract_from_stream(AsyncStream& stream)
-    {
-        std::error_code err;
-        local_endpoint = stream.local_endpoint(err);
-        remote_endpoint = stream.remote_endpoint(err);
-        (void)err;
-    }
 };
 } // namespace couchbase::protocol

data/ext/couchbase/protocol/cmd_insert.hxx

@@ -78,7 +78,7 @@ class insert_request_body
     std::vector<std::uint8_t> extras_{};
     std::vector<std::uint8_t> content_{};
     std::uint32_t flags_{};
-    std::uint32_t expiration_{};
+    std::uint32_t expiry_{};
     std::vector<std::uint8_t> framing_extras_{};
 
   public:
@@ -120,9 +120,9 @@ class insert_request_body
         flags_ = flags;
     }
 
-    void expiration(uint32_t value)
+    void expiry(uint32_t value)
     {
-        expiration_ = value;
+        expiry_ = value;
     }
 
     const std::string& key()
@@ -159,12 +159,12 @@ class insert_request_body
   private:
     void fill_extention()
     {
-        extras_.resize(sizeof(flags_) + sizeof(expiration_));
+        extras_.resize(sizeof(flags_) + sizeof(expiry_));
 
         uint32_t field = htonl(flags_);
         memcpy(extras_.data(), &field, sizeof(field));
 
-        field = htonl(expiration_);
+        field = htonl(expiry_);
         memcpy(extras_.data() + sizeof(flags_), &field, sizeof(field));
     }
 };

data/ext/couchbase/protocol/cmd_mutate_in.hxx

@@ -208,7 +208,7 @@ class mutate_in_request_body
     std::vector<std::uint8_t> extras_{};
     std::vector<std::uint8_t> value_{};
 
-    std::uint32_t expiration_{ 0 };
+    std::uint32_t expiry_{ 0 };
     std::uint8_t flags_{ 0 };
     mutate_in_specs specs_;
     std::vector<std::uint8_t> framing_extras_{};
@@ -223,9 +223,9 @@ class mutate_in_request_body
         }
     }
 
-    void expiration(uint32_t value)
+    void expiry(uint32_t value)
     {
-        expiration_ = value;
+        expiry_ = value;
     }
 
     void access_deleted(bool value)
@@ -317,9 +317,9 @@ class mutate_in_request_body
   private:
     void fill_extention()
     {
-        if (expiration_ != 0) {
-            extras_.resize(sizeof(expiration_));
-            std::uint32_t field = htonl(expiration_);
+        if (expiry_ != 0) {
+            extras_.resize(sizeof(expiry_));
+            std::uint32_t field = htonl(expiry_);
             memcpy(extras_.data(), &field, sizeof(field));
         }
         if (flags_ != 0) {

data/ext/couchbase/protocol/cmd_replace.hxx

@@ -78,7 +78,7 @@ class replace_request_body
     std::vector<std::uint8_t> extras_{};
     std::vector<std::uint8_t> content_{};
     std::uint32_t flags_{};
-    std::uint32_t expiration_{};
+    std::uint32_t expiry_{};
     std::vector<std::uint8_t> framing_extras_{};
 
   public:
@@ -120,9 +120,9 @@ class replace_request_body
         flags_ = flags;
     }
 
-    void expiration(uint32_t value)
+    void expiry(uint32_t value)
     {
-        expiration_ = value;
+        expiry_ = value;
     }
 
     const std::string& key()
@@ -159,12 +159,12 @@ class replace_request_body
   private:
     void fill_extention()
     {
-        extras_.resize(sizeof(flags_) + sizeof(expiration_));
+        extras_.resize(sizeof(flags_) + sizeof(expiry_));
 
         uint32_t field = htonl(flags_);
         memcpy(extras_.data(), &field, sizeof(field));
 
-        field = htonl(expiration_);
+        field = htonl(expiry_);
         memcpy(extras_.data() + sizeof(flags_), &field, sizeof(field));
     }
 };

data/ext/couchbase/protocol/cmd_touch.hxx

@@ -64,7 +64,7 @@ class touch_request_body
         }
     }
 
-    void expiration(std::uint32_t seconds)
+    void expiry(std::uint32_t seconds)
     {
         extras_.resize(sizeof(seconds));
         seconds = htonl(seconds);

data/ext/couchbase/protocol/cmd_upsert.hxx

@@ -78,7 +78,7 @@ class upsert_request_body
     std::vector<std::uint8_t> extras_{};
     std::vector<std::uint8_t> content_{};
     std::uint32_t flags_{};
-    std::uint32_t expiration_{};
+    std::uint32_t expiry_{};
     std::vector<std::uint8_t> framing_extras_{};
 
   public:
@@ -120,9 +120,9 @@ class upsert_request_body
         flags_ = flags;
     }
 
-    void expiration(uint32_t value)
+    void expiry(uint32_t value)
     {
-        expiration_ = value;
+        expiry_ = value;
     }
 
     const std::string& key()
@@ -159,12 +159,12 @@ class upsert_request_body
   private:
     void fill_extention()
     {
-        extras_.resize(sizeof(flags_) + sizeof(expiration_));
+        extras_.resize(sizeof(flags_) + sizeof(expiry_));
 
         uint32_t field = htonl(flags_);
         memcpy(extras_.data(), &field, sizeof(field));
 
-        field = htonl(expiration_);
+        field = htonl(expiry_);
         memcpy(extras_.data() + sizeof(flags_), &field, sizeof(field));
     }
 };

data/ext/couchbase/timeout_defaults.hxx

@@ -21,6 +21,8 @@
 
 namespace couchbase::timeout_defaults
 {
+constexpr std::chrono::milliseconds bootstrap_timeout{ 10'000 };
+
 constexpr std::chrono::milliseconds connect_timeout{ 10'000 };
 constexpr std::chrono::milliseconds key_value_timeout{ 2'500 };
 constexpr std::chrono::milliseconds key_value_durable_timeout{ 10'000 };
@@ -31,4 +33,9 @@ constexpr std::chrono::milliseconds search_timeout{ 75'000 };
 constexpr std::chrono::milliseconds management_timeout{ 75'000 };
 
 constexpr std::chrono::milliseconds dns_srv_timeout{ 500 };
+constexpr std::chrono::milliseconds tcp_keep_alive_interval{ 60'000 };
+constexpr std::chrono::milliseconds config_poll_interval{ 2'500 };
+constexpr std::chrono::milliseconds config_poll_floor{ 50'000 };
+constexpr std::chrono::milliseconds config_idle_redial_timeout{ 5 * 60'000 };
+constexpr std::chrono::milliseconds idle_http_connection_timeout{ 4'500 };
 } // namespace couchbase::timeout_defaults

data/ext/couchbase/utils/connection_string.hxx

@@ -22,6 +22,8 @@
 #include <tao/json/external/pegtl.hpp>
 #include <tao/json/external/pegtl/contrib/uri.hpp>
 
+#include <cluster_options.hxx>
+
 namespace couchbase::utils
 {
 
@@ -48,6 +50,8 @@ struct connection_string {
     std::string scheme{};
     bool tls{ false };
     std::map<std::string, std::string> params{};
+    cluster_options options{};
+
     std::vector<node> bootstrap_nodes{};
 
     std::optional<std::string> default_bucket_name{};
@@ -200,6 +204,140 @@ struct action<bucket_name> {
 };
 } // namespace priv
 
+static void
+extract_options(connection_string& connstr)
+{
+    connstr.options.enable_tls = connstr.tls;
+    if (connstr.bootstrap_nodes.size() != 1 || connstr.bootstrap_nodes[0].type != connection_string::address_type::dns) {
+        connstr.options.enable_dns_srv = false;
+    }
+    for (const auto& param : connstr.params) {
+        try {
+            if (param.first == "kv_connect_timeout") {
+                /**
+                 * Number of seconds the client should wait while attempting to connect to a node’s KV service via a socket.  Initial
+                 * connection, reconnecting, node added, etc.
+                 */
+                connstr.options.connect_timeout = std::chrono::milliseconds(std::stoull(param.second));
+            } else if (param.first == "kv_timeout") {
+                /**
+                 * Number of milliseconds to wait before timing out a KV operation by the client.
+                 */
+                connstr.options.key_value_timeout = std::chrono::milliseconds(std::stoull(param.second));
+            } else if (param.first == "kv_durable_timeout") {
+                /**
+                 * Number of milliseconds to wait before timing out a KV operation that is either using synchronous durability or
+                 * observe-based durability.
+                 */
+                connstr.options.key_value_durable_timeout = std::chrono::milliseconds(std::stoull(param.second));
+            } else if (param.first == "view_timeout") {
+                /**
+                 * Number of seconds to wait before timing out a View request  by the client..
+                 */
+                connstr.options.view_timeout = std::chrono::milliseconds(std::stoull(param.second));
+            } else if (param.first == "query_timeout") {
+                /**
+                 * Number of seconds to wait before timing out a Query or N1QL request by the client.
+                 */
+                connstr.options.query_timeout = std::chrono::milliseconds(std::stoull(param.second));
+            } else if (param.first == "analytics_timeout") {
+                /**
+                 * Number of seconds to wait before timing out an Analytics request by the client.
+                 */
+                connstr.options.analytics_timeout = std::chrono::milliseconds(std::stoull(param.second));
+            } else if (param.first == "search_timeout") {
+                /**
+                 * Number of seconds to wait before timing out a Search request by the client.
+                 */
+                connstr.options.search_timeout = std::chrono::milliseconds(std::stoull(param.second));
+            } else if (param.first == "management_timeout") {
+                /**
+                 * Number of seconds to wait before timing out a Management API request by the client.
+                 */
+                connstr.options.management_timeout = std::chrono::milliseconds(std::stoull(param.second));
+            } else if (param.first == "trust_certificate") {
+                connstr.options.trust_certificate = param.second;
+            } else if (param.first == "enable_mutation_tokens") {
+                /**
+                 * Request mutation tokens at connection negotiation time. Turning this off will save 16 bytes per operation response.
+                 */
+                if (param.second == "true" || param.second == "yes" || param.second == "on") {
+                    connstr.options.enable_mutation_tokens = true;
+                } else if (param.second == "false" || param.second == "no" || param.second == "off") {
+                    connstr.options.enable_mutation_tokens = false;
+                }
+            } else if (param.first == "enable_tcp_keep_alive") {
+                /**
+                 * Gets or sets a value indicating whether enable TCP keep-alive.
+                 */
+                if (param.second == "true" || param.second == "yes" || param.second == "on") {
+                    connstr.options.enable_tcp_keep_alive = true;
+                } else if (param.second == "false" || param.second == "no" || param.second == "off") {
+                    connstr.options.enable_tcp_keep_alive = false;
+                }
+            } else if (param.first == "tcp_keep_alive_interval") {
+                /**
+                 * Specifies the timeout, in milliseconds, with no activity until the first keep-alive packet is sent. This applies to all
+                 * services, but is advisory: if the underlying platform does not support this on all connections, it will be applied only
+                 * on those it can be.
+                 */
+                connstr.options.tcp_keep_alive_interval = std::chrono::milliseconds(std::stoull(param.second));
+            } else if (param.first == "force_ipv4") {
+                /**
+                 * Sets the SDK configuration to do IPv4 Name Resolution
+                 */
+                if (param.second == "true" || param.second == "yes" || param.second == "on") {
+                    connstr.options.force_ipv4 = true;
+                } else if (param.second == "false" || param.second == "no" || param.second == "off") {
+                    connstr.options.force_ipv4 = false;
+                }
+            } else if (param.first == "config_poll_interval") {
+                connstr.options.config_poll_interval = std::chrono::milliseconds(std::stoull(param.second));
+            } else if (param.first == "config_poll_floor") {
+                connstr.options.config_poll_floor = std::chrono::milliseconds(std::stoull(param.second));
+            } else if (param.first == "max_http_connections") {
+                /**
+                 * The maximum number of HTTP connections allowed on a per-host and per-port basis.  0 indicates an unlimited number of
+                 * connections are permitted.
+                 */
+                connstr.options.max_http_connections = std::stoul(param.second);
+            } else if (param.first == "idle_http_connection_timeout") {
+                /**
+                 * The period of time an HTTP connection can be idle before it is forcefully disconnected.
+                 */
+                connstr.options.idle_http_connection_timeout = std::chrono::milliseconds(std::stoull(param.second));
+            } else if (param.first == "enable_dns_srv") {
+                if (connstr.bootstrap_nodes.size() == 1) {
+                    if (param.second == "true" || param.second == "yes" || param.second == "on") {
+                        connstr.options.enable_dns_srv = true;
+                    } else if (param.second == "false" || param.second == "no" || param.second == "off") {
+                        connstr.options.enable_dns_srv = false;
+                    }
+                } else {
+                    spdlog::warn(
+                      R"(parameter "{}" require single entry in bootstrap nodes list of the connection string, ignoring (value "{}"))",
+                      param.first,
+                      param.second);
+                }
+            } else if (param.first == "network") {
+                connstr.options.network = param.second; /* current known values are "auto", "default" and "external" */
+            } else {
+                spdlog::warn(R"(unknown parameter "{}" in connection string (value "{}"))", param.first, param.second);
+            }
+        } catch (std::invalid_argument& ex1) {
+            spdlog::warn(R"(unable to parse "{}" parameter in connection string (value "{}" cannot be converted): {})",
+                         param.first,
+                         param.second,
+                         ex1.what());
+        } catch (std::out_of_range& ex2) {
+            spdlog::warn(R"(unable to parse "{}" parameter in connection string (value "{}" is out of range): {})",
+                         param.first,
+                         param.second,
+                         ex2.what());
+        }
+    }
+}
+
 static connection_string
 parse_connection_string(const std::string& input)
 {
@@ -226,6 +364,7 @@ parse_connection_string(const std::string& input)
             res.error = e.what();
         }
     }
+    extract_options(res);
     return res;
 }
 } // namespace couchbase::utils

data/ext/extconf.rb

@@ -1,7 +1,9 @@
 require "mkmf"
-require "fileutils"
 require "tempfile"
 
+require_relative "../lib/couchbase/version"
+SDK_VERSION = Couchbase::VERSION[:sdk]
+
 unless find_executable("cmake")
   abort "ERROR: CMake is required to build couchbase extension."
 end
@@ -14,28 +16,40 @@ end
 
 
 build_type = ENV["DEBUG"] ? "Debug" : "RelWithDebInfo"
-cmake_flags = [
-  "-DCMAKE_BUILD_TYPE=#{build_type}",
-  "-DRUBY_HDR_DIR=#{RbConfig::CONFIG["rubyhdrdir"]}",
-  "-DRUBY_ARCH_HDR_DIR=#{RbConfig::CONFIG["rubyarchhdrdir"]}",
-  "-DTAOCPP_JSON_BUILD_TESTS=OFF",
-  "-DTAOCPP_JSON_BUILD_EXAMPLES=OFF",
-  "-DSNAPPY_BUILD_TESTS=OFF",
-  "-DSNAPPY_INSTALL=OFF",
+cmake_flags = %W[
+  -DCMAKE_BUILD_TYPE=#{build_type}
+  -DRUBY_HDR_DIR=#{RbConfig::CONFIG["rubyhdrdir"]}
+  -DRUBY_ARCH_HDR_DIR=#{RbConfig::CONFIG["rubyarchhdrdir"]}
+  -DTAOCPP_JSON_BUILD_TESTS=OFF
+  -DTAOCPP_JSON_BUILD_EXAMPLES=OFF
+  -DSNAPPY_BUILD_TESTS=OFF
+  -DSNAPPY_INSTALL=OFF
 ]
+
+if ENV["CB_CC"]
+  cmake_flags << "-DCMAKE_C_COMPILER=#{ENV["CB_CC"]}"
+end
+if ENV["CB_CXX"]
+  cmake_flags << "-DCMAKE_CXX_COMPILER=#{ENV["CB_CXX"]}"
+end
+if ENV["CB_STATIC"]
+  cmake_flags << "-DSTATIC_STDLIB=ON"
+end
+
 openssl_root = `brew --prefix openssl 2> /dev/null`.strip
 unless openssl_root.empty?
   cmake_flags << "-DOPENSSL_ROOT_DIR=#{openssl_root}"
 end
 
 project_path = File.expand_path(File.join(__dir__))
-build_dir = ENV['EXT_BUILD_DIR'] || File.join(Dir.tmpdir, "couchbase-rubygem-#{build_type}-#{RUBY_VERSION}-#{RUBY_PATCHLEVEL}-#{RUBY_PLATFORM}")
+build_dir = ENV['CB_EXT_BUILD_DIR'] || File.join(Dir.tmpdir, "cb-#{build_type}-#{RUBY_VERSION}-#{RUBY_PATCHLEVEL}-#{RUBY_PLATFORM}-#{SDK_VERSION}")
 FileUtils.mkdir_p(build_dir)
 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")
 end
-extension_name = "libcouchbase.#{RbConfig::CONFIG["SOEXT"]}"
+extension_name = "libcouchbase.#{RbConfig::CONFIG["SOEXT"] || RbConfig::CONFIG["DLEXT"]}"
 extension_path = File.expand_path(File.join(build_dir, extension_name))
 unless File.file?(extension_path)
   abort "ERROR: failed to build extension in #{extension_path}"
@@ -44,4 +58,23 @@ extension_name.gsub!(/\.dylib/, '.bundle')
 install_path = File.expand_path(File.join(__dir__, "..", "lib", "couchbase", extension_name))
 puts "-- copy extension to #{install_path}"
 FileUtils.cp(extension_path, install_path)
+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}"
+  Dir
+      .glob("#{ext_directory}/*", File::FNM_DOTMATCH)
+      .reject { |path| %w[. .. extconf.rb].include?(File.basename(path)) || File.basename(path).start_with?(".gem") }
+      .each do |entry|
+    puts "-- remove #{entry}"
+    FileUtils.rm_rf(entry)
+  end
+  File.truncate("#{ext_directory}/extconf.rb", 0)
+  puts "-- truncate #{ext_directory}/extconf.rb"
+  File.write("#{ext_directory}/Makefile", <<EOF)
+.PHONY: all clean install
+all:
+clean:
+install:
+EOF
+end