get rid of hacky ssl_able flag and refine Process Initial Packet

Author: Tianyi Chen

src/include/network/connection_handle.h

@@ -91,6 +91,7 @@ class ConnectionHandle {
    * Flush out all the responses and do real SSL handshake
    */
   Transition ProcessWrite_SSLHandshake();
+
  private:
   /**
    * A state machine is defined to be a set of states, a set of symbols it
@@ -147,8 +148,8 @@ class ConnectionHandle {
   friend class ConnectionHandleFactory;
 
   ConnectionHandle(int sock_fd, ConnectionHandlerTask *handler,
-                   std::shared_ptr<Buffer> rbuf, std::shared_ptr<Buffer> wbuf,
-                   bool ssl_able);
+                   std::shared_ptr<Buffer> rbuf,
+                   std::shared_ptr<Buffer> wbuf);
 
   ProcessResult ProcessInitial();
 
@@ -220,11 +221,8 @@ class ConnectionHandle {
   std::shared_ptr<Buffer> rbuf_;    // Socket's read buffer
   std::shared_ptr<Buffer> wbuf_;    // Socket's write buffer
   unsigned int next_response_ = 0;  // The next response in the response buffer
- 
-  StateMachine state_machine_;
 
-  // TODO(Tianyi) Can we encapsulate these flags?
-  bool ssl_able_;
+  StateMachine state_machine_;
 
   short curr_event_flag_;  // current libevent event flag
 };

src/include/network/connection_handle_factory.h

@@ -40,22 +40,21 @@ class ConnectionHandleFactory {
     // (probably also to-do: beat up the person who wrote this)
     PelotonServer::recent_connfd = conn_fd;
     auto it = reusable_handles_.find(conn_fd);
-    bool ssl_able = (PelotonServer::GetSSLLevel() != SSLLevel::SSL_DISABLE);
     if (it == reusable_handles_.end()) {
       // We are not using std::make_shared here because we want to keep
       // ConnectionHandle constructor
       // private to avoid unintentional use.
       auto handle = std::shared_ptr<ConnectionHandle>(
           new ConnectionHandle(conn_fd, handler, std::make_shared<Buffer>(),
-                               std::make_shared<Buffer>(), ssl_able));
+                               std::make_shared<Buffer>()));
       reusable_handles_[conn_fd] = handle;
       return handle;
     }
 
     it->second->rbuf_->Reset();
     it->second->wbuf_->Reset();
     std::shared_ptr<ConnectionHandle> new_handle(new ConnectionHandle(
-        conn_fd, handler, it->second->rbuf_, it->second->wbuf_, ssl_able));
+        conn_fd, handler, it->second->rbuf_, it->second->wbuf_));
     reusable_handles_[conn_fd] = new_handle;
     return new_handle;
   }

src/include/network/postgres_protocol_handler.h

@@ -45,21 +45,8 @@ class PostgresProtocolHandler : public ProtocolHandler {
    * thread_id is the thread of current running thread. This is used
    * to generate txn
    */
-  ProcessResult Process(Buffer &rbuf, const bool ssl_able, const size_t thread_id);
+  ProcessResult Process(Buffer &rbuf, size_t thread_id);
 
-  /**
-   * 
-   */
-  ProcessResult ProcessInitialPackets(
-
-  /** 
-   * Main switch case wrapper to process every general packet apart from the
-   * initial packets. Avoid flushing the response for extended protocols.
-   */
-  ProcessResult ProcessNormalPackets(InputPacket *pkt, const size_t thread_id);
-  /* Manage the startup packet */
-  //  bool ManageStartupPacket();
-  void SendInitialResponse();
   void Reset();
 
   void GetResult();
@@ -96,17 +83,30 @@ class PostgresProtocolHandler : public ProtocolHandler {
   static bool ReadPacketHeader(Buffer &rbuf, InputPacket &rpkt,
                                bool startup_format);
 
-  /* Routine to deal with the first packet from the client */
-  bool ProcessInitialPackets(InputPacket *pkt, bool ssl_able);
-
-  /* Routine to deal with SSL request message */
-  void ProcessSSLRequestPacket(bool ssl_able, bool &ssl_handshake);
-
   //===--------------------------------------------------------------------===//
   // PROTOCOL HANDLING FUNCTIONS
   //===--------------------------------------------------------------------===//
-  /* Manage the startup packet */
-  virtual void SendInitialResponse();
+
+  /**
+   * @brief Routine to deal with the first packet from the client
+   */
+  ProcessResult ProcessInitialPackets(InputPacket *pkt);
+
+  /**
+   * @brief Main Switch function to process general packets
+   */
+  ProcessResult ProcessNormalPackets(InputPacket *pkt, const size_t thread_id);
+  
+  /**
+   * @brief Helper function to process startup packet
+   * @param proto_version protocol version of the session
+   */
+  ProcessResult ProcessStartupPacket(InputPacket *pkt, int32_t proto_version);
+
+  /**
+   * Send hardcoded response
+   */
+  void SendStartupResponse();
 
   // Generic error protocol packet
   void SendErrorResponse(
@@ -202,6 +202,8 @@ class PostgresProtocolHandler : public ProtocolHandler {
   std::unordered_map<std::string, stats::QueryMetric::QueryParamBuf>
       statement_param_types_;
 
+  std::unordered_map<std::string, std::string> cmdline_options_;
+
   //===--------------------------------------------------------------------===//
   // STATIC DATA
   //===--------------------------------------------------------------------===//

src/include/network/protocol_handler.h

@@ -35,7 +35,7 @@ class ProtocolHandler {
   /**
    * 
    */
-  virtual ProcessResult Process(Buffer &rbuf, const bool ssl_able, const size_t thread_id);
+  virtual ProcessResult Process(Buffer &rbuf, const size_t thread_id);
 
   virtual void Reset();
 
@@ -49,14 +49,13 @@ class ProtocolHandler {
 
   // TODO declare a response buffer pool so that we can reuse the responses
   // so that we don't have to new packet each time
-  ResponseBuffer responses;
+  ResponseBuffer responses_;
 
-  InputPacket request;  // Used for reading a single request
+  InputPacket request_;  // Used for reading a single request
 
   // The traffic cop used for this connection
   tcop::TrafficCop *traffic_cop_;
 
-  std::unordered_map<std::string, std::string> cmdline_options;
 };
 
 }  // namespace network

src/network/connection_handle.cpp

@@ -146,13 +146,12 @@ void ConnectionHandle::StateMachine::Accept(Transition action,
 
 ConnectionHandle::ConnectionHandle(int sock_fd, ConnectionHandlerTask *handler,
                                    std::shared_ptr<Buffer> rbuf,
-                                   std::shared_ptr<Buffer> wbuf, bool ssl_able)
+                                   std::shared_ptr<Buffer> wbuf)
     : sock_fd_(sock_fd),
       handler_(handler),
       protocol_handler_(nullptr),
       rbuf_(std::move(rbuf)),
-      wbuf_(std::move(wbuf)),
-      ssl_able_(ssl_able) {
+      wbuf_(std::move(wbuf)) {
   SetNonBlocking(sock_fd_);
   SetTCPNoDelay(sock_fd_);