couchbase 4.0.0 → 4.1.2

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/io/mcbp_session.hxx

@@ -47,7 +47,6 @@
 #include <couchbase/sasl/client.h>
 #include <couchbase/sasl/error.h>
 #include <couchbase/sasl/error_fmt.h>
-#include <couchbase/timeout_defaults.hxx>
 #include <couchbase/topology/capabilities_fmt.hxx>
 #include <couchbase/topology/configuration_fmt.hxx>
 #include <couchbase/utils/join_strings.hxx>
@@ -139,11 +138,12 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
                 hello_req.body().enable_compression();
             }
             hello_req.opaque(session_->next_opaque());
-            hello_req.body().user_agent(
-              meta::user_agent_for_mcbp(session_->client_id_, session_->id_, session_->origin_.options().user_agent_extra, 250));
+            auto user_agent =
+              meta::user_agent_for_mcbp(session_->client_id_, session_->id_, session_->origin_.options().user_agent_extra, 250);
+            hello_req.body().user_agent(user_agent);
             LOG_DEBUG("{} user_agent={}, requested_features=[{}]",
                       session_->log_prefix_,
-                      hello_req.body().user_agent(),
+                      user_agent,
                       utils::join_strings_fmt("{}", hello_req.body().features(), ", "));
             session_->write(hello_req.data());
 
@@ -301,7 +301,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
                                             session_->log_prefix_,
                                             resp.error_message(),
                                             resp.opaque(),
-                                            spdlog::to_hex(msg.header_data()));
+                                            spdlog::to_hex(resp.header()));
                                 return complete(error::network_errc::protocol_error);
                             }
                         } break;
@@ -328,7 +328,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
                                             session_->log_prefix_,
                                             resp.error_message(),
                                             resp.opaque(),
-                                            spdlog::to_hex(msg.header_data()));
+                                            spdlog::to_hex(resp.header()));
                                 return complete(error::common_errc::bucket_not_found);
                             }
                         } break;
@@ -358,7 +358,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
                                             session_->log_prefix_,
                                             resp.error_message(),
                                             resp.opaque(),
-                                            spdlog::to_hex(msg.header_data()));
+                                            spdlog::to_hex(resp.header()));
                                 return complete(error::network_errc::protocol_error);
                             }
                         } break;
@@ -406,7 +406,9 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         }
     };
 
