Cleaning sockets and testing examples

Author: hamidr

examples/tcp_server.hpp

@@ -10,34 +10,33 @@
 namespace async_redis {
 namespace tcp_server {
 
-  template<typename InputOutputHandler>
   class tcp_server
   {
   public:
-    using tcp_socket   = async_redis::network::tcp_socket<InputOutputHandler>;
+    using tcp_socket   = async_redis::network::tcp_socket;
+    using async_socket   = async_redis::network::async_socket;
 
-    tcp_server(InputOutputHandler &event_loop)
-      : loop_(event_loop) {
-      listener_ = std::make_shared<tcp_socket>(event_loop);
+    tcp_server(event_loop::event_loop_ev &event_loop)
+      : loop_(event_loop), listener_(event_loop) {
     }
 
     void listen(int port) {
-      if (!listener_->bind("127.0.0.1", port) || !listener_->listen())
+      if (!listener_.bind("127.0.0.1", port) || !listener_.listen())
         throw;
 
       auto receiver = std::bind(&tcp_server::accept, this, std::placeholders::_1);
-      listener_->template async_accept<tcp_socket>(receiver);
+      listener_.async_accept(receiver);
     }
 
-    void accept(std::shared_ptr<tcp_socket> socket) {
+    void accept(std::shared_ptr<async_socket> socket) {
       auto receiver = std::bind(&tcp_server::chunk_received, this, std::placeholders::_1, socket);
       socket->async_read(buffer_, max_buffer_length, receiver);
 
       conns_.emplace(socket, nullptr);
     }
 
   private:
-    void chunk_received(int len, std::shared_ptr<tcp_socket>& socket)
+    void chunk_received(int len, std::shared_ptr<async_socket>& socket)
     {
       std::string command;
 
@@ -78,10 +77,10 @@ namespace tcp_server {
     }
 
   private:
-    using socket_t = std::shared_ptr<tcp_socket>;
+    using socket_t = std::shared_ptr<async_socket>;
 
-    socket_t listener_;
-    InputOutputHandler& loop_;
+    tcp_socket listener_;
+    event_loop::event_loop_ev& loop_;
     std::unordered_map<socket_t, void*> conns_;
     enum { max_buffer_length = 1024 };
     char buffer_[max_buffer_length];

includes/connection.hpp

@@ -30,15 +30,15 @@ namespace async_redis
       if (!socket_ || !socket_->is_valid())
         socket_ = std::make_unique<tcp_socket>(event_loop_);
 
-      socket_->template async_connect<tcp_socket>(0, handler, ip, port);
+      static_cast<tcp_socket*>(socket_.get())->async_connect(ip, port, handler);
     }
 
     void connect(async_socket::connect_handler_t handler, const std::string& path)
     {
       if (!socket_ || !socket_->is_valid())
         socket_ = std::make_unique<unix_socket>(event_loop_);
 
-      socket_->template async_connect<unix_socket>(0, handler, path);
+      static_cast<unix_socket*>(socket_.get())->async_connect(path, handler);
     }
 
     bool is_connected() const

includes/monitor.hpp

@@ -33,15 +33,15 @@ namespace async_redis
       if (!socket_ || !socket_->is_valid())
         socket_ = std::make_unique<tcp_socket>(io_);
 
-      socket_->template async_connect<tcp_socket>(0, handler, ip, port);
+      static_cast<tcp_socket*>(socket_.get())->async_connect(ip, port, handler);
     }
 
     void connect(async_socket::connect_handler_t handler, const std::string& path)
     {
       if (!socket_ || !socket_->is_valid())
         socket_ = std::make_unique<unix_socket>(io_);
 
-      socket_->template async_connect<unix_socket>(0, handler, path);
+      static_cast<unix_socket*>(socket_.get())->async_connect(path, handler);
     }
 
     inline bool is_connected() const

includes/network/async_socket.hpp

@@ -36,15 +36,6 @@ namespace async_redis {
         : io_(io)
       { }
 
-      async_socket(event_loop::event_loop_ev &io, int fd)
-        : io_(io)
-      {
-        fd_ = fd;
-        is_connected_ = true;
-
-        id_ = io_.watch(fd_);
-      }
-
       ~async_socket() {
         close();
       }
@@ -125,8 +116,33 @@ namespace async_redis {
         return true;
       }
 
+      void async_accept(const std::function<void(std::shared_ptr<async_socket>)>& cb)
+      {
+        return io_.async_read(id_, [this, cb]() {
+            int fd = this->accept();
+            auto s = std::make_shared<async_socket>(io_);
+            s->set_fd_socket(fd);
+            cb(s);
+            this->async_accept(cb);
+          });
+      }
+
+      inline
+      bool is_connected() const {
+        return is_connected_;
+      }
+
+    protected:
+      void set_fd_socket(int fd)
+      {
+        fd_ = fd;
+        is_connected_ = true;
+
+        id_ = io_.watch(fd_);
+      }
+
       template <typename SocketType, typename... Args>
-      void async_connect(int timeout, async_socket::connect_handler_t handler, Args... args)
+      void async_connect(int timeout, connect_handler_t handler, Args... args)
       {
         if (timeout == 10) // is equal to 1 second
           return handler(false);
@@ -140,22 +156,7 @@ namespace async_redis {
           });
       }
 
-      template<typename SocketType>
-      void async_accept(const std::function<void(std::shared_ptr<SocketType>)>& cb)
-      {
-        return io_.async_read(id_, [&, cb]() {
-            int fd = this->accept();
-            cb(std::make_shared<SocketType>(io_, fd));
-            this->async_accept(cb);
-          });
-      }
 
-      inline
-      bool is_connected() const {
-        return is_connected_;
-      }
-
-    protected:
       void create_socket(int domain) {
         if (-1 == (fd_ = socket(domain, SOCK_STREAM, 0)))
           throw connect_socket_exception();

includes/network/tcp_socket.hpp

@@ -15,9 +15,11 @@ namespace async_redis {
         this->create_socket(AF_INET);
       }
 
-      tcp_socket(event_loop::event_loop_ev& io, int fd)
-        : async_socket(io, fd)
-      {}
+      inline
+      void async_connect(const string& ip, int port, connect_handler_t handler)
+      {
+        async_socket::template async_connect<tcp_socket>(0, handler, ip, port);
+      }
 
       bool bind(const string& host, int port)
       {

includes/network/unix_socket.hpp

@@ -17,9 +17,10 @@ namespace async_redis {
       }
 
       inline
-      unix_socket(event_loop::event_loop_ev &io, int fd)
-        : async_socket(io, fd)
-      {}
+      void async_connect(const string& path, connect_handler_t handler)
+      {
+        async_socket::template async_connect<unix_socket>(0, handler, path);
+      }
 
       int connect(const string& path) {
         struct sockaddr_un addr = {0};

test/main.cpp

@@ -7,6 +7,7 @@
 #include <network/unix_socket.hpp>
 #include <monitor.hpp>
 #include <sentinel.hpp>
+#include "../examples/tcp_server.hpp"
 
 #include <event_loop/event_loop_ev.h>
 
@@ -169,7 +170,9 @@ int main(int argc, char** args)
 
   event_loop_ev loop;
 
-  monitor_test monitor_mock(loop, 10000);
+  monitor_test monitor_mock(loop, 100000);
+  // async_redis::tcp_server::tcp_server server(loop);
+  // server.listen(9090);
   // sentinel_test sentinel_mock(loop);
 
   // using unix_socket_t = async_redis::network::unix_socket<event_loop_ev>;