couchbase 3.0.0.alpha.1-universal-darwin-19 → 3.0.0.alpha.2-universal-darwin-19

data/ext/couchbase/protocol/frame_info_id.hxx

@@ -0,0 +1,187 @@
+/* -*- 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);
+    }
+};

data/ext/couchbase/protocol/hello_feature.hxx

@@ -22,20 +22,129 @@
 namespace couchbase::protocol
 {
 enum class hello_feature : uint16_t {
+    /**
+     * The client wants to TLS and send STARTTLS
+     */
     tls = 0x02,
+
+    /**
+     * The client requests the server to set TCP NODELAY on the socket used by this connection.
+     */
     tcp_nodelay = 0x03,
+
+    /**
+     * The client requests the server to add the sequence number for a mutation to the response packet used in mutations.
+     */
     mutation_seqno = 0x04,
+
+    /**
+     * The client requests the server to set TCP DELAY on the socket used by this connection
+     */
+    tcp_delay = 0x05,
+
+    /**
+     * The client requests the server to add XATTRs to the stream for commands where it makes sense (GetWithMeta, SetWithMeta, DcpMutation
+     * etc)
+     */
     xattr = 0x06,
+
+    /**
+     * The client requests the server to send extended error codes instead of disconnecting the client when new errors occur (note that some
+     * errors may be remapped to more generic error codes instead of disconnecting)
+     */
     xerror = 0x07,
+
+    /**
+     * This is purely informational (it does not enable/disable anything on the server). It may be used from the client to know if it should
+     * be able to run select bucket or not (select bucket was a privileged command pre-spock. In spock all users may run select bucket, but
+     * only to a bucket they have access to).
+     */
     select_bucket = 0x08,
+
+    /**
+     * The client wants to enable support for Snappy compression. A client with support for Snappy compression must update the datatype
+     * filed in the requests with the bit representing SNAPPY when sending snappy compressed data to the server. It must be able to receive
+     * data from the server compressed with SNAPPY identified by the bit being set in the datatype field
+     */
     snappy = 0x0a,
+
+    /**
+     * The client wants to enable support for JSON. The client must set this bit when storing JSON documents on the server. The server will
+     * set the appropriate bit in the datatype field when returning such documents to the client
+     */
     json = 0x0b,
+
+    /**
+     * The client allows for full duplex on the socket. This means that the server may send requests back to the client. These messages is
+     * identified by the magic values of 0x82 (request) and 0x83 (response). See the document Duplex for more information.
+     *
+     * https://github.com/couchbase/kv_engine/blob/master/docs/Duplex.md
+     */
     duplex = 0x0c,
+
+    /**
+     * The client wants the server to notify the client with new cluster maps whenever ns_server push them to memcached. (note that this
+     * notification is subject to deduplication of the vbucket map received as part of not my vbucket)
+     */
     clustermap_change_notification = 0x0d,
+
+    /**
+     * The client allows the server to reorder the execution of commands. See the document UnorderedExecution for more information
+     *
+     * https://github.com/couchbase/kv_engine/blob/master/docs/UnorderedExecution.md
+     */
     unordered_execution = 0x0e,
+
+    /**
+     * The client wants the server to include tracing information in the response packet
+     */
+    tracing = 0x0f,
+
+    /**
+     * This is purely informational (it does not enable/disable anything on the server). It may be used from the client to know if it may
+     * send the alternative request packet (magic 0x08) containing FrameInfo segments.
+     */
     alt_request_support = 0x10,
+
+    /**
+     * This is purely informational (it does not enable/disable anything on the server). It may be used from the client to know if it may
+     * use synchronous replication tags in the mutation requests.
+     */
     sync_replication = 0x11,
+
+    /**
+     * The client wants to enable support for Collections
+     */
+    collections = 0x12,
+
+    /**
+     * This is purely informational (it does not enable / disable anything on the server). It may be used from the client to figure out if
+     * the server supports OpenTracing or not.)
+     */
+    open_tracing = 0x13,
+
+    /**
+     * This is purely informational (it does not enable / disable anything on the server). It may be used from the client to know if it may
+     * use PreserveTtl in the operations who carries the TTL for a document
+     */
+    preserve_ttl = 0x14,
+
+    /**
+     * This is purely information (it does not enable / disable anything on the server). It may be used from the client to determine if the
+     * server supports VATTRs in a generic way (can request $ and will either succeed or fail with SubdocXattrUnknownVattr). Requires XATTR.
+     */
     vattr = 0x15,
