design decision made. Skeloton code based on return value is built

Author: Tianyi Chen

src/include/common/internal_types.h

@@ -1397,7 +1397,8 @@ enum class ProcessResult {
   COMPLETE,
   TERMINATE,
   PROCESSING,
-  MORE_DATA_REQUIRED
+  MORE_DATA_REQUIRED,
+  NEED_SSL_HANDSHAKE,
 };
 
 enum class NetworkProtocolType {

src/include/network/connection_handle.h

@@ -204,17 +204,12 @@ 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
-  Client client_;
+ 
   StateMachine state_machine_;
 
   // TODO(Tianyi) Can we encapsulate these flags?
-  bool ssl_handshake_ = false;
-  bool finish_startup_packet_ = false;
   bool ssl_able_;
 
-  // TODO(Tianyi) hide this in protocol handler
-  InputPacket initial_packet_;
-
   short curr_event_flag_;  // current libevent event flag
 };
 }  // namespace network

src/include/network/marshal.h

@@ -15,9 +15,9 @@
 #include <string>
 #include <vector>
 
+#include "common/internal_types.h"
 #include "common/logger.h"
 #include "common/macros.h"
-#include "common/internal_types.h"
 
 #define BUFFER_INIT_SIZE 100
 
@@ -152,25 +152,13 @@ struct OutputPacket {
   }
 };
 
-struct Client {
-  // Authentication details
-  std::string dbname;
-  std::string user;
-  std::unordered_map<std::string, std::string> cmdline_options;
-
-  inline void Reset() {
-    dbname.clear();
-    user.clear();
-    cmdline_options.clear();
-  }
-};
-
 /*
-* Marshallers
-*/
+ * Marshallers
+ */
 
 /* packet_put_byte - used to write a single byte into a packet */
-extern void PacketPutByte(OutputPacket *pkt, const uchar c);
+extern void
+PacketPutByte(OutputPacket *pkt, const uchar c);
 
 /* packet_put_string - used to write a string into a packet */
 extern void PacketPutStringWithTerminator(OutputPacket *pkt,
@@ -186,22 +174,22 @@ extern void PacketPutCbytes(OutputPacket *pkt, const uchar *b, int len);
 extern void PacketPutString(OutputPacket *pkt, const std::string &data);
 
 /*
-* Unmarshallers
-*/
+ * Unmarshallers
+ */
 
 /* Copy len bytes from the position indicated by begin to an array */
 extern uchar *PacketCopyBytes(ByteBuf::const_iterator begin, int len);
 /*
-* packet_get_int -  Parse an int out of the head of the
-* 	packet. "base" bytes determine the number of bytes of integer
-* 	we are parsing out.
-*/
+ * packet_get_int -  Parse an int out of the head of the
+ * 	packet. "base" bytes determine the number of bytes of integer
+ * 	we are parsing out.
+ */
 extern int PacketGetInt(InputPacket *pkt, uchar base);
 
 /*
-* packet_get_string - parse out a string of size len.
-* 		if len=0? parse till the end of the string
-*/
+ * packet_get_string - parse out a string of size len.
+ * 		if len=0? parse till the end of the string
+ */
 extern void PacketGetString(InputPacket *pkt, size_t len, std::string &result);
 
 /* packet_get_bytes - Parse out "len" bytes of pkt as raw bytes */
@@ -211,9 +199,9 @@ extern void PacketGetBytes(InputPacket *pkt, size_t len, ByteBuf &result);
 extern void PacketGetByte(InputPacket *rpkt, uchar &result);
 
 /*
-* get_string_token - used to extract a string token
-* 		from an unsigned char vector
-*/
+ * get_string_token - used to extract a string token
+ * 		from an unsigned char vector
+ */
 extern void GetStringToken(InputPacket *pkt, std::string &result);
 
 }  // namespace network

src/include/network/postgres_protocol_handler.h

