implemented async server

network/__init__.py

@@ -116,8 +116,9 @@ class Server(object):
         self.conn_to_handler ={}
         self.handler_to_conn = {}
         self.read_sockets_expected = [self.socket]
-        self.write_sockets_expected = []
-        self.exc_sockets_expected = []
+
+    def cleanup(self):
+        pass
 
     def make_socket(self):
         lserver.debug("making a {} socket".format(self.af_family))
@@ -173,53 +174,88 @@ class Server(object):
         self.socket.listen(self.max_allowed_clients)
         # self.socket.settimeout(1)
 
-    def run(self):
+    def start(self):
+        curio.run(self.run):
+
+    async def run(self):
         self.setup()
         lserver.debug("entering main loop")
         while ( not self.exit_event ):
             # lserver.debug(self.read_sockets_expected)
             # lserver.debug(self.write_sockets_expected)
             # lserver.debug(self.exc_sockets_expected)
-            read_sockets_confirmed, \
-            write_sockets_confirmed, \
-            exc_sockets_confirmed \
-                = select.select(self.read_sockets_expected,
-                            self.write_sockets_expected,
-                            self.exc_sockets_expected,
-                )
-            for s in read_sockets_confirmed:
-                socket_handler = self.conn_to_handler.get(s, None)
-                if ( s == self.socket ):
-                    lserver.debug("handling new client")
-                    conn, addr = self.socket.accept()
+            # read_sockets = select.select(self.read_sockets_expected,[],[])
+            lserver.debug("waiting for client to connect")
+            conn,addr = await self.socket.accept()
+            if self.log_ip:
+                lserver.info(
+                    "new client connection, {}:{}!".format(*addr))
+            else:
+                lserver.info("a new client connected, let's handle it")
+            handler = self.make_handler(conn, addr)
+            self.register_conn(conn, addr)
+            self.register_handler(handler, conn)
+            await cutio.spawn(self.loop(conn))
+
+            # for s in read_sockets_confirmed:
+            #     socket_handler = self.conn_to_handler.get(s, None)
+            #     if ( s == self.socket ):
+            #         lserver.debug("handling new client")
+            #         conn, addr = self.socket.accept()
+            #         if self.log_ip:
+            #             lserver.info(
+            #                 "New connection from {} on port {}".format(*addr))
+            #         handler = self.make_handler(conn, addr)
+            #         self.register_conn(conn, addr)
+            #         self.register_handler(handler, conn)
+            #     elif ( socket_handler
+            #             and (socket_handler in self.connection_handler) ):
+            #         lserver.debug("handling client connection")
+            #         try:
+            #             data = socket_handler.recv()
+            #             if not data:
+            #                 lserver.info("connection {} closed".format(self.socket))
+            #                 self.unregister_handler(socket_handler, s)
+            #                 self.unregister_conn(conn)
+            #                 socket_handler.close()
+            #             else:
+            #                 lschat.info("Client:"+data.strip())
+            #                 socket_handler.handle(data)
+            #         except Exception as e:
+            #             lserver.error(e, exc_info=True)
+            #     else:
+            #         lserver.debug("else!")
+            #         lserver.debug(socket_handler)
+            #         time.sleep(1)
+
+        async def wait_for_client(self,socket,handler):
+            while True:
+                try:
                     if self.log_ip:
-                        lserver.info(
-                            "New connection from {} on port {}".format(*addr))
-                    handler = self.make_handler(conn, addr)
-                    self.register_conn(conn, addr)
-                    self.register_handler(handler, conn)
-                elif ( socket_handler
-                        and (socket_handler in self.connection_handler) ):
-                    lserver.debug("handling client connection")
-                    try:
-                        data = socket_handler.recv()
-                        if not data:
-                            lserver.info("connection {} closed".format(self.socket))
-                            self.unregister_handler(socket_handler, s)
-                            self.unregister_conn(conn)
-                            socket_handler.close()
+                        lserver.debug(
+                            "waiting for {} to send something"
+                            .format(socket.getsockname()))
+                    else:
+                        lserver.debug(
+                            "waiting for the client to send something")
+                    data = await handler.recv()
+                    if not data:
+                        if self.log_ip:
+                            lserver.info(
+                                "the connection to {} was closed"
+                                .format(socket.getsockname()))
                         else:
-                            lschat.info("Client:"+data.strip())
-                            socket_handler.handle(data)
-                    except Exception as e:
-                        lserver.error(e, exc_info=True)
-                else:
-                    lserver.debug("else!")
-                    lserver.debug(socket_handler)
-                    time.sleep(1)
+                            lserver.info(
+                                "the connection to the client was closed")
+                        self.unregister_handler(handler, socket)
+                        self.unregister_conn(socket)
+                        handler.close()
+                    else:
+                        lschat.info("Client:"+data.strip())
+                        socket_handler.handle(data)
+            except Exception as e:
+                    lserver.error(e, exc_info=True)
 
-        def cleanup(self):
-            pass
 
 class Client(threading.Thread):
     """docstring for Client"""