couchbase 4.1.2 → 4.1.3

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

@@ -1,38 +0,0 @@
-/* -*- 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 <couchbase/protocol/client_request.hxx>
-#include <couchbase/utils/binary.hxx>
-
-#include <snappy.h>
-
-namespace couchbase::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::protocol

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

@@ -1,157 +0,0 @@
-/* -*- 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/protocol/client_opcode.hxx>
-#include <couchbase/protocol/client_response.hxx>
-#include <couchbase/protocol/magic.hxx>
-#include <couchbase/utils/binary.hxx>
-#include <couchbase/utils/byteswap.hxx>
-
-#include <algorithm>
-#include <cstring>
-#include <gsl/util>
-
-namespace couchbase::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 };
-    Body body_;
-
-  public:
-    [[nodiscard]] client_opcode opcode() const
-    {
-        return opcode_;
-    }
-
-    void opaque(std::uint32_t val)
-    {
-        opaque_ = val;
-    }
-
-    void cas(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();
-
-        uint16_t key_size = gsl::narrow_cast<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);
-        }
-
-        uint8_t ext_size = gsl::narrow_cast<uint8_t>(body_.extras().size());
-        memcpy(payload.data() + 4, &ext_size, sizeof(ext_size));
-
-        uint16_t vbucket = utils::byte_swap(gsl::narrow_cast<uint16_t>(partition_));
-        memcpy(payload.data() + 6, &vbucket, sizeof(vbucket));
-
-        uint32_t body_size = utils::byte_swap(gsl::narrow_cast<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::protocol

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

@@ -1,74 +0,0 @@
-/* -*- 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 <couchbase/protocol/client_response.hxx>
-
-#include <couchbase/utils/json.hxx>
-
-#include <cstring>
-#include <gsl/assert>
-
-namespace couchbase::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, enhanced_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()) {
-            enhanced_error_info err{};
-            if (const auto* ref = err_obj->find("ref"); ref != nullptr && ref->is_string()) {
-                err.reference = ref->get_string();
-            }
-            if (const auto* ctx = err_obj->find("context"); ctx != nullptr && ctx->is_string()) {
-                err.context = ctx->get_string();
-            }
-
-            info = std::move(err);
-            return true;
-        }
-    }
-    return false;
-}
-} // namespace couchbase::protocol

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

@@ -1,209 +0,0 @@
-/* -*- 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 <couchbase/io/mcbp_message.hxx>
-#include <couchbase/protocol/client_opcode.hxx>
-#include <couchbase/protocol/client_opcode_fmt.hxx>
-#include <couchbase/protocol/cmd_info.hxx>
-#include <couchbase/protocol/datatype.hxx>
-#include <couchbase/protocol/enhanced_error_info.hxx>
-#include <couchbase/protocol/enhanced_error_info_fmt.hxx>
-#include <couchbase/protocol/frame_info_id.hxx>
-#include <couchbase/protocol/magic.hxx>
-#include <couchbase/protocol/magic_fmt.hxx>
-#include <couchbase/protocol/status.hxx>
-#include <couchbase/protocol/status_fmt.hxx>
-#include <couchbase/utils/byteswap.hxx>
-
-#include <cmath>
-#include <cstring>
-#include <fmt/core.h>
-#include <gsl/assert>
-#include <optional>
-
-namespace couchbase::protocol
-{
-
-double
-parse_server_duration_us(const io::mcbp_message& msg);
-
-bool
-parse_enhanced_error(std::string_view str, enhanced_error_info& info);
-
-template<typename Body>
-class client_response
-{
-  private:
-    Body body_;
-    magic magic_{ magic::client_response };
-    client_opcode opcode_{ client_opcode::invalid };
-    header_buffer header_{};
-    std::uint8_t data_type_{ 0 };
-    std::vector<std::byte> data_{};
-    std::uint16_t key_size_{ 0 };
-    std::uint8_t framing_extras_size_{ 0 };
-    std::uint8_t extras_size_{ 0 };
-    std::size_t body_size_{ 0 };
-    protocol::status status_{};
-    std::optional<enhanced_error_info> error_;
-    std::uint32_t opaque_{};
-    std::uint64_t cas_{};
-    cmd_info info_{};
-
-  public:
-    client_response() = default;
-    explicit client_response(io::mcbp_message&& msg)
-      : client_response(std::move(msg), {})
-    {
-    }
-
-    client_response(io::mcbp_message&& msg, const cmd_info& info)
-      : header_(msg.header_data())
-      , data_(std::move(msg.body))
-      , info_(info)
-    {
-        verify_header();
-        parse_body();
-    }
-
-    [[nodiscard]] client_opcode opcode() const
-    {
-        return opcode_;
-    }
-
-    [[nodiscard]] protocol::status status() const
-    {
-        return status_;
-    }
-
-    [[nodiscard]] couchbase::cas cas() const
-    {
-        return couchbase::cas{ cas_ };
-    }
-
-    [[nodiscard]] std::uint32_t opaque() const
-    {
-        return opaque_;
-    }
-
-    Body& body()
-    {
-        return body_;
-    }
-
-    [[nodiscard]] const Body& body() const
-    {
-        return body_;
-    }
-
-    [[nodiscard]] header_buffer& header()
-    {
-        return header_;
-    }
-
-    void verify_header()
-    {
-        Expects(header_[0] == static_cast<std::byte>(magic::alt_client_response) ||
-                header_[0] == static_cast<std::byte>(magic::client_response));
-        Expects(header_[1] == static_cast<std::byte>(Body::opcode));
-        magic_ = static_cast<magic>(header_[0]);
-        opcode_ = static_cast<client_opcode>(header_[1]);
-        data_type_ = std::to_integer<std::uint8_t>(header_[5]);
-
-        uint16_t status = 0;
-        memcpy(&status, header_.data() + 6, sizeof(status));
-        status = utils::byte_swap(status);
-        status_ = static_cast<protocol::status>(status);
-
-        extras_size_ = std::to_integer<std::uint8_t>(header_[4]);
-        if (magic_ == magic::alt_client_response) {
-            framing_extras_size_ = std::to_integer<std::uint8_t>(header_[2]);
-            key_size_ = std::to_integer<std::uint8_t>(header_[3]);
-        } else {
-            memcpy(&key_size_, header_.data() + 2, sizeof(key_size_));
-            key_size_ = utils::byte_swap(key_size_);
-        }
-
-        uint32_t field = 0;
-        memcpy(&field, header_.data() + 8, sizeof(field));
-        body_size_ = utils::byte_swap(field);
-        data_.resize(body_size_);
-
-        memcpy(&opaque_, header_.data() + 12, sizeof(opaque_));
-
-        memcpy(&cas_, header_.data() + 16, sizeof(cas_));
-        cas_ = utils::byte_swap(cas_);
-    }
-
-    [[nodiscard]] std::optional<enhanced_error_info> error_info()
-    {
-        return error_;
-    }
-
-    [[nodiscard]] std::string error_message() const
-    {
-        if (error_) {
-            return fmt::format(R"(magic={}, opcode={}, status={}, error={})", magic_, opcode_, status_, *error_);
-        }
-        return fmt::format("magic={}, opcode={}, status={}", magic_, opcode_, status_);
-    }
-
-    void parse_body()
-    {
-        parse_framing_extras();
-        bool parsed = body_.parse(status_, header_, framing_extras_size_, key_size_, extras_size_, data_, info_);
-        if (status_ != protocol::status::success && !parsed && has_json_datatype(data_type_)) {
-            enhanced_error_info err;
-            std::vector<uint8_t>::difference_type offset = framing_extras_size_ + extras_size_ + key_size_;
-            std::string_view enhanced_error_text{ reinterpret_cast<const char*>(data_.data()) + offset,
-                                                  data_.size() - static_cast<std::size_t>(offset) };
-            if (parse_enhanced_error(enhanced_error_text, err)) {
-                error_.emplace(err);
-            }
-        }
-    }
-
-    void parse_framing_extras()
-    {
-        if (framing_extras_size_ == 0) {
-            return;
-        }
-        size_t offset = 0;
-        while (offset < framing_extras_size_) {
-            auto frame_size = std::to_integer<std::uint8_t>(data_[offset] & std::byte{ 0b1111 });
-            auto frame_id = std::to_integer<std::uint8_t>((data_[offset] >> 4U) & std::byte{ 0b1111 });
-            ++offset;
-            if (frame_id == static_cast<std::uint8_t>(response_frame_info_id::server_duration) && frame_size == 2 &&
-                framing_extras_size_ - offset >= frame_size) {
-                std::uint16_t encoded_duration{};
-                std::memcpy(&encoded_duration, data_.data() + offset, sizeof(encoded_duration));
-                encoded_duration = utils::byte_swap(encoded_duration);
-                info_.server_duration_us = std::pow(encoded_duration, 1.74) / 2;
-            }
-            offset += frame_size;
-        }
-    }
-
-    [[nodiscard]] std::vector<std::byte>& data()
-    {
-        return data_;
-    }
-};
-} // namespace couchbase::protocol

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/cmd_append.cxx

@@ -1,69 +0,0 @@
-/* -*- 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 <couchbase/protocol/cmd_append.hxx>
-
-#include <couchbase/protocol/frame_info_utils.hxx>
-#include <couchbase/utils/byteswap.hxx>
-#include <couchbase/utils/unsigned_leb128.hxx>
-
-#include <cstring>
-
-namespace couchbase::protocol
-{
-
-bool
-protocol::append_response_body::parse(protocol::status status,
-                                      const header_buffer& header,
-                                      std::uint8_t framing_extras_size,
-                                      std::uint16_t /* key_size */,
-                                      std::uint8_t extras_size,
-                                      const std::vector<std::byte>& body,
-                                      const cmd_info& /* info */)
-{
-    Expects(header[1] == static_cast<std::byte>(opcode));
-    if (status == protocol::status::success) {
-        std::vector<uint8_t>::difference_type offset = framing_extras_size;
-        if (extras_size == 16) {
-            memcpy(&token_.partition_uuid, body.data() + offset, sizeof(token_.partition_uuid));
-            token_.partition_uuid = utils::byte_swap(token_.partition_uuid);
-            offset += 8;
-
-            memcpy(&token_.sequence_number, body.data() + offset, sizeof(token_.sequence_number));
-            token_.sequence_number = utils::byte_swap(token_.sequence_number);
-            return true;
-        }
-    }
-    return false;
-}
-
-void
-protocol::append_request_body::id(const document_id& id)
-{
-    key_ = make_protocol_key(id);
-}
-
-void
-protocol::append_request_body::durability(protocol::durability_level level, std::optional<std::uint16_t> timeout)
-{
-    if (level == protocol::durability_level::none) {
-        return;
-    }
-
-    add_durability_frame_info(framing_extras_, level, timeout);
-}
-} // namespace couchbase::protocol

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/cmd_append.hxx

