couchbase 3.4.0 → 3.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97dc31f5d538a882e27e0d837a7865798a5d50a3ba04f76592683a8300211b36
-  data.tar.gz: 9c6f2fea36ce5b5fcdaf26f93d18e5a8d1024dd9aa82024eb296b08587c14cf5
+  metadata.gz: 78899f9fd7614787a46a54ca185e869cc93a7714ff0a1ef4c38feef98d7d54be
+  data.tar.gz: f42e90dc0e70b2f690f9c4f7dffe3cd9675db7d8f9025bb5db315b6e59407199
 SHA512:
-  metadata.gz: 1c63fafd6e367c42f670dcc93d54c1a6e1ed47af28c349e22be3d2167fe9b734530146b3e03116b222813c202bfecbc14d0f1ad2d704bf82e8deda1ef6e39d8d
-  data.tar.gz: e0593d3d352f29054ee3be5c272c24c968f03960e845ff45cb67cfaaeb61c2e59828c6e03a4271d21200f5a3a84a234b101a25880b0ff32cb076b694d4d9f05c
+  metadata.gz: 804b0a4c05754a5349b19f4b06ee1017f62790e2f5f50696639d9cfc1b785d4f43d688cb05c325f5e10cb1e36fca1e4775c93f91cbf10ad600a5f4755a091a28
+  data.tar.gz: cbb64fe3e1c2f5925584032cd69bb626e87c9ff61c7735a570a7e291287874076e366e2282e15d432c18832b9853c749d806cab28aa65716dc91ab835910bd6b

data/README.md

