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

data/ext/couchbase/{operations/document_id.hxx → document_id.hxx}

@@ -17,19 +17,20 @@
 
 #pragma once
 
-namespace couchbase::operations
+namespace couchbase
 {
 struct document_id {
     std::string bucket;
     std::string collection;
     std::string key;
+    std::optional<std::uint32_t> collection_uid; // filled with resolved UID during request lifetime
 };
-} // namespace couchbase::operations
+} // namespace couchbase
 
 template<>
-struct fmt::formatter<couchbase::operations::document_id> : formatter<std::string> {
+struct fmt::formatter<couchbase::document_id> : formatter<std::string> {
     template<typename FormatContext>
-    auto format(const couchbase::operations::document_id& id, FormatContext& ctx)
+    auto format(const couchbase::document_id& id, FormatContext& ctx)
     {
         format_to(ctx.out(), "{}/{}/{}", id.bucket, id.collection, id.key);
         return formatter<std::string>::format("", ctx);

data/ext/couchbase/io/http_message.hxx

@@ -17,9 +17,12 @@
 
 #pragma once
 
+#include <service_type.hxx>
+
 namespace couchbase::io
 {
 struct http_request {
+    service_type type;
     std::string method;
     std::string path;
     std::map<std::string, std::string> headers;
@@ -27,7 +30,8 @@ struct http_request {
 };
 
 struct http_response {
-    std::string status;
+    uint32_t status_code;
+    std::string status_message;
     std::map<std::string, std::string> headers;
     std::string body;
 };

data/ext/couchbase/io/http_parser.hxx

@@ -98,7 +98,8 @@ struct http_parser {
 
     int on_status(const char* at, std::size_t length)
     {
-        response.status.assign(at, length);
+        response.status_message.assign(at, length);
+        response.status_code = parser_.status_code;
         return 0;
     }
 

data/ext/couchbase/io/http_session.hxx

@@ -148,7 +148,7 @@ class http_session : public std::enable_shared_from_this
         }
         endpoints_ = endpoints;
         do_connect(endpoints_.begin());
-        deadline_timer_.async_wait(std::bind(&http_session::check_deadline, this));
+        deadline_timer_.async_wait(std::bind(&http_session::check_deadline, this, std::placeholders::_1));
     }
 
     void do_connect(asio::ip::tcp::resolver::results_type::iterator it)
@@ -180,8 +180,11 @@ class http_session : public std::enable_shared_from_this
         }
     }
 
-    void check_deadline()
+    void check_deadline(std::error_code ec)
     {
+        if (ec == asio::error::operation_aborted) {
+            return;
+        }
         if (stopped_) {
             return;
         }
@@ -189,7 +192,7 @@ class http_session : public std::enable_shared_from_this
             socket_.close();
             deadline_timer_.expires_at(asio::steady_timer::time_point::max());
         }
-        deadline_timer_.async_wait(std::bind(&http_session::check_deadline, this));
+        deadline_timer_.async_wait(std::bind(&http_session::check_deadline, this, std::placeholders::_1));
     }
 
     void do_read()

data/ext/couchbase/io/{binary_message.hxx → mcbp_message.hxx}

@@ -17,22 +17,25 @@
 
 #pragma once
 
+#include <cstdint>
+#include <vector>
+
 namespace couchbase::io
 {
 struct binary_header {
-    uint8_t magic;
-    uint8_t opcode;
-    uint16_t keylen;
-    uint8_t extlen;
-    uint8_t datatype;
-    uint16_t specific;
-    uint32_t bodylen;
-    uint32_t opaque;
-    uint64_t cas;
+    std::uint8_t magic;
+    std::uint8_t opcode;
+    std::uint16_t keylen;
+    std::uint8_t extlen;
+    std::uint8_t datatype;
+    std::uint16_t specific;
+    std::uint32_t bodylen;
+    std::uint32_t opaque;
+    std::uint64_t cas;
 };
 
-struct binary_message {
+struct mcbp_message {
     binary_header header;
-    std::vector<uint8_t> body;
+    std::vector<std::uint8_t> body;
 };
-} // namespace couchbase::io
+} // namespace couchbase::io

data/ext/couchbase/io/mcbp_parser.hxx

@@ -0,0 +1,99 @@
+/* -*- 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 <snappy.h>
+
+#include <gsl/gsl_assert>
+#include <protocol/magic.hxx>
+#include <protocol/datatype.hxx>
+
+#include <spdlog/fmt/bin_to_hex.h>
+
+namespace couchbase::io
+{
+struct mcbp_parser {
+    enum result { ok, need_data, failure };
+
+    template<typename Iterator>
+    void feed(Iterator begin, Iterator end)
+    {
+        buf.reserve(buf.size() + static_cast<size_t>(std::distance(begin, end)));
+        std::copy(begin, end, std::back_inserter(buf));
+    }
+
+    void reset()
+    {
+        buf.clear();
+    }
+
+    result next(mcbp_message& msg)
+    {
+        static const size_t header_size = 24;
+        if (buf.size() < header_size) {
+            return need_data;
+        }
+        std::memcpy(&msg.header, buf.data(), header_size);
+        uint32_t body_size = ntohl(msg.header.bodylen);
+        if (body_size > 0 && buf.size() - header_size < body_size) {
+            return need_data;
+        }
+        msg.body.clear();
+        msg.body.reserve(body_size);
+        uint32_t key_size = ntohs(msg.header.keylen);
+        uint32_t prefix_size = uint32_t(msg.header.extlen) + key_size;
+        if (msg.header.magic == static_cast<uint8_t>(protocol::magic::alt_client_response)) {
+            uint8_t framing_extras_size = msg.header.keylen & 0xfU;
+            key_size = (msg.header.keylen & 0xf0U) >> 8U;
+            prefix_size = uint32_t(framing_extras_size) + uint32_t(msg.header.extlen) + key_size;
+        }
+        std::copy(buf.begin() + header_size, buf.begin() + header_size + prefix_size, std::back_inserter(msg.body));
+
+        bool is_compressed = (msg.header.datatype & static_cast<uint8_t>(protocol::datatype::snappy)) != 0;
+        bool use_raw_value = true;
+        if (is_compressed) {
+            std::string uncompressed;
+            size_t offset = header_size + prefix_size;
+            bool success = snappy::Uncompress(reinterpret_cast<const char*>(buf.data() + offset), body_size - prefix_size, &uncompressed);
+            if (success) {
+                std::copy(uncompressed.begin(), uncompressed.end(), std::back_inserter(msg.body));
+                use_raw_value = false;
+            }
+        }
+        if (use_raw_value) {
+            std::copy(buf.begin() + header_size + prefix_size, buf.begin() + header_size + body_size, std::back_inserter(msg.body));
+        }
+        buf.erase(buf.begin(), buf.begin() + header_size + body_size);
+        if (!protocol::is_valid_magic(buf[0])) {
+            spdlog::warn("parsed frame for magic={:x}, opcode={:x}, opaque={}, body_len={}. Invalid magic of the next frame: {:x}, {} "
+                         "bytes to parse{}",
+                         msg.header.magic,
+                         msg.header.opcode,
+                         msg.header.opaque,
+                         body_size,
+                         buf[0],
+                         buf.size(),
+                         spdlog::to_hex(buf));
+            reset();
+        }
+        return ok;
+    }
+
+    std::vector<std::uint8_t> buf;
+};
+} // namespace couchbase::io

data/ext/couchbase/io/{key_value_session.hxx → mcbp_session.hxx}

@@ -25,12 +25,13 @@
 
 #include <platform/uuid.h>
 
-#include <io/binary_message.hxx>
-#include <io/binary_parser.hxx>
+#include <io/mcbp_message.hxx>
+#include <io/mcbp_parser.hxx>
 
 #include <protocol/hello_feature.hxx>
 #include <protocol/client_request.hxx>
 #include <protocol/client_response.hxx>
+#include <protocol/server_request.hxx>
 #include <protocol/cmd_hello.hxx>
 #include <protocol/cmd_sasl_list_mechs.hxx>
 #include <protocol/cmd_sasl_auth.hxx>
@@ -40,6 +41,7 @@
 #include <protocol/cmd_get_error_map.hxx>
 #include <protocol/cmd_get_collections_manifest.hxx>
 #include <protocol/cmd_get.hxx>
+#include <protocol/cmd_cluster_map_change_notification.hxx>
 
 #include <cbsasl/client.h>
 
@@ -51,12 +53,12 @@
 namespace couchbase::io
 {
 
-class key_value_session : public std::enable_shared_from_this<key_value_session>
+class mcbp_session : public std::enable_shared_from_this<mcbp_session>
 {
     class message_handler
     {
       public:
-        virtual void handle(binary_message&& msg) = 0;
+        virtual void handle(mcbp_message&& msg) = 0;
 
         virtual ~message_handler() = default;
 
@@ -68,14 +70,23 @@ class key_value_session : public std::enable_shared_from_this
     class bootstrap_handler : public message_handler
     {
       private:
-        std::shared_ptr<key_value_session> session_;
+        std::shared_ptr<mcbp_session> session_;
         sasl::ClientContext sasl_;
+        std::atomic_bool stopped_{ false };
 
       public:
-        bootstrap_handler(bootstrap_handler&&) = default;
-        ~bootstrap_handler() = default;
+        ~bootstrap_handler() override = default;
 
-        explicit bootstrap_handler(std::shared_ptr<key_value_session> session)
+        void stop() override
+        {
+            if (stopped_) {
+                return;
+            }
+            stopped_ = true;
+            session_.reset();
+        }
+
+        explicit bootstrap_handler(std::shared_ptr<mcbp_session> session)
           : session_(session)
           , sasl_([this]() -> std::string { return session_->username_; },
                   [this]() -> std::string { return session_->password_; },
@@ -116,7 +127,6 @@ class key_value_session : public std::enable_shared_from_this
 
         void auth_success()
         {
-            spdlog::debug("{} authentication successful", sasl_.get_name());
             session_->authenticated_ = true;
             if (session_->supports_feature(protocol::hello_feature::xerror)) {
                 protocol::client_request<protocol::get_error_map_request_body> errmap_req;
@@ -139,8 +149,11 @@ class key_value_session : public std::enable_shared_from_this
             session_->flush();
         }
 
-        void handle(binary_message&& msg) override
+        void handle(mcbp_message&& msg) override
         {
+            if (stopped_ || !session_) {
+                return;
+            }
             Expects(protocol::is_valid_client_opcode(msg.header.opcode));
             auto opcode = static_cast<protocol::client_opcode>(msg.header.opcode);
             switch (opcode) {
@@ -183,7 +196,7 @@ class key_value_session : public std::enable_shared_from_this
                             return complete(std::make_error_code(error::common_errc::authentication_failure));
                         }
                     } else {
-                        spdlog::warn("unexpected message status during bootstrap: {}", resp.error_message());
+                        spdlog::warn("unexpected message status during bootstrap: {} (opcode={})", resp.error_message(), opcode);
                         return complete(std::make_error_code(error::common_errc::authentication_failure));
                     }
                 } break;
@@ -199,7 +212,7 @@ class key_value_session : public std::enable_shared_from_this
                     if (resp.status() == protocol::status::success) {
                         session_->errmap_.emplace(resp.body().errmap());
                     } else {
-                        spdlog::warn("unexpected message status during bootstrap: {}", resp.error_message());
+                        spdlog::warn("unexpected message status during bootstrap: {} (opcode={})", resp.error_message(), opcode);
                         return complete(std::make_error_code(error::network_errc::protocol_error));
                     }
                 } break;
@@ -214,7 +227,7 @@ class key_value_session : public std::enable_shared_from_this
                                       session_->bucket_name_.value_or(""),
                                       resp.error_message());
                     } else {
-                        spdlog::warn("unexpected message status during bootstrap: {}", resp.error_message());
+                        spdlog::warn("unexpected message status during bootstrap: {} (opcode={})", resp.error_message(), opcode);
                         return complete(std::make_error_code(error::network_errc::protocol_error));
                     }
                 } break;
@@ -237,15 +250,21 @@ class key_value_session : public std::enable_shared_from_this
                     protocol::client_response<protocol::get_cluster_config_response_body> resp(msg);
                     if (resp.status() == protocol::status::success) {
                         session_->update_configuration(resp.body().config());
-                        spdlog::trace("received new configuration: {}", session_->config_.value());
+                        complete({});
+                    } else if (resp.status() == protocol::status::no_bucket && !session_->bucket_name_) {
+                        // bucket-less session, but the server wants bucket
+                        session_->supports_gcccp_ = false;
+                        spdlog::warn("this server does not support GCCCP, open bucket before making any cluster-level command");
+                        session_->update_configuration(
+                          make_blank_configuration(session_->endpoint_.address().to_string(), session_->endpoint_.port(), 0));
                         complete({});
                     } else {
-                        spdlog::warn("unexpected message status during bootstrap: {}", resp.error_message());
+                        spdlog::warn("unexpected message status during bootstrap: {} (opcode={})", resp.error_message(), opcode);
                         return complete(std::make_error_code(error::network_errc::protocol_error));
                     }
                 } break;
                 default:
-                    spdlog::trace("unexpected message during bootstrap: {}", opcode);
+                    spdlog::warn("unexpected message during bootstrap: {}", opcode);
                     return complete(std::make_error_code(error::network_errc::protocol_error));
             }
         }
@@ -254,75 +273,124 @@ class key_value_session : public std::enable_shared_from_this
     class normal_handler : public message_handler
     {
       private:
-        std::shared_ptr<key_value_session> session_;
+        std::shared_ptr<mcbp_session> session_;
         asio::steady_timer heartbeat_timer_;
+        std::atomic_bool stopped_{ false };
 
       public:
-        normal_handler(normal_handler&&) = default;
-        ~normal_handler() = default;
+        ~normal_handler() override = default;
 
-        explicit normal_handler(std::shared_ptr<key_value_session> session)
+        explicit normal_handler(std::shared_ptr<mcbp_session> session)
           : session_(session)
           , heartbeat_timer_(session_->ctx_)
         {
-            fetch_config();
+            if (session_->supports_gcccp_) {
+                fetch_config({});
+            }
         }
 
         void stop() override
         {
+            if (stopped_) {
+                return;
+            }
+            stopped_ = true;
             heartbeat_timer_.cancel();
+            session_.reset();
         }
 
-        void handle(binary_message&& msg) override
+        void handle(mcbp_message&& msg) override
         {
-            if (session_->stopped_) {
+            if (stopped_ || !session_) {
                 return;
             }
-            Expects(protocol::is_valid_client_opcode(msg.header.opcode));
-            switch (auto opcode = static_cast<protocol::client_opcode>(msg.header.opcode)) {
-                case protocol::client_opcode::get_cluster_config: {
-                    protocol::client_response<protocol::get_cluster_config_response_body> resp(msg);
-                    if (resp.status() == protocol::status::success) {
-                        session_->update_configuration(resp.body().config());
-                    } else {
-                        spdlog::warn("unexpected message status: {}", resp.error_message());
+            Expects(protocol::is_valid_magic(msg.header.magic));
+            switch (auto magic = static_cast<protocol::magic>(msg.header.magic)) {
+                case protocol::magic::client_response:
+                case protocol::magic::alt_client_response:
+                    Expects(protocol::is_valid_client_opcode(msg.header.opcode));
+                    switch (auto opcode = static_cast<protocol::client_opcode>(msg.header.opcode)) {
+                        case protocol::client_opcode::get_cluster_config: {
+                            protocol::client_response<protocol::get_cluster_config_response_body> resp(msg);
+                            if (resp.status() == protocol::status::success) {
+                                if (session_) {
+                                    session_->update_configuration(resp.body().config());
+                                }
+                            } else {
+                                spdlog::warn("unexpected message status: {}", resp.error_message());
+                            }
+                        } break;
+                        case protocol::client_opcode::get:
+                        case protocol::client_opcode::get_and_lock:
+                        case protocol::client_opcode::get_and_touch:
+                        case protocol::client_opcode::touch:
+                        case protocol::client_opcode::insert:
+                        case protocol::client_opcode::replace:
+                        case protocol::client_opcode::upsert:
+                        case protocol::client_opcode::remove:
+                        case protocol::client_opcode::observe:
+                        case protocol::client_opcode::unlock:
+                        case protocol::client_opcode::increment:
+                        case protocol::client_opcode::decrement:
+                        case protocol::client_opcode::subdoc_multi_lookup:
+                        case protocol::client_opcode::subdoc_multi_mutation: {
+                            std::uint32_t opaque = msg.header.opaque;
+                            std::uint16_t status = ntohs(msg.header.specific);
+                            auto handler = session_->command_handlers_.find(opaque);
+                            if (handler != session_->command_handlers_.end()) {
+                                handler->second(session_->map_status_code(opcode, status), std::move(msg));
+                                session_->command_handlers_.erase(handler);
+                            } else {
+                                spdlog::debug("unexpected orphan response opcode={}, opaque={}", msg.header.opcode, msg.header.opaque);
+                            }
+                        } break;
+                        default:
+                            spdlog::warn("unexpected client response: {}", opcode);
                     }
-                } break;
-                case protocol::client_opcode::get:
-                case protocol::client_opcode::upsert:
-                case protocol::client_opcode::remove:
-                case protocol::client_opcode::subdoc_multi_lookup:
-                case protocol::client_opcode::subdoc_multi_mutation: {
-                    std::uint32_t opaque = msg.header.opaque;
-                    std::uint16_t status = ntohs(msg.header.specific);
-                    auto handler = session_->command_handlers_.find(opaque);
-                    if (handler != session_->command_handlers_.end()) {
-                        handler->second(session_->map_status_code(opcode, status), std::move(msg));
-                        session_->command_handlers_.erase(handler);
-                    } else {
-                        spdlog::trace("unexpected orphan response opcode={}, opaque={}", msg.header.opcode, msg.header.opaque);
+                    break;
+                case protocol::magic::server_request:
+                    Expects(protocol::is_valid_server_request_opcode(msg.header.opcode));
+                    switch (auto opcode = static_cast<protocol::server_opcode>(msg.header.opcode)) {
+                        case protocol::server_opcode::cluster_map_change_notification: {
+                            protocol::server_request<protocol::cluster_map_change_notification_request_body> req(msg);
+                            if (session_) {
+                                if ((!req.body().config().bucket.has_value() && req.body().bucket().empty()) ||
+                                    (session_->bucket_name_.has_value() && !req.body().bucket().empty() &&
+                                     session_->bucket_name_.value() == req.body().bucket())) {
+                                    session_->update_configuration(req.body().config());
+                                }
+                            }
+                        } break;
+                        default:
+                            spdlog::warn("unexpected server request: {}", opcode);
                     }
-                } break;
-                default:
-                    spdlog::trace("unexpected message: {}", opcode);
+                    break;
+                case protocol::magic::client_request:
+                case protocol::magic::alt_client_request:
+                case protocol::magic::server_response:
+                    spdlog::warn("unexpected magic: {}, opcode={}, opaque={}", magic, msg.header.opcode, msg.header.opaque);
+                    break;
             }
         }
 
-        void fetch_config()
+        void fetch_config(std::error_code ec)
         {
-            if (session_->stopped_) {
+            if (ec == asio::error::operation_aborted) {
+                return;
+            }
+            if (stopped_ || !session_) {
                 return;
             }
             protocol::client_request<protocol::get_cluster_config_request_body> req;
             req.opaque(session_->next_opaque());
             session_->write_and_flush(req.data());
             heartbeat_timer_.expires_after(std::chrono::milliseconds(2500));
-            heartbeat_timer_.async_wait(std::bind(&normal_handler::fetch_config, this));
+            heartbeat_timer_.async_wait(std::bind(&normal_handler::fetch_config, this, std::placeholders::_1));
         }
     };
 
   public:
-    key_value_session(uuid::uuid_t client_id, asio::io_context& ctx, std::optional<std::string> bucket_name = {})
+    mcbp_session(uuid::uuid_t client_id, asio::io_context& ctx, std::optional<std::string> bucket_name = {})
       : client_id_(client_id)
       , id_(uuid::random())
       , ctx_(ctx)
@@ -334,7 +402,7 @@ class key_value_session : public std::enable_shared_from_this
     {
     }
 
-    ~key_value_session()
+    ~mcbp_session()
     {
         stop();
     }
@@ -343,13 +411,13 @@ class key_value_session : public std::enable_shared_from_this
                    const std::string& service,
                    const std::string& username,
                    const std::string& password,
-                   std::function<void(std::error_code)>&& handler)
+                   std::function<void(std::error_code, configuration)>&& handler)
     {
         username_ = username;
         password_ = password;
         bootstrap_handler_ = std::move(handler);
         resolver_.async_resolve(
-          hostname, service, std::bind(&key_value_session::on_resolve, this, std::placeholders::_1, std::placeholders::_2));
+          hostname, service, std::bind(&mcbp_session::on_resolve, this, std::placeholders::_1, std::placeholders::_2));
     }
 
     [[nodiscard]] std::string id()
@@ -359,19 +427,18 @@ class key_value_session : public std::enable_shared_from_this
 
     void stop()
     {
-        stopped_ = true;
-        if (handler_) {
-            handler_->stop();
+        if (stopped_) {
+            return;
         }
+        stopped_ = true;
+        deadline_timer_.cancel();
+        resolver_.cancel();
         if (socket_.is_open()) {
             socket_.close();
         }
-        deadline_timer_.cancel();
-    }
-
-    bool is_stopped()
-    {
-        return stopped_;
+        if (handler_) {
+            handler_->stop();
+        }
     }
 
     void write(const std::vector<uint8_t>& buf)
@@ -401,13 +468,22 @@ class key_value_session : public std::enable_shared_from_this
 
     void write_and_subscribe(uint32_t opaque,
                              std::vector<std::uint8_t>& data,
-                             std::function<void(std::error_code, io::binary_message&&)> handler)
+                             std::function<void(std::error_code, io::mcbp_message&&)> handler)
     {
         if (stopped_) {
             return;
         }
         command_handlers_.emplace(opaque, std::move(handler));
-        write_and_flush(data);
+        if (bootstrapped_ && socket_.is_open()) {
+            write_and_flush(data);
+        } else {
+            pending_buffer_.push_back(data);
+        }
+    }
+
+    [[nodiscard]] std::optional<collections_manifest> manifest()
+    {
+        return manifest_;
     }
 
     bool supports_feature(protocol::hello_feature feature)
@@ -415,6 +491,11 @@ class key_value_session : public std::enable_shared_from_this
         return std::find(supported_features_.begin(), supported_features_.end(), feature) != supported_features_.end();
     }
 
+    bool supports_gcccp()
+    {
+        return supports_gcccp_;
+    }
+
     [[nodiscard]] bool has_config() const
     {
         return config_.has_value();
@@ -570,23 +651,15 @@ class key_value_session : public std::enable_shared_from_this
                 break;
         }
         // FIXME: use error map here
+        spdlog::warn("unknown status code: {} (opcode={})", status, opcode);
         return std::make_error_code(error::network_errc::protocol_error);
     }
 
-    template<typename Handler>
-    void subscribe_to_configuration_updates(Handler&& handler)
-    {
-        configuration_listeners_.emplace_back(std::forward<Handler>(handler));
-    }
-
     void update_configuration(configuration&& config)
     {
         if (!config_ || config.rev > config_->rev) {
             config_.emplace(config);
             spdlog::trace("received new configuration: {}", config_.value());
-            for (auto& listener : configuration_listeners_) {
-                listener(config_.value());
-            }
         }
     }
 
@@ -594,32 +667,45 @@ class key_value_session : public std::enable_shared_from_this
     void invoke_bootstrap_handler(std::error_code ec)
     {
         if (!bootstrapped_ && bootstrap_handler_) {
-            bootstrap_handler_(ec);
+            bootstrap_handler_(ec, config_.value_or(configuration{}));
             bootstrap_handler_ = nullptr;
         }
         bootstrapped_ = true;
         if (ec) {
             stop();
         }
+        if (!pending_buffer_.empty()) {
+            for (const auto& buf : pending_buffer_) {
+                write(buf);
+            }
+            pending_buffer_.clear();
+            flush();
+        }
     }
 
     void on_resolve(std::error_code ec, const asio::ip::tcp::resolver::results_type& endpoints)
     {
+        if (stopped_) {
+            return;
+        }
         if (ec) {
             spdlog::error("error on resolve: {}", ec.message());
             return invoke_bootstrap_handler(std::make_error_code(error::network_errc::resolve_failure));
         }
         endpoints_ = endpoints;
         do_connect(endpoints_.begin());
-        deadline_timer_.async_wait(std::bind(&key_value_session::check_deadline, this));
+        deadline_timer_.async_wait(std::bind(&mcbp_session::check_deadline, this, std::placeholders::_1));
     }
 
     void do_connect(asio::ip::tcp::resolver::results_type::iterator it)
     {
+        if (stopped_) {
+            return;
+        }
         if (it != endpoints_.end()) {
             spdlog::trace("connecting to {}:{}", it->endpoint().address().to_string(), it->endpoint().port());
             deadline_timer_.expires_after(std::chrono::seconds(10));
-            socket_.async_connect(it->endpoint(), std::bind(&key_value_session::on_connect, this, std::placeholders::_1, it));
+            socket_.async_connect(it->endpoint(), std::bind(&mcbp_session::on_connect, this, std::placeholders::_1, it));
         } else {
             spdlog::error("no more endpoints left to connect");
             invoke_bootstrap_handler(std::make_error_code(error::network_errc::no_endpoints_left));
@@ -635,6 +721,8 @@ class key_value_session : public std::enable_shared_from_this
         if (!socket_.is_open() || ec) {
             do_connect(++it);
         } else {
+            socket_.set_option(asio::ip::tcp::no_delay{ true });
+            socket_.set_option(asio::socket_base::keep_alive{ true });
             endpoint_ = it->endpoint();
             spdlog::trace("connected to {}:{}", endpoint_.address().to_string(), it->endpoint().port());
             handler_ = std::make_unique<bootstrap_handler>(shared_from_this());
@@ -643,8 +731,11 @@ class key_value_session : public std::enable_shared_from_this
         }
     }
 
-    void check_deadline()
+    void check_deadline(std::error_code ec)
     {
+        if (ec == asio::error::operation_aborted) {
+            return;
+        }
         if (stopped_) {
             return;
         }
@@ -652,7 +743,7 @@ class key_value_session : public std::enable_shared_from_this
             socket_.close();
             deadline_timer_.expires_at(asio::steady_timer::time_point::max());
         }
-        deadline_timer_.async_wait(std::bind(&key_value_session::check_deadline, this));
+        deadline_timer_.async_wait(std::bind(&mcbp_session::check_deadline, this, std::placeholders::_1));
     }
 
     void do_read()
@@ -660,27 +751,35 @@ class key_value_session : public std::enable_shared_from_this
         if (stopped_) {
             return;
         }
+        if (reading_) {
+            return;
+        }
+        reading_ = true;
         socket_.async_read_some(asio::buffer(input_buffer_),
                                 [self = shared_from_this()](std::error_code ec, std::size_t bytes_transferred) {
-                                    if (self->stopped_) {
+                                    if (ec == asio::error::operation_aborted || self->stopped_) {
                                         return;
                                     }
-                                    if (ec && ec != asio::error::operation_aborted) {
-                                        spdlog::error("IO error while reading from the socket: {}", ec.message());
+                                    if (ec) {
+                                        spdlog::error("[{}] [{}] IO error while reading from the socket: {}",
+                                                      uuid::to_string(self->id_),
+                                                      self->endpoint_.address().to_string(),
+                                                      ec.message());
                                         return self->stop();
                                     }
                                     self->parser_.feed(self->input_buffer_.data(), self->input_buffer_.data() + ssize_t(bytes_transferred));
 
                                     for (;;) {
-                                        binary_message msg{};
+                                        mcbp_message msg{};
                                         switch (self->parser_.next(msg)) {
-                                            case binary_parser::ok:
+                                            case mcbp_parser::ok:
                                                 self->handler_->handle(std::move(msg));
                                                 break;
-                                            case binary_parser::need_data:
+                                            case mcbp_parser::need_data:
+                                                self->reading_ = false;
                                                 return self->do_read();
-                                            case binary_parser::failure:
-                                                ec = std::make_error_code(std::errc::protocol_error);
+                                            case mcbp_parser::failure:
+                                                ec = std::make_error_code(error::common_errc::parsing_failure);
                                                 return self->stop();
                                         }
                                     }
@@ -706,7 +805,10 @@ class key_value_session : public std::enable_shared_from_this
                 return;
             }
             if (ec) {
-                spdlog::error("IO error while writing to the socket: {}", ec.message());
+                spdlog::error("[{}] [{}] IO error while writing to the socket: {}",
+                              uuid::to_string(self->id_),
+                              self->endpoint_.address().to_string(),
+                              ec.message());
                 return self->stop();
             }
             self->writing_buffer_.clear();
@@ -725,24 +827,25 @@ class key_value_session : public std::enable_shared_from_this
     asio::ip::tcp::socket socket_;
     asio::steady_timer deadline_timer_;
     std::optional<std::string> bucket_name_;
-    binary_parser parser_;
+    mcbp_parser parser_;
     std::unique_ptr<message_handler> handler_;
-    std::function<void(std::error_code)> bootstrap_handler_;
-    std::map<uint32_t, std::function<void(std::error_code, io::binary_message&&)>> command_handlers_{};
+    std::function<void(std::error_code, configuration)> bootstrap_handler_;
+    std::map<uint32_t, std::function<void(std::error_code, io::mcbp_message&&)>> command_handlers_{};
 
     bool bootstrapped_{ false };
-    bool stopped_{ false };
+    std::atomic_bool stopped_{ false };
     bool authenticated_{ false };
     bool bucket_selected_{ false };
+    bool supports_gcccp_{ true };
 
     std::atomic<std::uint32_t> opaque_{ 0 };
 
     std::string username_;
     std::string password_;
 
-    std::list<std::function<void(const configuration&)>> configuration_listeners_;
     std::array<std::uint8_t, 16384> input_buffer_{};
     std::vector<std::vector<std::uint8_t>> output_buffer_{};
+    std::vector<std::vector<std::uint8_t>> pending_buffer_{};
     std::vector<std::vector<std::uint8_t>> writing_buffer_{};
     asio::ip::tcp::endpoint endpoint_{}; // connected endpoint
     asio::ip::tcp::resolver::results_type endpoints_;
@@ -750,5 +853,7 @@ class key_value_session : public std::enable_shared_from_this
     std::optional<configuration> config_;
     std::optional<error_map> errmap_;
     std::optional<collections_manifest> manifest_;
+
+    std::atomic_bool reading_{ false };
 };
-} // namespace couchbase::io
+} // namespace couchbase::io