couchbase 3.0.1-universal-darwin-19 → 3.0.2-universal-darwin-19

data/ext/couchbase/protocol/cmd_hello.hxx

@@ -1,156 +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/hello_feature.hxx>
-
-namespace couchbase::protocol
-{
-
-class hello_response_body
-{
-  public:
-    static const inline client_opcode opcode = client_opcode::hello;
-
-  private:
-    std::vector<hello_feature> supported_features_;
-
-  public:
-    [[nodiscard]] const std::vector<hello_feature>& supported_features() const
-    {
-        return supported_features_;
-    }
-
-    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) {
-            std::vector<uint8_t>::difference_type offset = framing_extras_size + key_size + extras_size;
-            size_t value_size = body.size() - static_cast<std::size_t>(offset);
-            Expects(value_size % 2 == 0);
-            size_t num_features = value_size / 2;
-            supported_features_.reserve(num_features);
-            const auto* value = body.data() + offset;
-            for (size_t i = 0; i < num_features; i++) {
-                std::uint16_t field = 0;
-                std::memcpy(&field, value + i * 2, sizeof(std::uint16_t));
-                field = ntohs(field);
-                if (is_valid_hello_feature(field)) {
-                    supported_features_.push_back(static_cast<hello_feature>(field));
-                }
-            }
-            return true;
-        }
-        return false;
-    }
-};
-
-class hello_request_body
-{
-  public:
-    using response_body_type = hello_response_body;
-    static const inline client_opcode opcode = client_opcode::hello;
-
-  private:
-    std::string key_;
-    std::vector<hello_feature> features_{
-        hello_feature::tcp_nodelay,
-        hello_feature::mutation_seqno,
-        hello_feature::xattr,
-        hello_feature::xerror,
-        hello_feature::select_bucket,
-        hello_feature::snappy,
-        hello_feature::json,
-        hello_feature::duplex,
-        hello_feature::clustermap_change_notification,
-        hello_feature::unordered_execution,
-        hello_feature::alt_request_support,
-        hello_feature::tracing,
-        hello_feature::sync_replication,
-        hello_feature::vattr,
-        hello_feature::collections,
-    };
-    std::vector<std::uint8_t> value_;
-
-  public:
-    void user_agent(std::string val)
-    {
-        key_ = std::move(val);
-    }
-
-    [[nodiscard]] const std::string& user_agent() const
-    {
-        return key_;
-    }
-
-    [[nodiscard]] const std::vector<hello_feature>& features() const
-    {
-        return features_;
-    }
-
-    const std::string& key()
-    {
-        return key_;
-    }
-
-    const std::vector<std::uint8_t>& framing_extras()
-    {
-        static std::vector<std::uint8_t> empty;
-        return empty;
-    }
-
-    const std::vector<std::uint8_t>& extras()
-    {
-        static std::vector<std::uint8_t> empty;
-        return empty;
-    }
-
-    const std::vector<std::uint8_t>& value()
-    {
-        if (value_.empty()) {
-            fill_body();
-        }
-        return value_;
-    }
-
-    std::size_t size()
-    {
-        if (value_.empty()) {
-            fill_body();
-        }
-        return key_.size() + value_.size();
-    }
-
-  private:
-    void fill_body()
-    {
-        value_.resize(2 * features_.size());
-        for (std::size_t idx = 0; idx < features_.size(); idx++) {
-            value_[idx * 2] = 0; // we don't need this byte while feature codes fit the 8-bit
-            value_[idx * 2 + 1] = static_cast<uint8_t>(features_[idx]);
-        }
-    }
-};
-
-} // namespace couchbase::protocol

data/ext/couchbase/protocol/cmd_increment.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 increment_response_body
-{
-  public:
-    static const inline client_opcode opcode = client_opcode::increment;
-
-  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 increment_request_body
-{
-  public:
-    using response_body_type = increment_response_body;
-    static const inline client_opcode opcode = client_opcode::increment;
-
-  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 expiry_{ 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 expiry(std::uint32_t value)
-    {
-        expiry_ = 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(expiry_));
-        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(expiry_);
-        memcpy(extras_.data() + offset, &ttl, sizeof(ttl));
-    }
-};
-
-} // namespace couchbase::protocol

data/ext/couchbase/protocol/cmd_info.hxx

@@ -1,25 +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
-
-namespace couchbase::protocol
-{
-struct cmd_info {
-    double server_duration_us{ 0 };
-};
-} // namespace couchbase::protocol

data/ext/couchbase/protocol/cmd_insert.hxx

@@ -1,172 +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/status.hxx>
-#include <protocol/client_opcode.hxx>
-#include <protocol/frame_info_id.hxx>
-#include <protocol/unsigned_leb128.h>
-#include <protocol/durability_level.hxx>
-#include <mutation_token.hxx>
-#include <utils/byteswap.hxx>
-
-namespace couchbase::protocol
-{
-
-class insert_response_body
-{
-  public:
-    static const inline client_opcode opcode = client_opcode::insert;
-
-  private:
-    mutation_token token_;
-
-  public:
-    mutation_token& token()
-    {
-        return token_;
-    }
-
-    bool parse(protocol::status status,
-               const header_buffer& header,
-               std::uint8_t framing_extras_size,
-               std::uint16_t,
-               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) {
-            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_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);
-                return true;
-            }
-        }
-        return false;
-    }
-};
-
-class insert_request_body
-{
-  public:
-    using response_body_type = insert_response_body;
-    static const inline client_opcode opcode = client_opcode::insert;
-
-  private:
-    std::string key_{};
-    std::vector<std::uint8_t> extras_{};
-    std::vector<std::uint8_t> content_{};
-    std::uint32_t flags_{};
-    std::uint32_t expiry_{};
-    std::vector<std::uint8_t> framing_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 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);
-        }
-    }
-
-    void content(const std::string& content)
-    {
-        content_ = { content.begin(), content.end() };
-    }
-
-    void flags(uint32_t flags)
-    {
-        flags_ = flags;
-    }
-
-    void expiry(uint32_t value)
-    {
-        expiry_ = value;
-    }
-
-    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_extention();
-        }
-        return extras_;
-    }
-
-    const std::vector<std::uint8_t>& value()
-    {
-        return content_;
-    }
-
-    std::size_t size()
-    {
-        if (extras_.empty()) {
-            fill_extention();
-        }
-        return framing_extras_.size() + extras_.size() + key_.size() + content_.size();
-    }
-
-  private:
-    void fill_extention()
-    {
-        extras_.resize(sizeof(flags_) + sizeof(expiry_));
-
-        uint32_t field = htonl(flags_);
-        memcpy(extras_.data(), &field, sizeof(field));
-
-        field = htonl(expiry_);
-        memcpy(extras_.data() + sizeof(flags_), &field, sizeof(field));
-    }
-};
-
-} // namespace couchbase::protocol