couchbase 3.0.0.beta.1 → 3.1.0

data/ext/cmake/BuildTracing.cmake

@@ -0,0 +1,6 @@
+if(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
+  option(ENABLE_BUILD_WITH_TIME_TRACE "Enable -ftime-trace to generate time tracing .json files on clang" OFF)
+  if(ENABLE_BUILD_WITH_TIME_TRACE)
+    target_compile_options(project_options INTERFACE -ftime-trace)
+  endif()
+endif()

data/ext/cmake/Cache.cmake

@@ -0,0 +1,29 @@
+option(ENABLE_CACHE "Enable cache if available" ON)
+if(NOT ENABLE_CACHE)
+  return()
+endif()
+
+set(CACHE_OPTION
+    "ccache"
+    CACHE STRING "Compiler cache to be used")
+set(CACHE_OPTION_VALUES "ccache" "sccache")
+set_property(CACHE CACHE_OPTION PROPERTY STRINGS ${CACHE_OPTION_VALUES})
+list(
+  FIND
+  CACHE_OPTION_VALUES
+  ${CACHE_OPTION}
+  CACHE_OPTION_INDEX)
+
+if(${CACHE_OPTION_INDEX} EQUAL -1)
+  message(
+    STATUS
+      "Using custom compiler cache system: '${CACHE_OPTION}', explicitly supported entries are ${CACHE_OPTION_VALUES}")
+endif()
+
+find_program(CACHE_BINARY ${CACHE_OPTION})
+if(CACHE_BINARY)
+  message(STATUS "${CACHE_OPTION} found and enabled")
+  set(CMAKE_CXX_COMPILER_LAUNCHER ${CACHE_BINARY})
+else()
+  message(WARNING "${CACHE_OPTION} is enabled but was not found. Not using it")
+endif()

data/ext/cmake/CompilerWarnings.cmake

@@ -0,0 +1,84 @@
+# 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
+      /w14242 # '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
+      /w14619 # 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/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/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,49 @@
+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} "${CMAKE_SOURCE_DIR}/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} "${CMAKE_SOURCE_DIR}/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()
+
+  add_subdirectory(${CMAKE_SOURCE_DIR}/test)
+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

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *     Copyright 2020 Couchbase, Inc.
+ *   Copyright 2020-2021 Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -17,8 +17,8 @@
 
 #pragma once
 
-#include <utility>
 #include <queue>
+#include <utility>
 
 #include <operations.hxx>
 #include <origin.hxx>
@@ -42,6 +42,7 @@ class bucket : public std::enable_shared_from_this<bucket>
       , origin_(std::move(origin))
       , known_features_(known_features)
     {
+        log_prefix_ = fmt::format("[{}/{}]", client_id_, name_);
     }
 
     ~bucket()
@@ -54,6 +55,148 @@ class bucket : public std::enable_shared_from_this<bucket>
         return name_;
     }
 
