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

data/ext/couchbase/operations/command.hxx

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include <io/key_value_session.hxx>
+#include <io/mcbp_session.hxx>
 #include <io/http_session.hxx>
 
 namespace couchbase::operations
@@ -38,18 +38,18 @@ struct command : public std::enable_shared_from_this> {
     }
 
     template<typename Handler>
-    void send_to(std::shared_ptr<io::key_value_session> session, Handler&& handler)
+    void send_to(std::shared_ptr<io::mcbp_session> session, Handler&& handler)
     {
         request.opaque = session->next_opaque();
         request.encode_to(encoded);
-        session->write_and_subscribe(request.opaque,
-                                     encoded.data(),
-                                     [self = this->shared_from_this(),
-                                      handler = std::forward<Handler>(handler)](std::error_code ec, io::binary_message&& msg) mutable {
-                                         encoded_response_type resp(msg);
-                                         self->deadline.cancel();
-                                         handler(make_response(ec, self->request, resp));
-                                     });
+        session->write_and_subscribe(
+          request.opaque,
+          encoded.data(session->supports_feature(protocol::hello_feature::snappy)),
+          [self = this->shared_from_this(), handler = std::forward<Handler>(handler)](std::error_code ec, io::mcbp_message&& msg) mutable {
+              encoded_response_type resp(msg);
+              self->deadline.cancel();
+              handler(make_response(ec, self->request, resp));
+          });
         deadline.expires_after(std::chrono::milliseconds(2500));
         deadline.async_wait(std::bind(&command<Request>::deadline_handler, this));
     }

data/ext/couchbase/operations/document_decrement.hxx

