couchbase 3.0.0.alpha.5-x86_64-linux → 3.5.0-x86_64-linux

data/ext/couchbase/protocol/client_request.hxx

@@ -1,160 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2020 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
-
-#ifndef WIN32
-#include <arpa/inet.h>
-#endif
-
-#include <snappy.h>
-
-#include <gsl/gsl_util>
-#include <protocol/client_opcode.hxx>
-#include <protocol/magic.hxx>
-#include <protocol/client_response.hxx>
-
-namespace couchbase::protocol
-{
-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_;
-    std::vector<std::uint8_t> payload_;
-
-  public:
-    client_opcode opcode()
-    {
-        return opcode_;
-    }
-
-    void opaque(std::uint32_t val)
-    {
-        opaque_ = val;
-    }
-
-    void cas(std::uint64_t val)
-    {
-        cas_ = val;
-    }
-
-    std::uint32_t opaque()
-    {
-        return opaque_;
-    }
-
-    void opcode(client_opcode val)
-    {
-        opcode_ = val;
-    }
-
-    void partition(std::uint16_t val)
-    {
-        partition_ = val;
-    }
-
-    Body& body()
-    {
-        return body_;
-    }
-
-    std::vector<std::uint8_t>& data(bool try_to_compress = false)
-    {
-        switch (opcode_) {
-            case protocol::client_opcode::insert:
-            case protocol::client_opcode::upsert:
-            case protocol::client_opcode::replace:
-                write_payload(try_to_compress);
-                break;
-            default:
-                write_payload(false);
-                break;
-        }
-        return payload_;
-    }
-
-  private:
-    void write_payload(bool try_to_compress)
-    {
-        payload_.resize(header_size + body_.size(), 0);
-        payload_[0] = static_cast<uint8_t>(magic_);
-        payload_[1] = static_cast<uint8_t>(opcode_);
-
-        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 = htons(key_size);
-            memcpy(payload_.data() + 2, &key_size, sizeof(key_size));
-        } else {
-            magic_ = protocol::magic::alt_client_request;
-            payload_[0] = static_cast<uint8_t>(magic_);
-            payload_[2] = gsl::narrow_cast<std::uint8_t>(framing_extras.size());
-            payload_[3] = gsl::narrow_cast<std::uint8_t>(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 = ntohs(gsl::narrow_cast<uint16_t>(partition_));
-        memcpy(payload_.data() + 6, &vbucket, sizeof(vbucket));
-
-        uint32_t body_size = htonl(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 = std::copy(body_.key().begin(), body_.key().end(), body_itr);
-
-        static const std::size_t min_size_to_compress = 32;
-        static const double min_ratio = 0.83;
-        if (try_to_compress && body_.value().size() > min_size_to_compress) {
-            std::string compressed;
-            std::size_t compressed_size =
-              snappy::Compress(reinterpret_cast<const char*>(body_.value().data()), body_.value().size(), &compressed);
-            if (gsl::narrow_cast<double>(compressed_size) / gsl::narrow_cast<double>(body().value().size()) < min_ratio) {
-                std::copy(compressed.begin(), compressed.end(), body_itr);
-                payload_[5] |= static_cast<uint8_t>(protocol::datatype::snappy);
-                size_t new_body_size = body_.size() - (body_.value().size() - compressed_size);
-                body_size = htonl(gsl::narrow_cast<uint32_t>(new_body_size));
-                memcpy(payload_.data() + 8, &body_size, sizeof(body_size));
-                payload_.resize(header_size + new_body_size);
-                return;
-            }
-        }
-        std::copy(body_.value().begin(), body_.value().end(), body_itr);
-    }
-};
-} // namespace couchbase::protocol

data/ext/couchbase/protocol/client_response.hxx

@@ -1,218 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2020 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/gsl_assert>
-
-#include <tao/json.hpp>
-#include <tao/json/contrib/traits.hpp>
-
-#include <protocol/magic.hxx>
-#include <protocol/status.hxx>
-#include <protocol/datatype.hxx>
-#include <protocol/cmd_info.hxx>
-#include <protocol/frame_info_id.hxx>
-
-namespace couchbase::protocol
-{
-
-struct enhanced_error {
-    std::string context;
-    std::string ref;
-};
-
-template<typename Body>
-class client_response
-{
-  private:
-    Body body_;
-    magic magic_{ magic::client_response };
-    client_opcode opcode_{ client_opcode::invalid };
-    header_buffer header_{};
-    uint8_t data_type_{ 0 };
-    std::vector<std::uint8_t> 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> error_;
-    std::uint32_t opaque_{};
-    std::uint64_t cas_{};
-    cmd_info info_{};
-
-  public:
-    client_response() = default;
-    explicit client_response(io::mcbp_message& msg)
-    {
-        header_ = msg.header_data();
-        data_ = std::move(msg.body);
-        verify_header();
-        parse_body();
-    }
-
-    [[nodiscard]] client_opcode opcode() const
-    {
-        return opcode_;
-    }
-
-    [[nodiscard]] protocol::status status() const
-    {
-        return status_;
-    }
-
-    [[nodiscard]] std::size_t body_size() const
-    {
-        return body_size_;
-    }
-
-    [[nodiscard]] std::uint64_t cas() const
-    {
-        return cas_;
-    }
-
-    [[nodiscard]] std::uint32_t opaque() const
-    {
-        return opaque_;
-    }
-
-    Body& body()
-    {
-        return body_;
-    }
-
-    cmd_info& info()
-    {
-        return info_;
-    }
-
-    [[nodiscard]] header_buffer& header()
-    {
-        return header_;
-    }
-
-    void verify_header()
-    {
-        Expects(header_[0] == static_cast<std::uint8_t>(magic::alt_client_response) ||
-                header_[0] == static_cast<std::uint8_t>(magic::client_response));
-        Expects(header_[1] == static_cast<std::uint8_t>(Body::opcode));
-        magic_ = static_cast<magic>(header_[0]);
-        opcode_ = static_cast<client_opcode>(header_[1]);
-        data_type_ = header_[5];
-
-        uint16_t status = 0;
-        memcpy(&status, header_.data() + 6, sizeof(status));
-        status = ntohs(status);
-        Expects(protocol::is_valid_status(status));
-        status_ = static_cast<protocol::status>(status);
-
-        extras_size_ = header_[4];
-        if (magic_ == magic::alt_client_response) {
-            framing_extras_size_ = header_[2];
-            key_size_ = header_[3];
-        } else {
-            memcpy(&key_size_, header_.data() + 2, sizeof(key_size_));
-            key_size_ = ntohs(key_size_);
-        }
-
-        uint32_t field = 0;
-        memcpy(&field, header_.data() + 8, sizeof(field));
-        body_size_ = ntohl(field);
-        data_.resize(body_size_);
-
-        memcpy(&opaque_, header_.data() + 12, sizeof(opaque_));
-
-        memcpy(&cas_, header_.data() + 16, sizeof(cas_));
-    }
-
-    std::string error_message()
-    {
-        if (error_) {
-            return fmt::format(R"({}:{} {} {})", magic_, opcode_, status_, *error_);
-        }
-        return fmt::format("{}:{} {}", 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_)) {
-            auto error = tao::json::from_string(std::string(data_.begin() + framing_extras_size_ + extras_size_ + key_size_, data_.end()));
-            if (error.is_object()) {
-                auto& err_obj = error["error"];
-                if (err_obj.is_object()) {
-                    enhanced_error err{};
-                    auto& ref = err_obj["ref"];
-                    if (ref.is_string()) {
-                        err.ref = ref.get_string();
-                    }
-                    auto& ctx = err_obj["context"];
-                    if (ctx.is_string()) {
-                        err.context = ctx.get_string();
-                    }
-                    error_.emplace(err);
-                }
-            }
-        }
-    }
-
-    void parse_framing_extras()
-    {
-        if (framing_extras_size_ == 0) {
-            return;
-        }
-        size_t offset = 0;
-        while (offset < framing_extras_size_) {
-            std::uint8_t frame_size = data_[offset] & 0xfU;
-            std::uint8_t frame_id = (static_cast<std::uint32_t>(data_[offset]) >> 4U) & 0xfU;
-            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, data_.data() + offset, sizeof(encoded_duration));
-                    encoded_duration = ntohs(encoded_duration);
-                    info_.server_duration_us = std::pow(encoded_duration, 1.74) / 2;
-                }
-            }
-            offset += frame_size;
-        }
-    }
-
-    [[nodiscard]] std::vector<std::uint8_t>& data()
-    {
-        return data_;
-    }
-};
-} // namespace couchbase::protocol
-
-template<>
-struct fmt::formatter<couchbase::protocol::enhanced_error> : formatter<std::string> {
-    template<typename FormatContext>
-    auto format(const couchbase::protocol::enhanced_error& error, FormatContext& ctx)
-    {
-        if (!error.ref.empty() && !error.context.empty()) {
-            format_to(ctx.out(), R"((ref: "{}", ctx: "{}"))", error.ref, error.context);
-        } else if (!error.ref.empty()) {
-            format_to(ctx.out(), R"((ref: "{}"))", error.ref);
-        } else if (!error.context.empty()) {
-            format_to(ctx.out(), R"((ctx: "{}"))", error.context);
-        }
-        return formatter<std::string>::format("", ctx);
-    }
-};

