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

data/ext/couchbase/io/http_command.hxx

@@ -0,0 +1,91 @@
+/* -*- 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 <io/http_session.hxx>
+
+namespace couchbase::operations
+{
+
+template<typename Request>
+struct http_command : public std::enable_shared_from_this<http_command<Request>> {
+    using encoded_request_type = typename Request::encoded_request_type;
+    using encoded_response_type = typename Request::encoded_response_type;
+    asio::steady_timer deadline;
+    asio::steady_timer retry_backoff;
+    Request request;
+    encoded_request_type encoded;
+
+    http_command(asio::io_context& ctx, Request req)
+      : deadline(ctx)
+      , retry_backoff(ctx)
+      , request(req)
+    {
+    }
+
+    template<typename Handler>
+    void send_to(std::shared_ptr<io::http_session> session, Handler&& handler)
+    {
+        encoded.type = Request::type;
+        request.encode_to(encoded);
+        encoded.headers["client-context-id"] = request.client_context_id;
+        auto log_prefix = session->log_prefix();
+        spdlog::debug("{} HTTP request: {}, method={}, path={}, client_context_id={}, timeout={}ms",
+                      log_prefix,
+                      encoded.type,
+                      encoded.method,
+                      encoded.path,
+                      request.client_context_id,
+                      request.timeout.count());
+        SPDLOG_TRACE("{} HTTP request: {}, method={}, path={}, client_context_id={}, timeout={}ms{:a}",
+                     log_prefix,
+                     encoded.type,
+                     encoded.method,
+                     encoded.path,
+                     request.client_context_id,
+                     request.timeout.count(),
+                     spdlog::to_hex(encoded.body));
+        session->write_and_subscribe(encoded,
+                                     [self = this->shared_from_this(), log_prefix, handler = std::forward<Handler>(handler)](
+                                       std::error_code ec, io::http_response&& msg) mutable {
+                                         self->deadline.cancel();
+                                         encoded_response_type resp(msg);
+                                         spdlog::debug("{} HTTP response: {}, client_context_id={}, status={}",
+                                                       log_prefix,
+                                                       self->request.type,
+                                                       self->request.client_context_id,
+                                                       resp.status_code);
+                                         SPDLOG_TRACE("{} HTTP response: {}, client_context_id={}, status={}{:a}",
+                                                      log_prefix,
+                                                      self->request.type,
+                                                      self->request.client_context_id,
+                                                      resp.status_code,
+                                                      spdlog::to_hex(resp.body));
+                                         handler(make_response(ec, self->request, resp));
+                                     });
+        deadline.expires_after(request.timeout);
+        deadline.async_wait([session](std::error_code ec) {
+            if (ec == asio::error::operation_aborted) {
+                return;
+            }
+            session->stop();
+        });
+    }
+};
+
+} // namespace couchbase::operations

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

@@ -33,6 +33,7 @@
 #include <io/http_parser.hxx>
 #include <io/http_message.hxx>
 #include <platform/base64.h>
+#include <timeout_defaults.hxx>
 
 namespace couchbase::io
 {
@@ -40,32 +41,61 @@ namespace couchbase::io
 class http_session : public std::enable_shared_from_this<http_session>
 {
   public:
-    http_session(uuid::uuid_t client_id,
+    http_session(const std::string& client_id,
                  asio::io_context& ctx,
                  const std::string& username,
                  const std::string& password,
                  const std::string& hostname,
                  const std::string& service)
       : client_id_(client_id)
-      , id_(uuid::random())
+      , id_(uuid::to_string(uuid::random()))
       , ctx_(ctx)
       , resolver_(ctx_)
-      , strand_(asio::make_strand(ctx_))
-      , socket_(strand_)
+      , stream_(std::make_unique<plain_stream_impl>(ctx_))
       , deadline_timer_(ctx_)
       , username_(username)
       , password_(password)
       , hostname_(hostname)
       , service_(service)
-      , user_agent_(fmt::format("ruby_sdk/{}.{}.{}; client/{}; session/{}",
+      , user_agent_(fmt::format("ruby/{}.{}.{}/{}; client/{}; session/{}; {}",
                                 BACKEND_VERSION_MAJOR,
                                 BACKEND_VERSION_MINOR,
                                 BACKEND_VERSION_PATCH,
-                                uuid::to_string(client_id_),
-                                uuid::to_string(id_)))
+                                BACKEND_GIT_REVISION,
+                                client_id_,
+                                id_,
+                                BACKEND_SYSTEM))
+      , log_prefix_(fmt::format("[{}/{}]", client_id_, id_))
+    {
+    }
+
+    http_session(const std::string& client_id,
+                 asio::io_context& ctx,
+                 asio::ssl::context& tls,
+                 const std::string& username,
+                 const std::string& password,
+                 const std::string& hostname,
+                 const std::string& service)
+      : client_id_(client_id)
+      , id_(uuid::to_string(uuid::random()))
+      , ctx_(ctx)
+      , resolver_(ctx_)
+      , stream_(std::make_unique<tls_stream_impl>(ctx_, tls))
+      , deadline_timer_(ctx_)
+      , username_(username)
+      , password_(password)
+      , hostname_(hostname)
+      , service_(service)
+      , user_agent_(fmt::format("ruby/{}.{}.{}/{}; client/{}; session/{}; {}",
+                                BACKEND_VERSION_MAJOR,
+                                BACKEND_VERSION_MINOR,
+                                BACKEND_VERSION_PATCH,
+                                BACKEND_GIT_REVISION,
+                                client_id_,
+                                id_,
+                                BACKEND_SYSTEM))
+      , log_prefix_(fmt::format("[{}/{}]", client_id_, id_))
     {
-        resolver_.async_resolve(
-          hostname, service, std::bind(&http_session::on_resolve, this, std::placeholders::_1, std::placeholders::_2));
     }
 
     ~http_session()
@@ -73,18 +103,54 @@ class http_session : public std::enable_shared_from_this<http_session>
         stop();
     }
 
-    [[nodiscard]] std::string id()
+    void start()
+    {
+        resolver_.async_resolve(
+          hostname_, service_, std::bind(&http_session::on_resolve, shared_from_this(), std::placeholders::_1, std::placeholders::_2));
+    }
+
+    [[nodiscard]] const std::string& log_prefix() const
+    {
+        return log_prefix_;
+    }
+
+    [[nodiscard]] const std::string& id() const
+    {
+        return id_;
+    }
+
+    [[nodiscard]] const asio::ip::tcp::endpoint& endpoint() const
+    {
+        return endpoint_;
+    }
+
+    void on_stop(std::function<void()> handler)
     {
-        return uuid::to_string(id_);
+        on_stop_handler_ = std::move(handler);
     }
 
     void stop()
     {
         stopped_ = true;
-        if (socket_.is_open()) {
-            socket_.close();
+        if (stream_->is_open()) {
+            stream_->close();
         }
         deadline_timer_.cancel();
+
+        for (auto& handler : command_handlers_) {
+            handler(std::make_error_code(error::common_errc::ambiguous_timeout), {});
+        }
+        command_handlers_.clear();
+
+        if (on_stop_handler_) {
+            on_stop_handler_();
+            on_stop_handler_ = nullptr;
+        }
+    }
+
+    bool keep_alive()
+    {
+        return keep_alive_;
     }
 
     bool is_stopped()
@@ -105,7 +171,7 @@ class http_session : public std::enable_shared_from_this<http_session>
         if (stopped_) {
             return;
         }
-        output_buffer_.emplace_back(buf.begin(), buf.end());
+        output_buffer_.emplace_back(std::vector<uint8_t>{ buf.begin(), buf.end() });
     }
 
     void flush()
@@ -143,22 +209,22 @@ class http_session : public std::enable_shared_from_this<http_session>
     void on_resolve(std::error_code ec, const asio::ip::tcp::resolver::results_type& endpoints)
     {
         if (ec) {
-            spdlog::error("error on resolve: {}", ec.message());
+            spdlog::error("{} error on resolve: {}", log_prefix_, ec.message());
             return;
         }
         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, shared_from_this(), std::placeholders::_1));
     }
 
     void do_connect(asio::ip::tcp::resolver::results_type::iterator it)
     {
         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(&http_session::on_connect, this, std::placeholders::_1, it));
+            spdlog::debug("{} connecting to {}:{}", log_prefix_, it->endpoint().address().to_string(), it->endpoint().port());
+            deadline_timer_.expires_after(timeout_defaults::connect_timeout);
+            stream_->async_connect(it->endpoint(), std::bind(&http_session::on_connect, shared_from_this(), std::placeholders::_1, it));
         } else {
-            spdlog::error("no more endpoints left to connect");
+            spdlog::error("{} no more endpoints left to connect", log_prefix_);
             stop();
         }
     }
@@ -168,28 +234,34 @@ class http_session : public std::enable_shared_from_this<http_session>
         if (stopped_) {
             return;
         }
-        if (!socket_.is_open() || ec) {
+        if (!stream_->is_open() || ec) {
+            spdlog::warn(
+              "{} unable to connect to {}:{}: {}", log_prefix_, it->endpoint().address().to_string(), it->endpoint().port(), ec.message());
             do_connect(++it);
         } else {
             connected_ = true;
             endpoint_ = it->endpoint();
-            spdlog::trace("connected to {}:{}", it->endpoint().address().to_string(), it->endpoint().port());
+            spdlog::debug("{} connected to {}:{}", log_prefix_, it->endpoint().address().to_string(), it->endpoint().port());
+            log_prefix_ = fmt::format("[{}/{}] <{}:{}>", client_id_, id_, endpoint_.address().to_string(), endpoint_.port());
             deadline_timer_.expires_at(asio::steady_timer::time_point::max());
             deadline_timer_.cancel();
             flush();
         }
     }
 
-    void check_deadline()
+    void check_deadline(std::error_code ec)
     {
+        if (ec == asio::error::operation_aborted) {
+            return;
+        }
         if (stopped_) {
             return;
         }
         if (deadline_timer_.expiry() <= asio::steady_timer::clock_type::now()) {
-            socket_.close();
+            stream_->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, shared_from_this(), std::placeholders::_1));
     }
 
     void do_read()
@@ -197,27 +269,30 @@ class http_session : public std::enable_shared_from_this<http_session>
         if (stopped_) {
             return;
         }
-        socket_.async_read_some(
+        stream_->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: {}", self->log_prefix_, ec.message());
                   return self->stop();
               }
 
               switch (self->parser_.feed(reinterpret_cast<const char*>(self->input_buffer_.data()), bytes_transferred)) {
                   case http_parser::status::ok:
                       if (self->parser_.complete) {
-                          auto handler = self->command_handlers_.front();
-                          self->command_handlers_.pop_front();
-                          handler({}, std::move(self->parser_.response));
+                          if (!self->command_handlers_.empty()) {
+                              auto handler = self->command_handlers_.front();
+                              self->command_handlers_.pop_front();
+                              handler({}, std::move(self->parser_.response));
+                          }
                           self->parser_.reset();
-                          return;
+                          return self->stop();
                       }
                       return self->do_read();
                   case http_parser::status::failure:
+                      spdlog::error("{} failed to parse HTTP response", self->log_prefix_);
                       return self->stop();
               }
           });
@@ -237,12 +312,12 @@ class http_session : public std::enable_shared_from_this<http_session>
         for (auto& buf : writing_buffer_) {
             buffers.emplace_back(asio::buffer(buf));
         }
-        asio::async_write(socket_, buffers, [self = shared_from_this()](std::error_code ec, std::size_t /* bytes_transferred */) {
-            if (self->stopped_) {
+        stream_->async_write(buffers, [self = shared_from_this()](std::error_code ec, std::size_t /* bytes_transferred */) {
+            if (ec == asio::error::operation_aborted || self->stopped_) {
                 return;
             }
             if (ec) {
-                spdlog::error("IO error while writing to the socket: {}", ec.message());
+                spdlog::error("{} IO error while writing to the socket: {}", self->log_prefix_, ec.message());
                 return self->stop();
             }
             self->writing_buffer_.clear();
@@ -253,12 +328,11 @@ class http_session : public std::enable_shared_from_this<http_session>
         });
     }
 
-    uuid::uuid_t client_id_;
-    uuid::uuid_t id_;
+    std::string client_id_;
+    std::string id_;
     asio::io_context& ctx_;
     asio::ip::tcp::resolver resolver_;
-    asio::strand<asio::io_context::executor_type> strand_;
-    asio::ip::tcp::socket socket_;
+    std::unique_ptr<stream_impl> stream_;
     asio::steady_timer deadline_timer_;
 
     std::string username_;
@@ -269,6 +343,9 @@ class http_session : public std::enable_shared_from_this<http_session>
 
     bool stopped_{ false };
     bool connected_{ false };
+    bool keep_alive_{ false };
+
+    std::function<void()> on_stop_handler_{ nullptr };
 
     std::list<std::function<void(std::error_code, io::http_response&&)>> command_handlers_{};
     http_parser parser_{};
@@ -277,5 +354,7 @@ class http_session : public std::enable_shared_from_this<http_session>
     std::vector<std::vector<std::uint8_t>> writing_buffer_{};
     asio::ip::tcp::endpoint endpoint_{}; // connected endpoint
     asio::ip::tcp::resolver::results_type endpoints_;
+
+    std::string log_prefix_{};
 };