+
+    /**
+     * This is purely information (it does not enable / disable anything on the server). It may be used from the client to determine if the
+     * server supports Point in Time Recovery
+     */
+    point_in_time_recovery = 0x16,
+
+    /**
+     * Does the server support the subdoc mutation flag create_as_deleted
+     */
+    subdoc_create_as_deleted = 0x17,
 };
 
 constexpr inline bool
@@ -56,6 +165,13 @@ is_valid_hello_feature(uint16_t code)
         case hello_feature::alt_request_support:
         case hello_feature::sync_replication:
         case hello_feature::vattr:
+        case hello_feature::collections:
+        case hello_feature::open_tracing:
+        case hello_feature::preserve_ttl:
+        case hello_feature::point_in_time_recovery:
+        case hello_feature::tcp_delay:
+        case hello_feature::tracing:
+        case hello_feature::subdoc_create_as_deleted:
             return true;
     }
     return false;
@@ -112,6 +228,27 @@ struct fmt::formatter : formatter
             case couchbase::protocol::hello_feature::vattr:
                 name = "vattr";
                 break;
+            case couchbase::protocol::hello_feature::collections:
+                name = "collections";
+                break;
+            case couchbase::protocol::hello_feature::open_tracing:
+                name = "open_tracing";
+                break;
+            case couchbase::protocol::hello_feature::preserve_ttl:
+                name = "preserve_ttl";
+                break;
+            case couchbase::protocol::hello_feature::point_in_time_recovery:
+                name = "point_in_time_recovery";
+                break;
+            case couchbase::protocol::hello_feature::tcp_delay:
+                name = "tcp_delay";
+                break;
+            case couchbase::protocol::hello_feature::tracing:
+                name = "tracing";
+                break;
+            case couchbase::protocol::hello_feature::subdoc_create_as_deleted:
+                name = "subdoc_create_as_deleted";
+                break;
         }
         return formatter<string_view>::format(name, ctx);
     }

data/ext/couchbase/protocol/server_opcode.hxx

@@ -0,0 +1,57 @@
+/* -*- 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 server_opcode : uint8_t {
+    cluster_map_change_notification = 0x01,
+    invalid = 0xff,
+};
+
+constexpr inline bool
+is_valid_server_request_opcode(uint8_t code)
+{
+    switch (static_cast<server_opcode>(code)) {
+        case server_opcode::cluster_map_change_notification:
+            return true;
+        case server_opcode::invalid:
+            break;
+    }
+    return false;
+}
+
+} // namespace couchbase::protocol
+
+template<>
+struct fmt::formatter<couchbase::protocol::server_opcode> : formatter<string_view> {
+    template<typename FormatContext>
+    auto format(couchbase::protocol::server_opcode opcode, FormatContext& ctx)
+    {
+        string_view name = "unknown";
+        switch (opcode) {
+            case couchbase::protocol::server_opcode::cluster_map_change_notification:
+                name = "cluster_map_change_notification";
+                break;
+            case couchbase::protocol::server_opcode::invalid:
+                name = "invalid";
+                break;
+        }
+        return formatter<string_view>::format(name, ctx);
+    }
+};

data/ext/couchbase/protocol/server_request.hxx

@@ -0,0 +1,122 @@
+/* -*- 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/server_opcode.hxx>
+#include <protocol/magic.hxx>
+#include <protocol/status.hxx>
+#include <protocol/datatype.hxx>
+#include <protocol/cmd_info.hxx>
+
+namespace couchbase::protocol
+{
+
+template<typename Body>
+class server_request
+{
+  private:
+    static const inline magic magic_ = magic::server_request;
+
+    Body body_;
+    server_opcode opcode_{ server_opcode::invalid };
+    header_buffer header_;
+    uint8_t data_type_;
+    std::vector<std::uint8_t> data_;
+    std::size_t body_size_;
+    std::uint32_t opaque_;
+    std::uint64_t cas_;
+    cmd_info info_;
+
+  public:
+    server_request() = default;
+    explicit server_request(io::mcbp_message& msg)
+    {
+        std::memcpy(header_.data(), &msg.header, sizeof(msg.header));
+        verify_header();
+        data_ = std::move(msg.body);
+        parse_body();
+    }
+
+    [[nodiscard]] server_opcode opcode() const
+    {
+        return opcode_;
+    }
+
+    [[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_));
+        Expects(header_[1] == static_cast<std::uint8_t>(Body::opcode));
+        opcode_ = static_cast<server_opcode>(header_[1]);
+        data_type_ = header_[5];
+
+        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_));
+    }
+
+    void parse_body()
+    {
+        body_.parse(header_, data_, info_);
+    }
+
+    [[nodiscard]] std::vector<std::uint8_t>& data()
+    {
+        return data_;
+    }
+};
+} // namespace couchbase::protocol