couchbase 3.0.0-universal-darwin-19 → 3.0.1-universal-darwin-19

data/ext/cmake/PreventInSourceBuilds.cmake

@@ -0,0 +1,18 @@
+#
+# 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)
+
+  # 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/cmake/Sanitizers.cmake

@@ -0,0 +1,66 @@
+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})
+    endif()
+  endif()
+
+endfunction()

data/ext/cmake/StandardProjectSettings.cmake

@@ -0,0 +1,40 @@
+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()

data/ext/cmake/StaticAnalyzers.cmake

@@ -0,0 +1,37 @@
+option(ENABLE_CPPCHECK "Enable static analysis with cppcheck" OFF)
+option(ENABLE_CLANG_TIDY "Enable static analysis with clang-tidy" OFF)
+option(ENABLE_INCLUDE_WHAT_YOU_USE "Enable static analysis with include-what-you-use" OFF)
+
+if(ENABLE_CPPCHECK)
+  find_program(CPPCHECK cppcheck)
+  if(CPPCHECK)
+    set(CMAKE_CXX_CPPCHECK
+        ${CPPCHECK}
+        --suppress=missingInclude
+        --enable=all
+        --inline-suppr
+        --inconclusive
+        -i
+        ${CMAKE_SOURCE_DIR}/imgui/lib)
+  else()
+    message(SEND_ERROR "cppcheck requested but executable not found")
+  endif()
+endif()
+
+if(ENABLE_CLANG_TIDY)
+  find_program(CLANGTIDY clang-tidy)
+  if(CLANGTIDY)
+    set(CMAKE_CXX_CLANG_TIDY ${CLANGTIDY} -extra-arg=-Wno-unknown-warning-option)
+  else()
+    message(SEND_ERROR "clang-tidy requested but executable not found")
+  endif()
+endif()
+
+if(ENABLE_INCLUDE_WHAT_YOU_USE)
+  find_program(INCLUDE_WHAT_YOU_USE include-what-you-use)
+  if(INCLUDE_WHAT_YOU_USE)
+    set(CMAKE_CXX_INCLUDE_WHAT_YOU_USE ${INCLUDE_WHAT_YOU_USE})
+  else()
+    message(SEND_ERROR "include-what-you-use requested but executable not found")
+  endif()
+endif()

data/ext/cmake/Testing.cmake

