Implement Server.start_serving() and related APIs

tests/test_tcp.py

@@ -129,6 +129,8 @@ async def start_server():
 
             srv_socks = srv.sockets
             self.assertTrue(srv_socks)
+            if self.has_start_serving():
+                self.assertTrue(srv.is_serving())
 
             addr = srv_socks[0].getsockname()
 
@@ -147,6 +149,9 @@ async def start_server():
             for srv_sock in srv_socks:
                 self.assertEqual(srv_sock.fileno(), -1)
 
+            if self.has_start_serving():
+                self.assertFalse(srv.is_serving())
+
         async def start_server_sock():
             nonlocal CNT
             CNT = 0
@@ -167,6 +172,8 @@ async def start_server_sock():
 
             srv_socks = srv.sockets
             self.assertTrue(srv_socks)
+            if self.has_start_serving():
+                self.assertTrue(srv.is_serving())
 
             tasks = []
             for _ in range(TOTAL_CNT):
@@ -183,6 +190,9 @@ async def start_server_sock():
             for srv_sock in srv_socks:
                 self.assertEqual(srv_sock.fileno(), -1)
 
+            if self.has_start_serving():
+                self.assertFalse(srv.is_serving())
+
         self.loop.run_until_complete(start_server())
         self.assertEqual(CNT, TOTAL_CNT)
 
@@ -206,6 +216,8 @@ async def start_server_ephemeral_ports():
 
                 srv_socks = srv.sockets
                 self.assertTrue(srv_socks)
+                if self.has_start_serving():
+                    self.assertTrue(srv.is_serving())
 
                 host, port = srv_socks[0].getsockname()
                 self.assertNotEqual(0, port)
@@ -217,6 +229,9 @@ async def start_server_ephemeral_ports():
                 for srv_sock in srv_socks:
                     self.assertEqual(srv_sock.fileno(), -1)
 
+                if self.has_start_serving():
+                    self.assertFalse(srv.is_serving())
+
         self.loop.run_until_complete(start_server_ephemeral_ports())
 
     def test_create_server_4(self):
@@ -335,6 +350,60 @@ def test_create_server_8(self):
                 self.loop.create_server(
                     lambda: None, host='::', port=0, ssl_handshake_timeout=10))
 