@@ -0,0 +1,80 @@
+/* -*- 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 <document_id.hxx>
+#include <protocol/cmd_decrement.hxx>
+
+namespace couchbase::operations
+{
+
+struct decrement_response {
+    document_id id;
+    std::error_code ec{};
+    std::uint64_t content{};
+    std::uint64_t cas{};
+    mutation_token token{};
+};
+
+struct decrement_request {
+    using encoded_request_type = protocol::client_request<protocol::decrement_request_body>;
+    using encoded_response_type = protocol::client_response<protocol::decrement_response_body>;
+
+    document_id id;
+    std::uint16_t partition{};
+    std::uint32_t opaque{};
+    std::uint32_t expiration{ 0 };
+    std::uint64_t delta{ 1 };
+    std::optional<std::uint64_t> initial_value{};
+    protocol::durability_level durability_level{ protocol::durability_level::none };
+    std::optional<std::uint16_t> durability_timeout{};
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.opaque(opaque);
+        encoded.partition(partition);
+        encoded.body().id(id);
+        encoded.body().delta(delta);
+        if (initial_value) {
+            encoded.body().initial_value(initial_value.value());
+            encoded.body().expiration(expiration);
+        } else {
+            encoded.body().initial_value(0);
+            encoded.body().expiration(0xffff'ffff);
+        }
+        if (durability_level != protocol::durability_level::none) {
+            encoded.body().durability(durability_level, durability_timeout);
+        }
+    }
+};
+
+decrement_response
+make_response(std::error_code ec, decrement_request& request, decrement_request::encoded_response_type encoded)
+{
+    decrement_response response{ request.id, ec };
+    if (!ec) {
+        response.cas = encoded.cas();
+        response.content = encoded.body().content();
+        response.token = encoded.body().token();
+        response.token.partition_id = request.partition;
+        response.token.bucket_name = response.id.bucket;
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/document_exists.hxx

@@ -0,0 +1,80 @@
+/* -*- 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 <document_id.hxx>
+#include <protocol/cmd_exists.hxx>
+
+namespace couchbase::operations
+{
+
+struct exists_response {
+    enum class observe_status { invalid, found, not_found, persisted, logically_deleted };
+
+    document_id id;
+    std::error_code ec{};
+    std::uint16_t partition_id{};
+    std::uint64_t cas{};
+    observe_status status{ observe_status::invalid };
+};
+
+struct exists_request {
+    using encoded_request_type = protocol::client_request<protocol::exists_request_body>;
+    using encoded_response_type = protocol::client_response<protocol::exists_response_body>;
+
+    document_id id;
+    std::uint16_t partition{};
+    std::uint32_t opaque{};
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.opaque(opaque);
+        encoded.body().id(partition, id);
+    }
+};
+
+exists_response
+make_response(std::error_code ec, exists_request& request, exists_request::encoded_response_type encoded)
+{
+    exists_response response{ request.id, ec, request.partition };
+    if (!ec) {
+        response.cas = encoded.body().cas();
+        response.partition_id = encoded.body().partition_id();
+        switch (encoded.body().status()) {
+            case 0x00:
+                response.status = exists_response::observe_status::found;
+                break;
+            case 0x01:
+                response.status = exists_response::observe_status::persisted;
+                break;
+            case 0x80:
+                response.status = exists_response::observe_status::not_found;
+                break;
+            case 0x81:
+                response.status = exists_response::observe_status::logically_deleted;
+                break;
+            default:
+                spdlog::warn("invalid observe status for \"{}\": {:x}", request.id, encoded.body().status());
+                response.status = exists_response::observe_status::invalid;
+                break;
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/{get.hxx → document_get.hxx}

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include <operations/document_id.hxx>
+#include <document_id.hxx>
 #include <protocol/cmd_get.hxx>
 
 namespace couchbase::operations
@@ -28,6 +28,7 @@ struct get_response {
     std::error_code ec{};
     std::string value{};
     std::uint64_t cas{};
+    std::uint32_t flags{};
 };
 
 struct get_request {
@@ -53,8 +54,9 @@ make_response(std::error_code ec, get_request& request, get_request::encoded_res
     if (!ec) {
         response.value = std::move(encoded.body().value());
         response.cas = encoded.cas();
+        response.flags = encoded.body().flags();
     }
     return response;
 }
 
-} // namespace couchbase::operations
+} // namespace couchbase::operations

data/ext/couchbase/operations/document_get_and_lock.hxx

@@ -0,0 +1,64 @@
+/* -*- 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 <document_id.hxx>
+#include <protocol/cmd_get_and_lock.hxx>
+
+namespace couchbase::operations
+{
+
+struct get_and_lock_response {
+    document_id id;
+    std::error_code ec{};
+    std::string value{};
+    std::uint64_t cas{};
+    std::uint32_t flags{};
+};
+
+struct get_and_lock_request {
+    using encoded_request_type = protocol::client_request<protocol::get_and_lock_request_body>;
+    using encoded_response_type = protocol::client_response<protocol::get_and_lock_response_body>;
+
+    document_id id;
+    uint16_t partition{};
+    uint32_t opaque{};
+    uint32_t lock_time{};
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.opaque(opaque);
+        encoded.partition(partition);
+        encoded.body().id(id);
+        encoded.body().lock_time(lock_time);
+    }
+};
+
+get_and_lock_response
+make_response(std::error_code ec, get_and_lock_request& request, get_and_lock_request::encoded_response_type encoded)
+{
+    get_and_lock_response response{ request.id, ec };
+    if (!ec) {
+        response.value = std::move(encoded.body().value());
+        response.cas = encoded.cas();
+        response.flags = encoded.body().flags();
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/document_get_and_touch.hxx

@@ -0,0 +1,64 @@
+/* -*- 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 <document_id.hxx>
+#include <protocol/cmd_get_and_touch.hxx>
+
+namespace couchbase::operations
+{
+
+struct get_and_touch_response {
+    document_id id;
+    std::error_code ec{};
+    std::string value{};
+    std::uint64_t cas{};
+    std::uint32_t flags{};
+};
+
+struct get_and_touch_request {
+    using encoded_request_type = protocol::client_request<protocol::get_and_touch_request_body>;
+    using encoded_response_type = protocol::client_response<protocol::get_and_touch_response_body>;
+
+    document_id id;
+    uint16_t partition{};
+    uint32_t opaque{};
+    uint32_t expiration{};
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.opaque(opaque);
+        encoded.partition(partition);
+        encoded.body().id(id);
+        encoded.body().expiration(expiration);
+    }
+};
+
+get_and_touch_response
+make_response(std::error_code ec, get_and_touch_request& request, get_and_touch_request::encoded_response_type encoded)
+{
+    get_and_touch_response response{ request.id, ec };
+    if (!ec) {
+        response.value = std::move(encoded.body().value());
+        response.cas = encoded.cas();
+        response.flags = encoded.body().flags();
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/document_increment.hxx

@@ -0,0 +1,80 @@
+/* -*- 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 <document_id.hxx>
+#include <protocol/cmd_increment.hxx>
+
+namespace couchbase::operations
+{
+
+struct increment_response {
+    document_id id;
+    std::error_code ec{};
+    std::uint64_t content{};
+    std::uint64_t cas{};
+    mutation_token token{};
+};
+
+struct increment_request {
+    using encoded_request_type = protocol::client_request<protocol::increment_request_body>;
+    using encoded_response_type = protocol::client_response<protocol::increment_response_body>;
+
+    document_id id;
+    std::uint16_t partition{};
+    std::uint32_t opaque{};
+    std::uint32_t expiration{ 0 };
+    std::uint64_t delta{ 1 };
+    std::optional<std::uint64_t> initial_value{};
+    protocol::durability_level durability_level{ protocol::durability_level::none };
+    std::optional<std::uint16_t> durability_timeout{};
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.opaque(opaque);
+        encoded.partition(partition);
+        encoded.body().id(id);
+        encoded.body().delta(delta);
+        if (initial_value) {
+            encoded.body().initial_value(initial_value.value());
+            encoded.body().expiration(expiration);
+        } else {
+            encoded.body().initial_value(0);
+            encoded.body().expiration(0xffff'ffff);
+        }
+        if (durability_level != protocol::durability_level::none) {
+            encoded.body().durability(durability_level, durability_timeout);
+        }
+    }
+};
+
+increment_response
+make_response(std::error_code ec, increment_request& request, increment_request::encoded_response_type encoded)
+{
+    increment_response response{ request.id, ec };
+    if (!ec) {
+        response.cas = encoded.cas();
+        response.content = encoded.body().content();
+        response.token = encoded.body().token();
+        response.token.partition_id = request.partition;
+        response.token.bucket_name = response.id.bucket;
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/document_insert.hxx

@@ -0,0 +1,74 @@
+/* -*- 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 <document_id.hxx>
+#include <protocol/cmd_insert.hxx>
+#include <protocol/durability_level.hxx>
+
+namespace couchbase::operations
+{
+
+struct insert_response {
+    document_id id;
+    std::error_code ec{};
+    std::uint64_t cas{};
+    mutation_token token{};
+};
+
+struct insert_request {
+    using encoded_request_type = protocol::client_request<protocol::insert_request_body>;
+    using encoded_response_type = protocol::client_response<protocol::insert_response_body>;
+
+    document_id id;
+    std::string value;
+    uint16_t partition{};
+    uint32_t opaque{};
+    uint32_t flags{ 0 };
+    uint32_t expiration{ 0 };
+    protocol::durability_level durability_level{ protocol::durability_level::none };
+    std::optional<std::uint16_t> durability_timeout{};
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.opaque(opaque);
+        encoded.partition(partition);
+        encoded.body().id(id);
+        encoded.body().expiration(expiration);
+        encoded.body().flags(flags);
+        encoded.body().content(value);
+        if (durability_level != protocol::durability_level::none) {
+            encoded.body().durability(durability_level, durability_timeout);
+        }
+    }
+};
+
+insert_response
+make_response(std::error_code ec, insert_request& request, insert_request::encoded_response_type encoded)
+{
+    insert_response response{ request.id, ec };
+    if (!ec) {
+        response.cas = encoded.cas();
+        response.token = encoded.body().token();
+        response.token.partition_id = request.partition;
+        response.token.bucket_name = response.id.bucket;
+    }
+    return response;
+}
+
+} // namespace couchbase::operations