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

data/ext/couchbase/protocol/cmd_sasl_list_mechs.hxx

@@ -36,12 +36,18 @@ class sasl_list_mechs_response_body
         return supported_mechs_;
     }
 
-    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) {
             auto previous = body.begin();
-            auto current = std::find(body.begin(), body.end(), ' ');
+            auto current = std::find(body.begin() + framing_extras_size + extras_size + key_size, body.end(), ' ');
             while (current != body.end()) {
                 supported_mechs_.emplace_back(previous, current);
                 previous = current + 1;
@@ -67,7 +73,13 @@ class sasl_list_mechs_request_body
         return empty;
     }
 
-    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()
     {
         static std::vector<std::uint8_t> empty;
         return empty;

data/ext/couchbase/protocol/cmd_sasl_step.hxx

@@ -30,11 +30,17 @@ class sasl_step_response_body
     std::string value_;
 
   public:
-    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) {
-            value_ = { body.begin(), body.end() };
+            value_ = { body.begin() + framing_extras_size + extras_size + key_size, body.end() };
             return true;
         }
         return false;
@@ -72,7 +78,13 @@ class sasl_step_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()
     {
         static std::vector<std::uint8_t> empty;
         return empty;

data/ext/couchbase/protocol/cmd_select_bucket.hxx

@@ -25,7 +25,13 @@ class select_bucket_response_body
     static const inline client_opcode opcode = client_opcode::select_bucket;
 
   public:
-    bool parse(protocol::status, const header_buffer& header, const std::vector<uint8_t>&, const cmd_info&)
+    bool parse(protocol::status,
+               const header_buffer& header,
+               std::uint8_t,
+               std::uint16_t,
+               std::uint8_t,
+               const std::vector<uint8_t>&,
+               const cmd_info&)
     {
         Expects(header[1] == static_cast<uint8_t>(opcode));
         return false;
@@ -52,7 +58,13 @@ class select_bucket_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()
     {
         static std::vector<std::uint8_t> empty;
         return empty;

data/ext/couchbase/protocol/cmd_touch.hxx

@@ -0,0 +1,102 @@
+/* -*- 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 touch_response_body
+{
+  public:
+    static const inline client_opcode opcode = client_opcode::touch;
+
+  public:
+    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& /* info */)
+    {
+        Expects(header[1] == static_cast<uint8_t>(opcode));
+        return false;
+    }
+};
+
+class touch_request_body
+{
+  public:
+    using response_body_type = touch_response_body;
+    static const inline client_opcode opcode = client_opcode::touch;
+
+  private:
+    std::string key_;
+    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 expiration(std::uint32_t seconds)
+    {
+        extras_.resize(sizeof(seconds));
+        seconds = htonl(seconds);
+        memcpy(extras_.data(), &seconds, sizeof(seconds));
+    }
+
+    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()
+    {
+        return extras_;
+    }
+
+    const std::vector<std::uint8_t>& value()
+    {
+        static std::vector<std::uint8_t> empty;
+        return empty;
+    }
+
+    std::size_t size()
+    {
+        return key_.size() + extras_.size();
+    }
+};
+
+} // namespace couchbase::protocol

data/ext/couchbase/protocol/cmd_unlock.hxx

@@ -0,0 +1,95 @@
+/* -*- 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 unlock_response_body
+{
+  public:
+    static const inline client_opcode opcode = client_opcode::unlock;
+
+  public:
+    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));
+        return false;
+    }
+};
+
+class unlock_request_body
+{
+  public:
+    using response_body_type = unlock_response_body;
+    static const inline client_opcode opcode = client_opcode::unlock;
+
+  private:
+    std::string key_;
+
+  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());
+        }
+    }
+
+    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()
+    {
+        static std::vector<std::uint8_t> empty;
+        return empty;
+    }
+
+    std::size_t size()
+    {
+        return key_.size();
+    }
+};
+
+} // namespace couchbase::protocol

data/ext/couchbase/protocol/cmd_upsert.hxx

@@ -19,7 +19,9 @@
 
 #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>
 
@@ -40,13 +42,18 @@ class upsert_response_body
         return token_;
     }
 
-    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,
+               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 = 0;
-            uint8_t ext_size = header[4];
-            if (ext_size == 16) {
+            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;
@@ -68,15 +75,39 @@ class upsert_request_body
 
   private:
     std::string key_{};
-    std::vector<std::uint8_t> ext_{};
+    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 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 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)
@@ -99,12 +130,17 @@ class upsert_request_body
         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()
@@ -114,22 +150,22 @@ class upsert_request_body
 
     std::size_t size()
     {
-        if (ext_.empty()) {
+        if (extras_.empty()) {
             fill_extention();
         }
-        return key_.size() + ext_.size() + content_.size();
+        return framing_extras_.size() + extras_.size() + key_.size() + content_.size();
     }
 
   private:
     void fill_extention()
     {
-        ext_.resize(sizeof(flags_) + sizeof(expiration_));
+        extras_.resize(sizeof(flags_) + sizeof(expiration_));
 
         uint32_t field = htonl(flags_);
-        memcpy(ext_.data(), &field, sizeof(field));
+        memcpy(extras_.data(), &field, sizeof(field));
 
         field = htonl(expiration_);
-        memcpy(ext_.data() + sizeof(flags_), &field, sizeof(field));
+        memcpy(extras_.data() + sizeof(flags_), &field, sizeof(field));
     }
 };
 

data/ext/couchbase/protocol/durability_level.hxx

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