WIP

Author: taras

uvloop/handles/pipe.pxd

@@ -25,6 +25,8 @@ cdef class ReadUnixTransport(UVStream):
     cdef ReadUnixTransport new(Loop loop, object protocol, Server server,
                                object waiter)
 
+    cpdef write(self, data)
+
 
 cdef class WriteUnixTransport(UVStream):
 

uvloop/handles/pipe.pyx

@@ -156,7 +156,7 @@ cdef class ReadUnixTransport(UVStream):
     def get_write_buffer_size(self):
         raise NotImplementedError
 
-    def write(self, data):
+    cpdef write(self, data):
         raise NotImplementedError
 
     def writelines(self, list_of_data):

uvloop/handles/stream.pyx

@@ -931,6 +931,7 @@ cdef void __uv_stream_buffered_alloc(
         try:
             (<SSLProtocol>sc._protocol).get_buffer_impl(
                 suggested_size, &uvbuf.base, &uvbuf.len)
+
             return
         except BaseException as exc:
             # Can't call 'sc._fatal_error' or 'sc._close', libuv will SF.

uvloop/includes/consts.pxi

@@ -15,6 +15,8 @@ cdef enum:
 
 
     LOG_THRESHOLD_FOR_CONNLOST_WRITES = 5
+
+    SSL_READ_DEFAULT_SIZE = 64 * 1024
     SSL_READ_MAX_SIZE = 256 * 1024
 
 

uvloop/sslproto.pxd

@@ -58,8 +58,10 @@ cdef class SSLProtocol:
         object _incoming_write
         object _outgoing
         object _outgoing_read
-        char* _ssl_buffer
-        size_t _ssl_buffer_len
+        bytearray _plain_read_buffer
+        bytearray _ssl_read_buffer
+        object _ssl_read_max_size_obj
+
         SSLProtocolState _state
         size_t _conn_lost
         AppProtocolState _app_state

uvloop/sslproto.pyx

@@ -1,3 +1,7 @@
+from cpython.bytearray cimport PyByteArray_FromStringAndSize, PyByteArray_AS_STRING, PyByteArray_GET_SIZE, PyByteArray_Resize
+from cpython.bytes cimport PyBytes_FromStringAndSize
+
+
 cdef _create_transport_context(server_side, server_hostname):
     if server_side:
         raise ValueError('Server side SSL needs a valid SSLContext')
@@ -199,22 +203,12 @@ cdef class SSLProtocol:
     buffers which are ssl.MemoryBIO objects.
     """
 
-    def __cinit__(self, *args, **kwargs):
-        self._ssl_buffer_len = SSL_READ_MAX_SIZE
-        self._ssl_buffer = <char*>PyMem_RawMalloc(self._ssl_buffer_len)
-        if not self._ssl_buffer:
-            raise MemoryError()
-
-    def __dealloc__(self):
-        PyMem_RawFree(self._ssl_buffer)
-        self._ssl_buffer = NULL
-        self._ssl_buffer_len = 0
-
     def __init__(self, loop, app_protocol, sslcontext, waiter,
                  server_side=False, server_hostname=None,
                  call_connection_made=True,
                  ssl_handshake_timeout=None,
                  ssl_shutdown_timeout=None):
+
         if ssl_handshake_timeout is None:
             ssl_handshake_timeout = SSL_HANDSHAKE_TIMEOUT
         elif ssl_handshake_timeout <= 0:
@@ -261,6 +255,11 @@ cdef class SSLProtocol:
         self._incoming_write = self._incoming.write
         self._outgoing = ssl_MemoryBIO()
         self._outgoing_read = self._outgoing.read
+
+        self._plain_read_buffer = PyByteArray_FromStringAndSize(
+            NULL, SSL_READ_DEFAULT_SIZE)
+        self._ssl_read_max_size_obj = SSL_READ_MAX_SIZE
+
         self._state = UNWRAPPED
         self._conn_lost = 0  # Set when connection_lost called
         if call_connection_made:
@@ -291,8 +290,12 @@ cdef class SSLProtocol:
             self._app_protocol_get_buffer = app_protocol.get_buffer
             self._app_protocol_buffer_updated = app_protocol.buffer_updated
             self._app_protocol_is_buffer = True
+            self._ssl_read_buffer = None
         else:
             self._app_protocol_is_buffer = False
+            if self._ssl_read_buffer is None:
+                self._ssl_read_buffer = PyByteArray_FromStringAndSize(
+                    NULL, SSL_READ_MAX_SIZE)
 
     cdef _wakeup_waiter(self, exc=None):
         if self._waiter is None:
@@ -356,21 +359,24 @@ cdef class SSLProtocol:
             self._handshake_timeout_handle = None
 
     cdef get_buffer_impl(self, size_t n, char** buf, size_t* buf_size):
-        cdef size_t want = n
-        if want > SSL_READ_MAX_SIZE:
-            want = SSL_READ_MAX_SIZE
-        if self._ssl_buffer_len < want:
-            self._ssl_buffer = <char*>PyMem_RawRealloc(self._ssl_buffer, want)
-            if not self._ssl_buffer:
-                raise MemoryError()
-            self._ssl_buffer_len = want
-
-        buf[0] = self._ssl_buffer
-        buf_size[0] = self._ssl_buffer_len
+        cdef Py_ssize_t want = min(<Py_ssize_t>n, SSL_READ_MAX_SIZE)
+
+        if len(self._plain_read_buffer) < want:
+            PyByteArray_Resize(self._plain_read_buffer, want)
+            if self._ssl_read_buffer is not None:
+                PyByteArray_Resize(self._ssl_read_buffer, want)
+
+        buf[0] = PyByteArray_AS_STRING(self._plain_read_buffer)
+        buf_size[0] = PyByteArray_GET_SIZE(self._plain_read_buffer)
 
     cdef buffer_updated_impl(self, size_t nbytes):
-        self._incoming_write(PyMemoryView_FromMemory(
-            self._ssl_buffer, nbytes, PyBUF_WRITE))
+        mv = PyMemoryView_FromMemory(
+            self._plain_read_buffer,
+            nbytes,
+            PyBUF_WRITE
+        )
+
+        self._incoming_write(mv)
 
         if self._state == DO_HANDSHAKE:
             self._do_handshake()
@@ -597,7 +603,7 @@ cdef class SSLProtocol:
             bint close_notify = False
         try:
             while True:
-                if not self._sslobj_read(SSL_READ_MAX_SIZE):
+                if not self._sslobj_read(self._ssl_read_max_size_obj):
                     close_notify = True
                     break
         except ssl_SSLAgainErrors as exc:
@@ -787,7 +793,7 @@ cdef class SSLProtocol:
                         PyBUF_WRITE)
 
                 last_bytes_read = <Py_ssize_t>self._sslobj_read(
-                    app_buffer_size - total_bytes_read, app_buffer)
+                    self._ssl_read_max_size_obj, app_buffer)
                 total_bytes_read += last_bytes_read
 
                 if last_bytes_read == 0:
@@ -823,32 +829,36 @@ cdef class SSLProtocol:
 
     cdef _do_read__copied(self):
         cdef:
-            list data
-            bytes first, chunk = b'1'
-            bint zero = True, one = False
+            Py_ssize_t bytes_read = -1
+            list data = None
+            bytes first_chunk = None, curr_chunk
 
         try:
             while (<Py_ssize_t>self._incoming.pending > 0 or
                    <Py_ssize_t>self._sslobj_pending() > 0):
-                chunk = self._sslobj_read(SSL_READ_MAX_SIZE)
-                if not chunk:
+                bytes_read = self._sslobj_read(
+                    self._ssl_read_max_size_obj,
+                    self._ssl_read_buffer)
+                if bytes_read == 0:
                     break
-                if zero:
-                    zero = False
-                    one = True
-                    first = chunk
-                elif one:
-                    one = False
-                    data = [first, chunk]
+
+                curr_chunk = <bytes> PyBytes_FromStringAndSize(
+                    PyByteArray_AS_STRING(self._ssl_read_buffer), bytes_read)
+
+                if first_chunk is None:
+                    first_chunk = curr_chunk
+                elif data is None:
+                    data = [first_chunk, curr_chunk]
                 else:
-                    data.append(chunk)
+                    data.append(curr_chunk)
         except ssl_SSLAgainErrors as exc:
             pass
-        if one:
-            self._app_protocol.data_received(first)
-        elif not zero:
+
+        if data is not None:
             self._app_protocol.data_received(b''.join(data))
-        if not chunk:
+        elif first_chunk is not None:
+            self._app_protocol.data_received(first_chunk)
+        elif bytes_read == 0:
             # close_notify
             self._call_eof_received()
             self._start_shutdown()