Implemented socket message templates. (#40)

Implemented socket message templates to support broadcast (shared_ptr) and to achieve buffer zero-copy.

src/usr/user_session_handler.cpp

@@ -19,27 +19,39 @@ using error = boost::system::error_code;
 namespace usr
 {
 
+user_outbound_message::user_outbound_message(std::string &&_msg)
+{
+    msg = std::move(_msg);
+}
+
+// Returns the buffer that should be written to the socket.
+std::string_view user_outbound_message::buffer()
+{
+    return std::string_view(msg.data(), msg.size());
+}
+
 /**
  * This gets hit every time a client connects to HP via the public port (configured in contract config).
  */
-void user_session_handler::on_connect(sock::socket_session *session)
+void user_session_handler::on_connect(sock::socket_session<user_outbound_message> *session)
 {
-    LOG_INFO << "User client connected " << session->address_ << ":" << session->port_;
+    LOG_INFO << "User client connected " << session->address << ":" << session->port;
 
     // As soon as a user connects, we issue them a challenge message. We remember the
     // challenge we issued and later verifies the user's response with it.
 
-    std::string msg;
+    std::string msgstr;
     std::string challengehex;
-    usr::create_user_challenge(msg, challengehex);
+    usr::create_user_challenge(msgstr, challengehex);
 
     // We init the session unique id to associate with the challenge.
     session->init_uniqueid();
 
     // Create an entry in pending_challenges for later tracking upon challenge response.
-    usr::pending_challenges[session->uniqueid_] = challengehex;
+    usr::pending_challenges[session->uniqueid] = challengehex;
 
-    session->send(std::move(msg));
+    user_outbound_message outmsg(std::move(msgstr));
+    session->send(std::move(outmsg));
 
     // Set the challenge-issued flag to help later checks in on_message.
     session->flags_.set(util::SESSION_FLAG::USER_CHALLENGE_ISSUED);
@@ -48,14 +60,16 @@ void user_session_handler::on_connect(sock::socket_session *session)
 /**
  * This gets hit every time we receive some data from a client connected to the HP public port.
  */
-void user_session_handler::on_message(sock::socket_session *session, std::string &&message)
+void user_session_handler::on_message(
+    sock::socket_session<user_outbound_message> *session,
+    std::string_view message)
 {
     // First check whether this session is pending challenge.
     // Meaning we have previously issued a challenge to the client,
     if (session->flags_[util::SESSION_FLAG::USER_CHALLENGE_ISSUED])
     {
         // The received message must be the challenge response. We need to verify it.
-        auto itr = usr::pending_challenges.find(session->uniqueid_);
+        auto itr = usr::pending_challenges.find(session->uniqueid);
         if (itr != usr::pending_challenges.end())
         {
             std::string userpubkeyhex;
@@ -82,20 +96,20 @@ void user_session_handler::on_message(sock::socket_session *session, std::string
                     session->flags_.reset(util::SESSION_FLAG::USER_CHALLENGE_ISSUED); // Clear challenge-issued flag
                     session->flags_.set(util::SESSION_FLAG::USER_AUTHED);             // Set the user-authed flag
                     usr::add_user(session, userpubkey);                               // Add the user to the global authed user list
-                    usr::pending_challenges.erase(session->uniqueid_);                // Remove the stored challenge
+                    usr::pending_challenges.erase(session->uniqueid);                // Remove the stored challenge
 
-                    LOG_INFO << "User connection " << session->uniqueid_ << " authenticated. Public key "
-                              << userpubkeyhex;
+                    LOG_INFO << "User connection " << session->uniqueid << " authenticated. Public key "
+                             << userpubkeyhex;
                     return;
                 }
                 else
                 {
-                    LOG_INFO << "Duplicate user public key " << session->uniqueid_;
+                    LOG_INFO << "Duplicate user public key " << session->uniqueid;
                 }
             }
             else
             {
-                LOG_INFO << "Challenge verification failed " << session->uniqueid_;
+                LOG_INFO << "Challenge verification failed " << session->uniqueid;
             }
         }
     }
@@ -105,7 +119,7 @@ void user_session_handler::on_message(sock::socket_session *session, std::string
         // Check whether this user is among authenticated users
         // and perform authenticated msg processing.
 
-        auto itr = usr::users.find(session->uniqueid_);
+        auto itr = usr::users.find(session->uniqueid);
         if (itr != usr::users.end())
         {
             // This is an authed user.
@@ -121,30 +135,30 @@ void user_session_handler::on_message(sock::socket_session *session, std::string
 
     // If for any reason we reach this point, we should drop the connection.
     session->close();
-    LOG_INFO << "Dropped the user connection " << session->address_ << ":" << session->port_;
+    LOG_INFO << "Dropped the user connection " << session->address << ":" << session->port;
 }
 
 /**
  * This gets hit every time a client disconnects from the HP public port.
  */
-void user_session_handler::on_close(sock::socket_session *session)
+void user_session_handler::on_close(sock::socket_session<user_outbound_message> *session)
 {
     // Cleanup any resources related to this session.
 
     // Session is awaiting challenge response.
     if (session->flags_[util::SESSION_FLAG::USER_CHALLENGE_ISSUED])
     {
-        usr::pending_challenges.erase(session->uniqueid_);
+        usr::pending_challenges.erase(session->uniqueid);
     }
     // Session belongs to an authed user.
     else if (session->flags_[util::SESSION_FLAG::USER_AUTHED])
     {
         // Wait for SC process completion before we remove existing user.
         proc::await_contract_execution();
-        usr::remove_user(session->uniqueid_);
+        usr::remove_user(session->uniqueid);
     }
 
-    LOG_INFO << "User disconnected " << session->uniqueid_;
+    LOG_INFO << "User disconnected " << session->uniqueid;
 }
 
 } // namespace usr

src/usr/user_session_handler.hpp

@@ -1,3 +1,6 @@
+#ifndef _HP_USER_SESSION_HANDLER_H_
+#define _HP_USER_SESSION_HANDLER_H_
+
 #include <boost/beast/core.hpp>
 #include "../sock/socket_session_handler.hpp"
 #include "../sock/socket_session.hpp"
@@ -5,12 +8,29 @@
 namespace usr
 {
 
-class user_session_handler : public sock::socket_session_handler
+/**
+ * Represents a message (bytes) that is sent to a user.
+ */
+class user_outbound_message : public sock::outbound_message
 {
+    // Contains message bytes.
+    std::string msg;
+
 public:
-    void on_connect(sock::socket_session *session);
-    void on_message(sock::socket_session *session, std::string &&message);
-    void on_close(sock::socket_session *session);
+    user_outbound_message(std::string &&_msg);
+
+    // Returns the buffer that should be written to the socket.
+    virtual std::string_view buffer();
 };
 
-} // namespace usr
+class user_session_handler : public sock::socket_session_handler<user_outbound_message>
+{
+public:
+    void on_connect(sock::socket_session<user_outbound_message> *session);
+    void on_message(sock::socket_session<user_outbound_message> *session, std::string_view message);
+    void on_close(sock::socket_session<user_outbound_message> *session);
+};
+
+} // namespace usr
+
+#endif

src/usr/usr.cpp

@@ -202,9 +202,9 @@ int verify_user_challenge_response(std::string &extracted_pubkeyhex, std::string
  * @param pubkey User's binary public key.
  * @return 0 on successful additions. -1 on failure.
  */
-int add_user(sock::socket_session *session, const std::string &pubkey)
+int add_user(sock::socket_session<user_outbound_message> *session, const std::string &pubkey)
 {
-    const std::string &sessionid = session->uniqueid_;
+    const std::string &sessionid = session->uniqueid;
     if (users.count(sessionid) == 1)
     {
         LOG_INFO << sessionid << " already exist. Cannot add user.";
@@ -249,7 +249,7 @@ int remove_user(const std::string &sessionid)
 void start_listening()
 {
     auto address = net::ip::make_address(conf::cfg.listenip);
-    std::make_shared<sock::socket_server>(
+    std::make_shared<sock::socket_server<user_outbound_message>>(
         ioc,
         tcp::endpoint{address, conf::cfg.pubport},
         global_usr_session_handler)

src/usr/usr.hpp

@@ -6,6 +6,7 @@
 #include <unordered_map>
 #include "../util.hpp"
 #include "../sock/socket_session.hpp"
+#include "user_session_handler.hpp"
 
 /**
  * Maintains the global user list with pending input outputs and manages user connections.
@@ -27,12 +28,12 @@ struct connected_user
 
     // Holds the websocket session of this user.
     // We don't need to own the session object since the lifetime of user and session are coupled.
-    sock::socket_session *session;
+    sock::socket_session<user_outbound_message> *session;
 
     /**
      * @param _pubkey The public key of the user in binary format.
      */
-    connected_user(sock::socket_session *_session, std::string_view _pubkey)
+    connected_user(sock::socket_session<user_outbound_message> *_session, std::string_view _pubkey)
     {
         session = _session;
         pubkey = _pubkey;
@@ -64,7 +65,7 @@ void create_user_challenge(std::string &msg, std::string &challengehex);
 
 int verify_user_challenge_response(std::string &extracted_pubkeyhex, std::string_view response, std::string_view original_challenge);
 
-int add_user(sock::socket_session *session, const std::string &pubkey);
+int add_user(sock::socket_session<user_outbound_message> *session, const std::string &pubkey);
 
 int remove_user(const std::string &sessionid);