Struct LifespanScope 

pub struct LifespanScope<T: Send + Sync + 'static> {
    pub state: T,
    /* private fields */
}

Scope returned by a lifespan function containing state and cleanup logic.

The lifespan pattern allows sharing state between startup and shutdown phases, which is particularly useful for resources like database connections that need coordinated initialization and cleanup.

Example

use fastapi_core::app::{App, LifespanScope, LifespanError};

struct DatabasePool { /* ... */ }

impl DatabasePool {
    async fn connect(url: &str) -> Result<Self, Error> { /* ... */ }
    async fn close(&self) { /* ... */ }
}

let app = App::builder()
    .lifespan(|| async {
        // Startup: connect to database
        let pool = DatabasePool::connect("postgres://localhost/mydb")
            .await
            .map_err(|e| LifespanError::with_source("failed to connect to database", e))?;

        // Clone for the cleanup closure
        let pool_for_cleanup = pool.clone();

        // Return state + cleanup
        Ok(LifespanScope::new(pool)
            .on_shutdown(async move {
                pool_for_cleanup.close().await;
            }))
    })
    .build();

Fields

state: T

State produced by the lifespan function.

This state is automatically added to the application’s state container and can be accessed by handlers via the State<T> extractor.

Implementations

impl<T: Send + Sync + 'static> LifespanScope<T>

pub fn new(state: T) -> Self

Creates a new lifespan scope with the given state.

The state will be added to the application’s state container after successful startup, accessible via the State<T> extractor.

Example

let scope = LifespanScope::new(MyState { value: 42 });

pub fn on_shutdown<F>(self, cleanup: F) -> Self

where F: Future<Output = ()> + Send + 'static,

Sets the cleanup future to run during application shutdown.

The cleanup runs in reverse order relative to other lifespan/shutdown hooks, after all in-flight requests have completed or been cancelled.

Example

let scope = LifespanScope::new(pool.clone())
    .on_shutdown(async move {
        pool.close().await;
        println!("Database pool closed");
    });

pub fn take_cleanup( &mut self, ) -> Option<Pin<Box<dyn Future<Output = ()> + Send>>>

Takes the cleanup future, leaving None in its place.

This is used internally to transfer the cleanup to the shutdown system.

Trait Implementations

impl<T: Send + Sync + Debug + 'static> Debug for LifespanScope<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.