Fix tests

Author: taras

uvloop/handles/stream.pyx

@@ -233,7 +233,6 @@ cdef class UVStream(UVBaseTransport):
         UVBaseTransport._set_protocol(self, protocol)
 
         if isinstance(protocol, SSLProtocol):
-            self._protocol_buffer_updated = protocol.buffer_updated
             self.__buffered = 1
         elif (hasattr(protocol, 'get_buffer') and
                 not isinstance(protocol, aio_Protocol)):
@@ -930,13 +929,16 @@ cdef void __uv_stream_buffered_alloc(
     cdef UVStream sc = <UVStream>stream.data
 
     # Fast pass for our own SSLProtocol
-    # avoid python calls, memoryviews, etc
+    # avoid python calls, memoryviews, context enter/exit, etc
     if isinstance(sc._protocol, SSLProtocol):
         try:
-            (<SSLProtocol>sc._protocol).get_buffer_c(
+            (<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.
+            # We'll do it later in __uv_stream_buffered_on_read when we
+            # receive UV_ENOBUFS.
             uvbuf.len = 0
             uvbuf.base = NULL
             return
@@ -1023,7 +1025,14 @@ cdef void __uv_stream_buffered_on_read(
         if UVLOOP_DEBUG:
             loop._debug_stream_read_cb_total += 1
 
-        run_in_context1(sc.context, sc._protocol_buffer_updated, nread)
+        if isinstance(sc._protocol, SSLProtocol):
+            Context_Enter(sc.context)
+            try:
+                (<SSLProtocol>sc._protocol).buffer_updated_impl(nread)
+            finally:
+                Context_Exit(sc.context)
+        else:
+            run_in_context1(sc.context, sc._protocol_buffer_updated, nread)
     except BaseException as exc:
         if UVLOOP_DEBUG:
             loop._debug_stream_read_cb_errors_total += 1

uvloop/sslproto.pxd

@@ -83,7 +83,11 @@ cdef class SSLProtocol:
         object _handshake_timeout_handle
         object _shutdown_timeout_handle
 
-    cdef inline get_buffer_c(self, size_t n, char** buf, size_t* buf_size)
+    # Instead of doing python calls, c methods *_impl are called directly
+    # from stream.pyx
+
+    cdef inline get_buffer_impl(self, size_t n, char** buf, size_t* buf_size)
+    cdef inline buffer_updated_impl(self, size_t nbytes)
 
     cdef inline _set_app_protocol(self, app_protocol)
     cdef inline _wakeup_waiter(self, exc=*)

uvloop/sslproto.pyx

@@ -355,7 +355,7 @@ cdef class SSLProtocol:
             self._handshake_timeout_handle.cancel()
             self._handshake_timeout_handle = None
 
-    cdef get_buffer_c(self, size_t n, char** buf, size_t* buf_size):
+    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
@@ -368,17 +368,7 @@ cdef class SSLProtocol:
         buf[0] = self._ssl_buffer
         buf_size[0] = self._ssl_buffer_len
 
-    def get_buffer(self, size_t n):
-        # This pure python call is still used by some very peculiar test cases
-
-        cdef:
-            char* buf
-            size_t buf_size
-
-        self.get_buffer_c(n, &buf, &buf_size)
-        return PyMemoryView_FromMemory(buf, buf_size, PyBUF_WRITE)
-
-    def buffer_updated(self, size_t nbytes):
+    cdef buffer_updated_impl(self, size_t nbytes):
         self._incoming_write(PyMemoryView_FromMemory(
             self._ssl_buffer, nbytes, PyBUF_WRITE))
 
@@ -394,6 +384,18 @@ cdef class SSLProtocol:
         elif self._state == SHUTDOWN:
             self._do_shutdown()
 
+    def get_buffer(self, size_t n):
+        # This pure python call is still used by some very peculiar test cases
+        cdef:
+            char* buf
+            size_t buf_size
+
+        self.get_buffer_impl(n, &buf, &buf_size)
+        return PyMemoryView_FromMemory(buf, buf_size, PyBUF_WRITE)
+
+    def buffer_updated(self, size_t nbytes):
+        self.buffer_updated_impl(nbytes)
+
     def eof_received(self):
         """Called when the other end of the low-level stream
         is half-closed.
@@ -546,6 +548,7 @@ cdef class SSLProtocol:
         if self._app_state == STATE_INIT:
             self._app_state = STATE_CON_MADE
             self._app_protocol.connection_made(self._get_app_transport())
+
         self._wakeup_waiter()
 
         # We should wakeup user code before sending the first data below. In
@@ -558,7 +561,7 @@ cdef class SSLProtocol:
             new_MethodHandle(self._loop,
                              "SSLProtocol._do_read",
                              <method_t> self._do_read,
-                             None,  # current context is good
+                             None,
                              self))
 
     # Shutdown flow
@@ -758,7 +761,7 @@ cdef class SSLProtocol:
                         new_MethodHandle(self._loop,
                                          "SSLProtocol._do_read",
                                          <method_t>self._do_read,
-                                         None,  # current context is good
+                                         None,
                                          self))
         except ssl_SSLAgainErrors as exc:
             pass
@@ -794,10 +797,12 @@ cdef class SSLProtocol:
                     data.append(chunk)
         except ssl_SSLAgainErrors as exc:
             pass
+
         if one:
             self._app_protocol.data_received(first)
         elif not zero:
             self._app_protocol.data_received(b''.join(data))
+
         if not chunk:
             # close_notify
             self._call_eof_received()
@@ -887,11 +892,12 @@ cdef class SSLProtocol:
             self._app_reading_paused = False
             if self._state == WRAPPED:
                 self._loop._call_soon_handle(
-                    new_MethodHandle(self._loop,
-                                     "SSLProtocol._do_read",
-                                     <method_t>self._do_read,
-                                     context,
-                                     self))
+                    new_MethodHandle1(self._loop,
+                                      "SSLProtocol._do_read",
+                                      <method1_t>self._do_read,
+                                      context,
+                                      self,
+                                      context))
 
     # Flow control for reads from SSL socket