Added handshake_shutdown_timeout and test

See also python/cpython#4402

Author: fantix

tests/test_tcp.py

@@ -1,6 +1,8 @@
 import asyncio
 import asyncio.sslproto
 import gc
+import os
+import select
 import socket
 import unittest.mock
 import uvloop
@@ -2128,6 +2130,107 @@ def run(coro):
         with self._silence_eof_received_warning():
             run(client_sock)
 
+    def test_shutdown_timeout(self):
+        if self.implementation == 'asyncio':
+            raise unittest.SkipTest()
+
+        CNT = 0           # number of clients that were successful
+        TOTAL_CNT = 25    # total number of clients that test will create
+        TIMEOUT = 10.0    # timeout for this test
+
+        A_DATA = b'A' * 1024 * 1024
+
+        sslctx = self._create_server_ssl_context(self.ONLYCERT, self.ONLYKEY)
+        client_sslctx = self._create_client_ssl_context()
+
+        clients = []
+
+        async def handle_client(reader, writer):
+            nonlocal CNT
+
+            data = await reader.readexactly(len(A_DATA))
+            self.assertEqual(data, A_DATA)
+            writer.write(b'OK')
+            await writer.drain()
+            writer.close()
+            with self.assertRaisesRegex(TimeoutError,
+                                        'SSL shutdown timed out'):
+                await reader.read()
+            CNT += 1
+
+        async def test_client(addr):
+            fut = asyncio.Future(loop=self.loop)
+
+            def prog(sock):
+                try:
+                    sock.starttls(client_sslctx)
+                    sock.connect(addr)
+                    sock.send(A_DATA)
+
+                    data = sock.recv_all(2)
+                    self.assertEqual(data, b'OK')
+
+                    data = sock.recv(1024)
+                    self.assertEqual(data, b'')
+
+                    fd = sock.detach()
+                    try:
+                        select.select([fd], [], [], 3)
+                    finally:
+                        os.close(fd)
+
+                except Exception as ex:
+                    self.loop.call_soon_threadsafe(fut.set_exception, ex)
+                else:
+                    self.loop.call_soon_threadsafe(fut.set_result, None)
+
+            client = self.tcp_client(prog)
+            client.start()
+            clients.append(client)
+
+            await fut
+
+        async def start_server():
+            extras = {}
+            if self.implementation != 'asyncio' or self.PY37:
+                extras['ssl_handshake_timeout'] = 10.0
+            if self.implementation != 'asyncio':  # or self.PY38
+                extras['ssl_shutdown_timeout'] = 0.5
+
+            srv = await asyncio.start_server(
+                handle_client,
+                '127.0.0.1', 0,
+                family=socket.AF_INET,
+                ssl=sslctx,
+                loop=self.loop,
+                **extras)
+
+            try:
+                srv_socks = srv.sockets
+                self.assertTrue(srv_socks)
+
+                addr = srv_socks[0].getsockname()
+
+                tasks = []
+                for _ in range(TOTAL_CNT):
+                    tasks.append(test_client(addr))
+
+                await asyncio.wait_for(
+                    asyncio.gather(*tasks, loop=self.loop),
+                    TIMEOUT, loop=self.loop)
+
+            finally:
+                self.loop.call_soon(srv.close)
+                await srv.wait_closed()
+
+        with self._silence_eof_received_warning():
+            self.loop.run_until_complete(start_server())
+
+        self.assertEqual(CNT, TOTAL_CNT)
+
+        for client in clients:
+            client.stop()
+
 
 class Test_UV_TCPSSL(_TestSSL, tb.UVTestCase):
     pass

uvloop/handles/pipe.pxd

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

uvloop/handles/pipe.pyx

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

uvloop/handles/streamserver.pxd

@@ -2,14 +2,17 @@ cdef class UVStreamServer(UVSocketHandle):
     cdef:
         object ssl
         object ssl_handshake_timeout
+        object ssl_shutdown_timeout
         object protocol_factory
         bint opened
         Server _server
 
     # All "inline" methods are final
 
     cdef inline _init(self, Loop loop, object protocol_factory,
-                      Server server, object ssl, object ssl_handshake_timeout)
+                      Server server, object ssl,
+                      object ssl_handshake_timeout,
+                      object ssl_shutdown_timeout)
 
     cdef inline _mark_as_open(self)
 

uvloop/handles/streamserver.pyx

@@ -6,10 +6,13 @@ cdef class UVStreamServer(UVSocketHandle):
         self._server = None
         self.ssl = None
         self.ssl_handshake_timeout = None
+        self.ssl_shutdown_timeout = None
         self.protocol_factory = None
 
     cdef inline _init(self, Loop loop, object protocol_factory,
-                      Server server, object ssl, object ssl_handshake_timeout):
+                      Server server, object ssl,
+                      object ssl_handshake_timeout,
+                      object ssl_shutdown_timeout):
 
         if ssl is not None:
             if not isinstance(ssl, ssl_SSLContext):
@@ -20,9 +23,13 @@ cdef class UVStreamServer(UVSocketHandle):
             if ssl_handshake_timeout is not None:
                 raise ValueError(
                     'ssl_handshake_timeout is only meaningful with ssl')
+            if ssl_shutdown_timeout is not None:
+                raise ValueError(
+                    'ssl_shutdown_timeout is only meaningful with ssl')
 
         self.ssl = ssl
         self.ssl_handshake_timeout = ssl_handshake_timeout
+        self.ssl_shutdown_timeout = ssl_shutdown_timeout
 
         self._start_init(loop)
         self.protocol_factory = protocol_factory
@@ -67,7 +74,8 @@ cdef class UVStreamServer(UVSocketHandle):
                 waiter,
                 server_side=True,
                 server_hostname=None,
-                ssl_handshake_timeout=self.ssl_handshake_timeout)
+                ssl_handshake_timeout=self.ssl_handshake_timeout,
+                ssl_shutdown_timeout=self.ssl_shutdown_timeout)
 
             client = self._make_new_transport(ssl_protocol, None)
 

uvloop/handles/tcp.pxd

@@ -4,7 +4,8 @@ cdef class TCPServer(UVStreamServer):
     @staticmethod
     cdef TCPServer new(Loop loop, object protocol_factory, Server server,
                        object ssl, unsigned int flags,
-                       object ssl_handshake_timeout)
+                       object ssl_handshake_timeout,
+                       object ssl_shutdown_timeout)
 
 
 cdef class TCPTransport(UVStream):

uvloop/handles/tcp.pyx

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

uvloop/includes/consts.pxi

@@ -17,3 +17,6 @@ DEF LOG_THRESHOLD_FOR_CONNLOST_WRITES = 5
 # Number of seconds to wait for SSL handshake to complete
 # The default timeout matches that of Nginx.
 DEF SSL_HANDSHAKE_TIMEOUT = 60.0
+# Number of seconds to wait for SSL shutdown to complete
+# The default timeout mimics lingering_time
+DEF SSL_SHUTDOWN_TIMEOUT = 30.0

uvloop/loop.pxd

@@ -168,7 +168,8 @@ cdef class Loop:
                         object ssl,
                         bint reuse_port,
                         object backlog,
-                        object ssl_handshake_timeout)
+                        object ssl_handshake_timeout,
+                        object ssl_shutdown_timeout)
 
     cdef _track_transport(self, UVBaseTransport transport)
     cdef _fileobj_to_fd(self, fileobj)