data/ext/couchbase/protocol/cmd_cluster_map_change_notification.hxx

@@ -1,81 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2020 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/gsl_assert>
-
-#include <protocol/server_opcode.hxx>
-#include <protocol/cmd_info.hxx>
-
-#include <configuration.hxx>
-
-namespace couchbase::protocol
-{
-
-class cluster_map_change_notification_request_body
-{
-  public:
-    static const inline server_opcode opcode = server_opcode::cluster_map_change_notification;
-
-  private:
-    uint32_t protocol_revision_;
-    std::string bucket_;
-    configuration config_;
-
-  public:
-    [[nodiscard]] uint32_t protocol_revision()
-    {
-        return protocol_revision_;
-    }
-
-    [[nodiscard]] const std::string& bucket()
-    {
-        return bucket_;
-    }
-
-    [[nodiscard]] configuration config()
-    {
-        return config_;
-    }
-
-    bool parse(const header_buffer& header, const std::vector<uint8_t>& body, const cmd_info& info)
-    {
-        Expects(header[1] == static_cast<uint8_t>(opcode));
-        using offset_type = std::vector<uint8_t>::difference_type;
-        uint8_t ext_size = header[4];
-        offset_type offset = ext_size;
-        if (ext_size == 4) {
-            memcpy(&protocol_revision_, body.data(), sizeof(protocol_revision_));
-            protocol_revision_ = ntohl(protocol_revision_);
-        }
-        uint16_t key_size = 0;
-        memcpy(&key_size, header.data() + 2, sizeof(key_size));
-        key_size = ntohs(key_size);
-        bucket_.assign(body.begin() + offset, body.begin() + offset + key_size);
-        offset += key_size;
-        config_ = tao::json::from_string<deduplicate_keys>(std::string(body.begin() + offset, body.end())).as<configuration>();
-        for (auto& node : config_.nodes) {
-            if (node.this_node && node.hostname.empty()) {
-                node.hostname = info.remote_endpoint.address().to_string();
-            }
-        }
-        return true;
-    }
-};
-
-} // namespace couchbase::protocol

