couchbase 3.1.0 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6610fe0ac9f660835b0bfaf36f53673e35213f29440ceda426bfb6f488195b95
-  data.tar.gz: 734c1253fae466f3698046cf37d532f4ec754d2ed35d7d5c37c48539a59ce9ee
+  metadata.gz: ac08a1f11e2a448331f8d900fdf83f919860e4dfb58e82446ad195e900fbc55f
+  data.tar.gz: 54ee4c666ad5d25ac1c859c87a6dedb4751782ec91ff31ad6d9e35c54b27539b
 SHA512:
-  metadata.gz: d8ef7b9f1c6f417b4e803f12b64682980dcc9f69c8ebfc462b72dbeb60e306ee6a33176ca320cd85bd9974ff5b457d51e26ebf7dfbe2251bb6bbfd1a92b12077
-  data.tar.gz: 8ce0c1aab3a6f48295bf5a312a4bda8bc6668b3de079b60c4549bb8c1e27662eac49284c218928d5ffb60b7af799a01cdab736ae8d484eebc17e1b23b360aa8f
+  metadata.gz: 5d4ff24a9812790153298add2dcbd4b0ba53a1faa92d1c893379ca524b39a153ee2b66a5f519d3df660a7146941b6854b1bfe461c9c413659a5a56df0df300d2
+  data.tar.gz: fe0431eb1a6b433035c9d947106d504ee44c788c29f0350368a2b9c53119c2fa3148bd7796094fff277dcfe42df3220f7bb6b49e70cdd11b09f9e1ef9409ba28

data/README.md

