couchbase 4.2.1 → 4.2.2

package/deps/couchbase-cxx-client/core/impl/get_all_query_indexes.cxx

@@ -0,0 +1,76 @@
+/* -*- 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/manager_error_context.hxx>
+#include <couchbase/query_index_manager.hxx>
+
+#include "core/cluster.hxx"
+#include "core/operations/management/query_index_build.hxx"
+#include "core/operations/management/query_index_get_all.hxx"
+
+namespace couchbase::core::impl
+{
+template<typename Response>
+static manager_error_context
+build_context(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),
+             std::move(resp.ctx.client_context_id),
+             resp.ctx.http_status,
+             std::move(resp.ctx.http_body),
+             std::move(resp.ctx.path) };
+}
+
+void
+initiate_get_all_query_indexes(std::shared_ptr<couchbase::core::cluster> core,
+                               std::string bucket_name,
+                               couchbase::get_all_query_indexes_options::built options,
+                               query_context query_ctx,
+                               std::string collection_name,
+                               get_all_indexes_handler&& handler)
+{
+    core->execute(
+      operations::management::query_index_get_all_request{
+        bucket_name,
+        "",
+        collection_name,
+        query_ctx,
+        {},
+        options.timeout,
+      },
+      [handler = std::move(handler)](operations::management::query_index_get_all_response resp) {
+          if (resp.ctx.ec) {
+              return handler(build_context(resp), {});
+          }
+          handler(build_context(resp), resp.indexes);
+      });
+}
+
+void
+initiate_get_all_query_indexes(std::shared_ptr<couchbase::core::cluster> core,
+                               std::string bucket_name,
+                               couchbase::get_all_query_indexes_options::built options,
+                               get_all_indexes_handler&& handler)
+{
+    initiate_get_all_query_indexes(core, std::move(bucket_name), options, {}, "", std::move(handler));
+}
+
+} // namespace couchbase::core::impl

package/deps/couchbase-cxx-client/core/impl/query.cxx

@@ -168,10 +168,8 @@ build_query_request(query_options::built options)
         options.pipeline_cap,
         options.scan_consistency,
         std::move(options.mutation_state),
-        {},
-        {},
-        std::move(options.scope_qualifier),
         std::move(options.client_context_id),
+        {}, // we put the query_context in later, if one was specified.
         options.timeout,
         options.profile,
     };
@@ -227,15 +225,15 @@ build_transaction_query_request(query_options::built opts)
 void
 initiate_query_operation(std::shared_ptr<couchbase::core::cluster> core,
                          std::string statement,
-                         std::optional<std::string> bucket_name,
-                         std::optional<std::string> scope_name,
+                         std::optional<std::string> query_context,
                          query_options::built options,
                          query_handler&& handler)
 {
     auto request = build_query_request(options);
     request.statement = std::move(statement);
-    request.bucket_name = std::move(bucket_name);
-    request.scope_name = std::move(scope_name);
+    if (query_context) {
+        request.query_context = std::move(query_context);
+    }
 
     core->execute(std::move(request), [core, handler = std::move(handler)](operations::query_response resp) mutable {
         auto r = std::move(resp);

package/deps/couchbase-cxx-client/core/impl/watch_query_indexes.cxx

@@ -0,0 +1,168 @@
+/* -*- 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/error_codes.hxx>
+#include <couchbase/management/query_index.hxx>
+#include <couchbase/query_index_manager.hxx>
+
+#include "core/cluster.hxx"
+#include "core/operations/management/query_index_get_all.hxx"
+
+namespace couchbase::core::impl
+{
+
+template<typename Response>
+static manager_error_context
+build_context(Response& resp, std::optional<std::error_code> ec = {})
+{
+    return { ec ? ec.value() : resp.ctx.ec, resp.ctx.last_dispatched_to,       resp.ctx.last_dispatched_from,
+             resp.ctx.retry_attempts,       std::move(resp.ctx.retry_reasons), std::move(resp.ctx.client_context_id),
+             resp.ctx.http_status,          std::move(resp.ctx.http_body),     std::move(resp.ctx.path) };
+}
+
+class watch_context : public std::enable_shared_from_this<watch_context>
+{
+
+  private:
+    std::shared_ptr<couchbase::core::cluster> core_;
+    std::string bucket_name_;
+    std::vector<std::string> index_names_;
+    couchbase::watch_query_indexes_options::built options_;
+    query_context query_ctx_;
+    std::string collection_name_;
+    watch_query_indexes_handler handler_;
+    asio::steady_timer timer_{ core_->io_context() };
+    std::chrono::steady_clock::time_point start_time_{ std::chrono::steady_clock::now() };
+    std::chrono::milliseconds timeout_{ options_.timeout.value_or(core_->origin().second.options().query_timeout) };
+    std::atomic<size_t> attempts_{ 0 };
+
+    void finish(manager_error_context error_ctx)
+    {
+        handler_(error_ctx);
+        timer_.cancel();
+    }
+    std::chrono::milliseconds remaining()
+    {
+        return timeout_ - std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start_time_);
+    }
+    operations::management::query_index_get_all_request make_request()
+    {
+        return { bucket_name_, "", collection_name_, query_ctx_, {}, remaining() };
+    }
+
+    bool check(couchbase::core::operations::management::query_index_get_all_response resp)
+    {
+        bool complete = true;
+        for (auto name : index_names_) {
+            auto it = std::find_if(resp.indexes.begin(), resp.indexes.end(), [&](const couchbase::management::query::index& index) {
+                return index.name == name;
+            });
+            complete &= (it != resp.indexes.end() && it->state == "online");
+        }
+        if (options_.watch_primary) {
+            auto it = std::find_if(
+              resp.indexes.begin(), resp.indexes.end(), [&](const couchbase::management::query::index& index) { return index.is_primary; });
+            complete &= it != resp.indexes.end() && it->state == "online";
+        }
+        if (complete || resp.ctx.ec == couchbase::errc::common::ambiguous_timeout) {
+            finish(build_context(resp));
+        } else if (remaining().count() <= 0) {
+            finish(build_context(resp, couchbase::errc::common::ambiguous_timeout));
+            complete = true;
+        }
+        return complete;
+    }
+
+    void poll()
+    {
+        timer_.expires_after(options_.polling_interval);
+        auto timer_f = [ctx = shared_from_this()](asio::error_code) { ctx->execute(); };
+        timer_.async_wait(timer_f);
+    }
+
+  public:
+    watch_context(std::shared_ptr<couchbase::core::cluster> core,
+                  std::string bucket_name,
+                  std::vector<std::string> index_names,
+                  couchbase::watch_query_indexes_options::built options,
+                  query_context query_ctx,
+                  std::string collection_name,
+                  watch_query_indexes_handler&& handler)
+      : core_(core)
+      , bucket_name_(bucket_name)
+      , index_names_(index_names)
+      , options_(options)
+      , query_ctx_(query_ctx)
+      , collection_name_(collection_name)
+      , handler_(std::move(handler))
+      , attempts_(0)
+    {
+    }
+    watch_context(watch_context&& other)
+      : core_(std::move(other.core_))
+      , bucket_name_(std::move(other.bucket_name_))
+      , index_names_(std::move(other.index_names_))
+      , options_(std::move(other.options_))
+      , query_ctx_(std::move(other.query_ctx_))
+      , collection_name_(std::move(other.collection_name_))
+      , handler_(std::move(other.handler_))
+      , timer_(std::move(other.timer_))
+      , start_time_(std::move(other.start_time_))
+      , timeout_(std::move(other.timeout_))
+      , attempts_(other.attempts_.load())
+    {
+    }
+
+    void execute()
+    {
+        auto req = make_request();
+        CB_LOG_TRACE("watch indexes executing request");
+        auto resp_fn = [ctx = shared_from_this()](operations::management::query_index_get_all_response resp) {
+            CB_LOG_TRACE("watch indexes got {}", resp.ctx.ec.message());
+            if (!ctx->check(resp)) {
+                // now we try again
+                ctx->poll();
+            }
+        };
+        core_->execute(req, resp_fn);
+    }
+};
+
+void
+initiate_watch_query_indexes(std::shared_ptr<couchbase::core::cluster> core,
+                             std::string bucket_name,
+                             std::vector<std::string> index_names,
+                             couchbase::watch_query_indexes_options::built options,
+                             query_context query_ctx,
+                             std::string collection_name,
+                             watch_query_indexes_handler&& handler)
+{
+    auto ctx = std::make_shared<watch_context>(core, bucket_name, index_names, options, query_ctx, collection_name, std::move(handler));
+    ctx->execute();
+}
+
+void
+initiate_watch_query_indexes(std::shared_ptr<couchbase::core::cluster> core,
+                             std::string bucket_name,
+                             std::vector<std::string> index_names,
+                             couchbase::watch_query_indexes_options::built options,
+                             watch_query_indexes_handler&& handler)
+{
+    initiate_watch_query_indexes(core, std::move(bucket_name), std::move(index_names), options, {}, "", std::move(handler));
+}
+
+} // namespace couchbase::core::impl

package/deps/couchbase-cxx-client/core/io/mcbp_session.cxx

@@ -111,11 +111,22 @@ class mcbp_session_impl
             stopped_.compare_exchange_strong(expected_state, true);
         }
 
+        static auto sasl_mechanisms(const std::shared_ptr<mcbp_session_impl>& session) -> std::vector<std::string>
+        {
+            if (const auto user_mechanisms = session->origin_.credentials().allowed_sasl_mechanisms; user_mechanisms.has_value()) {
+                return user_mechanisms.value();
+            }
+            if (session->is_tls_) {
+                return { "PLAIN" };
+            }
+            return { "SCRAM-SHA512", "SCRAM-SHA256", "SCRAM-SHA1" };
+        }
+
         explicit bootstrap_handler(std::shared_ptr<mcbp_session_impl> session)
           : session_(std::move(session))
           , sasl_([origin = session_->origin_]() { return origin.username(); },
                   [origin = session_->origin_]() { return origin.password(); },
-                  session_->origin_.credentials().allowed_sasl_mechanisms)
+                  sasl_mechanisms(session_))
         {
             protocol::client_request<protocol::hello_request_body> hello_req;
             if (session_->origin_.options().enable_unordered_execution) {
@@ -127,6 +138,9 @@ class mcbp_session_impl
             if (session_->origin_.options().enable_compression) {
                 hello_req.body().enable_compression();
             }
+            if (session_->origin_.options().enable_mutation_tokens) {
+                hello_req.body().enable_mutation_tokens();
+            }
             hello_req.opaque(session_->next_opaque());
             auto user_agent =
               meta::user_agent_for_mcbp(session_->client_id_, session_->id_, session_->origin_.options().user_agent_extra, 250);

package/deps/couchbase-cxx-client/core/logger/configuration.hxx

@@ -10,7 +10,10 @@
  */
 #pragma once
 
