Keepalive connections aren't released when closing the ConnectionPool #720

Activity

1. florimondmanca commented on Jan 4, 2020

   

   florimondmanca

   on Jan 4, 2020

   Contributor

   More actions

   only one actual connection is opened to the IP address, so pooling seems to work fine

   I don't think that's actually the behavior you'd expect (though, from your code that's the behavior one should expect): since requests are concurrent here, HTTPX will use as many connections as it can to perform the requests, i.e. up to 10 (the hard limit). Once one of the 10 first requests terminates, the connection can be reused by a subsequent request.

   So what you'd expect is to have 10 connections almost constantly being used, but you only get one, plus a pool timeout…

   Your code is similar in spirit to this:

   while True:
       url = await get_next_url()
       async with client:
           response = await client.get(url)

   The async with client is what causes the connection pool to be setup, and then teardown. So in practice, you are tearing down the connection pool after each request, meaning you're only ever able to use one connection (because any previous connection would have been thrown away by closing the pool after the previous request terminated).

   What you need to do for the connection pool to be effectively used, is to move the async with block at the top-level:

   async with client:
       while True:
           url = await get_next_url()
           response = await client.get(url)

   With this I am able to run your program without issues against a local dummy server.

   But that doesn't explain the pool timeout…

   ---

   I am able to reproduce the timeout issue with this example:

   import asyncio
   
   import httpx
   
   
   async def main() -> None:
       url = "http://localhost:8000"
       max_connections = 2
       client = httpx.AsyncClient(
           pool_limits=httpx.PoolLimits(soft_limit=1, hard_limit=max_connections)
       )
   
       for _ in range(max_connections + 1):
           async with client:
               await client.get(url)
   
   
   if __name__ == "__main__":
       asyncio.run(main())

   (Note that if we switch out for _ in range() and async with client as suggested above, there's no error.)

   I pinpointed the origin of the issue to us not releasing the internal max_connections semaphore when closing keepalive connections when closing the connection pool. PR incoming!

   👍React with 👍1Reacted by Edoardo Codeglia
2. florimondmanca

   added

   bugSomething isn't workingSomething isn't working

   on Jan 4, 2020
3. florimondmanca

   changed the title [-]Connections don't get closed[/-] [+]Keepalive connections aren't released when closing the ConnectionPool[/+] on Jan 4, 2020
4. florimondmanca

   added

   poolingIssues and PRs relative to connection poolingIssues and PRs relative to connection pooling

   on Jan 4, 2020
5. edocod1 commented on Jan 4, 2020

   

   edocod1

   on Jan 4, 2020

   Author

   More actions

   Oh, I thought instantiating the client opened the connection pool, and you'd need to use "async with" to let the pool know you wanted a connection. Please close this issue if you feel like it. Thank you!
6. lovelydinosaur

   closed this as completedin #721on Jan 6, 2020
7. zeldrinn commented on Aug 11, 2020

   

   zeldrinn

   on Aug 11, 2020

   More actions

   @florimondmanca is this truly fixed? i'm running into something that seems similar, yet i'm using version 0.13.3 which looks to contain the fix. specifically, if the number of tasks executed via asyncio.gather(...) is greater than max_connections, i get a PoolTimeout. it seems like maybe this is happening because the tasks that have completed aren't releasing their connections upon completion?

   that said, i'm fairly new to asyncio to it's possible i'm doing something wrong. here's an example that throws a PoolTimeout:

   import asyncio
   import httpx
   
   
   async def main() -> None:
       url = "https://www.example.com"
       max_connections = 2
       timeout = httpx.Timeout(3.0, connect=5.0, pool=2.0)
       limits = httpx.Limits(max_connections=2)
       client = httpx.AsyncClient(timeout=timeout, pool_limits=limits)
   
       async with client:
           tasks = []
           for _ in range(max_connections + 1):
               tasks.append(client.get(url))
           await asyncio.gather(*tasks)
   
   if __name__ == "__main__":
       loop = asyncio.get_event_loop()
       try:
           loop.run_until_complete(main())
       finally:
           loop.close()
   

   👍React with 👍1Reacted by Dev Aggarwal