@@ -11,7 +11,7 @@ This repository contains the third generation of the official Couchbase SDK for
 ## Support and Feedback
 
 If you find an issue, please file it in [our JIRA issue tracker](https://couchbase.com/issues/browse/RCBC). Also you are
-always welcome on [our forum](https://forums.couchbase.com/c/ruby-sdk).
+always welcome on [our forum](https://forums.couchbase.com/c/ruby-sdk) and [Discord](https://discord.com/invite/sQ5qbPZuTh).
 
 Please attach version information to ticket/post. To obtain this information use the following command:
 
@@ -19,12 +19,12 @@ Please attach version information to ticket/post. To obtain this information use
 
 ## Installation
 
-The library tested with the MRI 2.5, 2.6, 2.7 and 3.0. Supported platforms are Linux and MacOS.
+The library tested with the MRI 2.6, 2.7 and 3.0. Supported platforms are Linux and MacOS.
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "couchbase", "3.1.0"
+gem "couchbase", "3.3.0"
 ```
 
 And then execute:

data/ext/CMakeLists.txt

@@ -1,132 +1,66 @@
-cmake_minimum_required(VERSION 3.15)
-project(ruby_client LANGUAGES CXX C)
-include(cmake/PreventInSourceBuilds.cmake)
-include(cmake/StandardProjectSettings.cmake)
+cmake_minimum_required(VERSION 3.20)
+project(ruby_client LANGUAGES CXX)
 
-# 'library' to set the c++ standard / compile-time options requested
-add_library(project_options INTERFACE)
-target_compile_features(project_options INTERFACE cxx_std_17)
-if(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
-  target_compile_options(project_options INTERFACE -fdeclspec)
-endif()
-
-# 'library' to use the warnings specified in CompilerWarnings.cmake
-add_library(project_warnings INTERFACE)
-
-include(cmake/BuildTracing.cmake)
-
-# enable cache system
-include(cmake/Cache.cmake)
-
-# standard compiler warnings
-include(cmake/CompilerWarnings.cmake)
-set_project_warnings(project_warnings)
-
-# sanitizer options if supported by compiler
-include(cmake/Sanitizers.cmake)
-enable_sanitizers(project_options)
-
-# allow for static analysis options
-include(cmake/StaticAnalyzers.cmake)
-
-include(cmake/Backtrace.cmake)
-
-include(cmake/ThirdPartyDependencies.cmake)
-
-option(STATIC_STDLIB "Statically link C++ standard library" FALSE)
-if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-  if(STATIC_STDLIB)
-    target_compile_options(project_options INTERFACE -static-libgcc -static-libstdc++)
-    target_link_libraries(project_options INTERFACE -static-libgcc -static-libstdc++)
-  endif()
-endif()
-
-option(STATIC_OPENSSL "Statically link OpenSSL library" FALSE)
-# Read more at https://wiki.wireshark.org/TLS
-option(TLS_KEY_LOG_FILE "Path to file to write per-session secrets (Useful for Wireshark SSL/TLS dissection)")
-if(STATIC_OPENSSL)
-  set(OPENSSL_USE_STATIC_LIBS ON)
-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}")
-else()
-  message(FATAL_ERROR "Cannot build couchbase extension without OpenSSL")
+if(WIN32)
+  add_definitions(-D_WIN32_WINNT=0x0601)
 endif()
 
-include(cmake/VersionInfo.cmake)
-
-include_directories(${CMAKE_SOURCE_DIR}/couchbase)
-
-add_library(
-  platform OBJECT
-  couchbase/platform/string_hex.cc
-  couchbase/platform/uuid.cc
-  couchbase/platform/random.cc
-  couchbase/platform/base64.cc
-  couchbase/platform/backtrace.c
-  couchbase/platform/terminate_handler.cc)
-target_include_directories(platform PRIVATE ${PROJECT_BINARY_DIR}/generated)
-target_link_libraries(platform PRIVATE ${PLATFORM_LIBRARIES})
-
-add_library(cbcrypto OBJECT couchbase/cbcrypto/cbcrypto.cc)
-target_link_libraries(
-  cbcrypto
-  PRIVATE project_options
-          project_warnings
-          OpenSSL::SSL
-          OpenSSL::Crypto)
-
-add_library(
-  cbsasl OBJECT
-  couchbase/cbsasl/client.cc
-  couchbase/cbsasl/context.cc
-  couchbase/cbsasl/mechanism.cc
-  couchbase/cbsasl/plain/plain.cc
-  couchbase/cbsasl/scram-sha/scram-sha.cc
-  couchbase/cbsasl/scram-sha/stringutils.cc)
-
 if(RUBY_HDR_DIR)
   set(RUBY_INCLUDE_DIR ${RUBY_HDR_DIR} ${RUBY_ARCH_HDR_DIR})
 else()
-  find_package(Ruby REQUIRED)
+  find_package(Ruby 2.6.0 REQUIRED)
   message(STATUS "RUBY_VERSION: ${RUBY_VERSION}")
   message(STATUS "RUBY_EXECUTABLE: ${RUBY_EXECUTABLE}")
 endif()
-message(STATUS "RUBY_LIBRARY: ${RUBY_LIBRARY}")
-if(RUBY_INCLUDE_DIR)
-  message(STATUS "RUBY_INCLUDE_DIR: ${RUBY_INCLUDE_DIR}")
-  include_directories(BEFORE SYSTEM "${RUBY_INCLUDE_DIR}")
-endif()
 
-add_library(couchbase SHARED couchbase/couchbase.cxx)
-target_include_directories(couchbase PRIVATE ${PROJECT_BINARY_DIR}/generated)
+add_subdirectory(couchbase)
+
+if(NOT EXT_GIT_REVISION)
+  find_program(GIT git)
+  if(GIT)
+    execute_process(
+      COMMAND git rev-parse HEAD
+      WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+      OUTPUT_VARIABLE EXT_GIT_REVISION)
+  else()
+    set(EXT_GIT_REVISION "unknown")
+  endif()
+endif()
+configure_file(${PROJECT_SOURCE_DIR}/ext_build_version.hxx.in ${PROJECT_BINARY_DIR}/generated/ext_build_version.hxx
+               @ONLY)
+file(
+  GENERATE
+  OUTPUT ${PROJECT_BINARY_DIR}/generated/ext_build_info.hxx
+  CONTENT
+    "
+#pragma once
+constexpr auto RUBY_LIBRUBYARG = \"${RUBY_LIBRUBYARG}\";
+constexpr auto RUBY_INCLUDE_DIR = \"${RUBY_INCLUDE_DIR}\";
+constexpr auto RUBY_LIBRARY_DIR = \"${RUBY_LIBRARY_DIR}\";
+")
+
+message(STATUS "RUBY_LIBRUBYARG: ${RUBY_LIBRUBYARG}")
+message(STATUS "RUBY_INCLUDE_DIR: ${RUBY_INCLUDE_DIR}")
+message(STATUS "RUBY_LIBRARY_DIR: ${RUBY_LIBRARY_DIR}")
+
+add_library(couchbase SHARED couchbase.cxx)
+target_include_directories(couchbase PRIVATE ${PROJECT_BINARY_DIR}/generated ${RUBY_INCLUDE_DIR})
 target_link_libraries(
   couchbase
   PRIVATE project_options
           project_warnings
-          OpenSSL::SSL
-          OpenSSL::Crypto
-          platform
-          cbcrypto
-          cbsasl
-          http_parser
-          snappy
-          spdlog::spdlog_header_only)
+          couchbase_cxx_client
+          snappy)
+if(RUBY_LIBRUBY)
+  target_link_directories(couchbase PRIVATE "${RUBY_LIBRARY_DIR}")
+  target_link_libraries(couchbase PRIVATE "${RUBY_LIBRUBY}")
+endif()
 
-set_target_properties(
-  cbcrypto
-  cbsasl
-  platform
-  snappy
-  PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
+if(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
+  target_compile_options(couchbase PRIVATE -fdeclspec)
+endif()
 
 if(APPLE)
   target_link_libraries(couchbase PRIVATE -Wl,-undefined,dynamic_lookup)
-else()
-  set_target_properties(cbcrypto cbsasl platform PROPERTIES CXX_VISIBILITY_PRESET hidden)
 endif()
-
-include(cmake/Testing.cmake)

data/ext/couchbase/CMakeLists.txt

@@ -0,0 +1,142 @@
+cmake_minimum_required(VERSION 3.17)
+# node.js uses cmake 3.17
+message(STATUS "CMake version ${CMAKE_VERSION}")
+
+set(couchbase_cxx_client_BUILD_NUMBER 0)
+if(DEFINED ENV{BUILD_NUMBER})
+  set(couchbase_cxx_client_BUILD_NUMBER $ENV{BUILD_NUMBER})
+endif()
+
+if(NOT DEFINED COUCHBASE_CXX_CLIENT_MASTER_PROJECT)
+  if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+    set(COUCHBASE_CXX_CLIENT_MASTER_PROJECT ON)
+  else()
+    set(COUCHBASE_CXX_CLIENT_MASTER_PROJECT OFF)
+  endif()
+endif()
+
+project(
+  couchbase_cxx_client
+  VERSION "1.0.0.${couchbase_cxx_client_BUILD_NUMBER}"
+  LANGUAGES CXX C)
+message(STATUS "Couchbase C++ client ${couchbase_cxx_client_VERSION}")
+
+include(cmake/PreventInSourceBuilds.cmake)
+include(cmake/StandardProjectSettings.cmake)
+
+# 'library' to set the c++ standard / compile-time options requested
+add_library(project_options INTERFACE)
+target_compile_features(project_options INTERFACE cxx_std_17)
+
+# 'library' to use the warnings specified in CompilerWarnings.cmake
+add_library(project_warnings INTERFACE)
+
+include(cmake/BuildTracing.cmake)
+
+# enable cache system
+include(cmake/Cache.cmake)
+
+# standard compiler warnings
+include(cmake/CompilerWarnings.cmake)
+
+# sanitizer options if supported by compiler
+include(cmake/Sanitizers.cmake)
+
+# allow for static analysis options
+include(cmake/StaticAnalyzers.cmake)
+
+include(cmake/Backtrace.cmake)
+
+if(COUCHBASE_CXX_CLIENT_MASTER_PROJECT)
+  set_project_warnings(project_warnings)
+  enable_sanitizers(project_options)
+endif()
+
+find_package(Threads REQUIRED)
+
+include(cmake/ThirdPartyDependencies.cmake)
+
+option(COUCHBASE_CXX_CLIENT_STATIC_STDLIB "Statically link C++ standard library" FALSE)
+if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+  if(COUCHBASE_CXX_CLIENT_STATIC_STDLIB)
+    target_compile_options(project_options INTERFACE -static-libgcc -static-libstdc++)
+    target_link_libraries(project_options INTERFACE -static-libgcc -static-libstdc++)
+  endif()
+endif()
+
+include(cmake/OpenSSL.cmake)
+
+include(cmake/VersionInfo.cmake)
+
+add_subdirectory(couchbase/meta)
+add_subdirectory(couchbase/platform)
+add_subdirectory(couchbase/logger)
+add_subdirectory(couchbase/crypto)
+add_subdirectory(couchbase/sasl)
+add_subdirectory(couchbase/topology)
+add_subdirectory(couchbase/utils)
+add_subdirectory(couchbase/protocol)
+add_subdirectory(couchbase/io)
+add_subdirectory(couchbase/management)
+add_subdirectory(couchbase/operations)
+add_subdirectory(couchbase/tracing)
+add_subdirectory(couchbase/metrics)
+
+if(COUCHBASE_CXX_CLIENT_BUILD_SHARED)
+  add_library(couchbase_cxx_client SHARED couchbase/cluster.cxx couchbase/document_id.cxx couchbase/cluster_options.cxx)
+else()
+  add_library(couchbase_cxx_client STATIC couchbase/cluster.cxx couchbase/document_id.cxx couchbase/cluster_options.cxx)
+endif()
+set_target_properties(couchbase_cxx_client PROPERTIES POSITION_INDEPENDENT_CODE ON)
+target_include_directories(couchbase_cxx_client PUBLIC ${PROJECT_SOURCE_DIR})
+target_include_directories(
+  couchbase_cxx_client SYSTEM
+  PUBLIC ${PROJECT_SOURCE_DIR}/third_party/asio/asio/include
+         ${PROJECT_SOURCE_DIR}/third_party/gsl/include
+         ${PROJECT_SOURCE_DIR}/third_party/json/external/PEGTL/include
+         ${PROJECT_SOURCE_DIR}/third_party/json/include
+         ${PROJECT_SOURCE_DIR}/third_party/cxx_function
+         ${PROJECT_SOURCE_DIR}/third_party/fmt/include
+         ${PROJECT_SOURCE_DIR}/third_party/spdlog/include)
+target_link_libraries(couchbase_cxx_client PRIVATE project_options project_warnings)
+
+include(cmake/DetectStandardFilesystem.cmake)
+couchbase_cxx_check_filesystem(
+  couchbase_cxx_client
+  "filesystem"
+  "std::filesystem"
+  "stdc++fs;c++fs"
+  STD_FILESYSTEM)
+if(STD_FILESYSTEM)
+  message(STATUS "Using std::filesystem")
+else()
+  message(FATAL_ERROR "Couchbase C++ Client requires C++17, including an implementation of std::filesystem.")
+endif()
+
+target_link_libraries(
+  couchbase_cxx_client
+  PUBLIC fmt::fmt
+         spdlog::spdlog
+         couchbase_backtrace
+         couchbase_logger
+         couchbase_platform
+         couchbase_io
+         couchbase_meta
+         couchbase_crypto
+         couchbase_sasl
+         couchbase_topology
+         couchbase_utils
+         couchbase_protocol
+         couchbase_management
+         couchbase_operations
+         couchbase_operations_management
+         couchbase_tracing
+         couchbase_metrics)
+if(NOT COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL)
+  target_link_libraries(couchbase_cxx_client PUBLIC OpenSSL::SSL OpenSSL::Crypto)
+endif()
+
+option(COUCHBASE_CXX_CLIENT_BUILD_TESTS "Build test programs" TRUE)
+if(COUCHBASE_CXX_CLIENT_BUILD_TESTS)
+  include(cmake/Testing.cmake)
+endif()

data/ext/couchbase/cmake/CompilerWarnings.cmake

@@ -0,0 +1,83 @@
+# from here:
+#
+# https://github.com/lefticus/cppbestpractices/blob/master/02-Use_the_Tools_Available.md
+
+function(set_project_warnings project_name)
+  option(WARNINGS_AS_ERRORS "Treat compiler warnings as errors" TRUE)
+
+  set(MSVC_WARNINGS
+      /W4 # Baseline reasonable warnings
+      /wd4242 # 'identifier': conversion from 'type1' to 'type1', possible loss of data
+      /wd4244 # 'identifier': conversion from 'type1' to 'type1', possible loss of data
+      /w14254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
+      /w14263 # 'function': member function does not override any base class virtual member function
+      /w14265 # 'classname': class has virtual functions, but destructor is not virtual instances of this class may not
+              # be destructed correctly
+      /w14287 # 'operator': unsigned/negative constant mismatch
+      /we4289 # nonstandard extension used: 'variable': loop control variable declared in the for-loop is used outside
+              # the for-loop scope
+      /w14296 # 'operator': expression is always 'boolean_value'
+      /w14311 # 'variable': pointer truncation from 'type1' to 'type2'
+      /w14545 # expression before comma evaluates to a function which is missing an argument list
+      /w14546 # function call before comma missing argument list
+      /w14547 # 'operator': operator before comma has no effect; expected operator with side-effect
+      /w14549 # 'operator': operator before comma has no effect; did you intend 'operator'?
+      /w14555 # expression has no effect; expected expression with side- effect
+      /wd4619 # pragma warning: there is no warning number 'number'
+      /w14640 # Enable warning on thread un-safe static member initialization
+      /w14826 # Conversion from 'type1' to 'type_2' is sign-extended. This may cause unexpected runtime behavior.
+      /w14905 # wide string literal cast to 'LPSTR'
+      /w14906 # string literal cast to 'LPWSTR'
+      /w14928 # illegal copy-initialization; more than one user-defined conversion has been implicitly applied
+      /permissive- # standards conformance mode for MSVC compiler.
+  )
+
+  set(CLANG_WARNINGS
+      -Wall
+      -Wextra # reasonable and standard
+      -Wshadow # warn the user if a variable declaration shadows one from a parent context
+      -Wnon-virtual-dtor # warn the user if a class with virtual functions has a non-virtual destructor. This helps
+                         # catch hard to track down memory errors
+      -Wold-style-cast # warn for c-style casts
+      -Wcast-align # warn for potential performance problem casts
+      -Wunused # warn on anything being unused
+      -Woverloaded-virtual # warn if you overload (not override) a virtual function
+      -Wpedantic # warn if non-standard C++ is used
+      -Wconversion # warn on type conversions that may lose data
+      -Wsign-conversion # warn on sign conversions
+      -Wnull-dereference # warn if a null dereference is detected
+      -Wdouble-promotion # warn if float is implicit promoted to double
+      -Wformat=2 # warn on security issues around functions that format output (ie printf)
+      # TODO: make it local to ext/couchbase/couchbase.cxx
+      -Wno-unknown-warning-option
+      -Wno-gnu-statement-expression
+      -Wno-compound-token-split-by-macro)
+
+  if(WARNINGS_AS_ERRORS)
+    set(CLANG_WARNINGS ${CLANG_WARNINGS} -Werror)
+    set(MSVC_WARNINGS ${MSVC_WARNINGS} /WX)
+  endif()
+
+  set(GCC_WARNINGS
+      ${CLANG_WARNINGS}
+      -Wmisleading-indentation # warn if indentation implies blocks where blocks do not exist
+      -Wduplicated-cond # warn if if / else chain has duplicated conditions
+      -Wduplicated-branches # warn if if / else branches have duplicated code
+      -Wlogical-op # warn about logical operations being used where bitwise were probably wanted
+      -Wuseless-cast # warn if you perform a cast to the same type
+      -Wdeprecated-declarations # warn if [[deprecated]] elements being used
+  )
+
+  if(MSVC)
+    set(PROJECT_WARNINGS ${MSVC_WARNINGS})
+  elseif(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
+    set(PROJECT_WARNINGS ${CLANG_WARNINGS})
+  elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    set(PROJECT_WARNINGS ${GCC_WARNINGS})
+  else()
+    message(AUTHOR_WARNING "No compiler warnings set for '${CMAKE_CXX_COMPILER_ID}' compiler.")
+  endif()
+
+  target_compile_options(${project_name} INTERFACE ${PROJECT_WARNINGS})
+
+endfunction()

data/ext/couchbase/cmake/DetectStandardFilesystem.cmake

@@ -0,0 +1,30 @@
+# Try compiling a test program with std::filesystem or one of its alternatives
+function(couchbase_cxx_check_filesystem TARGET FILESYSTEM_HEADER FILESYSTEM_NAMESPACE OPTIONAL_LIBS OUT_RESULT)
+    set(TEST_FILE "test_${OUT_RESULT}.cpp")
+    configure_file(${PROJECT_SOURCE_DIR}/cmake/test_filesystem.cpp.in ${TEST_FILE} @ONLY)
+
+    try_compile(TEST_RESULT
+            ${CMAKE_CURRENT_BINARY_DIR}
+            ${CMAKE_CURRENT_BINARY_DIR}/${TEST_FILE}
+            CXX_STANDARD 17)
+
+    if(NOT TEST_RESULT)
+        # Retry with each of the optional libraries
+        foreach(OPTIONAL_LIB IN LISTS OPTIONAL_LIBS)
+            try_compile(TEST_RESULT
+                    ${CMAKE_CURRENT_BINARY_DIR}
+                    ${CMAKE_CURRENT_BINARY_DIR}/${TEST_FILE}
+                    LINK_LIBRARIES ${OPTIONAL_LIB}
+                    CXX_STANDARD 17)
+
+            if(TEST_RESULT)
+                # Looks like the optional library was required, go ahead and add it to the link options.
+                message(STATUS "Adding ${OPTIONAL_LIB} to the Couchbase C++ Client to build with ${FILESYSTEM_NAMESPACE}.")
+                target_link_libraries(${TARGET} INTERFACE ${OPTIONAL_LIB})
+                break()
+            endif()
+        endforeach()
+    endif()
+
+    set(${OUT_RESULT} ${TEST_RESULT} PARENT_SCOPE)
+endfunction()

data/ext/couchbase/cmake/OpenSSL.cmake

@@ -0,0 +1,24 @@
+option(COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL "Rely on application to link OpenSSL library" FALSE)
+
+if(COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL)
+  message(
+    STATUS "COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL is set, assuming OpenSSL headers and symbols are available already"
+  )
+else()
+  option(COUCHBASE_CXX_CLIENT_STATIC_OPENSSL "Statically link OpenSSL library" FALSE)
+  if(COUCHBASE_CXX_CLIENT_STATIC_OPENSSL)
+    set(OPENSSL_USE_STATIC_LIBS ON)
+  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}")
+  else()
+    message(FATAL_ERROR "Cannot build Couchbase C++ SDK without OpenSSL")
+  endif()
+endif()
+
+# Read more at https://wiki.wireshark.org/TLS
+option(COUCHBASE_CXX_CLIENT_TLS_KEY_LOG_FILE
+       "Path to file to write per-session secrets (Useful for Wireshark SSL/TLS dissection)")

data/ext/couchbase/cmake/PreventInSourceBuilds.cmake

@@ -0,0 +1,21 @@
+#
+# This function will prevent in-source builds
+function(AssureOutOfSourceBuilds)
+  # make sure the user doesn't play dirty with symlinks
+  get_filename_component(srcdir "${CMAKE_SOURCE_DIR}" REALPATH)
+  get_filename_component(bindir "${CMAKE_BINARY_DIR}" REALPATH)
+
+  message(STATUS "CMAKE_SOURCE_DIR=${srcdir}")
+  message(STATUS "CMAKE_BINARY_DIR=${bindir}")
+
+  # disallow in-source builds
+  if("${srcdir}" STREQUAL "${bindir}")
+    message("######################################################")
+    message("Warning: in-source builds are disabled")
+    message("Please create a separate build directory and run cmake from there")
+    message("######################################################")
+    message(FATAL_ERROR "Quitting configuration")
+  endif()
+endfunction()
+
+assureoutofsourcebuilds()

data/ext/couchbase/cmake/Sanitizers.cmake

@@ -0,0 +1,67 @@
+function(enable_sanitizers project_name)
+
+  if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
+    option(ENABLE_COVERAGE "Enable coverage reporting for gcc/clang" FALSE)
+
+    if(ENABLE_COVERAGE)
+      target_compile_options(${project_name} INTERFACE --coverage -O0 -g)
+      target_link_libraries(${project_name} INTERFACE --coverage)
+    endif()
+
+    set(SANITIZERS "")
+
+    option(ENABLE_SANITIZER_ADDRESS "Enable address sanitizer" FALSE)
+    if(ENABLE_SANITIZER_ADDRESS)
+      list(APPEND SANITIZERS "address")
+    endif()
+
+    option(ENABLE_SANITIZER_LEAK "Enable leak sanitizer" FALSE)
+    if(ENABLE_SANITIZER_LEAK)
+      list(APPEND SANITIZERS "leak")
+    endif()
+
+    option(ENABLE_SANITIZER_UNDEFINED_BEHAVIOUR "Enable undefined behaviour sanitizer" FALSE)
+    if(ENABLE_SANITIZER_UNDEFINED_BEHAVIOUR)
+      list(APPEND SANITIZERS "undefined")
+    endif()
+
+    option(ENABLE_SANITIZER_THREAD "Enable thread sanitizer" FALSE)
+    if(ENABLE_SANITIZER_THREAD)
+      if("address" IN_LIST SANITIZERS OR "leak" IN_LIST SANITIZERS)
+        message(WARNING "Thread sanitizer does not work with Address and Leak sanitizer enabled")
+      else()
+        list(APPEND SANITIZERS "thread")
+      endif()
+    endif()
+
+    option(ENABLE_SANITIZER_MEMORY "Enable memory sanitizer" FALSE)
+    if(ENABLE_SANITIZER_MEMORY AND CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
+      if("address" IN_LIST SANITIZERS
+         OR "thread" IN_LIST SANITIZERS
+         OR "leak" IN_LIST SANITIZERS)
+        message(WARNING "Memory sanitizer does not work with Address, Thread and Leak sanitizer enabled")
+      else()
+        list(APPEND SANITIZERS "memory")
+      endif()
+    endif()
+
+    list(
+      JOIN
+      SANITIZERS
+      ","
+      LIST_OF_SANITIZERS)
+
+  endif()
+
+  if(LIST_OF_SANITIZERS)
+    if(NOT
+       "${LIST_OF_SANITIZERS}"
+       STREQUAL
+       "")
+      target_compile_options(${project_name} INTERFACE -fsanitize=${LIST_OF_SANITIZERS})
+      target_link_libraries(${project_name} INTERFACE -fsanitize=${LIST_OF_SANITIZERS})
+      message(STATUS "Enabled stanitizers: ${LIST_OF_SANITIZERS}")
+    endif()
+  endif()
+
+endfunction()

data/ext/couchbase/cmake/StandardProjectSettings.cmake

@@ -0,0 +1,45 @@
+set(CMAKE_CXX_STANDARD 17)
+
+# Set a default build type if none was specified
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  message(STATUS "Setting build type to 'RelWithDebInfo' as none was specified.")
+  set(CMAKE_BUILD_TYPE
+      RelWithDebInfo
+      CACHE STRING "Choose the type of build." FORCE)
+  # Set the possible values of build type for cmake-gui, ccmake
+  set_property(
+    CACHE CMAKE_BUILD_TYPE
+    PROPERTY STRINGS
+             "Debug"
+             "Release"
+             "MinSizeRel"
+             "RelWithDebInfo")
+endif()
+
+# Generate compile_commands.json to make it easier to work with clang based tools
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+option(ENABLE_IPO "Enable Interprocedural Optimization, aka Link Time Optimization (LTO)" OFF)
+
+if(ENABLE_IPO)
+  include(CheckIPOSupported)
+  check_ipo_supported(RESULT result OUTPUT output)
+  if(result)
+    set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+  else()
+    message(SEND_ERROR "IPO is not supported: ${output}")
+  endif()
+endif()
+
+if(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
+  add_compile_options(-fcolor-diagnostics)
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  add_compile_options(-fdiagnostics-color=always)
+else()
+  message(STATUS "No colored compiler diagnostic set for '${CMAKE_CXX_COMPILER_ID}' compiler.")
+endif()
+
+if(MSVC)
+  add_definitions(/bigobj)
+endif()
+