+#include "level.hxx"
+
 #include <spdlog/common.h>
+
 #include <string>
 
 namespace couchbase::core::logger

package/deps/couchbase-cxx-client/core/logger/level.hxx

@@ -0,0 +1,21 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2018-Present Couchbase, Inc.
+ *
+ *   Use of this software is governed by the Business Source License included
+ *   in the file licenses/BSL-Couchbase.txt.  As of the Change Date specified
+ *   in that file, in accordance with the Business Source License, use of this
+ *   software will be governed by the Apache License, Version 2.0, included in
+ *   the file licenses/APL2.txt.
+ */
+#pragma once
+
+namespace couchbase::core::logger
+{
+
+/**
+ * the various severity levels we can log at
+ */
+enum class level { trace, debug, info, warn, err, critical, off };
+
+} // namespace couchbase::core::logger

package/deps/couchbase-cxx-client/core/logger/logger.hxx

@@ -25,21 +25,19 @@
 
 #pragma once
 
+#include "level.hxx"
+
 #include <fmt/core.h>
+#include <spdlog/fwd.h>
+
 #include <memory>
 #include <optional>
-#include <spdlog/fwd.h>
 #include <string>
 
 namespace couchbase::core::logger
 {
 struct configuration;
 
-/**
- * the various severity levels we can log at
- */
-enum class level { trace, debug, info, warn, err, critical, off };
-
 level
 level_from_str(const std::string& str);
 

package/deps/couchbase-cxx-client/core/meta/CMakeLists.txt

@@ -7,8 +7,10 @@ target_link_libraries(
           snappy
           fmt::fmt
           spdlog::spdlog)
-target_include_directories(couchbase_meta PRIVATE ${PROJECT_BINARY_DIR}/generated ../..
-        ../../third_party/http_parser)
+target_include_directories(couchbase_meta PRIVATE
+        ${PROJECT_BINARY_DIR}/generated
+        ${PROJECT_SOURCE_DIR}
+        ${PROJECT_SOURCE_DIR}/third_party/http_parser)
 
 if(NOT COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL)
   target_link_libraries(couchbase_meta PUBLIC OpenSSL::SSL OpenSSL::Crypto)

package/deps/couchbase-cxx-client/core/meta/features.hxx

@@ -0,0 +1,31 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2022-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.
+ */
+
+#pragma once
+
+/*
+ * This header defines macros for the various features to help
+ * users adopt early features or use conditional compilation to avoid
+ * unnecessary or untested code.
+ *
+ * Feel free to update this header with more macros.
+ */
+
+/**
+ * couchbase::core::meta::sdk_version() function is available
+ */
+#define COUCHBASE_CXX_CLIENT_HAS_SDK_SEMVER 1

package/deps/couchbase-cxx-client/core/meta/version.cxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *   Copyright 2020-2021 Couchbase, Inc.
+ *   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.
@@ -32,6 +32,8 @@
 #include <snappy-stubs-public.h>
 #include <spdlog/version.h>
 
+#include <regex>
+
 namespace couchbase::core::meta
 {
 std::map<std::string, std::string>
@@ -52,6 +54,7 @@ sdk_build_info()
 #else
     info["snapshot"] = "false";
 #endif
+    info["semver"] = sdk_semver();
     auto txns_forward_compat = core::transactions::forward_compat_supported{};
     info["txns_forward_compat_protocol_version"] =
       fmt::format("{}.{}", txns_forward_compat.protocol_major, txns_forward_compat.protocol_minor);
@@ -140,14 +143,73 @@ sdk_build_info_short()
 const std::string&
 sdk_id()
 {
-    static const std::string identifier{ std::string("cxx/") + std::to_string(COUCHBASE_CXX_CLIENT_VERSION_MAJOR) + "." +
-                                         std::to_string(COUCHBASE_CXX_CLIENT_VERSION_MINOR) + "." +
-                                         std::to_string(COUCHBASE_CXX_CLIENT_VERSION_PATCH) + "/" +
-                                         COUCHBASE_CXX_CLIENT_GIT_REVISION_SHORT + ";" + COUCHBASE_CXX_CLIENT_SYSTEM_NAME + "/" +
+    static const std::string identifier{ sdk_version() + ";" + COUCHBASE_CXX_CLIENT_SYSTEM_NAME + "/" +
                                          COUCHBASE_CXX_CLIENT_SYSTEM_PROCESSOR };
     return identifier;
 }
 
+std::string
+parse_git_describe_output(const std::string& git_describe_output)
+{
+    if (git_describe_output.empty() || git_describe_output == "unknown") {
+        return "";
+    }
+
+    static const std::regex version_regex(R"(^(\d+(?:\.\d+){2})(?:-(\w+(?:\.\w+)*))?(-(\d+)-g(\w+))?$)");
+    std::smatch match;
+    if (std::regex_match(git_describe_output, match, version_regex)) {
+        auto version_core = match[1].str();
+        auto pre_release = match[2].str();
+        auto number_of_commits{ 0 };
+        if (match[4].matched) {
+            number_of_commits = std::stoi(match[4].str());
+        }
+        if (auto build = match[5].str(); !build.empty() && number_of_commits > 0) {
+            if (pre_release.empty()) {
+                return fmt::format("{}+{}.{}", version_core, number_of_commits, build);
+            }
+            return fmt::format("{}-{}+{}.{}", version_core, pre_release, number_of_commits, build);
+        }
+        if (pre_release.empty()) {
+            return fmt::format("{}", version_core);
+        }
+        return fmt::format("{}-{}", version_core, pre_release);
+    }
+
+    return "";
+}
+
+const std::string&
+sdk_semver()
+{
+    static const std::string simple_version{ std::to_string(COUCHBASE_CXX_CLIENT_VERSION_MAJOR) + "." +
+                                             std::to_string(COUCHBASE_CXX_CLIENT_VERSION_MINOR) + "." +
+                                             std::to_string(COUCHBASE_CXX_CLIENT_VERSION_PATCH) + "+" +
+                                             std::string(COUCHBASE_CXX_CLIENT_GIT_REVISION_SHORT) };
+    static const std::string git_describe_output{ COUCHBASE_CXX_CLIENT_GIT_DESCRIBE };
+    static const std::string semantic_version = parse_git_describe_output(git_describe_output);
+    if (semantic_version.empty()) {
+        return simple_version;
+    }
+    return semantic_version;
+}
+
+const std::string&
+sdk_version()
+{
+    static const std::string version{ sdk_version_short() + "/" + COUCHBASE_CXX_CLIENT_GIT_REVISION_SHORT };
+    return version;
+}
+
+const std::string&
+sdk_version_short()
+{
+    static const std::string version{ std::string("cxx/") + std::to_string(COUCHBASE_CXX_CLIENT_VERSION_MAJOR) + "." +
+                                      std::to_string(COUCHBASE_CXX_CLIENT_VERSION_MINOR) + "." +
+                                      std::to_string(COUCHBASE_CXX_CLIENT_VERSION_PATCH) };
+    return version;
+}
+
 const std::string&
 os()
 {

package/deps/couchbase-cxx-client/core/meta/version.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *   Copyright 2020-2021 Couchbase, Inc.
+ *   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.
@@ -20,11 +20,22 @@
 #include <map>
 #include <string>
 
+#include "features.hxx"
+
 namespace couchbase::core::meta
 {
 const std::string&
 sdk_id();
 
+const std::string&
+sdk_semver();
+
+const std::string&
+sdk_version();
+
+const std::string&
+sdk_version_short();
+
 std::map<std::string, std::string>
 sdk_build_info();
 

package/deps/couchbase-cxx-client/core/metrics/CMakeLists.txt

@@ -7,4 +7,7 @@ target_link_libraries(
           hdr_histogram_static
           fmt::fmt
           spdlog::spdlog)
-target_include_directories(couchbase_metrics PRIVATE ../.. ../../third_party/hdr_histogram_c/src)
+target_include_directories(couchbase_metrics PRIVATE
+        ${PROJECT_BINARY_DIR}/generated
+        ${PROJECT_SOURCE_DIR}
+        ${PROJECT_SOURCE_DIR}/third_party/hdr_histogram_c/src)

package/deps/couchbase-cxx-client/core/metrics/logging_meter.cxx

@@ -17,12 +17,16 @@
 
 #include "logging_meter.hxx"
 
+#include "couchbase/build_info.hxx"
+
 #include "core/logger/logger.hxx"
 #include "core/utils/json.hxx"
 #include "noop_meter.hxx"
 
-#include "third_party/hdr_histogram_c/src/hdr_histogram.h"
+#include <hdr_histogram.h>
+
 #include <gsl/assert>
+
 #include <memory>
 #include <utility>
 
@@ -142,7 +146,7 @@ logging_meter::log_report() const
           {
 
             { "emit_interval_s", std::chrono::duration_cast<std::chrono::seconds>(options_.emit_interval).count() },
-#if BACKEND_DEBUG_BUILD
+#if COUCHBASE_CXX_CLIENT_DEBUG_BUILD
             { "emit_interval_ms", options_.emit_interval.count() },
 #endif
           },
@@ -158,22 +162,59 @@ logging_meter::log_report() const
     }
 }
 
+logging_meter::logging_meter(asio::io_context& ctx, logging_meter_options options)
+  : emit_report_(ctx)
+  , options_(options)
+{
+}
+
+logging_meter::~logging_meter()
+{
+    emit_report_.cancel();
+    log_report();
+}
+
+void
+logging_meter::rearm_reporter()
+{
+    emit_report_.expires_after(options_.emit_interval);
+    emit_report_.async_wait([self = shared_from_this()](std::error_code ec) {
+        if (ec == asio::error::operation_aborted) {
+            return;
+        }
+        self->log_report();
+        self->rearm_reporter();
+    });
+}
+
+void
+logging_meter::start()
+{
+    rearm_reporter();
+}
+
+void
+logging_meter::stop()
+{
+    emit_report_.cancel();
+}
+
 std::shared_ptr<couchbase::metrics::value_recorder>
 logging_meter::get_value_recorder(const std::string& name, const std::map<std::string, std::string>& tags)
 {
     static std::shared_ptr<noop_value_recorder> noop_recorder{ std::make_shared<noop_value_recorder>() };
 
-    if (static std::string meter_name = "db.couchbase.operations"; name != meter_name) {
+    if (static const std::string meter_name = "db.couchbase.operations"; name != meter_name) {
         return noop_recorder;
     }
 
-    static std::string service_tag = "db.couchbase.service";
+    static const std::string service_tag = "db.couchbase.service";
     auto service = tags.find(service_tag);
     if (service == tags.end()) {
         return noop_recorder;
     }
 
-    static std::string operation_tag = "db.operation";
+    static const std::string operation_tag = "db.operation";
     auto operation = tags.find(operation_tag);
     if (operation == tags.end()) {
         return noop_recorder;