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

data/ext/couchbase/protocol/cmd_info.hxx

@@ -20,16 +20,6 @@
 namespace couchbase::protocol
 {
 struct cmd_info {
-    asio::ip::tcp::endpoint local_endpoint{};
-    asio::ip::tcp::endpoint remote_endpoint{};
-
-    template<class AsyncStream>
-    void extract_from_stream(AsyncStream& stream)
-    {
-        std::error_code err;
-        local_endpoint = stream.local_endpoint(err);
-        remote_endpoint = stream.remote_endpoint(err);
-        (void)err;
-    }
+    double server_duration_us{ 0 };
 };
 } // namespace couchbase::protocol

data/ext/couchbase/protocol/cmd_insert.hxx

@@ -0,0 +1,172 @@
+/* -*- 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

data/ext/couchbase/protocol/cmd_lookup_in.hxx

@@ -20,7 +20,7 @@
 #include <protocol/unsigned_leb128.h>
 
 #include <protocol/client_opcode.hxx>
-#include <operations/document_id.hxx>
+#include <document_id.hxx>
 
 namespace couchbase::protocol
 {
@@ -44,13 +44,18 @@ class lookup_in_response_body
         return fields_;
     }
 
-    bool parse(protocol::status status, const header_buffer& header, const std::vector<uint8_t>& body, const cmd_info&)
+    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 || status == protocol::status::subdoc_multi_path_failure) {
             using offset_type = std::vector<uint8_t>::difference_type;
-            uint8_t ext_size = header[4];
-            offset_type offset = ext_size;
+            offset_type offset = framing_extras_size + key_size + extras_size;
             fields_.reserve(16); /* we won't have more than 16 entries anyway */
             while (static_cast<std::size_t>(offset) < body.size()) {
                 lookup_in_field field;
@@ -95,6 +100,7 @@ class lookup_in_request_body
             std::uint8_t opcode;
             std::uint8_t flags;
             std::string path;
+            std::size_t original_index{};
         };
         std::vector<entry> entries;
 
@@ -112,16 +118,20 @@ class lookup_in_request_body
 
   private:
     std::string key_;
-    std::vector<std::uint8_t> ext_{};
+    std::vector<std::uint8_t> extras_{};
     std::vector<std::uint8_t> value_{};
 
     std::uint8_t flags_{ 0 };
     lookup_in_specs specs_;
 
   public:
-    void id(const operations::document_id& id)
+    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 access_deleted(bool value)
@@ -143,12 +153,18 @@ class lookup_in_request_body
         return key_;
     }
 
