couchbase 4.1.1 → 4.1.3

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/protocol/client_opcode_fmt.hxx

@@ -0,0 +1,316 @@
+/* -*- 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 "client_opcode.hxx"
+
+#include <fmt/core.h>
+
+template<>
+struct fmt::formatter<couchbase::core::protocol::client_opcode> {
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(couchbase::core::protocol::client_opcode opcode, FormatContext& ctx) const
+    {
+        string_view name = "unknown";
+        switch (opcode) {
+            case couchbase::core::protocol::client_opcode::get:
+                name = "get (0x00)";
+                break;
+            case couchbase::core::protocol::client_opcode::upsert:
+                name = "upsert (0x01)";
+                break;
+            case couchbase::core::protocol::client_opcode::insert:
+                name = "insert (0x02)";
+                break;
+            case couchbase::core::protocol::client_opcode::replace:
+                name = "replace (0x03)";
+                break;
+            case couchbase::core::protocol::client_opcode::remove:
+                name = "remove (0x04)";
+                break;
+            case couchbase::core::protocol::client_opcode::hello:
+                name = "hello (0x1f)";
+                break;
+            case couchbase::core::protocol::client_opcode::sasl_list_mechs:
+                name = "sasl_list_mechs (0x20)";
+                break;
+            case couchbase::core::protocol::client_opcode::sasl_auth:
+                name = "sasl_auth (0x21)";
+                break;
+            case couchbase::core::protocol::client_opcode::sasl_step:
+                name = "sasl_step (0x22)";
+                break;
+            case couchbase::core::protocol::client_opcode::select_bucket:
+                name = "select_bucket (0x89)";
+                break;
+            case couchbase::core::protocol::client_opcode::subdoc_multi_lookup:
+                name = "subdoc_multi_lookup (0xd0)";
+                break;
+            case couchbase::core::protocol::client_opcode::subdoc_multi_mutation:
+                name = "subdoc_multi_mutation (0xd1)";
+                break;
+            case couchbase::core::protocol::client_opcode::get_cluster_config:
+                name = "get_cluster_config (0xb5)";
+                break;
+            case couchbase::core::protocol::client_opcode::get_error_map:
+                name = "get_error_map (0xfe)";
+                break;
+            case couchbase::core::protocol::client_opcode::invalid:
+                name = "invalid (0xff)";
+                break;
+            case couchbase::core::protocol::client_opcode::get_collections_manifest:
+                name = "get_collections_manifest (0xba)";
+                break;
+            case couchbase::core::protocol::client_opcode::touch:
+                name = "touch (0x1c)";
+                break;
+            case couchbase::core::protocol::client_opcode::observe:
+                name = "observe (0x92)";
+                break;
+            case couchbase::core::protocol::client_opcode::get_and_lock:
+                name = "get_and_lock (0x94)";
+                break;
+            case couchbase::core::protocol::client_opcode::unlock:
+                name = "unlock (0x95)";
+                break;
+            case couchbase::core::protocol::client_opcode::get_and_touch:
+                name = "get_and_touch (0x1d)";
+                break;
+            case couchbase::core::protocol::client_opcode::increment:
+                name = "increment (0x05)";
+                break;
+            case couchbase::core::protocol::client_opcode::decrement:
+                name = "decrement (0x06)";
+                break;
+            case couchbase::core::protocol::client_opcode::get_collection_id:
+                name = "get_collection_uid (0xbb)";
+                break;
+            case couchbase::core::protocol::client_opcode::noop:
+                name = "noop (0x0a)";
+                break;
+            case couchbase::core::protocol::client_opcode::version:
+                name = "version (0x0b)";
+                break;
+            case couchbase::core::protocol::client_opcode::append:
+                name = "append (0x0e)";
+                break;
+            case couchbase::core::protocol::client_opcode::prepend:
+                name = "prepend (0x0f)";
+                break;
+            case couchbase::core::protocol::client_opcode::stat:
+                name = "stat (0x10)";
+                break;
+            case couchbase::core::protocol::client_opcode::verbosity:
+                name = "verbosity (0x1b)";
+                break;
+            case couchbase::core::protocol::client_opcode::get_all_vbucket_seqnos:
+                name = "get_all_vbucket_seqnos (0x48)";
+                break;
+            case couchbase::core::protocol::client_opcode::dcp_open:
+                name = "dcp_open (0x50)";
+                break;
+            case couchbase::core::protocol::client_opcode::dcp_add_stream:
+                name = "dcp_add_stream (0x51)";
+                break;
+            case couchbase::core::protocol::client_opcode::dcp_close_stream:
+                name = "dcp_add_stream (0x52)";
+                break;
+            case couchbase::core::protocol::client_opcode::dcp_stream_request:
+                name = "dcp_stream_request (0x53)";
+                break;
+            case couchbase::core::protocol::client_opcode::dcp_get_failover_log:
+                name = "dcp_get_failover_log (0x54)";
+                break;
+            case couchbase::core::protocol::client_opcode::dcp_stream_end:
+                name = "dcp_stream_end (0x55)";
+                break;
+            case couchbase::core::protocol::client_opcode::dcp_snapshot_marker:
+                name = "dcp_snapshot_marker (0x56)";
+                break;
+            case couchbase::core::protocol::client_opcode::dcp_mutation:
+                name = "dcp_mutation (0x57)";
+                break;
+            case couchbase::core::protocol::client_opcode::dcp_deletion:
+                name = "dcp_deletion (0x58)";
+                break;
+            case couchbase::core::protocol::client_opcode::dcp_expiration:
+                name = "dcp_expiration (0x59)";
+                break;
+            case couchbase::core::protocol::client_opcode::dcp_set_vbucket_state:
+                name = "dcp_expiration (0x5b)";
+                break;
+            case couchbase::core::protocol::client_opcode::dcp_noop:
+                name = "dcp_noop (0x5c)";
+                break;
+            case couchbase::core::protocol::client_opcode::dcp_buffer_acknowledgement:
+                name = "dcp_buffer_acknowledgement (0x5d)";
+                break;
+            case couchbase::core::protocol::client_opcode::dcp_control:
+                name = "dcp_control (0x5e)";
+                break;
+            case couchbase::core::protocol::client_opcode::dcp_system_event:
+                name = "dcp_system_event (0x5f)";
+                break;
+            case couchbase::core::protocol::client_opcode::dcp_prepare:
+                name = "dcp_prepare (0x60)";
+                break;
+            case couchbase::core::protocol::client_opcode::dcp_seqno_acknowledged:
+                name = "dcp_seqno_acknowledged (0x61)";
+                break;
+            case couchbase::core::protocol::client_opcode::dcp_commit:
+                name = "dcp_commit (0x62)";
+                break;
+            case couchbase::core::protocol::client_opcode::dcp_abort:
+                name = "dcp_abort (0x63)";
+                break;
+            case couchbase::core::protocol::client_opcode::dcp_seqno_advanced:
+                name = "dcp_seqno_advanced (0x64)";
+                break;
+            case couchbase::core::protocol::client_opcode::dcp_oso_snapshot:
+                name = "dcp_oso_snapshot (0x65)";
+                break;
+            case couchbase::core::protocol::client_opcode::get_replica:
+                name = "get_replica (0x83)";
+                break;
+            case couchbase::core::protocol::client_opcode::list_buckets:
+                name = "list_buckets (0x87)";
+                break;
+            case couchbase::core::protocol::client_opcode::observe_seqno:
+                name = "observe_seqno (0x91)";
+                break;
+            case couchbase::core::protocol::client_opcode::evict_key:
+                name = "evict_key (0x93)";
+                break;
+            case couchbase::core::protocol::client_opcode::get_failover_log:
+                name = "get_failover_log (0x96)";
+                break;
+            case couchbase::core::protocol::client_opcode::last_closed_checkpoint:
+                name = "last_closed_checkpoint (0x97)";
+                break;
+            case couchbase::core::protocol::client_opcode::get_meta:
+                name = "get_meta (0xa0)";
+                break;
+            case couchbase::core::protocol::client_opcode::upsert_with_meta:
+                name = "upsert_with_meta (0xa2)";
+                break;
+            case couchbase::core::protocol::client_opcode::insert_with_meta:
+                name = "insert_with_meta (0xa4)";
+                break;
+            case couchbase::core::protocol::client_opcode::remove_with_meta:
+                name = "remove_with_meta (0xa8)";
+                break;
+            case couchbase::core::protocol::client_opcode::create_checkpoint:
+                name = "create_checkpoint (0xaa)";
+                break;
+            case couchbase::core::protocol::client_opcode::checkpoint_persistence:
+                name = "checkpoint_persistence (0xb1)";
+                break;
+            case couchbase::core::protocol::client_opcode::return_meta:
+                name = "return_meta (0xb2)";
+                break;
+            case couchbase::core::protocol::client_opcode::get_random_key:
+                name = "get_random_key (0xb6)";
+                break;
+            case couchbase::core::protocol::client_opcode::seqno_persistence:
+                name = "seqno_persistence (0xb7)";
+                break;
+            case couchbase::core::protocol::client_opcode::get_keys:
+                name = "get_keys (0xb8)";
+                break;
+            case couchbase::core::protocol::client_opcode::set_collections_manifest:
+                name = "set_collections_manifest (0xb9)";
+                break;
+            case couchbase::core::protocol::client_opcode::get_scope_id:
+                name = "get_scope_id (0xbc)";
+                break;
+        }
+        return format_to(ctx.out(), "{}", name);
+    }
+};
+
+template<>
+struct fmt::formatter<couchbase::core::protocol::subdoc_opcode> {
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(couchbase::core::protocol::subdoc_opcode opcode, FormatContext& ctx) const
+    {
+        string_view name = "unknown";
+        switch (opcode) {
+            case couchbase::core::protocol::subdoc_opcode::get:
+                name = "get (0xc5)";
+                break;
+            case couchbase::core::protocol::subdoc_opcode::exists:
+                name = "exists (0xc6)";
+                break;
+            case couchbase::core::protocol::subdoc_opcode::dict_add:
+                name = "dict_add (0xc7)";
+                break;
+            case couchbase::core::protocol::subdoc_opcode::dict_upsert:
+                name = "dict_upsert (0xc8)";
+                break;
+            case couchbase::core::protocol::subdoc_opcode::remove:
+                name = "remove (0xc9)";
+                break;
+            case couchbase::core::protocol::subdoc_opcode::replace:
+                name = "replace (0xca)";
+                break;
+            case couchbase::core::protocol::subdoc_opcode::array_push_last:
+                name = "array_push_last (0xcb)";
+                break;
+            case couchbase::core::protocol::subdoc_opcode::array_push_first:
+                name = "array_push_first (0xcc)";
+                break;
+            case couchbase::core::protocol::subdoc_opcode::array_insert:
+                name = "array_insert (0xcd)";
+                break;
+            case couchbase::core::protocol::subdoc_opcode::array_add_unique:
+                name = "array_add_unique (0xce)";
+                break;
+            case couchbase::core::protocol::subdoc_opcode::counter:
+                name = "counter (0xcf)";
+                break;
+            case couchbase::core::protocol::subdoc_opcode::get_count:
+                name = "get_count (0xd2)";
+                break;
+            case couchbase::core::protocol::subdoc_opcode::get_doc:
+                name = "get_doc (0x00)";
+                break;
+            case couchbase::core::protocol::subdoc_opcode::set_doc:
+                name = "set_doc (0x01)";
+                break;
+            case couchbase::core::protocol::subdoc_opcode::replace_body_with_xattr:
+                name = "replace_body_with_xattr (0xd3)";
+                break;
+            case couchbase::core::protocol::subdoc_opcode::remove_doc:
+                name = "remove_doc (0x04)";
+                break;
+        }
+        return format_to(ctx.out(), "{}", name);
+    }
+};

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/protocol/client_request.cxx

@@ -0,0 +1,38 @@
+/* -*- 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.
+ */
+
+#include "client_request.hxx"
+#include "core/utils/binary.hxx"
+
+#include "third_party/snappy/snappy.h"
+
+namespace couchbase::core::protocol
+{
+std::pair<bool, std::uint32_t>
+compress_value(const std::vector<std::byte>& value, std::vector<std::byte>::iterator& output)
+{
+    static const double min_ratio = 0.83;
+
+    std::string compressed;
+    std::size_t compressed_size = snappy::Compress(reinterpret_cast<const char*>(value.data()), value.size(), &compressed);
+    if (gsl::narrow_cast<double>(compressed_size) / gsl::narrow_cast<double>(value.size()) < min_ratio) {
+        utils::to_binary(compressed, output);
+        return { true, gsl::narrow_cast<std::uint32_t>(compressed_size) };
+    }
+    return { false, 0 };
+}
+} // namespace couchbase::core::protocol

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/protocol/client_request.hxx