@@ -46,7 +46,7 @@ class PostgresProtocolHandler : public ProtocolHandler {
 
   /* Main switch case wrapper to process every packet apart from the startup
    * packet. Avoid flushing the response for extended protocols. */
-  ProcessResult ProcessPacket(InputPacket *pkt, const size_t thread_id);
+  ProcessResult ProcessNormalPacket(InputPacket *pkt, const size_t thread_id);
 
   /* Manage the startup packet */
   //  bool ManageStartupPacket();
@@ -55,6 +55,7 @@ class PostgresProtocolHandler : public ProtocolHandler {
 
   void GetResult();
 
+ private:
   //===--------------------------------------------------------------------===//
   // STATIC HELPERS
   //===--------------------------------------------------------------------===//
@@ -73,28 +74,25 @@ class PostgresProtocolHandler : public ProtocolHandler {
       std::vector<std::pair<type::TypeId, std::string>> &bind_parameters,
       std::vector<type::Value> &param_values, std::vector<int16_t> &formats);
 
+  // Parse the input packet based on if it is the startup packet
+  static bool ParseInputPacket(Buffer &rbuf, InputPacket &rpkt,
+                               bool startup_format);
+
   // Packet Reading Function
   // Extracts the contents of Postgres packet from the read socket buffer
   static bool ReadPacket(Buffer &rbuf, InputPacket &rpkt);
 
+  // Packet Reading Function
+  // Extracts the header of a Postgres packet from the read socket buffer
+  static bool ReadPacketHeader(Buffer &rbuf, InputPacket &rpkt,
+                               bool startup_format);
+
   /* Routine to deal with the first packet from the client */
-  bool ProcessInitialPackets(InputPacket *pkt, Client client, bool ssl_able,
-                             bool &ssl_sent, bool &finish_startup_packet);
+  bool ProcessInitialPackets(InputPacket *pkt, bool ssl_able);
 
   /* Routine to deal with SSL request message */
   void ProcessSSLRequestPacket(bool ssl_able, bool &ssl_handshake);
 
-  /* Routine to deal with general Startup message */
-  bool ProcessStartupPacket(InputPacket *pkt, int32_t proto_version,
-                            Client client, bool &finish_startup_packet);
-
-  bool GetFinishedStartupPacket();
-
- private:
-  // Packet Reading Function
-  // Extracts the header of a Postgres packet from the read socket buffer
-  static bool ReadPacketHeader(Buffer &rbuf, InputPacket &rpkt);
-
   //===--------------------------------------------------------------------===//
   // PROTOCOL HANDLING FUNCTIONS
   //===--------------------------------------------------------------------===//
@@ -155,6 +153,8 @@ class PostgresProtocolHandler : public ProtocolHandler {
   //===--------------------------------------------------------------------===//
   // MEMBERS
   //===--------------------------------------------------------------------===//
+  // True if this protocol is handling startup/SSL packets
+  bool init_stage_;
 
   NetworkProtocolType protocol_type_;
 
@@ -166,7 +166,7 @@ class PostgresProtocolHandler : public ProtocolHandler {
   // global txn state
   NetworkTransactionStateType txn_state_;
 
-  // state to mang skipped queries
+  // state to manage skipped queries
   bool skipped_stmt_ = false;
   std::string skipped_query_string_;
   QueryType skipped_query_type_;

src/include/network/protocol_handler.h

@@ -60,6 +60,8 @@ class ProtocolHandler {
 
   // 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

@@ -83,8 +83,7 @@ namespace {
   ;
 }
 
-// For readability sake, do not run clang-format on this macro block and follow
-// the style presented when editing.
+// clang-format off
 DEF_TRANSITION_GRAPH
   DEFINE_STATE(READ)
     ON(WAKEUP) SET_STATE_TO(READ) AND_INVOKE(FillReadBuffer)
@@ -94,6 +93,7 @@ DEF_TRANSITION_GRAPH
   END_DEF
 
   DEFINE_STATE(SSL_HANDSHAKE)
+    ON(WAKEUP) SET_STATE_TO(SSL_HANDSHAKE) AND_INVOKE(SSL_handshake)
     ON(NEED_DATA) SET_STATE_TO(SSL_HANDSHAKE) AND_WAIT
     ON(FINISH) SET_STATE_TO(CLOSING) AND_INVOKE(CloseSocket)
     ON(PROCEED) SET_STATE_TO(PROCESS) AND_INVOKE(Process)
@@ -124,6 +124,7 @@ DEF_TRANSITION_GRAPH
   END_DEF
 
 END_DEF
+// clang-format on
 
 void ConnectionHandle::StateMachine::Accept(Transition action,
                                             ConnectionHandle &connection) {
@@ -440,75 +441,6 @@ std::string ConnectionHandle::WriteBufferToString() {
   return std::string(wbuf_->buf.begin(), wbuf_->buf.end());
 }
 
-ProcessResult ConnectionHandle::ProcessInitial() {
-  // TODO(Tianyi): this is a direct copy from protocol handler
-  // and we could get rid of it later when we have the second
-  // protocol handler;
-
-  if (initial_packet_.header_parsed == false) {
-    // parse out the header first
-    if (ReadStartupPacketHeader(*rbuf_, initial_packet_) == false) {
-      // need more data
-      return ProcessResult::MORE_DATA_REQUIRED;
-    }
-  }
-  PL_ASSERT(initial_packet_.header_parsed == true);
-
-  if (initial_packet_.is_initialized == false) {
-    // packet needs to be initialized with rest of the contents
-    // TODO(Tianyi): If other protocols are added, this need to be changed
-    if (PostgresProtocolHandler::ReadPacket(*rbuf_, initial_packet_) == false) {
-      // need more data
-      return ProcessResult::MORE_DATA_REQUIRED;
-    }
-  }
-
-  if (protocol_handler_ == nullptr) {
-    protocol_handler_ = ProtocolHandlerFactory::CreateProtocolHandler(
-        ProtocolHandlerType::Postgres, &traffic_cop_);
-  }
-  // We need to handle startup packet first
-  // TODO(Tianyi): If other protocols are added, this need to be changed
-  bool result = protocol_handler_->ProcessInitialPackets(
-      &initial_packet_, client_, ssl_able_, ssl_handshake_,
-      finish_startup_packet_);
-  // Clean up the initial_packet after finishing processing.
-  initial_packet_.Reset();
-  if (result) {
-    return ProcessResult::COMPLETE;
-  } else {
-    return ProcessResult::TERMINATE;
-  }
-}
-
-// TODO(Tianyi): This function is now dedicated for postgres packet
-bool ConnectionHandle::ReadStartupPacketHeader(Buffer &rbuf,
-                                               InputPacket &rpkt) {
-  size_t initial_read_size = sizeof(int32_t);
-
-  if (!rbuf.IsReadDataAvailable(initial_read_size)) {
-    return false;
-  }
-
-  // extract packet contents size
-  // content lengths should exclude the length
-  rpkt.len = rbuf.GetUInt32BigEndian() - sizeof(uint32_t);
-
-  // do we need to use the extended buffer for this packet?
-  rpkt.is_extended = (rpkt.len > rbuf.GetMaxSize());
-
-  if (rpkt.is_extended) {
-    LOG_DEBUG("Using extended buffer for pkt size:%ld", rpkt.len);
-    // reserve space for the extended buffer
-    rpkt.ReserveExtendedBuffer();
-  }
-
-  // we have processed the data, move buffer pointer
-  rbuf.buf_ptr += initial_read_size;
-  rpkt.header_parsed = true;
-  return true;
-}
-
 // Writes a packet's header (type, size) into the write buffer.
 // Return false when the socket is not ready for write
 WriteState ConnectionHandle::BufferWriteBytesHeader(OutputPacket *pkt) {
@@ -645,6 +577,12 @@ Transition ConnectionHandle::CloseSocket() {
 }
 
 Transition ConnectionHandle::SSL_handshake() {
+  if (HaveResponse()) {
+    switch(ProcessWrite()) {
+      
+    } 
+  }
+
   if (conn_SSL_context == nullptr) {
     conn_SSL_context = SSL_new(PelotonServer::ssl_context);
     if (conn_SSL_context == nullptr) {
@@ -735,6 +673,8 @@ Transition ConnectionHandle::Process() {
       return Transition::GET_RESULT;
     case ProcessResult::TERMINATE:
       return Transition::FINISH;
+    case ProcessResult::NEED_SSL_HANDSHAKE：
+      return Transition::NEED_SSL_HANDSHAKE;
   }
 }