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

data/ext/couchbase/protocol/cmd_cluster_map_change_notification.hxx

@@ -0,0 +1,81 @@
+/* -*- 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 <protocol/server_opcode.hxx>
+#include <protocol/cmd_info.hxx>
+
+#include <configuration.hxx>
+
+namespace couchbase::protocol
+{
+
+class cluster_map_change_notification_request_body
+{
+  public:
+    static const inline server_opcode opcode = server_opcode::cluster_map_change_notification;
+
+  private:
+    uint32_t protocol_revision_;
+    std::string bucket_;
+    configuration config_;
+
+  public:
+    [[nodiscard]] uint32_t protocol_revision()
+    {
+        return protocol_revision_;
+    }
+
+    [[nodiscard]] const std::string& bucket()
+    {
+        return bucket_;
+    }
+
+    [[nodiscard]] configuration config()
+    {
+        return config_;
+    }
+
+    bool parse(const header_buffer& header, const std::vector<uint8_t>& body, const cmd_info& info)
+    {
+        Expects(header[1] == static_cast<uint8_t>(opcode));
+        using offset_type = std::vector<uint8_t>::difference_type;
+        uint8_t ext_size = header[4];
+        offset_type offset = ext_size;
+        if (ext_size == 4) {
+            memcpy(&protocol_revision_, body.data(), sizeof(protocol_revision_));
+            protocol_revision_ = ntohl(protocol_revision_);
+        }
+        uint16_t key_size = 0;
+        memcpy(&key_size, header.data() + 2, sizeof(key_size));
+        key_size = ntohs(key_size);
+        bucket_.assign(body.begin() + offset, body.begin() + offset + key_size);
+        offset += key_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();
+            }
+        }
+        return true;
+    }
+};
+
+} // namespace couchbase::protocol

data/ext/couchbase/protocol/cmd_decrement.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
+
+#include <protocol/unsigned_leb128.h>
+
+#include <protocol/client_opcode.hxx>
+#include <document_id.hxx>
+
+namespace couchbase::protocol
+{
+
+class decrement_response_body
+{
+  public:
+    static const inline client_opcode opcode = client_opcode::decrement;
+
+  private:
+    mutation_token token_;
+    std::uint64_t content_;
+
+  public:
+    std::uint64_t content()
+    {
+        return content_;
+    }
+
+    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) {
+            using offset_type = std::vector<uint8_t>::difference_type;
+            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;
+            }
+            memcpy(&content_, body.data() + offset, sizeof(content_));
+            content_ = utils::byte_swap_64(content_);
+            return true;
+        }
+        return false;
+    }
+};
+
+class decrement_request_body
+{
+  public:
+    using response_body_type = decrement_response_body;
+    static const inline client_opcode opcode = client_opcode::decrement;
+
+  private:
+    std::string key_;
+    std::vector<std::uint8_t> framing_extras_{};
+    std::uint64_t delta_{ 1 };
+    std::uint64_t initial_value_{ 0 };
+    std::uint32_t expiration_{ 0 };
+    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 delta(std::uint64_t value)
+    {
+        delta_ = value;
+    }
+
+    void initial_value(std::uint64_t value)
+    {
+        initial_value_ = value;
+    }
+
+    void expiration(std::uint32_t value)
+    {
+        expiration_ = value;
+    }
+
+    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>& framing_extras()
+    {
+        return framing_extras_;
+    }
+
+    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;
+    }
+
+    [[nodiscard]] std::size_t size()
+    {
+        if (extras_.empty()) {
+            fill_extras();
+        }
+        return extras_.size() + key_.size();
+    }
+
+  private:
+    void fill_extras()
+    {
+        extras_.resize(sizeof(delta_) + sizeof(initial_value_) + sizeof(expiration_));
+        using offset_type = std::vector<uint8_t>::difference_type;
+        offset_type offset = 0;
+
+        std::uint64_t num = utils::byte_swap_64(delta_);
+        memcpy(extras_.data() + offset, &num, sizeof(num));
+        offset += static_cast<offset_type>(sizeof(delta_));
+
+        num = utils::byte_swap_64(initial_value_);
+        memcpy(extras_.data() + offset, &num, sizeof(num));
+        offset += static_cast<offset_type>(sizeof(delta_));
+
+        std::uint32_t ttl = htonl(expiration_);
+        memcpy(extras_.data() + offset, &ttl, sizeof(ttl));
+    }
+};
+
+} // namespace couchbase::protocol

data/ext/couchbase/protocol/cmd_exists.hxx

@@ -0,0 +1,171 @@
+/* -*- 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 exists_response_body
+{
+  public:
+    static const inline client_opcode opcode = client_opcode::observe;
+
+  private:
+    std::uint16_t partition_id_;
+    std::string key_;
+    std::uint8_t status_;
+    std::uint64_t cas_;
+
+  public:
+    [[nodiscard]] std::uint16_t partition_id()
+    {
+        return partition_id_;
+    }
+
+    [[nodiscard]] std::uint64_t cas()
+    {
+        return cas_;
+    }
+
+    [[nodiscard]] const std::string& key()
+    {
+        return key_;
+    }
+
+    [[nodiscard]] std::uint8_t status()
+    {
+        return status_;
+    }
+
+    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) {
+            using offset_type = std::vector<uint8_t>::difference_type;
+            offset_type offset = framing_extras_size + extras_size + key_size;
+
+            memcpy(&partition_id_, body.data() + offset, sizeof(partition_id_));
+            partition_id_ = ntohs(partition_id_);
+            offset += static_cast<offset_type>(sizeof(partition_id_));
+
+            std::uint16_t key_len{};
+            memcpy(&key_len, body.data() + offset, sizeof(key_len));
+            key_len = ntohs(key_len);
+            offset += static_cast<offset_type>(sizeof(key_len));
+
+            key_.resize(key_len);
+            memcpy(key_.data(), body.data() + offset, key_len);
+            offset += key_len;
+
+            status_ = body[static_cast<std::size_t>(offset)];
+            offset++;
+
+            memcpy(&cas_, body.data() + offset, sizeof(cas_));
+        }
+        return false;
+    }
+};
+
+class exists_request_body
+{
+  public:
+    using response_body_type = exists_response_body;
+    static const inline client_opcode opcode = client_opcode::observe;
+
+  private:
+    std::uint16_t partition_id_;
+    std::string key_;
+    std::vector<std::uint8_t> value_{};
+
+  public:
+    void id(std::uint16_t partition_id, const document_id& id)
+    {
+        partition_id_ = partition_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()
+    {
+        /* for observe key goes in the body */
+        static std::string empty;
+        return empty;
+    }
+
+    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()
+    {
+        if (value_.empty()) {
+            fill_body();
+        }
+        return value_;
+    }
+
+    std::size_t size()
+    {
+        if (value_.empty()) {
+            fill_body();
+        }
+        return value_.size();
+    }
+
+  private:
+    void fill_body()
+    {
+        std::vector<std::uint8_t>::size_type offset = 0;
+
+        value_.resize(2 * sizeof(std::uint16_t) + key_.size());
+
+        uint16_t field = htons(partition_id_);
+        memcpy(value_.data() + offset, &field, sizeof(field));
+        offset += sizeof(field);
+
+        field = htons(static_cast<uint16_t>(key_.size()));
+        memcpy(value_.data() + offset, &field, sizeof(field));
+        offset += sizeof(field);
+
+        std::memcpy(value_.data() + offset, key_.data(), key_.size());
+    }
+};
+
+} // namespace couchbase::protocol

data/ext/couchbase/protocol/cmd_get.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
 {
@@ -40,17 +40,30 @@ class get_response_body
         return value_;
     }
 
-    bool parse(protocol::status status, const header_buffer& header, const std::vector<uint8_t>& body, const cmd_info&)
+    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 = 0;
-            uint8_t ext_size = header[4];
-            if (ext_size == 4) {
-                memcpy(&flags_, body.data(), sizeof(flags_));
+            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;
         }
@@ -68,9 +81,13 @@ class get_request_body
     std::string key_;
 
   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());
+        }
     }
 
     const std::string& key()
@@ -78,7 +95,13 @@ class get_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;