Switch back to synchronous close

There are arguments either way, but the arguments for async close are
largely aesthetic, and the arguments against are that it creates some
tricky problems with exception handling, and extra churn in urllib3
interfaces. For more details see:
  https://github.com/njsmith/urllib3/pull/4#issuecomment-354729966

Author: njsmith

urllib3/backends/trio_backend.py

@@ -65,19 +65,23 @@ async def receiver():
         except LoopAbort:
             pass
 
-    async def forceful_close(self):
-        await trio.aclose_forcefully(self._stream)
+    # Pull out the underlying trio socket, because it turns out HTTP is not so
+    # great at respecting abstraction boundaries.
+    def _socket(self):
+        stream = self._stream
+        # Strip off any layers of SSLStream
+        while hasattr(stream, "transport_stream"):
+            stream = stream.transport_stream
+        # Now we have a SocketStream
+        return stream.socket
+
+    # We want this to be synchronous, and don't care about graceful teardown
+    # of the SSL/TLS layer.
+    def forceful_close(self):
+        self._socket().close()
 
     def is_readable(self):
-        # This is a bit of a hack, but I can't think of a better API that trio
-        # *could* provide, since what we want to check here is such an odd
-        # thing.
-        sock_stream = self._stream
-        # Strip off SSLStream wrappings
-        while hasattr(sock_stream, "transport_stream"):
-            sock_stream = sock_stream.transport_stream
-        sock = sock_stream.socket
-        return is_readable(sock)
+        return is_readable(self._socket())
 
     def set_readable_watch_state(self, enabled):
         pass

urllib3/backends/twisted_backend.py

@@ -245,6 +245,9 @@ def receive_loop_allback(result):
         else:
             raise DoubleError(*failures)
 
+    def forceful_close(self):
+        self._protocol.transport.abortConnection()
+
     def is_readable(self):
         return self._protocol.is_readable()
 

urllib3/connectionpool.py

@@ -123,7 +123,7 @@ def __exit__(self, exc_type, exc_val, exc_tb):
         # Return False to re-raise any potential exceptions
         return False
 
-    async def close(self):
+    def close(self):
         """
         Close all pooled connections and disable the pool.
         """
@@ -277,7 +277,7 @@ async def _get_conn(self, timeout=None):
         # If this is a persistent connection, check if it got disconnected
         if conn and is_connection_dropped(conn):
             log.debug("Resetting dropped connection: %s", self.host)
-            await conn.close()
+            conn.close()
 
         return conn or self._new_conn()
 
@@ -309,7 +309,7 @@ async def _put_conn(self, conn):
 
         # Connection never got put back into the pool, close it.
         if conn:
-            await conn.close()
+            conn.close()
 
     async def _start_conn(self, conn, connect_timeout):
         """
@@ -421,7 +421,7 @@ async def _make_request(
     def _absolute_url(self, path):
         return Url(scheme=self.scheme, host=self.host, port=self.port, path=path).url
 
-    async def close(self):
+    def close(self):
         """
         Close all pooled connections and disable the pool.
         """
@@ -432,7 +432,7 @@ async def close(self):
             while True:
                 conn = old_pool.get(block=False)
                 if conn:
-                    await conn.close()
+                    conn.close()
 
         except queue.Empty:
             pass  # Done.
@@ -618,7 +618,7 @@ async def urlopen(self, method, url, body=None, headers=None, retries=None,
                 # to throw the connection away unless explicitly told not to.
                 # Close the connection, set the variable to None, and make sure
                 # we put the None back in the pool to avoid leaking it.
-                conn = conn and await conn.close()
+                conn = conn and conn.close()
                 release_this_conn = True
 
             if release_this_conn:

urllib3/sync_connection.py

@@ -430,14 +430,14 @@ async def connect(self, ssl_context=None,
         # XX We should pick one of these names and use it consistently...
         self._sock = conn
 
-    async def close(self):
+    def close(self):
         """
         Close this connection.
         """
         if self._sock is not None:
             # Make sure self._sock is None even if closing raises an exception
             sock, self._sock = self._sock, None
-            await sock.forceful_close()
+            sock.forceful_close()
 
     def is_dropped(self):
         """