FastAPI: 测试lifespan特性（转）

标签：resource FastAPI app lifespan yield 测试 async

add by zhj：实践出真知，文章写得真不错，自己测试这些条件

Init

In FastAPI, one of ways creating a shared resource and living as long as application is up is using lifespan feature in FastAPI.

This lifespan feature can do

creating resources before App starts getting requests.
cleaning up resources when App is terminating

The feature used to be supported with startup/shutdown, but it has been deprecated.

Why startup/shutdown is deprecated?

In FastAPI, the startup and shutdown are two different functions. As you know, the shutdown function is used to clean up ( OR free up the resources ). To do that, some instances have to be kept in Global area.

The lifespan feature ( new ) tries to simplify ( OR remove ) those unencessity keeping them in Global area by utilizing “contextmanager”.

I’d like to try how it works today.

Start: Base Code

Here is the starting code. It uses “asynccontextmanager” in contextlib.

from contextlib import asynccontextmanager

from fastapi import FastAPI, Request

resource = {}

@asynccontextmanager
async def app_lifespan(app: FastAPI):
    print("init lifespan")
    resource["msg"] = "Hello, it's beautiful day!!"
    yield
    resource.clear()
    print("clean up lifespan")

app = FastAPI(lifespan=app_lifespan)

@app.get("/", include_in_schema=False)
async def root(request: Request):
    resource["msg"]

print("completed app init.")

Loading Application

The interesting thing was that the execution of the code wasn’t blocking code. The message “completed app int” is printed before the “init lifespan”.
And, one obvious thing was that “clean up lifespan” wasn’t printed when application is loaded. ( coroutine ).

Experiment 1: can contextmanager be used?

I got curious if `contextmanager` instead of `asynccontextmanager` can be used for the lifespan function.

So, I tried it. And, I got an error.

( maybe using sync contextmanager for async function didn’t make a sense from the beggining )

The error is from Starlette that FastAPI depends on.

Based on the code, the lifespan has to be wrapped ( or supported ) with async context manager. ( required )

Experiment 2: Is app positional argument required for lifespan function?

Here is the base code. I got curious if the app argument is required.

So, I tried after removing the app argument from the app_lifespan function.

@asynccontextmanager
async def app_lifespan(app: FastAPI):
    print("init lifespan")
    resource["msg"] = "Hello, it's beautiful day!!"
    yield
    resource.clear()
    print("clean up lifespan")

And, I got this error. The error came from the same code that I looked into when I tried contextmanager instead asynccontextmanager .

Basically, the Starlette lifespan implementation that FastAPI uses requires

asynccontextmanager
taking a positional argument

async with self.lifespan_context(app) as maybe_state:

Experiment 3: Does lifespan has to be set to FastAPI?

The `def app_lifespan` is assigned ( or set ) to FastAPI in the base code like below.

app = FastAPI(lifespan=app_lifespan)

What if the `app_lifespan` is not assigned into FastAPI during the initialization, will the lifespan be executed?

Well, based on the code I saw in previous experimentations, I can say that it won’t work. And, the below result confirmed that.

Experiment 4: Is `yield` required in lifespan?

What if `yield` is removed? Does it still work?

Is the `yield` required in the lifespan?

@asynccontextmanager
async def app_lifespan(app: FastAPI):
    print("init lifespan")
    resource["msg"] = "Hello, it's beautiful day!!"
    # yield
    resource.clear()
    print("clean up lifespan")

Yes. The `yield` is required. It’s because the lifespan uses async function + asynccontextmanger. It needs `yield`

Experiment 5: what if lifespan is implemented as sync function?

What if the lifspan is implemented fully as sync function like below?

@contextmanager
def app_lifespan(app: FastAPI):
    print("init lifespan")
    resource["msg"] = "Hello, it's beautiful day!!"
    # yield
    resource.clear()
    print("clean up lifespan")

As seen in the previous experimentations, since the Starlette uses ( or expect ) asynccontextmanger, it doesn’t work.

Summary

Basically, the lifespan feature requires

async implemented function
yield has to be set in the function
asynccontextmanager has to be used
async implemented function lifespan has to be set to FastAPI

Here is the final format how FastAPI lifespan has to be implemented.

@asynccontextmanager
async def app_lifespan(app: FastAPI):
    # code to execute when app is loading
    yield
    # code to execute when app is shutting down

app = FastAPI(lifespan=app_lifespan)

标签：resource,FastAPI,app,lifespan,yield,测试,async
From： https://www.cnblogs.com/ajianbeyourself/p/18132009