+    /**
+     * copies nodes from rhs that are not in lhs to output vector
+     */
+    static void diff_nodes(const std::vector<configuration::node>& lhs,
+                           const std::vector<configuration::node>& rhs,
+                           std::vector<configuration::node>& output)
+    {
+        for (const auto& re : rhs) {
+            bool known = false;
+            for (const auto& le : lhs) {
+                if (le.hostname == re.hostname && le.services_plain.management.value_or(0) == re.services_plain.management.value_or(0)) {
+                    known = true;
+                    break;
+                }
+            }
+            if (!known) {
+                output.push_back(re);
+            }
+        }
+    }
+
+    void update_config(const configuration& config)
+    {
+        if (!config_) {
+            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;
+        }
+
+        std::vector<configuration::node> added{};
+        std::vector<configuration::node> removed{};
+        if (config_) {
+            diff_nodes(config_->nodes, config.nodes, added);
+            diff_nodes(config.nodes, config_->nodes, removed);
+        } else {
+            added = config.nodes;
+        }
+        config_ = config;
+        if (!added.empty() || removed.empty()) {
+            std::map<size_t, std::shared_ptr<io::mcbp_session>> new_sessions{};
+
+            for (auto entry : sessions_) {
+                std::size_t new_index = config.nodes.size() + 1;
+                for (const auto& node : config.nodes) {
+                    if (entry.second->bootstrap_hostname() == node.hostname_for(origin_.options().network) &&
+                        entry.second->bootstrap_port() ==
+                          std::to_string(node.port_or(origin_.options().network, service_type::kv, origin_.options().enable_tls, 0))) {
+                        new_index = node.index;
+                        break;
+                    }
+                }
+                if (new_index < config.nodes.size()) {
+                    spdlog::debug(R"({} rev={}, preserve session="{}", address="{}:{}")",
+                                  log_prefix_,
+                                  config.rev_str(),
+                                  entry.second->id(),
+                                  entry.second->bootstrap_hostname(),
+                                  entry.second->bootstrap_port());
+                    new_sessions.emplace(new_index, std::move(entry.second));
+                } else {
+                    spdlog::debug(R"({} rev={}, drop session="{}", address="{}:{}")",
+                                  log_prefix_,
+                                  config.rev_str(),
+                                  entry.second->id(),
+                                  entry.second->bootstrap_hostname(),
+                                  entry.second->bootstrap_port());
+                    entry.second.reset();
+                }
+            }
+
+            for (const auto& node : config.nodes) {
+                if (new_sessions.find(node.index) != new_sessions.end()) {
+                    continue;
+                }
+
+                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) {
+                    session = std::make_shared<io::mcbp_session>(client_id_, ctx_, tls_, origin, name_, known_features_);
+                } 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_str(), session->id(), hostname, port);
+                session->bootstrap(
+                  [self = shared_from_this(), session](std::error_code err, const configuration& cfg) {
+                      if (!err) {
+                          self->update_config(cfg);
+                          session->on_configuration_update([self](const configuration& new_config) { self->update_config(new_config); });
+                          session->on_stop([index = session->index(), self](io::retry_reason reason) {
+                              if (reason == io::retry_reason::socket_closed_while_in_flight) {
+                                  self->restart_node(index);
+                              }
+                          });
+                      }
+                  },
+                  true);
+                new_sessions.emplace(node.index, std::move(session));
+            }
+            sessions_ = new_sessions;
+        }
+    }
+
+    void restart_node(std::size_t index)
+    {
+        auto ptr = sessions_.find(index);
+        if (ptr == sessions_.end()) {
+            spdlog::debug(R"({} requested to restart session idx={}, which does not exist, ignoring)", log_prefix_, index);
+            return;
+        }
+        auto& old_session = ptr->second;
+        auto hostname = old_session->bootstrap_hostname();
+        auto port = old_session->bootstrap_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;
+        if (origin_.options().enable_tls) {
+            session = std::make_shared<io::mcbp_session>(client_id_, ctx_, tls_, origin, name_, known_features_);
+        } 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) {
+                  self->update_config(config);
+                  session->on_configuration_update([self](const configuration& new_config) { self->update_config(new_config); });
+              }
+          },
+          true);
+        sessions_.emplace(index, std::move(session));
+    }
+
     template<typename Handler>
     void bootstrap(Handler&& handler)
     {
@@ -66,55 +209,61 @@ class bucket : public std::enable_shared_from_this<bucket>
         new_session->bootstrap([self = shared_from_this(), new_session, h = std::forward<Handler>(handler)](
                                  std::error_code ec, const configuration& cfg) mutable {
             if (!ec) {
-                self->config_ = cfg;
                 size_t this_index = new_session->index();
-                self->sessions_.emplace(this_index, std::move(new_session));
-                if (cfg.nodes.size() > 1) {
-                    for (const auto& n : cfg.nodes) {
-                        if (n.index != this_index) {
-                            couchbase::origin origin(
-                              self->origin_.get_username(),
-                              self->origin_.get_password(),
-                              n.hostname_for(self->origin_.options().network),
-                              n.port_or(self->origin_.options().network, service_type::kv, self->origin_.options().enable_tls, 0),
-                              self->origin_.options());
-                            std::shared_ptr<io::mcbp_session> s;
-                            if (self->origin_.options().enable_tls) {
-                                s = std::make_shared<io::mcbp_session>(
-                                  self->client_id_, self->ctx_, self->tls_, origin, self->name_, self->known_features_);
-                            } else {
-                                s = std::make_shared<io::mcbp_session>(
-                                  self->client_id_, self->ctx_, origin, self->name_, self->known_features_);
-                            }
-                            s->bootstrap([host = n.hostname, bucket = self->name_](std::error_code err, const configuration& /*config*/) {
-                                // TODO: retry, we know that auth is correct
-                                if (err) {
-                                    spdlog::warn("unable to bootstrap node {} ({}): {}", host, bucket, err.message());
-                                }
-                            });
-                            self->sessions_.emplace(n.index, std::move(s));
-                        }
+                new_session->on_configuration_update([self](const configuration& config) { self->update_config(config); });
+                new_session->on_stop([this_index, self](io::retry_reason reason) {
+                    if (reason == io::retry_reason::socket_closed_while_in_flight) {
+                        self->restart_node(this_index);
                     }
-                }
-                while (!self->deferred_commands_.empty()) {
-                    self->deferred_commands_.front()();
-                    self->deferred_commands_.pop();
-                }
+                });
+
+                self->sessions_.emplace(this_index, std::move(new_session));
+                self->update_config(cfg);
+                self->drain_deferred_queue();
             }
             h(ec, cfg);
         });
     }
 
+    void drain_deferred_queue()
+    {
+        while (!deferred_commands_.empty()) {
+            deferred_commands_.front()();
+            deferred_commands_.pop();
+        }
+    }
+
     template<typename Request, typename Handler>
     void execute(Request request, Handler&& handler)
     {
         if (closed_) {
             return;
         }
-        auto cmd = std::make_shared<operations::mcbp_command<Request>>(ctx_, request);
+        auto cmd = std::make_shared<operations::mcbp_command<bucket, Request>>(ctx_, shared_from_this(), request);
         cmd->start([cmd, handler = std::forward<Handler>(handler)](std::error_code ec, std::optional<io::mcbp_message> msg) mutable {
             using encoded_response_type = typename Request::encoded_response_type;
-            handler(make_response(ec, cmd->request, msg ? encoded_response_type(*msg) : encoded_response_type{}));
+            auto resp = msg ? encoded_response_type(*msg) : encoded_response_type{};
+            error_context::key_value ctx{};
+            ctx.id = cmd->request.id;
+            ctx.opaque = resp.opaque();
+            ctx.ec = ec;
+            if (ctx.ec && ctx.opaque == 0) {
+                ctx.opaque = cmd->request.opaque;
+            }
+            if (msg) {
+                ctx.status_code = resp.status();
+            }
+            ctx.retry_attempts = cmd->request.retries.retry_attempts;
+            ctx.retry_reasons = cmd->request.retries.reasons;
+            if (cmd->session_) {
+                ctx.last_dispatched_from = cmd->session_->local_address();
+                ctx.last_dispatched_to = cmd->session_->remote_address();
+                if (msg) {
+                    ctx.error_map_info = cmd->session_->decode_error_code(msg->header.status());
+                }
+            }
+            ctx.enhanced_error_info = resp.error_info();
+            handler(make_response(std::move(ctx), cmd->request, std::move(resp)));
         });
         if (config_) {
             map_and_send(cmd);
@@ -129,20 +278,79 @@ class bucket : public std::enable_shared_from_this<bucket>
             return;
         }
         closed_ = true;
+
+        drain_deferred_queue();
         for (auto& session : sessions_) {
-            session.second->stop();
+            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);
+            }
         }
     }
 
     template<typename Request>