-} // namespace couchbase::io
+} // namespace couchbase::io

data/ext/couchbase/io/{session_manager.hxx → http_session_manager.hxx}

@@ -25,17 +25,19 @@
 namespace couchbase::io
 {
 
-class session_manager
+class http_session_manager : public std::enable_shared_from_this<http_session_manager>
 {
   public:
-    session_manager(uuid::uuid_t client_id, asio::io_context& ctx)
+    http_session_manager(const std::string& client_id, asio::io_context& ctx, asio::ssl::context& tls)
       : client_id_(client_id)
       , ctx_(ctx)
+      , tls_(tls)
     {
     }
 
-    void set_configuration(const configuration& config)
+    void set_configuration(const configuration& config, const cluster_options& options)
     {
+        options_ = options;
         config_ = config;
         next_index_ = 0;
         if (config_.nodes.size() > 1) {
@@ -48,60 +50,73 @@ class session_manager
 
     std::shared_ptr<http_session> check_out(service_type type, const std::string& username, const std::string& password)
     {
+        std::scoped_lock lock(sessions_mutex_);
         if (idle_sessions_[type].empty()) {
             std::string hostname;
             std::uint16_t port = 0;
             std::tie(hostname, port) = next_node(type);
-            Expects(port != 0); // FIXME: service_not_available
+            if (port == 0) {
+                return nullptr;
+            }
             config_.nodes.size();
-            auto session = std::make_shared<http_session>(client_id_, ctx_, username, password, hostname, std::to_string(port));
+            std::shared_ptr<http_session> session;
+            if (options_.enable_tls) {
+                session = std::make_shared<http_session>(client_id_, ctx_, tls_, username, password, hostname, std::to_string(port));
+            } else {
+                session = std::make_shared<http_session>(client_id_, ctx_, username, password, hostname, std::to_string(port));
+            }
+            session->start();
+            session->on_stop([type, id = session->id(), self = this->shared_from_this()]() {
+                std::scoped_lock inner_lock(self->sessions_mutex_);
+                self->busy_sessions_[type].remove_if([id](const auto& s) -> bool { return s->id() == id; });
+                self->idle_sessions_[type].remove_if([id](const auto& s) -> bool { return s->id() == id; });
+            });
             busy_sessions_[type].push_back(session);
             return session;
         }
         auto session = idle_sessions_[type].front();
         idle_sessions_[type].pop_front();
+        busy_sessions_[type].push_back(session);
         return session;
     }
 
     void check_in(service_type type, std::shared_ptr<http_session> session)
     {
-        idle_sessions_[type].push_back(session);
+        if (!session->keep_alive()) {
+            return session->stop();
+        }
+        if (!session->is_stopped()) {
+            std::scoped_lock lock(sessions_mutex_);
+            spdlog::debug("{} put HTTP session back to idle connections", session->log_prefix());
+            idle_sessions_[type].push_back(session);
+        }
     }
 
   private:
     std::pair<std::string, std::uint16_t> next_node(service_type type)
     {
-        auto cur_index = next_index_;
-        next_index_ = (next_index_ + 1) % config_.nodes.size();
-        auto& node = config_.nodes[cur_index];
-        switch (type) {
-            case service_type::query:
-                return { node.hostname, node.services_plain.query.value_or(0) };
-
-            case service_type::analytics:
-                return { node.hostname, node.services_plain.analytics.value_or(0) };
-
-            case service_type::search:
-                return { node.hostname, node.services_plain.search.value_or(0) };
-
-            case service_type::views:
-                return { node.hostname, node.services_plain.views.value_or(0) };
-
-            case service_type::management:
-                return { node.hostname, node.services_plain.management.value_or(0) };
-
-            case service_type::kv:
-                return { node.hostname, node.services_plain.key_value.value_or(0) };
+        auto candidates = config_.nodes.size();
+        while (candidates > 0) {
+            --candidates;
+            auto& node = config_.nodes[next_index_];
+            next_index_ = (next_index_ + 1) % config_.nodes.size();
+            std::uint16_t port = node.port_or(options_.network, type, options_.enable_tls, 0);
+            if (port != 0) {
+                return { node.hostname_for(options_.network), port };
+            }
         }
         return { "", 0 };
     }
 
-    uuid::uuid_t client_id_;
+    std::string client_id_;
     asio::io_context& ctx_;
+    asio::ssl::context& tls_;
+    cluster_options options_;
 
     configuration config_{};
     std::map<service_type, std::list<std::shared_ptr<http_session>>> busy_sessions_{};
     std::map<service_type, std::list<std::shared_ptr<http_session>>> idle_sessions_{};
     std::size_t next_index_{ 0 };
+    std::mutex sessions_mutex_{};
 };
 } // namespace couchbase::io