@@ -23,7 +23,7 @@ The library has been tested with MRI 3.0, 3.1 and 3.2. Supported platforms are L
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "couchbase", "3.4.0"
+gem "couchbase", "3.4.2"
 ```
 
 And then execute:
@@ -139,7 +139,7 @@ Now the API reference is accessible using a web browser (where `VERSION` is the
 
 The gem is available as open source under the terms of the [Apache2 License](https://opensource.org/licenses/Apache-2.0).
 
-    Copyright 2011-2021 Couchbase, Inc.
+    Copyright 2011-Present Couchbase, Inc.
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.

data/ext/couchbase/CMakeLists.txt

@@ -255,6 +255,7 @@ set(couchbase_cxx_client_FILES
         core/utils/mutation_token.cxx
         core/utils/split_string.cxx
         core/utils/url_codec.cxx
+        core/impl/analytics.cxx
         core/impl/analytics_error_category.cxx
         core/impl/append.cxx
         core/impl/best_effort_retry_strategy.cxx
@@ -296,8 +297,6 @@ set(couchbase_cxx_client_FILES
         core/impl/retry_reason.cxx
         core/impl/search_error_category.cxx
         core/impl/streaming_json_lexter_error_category.cxx
-        core/impl/unlock.cxx
-        core/impl/watch_query_indexes.cxx
         core/impl/subdoc/array_add_unique.cxx
         core/impl/subdoc/array_append.cxx
         core/impl/subdoc/array_insert.cxx
@@ -317,9 +316,13 @@ set(couchbase_cxx_client_FILES
         core/impl/subdoc/upsert.cxx
         core/impl/touch.cxx
         core/impl/transaction_error_category.cxx
+        core/impl/transaction_get_result.cxx
         core/impl/transaction_op_error_category.cxx
+        core/impl/unlock.cxx
         core/impl/upsert.cxx
         core/impl/view_error_category.cxx
+        core/impl/watch_query_indexes.cxx
+        core/io/dns_client.cxx
         core/io/dns_config.cxx
         core/io/http_parser.cxx
         core/io/mcbp_message.cxx
@@ -398,7 +401,11 @@ if (WIN32)
 endif ()
 
 if (NOT COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL)
-    target_link_libraries(couchbase_cxx_client PUBLIC OpenSSL::SSL OpenSSL::Crypto)
+    if (TARGET PkgConfig::PKG_CONFIG_OPENSSL)
+        target_link_libraries(couchbase_cxx_client PUBLIC PkgConfig::PKG_CONFIG_OPENSSL)
+    else()
+        target_link_libraries(couchbase_cxx_client PUBLIC OpenSSL::SSL OpenSSL::Crypto)
+    endif()
 endif ()
 
 option(COUCHBASE_CXX_CLIENT_BUILD_TESTS "Build test programs" TRUE)

data/ext/couchbase/cmake/CompilerWarnings.cmake

@@ -67,8 +67,8 @@ function(set_project_warnings project_name)
       -Wuseless-cast # warn if you perform a cast to the same type
       -Wdeprecated-declarations # warn if [[deprecated]] elements being used
   )
-  set(CLANG_WARNINGS ${COMMON_WARNINGS}
-      -Wshadow # warn the user if a variable declaration shadows one from a parent context
+  set(CLANG_WARNINGS ${COMMON_WARNINGS} -Wshadow # warn the user if a variable declaration shadows one from a parent
+                                                 # context
   )
 
   if(MSVC)
@@ -76,9 +76,17 @@ function(set_project_warnings project_name)
   elseif(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
     set(PROJECT_WARNINGS ${CLANG_WARNINGS})
   elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-    if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12.0.0" AND NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "11.0.0"
+       AND NOT
+           CMAKE_BUILD_TYPE
+           STREQUAL
+           "Debug")
       # One of the occurrences: https://github.com/chriskohlhoff/asio/pull/1176
-      set(GCC_WARNINGS ${GCC_WARNINGS} -Wno-error=null-dereference -Wno-error=array-bounds)
+      set(GCC_WARNINGS
+          ${GCC_WARNINGS}
+          -Wno-error=null-dereference
+          -Wno-error=array-bounds
+          -Wno-error=stringop-overflow)
     endif()
     set(PROJECT_WARNINGS ${GCC_WARNINGS})
   else()

data/ext/couchbase/cmake/Documentation.cmake

@@ -11,11 +11,12 @@ if(DOXYGEN_FOUND AND DOT)
   file(
     GLOB_RECURSE
     COUCHBASE_CXX_CLIENT_PUBLIC_HEADERS
-    ${PROJECT_SOURCE_DIR}/couchbase/*.hxx
-    ${PROJECT_SOURCE_DIR}/docs/*.hxx)
+    ${PROJECT_SOURCE_DIR}/couchbase/**/*.hxx
+    ${PROJECT_SOURCE_DIR}/docs/*.hxx
+    ${PROJECT_SOURCE_DIR}/docs/*.md)
 
   set(DOXYGEN_INPUT_DIR ${PROJECT_SOURCE_DIR}/couchbase)
-  set(DOXYGEN_OUTPUT_DIR ${PROJECT_BINARY_DIR}/couchbase-cxx-client-${couchbase_cxx_client_VERSION})
+  set(DOXYGEN_OUTPUT_DIR ${PROJECT_BINARY_DIR}/couchbase-cxx-client-${COUCHBASE_CXX_CLIENT_SEMVER})
   set(DOXYGEN_INDEX_FILE ${DOXYGEN_OUTPUT_DIR}/html/index.html)
   set(DOXYGEN_CONFIG_TEMPLATE ${PROJECT_SOURCE_DIR}/docs/Doxyfile.in)
   set(DOXYGEN_CONFIG ${PROJECT_BINARY_DIR}/Doxyfile)

data/ext/couchbase/cmake/OpenSSL.cmake

@@ -14,11 +14,21 @@ else()
   if(NOT OPENSSL_ROOT_DIR)
     if(APPLE AND COUCHBASE_CXX_CLIENT_USE_HOMEBREW_TO_DETECT_OPENSSL)
       execute_process(
-        COMMAND brew --prefix openssl@1.1
+        COMMAND brew --prefix openssl
         OUTPUT_VARIABLE OPENSSL_ROOT_DIR
+        ERROR_VARIABLE HOMEBREW_STDERR
         ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
       if(OPENSSL_ROOT_DIR)
-        message(STATUS "Found OpenSSL prefix using homebrew: ${OPENSSL_ROOT_DIR}")
+        message(STATUS "Found OpenSSL prefix using Homebrew: ${OPENSSL_ROOT_DIR}")
+      else()
+        execute_process(
+          COMMAND brew --prefix openssl@1.1
+          OUTPUT_VARIABLE OPENSSL_ROOT_DIR
+          ERROR_VARIABLE HOMEBREW_STDERR
+          ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+        if(OPENSSL_ROOT_DIR)
+          message(STATUS "Found OpenSSL 1.1 prefix using Homebrew: ${OPENSSL_ROOT_DIR}")
+        endif()
       endif()
     endif()
     if(MSVC AND COUCHBASE_CXX_CLIENT_USE_SCOOP_TO_DETECT_OPENSSL)
@@ -32,11 +42,46 @@ else()
       endif()
     endif()
   endif()
-  include(FindOpenSSL)
-  if(OPENSSL_LIBRARIES AND OPENSSL_INCLUDE_DIR)
-    message(STATUS "OPENSSL_VERSION: ${OPENSSL_VERSION}")
-    message(STATUS "OPENSSL_INCLUDE_DIR: ${OPENSSL_INCLUDE_DIR}")
-    message(STATUS "OPENSSL_LIBRARIES: ${OPENSSL_LIBRARIES}")
+
+  find_package(OpenSSL 1.1)
+  if(OpenSSL_FOUND)
+    try_compile(
+      OPENSSL_USABLE ${CMAKE_CURRENT_BINARY_DIR}
+      ${CMAKE_CURRENT_SOURCE_DIR}/cmake/test_openssl.cxx
+      LINK_LIBRARIES OpenSSL::SSL CXX_STANDARD 17)
+    if( OPENSSL_USABLE)
+      message(STATUS "OPENSSL_VERSION: ${OPENSSL_VERSION}")
+      message(STATUS "OPENSSL_INCLUDE_DIR: ${OPENSSL_INCLUDE_DIR}")
+      message(STATUS "OPENSSL_LIBRARIES: ${OPENSSL_LIBRARIES}")
+    else()
+      if(UNIX)
+        message(
+          STATUS
+            "Cannot use OpenSSL ${OPENSSL_VERSION} at \"${OPENSSL_INCLUDE_DIR}\" and \"${OPENSSL_LIBRARIES}\". Will try to use from pkg-config."
+        )
+        find_package(PkgConfig REQUIRED)
+        pkg_check_modules(PKG_CONFIG_OPENSSL REQUIRED IMPORTED_TARGET GLOBAL openssl11)
+        if(PKG_CONFIG_OPENSSL_FOUND)
+          message(STATUS "PKG_CONFIG_OPENSSL_VERSION: ${PKG_CONFIG_OPENSSL_VERSION}")
+          message(STATUS "PKG_CONFIG_OPENSSL_INCLUDE_DIRS: ${PKG_CONFIG_OPENSSL_INCLUDE_DIRS}")
+          message(STATUS "PKG_CONFIG_OPENSSL_LIBRARIES: ${PKG_CONFIG_OPENSSL_LIBRARIES}")
+        else()
+          message(FATAL_ERROR "Cannot Find OpenSSL using pkg-config, find_package() returns unusable setup")
+        endif()
+      else()
+        message(FATAL_ERROR "OpenSSL discovered by find_package() returns unusable setup")
+      endif()
+    endif()
+  elseif(UNIX)
+    find_package(PkgConfig REQUIRED)
+    pkg_check_modules(PKG_CONFIG_OPENSSL REQUIRED IMPORTED_TARGET GLOBAL openssl11)
+    if(PKG_CONFIG_OPENSSL_FOUND)
+      message(STATUS "PKG_CONFIG_OPENSSL_VERSION: ${PKG_CONFIG_OPENSSL_VERSION}")
+      message(STATUS "PKG_CONFIG_OPENSSL_INCLUDE_DIRS: ${PKG_CONFIG_OPENSSL_INCLUDE_DIRS}")
+      message(STATUS "PKG_CONFIG_OPENSSL_LIBRARIES: ${PKG_CONFIG_OPENSSL_LIBRARIES}")
+    else()
+      message(FATAL_ERROR "Cannot Find OpenSSL using pkg-config")
+    endif()
   else()
     message(FATAL_ERROR "Cannot build Couchbase C++ SDK without OpenSSL")
   endif()

data/ext/couchbase/cmake/ThirdPartyDependencies.cmake

@@ -18,6 +18,10 @@ set(PEGTL_BUILD_TESTS OFF CACHE BOOL "" FORCE)
 set(PEGTL_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
 add_subdirectory(${PROJECT_SOURCE_DIR}/third_party/snappy)
 set_target_properties(snappy PROPERTIES POSITION_INDEPENDENT_CODE ON)
+if(NOT MSVC)
+  # https://github.com/google/snappy/pull/156
+  target_compile_options(snappy PRIVATE -Wno-sign-compare)
+endif()
 
 set(HDR_LOG_REQUIRED OFF CACHE BOOL "" FORCE)
 set(HDR_HISTOGRAM_BUILD_SHARED OFF CACHE BOOL "" FORCE)

data/ext/couchbase/cmake/VersionInfo.cmake

@@ -25,6 +25,37 @@ if(NOT COUCHBASE_CXX_CLIENT_GIT_DESCRIBE)
 endif()
 
 string(TIMESTAMP COUCHBASE_CXX_CLIENT_BUILD_TIMESTAMP "%Y-%m-%d %H:%M:%S" UTC)
+string(TIMESTAMP COUCHBASE_CXX_CLIENT_BUILD_DATE "%Y-%m-%d" UTC)
+
+# set(couchbase_cxx_client_BUILD_NUMBER 142)
+# set(COUCHBASE_CXX_CLIENT_GIT_DESCRIBE "1.0.0-beta.4-27-g6807da0") #-> "couchbase_cxx_client-1.0.0-beta.4+142.27.6807da0"
+# set(COUCHBASE_CXX_CLIENT_GIT_DESCRIBE "1.0.0-beta.4-0-g6807da0")  #-> "couchbase_cxx_client-1.0.0-beta.4"
+# set(COUCHBASE_CXX_CLIENT_GIT_DESCRIBE "1.0.0-27-g6807da0")        #-> "couchbase_cxx_client-1.0.0+142.27.6807da0"
+# set(COUCHBASE_CXX_CLIENT_GIT_DESCRIBE "1.0.0-0-g6807da0")         #-> "couchbase_cxx_client-1.0.0"
+# set(COUCHBASE_CXX_CLIENT_GIT_DESCRIBE "1.0.0")                    #-> "couchbase_cxx_client-1.0.0"
+set(COUCHBASE_CXX_CLIENT_SEMVER "${couchbase_cxx_client_VERSION}")
+set(COUCHBASE_CXX_CLIENT_PACKAGE_VERSION "${couchbase_cxx_client_VERSION}")
+set(COUCHBASE_CXX_CLIENT_PACKAGE_RELEASE "${couchbase_cxx_client_BUILD_NUMBER}")
+if(COUCHBASE_CXX_CLIENT_GIT_DESCRIBE MATCHES
+   "^([0-9]+\\.[0-9]+\\.[0-9]+)(-([a-zA-Z0-9\\.]+))?(-([0-9]+)-g([a-zA-Z0-9]+))?$")
+  set(COUCHBASE_CXX_CLIENT_SEMVER "${CMAKE_MATCH_1}")
+  set(COUCHBASE_CXX_CLIENT_PACKAGE_VERSION "${CMAKE_MATCH_1}")
+  if(CMAKE_MATCH_3) # pre-release
+    set(COUCHBASE_CXX_CLIENT_SEMVER "${COUCHBASE_CXX_CLIENT_SEMVER}-${CMAKE_MATCH_3}")
+    set(COUCHBASE_CXX_CLIENT_PACKAGE_RELEASE "${CMAKE_MATCH_3}.${couchbase_cxx_client_BUILD_NUMBER}")
+  endif()
+  if(CMAKE_MATCH_5 AND CMAKE_MATCH_5 GREATER 0) # number_of_commits.build_number.sha1
+    set(COUCHBASE_CXX_CLIENT_SEMVER
+        "${COUCHBASE_CXX_CLIENT_SEMVER}+${CMAKE_MATCH_5}.${couchbase_cxx_client_BUILD_NUMBER}.${CMAKE_MATCH_6}")
+    if(CMAKE_MATCH_3) # pre-release
+      set(COUCHBASE_CXX_CLIENT_PACKAGE_RELEASE
+          "${CMAKE_MATCH_3}.${CMAKE_MATCH_5}.${couchbase_cxx_client_BUILD_NUMBER}.${CMAKE_MATCH_6}")
+    else()
+      set(COUCHBASE_CXX_CLIENT_PACKAGE_RELEASE "${CMAKE_MATCH_5}.${couchbase_cxx_client_BUILD_NUMBER}.${CMAKE_MATCH_6}")
+    endif()
+  endif()
+endif()
+
 configure_file(${PROJECT_SOURCE_DIR}/cmake/build_version.hxx.in
                ${PROJECT_BINARY_DIR}/generated/couchbase/build_version.hxx @ONLY)
 configure_file(${PROJECT_SOURCE_DIR}/cmake/build_config.hxx.in
@@ -47,9 +78,14 @@ file(
 #define COUCHBASE_CXX_CLIENT_LINK_OPTIONS \"$<TARGET_PROPERTY:couchbase_cxx_client,LINK_OPTIONS>\"
 #define COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL \"${COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL}\"
 
-#define OPENSSL_CRYPTO_LIBRARIES \"${OPENSSL_CRYPTO_LIBRARIES}\"
-#define OPENSSL_SSL_LIBRARIES \"${OPENSSL_SSL_LIBRARIES}\"
-#define OPENSSL_INCLUDE_DIR \"${OPENSSL_INCLUDE_DIR}\"
+#define OPENSSL_SSL_IMPORTED_LOCATION \"$<$<TARGET_EXISTS:OpenSSL::SSL>:$<TARGET_PROPERTY:OpenSSL::SSL,IMPORTED_LOCATION>>\"
+#define OPENSSL_SSL_INTERFACE_INCLUDE_DIRECTORIES \"$<$<TARGET_EXISTS:OpenSSL::SSL>:$<TARGET_PROPERTY:OpenSSL::SSL,INTERFACE_INCLUDE_DIRECTORIES>>\"
+#define OPENSSL_SSL_INTERFACE_LINK_LIBRARIES \"$<$<TARGET_EXISTS:OpenSSL::SSL>:$<TARGET_PROPERTY:OpenSSL::SSL,INTERFACE_LINK_LIBRARIES>>\"
+#define OPENSSL_CRYPTO_IMPORTED_LOCATION \"$<$<TARGET_EXISTS:OpenSSL::Crypto>:$<TARGET_PROPERTY:OpenSSL::Crypto,IMPORTED_LOCATION>>\"
+#define OPENSSL_CRYPTO_INTERFACE_INCLUDE_DIRECTORIES \"$<$<TARGET_EXISTS:OpenSSL::Crypto>:$<TARGET_PROPERTY:OpenSSL::Crypto,INTERFACE_INCLUDE_DIRECTORIES>>\"
+#define OPENSSL_CRYPTO_INTERFACE_LINK_LIBRARIES \"$<$<TARGET_EXISTS:OpenSSL::Crypto>:$<TARGET_PROPERTY:OpenSSL::Crypto,INTERFACE_LINK_LIBRARIES>>\"
+#define OPENSSL_PKG_CONFIG_INTERFACE_INCLUDE_DIRECTORIES \"$<$<TARGET_EXISTS:PkgConfig::PKG_CONFIG_OPENSSL>:$<TARGET_PROPERTY:PkgConfig::PKG_CONFIG_OPENSSL,INTERFACE_INCLUDE_DIRECTORIES>>\"
+#define OPENSSL_PKG_CONFIG_INTERFACE_LINK_LIBRARIES \"$<$<TARGET_EXISTS:PkgConfig::PKG_CONFIG_OPENSSL>:$<TARGET_PROPERTY:PkgConfig::PKG_CONFIG_OPENSSL,INTERFACE_LINK_LIBRARIES>>\"
 
 #define CMAKE_BUILD_TYPE \"${CMAKE_BUILD_TYPE}\"
 #define CMAKE_VERSION \"${CMAKE_VERSION}\"

data/ext/couchbase/cmake/test_openssl.cxx

@@ -0,0 +1,7 @@
+#include <openssl/crypto.h>
+
+int
+main()
+{
+    return static_cast<int>(OpenSSL_version_num());
+}

data/ext/couchbase/core/cluster_options.hxx

@@ -53,7 +53,6 @@ struct cluster_options {
     std::chrono::milliseconds analytics_timeout = timeout_defaults::analytics_timeout;
     std::chrono::milliseconds search_timeout = timeout_defaults::search_timeout;
     std::chrono::milliseconds management_timeout = timeout_defaults::management_timeout;
-    std::chrono::milliseconds dns_srv_timeout = timeout_defaults::dns_srv_timeout;
 
     bool enable_tls{ false };
     std::string trust_certificate{};

data/ext/couchbase/core/config_profile.cxx

@@ -22,4 +22,26 @@ couchbase::core::known_profiles()
 {
     static couchbase::core::config_profiles profiles{};
     return profiles;
-}
+}
+
+void
+couchbase::core::development_profile::apply(couchbase::core::cluster_options& opts)
+{
+    opts.key_value_timeout = std::chrono::seconds(20);
+    opts.key_value_durable_timeout = std::chrono::seconds(20);
+    opts.connect_timeout = std::chrono::seconds(20);
+    opts.view_timeout = std::chrono::minutes(2);
+    opts.query_timeout = std::chrono::minutes(2);
+    opts.analytics_timeout = std::chrono::minutes(2);
+    opts.search_timeout = std::chrono::minutes(2);
+    opts.management_timeout = std::chrono::minutes(2);
+
+    // C++SDK specific
+    opts.dns_config = couchbase::core::io::dns::dns_config{
+        opts.dns_config.nameserver(),
+        opts.dns_config.port(),
+        std::chrono::seconds(20), // timeout to make DNS-SRV query
+    };
+    opts.resolve_timeout = std::chrono::seconds(20);  // timeout to resolve hostnames
+    opts.bootstrap_timeout = std::chrono::minutes(2); // overall timeout to bootstrap
+}

data/ext/couchbase/core/config_profile.hxx

@@ -36,17 +36,7 @@ class config_profile
 class development_profile : public config_profile
 {
   public:
-    void apply(couchbase::core::cluster_options& opts) override
-    {
-        opts.key_value_timeout = std::chrono::milliseconds(20000); // 20 sec kv timeout.
-        opts.key_value_durable_timeout = std::chrono::milliseconds(20000); // 20 sec durable kv timeout.
-        opts.connect_timeout = std::chrono::milliseconds(20000);           // 20 sec connect timeout.
-        opts.view_timeout = std::chrono::milliseconds(120000);             // 2 minute view timeout
-        opts.query_timeout = std::chrono::milliseconds(120000);            // 2 minute query timeout
-        opts.analytics_timeout = std::chrono::milliseconds(120000);        // 2 minute analytics timeout
-        opts.search_timeout = std::chrono::milliseconds(120000);           // 2 minute search timeout
-        opts.management_timeout = std::chrono::milliseconds(120000);       // 2 minute management timeout
-    }
+    void apply(couchbase::core::cluster_options& opts) override;
 };
 
 // this class just registers the known profiles defined above, and allows access to them.
@@ -89,4 +79,4 @@ class config_profiles
 config_profiles&
 known_profiles();
 
-} // namespace couchbase::core
+} // namespace couchbase::core

data/ext/couchbase/core/crypto/CMakeLists.txt

@@ -4,7 +4,11 @@ target_link_libraries(couchbase_crypto PRIVATE project_options project_warnings)
 target_include_directories(couchbase_crypto PRIVATE ../..)
 
 if(NOT COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL)
-  target_link_libraries(couchbase_crypto PUBLIC OpenSSL::SSL OpenSSL::Crypto)
+  if (TARGET PkgConfig::PKG_CONFIG_OPENSSL)
+    target_link_libraries(couchbase_crypto PUBLIC PkgConfig::PKG_CONFIG_OPENSSL)
+  else()
+    target_link_libraries(couchbase_crypto PUBLIC OpenSSL::SSL OpenSSL::Crypto)
+  endif()
 endif()
 
 if(WIN32)

data/ext/couchbase/core/impl/analytics.cxx

@@ -0,0 +1,236 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-Present 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 <couchbase/cluster.hxx>
+#include <couchbase/error_codes.hxx>
+
+#include "core/cluster.hxx"
+#include "core/operations/document_analytics.hxx"
+
+namespace couchbase
+{
+static analytics_error_context
+build_context(core::operations::analytics_response& resp)
+{
+    return {
+        resp.ctx.ec,
+        resp.ctx.last_dispatched_to,
+        resp.ctx.last_dispatched_from,
+        resp.ctx.retry_attempts,
+        std::move(resp.ctx.retry_reasons),
+        resp.ctx.first_error_code,
+        std::move(resp.ctx.first_error_message),
+        std::move(resp.ctx.client_context_id),
+        std::move(resp.ctx.statement),
+        std::move(resp.ctx.parameters),
+        std::move(resp.ctx.method),
+        std::move(resp.ctx.path),
+        resp.ctx.http_status,
+        std::move(resp.ctx.http_body),
+        std::move(resp.ctx.hostname),
+        resp.ctx.port,
+    };
+}
+
+static analytics_status
+map_status(core::operations::analytics_response::analytics_status status)
+{
+    switch (status) {
+        case core::operations::analytics_response::running:
+            return analytics_status::running;
+        case core::operations::analytics_response::success:
+            return analytics_status::success;
+        case core::operations::analytics_response::errors:
+            return analytics_status::errors;
+        case core::operations::analytics_response::completed:
+            return analytics_status::completed;
+        case core::operations::analytics_response::stopped:
+            return analytics_status::stopped;
+        case core::operations::analytics_response::timedout:
+            return analytics_status::timeout;
+        case core::operations::analytics_response::closed:
+            return analytics_status::closed;
+        case core::operations::analytics_response::fatal:
+            return analytics_status::fatal;
+        case core::operations::analytics_response::aborted:
+            return analytics_status::aborted;
+        case core::operations::analytics_response::unknown:
+            return analytics_status::unknown;
+    }
+    return analytics_status::unknown;
+}
+
+static std::optional<couchbase::core::analytics_scan_consistency>
+map_scan_consistency(std::optional<couchbase::analytics_scan_consistency> consistency)
+{
+    if (consistency.has_value()) {
+        switch (consistency.value()) {
+            case analytics_scan_consistency::not_bounded:
+                return couchbase::core::analytics_scan_consistency::not_bounded;
+            case analytics_scan_consistency::request_plus:
+                return couchbase::core::analytics_scan_consistency::request_plus;
+        }
+    }
+    return {};
+}
+
+static std::vector<codec::binary>
+map_rows(const core::operations::analytics_response& resp)
+{
+    std::vector<codec::binary> rows;
+    rows.reserve(resp.rows.size());
+    for (const auto& row : resp.rows) {
+        rows.emplace_back(core::utils::to_binary(row));
+    }
+    return rows;
+}
+
+static std::vector<analytics_warning>
+map_warnings(core::operations::analytics_response& resp)
+{
+    if (resp.meta.warnings.empty()) {
+        return {};
+    }
+    std::vector<analytics_warning> warnings;
+    warnings.reserve(resp.meta.warnings.size());
+    for (auto& warning : resp.meta.warnings) {
+        warnings.emplace_back(warning.code, std::move(warning.message));
+    }
+    return warnings;
+}
+
+static analytics_metrics
+map_metrics(const core::operations::analytics_response& resp)
+{
+    return analytics_metrics{
+        resp.meta.metrics.elapsed_time,  resp.meta.metrics.execution_time,    resp.meta.metrics.result_count,
+        resp.meta.metrics.result_size,   resp.meta.metrics.processed_objects, resp.meta.metrics.error_count,
+        resp.meta.metrics.warning_count,
+    };
+}
+
+static std::optional<std::vector<std::byte>>
+map_signature(core::operations::analytics_response& resp)
+{
+    if (!resp.meta.signature) {
+        return {};
+    }
+    return core::utils::to_binary(resp.meta.signature.value());
+}
+
+static analytics_result
+build_result(core::operations::analytics_response& resp)
+{
+    return {
+        analytics_meta_data{
+          std::move(resp.meta.request_id),
+          std::move(resp.meta.client_context_id),
+          map_status(resp.meta.status),
+          map_warnings(resp),
+          map_metrics(resp),
+          map_signature(resp),
+        },
+        map_rows(resp),
+    };
+}
+
+static core::operations::analytics_request
+build_analytics_request(std::string statement,
+                        analytics_options::built options,
+                        std::optional<std::string> bucket_name,
+                        std::optional<std::string> scope_name)
+{
+    core::operations::analytics_request request{
+        std::move(statement),
+        options.readonly,
+        options.priority,
+        std::move(bucket_name),
+        std::move(scope_name),
+        {},
+        map_scan_consistency(options.scan_consistency),
+        {},
+        {},
+        {},
+        {},
+        std::move(options.client_context_id),
+        options.timeout,
+    };
+    if (!options.raw.empty()) {
+        for (auto& [name, value] : options.raw) {
+            request.raw[name] = std::move(value);
+        }
+    }
+    if (!options.positional_parameters.empty()) {
+        for (auto& value : options.positional_parameters) {
+            request.positional_parameters.emplace_back(std::move(value));
+        }
+    }
+    if (!options.named_parameters.empty()) {
+        for (auto& [name, value] : options.named_parameters) {
+            request.named_parameters[name] = std::move(value);
+        }
+    }
+    return request;
+}
+
+void
+cluster::analytics_query(std::string statement, const analytics_options& options, analytics_handler&& handler) const
+{
+    auto request = build_analytics_request(std::move(statement), options.build(), {}, {});
+
+    core_->execute(std::move(request), [handler = std::move(handler)](core::operations::analytics_response resp) mutable {
+        auto r = std::move(resp);
+        return handler(build_context(r), build_result(r));
+    });
+}
+
+auto
+cluster::analytics_query(std::string statement, const analytics_options& options) const
+  -> std::future<std::pair<analytics_error_context, analytics_result>>
+{
+    auto barrier = std::make_shared<std::promise<std::pair<analytics_error_context, analytics_result>>>();
+    auto future = barrier->get_future();
+    analytics_query(std::move(statement), options, [barrier](auto ctx, auto result) {
+        barrier->set_value({ std::move(ctx), std::move(result) });
+    });
+    return future;
+}
+
+void
+scope::analytics_query(std::string statement, const analytics_options& options, analytics_handler&& handler) const
+{
+    auto request = build_analytics_request(std::move(statement), options.build(), bucket_name_, name_);
+
+    core_->execute(std::move(request), [handler = std::move(handler)](core::operations::analytics_response resp) mutable {
+        auto r = std::move(resp);
+        return handler(build_context(r), build_result(r));
+    });
+}
+
+auto
+scope::analytics_query(std::string statement, const analytics_options& options) const
+  -> std::future<std::pair<analytics_error_context, analytics_result>>
+{
+    auto barrier = std::make_shared<std::promise<std::pair<analytics_error_context, analytics_result>>>();
+    auto future = barrier->get_future();
+    analytics_query(std::move(statement), options, [barrier](auto ctx, auto result) {
+        barrier->set_value({ std::move(ctx), std::move(result) });
+    });
+    return future;
+}
+
+} // namespace couchbase

data/ext/couchbase/core/impl/cluster.cxx

@@ -95,7 +95,6 @@ options_to_origin(const std::string& connection_string, const couchbase::cluster
     if (opts.dns.nameserver) {
         user_options.dns_config =
           io::dns::dns_config(opts.dns.nameserver.value(), opts.dns.port.value_or(io::dns::dns_config::default_port), opts.dns.timeout);
-        user_options.dns_srv_timeout = opts.dns.timeout;
     }
     user_options.enable_clustermap_notification = opts.behavior.enable_clustermap_notification;
     user_options.show_queries = opts.behavior.show_queries;

data/ext/couchbase/core/impl/collection_query_index_manager.cxx

@@ -22,14 +22,14 @@ namespace couchbase
 {
 
 void
-collection_query_index_manager::get_all_indexes(const get_all_query_indexes_options& options, get_all_indexes_handler&& handler) const
+collection_query_index_manager::get_all_indexes(const get_all_query_indexes_options& options, get_all_query_indexes_handler&& handler) const
 {
     return core::impl::initiate_get_all_query_indexes(core_,
                                                       "",
                                                       options.build(),
                                                       core::query_context(bucket_name_, scope_name_),
                                                       collection_name_,
-                                                      std::forward<get_all_indexes_handler>(handler));
+                                                      std::forward<get_all_query_indexes_handler>(handler));
 }
 
 void
@@ -90,4 +90,4 @@ collection_query_index_manager::watch_indexes(std::vector<std::string> index_nam
     return core::impl::initiate_watch_query_indexes(
       core_, "", std::move(index_names), options.build(), { bucket_name_, scope_name_ }, collection_name_, std::move(handler));
 }
-} // namespace couchbase
+} // namespace couchbase

data/ext/couchbase/core/impl/dns_srv_tracker.cxx

@@ -16,11 +16,13 @@
  */
 
 #include "dns_srv_tracker.hxx"
-#include "../logger/logger.hxx"
-#include "../topology/configuration.hxx"
+
+#include "core/logger/logger.hxx"
+#include "core/utils/join_strings.hxx"
 
 #include <asio/bind_executor.hpp>
 #include <asio/io_context.hpp>
+#include <asio/post.hpp>
 
 #include <memory>
 
@@ -44,7 +46,7 @@ dns_srv_tracker::get_srv_nodes(utils::movable_function<void(origin::node_list, s
       address_,
       service_,
       config_,
-      [self = shared_from_this(), callback = std::move(callback)](couchbase::core::io::dns::dns_client::dns_srv_response&& resp) mutable {
+      [self = shared_from_this(), callback = std::move(callback)](couchbase::core::io::dns::dns_srv_response&& resp) mutable {
           origin::node_list nodes;
           if (resp.ec) {
               CB_LOG_WARNING("failed to fetch DNS SRV records for \"{}\" ({}), assuming that cluster is listening this address",