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

data/ext/couchbase/protocol/cmd_get_and_lock.hxx

@@ -0,0 +1,142 @@
+/* -*- 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 get_and_lock_response_body
+{
+  public:
+    static const inline client_opcode opcode = client_opcode::get_and_lock;
+
+  private:
+    std::uint32_t flags_;
+    std::string value_;
+
+  public:
+    std::string& value()
+    {
+        return value_;
+    }
+
+    std::uint32_t flags()
+    {
+        return flags_;
+    }
+
+    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;
+            if (extras_size == 4) {
+                memcpy(&flags_, body.data() + offset, sizeof(flags_));
+                flags_ = ntohl(flags_);
+                offset += 4;
+            } else {
+                offset += extras_size;
+            }
+            offset += key_size;
+            value_.assign(body.begin() + offset, body.end());
+            return true;
+        }
+        return false;
+    }
+};
+
+class get_and_lock_request_body
+{
+  public:
+    using response_body_type = get_and_lock_response_body;
+    static const inline client_opcode opcode = client_opcode::get_and_lock;
+
+  private:
+    std::string key_;
+    std::uint32_t lock_time_;
+    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 lock_time(std::uint32_t seconds)
+    {
+        lock_time_ = 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()
+    {
+        if (extras_.empty()) {
+            fill_extras();
+        }
+        return extras_;
+    }
+
+    const std::vector<std::uint8_t>& value()
+    {
+        static std::vector<std::uint8_t> empty;
+        return empty;
+    }
+
+    std::size_t size()
+    {
+        if (extras_.empty()) {
+            fill_extras();
+        }
+        return key_.size() + extras_.size();
+    }
+
+  private:
+    void fill_extras()
+    {
+        extras_.resize(sizeof(lock_time_));
+        uint32_t field = htonl(lock_time_);
+        memcpy(extras_.data(), &field, sizeof(field));
+    }
+};
+
+} // namespace couchbase::protocol

data/ext/couchbase/protocol/cmd_get_and_touch.hxx

@@ -0,0 +1,142 @@
+/* -*- 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 get_and_touch_response_body
+{
+  public:
+    static const inline client_opcode opcode = client_opcode::get_and_touch;
+
+  private:
+    std::uint32_t flags_;
+    std::string value_;
+
+  public:
+    std::string& value()
+    {
+        return value_;
+    }
+
+    std::uint32_t flags()
+    {
+        return flags_;
+    }
+
+    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;
+            if (extras_size == 4) {
+                memcpy(&flags_, body.data() + offset, sizeof(flags_));
+                flags_ = ntohl(flags_);
+                offset += 4;
+            } else {
+                offset += extras_size;
+            }
+            offset += key_size;
+            value_.assign(body.begin() + offset, body.end());
+            return true;
+        }
+        return false;
+    }
+};
+
+class get_and_touch_request_body
+{
+  public:
+    using response_body_type = get_and_touch_response_body;
+    static const inline client_opcode opcode = client_opcode::get_and_touch;
+
+  private:
+    std::string key_;
+    std::uint32_t expiration_;
+    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)
+    {
+        expiration_ = 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()
+    {
+        if (extras_.empty()) {
+            fill_extras();
+        }
+        return extras_;
+    }
+
+    const std::vector<std::uint8_t>& value()
+    {
+        static std::vector<std::uint8_t> empty;
+        return empty;
+    }
+
+    std::size_t size()
+    {
+        if (extras_.empty()) {
+            fill_extras();
+        }
+        return key_.size() + extras_.size();
+    }
+
+  private:
+    void fill_extras()
+    {
+        extras_.resize(sizeof(expiration_));
+        uint32_t field = htonl(expiration_);
+        memcpy(extras_.data(), &field, sizeof(field));
+    }
+};
+
+} // namespace couchbase::protocol

data/ext/couchbase/protocol/cmd_get_cluster_config.hxx

@@ -61,11 +61,18 @@ class get_cluster_config_response_body
         return config_;
     }
 
-    bool parse(protocol::status status, const header_buffer& header, const std::vector<uint8_t>& body, const cmd_info& 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& info)
     {
         Expects(header[1] == static_cast<uint8_t>(opcode));
         if (status == protocol::status::success) {
-            config_ = tao::json::from_string<deduplicate_keys>(std::string(body.begin(), body.end())).as<configuration>();
+            std::vector<uint8_t>::difference_type offset = framing_extras_size + key_size + extras_size;
+            config_ = tao::json::from_string<deduplicate_keys>(std::string(body.begin() + offset, body.end())).as<configuration>();
             for (auto& node : config_.nodes) {
                 if (node.this_node && node.hostname.empty()) {
                     node.hostname = info.remote_endpoint.address().to_string();
@@ -90,7 +97,13 @@ class get_cluster_config_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_get_collections_manifest.hxx

@@ -42,11 +42,18 @@ class get_collections_manifest_response_body
         return manifest_;
     }
 
-    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) {
-            manifest_ = tao::json::from_string(std::string(body.begin(), body.end())).as<collections_manifest>();
+            std::vector<uint8_t>::difference_type offset = framing_extras_size + key_size + extras_size;
+            manifest_ = tao::json::from_string(std::string(body.begin() + offset, body.end())).as<collections_manifest>();
             return true;
         }
         return false;
@@ -65,7 +72,13 @@ class get_collections_manifest_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_get_error_map.hxx

@@ -42,12 +42,19 @@ class get_error_map_response_body
         return errmap_;
     }
 
-    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) {
             try {
-                errmap_ = tao::json::from_string(std::string(body.begin(), body.end())).as<error_map>();
+                std::vector<uint8_t>::difference_type offset = framing_extras_size + key_size + extras_size;
+                errmap_ = tao::json::from_string(std::string(body.begin() + offset, body.end())).as<error_map>();
             } catch (tao::json::pegtl::parse_error& e) {
                 spdlog::critical("unable to parse JSON: {}", std::string(body.begin(), body.end()));
             }
@@ -79,7 +86,13 @@ class get_error_map_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_hello.hxx

@@ -36,16 +36,25 @@ class hello_response_body
         return supported_features_;
     }
 
-    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) {
-            Expects(body.size() % 2 == 0);
-            size_t num_features = body.size() / 2;
+            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, body.data() + i * 2, sizeof(std::uint16_t));
+                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));
@@ -66,7 +75,6 @@ class hello_request_body
   private:
     std::string key_;
     std::vector<hello_feature> features_{
-        hello_feature::tls,
         hello_feature::tcp_nodelay,
         hello_feature::mutation_seqno,
         hello_feature::xattr,
@@ -77,9 +85,11 @@ class hello_request_body
         hello_feature::duplex,
         hello_feature::clustermap_change_notification,
         hello_feature::unordered_execution,
-        // hello_feature::alt_request_support,
-        // hello_feature::sync_replication,
+        hello_feature::alt_request_support,
+        hello_feature::tracing,
+        hello_feature::sync_replication,
         hello_feature::vattr,
+        hello_feature::collections,
     };
     std::vector<std::uint8_t> value_;
 
@@ -94,7 +104,13 @@ class hello_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;