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

data/ext/couchbase/protocol/cmd_upsert.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 upsert_response_body
-{
-  public:
-    static const inline client_opcode opcode = client_opcode::upsert;
-
-  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 upsert_request_body
-{
-  public:
-    using response_body_type = upsert_response_body;
-    static const inline client_opcode opcode = client_opcode::upsert;
-
-  private:
-    std::string key_{};
-    std::vector<std::uint8_t> extras_{};
-    std::vector<std::uint8_t> content_{};
-    std::uint32_t flags_{};
-    std::uint32_t expiration_{};
-    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 expiration(uint32_t value)
-    {
-        expiration_ = 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(expiration_));
-
-        uint32_t field = htonl(flags_);
-        memcpy(extras_.data(), &field, sizeof(field));
-
-        field = htonl(expiration_);
-        memcpy(extras_.data() + sizeof(flags_), &field, sizeof(field));
-    }
-};
-
-} // namespace couchbase::protocol

data/ext/couchbase/protocol/datatype.hxx

@@ -1,48 +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
-{
-enum class datatype : uint8_t {
-    raw = 0x00,
-    json = 0x01,
-    snappy = 0x02,
-    xattr = 0x04,
-
-};
-
-constexpr inline bool
-is_valid_datatype(uint8_t code)
-{
-    switch (static_cast<datatype>(code)) {
-        case datatype::raw:
-        case datatype::json:
-        case datatype::snappy:
-        case datatype::xattr:
-            return true;
-    }
-    return false;
-}
-
-constexpr inline bool
-has_json_datatype(uint8_t code)
-{
-    return (code & uint8_t(datatype::json)) != 0;
-}
-} // namespace couchbase::protocol

data/ext/couchbase/protocol/durability_level.hxx

@@ -1,67 +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 <spdlog/spdlog.h>
-
-namespace couchbase::protocol
-{
-enum class durability_level : uint8_t {
-    none = 0x00,
-    majority = 0x01,
-    majority_and_persist_to_active = 0x02,
-    persist_to_majority = 0x03,
-};
-
-constexpr inline bool
-is_valid_durability_level(uint8_t value)
-{
-    switch (static_cast<durability_level>(value)) {
-        case durability_level::none:
-        case durability_level::majority:
-        case durability_level::majority_and_persist_to_active:
-        case durability_level::persist_to_majority:
-            return true;
-    }
-    return false;
-}
-} // namespace couchbase::protocol
-
-template<>
-struct fmt::formatter<couchbase::protocol::durability_level> : formatter<string_view> {
-    template<typename FormatContext>
-    auto format(couchbase::protocol::durability_level value, FormatContext& ctx)
-    {
-        string_view name = "unknown";
-        switch (value) {
-            case couchbase::protocol::durability_level::none:
-                name = "none";
-                break;
-            case couchbase::protocol::durability_level::majority:
-                name = "majority";
-                break;
-            case couchbase::protocol::durability_level::majority_and_persist_to_active:
-                name = "majority_and_persist_to_active";
-                break;
-            case couchbase::protocol::durability_level::persist_to_majority:
-                name = "persist_to_majority";
-                break;
-        }
-        return formatter<string_view>::format(name, ctx);
-    }
-};

