Background services

HTTP host’un yönettiği worker’ları başlatın ve her iş için ayrı DI scope açın.

add_background_service ile kayıtlı işler uygulamanın yaşam döngüsüne dahildir. Bir iş biriminin Scoped servisleri varsa her çalıştırmada yeni scope oluşturun.

Worker tanımlama#

lilyrs için http-api feature’ı hem worker sözleşmesini hem DI tiplerini sunar. Ayrıca tokio (macros, rt-multi-thread, time) gerekir:

use std::{sync::Arc, time::Duration};
use lilyrs::http_api::{
    ApplicationScopeFactory, BackgroundServiceTrait, ExecutionCancellation,
    InjectionError, ProcessContext, ServiceTrait,
};
use lilyrs::http_api::Injectable;

#[derive(Injectable)]
#[service(lifetime = "Scoped")]
struct JobService;
impl ServiceTrait for JobService {}

impl JobService {
    async fn tick(&self, stopping: ExecutionCancellation) -> Result<(), InjectionError> {
        if stopping.is_cancelled() { return Ok(()); }
        Ok(()) // Uygulamanın bir iş birimi burada çalışır.
    }
}

pub struct PollingWorker { scopes: Arc<ApplicationScopeFactory> }

#[lilyrs::http_api::async_trait::async_trait]
impl BackgroundServiceTrait for PollingWorker {
    type Error = InjectionError;

    async fn new(scopes: Arc<ApplicationScopeFactory>) -> Result<Self, Self::Error> {
        Ok(Self { scopes })
    }

    async fn execute_async(&mut self, stopping: ExecutionCancellation) -> Result<(), Self::Error> {
        while !stopping.is_cancelled() {
            let cancellation = stopping.clone();
            self.scopes.create_scope(ProcessContext::new())?
                .run(move |extensions| Box::pin(async move {
                    let job = extensions.get_service::<JobService>(None).await?;
                    job.tick(cancellation).await
                })).await?;
            tokio::select! {
                _ = stopping.cancelled() => break,
                _ = tokio::time::sleep(Duration::from_secs(1)) => {}
            }
        }
        Ok(())
    }
}

tick burada iş biriminin yerini gösterir; gerçek polling veya işleme kodu uygulamanızdadır. Scope run sonucu await edilir. Scoped servis sonraki tick’e veya detached task’a taşınmaz.

Host’a kayıt#

Builder zincirine .add_background_service::<PollingWorker>() ekleyin. Worker’ın kendisi Injectable olmak zorunda değildir. Aynı worker türünün tekrar kaydı deduplicate edilir.

Çalışma zamanı#

new build sırasında, execute_async başarılı listener bind sonrasında bir kez çalışır. Normal Ok(()) host’u kapatmaz. Yakalanmamış hata veya panic host shutdown’ını başlatır.

Otomatik retry, restart, cron veya distributed leader seçimi bu API’nin sözleşmesi değildir. Gerekli iş politikasını worker’ın içinde açıkça kurun.

Kapanış#

Worker’ın stopping görünümü host kapanışına aittir; normal request cancellation’ından farklıdır. Döngü sinyali gözlemleyip işini sonlandırmalıdır. Uygulamanın kendi tokio::spawn çağrıları bu kayıtlı worker yaşam döngüsüne kendiliğinden eklenmez.