@@ -0,0 +1,168 @@
+/* -*- 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/cas.hxx>
+
+#include "client_opcode.hxx"
+#include "client_response.hxx"
+#include "core/utils/binary.hxx"
+#include "core/utils/byteswap.hxx"
+#include "magic.hxx"
+
+#include <algorithm>
+#include <cstring>
+#include <gsl/util>
+
+namespace couchbase::core::protocol
+{
+std::pair<bool, std::uint32_t>
+compress_value(const std::vector<std::byte>& value, std::vector<std::byte>::iterator& output);
+
+template<typename Body>
+class client_request
+{
+  public:
+    using body_type = Body;
+    using response_body_type = typename Body::response_body_type;
+    using response_type = client_response<response_body_type>;
+
+  private:
+    magic magic_{ magic::client_request };
+
+    client_opcode opcode_{ Body::opcode };
+    std::uint16_t partition_{ 0 };
+    std::uint32_t opaque_{ 0 };
+    std::uint64_t cas_{ 0 };
+    protocol::datatype datatype_{ protocol::datatype::raw };
+
+    Body body_;
+
+  public:
+    [[nodiscard]] client_opcode opcode() const
+    {
+        return opcode_;
+    }
+
+    void opaque(std::uint32_t val)
+    {
+        opaque_ = val;
+    }
+
+    void datatype(protocol::datatype val)
+    {
+        datatype_ = val;
+    }
+
+    void cas(couchbase::cas val)
+    {
+        cas_ = utils::byte_swap(val.value());
+    }
+
+    [[nodiscard]] std::uint32_t opaque() const
+    {
+        return opaque_;
+    }
+
+    void opcode(client_opcode val)
+    {
+        opcode_ = val;
+    }
+
+    void partition(std::uint16_t val)
+    {
+        partition_ = val;
+    }
+
+    Body& body()
+    {
+        return body_;
+    }
+
+    [[nodiscard]] std::vector<std::byte> data(bool try_to_compress = false)
+    {
+        switch (opcode_) {
+            case protocol::client_opcode::insert:
+            case protocol::client_opcode::upsert:
+            case protocol::client_opcode::replace:
+                return generate_payload(try_to_compress);
+            default:
+                break;
+        }
+        return generate_payload(false);
+    }
+
+  private:
+    [[nodiscard]] std::vector<std::byte> generate_payload(bool try_to_compress)
+    {
+        std::vector<std::byte> payload;
+        payload.resize(header_size + body_.size(), std::byte{ 0 });
+        payload[0] = static_cast<std::byte>(magic_);
+        payload[1] = static_cast<std::byte>(opcode_);
+
+        const auto& framing_extras = body_.framing_extras();
+
+        std::uint16_t key_size = gsl::narrow_cast<std::uint16_t>(body_.key().size());
+        if (framing_extras.size() == 0) {
+            key_size = utils::byte_swap(key_size);
+            memcpy(payload.data() + 2, &key_size, sizeof(key_size));
+        } else {
+            magic_ = protocol::magic::alt_client_request;
+            payload[0] = static_cast<std::byte>(magic_);
+            payload[2] = gsl::narrow_cast<std::byte>(framing_extras.size());
+            payload[3] = gsl::narrow_cast<std::byte>(key_size);
+        }
+
+        std::uint8_t ext_size = gsl::narrow_cast<std::uint8_t>(body_.extras().size());
+        memcpy(payload.data() + 4, &ext_size, sizeof(ext_size));
+
+        payload[5] = static_cast<std::byte>(datatype_);
+
+        std::uint16_t vbucket = utils::byte_swap(gsl::narrow_cast<std::uint16_t>(partition_));
+        memcpy(payload.data() + 6, &vbucket, sizeof(vbucket));
+
+        std::uint32_t body_size = utils::byte_swap(gsl::narrow_cast<std::uint32_t>(body_.size()));
+        memcpy(payload.data() + 8, &body_size, sizeof(body_size));
+
+        memcpy(payload.data() + 12, &opaque_, sizeof(opaque_));
+        memcpy(payload.data() + 16, &cas_, sizeof(cas_));
+
+        auto body_itr = payload.begin() + header_size;
+        if (framing_extras.size() > 0) {
+            body_itr = std::copy(framing_extras.begin(), framing_extras.end(), body_itr);
+        }
+        body_itr = std::copy(body_.extras().begin(), body_.extras().end(), body_itr);
+        body_itr = utils::to_binary(body_.key(), body_itr);
+
+        if (static const std::size_t min_size_to_compress = 32; try_to_compress && body_.value().size() > min_size_to_compress) {
+            if (auto [compressed, new_value_size] = compress_value(body_.value(), body_itr); compressed) {
+                /* the compressed value meets requirements and was copied to the payload */
+                payload[5] |= static_cast<std::byte>(protocol::datatype::snappy);
+                std::uint32_t new_body_size =
+                  utils::byte_swap(body_size) - gsl::narrow_cast<std::uint32_t>(body_.value().size()) + new_value_size;
+                payload.resize(header_size + new_body_size);
+                new_body_size = utils::byte_swap(new_body_size);
+                memcpy(payload.data() + 8, &new_body_size, sizeof(new_body_size));
+                return payload;
+            }
+        }
+        std::copy(body_.value().begin(), body_.value().end(), body_itr);
+        return payload;
+    }
+};
+} // namespace couchbase::core::protocol

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/protocol/client_response.cxx