-    class normal_handler : public message_handler
+    class normal_handler
+      : public message_handler
+      , public std::enable_shared_from_this<normal_handler>
     {
       private:
         std::shared_ptr<mcbp_session> session_;
@@ -414,11 +416,18 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         std::atomic_bool stopped_{ false };
 
       public:
-        ~normal_handler() override = default;
+        ~normal_handler() override
+        {
+            stop();
+        }
 
         explicit normal_handler(std::shared_ptr<mcbp_session> session)
           : session_(session)
           , heartbeat_timer_(session_->ctx_)
+        {
+        }
+
+        void start()
         {
             if (session_->supports_gcccp_) {
                 fetch_config({});
@@ -560,11 +569,11 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
             req.opaque(session_->next_opaque());
             session_->write_and_flush(req.data());
             heartbeat_timer_.expires_after(std::chrono::milliseconds(2500));
-            heartbeat_timer_.async_wait([this](std::error_code e) {
+            heartbeat_timer_.async_wait([self = shared_from_this()](std::error_code e) {
                 if (e == asio::error::operation_aborted) {
                     return;
                 }
-                fetch_config(e);
+                self->fetch_config(e);
             });
         }
     };
@@ -658,7 +667,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         protocol::client_request<protocol::mcbp_noop_request_body> req;
         req.opaque(next_opaque());
         write_and_subscribe(req.opaque(),
-                            req.data(false),
+                            std::move(req.data(false)),
                             [start = std::chrono::steady_clock::now(), self = shared_from_this(), handler](
                               std::error_code ec, retry_reason reason, io::mcbp_message&& /* msg */) {
                                 diag::ping_state state = diag::ping_state::ok;
@@ -740,9 +749,12 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
                                   bootstrap_hostname_,
                                   bootstrap_port_);
         LOG_DEBUG("{} attempt to establish MCBP connection", log_prefix_);
-        resolver_.async_resolve(bootstrap_hostname_,
-                                bootstrap_port_,
-                                std::bind(&mcbp_session::on_resolve, shared_from_this(), std::placeholders::_1, std::placeholders::_2));
+
+        async_resolve(origin_.options().use_ip_protocol,
+                      resolver_,
+                      bootstrap_hostname_,
+                      bootstrap_port_,
+                      std::bind(&mcbp_session::on_resolve, shared_from_this(), std::placeholders::_1, std::placeholders::_2));
     }
 
     [[nodiscard]] const std::string& id() const
@@ -780,6 +792,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         }
         if (handler_) {
             handler_->stop();
+            handler_ = nullptr;
         }
         {
             std::scoped_lock lock(command_handlers_mutex_);
@@ -800,7 +813,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         state_ = diag::endpoint_state::disconnected;
     }
 
-    void write(const std::vector<uint8_t>& buf)
+    void write(std::vector<std::byte>&& buf)
     {
         if (stopped_) {
             return;
@@ -809,7 +822,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         std::memcpy(&opaque, buf.data() + 12, sizeof(opaque));
         LOG_TRACE("{} MCBP send, opaque={}, {:n}", log_prefix_, opaque, spdlog::to_hex(buf.begin(), buf.begin() + 24));
         std::scoped_lock lock(output_buffer_mutex_);
-        output_buffer_.push_back(buf);
+        output_buffer_.emplace_back(std::move(buf));
     }
 
     void flush()
@@ -820,17 +833,17 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         do_write();
     }
 
-    void write_and_flush(const std::vector<uint8_t>& buf)
+    void write_and_flush(std::vector<std::byte>&& buf)
     {
         if (stopped_) {
             return;
         }
-        write(buf);
+        write(std::move(buf));
         flush();
     }
 
-    void write_and_subscribe(uint32_t opaque,
-                             std::vector<std::uint8_t>& data,
+    void write_and_subscribe(std::uint32_t opaque,
+                             std::vector<std::byte>&& data,
                              std::function<void(std::error_code, retry_reason, io::mcbp_message&&)> handler)
     {
         if (stopped_) {
@@ -843,14 +856,14 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
             command_handlers_.try_emplace(opaque, std::move(handler));
         }
         if (bootstrapped_ && stream_->is_open()) {
-            write_and_flush(data);
+            write_and_flush(std::move(data));
         } else {
             LOG_DEBUG("{} the stream is not ready yet, put the message into pending buffer, opaque={}", log_prefix_, opaque);
             std::scoped_lock lock(pending_buffer_mutex_);
             if (bootstrapped_ && stream_->is_open()) {
-                write_and_flush(data);
+                write_and_flush(std::move(data));
             } else {
-                pending_buffer_.push_back(data);
+                pending_buffer_.emplace_back(data);
             }
         }
     }
@@ -978,7 +991,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
                 }
             }
         }
-        config_.emplace(config);
+        config_.emplace(std::move(config));
         configured_ = true;
         LOG_DEBUG("{} received new configuration: {}", log_prefix_, config_.value());
         for (const auto& listener : config_listeners_) {
@@ -986,7 +999,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         }
     }
 
