couchbase 4.2.0 → 4.2.2

package/deps/couchbase-cxx-client/core/io/retry_context.hxx

@@ -17,22 +17,73 @@
 
 #pragma once
 
-#include "retry_strategy.hxx"
 #include <couchbase/retry_reason.hxx>
+#include <couchbase/retry_strategy.hxx>
 
 #include <chrono>
+#include <memory>
+#include <mutex>
 #include <set>
 
 namespace couchbase::core::io
 {
 
-template<class RetryStrategy>
-struct retry_context {
-    bool idempotent;
-    int retry_attempts{ 0 };
-    std::chrono::milliseconds last_duration{ 0 };
-    std::set<retry_reason> reasons{};
-    RetryStrategy strategy{};
+template<bool is_idempotent>
+class retry_context : public retry_request
+{
+  public:
+    retry_context(std::shared_ptr<retry_strategy> strategy = nullptr, std::string identifier = {})
+      : identifier_{ std::move(identifier) }
+      , strategy_{ std::move(strategy) }
+    {
+    }
+
+    [[nodiscard]] auto identifier() const -> std::string override
+    {
+        return identifier_;
+    }
+
+    [[nodiscard]] auto idempotent() const -> bool override
+    {
+        return is_idempotent;
+    }
+
+    [[nodiscard]] auto strategy() const -> std::shared_ptr<retry_strategy>
+    {
+        return strategy_;
+    }
+
+    [[nodiscard]] auto retry_attempts() const -> std::size_t override
+    {
+        std::scoped_lock lock(*mutex_);
+        return retry_attempts_;
+    }
+
+    [[nodiscard]] auto retry_reasons() const -> std::set<retry_reason> override
+    {
+        std::scoped_lock lock(*mutex_);
+        return reasons_;
+    }
+
+    void record_retry_attempt(retry_reason reason) override
+    {
+        std::scoped_lock lock(*mutex_);
+        ++retry_attempts_;
+        reasons_.insert(reason);
+    }
+
+    void add_reason(retry_reason reason)
+    {
+        std::scoped_lock lock(*mutex_);
+        reasons_.insert(reason);
+    }
+
+  private:
+    const std::string identifier_;
+    const std::shared_ptr<retry_strategy> strategy_;
+    mutable std::shared_ptr<std::mutex> mutex_{ std::make_shared<std::mutex>() };
+    std::size_t retry_attempts_{ 0 };
+    std::set<retry_reason> reasons_{};
 };
 
 } // namespace couchbase::core::io

package/deps/couchbase-cxx-client/core/io/retry_orchestrator.hxx

@@ -18,8 +18,10 @@
 #pragma once
 
 #include "core/logger/logger.hxx"
-#include "retry_action.hxx"
-#include "retry_reason.hxx"
+#include "core/protocol/client_opcode_fmt.hxx"
+
+#include <couchbase/best_effort_retry_strategy.hxx>
+#include <couchbase/fmt/retry_reason.hxx>
 
 #include <chrono>
 #include <memory>
@@ -45,25 +47,6 @@ cap_duration(std::chrono::milliseconds uncapped, std::shared_ptr<Command> comman
     return uncapped;
 }
 
-inline std::chrono::milliseconds
-controlled_backoff(int retry_attempts)
-{
-    switch (retry_attempts) {
-        case 0:
-            return std::chrono::milliseconds(1);
-        case 1:
-            return std::chrono::milliseconds(10);
-        case 2:
-            return std::chrono::milliseconds(50);
-        case 3:
-            return std::chrono::milliseconds(100);
-        case 4:
-            return std::chrono::milliseconds(500);
-        default:
-            return std::chrono::milliseconds(1000);
-    }
-}
-
 template<class Manager, class Command>
 void
 retry_with_duration(std::shared_ptr<Manager> manager,
@@ -71,16 +54,14 @@ retry_with_duration(std::shared_ptr<Manager> manager,
                     retry_reason reason,
                     std::chrono::milliseconds duration)
 {
-    ++command->request.retries.retry_attempts;
-    command->request.retries.reasons.insert(reason);
-    command->request.retries.last_duration = duration;
-    LOG_TRACE(R"({} retrying operation {} (duration={}ms, id="{}", reason={}, attempts={}))",
-              manager->log_prefix(),
-              decltype(command->request)::encoded_request_type::body_type::opcode,
-              duration.count(),
-              command->id_,
-              reason,
-              command->request.retries.retry_attempts);
+    command->request.retries.record_retry_attempt(reason);
+    CB_LOG_TRACE(R"({} retrying operation {} (duration={}ms, id="{}", reason={}, attempts={}))",
+                 manager->log_prefix(),
+                 decltype(command->request)::encoded_request_type::body_type::opcode,
+                 duration.count(),
+                 command->id_,
+                 reason,
+                 command->request.retries.retry_attempts());
     manager->schedule_for_retry(command, duration);
 }
 
@@ -91,21 +72,25 @@ void
 maybe_retry(std::shared_ptr<Manager> manager, std::shared_ptr<Command> command, retry_reason reason, std::error_code ec)
 {
     if (always_retry(reason)) {
-        return priv::retry_with_duration(manager, command, reason, priv::controlled_backoff(command->request.retries.retry_attempts));
+        return priv::retry_with_duration(manager, command, reason, controlled_backoff(command->request.retries.retry_attempts()));
     }
 
-    if (retry_action action = command->request.retries.strategy.should_retry(command->request, reason); action.retry_requested) {
-        return priv::retry_with_duration(manager, command, reason, priv::cap_duration(action.duration, command));
+    auto retry_strategy = command->request.retries.strategy();
+    if (retry_strategy == nullptr) {
+        retry_strategy = manager->default_retry_strategy();
+    }
+    if (retry_action action = retry_strategy->retry_after(command->request.retries, reason); action.need_to_retry()) {
+        return priv::retry_with_duration(manager, command, reason, priv::cap_duration(action.duration(), command));
     }
 
-    LOG_TRACE(R"({} not retrying operation {} (id="{}", reason={}, attempts={}, ec={} ({})))",
-              manager->log_prefix(),
-              decltype(command->request)::encoded_request_type::body_type::opcode,
-              command->id_,
-              reason,
-              command->request.retries.retry_attempts,
-              ec.value(),
-              ec.message());
+    CB_LOG_TRACE(R"({} not retrying operation {} (id="{}", reason={}, attempts={}, ec={} ({})))",
+                 manager->log_prefix(),
+                 decltype(command->request)::encoded_request_type::body_type::opcode,
+                 command->id_,
+                 reason,
+                 command->request.retries.retry_attempts(),
+                 ec.value(),
+                 ec.message());
     return command->invoke_handler(ec);
 }
 

package/deps/couchbase-cxx-client/core/key_value_config.cxx

@@ -0,0 +1,35 @@
+/* -*- 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
+ *
+ *     https://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 "key_value_config.hxx"
+
+#include <fmt/chrono.h>
+#include <fmt/core.h>
+
+namespace couchbase::core
+{
+auto
+key_value_config::to_string() const -> std::string
+{
+    return fmt::format(
+      R"(#<key_value_config:{} connect_timeout={}, reconnect_wait_backoff={}, pool_size={}, max_queue_size={}, connection_buffer_size={}>)",
+      static_cast<const void*>(this),
+      connect_timeout,
+      reconnect_wait_backoff,
+      pool_size,
+      max_queue_size,
+      connection_buffer_size);
+}
+} // namespace couchbase::core

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

@@ -0,0 +1,40 @@
+/* -*- 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
+ *
+ *     https://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 <chrono>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace couchbase::core
+{
+struct key_value_config {
+    static constexpr std::chrono::milliseconds default_connect_timeout{ std::chrono::seconds{ 7 } };
+    static constexpr std::chrono::milliseconds default_reconnect_wait_backoff{ std::chrono::seconds{ 5 } };
+    static constexpr std::size_t default_pool_size{ 1 };
+    static constexpr std::size_t default_max_queue_size{ 2048 };
+    static constexpr std::size_t default_connection_buffer_size{ 0 };
+
+    std::chrono::milliseconds connect_timeout{ default_connect_timeout };
+    std::chrono::milliseconds reconnect_wait_backoff{ default_reconnect_wait_backoff };
+    std::size_t pool_size{ default_pool_size };
+    std::size_t max_queue_size{ default_max_queue_size };
+    std::size_t connection_buffer_size{ default_connection_buffer_size };
+
+    [[nodiscard]] auto to_string() const -> std::string;
+};
+} // namespace couchbase::core

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);
 
@@ -208,12 +206,12 @@ is_initialized();
         }                                                                                                                                  \
     } while (false)
 
-#define LOG_TRACE(...) COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::trace, __VA_ARGS__)
-#define LOG_DEBUG(...) COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::debug, __VA_ARGS__)
-#define LOG_INFO(...) COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::info, __VA_ARGS__)
-#define LOG_WARNING(...) COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::warn, __VA_ARGS__)
-#define LOG_ERROR(...) COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::err, __VA_ARGS__)
-#define LOG_CRITICAL(...)                                                                                                                  \
+#define CB_LOG_TRACE(...) COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::trace, __VA_ARGS__)
+#define CB_LOG_DEBUG(...) COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::debug, __VA_ARGS__)
+#define CB_LOG_INFO(...) COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::info, __VA_ARGS__)
+#define CB_LOG_WARNING(...) COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::warn, __VA_ARGS__)
+#define CB_LOG_ERROR(...) COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::err, __VA_ARGS__)
+#define CB_LOG_CRITICAL(...)                                                                                                               \
     COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::critical, __VA_ARGS__)
 
 /**
@@ -233,10 +231,10 @@ is_initialized();
         }                                                                                                                                  \
     } while (false)
 
-#define LOG_TRACE_RAW(msg) COUCHBASE_LOG_RAW(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::trace, msg)
-#define LOG_DEBUG_RAW(msg) COUCHBASE_LOG_RAW(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::debug, msg)
-#define LOG_INFO_RAW(msg) COUCHBASE_LOG_RAW(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::info, msg)
-#define LOG_WARNING_RAW(msg) COUCHBASE_LOG_RAW(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::warn, msg)
-#define LOG_ERROR_RAW(msg) COUCHBASE_LOG_RAW(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::err, msg)
-#define LOG_CRITICAL_RAW(msg)                                                                                                              \
+#define CB_LOG_TRACE_RAW(msg) COUCHBASE_LOG_RAW(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::trace, msg)
+#define CB_LOG_DEBUG_RAW(msg) COUCHBASE_LOG_RAW(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::debug, msg)
+#define CB_LOG_INFO_RAW(msg) COUCHBASE_LOG_RAW(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::info, msg)
+#define CB_LOG_WARNING_RAW(msg) COUCHBASE_LOG_RAW(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::warn, msg)
+#define CB_LOG_ERROR_RAW(msg) COUCHBASE_LOG_RAW(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::err, msg)
+#define CB_LOG_CRITICAL_RAW(msg)                                                                                                           \
     COUCHBASE_LOG_RAW(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::critical, msg)

package/deps/couchbase-cxx-client/core/management/rbac_json.hxx

@@ -36,7 +36,7 @@ struct traits<couchbase::core::management::rbac::user_and_metadata> {
         } else if (domain == "external") {
             result.domain = couchbase::core::management::rbac::auth_domain::external;
         } else {
-            LOG_ERROR(R"("unexpected domain for user with metadata: "{}")", domain);
+            CB_LOG_ERROR(R"("unexpected domain for user with metadata: "{}")", domain);
         }
         result.username = v.at("id").get_string();
         if (const auto* display_name = v.find("name"); display_name != nullptr && !display_name->get_string().empty()) {

package/deps/couchbase-cxx-client/core/mcbp/barrier_frame.hxx

@@ -0,0 +1,27 @@
+/* -*- 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
+
+namespace couchbase::core::mcbp
+{
+// barrier_frame is used to signal to the server that this command should be barriered and must not be executed concurrently with other
+// commands.
+struct barrier_frame {
+    // Barrier frames have no additional configuration, but their existence triggers the barriering behaviour.
+};
+} // namespace couchbase::core::mcbp

package/deps/couchbase-cxx-client/core/mcbp/big_endian.cxx

@@ -0,0 +1,73 @@
+/* -*- 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.
+ */
+
+#include "big_endian.hxx"
+
+namespace couchbase::core::mcbp::big_endian
+{
+auto
+read_uint64(gsl::span<std::byte> buffer, std::size_t offset) -> std::uint64_t
+{
+    return (std::to_integer<std::uint64_t>(buffer[offset + 7])) |       //
+           (std::to_integer<std::uint64_t>(buffer[offset + 6]) << 8) |  //
+           (std::to_integer<std::uint64_t>(buffer[offset + 5]) << 16) | //
+           (std::to_integer<std::uint64_t>(buffer[offset + 4]) << 24) | //
+           (std::to_integer<std::uint64_t>(buffer[offset + 3]) << 32) | //
+           (std::to_integer<std::uint64_t>(buffer[offset + 2]) << 40) | //
+           (std::to_integer<std::uint64_t>(buffer[offset + 1]) << 48) | //
+           (std::to_integer<std::uint64_t>(buffer[offset + 0]) << 56);
+}
+
+auto
+read_uint32(gsl::span<std::byte> buffer, std::size_t offset) -> std::uint32_t
+{
+    return (std::to_integer<std::uint32_t>(buffer[offset + 3])) |       //
+           (std::to_integer<std::uint32_t>(buffer[offset + 2]) << 8) |  //
+           (std::to_integer<std::uint32_t>(buffer[offset + 1]) << 16) | //
+           (std::to_integer<std::uint32_t>(buffer[offset + 0]) << 24);
+}
+
+auto
+read_uint16(gsl::span<std::byte> buffer, std::size_t offset) -> std::uint16_t
+{
+    return static_cast<std::uint16_t>((std::to_integer<std::uint32_t>(buffer[offset + 1])) |
+                                      (std::to_integer<std::uint32_t>(buffer[offset + 0]) << 8));
+}
+
+auto
+read_uint8(gsl::span<std::byte> buffer, std::size_t offset) -> std::uint8_t
+{
+    return std::to_integer<std::uint8_t>(buffer[offset]);
+}
+
+auto
+read(gsl::span<std::byte> buffer, std::size_t offset, std::size_t length) -> std::vector<std::byte>
+{
+    std::vector<std::byte> ret(length);
+    std::memcpy(ret.data(), buffer.data() + offset, length);
+    return ret;
+}
+
+void
+put_uint32(gsl::span<std::byte> bytes, std::uint32_t value)
+{
+    bytes[0] = static_cast<std::byte>(value >> 24);
+    bytes[1] = static_cast<std::byte>(value >> 16);
+    bytes[2] = static_cast<std::byte>(value >> 8);
+    bytes[3] = static_cast<std::byte>(value);
+}
+} // namespace couchbase::core::mcbp::big_endian

package/deps/couchbase-cxx-client/core/mcbp/big_endian.hxx

@@ -0,0 +1,46 @@
+/* -*- 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
+
+#include <gsl/span>
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+namespace couchbase::core::mcbp::big_endian
+{
+auto
+read_uint64(gsl::span<std::byte> buffer, std::size_t offset) -> std::uint64_t;
+
+auto
+read_uint32(gsl::span<std::byte> buffer, std::size_t offset) -> std::uint32_t;
+
+auto
+read_uint16(gsl::span<std::byte> buffer, std::size_t offset) -> std::uint16_t;
+
+auto
+read_uint8(gsl::span<std::byte> buffer, std::size_t offset) -> std::uint8_t;
+
+auto
+read(gsl::span<std::byte> buffer, std::size_t offset, std::size_t length) -> std::vector<std::byte>;
+
+void
+put_uint32(gsl::span<std::byte> bytes, std::uint32_t value);
+} // namespace couchbase::core::mcbp::big_endian

package/deps/couchbase-cxx-client/core/mcbp/buffer_writer.cxx

@@ -0,0 +1,78 @@
+/* -*- 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.
+ */
+
+#include "buffer_writer.hxx"
+
+#include <cstddef>
+#include <cstring>
+
+namespace couchbase::core::mcbp
+{
+buffer_writer::buffer_writer(std::size_t size)
+  : store_{ size }
+{
+}
+
+void
+buffer_writer::write(const std::vector<std::byte>& val)
+{
+    std::memcpy(store_.data() + offset_, val.data(), val.size());
+    offset_ += val.size();
+}
+
+void
+buffer_writer::write_frame_header(std::uint8_t type, std::size_t length)
+{
+    write_byte((std::byte{ type } << 4) | static_cast<std::byte>(length));
+}
+
+void
+buffer_writer::write_uint64(std::uint64_t val)
+{
+    write_byte(static_cast<std::byte>(val >> 56));
+    write_byte(static_cast<std::byte>(val >> 48));
+    write_byte(static_cast<std::byte>(val >> 40));
+    write_byte(static_cast<std::byte>(val >> 32));
+    write_byte(static_cast<std::byte>(val >> 24));
+    write_byte(static_cast<std::byte>(val >> 16));
+    write_byte(static_cast<std::byte>(val >> 8));
+    write_byte(static_cast<std::byte>(val));
+}
+
+void
+buffer_writer::write_uint32(std::uint32_t val)
+{
+    write_byte(static_cast<std::byte>(val >> 24));
+    write_byte(static_cast<std::byte>(val >> 16));
+    write_byte(static_cast<std::byte>(val >> 8));
+    write_byte(static_cast<std::byte>(val));
+}
+
+void
+buffer_writer::write_uint16(std::uint16_t val)
+{
+    write_byte(static_cast<std::byte>(val >> 8));
+    write_byte(static_cast<std::byte>(val));
+}
+
+void
+buffer_writer::write_byte(std::byte val)
+{
+    store_[offset_] = val;
+    ++offset_;
+}
+} // namespace couchbase::core::mcbp

package/deps/couchbase-cxx-client/core/mcbp/buffer_writer.hxx

@@ -0,0 +1,38 @@
+/* -*- 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
+
+#include <cinttypes>
+#include <vector>
+
+namespace couchbase::core::mcbp
+{
+struct buffer_writer {
+    explicit buffer_writer(std::size_t size);
+
+    void write_byte(std::byte val);
+    void write_uint16(std::uint16_t val);
+    void write_uint32(std::uint32_t val);
+    void write_uint64(std::uint64_t val);
+    void write_frame_header(std::uint8_t type, std::size_t length);
+    void write(const std::vector<std::byte>& val);
+
+    std::vector<std::byte> store_;
+    std::size_t offset_{ 0 };
+};
+} // namespace couchbase::core::mcbp