@@ -1,107 +0,0 @@
-/* -*- 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 <optional>
-
-#include <couchbase/document_id.hxx>
-#include <couchbase/io/mcbp_message.hxx>
-#include <couchbase/protocol/client_opcode.hxx>
-#include <couchbase/protocol/cmd_info.hxx>
-#include <couchbase/protocol/status.hxx>
-
-#include <couchbase/mutation_token.hxx>
-#include <couchbase/protocol/durability_level.hxx>
-
-namespace couchbase::protocol
-{
-
-class append_response_body
-{
-  public:
-    static const inline client_opcode opcode = client_opcode::append;
-
-  private:
-    mutation_token token_{};
-
-  public:
-    [[nodiscard]] const mutation_token& token() const
-    {
-        return token_;
-    }
-
-    bool parse(protocol::status status,
-               const header_buffer& header,
-               std::uint8_t framing_extras_size,
-               std::uint16_t key_size,
-               std::uint8_t extras_size,
-               const std::vector<std::byte>& body,
-               const cmd_info& info);
-};
-
-class append_request_body
-{
-  public:
-    using response_body_type = append_response_body;
-    static const inline client_opcode opcode = client_opcode::append;
-
-  private:
-    std::vector<std::byte> key_{};
-    std::vector<std::byte> extras_{};
-    std::vector<std::byte> content_{};
-    std::vector<std::byte> framing_extras_{};
-
-    static inline std::vector<std::uint8_t> empty;
-
-  public:
-    void id(const document_id& id);
-
-    void durability(protocol::durability_level level, std::optional<std::uint16_t> timeout);
-
-    void content(const std::vector<std::byte>& content)
-    {
-        content_ = { content.begin(), content.end() };
-    }
-
-    [[nodiscard]] const auto& key() const
-    {
-        return key_;
-    }
-
-    [[nodiscard]] const auto& framing_extras() const
-    {
-        return framing_extras_;
-    }
-
-    [[nodiscard]] const auto& extras() const
-    {
-        return empty_buffer;
-    }
-
-    [[nodiscard]] const auto& value() const
-    {
-        return content_;
-    }
-
-    [[nodiscard]] std::size_t size() const
-    {
-        return framing_extras_.size() + key_.size() + content_.size();
-    }
-};
-
-} // namespace couchbase::protocol