data/ext/couchbase/protocol/cmd_decrement.hxx

@@ -1,187 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2020 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 <protocol/unsigned_leb128.h>
-
-#include <protocol/client_opcode.hxx>
-#include <document_id.hxx>
-
-namespace couchbase::protocol
-{
-
-class decrement_response_body
-{
-  public:
-    static const inline client_opcode opcode = client_opcode::decrement;
-
-  private:
-    mutation_token token_;
-    std::uint64_t content_;
-
-  public:
-    std::uint64_t content()
-    {
-        return content_;
-    }
-
-    mutation_token& token()
-    {
-        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<uint8_t>& body,
-               const cmd_info&)
-    {
-        Expects(header[1] == static_cast<uint8_t>(opcode));
-        if (status == protocol::status::success) {
-            using offset_type = std::vector<uint8_t>::difference_type;
-            offset_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_64(token_.partition_uuid);
-                offset += 8;
-
-                memcpy(&token_.sequence_number, body.data() + offset, sizeof(token_.sequence_number));
-                token_.sequence_number = utils::byte_swap_64(token_.sequence_number);
-                offset += 8;
-            }
-            memcpy(&content_, body.data() + offset, sizeof(content_));
-            content_ = utils::byte_swap_64(content_);
-            return true;
-        }
-        return false;
-    }
-};
-
-class decrement_request_body
-{
-  public:
-    using response_body_type = decrement_response_body;
-    static const inline client_opcode opcode = client_opcode::decrement;
-
-  private:
-    std::string key_;
-    std::vector<std::uint8_t> framing_extras_{};
-    std::uint64_t delta_{ 1 };
-    std::uint64_t initial_value_{ 0 };
-    std::uint32_t expiration_{ 0 };
-    std::vector<std::uint8_t> extras_{};
-
-  public:
-    void id(const document_id& id)
-    {
-        key_ = id.key;
-        if (id.collection_uid) {
-            unsigned_leb128<uint32_t> encoded(*id.collection_uid);
-            key_.insert(0, encoded.get());
-        }
-    }
-
-    void delta(std::uint64_t value)
-    {
-        delta_ = value;
-    }
-
-    void initial_value(std::uint64_t value)
-    {
-        initial_value_ = value;
-    }
-
-    void expiration(std::uint32_t value)
-    {
-        expiration_ = value;
-    }
-
-    void durability(protocol::durability_level level, std::optional<std::uint16_t> timeout)
-    {
-        if (level == protocol::durability_level::none) {
-            return;
-        }
-        auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::durability_requirement);
-        if (timeout) {
-            framing_extras_.resize(4);
-            framing_extras_[0] = static_cast<std::uint8_t>((static_cast<std::uint32_t>(frame_id) << 4U) | 3U);
-            framing_extras_[1] = static_cast<std::uint8_t>(level);
-            uint16_t val = htons(*timeout);
-            memcpy(framing_extras_.data() + 2, &val, sizeof(val));
-        } else {
-            framing_extras_.resize(2);
-            framing_extras_[0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 1U);
-            framing_extras_[1] = static_cast<std::uint8_t>(level);
-        }
-    }
-
-    const std::string& key()
-    {
-        return key_;
-    }
-
-    const std::vector<std::uint8_t>& framing_extras()
-    {
-        return framing_extras_;
-    }
-
-    const std::vector<std::uint8_t>& extras()
-    {
-        if (extras_.empty()) {
-            fill_extras();
-        }
-        return extras_;
-    }
-
-    const std::vector<std::uint8_t>& value()
-    {
-        static std::vector<std::uint8_t> empty;
-        return empty;
-    }
-
-    [[nodiscard]] std::size_t size()
-    {
-        if (extras_.empty()) {
-            fill_extras();
-        }
-        return extras_.size() + key_.size();
-    }
-
-  private:
-    void fill_extras()
-    {
-        extras_.resize(sizeof(delta_) + sizeof(initial_value_) + sizeof(expiration_));
-        using offset_type = std::vector<uint8_t>::difference_type;
-        offset_type offset = 0;
-
-        std::uint64_t num = utils::byte_swap_64(delta_);
-        memcpy(extras_.data() + offset, &num, sizeof(num));
-        offset += static_cast<offset_type>(sizeof(delta_));
-
-        num = utils::byte_swap_64(initial_value_);
-        memcpy(extras_.data() + offset, &num, sizeof(num));
-        offset += static_cast<offset_type>(sizeof(delta_));
-
-        std::uint32_t ttl = htonl(expiration_);
-        memcpy(extras_.data() + offset, &ttl, sizeof(ttl));
-    }
-};
-
-} // namespace couchbase::protocol