@@ -0,0 +1,75 @@
+/* -*- 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.
+ */
+
+#include "client_response.hxx"
+
+#include "core/utils/json.hxx"
+
+#include <cstring>
+#include <gsl/assert>
+
+namespace couchbase::core::protocol
+{
+double
+parse_server_duration_us(const io::mcbp_message& msg)
+{
+    if (msg.header.magic != static_cast<std::uint8_t>(magic::alt_client_response)) {
+        return 0;
+    }
+    auto framing_extras_size = static_cast<std::uint8_t>(msg.header.keylen & 0xfU);
+    if (framing_extras_size == 0) {
+        return 0;
+    }
+    std::size_t offset = 0;
+    while (offset < framing_extras_size) {
+        auto frame_size = std::to_integer<std::uint8_t>(msg.body[offset] & std::byte{ 0b1111 });
+        auto frame_id = std::to_integer<std::uint8_t>((msg.body[offset] >> 4U) & std::byte{ 0b1111 });
+        ++offset;
+        if (frame_id == static_cast<std::uint8_t>(response_frame_info_id::server_duration)) {
+            if (frame_size == 2 && framing_extras_size - offset >= frame_size) {
+                std::uint16_t encoded_duration{};
+                std::memcpy(&encoded_duration, msg.body.data() + offset, sizeof(encoded_duration));
+                encoded_duration = utils::byte_swap(encoded_duration);
+                return std::pow(encoded_duration, 1.74) / 2;
+            }
+        }
+        offset += frame_size;
+    }
+    return 0;
+}
+
+bool
+parse_enhanced_error(std::string_view str, key_value_extended_error_info& info)
+{
+    if (auto error = utils::json::parse(str); error.is_object()) {
+        if (const auto* err_obj = error.find("error"); err_obj != nullptr && err_obj->is_object()) {
+            std::string reference;
+            if (const auto* ref = err_obj->find("ref"); ref != nullptr && ref->is_string()) {
+                reference = ref->get_string();
+            }
+            std::string context;
+            if (const auto* ctx = err_obj->find("context"); ctx != nullptr && ctx->is_string()) {
+                context = ctx->get_string();
+            }
+
+            info = key_value_extended_error_info{ reference, context };
+            return true;
+        }
+    }
+    return false;
+}
+} // namespace couchbase::core::protocol