httpx requests cancelling outer tasks

[Booplicate]

import asyncio

import httpx


async def ping():
    async with httpx.AsyncClient(timeout=1.0) as client:
        try:
            url = "http://httpbin.org/get"
            resp = await client.get(url)

        except Exception as e:
            print(repr(e))

        else:
            print(resp.status_code)

async def loop():
    while True:
        await asyncio.sleep(3)
        await ping()

async def spawn_task():
    task = asyncio.create_task(loop())
    while True:
        await asyncio.sleep(3)
        print("is cancelling: ", task.cancelling())
        print("state: ", task._state)


asyncio.run(spawn_task())

The code above will print something like:

is cancelling:  0
state:  PENDING
200
is cancelling:  1
state:  PENDING
200
is cancelling:  2
state:  PENDING
200
is cancelling:  3
state:  PENDING
200
is cancelling:  4
state:  PENDING
200
is cancelling:  5
state:  PENDING

Somehow httpx increases the number of cancellation requests to the task it doesn't own.
This only happens if I use httpx in ping.

1. if I change the url say url = "http://localhost:8088" (I have nothing on that port listening), I'll get a timeout error, but in that case httpx won't attempt to cancel my task
2. if I remove the timeout, I'll get ConnectError, but again httpx won't try to cancel. It only happens on "successful" requests.
3. I tried to use a few other corotines from ping instead of httpx functions, they didn't cause that effect either
4. somehow wrapping ping in shield prevents this from happening (await asyncio.shield(ping())), but that's not the correct usage of shield and I have no idea why it works the way it works, shield should prevent the inner task from being cancelled, not the outer?

This doesn't cause a direct issue (so far), but I find it strange that httpx tries to cancel an outer task when there's no CancelledError. I was trying to monitor my tasks and saw that some of them were marked as "awaiting cancellation" while I didn't expect them to be cancelled at all.

[tomchristie]

I can isolate this down further...

import asyncio

import httpcore


origin = httpcore.URL("http://www.example.com").origin

async def ping():
    async with httpcore.AsyncHTTPConnection(origin) as connection:
        try:
            url = "http://www.example.com"
            resp = await connection.request("GET", url)

        except Exception as e:
            print(repr(e))

        else:
            print(resp.status)

async def loop():
    while True:
        await asyncio.sleep(3)
        await ping()

async def spawn_task():
    task = asyncio.create_task(loop())
    while True:
        await asyncio.sleep(3)
        print("is cancelling: ", task.cancelling())
        print("is done: ", task.done())
        print("state: ", task._state)


asyncio.run(spawn_task())

I don't know what that's about, or how to figure out if that's an httpcore bug or an asyncio bug...

Is there a way to inspect where in the stacktrace those cancellations are?

[Booplicate]

Good call about stacktrace, I was able to override and add logging:

import asyncio

import httpcore


origin = httpcore.URL("http://www.example.com").origin

async def ping():
    async with httpcore.AsyncHTTPConnection(origin) as connection:
        try:
            url = "http://www.example.com"
            resp = await connection.request("GET", url)

        except Exception as e:
            print(repr(e))

        else:
            print(resp.status)

async def loop():
    while True:
        await asyncio.sleep(3)
        await ping()


async def spawn_task():
    task = asyncio.create_task(loop(), name="loop task")

    og_cancel = task.cancel
    def new_cancel(msg = None):
        import traceback
        traceback.print_stack()
        print(msg)
        return og_cancel(msg)

    task.cancel = new_cancel

    while True:
        await asyncio.sleep(3)
        print("is cancelling: ", task.cancelling())
        print("is done: ", task.done())
        print("state: ", task._state)


asyncio.run(spawn_task())

Getting Cancelled by cancel scope ... from anyio._backends._asyncio._deliver_cancellation line 493. It looks like the problem is in anyio, not httpx.

[Booplicate]

Not sure how to make a reproducible example with just anyio though, I never used it myself, and there's no stacktrace from httpcore to indicate how we get there...

[tomchristie]

Here's how to replicate it with just anyio...

import anyio

async def loop():
    while True:
        stream = await anyio.connect_tcp('www.example.com', 80)
        # await stream.aclose()
        await asyncio.sleep(1)

async def spawn_task():
    task = asyncio.create_task(loop())
    while True:
        await asyncio.sleep(1)
        print("cancelling: ", task.cancelling())

asyncio.run(spawn_task())

I'm unclear if that's an anyio bug or an asyncio bug. Either way I'd guess it's related to the DNS resolution. (?)

Here's where we're using anyio as the default async network backend... https://github.com/encode/httpcore/blob/1851ac30900a38a9cef4e56975f40267352c6012/httpcore/_backends/anyio.py#L114-L123

(We could be using asyncio directly... back in this release we switched to anyio as the default instead of using asyncio directly. It's feasible that the issues we bumped into at the time have now been resolved in core python)

[Booplicate]

It doesn't appear to be a DNS problem as far as I can tell, I tried to connect using a direct IP to my local server, anyio is still cancelling on a successful connection.
I opened an issue in anyio repo.