data/ext/couchbase/protocol/frame_info_id.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
-
-namespace couchbase::protocol
-{
-enum class request_frame_info_id : uint8_t {
-    /**
-     * No commands may be executed in parallel (received on the same connection) as this command (the command before MUST be completed
-     * before execution of this command is started, and this command MUST be completed before execution of the next command is started).
-     * FrameInfo encoded as:
-     *
-     *    Byte/     0       |
-     *       /              |
-     *      |0 1 2 3 4 5 6 7|
-     *      +---------------+
-     *     0|  ID:0 | Len:0 |
-     */
-    barrier = 0x00,
-
-    /**
-     * This command contains durability requirements. FrameInfo encoded as:
-     *
-     *    Byte/     0            |
-     *       /                   |
-     *      |   0 1 2 3 4 5 6 7  |
-     *      +--------------------+
-     *     0|  ID:1 | Len:1 or 3 |
-     *
-     * The size of the durability requirement is variable length. The first byte contains the durability level by using the following table:
-     *
-     *    0x01 = majority
-     *    0x02 = majority and persist on master
-     *    0x03 = persist to majority
-     *
-     * The (optional) 2nd and 3rd byte contains the timeout specified in milliseconds (network byte order). If the timeout is omitted the
-     * default timeout value configured on the server will be used.
-     *
-     * If timeout is specified, the valid range is 1..65535. Values 0x0 and 0xffff are reserved and will result in the request failing with
-     * invalid_argument (0x4) if used.
-     */
-    durability_requirement = 0x01,
-
-    /**
-     * This command contains a DCP stream-ID as per the stream-request which created the stream.
-     *
-     *     Byte/     0       |
-     *        /              |
-     *       |0 1 2 3 4 5 6 7|
-     *       +---------------+
-     *      0|  ID:2 | Len:2 |
-     *
-     * The 2nd and 3rd byte contain a network byte order (uint16) storing the stream ID value which was specified in the DCP stream-request
-     * that created the stream.
-     */
-    dcp_stream_id = 0x02,
-
-    /**
-     * Request the server to submit trace information by using the supplied context information as the parent span. The context must be
-     * present (length > 0)
-     */
-    open_tracing_context = 0x03,
-
-    /**
-     * Request the server to execute the command as the provided user username (must be present) to identify users defined outside Couchbase
-     * (ldap) the username must be prefixed with ^ (ex: ^trond). Local users do not need a prefix.
-     *
-     * The authenticated user must possess the impersonate privilege in order to utilize the feature (otherwise an error will be returned),
-     * and the effective privilege set when executing the command is an intersection of the authenticated users privilege set and the
-     * impersonated persons privilege set.
-     */
-    impersonate_user = 0x04,
-
-    /**
-     * If the request modifies an existing document the expiry time from the existing document should be used instead of the TTL provided.
-     * If document don't exist the provided TTL should be used. The frame info contains no value (length = 0).
-     */
-    preserve_ttl = 0x1f,
-};
-
-constexpr inline bool
-is_valid_request_frame_info_id(uint8_t value)
-{
-    switch (static_cast<request_frame_info_id>(value)) {
-        case request_frame_info_id::barrier:
-        case request_frame_info_id::durability_requirement:
-        case request_frame_info_id::dcp_stream_id:
-        case request_frame_info_id::open_tracing_context:
-        case request_frame_info_id::impersonate_user:
-        case request_frame_info_id::preserve_ttl:
-            return true;
-    }
-    return false;
-}
-
-enum class response_frame_info_id : uint8_t {
-    /**
-     * Time (in microseconds) server spent on the operation. Measured from receiving header from OS to when response given to OS. Size: 2
-     * bytes; encoded as variable-precision value (see below)
-     *
-     * FrameInfo encoded as:
-     *
-     *     Byte/     0       |       1       |       2       |
-     *        /              |               |               |
-     *       |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|
-     *       +---------------+---------------+---------------+
-     *      0|  ID:0 | Len:2 |  Server Recv->Send Duration   |
-     *
-     * The duration in micros is encoded as:
-     *
-     *     encoded =  (micros * 2) ^ (1.0 / 1.74)
-     *     decoded =  (encoded ^ 1.74) / 2
-     */
-    server_duration = 0x00,
-};
-
-constexpr inline bool
-is_valid_response_frame_info_id(uint8_t value)
-{
-    switch (static_cast<response_frame_info_id>(value)) {
-        case response_frame_info_id::server_duration:
-            return true;
-    }
-    return false;
-}
-
-} // namespace couchbase::protocol
-
-template<>
-struct fmt::formatter<couchbase::protocol::request_frame_info_id> : formatter<string_view> {
-    template<typename FormatContext>
-    auto format(couchbase::protocol::request_frame_info_id opcode, FormatContext& ctx)
-    {
-        string_view name = "unknown";
-        switch (opcode) {
-            case couchbase::protocol::request_frame_info_id::barrier:
-                name = "barrier";
-                break;
-            case couchbase::protocol::request_frame_info_id::durability_requirement:
-                name = "durability_requirement";
-                break;
-            case couchbase::protocol::request_frame_info_id::dcp_stream_id:
-                name = "dcp_stream_id";
-                break;
-            case couchbase::protocol::request_frame_info_id::open_tracing_context:
-                name = "open_tracing_context";
-                break;
-            case couchbase::protocol::request_frame_info_id::impersonate_user:
-                name = "impersonate_user";
-                break;
-            case couchbase::protocol::request_frame_info_id::preserve_ttl:
-                name = "preserve_ttl";
-                break;
-        }
-        return formatter<string_view>::format(name, ctx);
-    }
-};
-
-template<>
-struct fmt::formatter<couchbase::protocol::response_frame_info_id> : formatter<string_view> {
-    template<typename FormatContext>
-    auto format(couchbase::protocol::response_frame_info_id opcode, FormatContext& ctx)
-    {
-        string_view name = "unknown";
-        switch (opcode) {
-            case couchbase::protocol::response_frame_info_id::server_duration:
-                name = "server_duration";
-                break;
-        }
-        return formatter<string_view>::format(name, ctx);
-    }
-};