background worker

crates/presentation/src/event_handlers.rs

@@ -1,61 +0,0 @@
-use std::time::Duration;
-
-use application::{commands::SyncPosterCommand, context::AppContext, use_cases::sync_poster};
-use async_trait::async_trait;
-use domain::ports::EventHandler;
-use domain::{errors::DomainError, events::DomainEvent};
-
-pub struct PosterSyncHandler {
-    ctx: AppContext,
-    max_retries: u32,
-}
-
-impl PosterSyncHandler {
-    pub fn new(ctx: AppContext, max_retries: u32) -> Self {
-        Self { ctx, max_retries }
-    }
-}
-
-#[async_trait]
-impl EventHandler for PosterSyncHandler {
-    async fn handle(&self, event: &DomainEvent) -> Result<(), DomainError> {
-        let (movie_id, external_metadata_id) = match event {
-            DomainEvent::MovieDiscovered {
-                movie_id,
-                external_metadata_id,
-            } => (movie_id.value(), external_metadata_id.value().to_owned()),
-            _ => return Ok(()),
-        };
-
-        let mut last_err: Option<DomainError> = None;
-        for attempt in 0..=self.max_retries {
-            let cmd = SyncPosterCommand {
-                movie_id,
-                external_metadata_id: external_metadata_id.clone(),
-            };
-            match sync_poster::execute(&self.ctx, cmd).await {
-                Ok(()) => return Ok(()),
-                Err(e) => {
-                    if attempt < self.max_retries {
-                        let delay = Duration::from_secs(2u64.pow(attempt));
-                        tracing::warn!(
-                            attempt = attempt + 1,
-                            max_attempts = self.max_retries + 1,
-                            delay_secs = delay.as_secs(),
-                            "poster sync failed, retrying: {e}"
-                        );
-                        tokio::time::sleep(delay).await;
-                    }
-                    last_err = Some(e);
-                }
-            }
-        }
-
-        let err = last_err.expect("loop runs at least once and always sets last_err on Err");
-        tracing::error!(
-            attempts = self.max_retries + 1,
-            "poster sync failed after all attempts: {err}"
-        );
-        Err(err)
-    }
-}

crates/presentation/src/lib.rs

@@ -1,7 +1,6 @@
 pub mod csrf;
 pub mod dtos;
 pub mod errors;
-pub mod event_handlers;
 pub mod extractors;
 pub mod handlers;
 pub mod openapi;

crates/presentation/src/main.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use anyhow::Context;
 use event_publisher::{EventPublisherConfig, NoopEventPublisher, create_event_channel};
-use presentation::event_handlers::PosterSyncHandler;
+use application::event_handlers::PosterSyncHandler;
 use std::str::FromStr;
 
 use tokio::net::TcpListener;
@@ -24,7 +24,7 @@ use activitypub::{
     ReviewObjectHandler,
 };
 
-use application::{config::AppConfig, context::AppContext};
+use application::{config::AppConfig, context::AppContext, worker::WorkerService};
 use auth::{Argon2PasswordHasher, AuthConfig, JwtAuthService};
 use export::ExportAdapter;
 use metadata::MetadataClientImpl;
@@ -184,12 +184,13 @@ async fn wire_dependencies() -> anyhow::Result<(AppState, axum::Router)> {
         );
         let ap_service_arc: Arc<dyn ActivityPubPort> = concrete_ap_service;
 
-        let poster_handler = PosterSyncHandler::new(handler_ctx, 3);
-        let (event_publisher, event_worker) = create_event_channel(
-            EventPublisherConfig::from_env(),
-            vec![Box::new(poster_handler), Box::new(ap_event_handler)],
+        let poster_handler = Arc::new(PosterSyncHandler::new(handler_ctx, 3));
+        let (event_publisher, consumer) = create_event_channel(EventPublisherConfig::from_env());
+        let worker = WorkerService::new(
+            Arc::new(consumer),
+            vec![poster_handler, Arc::new(ap_event_handler)],
         );
-        tokio::spawn(event_worker.run());
+        tokio::spawn(worker.run());
 
         let ep: Arc<dyn domain::ports::EventPublisher> = Arc::new(event_publisher);
         (ep, ap_router, ap_service_arc, social_query_arc)
@@ -197,12 +198,10 @@ async fn wire_dependencies() -> anyhow::Result<(AppState, axum::Router)> {
 
     #[cfg(not(feature = "federation"))]
     let (event_publisher_arc, ap_router): (Arc<dyn domain::ports::EventPublisher>, axum::Router) = {
-        let poster_handler = PosterSyncHandler::new(handler_ctx, 3);
-        let (event_publisher, event_worker) = create_event_channel(
-            EventPublisherConfig::from_env(),
-            vec![Box::new(poster_handler)],
-        );
-        tokio::spawn(event_worker.run());
+        let poster_handler = Arc::new(PosterSyncHandler::new(handler_ctx, 3));
+        let (event_publisher, consumer) = create_event_channel(EventPublisherConfig::from_env());
+        let worker = WorkerService::new(Arc::new(consumer), vec![poster_handler]);
+        tokio::spawn(worker.run());
         (Arc::new(event_publisher), axum::Router::new())
     };