Trait IHostedService 

pub trait IHostedService: Send + Sync {
    // Required method
    fn start<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;

    // Provided method
    fn stop<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
}

Background service that is started when the host starts and stopped when the host performs a graceful shutdown.

Analogous to ASP.NET Core’s IHostedService.

Use this for:

• Data initialization / seeding at application startup
• Background polling loops
• Queue consumers
• Connection pool warmup

Example

#[derive(Default)]
struct DbInitService;

#[async_trait]
impl IHostedService for DbInitService {
    async fn start(&self) -> Result<()> {
        tracing::info!("[DbInitService] Running migrations...");
        run_migrations().await?;
        tracing::info!("[DbInitService] Seeding data...");
        seed_data().await?;
        Ok(())
    }

    async fn stop(&self) -> Result<()> {
        tracing::info!("[DbInitService] Shutting down...");
        Ok(())
    }
}

Required Methods

fn start<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Called when the host starts.

Services start in registration order and the host waits for all of them before accepting requests. There is no ambient DI context: a hosted service that needs scoped dependencies (DbContext, transactions, …) takes rust-dix’s built-in #[inject] services: Arc<dyn ScopeFactory> field and opens its own scope (let scope = services.create_scope();), disposed with the scope. If one start() fails, the services that already started are stopped again in reverse order before the host reports the error.

Provided Methods

fn stop<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Called during a graceful shutdown.

The host stops the services that started, in reverse start order (the last dependency to start is the first to stop), with a timeout per service so one stuck service cannot block the process forever. Like start(), each stop() runs inside a fresh DI scope.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors