Bug#36072058 simplify MysqlRoutingClassicConnection class

MysqlRoutingClassicConnectionBase contains a ProtocolSplicerBase class
which wraps a client-side and server-side connection.

That class doesn't offer anything extra and can be removed.

Change
======

- moved ClassicProtocolState into its own header
- split ClassicProtocolState into client-side and server-side
- templatized TlsSwitchableConnection for the Protocol-class to avoid
  heap allocation for std::make_unique<ProtocolStateBase>
- embed Channel directly into TlsSwitchableConnection instead of
  std::unqiue_ptr<Channel>
- embed TlsSwitchableConnection directly in MysqlRoutingClassicConnectionBase
  instead of std::unique_ptr<TlsSwitchableConnection>
- removed now unused ProtocolStateBase
- removed now unused ProtocolSplicerBase
- added "connection" based recv_msg<>, send_msg<> and used them where
  possible

... which leads to a lot of changes like:

- refer to Channel and ProtocolState by 'ref' instead of 'pointer'
- replace all calls through socket_splicer()->{method} by calls to
  {method}

Change-Id: I947bd95deb28f5bf5a185b2addfe2388dd385924

Author: weigon

router/src/routing/src/await_client_or_server.cc

@@ -65,8 +65,6 @@ AwaitClientOrServerProcessor::init() {
  */
 stdx::expected<Processor::Result, std::error_code>
 AwaitClientOrServerProcessor::wait_both() {
-  auto *socket_splicer = connection()->socket_splicer();
-
   switch (connection()->recv_from_either()) {
     case MysqlRoutingClassicConnectionBase::FromEither::RecvedFromServer: {
       // server side sent something.
@@ -76,7 +74,7 @@ AwaitClientOrServerProcessor::wait_both() {
 
       stage(Stage::WaitClientCancelled);
 
-      (void)socket_splicer->client_conn().cancel();
+      (void)connection()->client_conn().cancel();
 
       // end this execution branch.
       return Result::Void;
@@ -88,7 +86,7 @@ AwaitClientOrServerProcessor::wait_both() {
       // - read from client in ::wait_server_cancelled
       stage(Stage::WaitServerCancelled);
 
-      (void)socket_splicer->server_conn().cancel();
+      (void)connection()->server_conn().cancel();
 
       // end this execution branch.
       return Result::Void;

router/src/routing/src/basic_protocol_splicer.h

@@ -287,11 +287,6 @@ using TcpConnection = BasicConnection<net::ip::tcp>;
 using UnixDomainConnection = BasicConnection<local::stream_protocol>;
 #endif
 
-class ProtocolStateBase {
- public:
-  virtual ~ProtocolStateBase() = default;
-};
-
 /**
  * a Connection that can be switched to TLS.
  *
@@ -302,6 +297,7 @@ class ProtocolStateBase {
  * - a tls switchable (a SSL_CTX * wrapper)
  * - protocol state (classic, xproto)
  */
+template <class T>
 class TlsSwitchableConnection {
  public:
   //    16kb per buffer
@@ -310,29 +306,29 @@ class TlsSwitchableConnection {
   // 10000   connections
   // = 640MByte
   static constexpr size_t kRecvBufferSize{16UL * 1024};
+  using protocol_state_type = T;
 
   TlsSwitchableConnection(std::unique_ptr<ConnectionBase> conn,
                           std::unique_ptr<RoutingConnectionBase> routing_conn,
-                          SslMode ssl_mode,
-                          std::unique_ptr<ProtocolStateBase> state)
+                          SslMode ssl_mode, protocol_state_type state)
       : conn_{std::move(conn)},
         routing_conn_{std::move(routing_conn)},
         ssl_mode_{std::move(ssl_mode)},
-        channel_{std::make_unique<Channel>()},
+        channel_{},
         protocol_{std::move(state)} {
-    channel_->recv_buffer().reserve(kRecvBufferSize);
+    channel_.recv_buffer().reserve(kRecvBufferSize);
   }
 
   TlsSwitchableConnection(std::unique_ptr<ConnectionBase> conn,
                           std::unique_ptr<RoutingConnectionBase> routing_conn,
-                          SslMode ssl_mode, std::unique_ptr<Channel> channel,
-                          std::unique_ptr<ProtocolStateBase> state)
+                          SslMode ssl_mode, Channel channel,
+                          protocol_state_type state)
       : conn_{std::move(conn)},
         routing_conn_{std::move(routing_conn)},
         ssl_mode_{std::move(ssl_mode)},
         channel_{std::move(channel)},
         protocol_{std::move(state)} {
-    channel_->recv_buffer().reserve(kRecvBufferSize);
+    channel_.recv_buffer().reserve(kRecvBufferSize);
   }
 
   [[nodiscard]] std::vector<std::pair<std::string, std::string>>
@@ -355,15 +351,14 @@ class TlsSwitchableConnection {
   template <class Func>
   void async_recv(Func &&func) {
     harness_assert(conn_ != nullptr);
-    harness_assert(channel_ != nullptr);
 
     // discard everything that has been marked as 'consumed'
-    channel_->view_discard_raw();
+    channel_.view_discard_raw();
 
-    conn_->async_recv(channel_->recv_buffer(),
+    conn_->async_recv(channel_.recv_buffer(),
                       [this, func = std::forward<Func>(func)](
                           std::error_code ec, size_t transferred) {
-                        channel_->view_sync_raw();
+                        channel_.view_sync_raw();
 
                         func(ec, transferred);
                       });
@@ -376,7 +371,7 @@ class TlsSwitchableConnection {
    */
   template <class Func>
   void async_send(Func &&func) {
-    conn_->async_send(channel_->send_buffer(), std::forward<Func>(func));
+    conn_->async_send(channel_.send_buffer(), std::forward<Func>(func));
   }
 
   /**
@@ -394,9 +389,9 @@ class TlsSwitchableConnection {
     conn_->async_wait_error(std::forward<Func>(func));
   }
 
-  [[nodiscard]] Channel *channel() { return channel_.get(); }
+  [[nodiscard]] Channel &channel() { return channel_; }
 
-  [[nodiscard]] const Channel *channel() const { return channel_.get(); }
+  [[nodiscard]] const Channel &channel() const { return channel_; }
 
   [[nodiscard]] SslMode ssl_mode() const { return ssl_mode_; }
 
@@ -443,10 +438,10 @@ class TlsSwitchableConnection {
     return conn_->cancel();
   }
 
-  [[nodiscard]] ProtocolStateBase *protocol() { return protocol_.get(); }
+  [[nodiscard]] protocol_state_type &protocol() { return protocol_; }
 
-  [[nodiscard]] const ProtocolStateBase *protocol() const {
-    return protocol_.get();
+  [[nodiscard]] const protocol_state_type &protocol() const {
+    return protocol_;
   }
 
   std::unique_ptr<ConnectionBase> &connection() { return conn_; }
@@ -458,7 +453,7 @@ class TlsSwitchableConnection {
    * - if transport is secure, the channel is secure
    */
   [[nodiscard]] bool is_secure_transport() const {
-    return conn_->is_secure_transport() || channel_->ssl();
+    return conn_->is_secure_transport() || (channel_.ssl() != nullptr);
   }
 
  private:
@@ -469,117 +464,10 @@ class TlsSwitchableConnection {
   SslMode ssl_mode_;
 
   // socket buffers
-  std::unique_ptr<Channel> channel_;
+  Channel channel_;
 
   // higher-level protocol
-  std::unique_ptr<ProtocolStateBase> protocol_;
-};
-
-/**
- * splices two connections together.
- */
-class ProtocolSplicerBase {
- public:
-  ProtocolSplicerBase(TlsSwitchableConnection client_conn,
-                      TlsSwitchableConnection server_conn)
-      : client_conn_{std::move(client_conn)},
-        server_conn_{std::move(server_conn)} {}
-
-  template <class Func>
-  void async_wait_send_server(Func &&func) {
-    server_conn_.async_wait_send(std::forward<Func>(func));
-  }
-
-  template <class Func>
-  void async_recv_server(Func &&func) {
-    server_conn_.async_recv(std::forward<Func>(func));
-  }
-
-  template <class Func>
-  void async_send_server(Func &&func) {
-    server_conn_.async_send(std::forward<Func>(func));
-  }
-
-  template <class Func>
-  void async_recv_client(Func &&func) {
-    client_conn_.async_recv(std::forward<Func>(func));
-  }
-
-  template <class Func>
-  void async_send_client(Func &&func) {
-    client_conn_.async_send(std::forward<Func>(func));
-  }
-
-  template <class Func>
-  void async_client_wait_error(Func &&func) {
-    client_conn_.async_wait_error(std::forward<Func>(func));
-  }
-
-  [[nodiscard]] TlsSwitchableConnection &client_conn() { return client_conn_; }
-
-  [[nodiscard]] const TlsSwitchableConnection &client_conn() const {
-    return client_conn_;
-  }
-
-  [[nodiscard]] TlsSwitchableConnection &server_conn() { return server_conn_; }
-
-  [[nodiscard]] const TlsSwitchableConnection &server_conn() const {
-    return server_conn_;
-  }
-
-  [[nodiscard]] SslMode source_ssl_mode() const {
-    return client_conn().ssl_mode();
-  }
-
-  [[nodiscard]] SslMode dest_ssl_mode() const {
-    return server_conn().ssl_mode();
-  }
-
-  [[nodiscard]] Channel *client_channel() { return client_conn().channel(); }
-
-  [[nodiscard]] const Channel *client_channel() const {
-    return client_conn().channel();
-  }
-
-  [[nodiscard]] Channel *server_channel() { return server_conn().channel(); }
-
-  /**
-   * accept a TLS connection from the client_channel_.
-   */
-  [[nodiscard]] stdx::expected<void, std::error_code> tls_accept() {
-    // write socket data to SSL struct
-    auto *channel = client_conn_.channel();
-
-    {
-      const auto flush_res = channel->flush_from_recv_buf();
-      if (!flush_res) return stdx::unexpected(flush_res.error());
-    }
-
-    if (!channel->tls_init_is_finished()) {
-      const auto res = channel->tls_accept();
-
-      // flush the TLS message to the send-buffer.
-      {
-        const auto flush_res = channel->flush_to_send_buf();
-        if (!flush_res) {
-          const auto ec = flush_res.error();
-          if (ec != make_error_code(std::errc::operation_would_block)) {
-            return stdx::unexpected(flush_res.error());
-          }
-        }
-      }
-
-      if (!res) {
-        return stdx::unexpected(res.error());
-      }
-    }
-
-    return {};
-  }
-
- protected:
-  TlsSwitchableConnection client_conn_;
-  TlsSwitchableConnection server_conn_;
+  protocol_state_type protocol_;
 };
 
 #endif

router/src/routing/src/classic_auth_caching_sha2.cc

@@ -39,16 +39,16 @@ std::optional<std::string> AuthCachingSha2Password::scramble(
 
 stdx::expected<size_t, std::error_code>
 AuthCachingSha2Password::send_public_key_request(
-    Channel *dst_channel, ClassicProtocolState *dst_protocol) {
+    Channel &dst_channel, ClassicProtocolState &dst_protocol) {
   return ClassicFrame::send_msg(
       dst_channel, dst_protocol,
       classic_protocol::borrowed::message::client::AuthMethodData{
           kPublicKeyRequest});
 }
 
 stdx::expected<size_t, std::error_code>
-AuthCachingSha2Password::send_public_key(Channel *dst_channel,
-                                         ClassicProtocolState *dst_protocol,
+AuthCachingSha2Password::send_public_key(Channel &dst_channel,
+                                         ClassicProtocolState &dst_protocol,
                                          const std::string &public_key) {
   return ClassicFrame::send_msg(
       dst_channel, dst_protocol,
@@ -57,7 +57,7 @@ AuthCachingSha2Password::send_public_key(Channel *dst_channel,
 
 stdx::expected<size_t, std::error_code>
 AuthCachingSha2Password::send_plaintext_password_request(
-    Channel *dst_channel, ClassicProtocolState *dst_protocol) {
+    Channel &dst_channel, ClassicProtocolState &dst_protocol) {
   return ClassicFrame::send_msg(
       dst_channel, dst_protocol,
       classic_protocol::borrowed::message::server::AuthMethodData{
@@ -66,7 +66,7 @@ AuthCachingSha2Password::send_plaintext_password_request(
 
 stdx::expected<size_t, std::error_code>
 AuthCachingSha2Password::send_plaintext_password(
-    Channel *dst_channel, ClassicProtocolState *dst_protocol,
+    Channel &dst_channel, ClassicProtocolState &dst_protocol,
     const std::string &password) {
   return ClassicFrame::send_msg(
       dst_channel, dst_protocol,
@@ -76,7 +76,7 @@ AuthCachingSha2Password::send_plaintext_password(
 
 stdx::expected<size_t, std::error_code>
 AuthCachingSha2Password::send_encrypted_password(
-    Channel *dst_channel, ClassicProtocolState *dst_protocol,
+    Channel &dst_channel, ClassicProtocolState &dst_protocol,
     const std::string &encrypted) {
   return ClassicFrame::send_msg(
       dst_channel, dst_protocol,

router/src/routing/src/classic_auth_caching_sha2.h

@@ -30,6 +30,7 @@
 
 #include <openssl/ssl.h>
 
+#include "basic_protocol_splicer.h"
 #include "classic_auth.h"
 #include "classic_connection_base.h"
 #include "mysql/harness/stdx/expected.h"
@@ -49,24 +50,48 @@ class AuthCachingSha2Password : public AuthBase {
                                              std::string_view pwd);
 
   static stdx::expected<size_t, std::error_code> send_public_key_request(
-      Channel *dst_channel, ClassicProtocolState *dst_protocol);
+      Channel &dst_channel, ClassicProtocolState &dst_protocol);
+
+  template <class Proto>
+  static stdx::expected<size_t, std::error_code> send_public_key_request(
+      TlsSwitchableConnection<Proto> &conn) {
+    return send_public_key_request(conn.channel(), conn.protocol());
+  }
 
   static stdx::expected<size_t, std::error_code> send_public_key(
-      Channel *dst_channel, ClassicProtocolState *dst_protocol,
+      Channel &dst_channel, ClassicProtocolState &dst_protocol,
       const std::string &public_key);
 
+  template <class Proto>
+  static stdx::expected<size_t, std::error_code> send_public_key(
+      TlsSwitchableConnection<Proto> &conn, const std::string &public_key) {
+    return send_public_key(conn.channel(), conn.protocol(), public_key);
+  }
+
   static stdx::expected<size_t, std::error_code>
-  send_plaintext_password_request(Channel *dst_channel,
-                                  ClassicProtocolState *dst_protocol);
+  send_plaintext_password_request(Channel &dst_channel,
+                                  ClassicProtocolState &dst_protocol);
 
   static stdx::expected<size_t, std::error_code> send_plaintext_password(
-      Channel *dst_channel, ClassicProtocolState *dst_protocol,
+      Channel &dst_channel, ClassicProtocolState &dst_protocol,
       const std::string &password);
 
+  template <class Proto>
+  static stdx::expected<size_t, std::error_code> send_plaintext_password(
+      TlsSwitchableConnection<Proto> &conn, const std::string &password) {
+    return send_plaintext_password(conn.channel(), conn.protocol(), password);
+  }
+
   static stdx::expected<size_t, std::error_code> send_encrypted_password(
-      Channel *dst_channel, ClassicProtocolState *dst_protocol,
+      Channel &dst_channel, ClassicProtocolState &dst_protocol,
       const std::string &password);
 
+  template <class Proto>
+  static stdx::expected<size_t, std::error_code> send_encrypted_password(
+      TlsSwitchableConnection<Proto> &conn, const std::string &password) {
+    return send_encrypted_password(conn.channel(), conn.protocol(), password);
+  }
+
   static bool is_public_key_request(const std::string_view &data);
   static bool is_public_key(const std::string_view &data);
 };