-    const std::vector<std::uint8_t>& extension()
+    const std::vector<std::uint8_t>& framing_extras()
+    {
+        static std::vector<std::uint8_t> empty;
+        return empty;
+    }
+
+    const std::vector<std::uint8_t>& extras()
     {
-        if (ext_.empty()) {
+        if (extras_.empty()) {
             fill_extention();
         }
-        return ext_;
+        return extras_;
     }
 
     const std::vector<std::uint8_t>& value()
@@ -161,21 +177,21 @@ class lookup_in_request_body
 
     std::size_t size()
     {
-        if (ext_.empty()) {
+        if (extras_.empty()) {
             fill_extention();
         }
         if (value_.empty()) {
             fill_value();
         }
-        return key_.size() + ext_.size() + value_.size();
+        return key_.size() + extras_.size() + value_.size();
     }
 
   private:
     void fill_extention()
     {
         if (flags_ != 0) {
-            ext_.resize(sizeof(flags_));
-            ext_[0] = flags_;
+            extras_.resize(sizeof(flags_));
+            extras_[0] = flags_;
         }
     }
 

data/ext/couchbase/protocol/cmd_mutate_in.hxx

@@ -20,7 +20,7 @@
 #include <protocol/unsigned_leb128.h>
 
 #include <protocol/client_opcode.hxx>
-#include <operations/document_id.hxx>
+#include <document_id.hxx>
 
 namespace couchbase::protocol
 {
@@ -38,6 +38,7 @@ class mutate_in_response_body
 
   private:
     std::vector<mutate_in_field> fields_;
+    mutation_token token_;
 
   public:
     std::vector<mutate_in_field>& fields()
@@ -45,13 +46,35 @@ class mutate_in_response_body
         return fields_;
     }
 
-    bool parse(protocol::status status, const header_buffer& header, const std::vector<uint8_t>& body, const cmd_info&)
+    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 || status == protocol::status::subdoc_multi_path_failure) {
             using offset_type = std::vector<uint8_t>::difference_type;
-            uint8_t ext_size = header[4];
-            offset_type offset = ext_size;
+            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;
+            } else {
+                offset += extras_size;
+            }
+            offset += key_size;
             fields_.reserve(16); /* we won't have more than 16 entries anyway */
             while (static_cast<std::size_t>(offset) < body.size()) {
                 mutate_in_field field;
@@ -93,7 +116,26 @@ class mutate_in_request_body
     using response_body_type = mutate_in_response_body;
     static const inline client_opcode opcode = client_opcode::subdoc_multi_mutation;
 
-    static const inline uint8_t doc_flag_access_deleted = 0x04;
+    enum class store_semantics_type {
+        /**
+         * Replace the document, fail if it does not exist. This is the default.
+         */
+        replace,
+
+        /**
+         * Replace the document or create it if it does not exist.
+         */
+        upsert,
+
+        /**
+         * Replace the document or create it if it does not exist.
+         */
+        insert,
+    };
+
+    static const inline uint8_t doc_flag_access_deleted = 0b0000'0100;
+    static const inline uint8_t doc_flag_mkdoc = 0b0000'0001;
+    static const inline uint8_t doc_flag_add = 0b0000'0010;
 
     struct mutate_in_specs {
         static const inline uint8_t path_flag_create_parents = 0x01;
@@ -105,6 +147,7 @@ class mutate_in_request_body
             std::uint8_t flags;
             std::string path;
             std::string param;
+            std::size_t original_index{};
         };
         std::vector<entry> entries;
 
@@ -162,24 +205,51 @@ class mutate_in_request_body
 
   private:
     std::string key_;
-    std::vector<std::uint8_t> ext_{};
+    std::vector<std::uint8_t> extras_{};
     std::vector<std::uint8_t> value_{};
 
+    std::uint32_t expiry_{ 0 };
     std::uint8_t flags_{ 0 };
     mutate_in_specs specs_;
+    std::vector<std::uint8_t> framing_extras_{};
 
   public:
-    void id(const operations::document_id& id)
+    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 expiry(uint32_t value)
+    {
+        expiry_ = value;
     }
 
     void access_deleted(bool value)
     {
         if (value) {
-            flags_ = doc_flag_access_deleted;
+            flags_ |= doc_flag_access_deleted;
         } else {
-            flags_ = 0;
+            flags_ &= static_cast<std::uint8_t>(~doc_flag_access_deleted);
+        }
+    }
+
+    void store_semantics(store_semantics_type semantics)
+    {
+        flags_ &= 0b1111'1100; /* reset first two bits */
+        switch (semantics) {
+            case store_semantics_type::replace:
+                /* leave bits as zeros */
+                break;
+            case store_semantics_type::upsert:
+                flags_ |= doc_flag_mkdoc;
+                break;
+            case store_semantics_type::insert:
+                flags_ |= doc_flag_add;
+                break;
         }
     }
 
@@ -188,17 +258,41 @@ class mutate_in_request_body
         specs_ = specs;
     }
 
+    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>& extension()
+    const std::vector<std::uint8_t>& framing_extras()
+    {
+        return framing_extras_;
+    }
+
+    const std::vector<std::uint8_t>& extras()
     {
-        if (ext_.empty()) {
+        if (extras_.empty()) {
             fill_extention();
         }
-        return ext_;
+        return extras_;
     }
 
     const std::vector<std::uint8_t>& value()
@@ -211,21 +305,27 @@ class mutate_in_request_body
 
     std::size_t size()
     {
-        if (ext_.empty()) {
+        if (extras_.empty()) {
             fill_extention();
         }
         if (value_.empty()) {
             fill_value();
         }
-        return key_.size() + ext_.size() + value_.size();
+        return framing_extras_.size() + extras_.size() + key_.size() + value_.size();
     }
 
   private:
     void fill_extention()
     {
+        if (expiry_ != 0) {
+            extras_.resize(sizeof(expiry_));
+            std::uint32_t field = htonl(expiry_);
+            memcpy(extras_.data(), &field, sizeof(field));
+        }
         if (flags_ != 0) {
-            ext_.resize(sizeof(flags_));
-            ext_[0] = flags_;
+            std::size_t offset = extras_.size();
+            extras_.resize(offset + sizeof(flags_));
+            extras_[offset] = flags_;
         }
     }