@@ -0,0 +1,52 @@
+if(ENABLE_TESTING)
+  file(
+    GENERATE
+    OUTPUT ${PROJECT_BINARY_DIR}/generated/test_config.hxx
+    CONTENT
+      "
+#pragma once
+#define LIBCOUCHBASE_EXT_PATH \"$<TARGET_FILE:couchbase>\"
+")
+
+  add_subdirectory(third_party/catch2)
+  list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/third_party/catch2/contrib")
+  enable_testing()
+  include(Catch)
+
+  macro(ruby_test name)
+    add_executable(test_ruby_${name} test/test_ruby_${name}.cxx)
+    target_include_directories(test_ruby_${name} PRIVATE ${PROJECT_BINARY_DIR}/generated)
+    target_link_libraries(
+      test_ruby_${name}
+      project_options
+      project_warnings
+      ${RUBY_LIBRARY}
+      couchbase
+      Catch2::Catch2)
+    catch_discover_tests(test_ruby_${name})
+  endmacro()
+
+  macro(native_test name)
+    add_executable(test_native_${name} test/test_native_${name}.cxx)
+    target_include_directories(test_native_${name} PRIVATE ${PROJECT_BINARY_DIR}/generated)
+    target_link_libraries(
+      test_native_${name}
+      project_options
+      project_warnings
+      Catch2::Catch2
+      OpenSSL::SSL
+      OpenSSL::Crypto
+      platform
+      cbcrypto
+      cbsasl
+      http_parser
+      snappy
+      spdlog::spdlog_header_only)
+    catch_discover_tests(test_native_${name})
+  endmacro()
+
+  ruby_test(trivial_crud)
+  ruby_test(trivial_query)
+  native_test(trivial_crud)
+  native_test(diagnostics)
+endif()

data/ext/cmake/ThirdPartyDependencies.cmake

@@ -0,0 +1,20 @@
+add_subdirectory(third_party/gsl)
+
+option(TAOCPP_JSON_BUILD_TESTS OFF)
+option(TAOCPP_JSON_BUILD_EXAMPLES OFF)
+add_subdirectory(third_party/json)
+
+add_subdirectory(third_party/spdlog)
+
+option(SNAPPY_BUILD_TESTS OFF)
+option(SNAPPY_INSTALL OFF)
+add_subdirectory(third_party/snappy)
+
+include_directories(BEFORE SYSTEM third_party/gsl/include)
+include_directories(BEFORE SYSTEM third_party/asio/asio/include)
+include_directories(BEFORE SYSTEM third_party/json/include)
+include_directories(BEFORE SYSTEM third_party/spdlog/include)
+include_directories(BEFORE SYSTEM third_party/http_parser)
+
+add_library(http_parser OBJECT third_party/http_parser/http_parser.c)
+set_target_properties(http_parser PROPERTIES C_VISIBILITY_PRESET hidden POSITION_INDEPENDENT_CODE TRUE)

data/ext/cmake/VersionInfo.cmake

@@ -0,0 +1,37 @@
+find_program(GIT git)
+if(GIT)
+  execute_process(
+    COMMAND git rev-parse HEAD
+    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    OUTPUT_VARIABLE BACKEND_GIT_REVISION)
+endif()
+
+string(TIMESTAMP BACKEND_BUILD_TIMESTAMP "%Y-%m-%d %H:%M:%S" UTC)
+configure_file(${PROJECT_SOURCE_DIR}/build_version.hxx.in ${PROJECT_BINARY_DIR}/generated/build_version.hxx @ONLY)
+configure_file(${PROJECT_SOURCE_DIR}/build_config.hxx.in ${PROJECT_BINARY_DIR}/generated/build_config.hxx @ONLY)
+
+file(
+  GENERATE
+  OUTPUT ${PROJECT_BINARY_DIR}/generated/build_info.hxx
+  CONTENT
+    "
+#pragma once
+#define BACKEND_COMPILE_DEFINITIONS \"$<TARGET_PROPERTY:couchbase,COMPILE_DEFINITIONS>\"
+#define BACKEND_COMPILE_FEATURES \"$<TARGET_PROPERTY:couchbase,COMPILE_FEATURES>\"
+#define BACKEND_COMPILE_FLAGS \"$<TARGET_PROPERTY:couchbase,COMPILE_FLAGS>\"
+#define BACKEND_COMPILE_OPTIONS \"$<TARGET_PROPERTY:couchbase,COMPILE_OPTIONS>\"
+
+#define BACKEND_LINK_DEPENDS \"$<TARGET_PROPERTY:couchbase,LINK_DEPENDS>\"
+#define BACKEND_LINK_FLAGS \"$<TARGET_PROPERTY:couchbase,LINK_FLAGS>\"
+#define BACKEND_LINK_LIBRARIES \"$<TARGET_PROPERTY:couchbase,LINK_LIBRARIES>\"
+#define BACKEND_LINK_OPTIONS \"$<TARGET_PROPERTY:couchbase,LINK_OPTIONS>\"
+
+#define OPENSSL_CRYPTO_LIBRARIES \"${OPENSSL_CRYPTO_LIBRARIES}\"
+#define OPENSSL_SSL_LIBRARIES \"${OPENSSL_SSL_LIBRARIES}\"
+#define OPENSSL_INCLUDE_DIR \"${OPENSSL_INCLUDE_DIR}\"
+#define RUBY_LIBRARY \"${RUBY_LIBRARY}\"
+#define RUBY_INCLUDE_DIR \"${RUBY_INCLUDE_DIR}\"
+
+#define CMAKE_BUILD_TYPE \"${CMAKE_BUILD_TYPE}\"
+")

data/ext/couchbase/bucket.hxx

@@ -79,9 +79,9 @@ class bucket : public std::enable_shared_from_this<bucket>
     void update_config(const configuration& config)
     {
         if (!config_) {
-            spdlog::debug("{} initialize configuration rev={}", log_prefix_, config.rev);
-        } else if (config.rev > config_->rev) {
-            spdlog::debug("{} will update the configuration old={} -> new={}", log_prefix_, config_->rev, config.rev);
+            spdlog::debug("{} initialize configuration rev={}", log_prefix_, config.rev_str());
+        } else if (config.rev && config_->rev && *config.rev > *config_->rev) {
+            spdlog::debug("{} will update the configuration old={} -> new={}", log_prefix_, config_->rev_str(), config.rev_str());
         } else {
             return;
         }
@@ -111,7 +111,7 @@ class bucket : public std::enable_shared_from_this<bucket>
                 if (new_index < config.nodes.size()) {
                     spdlog::debug(R"({} rev={}, preserve session="{}", address="{}:{}")",
                                   log_prefix_,
-                                  config.rev,
+                                  config.rev_str(),
                                   entry.second->id(),
                                   entry.second->bootstrap_hostname(),
                                   entry.second->bootstrap_port());
@@ -119,7 +119,7 @@ class bucket : public std::enable_shared_from_this<bucket>
                 } else {
                     spdlog::debug(R"({} rev={}, drop session="{}", address="{}:{}")",
                                   log_prefix_,
-                                  config.rev,
+                                  config.rev_str(),
                                   entry.second->id(),
                                   entry.second->bootstrap_hostname(),
                                   entry.second->bootstrap_port());
@@ -134,6 +134,9 @@ class bucket : public std::enable_shared_from_this<bucket>
 
                 auto hostname = node.hostname_for(origin_.options().network);
                 auto port = node.port_or(origin_.options().network, service_type::kv, origin_.options().enable_tls, 0);
+                if (port == 0) {
+                    continue;
+                }
                 couchbase::origin origin(origin_.credentials(), hostname, port, origin_.options());
                 std::shared_ptr<io::mcbp_session> session;
                 if (origin_.options().enable_tls) {
@@ -141,7 +144,8 @@ class bucket : public std::enable_shared_from_this<bucket>
                 } else {
                     session = std::make_shared<io::mcbp_session>(client_id_, ctx_, origin, name_, known_features_);
                 }
-                spdlog::debug(R"({} rev={}, add session="{}", address="{}:{}")", log_prefix_, config.rev, session->id(), hostname, port);
+                spdlog::debug(
+                  R"({} rev={}, add session="{}", address="{}:{}")", log_prefix_, config.rev_str(), session->id(), hostname, port);
                 session->bootstrap(
                   [self = shared_from_this(), session](std::error_code err, const configuration& cfg) {
                       if (!err) {
@@ -171,7 +175,7 @@ class bucket : public std::enable_shared_from_this<bucket>
         auto& old_session = ptr->second;
         auto hostname = old_session->bootstrap_hostname();
         auto port = old_session->bootstrap_port();
-        spdlog::debug(R"({} restarting session idx={}, id="{}", address="{}")", log_prefix_, index, old_session->id(), hostname, port);
+        auto old_id = old_session->id();
         couchbase::origin origin(origin_.credentials(), hostname, port, origin_.options());
         sessions_.erase(ptr);
         std::shared_ptr<io::mcbp_session> session;
@@ -180,6 +184,8 @@ class bucket : public std::enable_shared_from_this<bucket>
         } else {
             session = std::make_shared<io::mcbp_session>(client_id_, ctx_, origin, name_, known_features_);
         }
+        spdlog::debug(
+          R"({} restarting session idx={}, id=("{}" -> "{}"), address="{}")", log_prefix_, index, old_id, session->id(), hostname, port);
         session->bootstrap(
           [self = shared_from_this(), session](std::error_code err, const configuration& config) {
               if (!err) {
@@ -254,7 +260,10 @@ class bucket : public std::enable_shared_from_this<bucket>
 
         drain_deferred_queue();
         for (auto& session : sessions_) {
-            session.second->stop(io::retry_reason::do_not_retry);
+            if (session.second) {
+                spdlog::debug(R"({} shutdown session session="{}", idx={})", log_prefix_, session.second->id(), session.first);
+                session.second->stop(io::retry_reason::do_not_retry);
+            }
         }
     }
 
@@ -265,10 +274,18 @@ class bucket : public std::enable_shared_from_this<bucket>
             return cmd->cancel(io::retry_reason::do_not_retry);
         }
         std::int16_t index = 0;
-        std::tie(cmd->request.partition, index) = config_->map_key(cmd->request.id.key);
-        if (index < 0) {
-            return io::retry_orchestrator::maybe_retry(
-              cmd->manager_, cmd, io::retry_reason::node_not_available, std::make_error_code(error::common_errc::request_canceled));
+        if (cmd->request.id.use_any_session) {
+            index = round_robin_next_;
+            ++round_robin_next_;
+            if (static_cast<std::size_t>(round_robin_next_) >= sessions_.size()) {
+                round_robin_next_ = 0;
+            }
+        } else {
+            std::tie(cmd->request.partition, index) = config_->map_key(cmd->request.id.key);
+            if (index < 0) {
+                return io::retry_orchestrator::maybe_retry(
+                  cmd->manager_, cmd, io::retry_reason::node_not_available, std::make_error_code(error::common_errc::request_canceled));
+            }
         }
         cmd->send_to(sessions_.at(static_cast<std::size_t>(index)));
     }
@@ -293,6 +310,13 @@ class bucket : public std::enable_shared_from_this<bucket>
         return log_prefix_;
     }
 
+    void export_diag_info(diag::diagnostics_result& res) const
+    {
+        for (const auto& session : sessions_) {
+            res.services[service_type::kv].emplace_back(session.second->diag_info());
+        }
+    }
+
   private:
     std::string client_id_;
     asio::io_context& ctx_;
@@ -307,6 +331,7 @@ class bucket : public std::enable_shared_from_this<bucket>
 
     bool closed_{ false };
     std::map<size_t, std::shared_ptr<io::mcbp_session>> sessions_{};
+    std::int16_t round_robin_next_{ 0 };
 
     std::string log_prefix_{};
 };

data/ext/couchbase/capabilities.hxx

@@ -0,0 +1,117 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <spdlog/fmt/fmt.h>
+
+namespace couchbase
+{
+enum class bucket_capability {
+    couchapi,
+    xattr,
+    dcp,
+    cbhello,
+    touch,
+    cccp,
+    xdcr_checkpointing,
+    nodes_ext,
+    collections,
+    durable_write,
+    tombstoned_user_xattrs,
+};
+
+enum class cluster_capability {
+    n1ql_cost_based_optimizer,
+    n1ql_index_advisor,
+    n1ql_javascript_functions,
+    n1ql_inline_functions,
+    n1ql_enhanced_prepared_statements,
+};
+} // namespace couchbase
+
+template<>
+struct fmt::formatter<couchbase::bucket_capability> : formatter<std::string_view> {
+    template<typename FormatContext>
+    auto format(couchbase::bucket_capability type, FormatContext& ctx)
+    {
+        string_view name = "unknown";
+        switch (type) {
+            case couchbase::bucket_capability::couchapi:
+                name = "couchapi";
+                break;
+            case couchbase::bucket_capability::xattr:
+                name = "xattr";
+                break;
+            case couchbase::bucket_capability::dcp:
+                name = "dcp";
+                break;
+            case couchbase::bucket_capability::cbhello:
+                name = "cbhello";
+                break;
+            case couchbase::bucket_capability::touch:
+                name = "touch";
+                break;
+            case couchbase::bucket_capability::cccp:
+                name = "cccp";
+                break;
+            case couchbase::bucket_capability::xdcr_checkpointing:
+                name = "xdcr_checkpointing";
+                break;
+            case couchbase::bucket_capability::nodes_ext:
+                name = "nodes_ext";
+                break;
+            case couchbase::bucket_capability::collections:
+                name = "collections";
+                break;
+            case couchbase::bucket_capability::durable_write:
+                name = "durable_write";
+                break;
+            case couchbase::bucket_capability::tombstoned_user_xattrs:
+                name = "tombstoned_user_xattrs";
+                break;
+        }
+        return formatter<string_view>::format(name, ctx);
+    }
+};
+
+template<>
+struct fmt::formatter<couchbase::cluster_capability> : formatter<std::string_view> {
+    template<typename FormatContext>
+    auto format(couchbase::cluster_capability type, FormatContext& ctx)
+    {
+        string_view name = "unknown";
+        switch (type) {
+            case couchbase::cluster_capability::n1ql_cost_based_optimizer:
+                name = "n1ql_cost_based_optimizer";
+                break;
+            case couchbase::cluster_capability::n1ql_index_advisor:
+                name = "n1ql_index_advisor";
+                break;
+            case couchbase::cluster_capability::n1ql_javascript_functions:
+                name = "n1ql_javascript_functions";
+                break;
+            case couchbase::cluster_capability::n1ql_inline_functions:
+                name = "n1ql_inline_functions";
+                break;
+            case couchbase::cluster_capability::n1ql_enhanced_prepared_statements:
+                name = "n1ql_enhanced_prepared_statements";
+                break;
+        }
+        return formatter<string_view>::format(name, ctx);
+    }
+};