-    void map_and_send(std::shared_ptr<operations::mcbp_command<Request>> cmd)
+    void map_and_send(std::shared_ptr<operations::mcbp_command<bucket, Request>> cmd)
     {
-        size_t index = 0;
-        std::tie(cmd->request.partition, index) = config_->map_key(cmd->request.id.key);
-        auto session = sessions_.at(index);
+        if (closed_) {
+            return cmd->cancel(io::retry_reason::do_not_retry);
+        }
+        std::int16_t index = 0;
+        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));
+            }
+        }
+        auto session = sessions_.at(static_cast<std::size_t>(index));
+        if (session->is_stopped()) {
+            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(session);
     }
 
+    template<typename Request>
+    void schedule_for_retry(std::shared_ptr<operations::mcbp_command<bucket, Request>> cmd, std::chrono::milliseconds duration)
+    {
+        if (closed_) {
+            return cmd->cancel(io::retry_reason::do_not_retry);
+        }
+        cmd->retry_backoff.expires_after(duration);
+        cmd->retry_backoff.async_wait([self = shared_from_this(), cmd](std::error_code ec) mutable {
+            if (ec == asio::error::operation_aborted) {
+                return;
+            }
+            self->map_and_send(cmd);
+        });
+    }
+
+    [[nodiscard]] const std::string& log_prefix()
+    {
+        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());
+        }
+    }
+
+    template<typename Collector>
+    void ping(std::shared_ptr<Collector> collector)
+    {
+        for (const auto& session : sessions_) {
+            session.second->ping(collector->build_reporter());
+        }
+    }
+
   private:
     std::string client_id_;
     asio::io_context& ctx_;
@@ -157,5 +365,8 @@ 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_{};
 };
 } // namespace couchbase