+    def test_create_server_9(self):
+        if not self.has_start_serving():
+            raise unittest.SkipTest()
+
+        async def handle_client(reader, writer):
+            pass
+
+        async def start_server():
+            srv = await asyncio.start_server(
+                handle_client,
+                '127.0.0.1', 0,
+                family=socket.AF_INET,
+                loop=self.loop,
+                start_serving=False)
+
+            await srv.start_serving()
+            self.assertTrue(srv.is_serving())
+
+            # call start_serving again
+            await srv.start_serving()
+            self.assertTrue(srv.is_serving())
+
+            srv.close()
+            await srv.wait_closed()
+            self.assertFalse(srv.is_serving())
+
+        self.loop.run_until_complete(start_server())
+
+    def test_create_server_10(self):
+        if not self.has_start_serving():
+            raise unittest.SkipTest()
+
+        async def handle_client(reader, writer):
+            pass
+
+        async def start_server():
+            srv = await asyncio.start_server(
+                handle_client,
+                '127.0.0.1', 0,
+                family=socket.AF_INET,
+                loop=self.loop,
+                start_serving=False)
+
+            fut = asyncio.ensure_future(srv.serve_forever(), loop=self.loop)
+            await asyncio.sleep(0, loop=self.loop)
+            self.assertTrue(srv.is_serving())
+
+            fut.cancel()
+            with self.assertRaises(asyncio.CancelledError):
+                await fut
+            self.assertFalse(srv.is_serving())
+
+        self.loop.run_until_complete(start_server())
+
     def test_create_connection_open_con_addr(self):
         async def client(addr):
             reader, writer = await asyncio.open_connection(

tests/test_unix.py

@@ -66,6 +66,8 @@ async def start_server():
                 try:
                     srv_socks = srv.sockets
                     self.assertTrue(srv_socks)
+                    if self.has_start_serving():
+                        self.assertTrue(srv.is_serving())
 
                     tasks = []
                     for _ in range(TOTAL_CNT):
@@ -83,6 +85,9 @@ async def start_server():
                     for srv_sock in srv_socks:
                         self.assertEqual(srv_sock.fileno(), -1)
 
+                    if self.has_start_serving():
+                        self.assertFalse(srv.is_serving())
+
                 # asyncio doesn't cleanup the sock file
                 self.assertTrue(os.path.exists(sock_name))
 
@@ -100,6 +105,8 @@ async def start_server_sock(start_server):
                 try:
                     srv_socks = srv.sockets
                     self.assertTrue(srv_socks)
+                    if self.has_start_serving():
+                        self.assertTrue(srv.is_serving())
 
                     tasks = []
                     for _ in range(TOTAL_CNT):
@@ -117,6 +124,9 @@ async def start_server_sock(start_server):
                     for srv_sock in srv_socks:
                         self.assertEqual(srv_sock.fileno(), -1)
 
+                    if self.has_start_serving():
+                        self.assertFalse(srv.is_serving())
+
                 # asyncio doesn't cleanup the sock file
                 self.assertTrue(os.path.exists(sock_name))
 

uvloop/_testbase.py

@@ -67,6 +67,10 @@ def new_loop(self):
     def mock_pattern(self, str):
         return MockPattern(str)
 
+    def has_start_serving(self):
+        return not (self.is_asyncio_loop() and
+                    sys.version_info[:2] in [(3, 5), (3, 6)])
+
     def is_asyncio_loop(self):
         return type(self.loop).__module__.startswith('asyncio.')
 

uvloop/handles/pipe.pxd

@@ -4,6 +4,7 @@ cdef class UnixServer(UVStreamServer):
 
     @staticmethod
     cdef UnixServer new(Loop loop, object protocol_factory, Server server,
+                        object backlog,
                         object ssl,
                         object ssl_handshake_timeout,
                         object ssl_shutdown_timeout)

uvloop/handles/pipe.pyx

@@ -38,13 +38,14 @@ cdef class UnixServer(UVStreamServer):
 
     @staticmethod
     cdef UnixServer new(Loop loop, object protocol_factory, Server server,
+                        object backlog,
                         object ssl,
                         object ssl_handshake_timeout,
                         object ssl_shutdown_timeout):
 
         cdef UnixServer handle
         handle = UnixServer.__new__(UnixServer)
-        handle._init(loop, protocol_factory, server,
+        handle._init(loop, protocol_factory, server, backlog,
                      ssl, ssl_handshake_timeout, ssl_shutdown_timeout)
         __pipe_init_uv_handle(<UVStream>handle, loop)
         return handle

uvloop/handles/streamserver.pxd

@@ -1,5 +1,6 @@
 cdef class UVStreamServer(UVSocketHandle):
     cdef:
+        int backlog
         object ssl
         object ssl_handshake_timeout
         object ssl_shutdown_timeout
@@ -10,13 +11,15 @@ cdef class UVStreamServer(UVSocketHandle):
     # All "inline" methods are final
 
     cdef inline _init(self, Loop loop, object protocol_factory,
-                      Server server, object ssl,
+                      Server server,
+                      object backlog,
+                      object ssl,
                       object ssl_handshake_timeout,
                       object ssl_shutdown_timeout)
 
     cdef inline _mark_as_open(self)
 
-    cdef inline listen(self, backlog)
+    cdef inline listen(self)
     cdef inline _on_listen(self)
 
     cdef UVStream _make_new_transport(self, object protocol, object waiter)

uvloop/handles/streamserver.pyx

@@ -10,10 +10,17 @@ cdef class UVStreamServer(UVSocketHandle):
         self.protocol_factory = None
 
     cdef inline _init(self, Loop loop, object protocol_factory,
-                      Server server, object ssl,
+                      Server server,
+                      object backlog,
+                      object ssl,
                       object ssl_handshake_timeout,
                       object ssl_shutdown_timeout):
 
+        if not isinstance(backlog, int):
+            # Don't allow floats
+            raise TypeError('integer argument expected, got {}'.format(
+                type(backlog).__name__))
+
         if ssl is not None:
             if not isinstance(ssl, ssl_SSLContext):
                 raise TypeError(
@@ -27,6 +34,7 @@ cdef class UVStreamServer(UVSocketHandle):
                 raise ValueError(
                     'ssl_shutdown_timeout is only meaningful with ssl')
 
+        self.backlog = backlog
         self.ssl = ssl
         self.ssl_handshake_timeout = ssl_handshake_timeout
         self.ssl_shutdown_timeout = ssl_shutdown_timeout
@@ -35,23 +43,18 @@ cdef class UVStreamServer(UVSocketHandle):
         self.protocol_factory = protocol_factory
         self._server = server
 
-    cdef inline listen(self, backlog):
+    cdef inline listen(self):
         cdef int err
         self._ensure_alive()
 
-        if not isinstance(backlog, int):
-            # Don't allow floats
-            raise TypeError('integer argument expected, got {}'.format(
-                type(backlog).__name__))
-
         if self.protocol_factory is None:
             raise RuntimeError('unable to listen(); no protocol_factory')
 
         if self.opened != 1:
             raise RuntimeError('unopened TCPServer')
 
         err = uv.uv_listen(<uv.uv_stream_t*> self._handle,
-                           backlog,
+                           self.backlog,
                            __uv_streamserver_on_listen)
         if err < 0:
             exc = convert_error(err)

uvloop/handles/tcp.pxd

@@ -3,7 +3,9 @@ cdef class TCPServer(UVStreamServer):
 
     @staticmethod
     cdef TCPServer new(Loop loop, object protocol_factory, Server server,
-                       object ssl, unsigned int flags,
+                       unsigned int flags,
+                       object backlog,
+                       object ssl,
                        object ssl_handshake_timeout,
                        object ssl_shutdown_timeout)
 

uvloop/handles/tcp.pyx

@@ -57,13 +57,15 @@ cdef class TCPServer(UVStreamServer):
 
     @staticmethod
     cdef TCPServer new(Loop loop, object protocol_factory, Server server,
-                       object ssl, unsigned int flags,
+                       unsigned int flags,
+                       object backlog,
+                       object ssl,
                        object ssl_handshake_timeout,
                        object ssl_shutdown_timeout):
 
         cdef TCPServer handle
         handle = TCPServer.__new__(TCPServer)
-        handle._init(loop, protocol_factory, server,
+        handle._init(loop, protocol_factory, server, backlog,
                      ssl, ssl_handshake_timeout, ssl_shutdown_timeout)
         __tcp_init_uv_handle(<UVStream>handle, loop, flags)
         return handle

uvloop/includes/stdlib.pxi

@@ -66,6 +66,8 @@ cdef gc_disable = gc.disable
 cdef iter_chain = itertools.chain
 cdef inspect_isgenerator = inspect.isgenerator
 
+cdef int has_IPV6_V6ONLY = hasattr(socket, 'IPV6_V6ONLY')
+cdef int IPV6_V6ONLY = getattr(socket, 'IPV6_V6ONLY', -1)
 cdef int has_SO_REUSEPORT = hasattr(socket, 'SO_REUSEPORT')
 cdef int SO_REUSEPORT = getattr(socket, 'SO_REUSEPORT', 0)
 cdef int SO_BROADCAST = getattr(socket, 'SO_BROADCAST')
@@ -118,6 +120,7 @@ cdef sys_set_coroutine_wrapper = sys.set_coroutine_wrapper
 cdef sys_get_coroutine_wrapper = sys.get_coroutine_wrapper
 cdef sys_getframe = sys._getframe
 cdef sys_version_info = sys.version_info
+cdef str sys_platform = sys.platform
 
 cdef ssl_SSLContext = ssl.SSLContext
 cdef ssl_MemoryBIO = ssl.MemoryBIO

uvloop/loop.pxd

@@ -161,15 +161,6 @@ cdef class Loop:
 
     cdef _getnameinfo(self, system.sockaddr *addr, int flags)
 
-    cdef _create_server(self, system.sockaddr *addr,
-                        object protocol_factory,
-                        Server server,
-                        object ssl,
-                        bint reuse_port,
-                        object backlog,
-                        object ssl_handshake_timeout,
-                        object ssl_shutdown_timeout)
-
     cdef _track_transport(self, UVBaseTransport transport)
     cdef _fileobj_to_fd(self, fileobj)
     cdef _ensure_fd_no_transport(self, fd)