-    void handle_not_my_vbucket(io::mcbp_message&& msg)
+    void handle_not_my_vbucket(const io::mcbp_message& msg)
     {
         if (stopped_) {
             return;
@@ -994,7 +1007,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         Expects(msg.header.magic == static_cast<std::uint8_t>(protocol::magic::alt_client_response) ||
                 msg.header.magic == static_cast<std::uint8_t>(protocol::magic::client_response));
         if (protocol::has_json_datatype(msg.header.datatype)) {
-            auto magic = protocol::magic(msg.header.magic);
+            auto magic = static_cast<protocol::magic>(msg.header.magic);
             uint8_t extras_size = msg.header.extlen;
             uint8_t framing_extras_size = 0;
             uint16_t key_size = utils::byte_swap(msg.header.keylen);
@@ -1005,8 +1018,9 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
 
             std::vector<uint8_t>::difference_type offset = framing_extras_size + key_size + extras_size;
             if (utils::byte_swap(msg.header.bodylen) - offset > 0) {
-                auto config =
-                  protocol::parse_config(std::string(msg.body.begin() + offset, msg.body.end()), endpoint_address_, endpoint_.port());
+                std::string_view config_text{ reinterpret_cast<const char*>(msg.body.data()) + offset,
+                                              msg.body.size() - static_cast<std::size_t>(offset) };
+                auto config = protocol::parse_config(config_text, endpoint_address_, endpoint_.port());
                 LOG_DEBUG("{} received not_my_vbucket status for {}, opaque={} with config rev={} in the payload",
                           log_prefix_,
                           protocol::client_opcode(msg.header.opcode),
@@ -1051,12 +1065,16 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
             return stop(retry_reason::node_not_available);
         }
         state_ = diag::endpoint_state::connected;
-        handler_ = std::make_unique<normal_handler>(shared_from_this());
+        {
+            auto handler = std::make_shared<normal_handler>(shared_from_this());
+            handler->start();
+            handler_ = handler;
+        }
         std::scoped_lock lock(pending_buffer_mutex_);
         bootstrapped_ = true;
         if (!pending_buffer_.empty()) {
-            for (const auto& buf : pending_buffer_) {
-                write(buf);
+            for (auto& buf : pending_buffer_) {
+                write(std::move(buf));
             }
             pending_buffer_.clear();
             flush();
@@ -1065,7 +1083,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
 
     void on_resolve(std::error_code ec, const asio::ip::tcp::resolver::results_type& endpoints)
     {
-        if (stopped_) {
+        if (ec == asio::error::operation_aborted || stopped_) {
             return;
         }
         last_active_ = std::chrono::steady_clock::now();
@@ -1075,8 +1093,13 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         }
         endpoints_ = endpoints;
         do_connect(endpoints_.begin());
-        connection_deadline_.expires_after(timeout_defaults::connect_timeout);
-        connection_deadline_.async_wait(std::bind(&mcbp_session::check_deadline, shared_from_this(), std::placeholders::_1));
+        connection_deadline_.expires_after(origin_.options().resolve_timeout);
+        connection_deadline_.async_wait([self = shared_from_this()](const auto timer_ec) {
+            if (timer_ec == asio::error::operation_aborted || self->stopped_) {
+                return;
+            }
+            return self->stream_->close([self](std::error_code) { self->initiate_bootstrap(); });
+        });
     }
 
     void do_connect(asio::ip::tcp::resolver::results_type::iterator it)
@@ -1086,8 +1109,18 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         }
         last_active_ = std::chrono::steady_clock::now();
         if (it != endpoints_.end()) {
-            LOG_DEBUG("{} connecting to {}:{}", log_prefix_, it->endpoint().address().to_string(), it->endpoint().port());
-            connection_deadline_.expires_after(timeout_defaults::connect_timeout);
+            LOG_DEBUG("{} connecting to {}:{}, timeout={}ms",
+                      log_prefix_,
+                      it->endpoint().address().to_string(),
+                      it->endpoint().port(),
+                      origin_.options().connect_timeout.count());
+            connection_deadline_.expires_after(origin_.options().connect_timeout);
+            connection_deadline_.async_wait([self = shared_from_this()](const auto timer_ec) {
+                if (timer_ec == asio::error::operation_aborted || self->stopped_) {
+                    return;
+                }
+                return self->stream_->close([self](std::error_code) { self->initiate_bootstrap(); });
+            });
             stream_->async_connect(it->endpoint(), std::bind(&mcbp_session::on_connect, shared_from_this(), std::placeholders::_1, it));
         } else {
             LOG_ERROR("{} no more endpoints left to connect, will try another address", log_prefix_);
@@ -1097,7 +1130,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
 
     void on_connect(const std::error_code& ec, asio::ip::tcp::resolver::results_type::iterator it)
     {
-        if (stopped_) {
+        if (ec == asio::error::operation_aborted || stopped_) {
             return;
         }
         last_active_ = std::chrono::steady_clock::now();
@@ -1132,7 +1165,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
                                       bootstrap_hostname_,
                                       endpoint_address_,
                                       endpoint_.port());
-            handler_ = std::make_unique<bootstrap_handler>(shared_from_this());
+            handler_ = std::make_shared<bootstrap_handler>(shared_from_this());
             connection_deadline_.expires_at(asio::steady_timer::time_point::max());
             connection_deadline_.cancel();
         }
@@ -1254,7 +1287,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
     couchbase::origin origin_;
     std::optional<std::string> bucket_name_;
     mcbp_parser parser_;
-    std::unique_ptr<message_handler> handler_;
+    std::shared_ptr<message_handler> handler_;
     utils::movable_function<void(std::error_code, const topology::configuration&)> bootstrap_handler_{};
     std::mutex command_handlers_mutex_{};
     std::map<uint32_t, utils::movable_function<void(std::error_code, retry_reason, io::mcbp_message&&)>> command_handlers_{};
@@ -1270,10 +1303,10 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
 
     std::atomic<std::uint32_t> opaque_{ 0 };
 
-    std::array<std::uint8_t, 16384> input_buffer_{};
-    std::vector<std::vector<std::uint8_t>> output_buffer_{};
-    std::vector<std::vector<std::uint8_t>> pending_buffer_{};
-    std::vector<std::vector<std::uint8_t>> writing_buffer_{};
+    std::array<std::byte, 16384> input_buffer_{};
+    std::vector<std::vector<std::byte>> output_buffer_{};
+    std::vector<std::vector<std::byte>> pending_buffer_{};
+    std::vector<std::vector<std::byte>> writing_buffer_{};
     std::mutex output_buffer_mutex_{};
     std::mutex pending_buffer_mutex_{};
     std::mutex writing_buffer_mutex_{};

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/io/mcbp_traits.hxx

@@ -0,0 +1,30 @@
+/* -*- 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.
+ */
+
+#pragma once
+
+#include <type_traits>
+
+namespace couchbase::io::mcbp_traits
+{
+template<typename T>
+struct supports_durability : public std::false_type {
+};
+
+template<typename T>
+inline constexpr bool supports_durability_v = supports_durability<T>::value;
+} // namespace couchbase::io::mcbp_traits

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/io/streams.hxx

@@ -17,13 +17,35 @@
 
 #pragma once
 
+#include <couchbase/io/ip_protocol.hxx>
+
 #include <asio.hpp>
 #include <asio/ssl.hpp>
+
 #include <functional>
 
 namespace couchbase::io
 {
 
+template<typename Resolver, typename Handler>
+static void
+async_resolve(ip_protocol protocol, Resolver& resolver, const std::string& hostname, const std::string& service, Handler&& handler)
+{
+
+    switch (protocol) {
+        case ip_protocol::force_ipv4:
+            return resolver.async_resolve(asio::ip::tcp::v4(), hostname, service, std::forward<Handler>(handler));
+        case ip_protocol::force_ipv6:
+            return resolver.async_resolve(asio::ip::tcp::v6(), hostname, service, std::forward<Handler>(handler));
+        case ip_protocol::any:
+            /* fall-through */
+        default:
+            /* use any protocol */
+            break;
+    }
+    return resolver.async_resolve(hostname, service, std::forward<Handler>(handler));
+}
+
 class stream_impl
 {
   protected:

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

@@ -47,6 +47,11 @@ struct configuration {
      * The default log level to initialize the logger to
      */
     level log_level{ level::info };
+
+    /**
+     * Custom sink to use, if desired
+     */
+    std::shared_ptr<spdlog::sinks::sink> sink{ nullptr };
 };
 
 } // namespace couchbase::logger

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/logger/logger.cxx

@@ -68,8 +68,7 @@ translate_level(level level)
 level
 level_from_str(const std::string& str)
 {
-    auto level = spdlog::level::from_str(str);
-    switch (level) {
+    switch (spdlog::level::from_str(str)) {
         case spdlog::level::level_enum::trace:
             return level::trace;
         case spdlog::level::level_enum::debug:
@@ -211,6 +210,10 @@ create_file_logger(const configuration& logger_settings)
             }
             sink->add_sink(stderrsink);
         }
+        if (nullptr != logger_settings.sink) {
+            logger_settings.sink->set_pattern(log_pattern);
+            sink->add_sink(logger_settings.sink);
+        }
 
         spdlog::drop(logger_name);
 

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

@@ -128,14 +128,14 @@ unregister_spdlog_logger(const std::string& n);
  * @return true if all registered loggers have the specified severity level
  */
 bool
-check_log_levels(level level);
+check_log_levels(level lvl);
 
 /**
  * Set the log level of all registered spdLoggers
  * @param log severity level
  */
 void
-set_log_levels(level level);
+set_log_levels(level lvl);
 
 /**
  * Checks whether a specific level should be logged based on the current

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/management/CMakeLists.txt

@@ -0,0 +1,13 @@
+add_library(
+  couchbase_management OBJECT
+  analytics_link_azure_blob_external.cxx
+  analytics_link_couchbase_remote.cxx
+  analytics_link_s3_external.cxx)
+set_target_properties(couchbase_management PROPERTIES POSITION_INDEPENDENT_CODE ON)
+target_link_libraries(
+  couchbase_management
+  PRIVATE project_options
+          project_warnings
+          fmt::fmt
+          spdlog::spdlog)
+target_include_directories(couchbase_management PRIVATE ${PROJECT_SOURCE_DIR})

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/management/analytics_dataset.hxx

@@ -0,0 +1,30 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   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.
+ *   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 <string>
+
+namespace couchbase::management::analytics
+{
+struct dataset {
+    std::string name;
+    std::string dataverse_name;
+    std::string link_name;
+    std::string bucket_name;
+};
+} // namespace couchbase::management::analytics

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/management/analytics_index.hxx

@@ -0,0 +1,30 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   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.
+ *   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 <string>
+
+namespace couchbase::management::analytics
+{
+struct index {
+    std::string name;
+    std::string dataverse_name;
+    std::string dataset_name;
+    bool is_primary;
+};
+} // namespace couchbase::management::analytics

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/management/analytics_link.hxx

@@ -0,0 +1,22 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   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.
+ *   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 <couchbase/management/analytics_link_azure_blob_external.hxx>
+#include <couchbase/management/analytics_link_couchbase_remote.hxx>
+#include <couchbase/management/analytics_link_s3_external.hxx>

package/deps/{couchbase-cxx-client/couchbase/operations → couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase}/management/analytics_link_azure_blob_external.cxx

@@ -15,17 +15,17 @@
  *   limitations under the License.
  */
 
-#include <couchbase/operations/management/analytics_link_azure_blob_external.hxx>
+#include <couchbase/management/analytics_link_azure_blob_external.hxx>
 
 #include <couchbase/errors.hxx>
 #include <couchbase/utils/url_codec.hxx>
 
 #include <algorithm>
 
-namespace couchbase::operations::management
+namespace couchbase::management::analytics
 {
 std::error_code
-analytics_link::azure_blob_external::validate() const
+azure_blob_external_link::validate() const
 {
     if (dataverse.empty() || link_name.empty()) {
         return error::common_errc::invalid_argument;
@@ -37,7 +37,7 @@ analytics_link::azure_blob_external::validate() const
 }
 
 std::string
-analytics_link::azure_blob_external::encode() const
+azure_blob_external_link::encode() const
 {
     std::map<std::string, std::string> values{
         { "type", "azureblob" },
@@ -64,4 +64,4 @@ analytics_link::azure_blob_external::encode() const
     }
     return utils::string_codec::v2::form_encode(values);
 }
-} // namespace couchbase::operations::management
+} // namespace couchbase::management::analytics

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/{operations/management → management}/analytics_link_azure_blob_external.hxx

@@ -21,13 +21,13 @@
 #include <string>
 #include <system_error>
 
-namespace couchbase::operations::management::analytics_link
+namespace couchbase::management::analytics
 {
 /**
  * An external analytics link which uses the Microsoft Azure Blob Storage service.
  * Only available as of 7.0 Developer Preview.
  */
-struct azure_blob_external {
+struct azure_blob_external_link {
     /**
      * The name of this link.
      */
@@ -73,4 +73,4 @@ struct azure_blob_external {
 
     [[nodiscard]] std::string encode() const;
 };
-} // namespace couchbase::operations::management::analytics_link
+} // namespace couchbase::management::analytics

package/deps/{couchbase-cxx-client/couchbase/operations → couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase}/management/analytics_link_azure_blob_external_json.hxx

@@ -17,18 +17,18 @@
 
 #pragma once
 
-#include <couchbase/operations/management/analytics_link_azure_blob_external.hxx>
+#include <couchbase/management/analytics_link_azure_blob_external.hxx>
 
 #include <tao/json/forward.hpp>
 
 namespace tao::json
 {
 template<>
-struct traits<couchbase::operations::management::analytics_link::azure_blob_external> {
+struct traits<couchbase::management::analytics::azure_blob_external_link> {
     template<template<typename...> class Traits>
-    static couchbase::operations::management::analytics_link::azure_blob_external as(const tao::json::basic_value<Traits>& v)
+    static couchbase::management::analytics::azure_blob_external_link as(const tao::json::basic_value<Traits>& v)
     {
-        couchbase::operations::management::analytics_link::azure_blob_external result{};
+        couchbase::management::analytics::azure_blob_external_link result{};
 
         result.link_name = v.at("name").get_string();
         if (const auto* dataverse = v.find("dataverse"); dataverse != nullptr) {