317 lines
12 KiB
Rust
317 lines
12 KiB
Rust
use std::sync::Arc;
|
|
|
|
use application::{
|
|
MovieDiscoveryIndexer, SearchCleanupHandler, SearchReindexHandler, worker::WorkerService,
|
|
};
|
|
use domain::ports::{EventHandler, MovieEnrichmentClient, PeriodicJob, PersonEnrichmentClient};
|
|
use domain::value_objects::InstanceIdentity;
|
|
|
|
use crate::database::{self, DatabaseOutput};
|
|
use crate::event_bus;
|
|
use crate::outbox_relay::OutboxRelay;
|
|
use tokio::sync::watch;
|
|
|
|
pub struct WorkerApp {
|
|
service: WorkerService,
|
|
/// Present when the bus is external: drains the outbox into it.
|
|
relay: Option<OutboxRelay>,
|
|
}
|
|
|
|
impl WorkerApp {
|
|
/// Names of the registered event handlers, in registration order.
|
|
pub fn handler_names(&self) -> Vec<&'static str> {
|
|
self.service.handler_names()
|
|
}
|
|
|
|
/// Runs the handlers and, when there is one, the outbox relay, until
|
|
/// `shutdown` fires. Both stop together and finish their in-flight work.
|
|
///
|
|
/// If the relay stops or panics on its own, the worker stops too and
|
|
/// returns an error so the process exits non-zero and the supervisor
|
|
/// restarts it: a worker that keeps handling events but no longer
|
|
/// delivers the outbox would fail silently.
|
|
pub async fn run(self, mut shutdown: watch::Receiver<bool>) -> anyhow::Result<()> {
|
|
let (stop_tx, stop_rx) = watch::channel(false);
|
|
let mut relay = self.relay.map(|r| tokio::spawn(r.run(stop_rx.clone())));
|
|
let service = self.service.run(stop_rx);
|
|
tokio::pin!(service);
|
|
|
|
let mut stopping = false;
|
|
let mut relay_failure = None;
|
|
loop {
|
|
tokio::select! {
|
|
_ = &mut service => break,
|
|
_ = shutdown.changed(), if !stopping => {
|
|
stopping = true;
|
|
let _ = stop_tx.send(true);
|
|
}
|
|
result = async { relay.as_mut().expect("guarded").await }, if relay.is_some() => {
|
|
relay = None;
|
|
if !stopping {
|
|
relay_failure = Some(match result {
|
|
Ok(()) => "outbox relay stopped unexpectedly".to_owned(),
|
|
Err(e) => format!("outbox relay died: {e}"),
|
|
});
|
|
stopping = true;
|
|
let _ = stop_tx.send(true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let _ = stop_tx.send(true);
|
|
if let Some(handle) = relay
|
|
&& let Err(e) = handle.await
|
|
{
|
|
relay_failure.get_or_insert(format!("outbox relay died: {e}"));
|
|
}
|
|
match relay_failure {
|
|
Some(message) => {
|
|
tracing::error!("{message}");
|
|
Err(anyhow::anyhow!(message))
|
|
}
|
|
None => Ok(()),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Wires the background worker: event handlers, periodic jobs (already
|
|
/// spawned) and the consumer. Run it with `service.run(shutdown)`.
|
|
pub async fn build_worker(config: &config::AppConfig) -> anyhow::Result<WorkerApp> {
|
|
database::warn_if_database_backend_set();
|
|
let instance = InstanceIdentity::new(config.server.base_url.clone());
|
|
let db = database::build_database_adapters(&config.database.url, &instance).await?;
|
|
assemble(config, db, instance).await
|
|
}
|
|
|
|
/// Builds the same worker as [`build_worker`] on a caller-provided pool.
|
|
/// Migrations run on it exactly as they do for the normal path.
|
|
pub async fn build_worker_on(
|
|
config: &config::AppConfig,
|
|
pool: sqlx::SqlitePool,
|
|
) -> anyhow::Result<WorkerApp> {
|
|
let instance = InstanceIdentity::new(config.server.base_url.clone());
|
|
let db = database::build_database_adapters_on(pool, &instance).await?;
|
|
assemble(config, db, instance).await
|
|
}
|
|
|
|
async fn assemble(
|
|
config: &config::AppConfig,
|
|
db: DatabaseOutput,
|
|
#[cfg_attr(not(feature = "federation"), allow(unused_variables))] instance: InstanceIdentity,
|
|
) -> anyhow::Result<WorkerApp> {
|
|
let metadata_client = metadata::create(&config.metadata)?;
|
|
let poster_fetcher = poster_fetcher::create(&config.metadata)?;
|
|
let object_storage = object_storage::create(&config.storage)?;
|
|
|
|
// TMDb client detection happens before `build_worker_deps` so the optional
|
|
// person-enrichment port can be handed to `WorkerServices` up front.
|
|
let tmdb_client = match tmdb_enrichment::TmdbEnrichmentClient::from_config(&config.metadata) {
|
|
Ok(client) => {
|
|
tracing::info!("TMDb enrichment enabled");
|
|
Some(Arc::new(client))
|
|
}
|
|
Err(e) => {
|
|
tracing::warn!("TMDb enrichment disabled: {e}");
|
|
None
|
|
}
|
|
};
|
|
let person_enrichment: Option<Arc<dyn PersonEnrichmentClient>> = tmdb_client
|
|
.clone()
|
|
.map(|c| c as Arc<dyn PersonEnrichmentClient>);
|
|
|
|
let (event_publisher_arc, consumer_arc, relay) =
|
|
event_bus::create_channel(&db.db_pool, config).await?;
|
|
|
|
let worker_services = application::WorkerServices {
|
|
object_storage: Arc::clone(&object_storage),
|
|
event_publisher: Arc::clone(&event_publisher_arc),
|
|
person_enrichment,
|
|
};
|
|
let worker_deps = crate::build::build_worker_deps(&db, &worker_services);
|
|
|
|
let image_ref_command = Arc::clone(&db.image_ref_command);
|
|
let image_ref_query = Arc::clone(&db.image_ref_query);
|
|
|
|
#[cfg(feature = "federation")]
|
|
let federation_handlers =
|
|
crate::federation::wire_worker_handlers(&db, &instance, config, &event_publisher_arc)
|
|
.await?;
|
|
|
|
let movie_command = db.movie_command;
|
|
let movie_query = db.movie_query;
|
|
let user = db.user;
|
|
let import_session = db.import_session;
|
|
let movie_profile = db.movie_profile;
|
|
let watch_event_command = db.watch_event_command;
|
|
let person_query = db.person_query;
|
|
let search_command = db.search_command;
|
|
let wrapup_repo = db.wrapup_repo;
|
|
let refresh_session = db.refresh_session;
|
|
let processed_events = db.processed_events;
|
|
|
|
let event_publisher = event_publisher_arc;
|
|
let metadata = metadata_client;
|
|
|
|
// ── Enrichment ────────────────────────────────────────────────────────────
|
|
// Both the event handler and the staleness job are gated on TMDB_API_KEY.
|
|
// Without a key, no MovieEnrichmentRequested events are produced or handled.
|
|
|
|
type EnrichmentParts = (
|
|
Option<Arc<dyn EventHandler>>,
|
|
Option<Arc<dyn EventHandler>>,
|
|
Option<Arc<dyn PeriodicJob>>,
|
|
);
|
|
let (enrichment_handler, person_enrichment_handler, enrichment_job): EnrichmentParts =
|
|
match tmdb_client {
|
|
Some(client) => {
|
|
let image_fetcher = poster_fetcher::create_image_fetcher(&config.metadata)?;
|
|
let handler = Arc::new(application::movies::MovieEnrichmentHandler::new(
|
|
Arc::clone(&client) as Arc<dyn MovieEnrichmentClient>,
|
|
worker_deps.enrich_movie.movie_query.clone(),
|
|
worker_deps.enrich_movie.movie_profile.clone(),
|
|
worker_deps.enrich_movie.person_command.clone(),
|
|
worker_deps.enrich_movie.search_command.clone(),
|
|
Arc::clone(&object_storage),
|
|
image_fetcher,
|
|
)) as Arc<dyn EventHandler>;
|
|
let person_handler = Arc::new(application::person::PersonEnrichmentHandler::new(
|
|
worker_deps.enrich_person.person_query.clone(),
|
|
worker_deps.enrich_person.person_enrichment.clone(),
|
|
worker_deps.enrich_person.person_command.clone(),
|
|
)) as Arc<dyn EventHandler>;
|
|
let job = Arc::new(application::jobs::EnrichmentStalenessJob::new(
|
|
Arc::clone(&movie_profile),
|
|
Arc::clone(&event_publisher),
|
|
)) as Arc<dyn PeriodicJob>;
|
|
(Some(handler), Some(person_handler), Some(job))
|
|
}
|
|
None => (None, None, None),
|
|
};
|
|
|
|
// ── Image conversion ──────────────────────────────────────────────────────
|
|
|
|
let conversion = image_converter::build(
|
|
&config.image_conversion,
|
|
Arc::clone(&object_storage),
|
|
image_ref_command,
|
|
image_ref_query,
|
|
Arc::clone(&event_publisher),
|
|
)?;
|
|
|
|
// ── Periodic jobs ─────────────────────────────────────────────────────────
|
|
|
|
let mut periodic_jobs: Vec<Arc<dyn PeriodicJob>> = vec![
|
|
Arc::new(application::jobs::MovieDeduplicationJob::new(
|
|
worker_deps.merge_duplicates.movie_query.clone(),
|
|
worker_deps.merge_duplicates.deduplicator.clone(),
|
|
worker_deps.merge_duplicates.object_storage.clone(),
|
|
)),
|
|
Arc::new(application::jobs::ImportSessionCleanupJob::new(
|
|
import_session.clone(),
|
|
)),
|
|
Arc::new(application::jobs::WatchEventCleanupJob::new(
|
|
watch_event_command.clone(),
|
|
)),
|
|
Arc::new(application::jobs::WrapUpAutoGenerateJob::new(
|
|
Arc::clone(&user),
|
|
Arc::clone(&wrapup_repo),
|
|
Arc::clone(&event_publisher),
|
|
)),
|
|
Arc::new(application::jobs::WrapUpCleanupJob::new(Arc::clone(
|
|
&wrapup_repo,
|
|
))),
|
|
Arc::new(application::jobs::RefreshSessionCleanupJob::new(
|
|
Arc::clone(&refresh_session),
|
|
)),
|
|
Arc::new(application::jobs::ProcessedEventsCleanupJob::new(
|
|
Arc::clone(&processed_events),
|
|
)),
|
|
];
|
|
if let Some(job) = enrichment_job {
|
|
periodic_jobs.push(job);
|
|
}
|
|
if let Some((_, ref conv_job)) = conversion {
|
|
periodic_jobs.push(Arc::clone(conv_job));
|
|
}
|
|
|
|
for job in periodic_jobs {
|
|
tokio::spawn(async move {
|
|
let mut tick = tokio::time::interval(job.interval());
|
|
loop {
|
|
tick.tick().await;
|
|
if let Err(e) = job.run().await {
|
|
tracing::error!("periodic job failed: {e}");
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
// ── Event handlers ────────────────────────────────────────────────────────
|
|
|
|
let handlers: Vec<Arc<dyn EventHandler>> = {
|
|
let poster = Arc::new(
|
|
application::movies::poster_sync_handler::PosterSyncHandler::new(
|
|
Arc::clone(&movie_command),
|
|
Arc::clone(&movie_query),
|
|
Arc::clone(&metadata),
|
|
Arc::clone(&poster_fetcher),
|
|
Arc::clone(&object_storage),
|
|
Arc::clone(&event_publisher),
|
|
3,
|
|
),
|
|
) as Arc<dyn EventHandler>;
|
|
|
|
let cleanup = Arc::new(object_storage::ImageCleanupHandler::new(Arc::clone(
|
|
&object_storage,
|
|
))) as Arc<dyn EventHandler>;
|
|
|
|
let search_cleanup = Arc::new(SearchCleanupHandler::new(
|
|
Arc::clone(&search_command),
|
|
Arc::clone(&person_query),
|
|
)) as Arc<dyn EventHandler>;
|
|
|
|
let discovery_indexer = Arc::new(MovieDiscoveryIndexer::new(
|
|
Arc::clone(&movie_query),
|
|
Arc::clone(&search_command),
|
|
)) as Arc<dyn EventHandler>;
|
|
|
|
let wrapup_handler = Arc::new(application::wrapup::event_handler::WrapUpEventHandler::new(
|
|
worker_deps.handle_requested.wrapup_repo.clone(),
|
|
worker_deps.handle_requested.event_publisher.clone(),
|
|
worker_deps.handle_requested.wrapup_stats.clone(),
|
|
)) as Arc<dyn EventHandler>;
|
|
|
|
let reindex_handler = Arc::new(SearchReindexHandler::new(worker_deps.reindex_search))
|
|
as Arc<dyn EventHandler>;
|
|
|
|
let mut h = vec![
|
|
poster,
|
|
cleanup,
|
|
search_cleanup,
|
|
discovery_indexer,
|
|
wrapup_handler,
|
|
reindex_handler,
|
|
];
|
|
|
|
#[cfg(feature = "federation")]
|
|
h.extend(federation_handlers);
|
|
|
|
if let Some(e) = enrichment_handler {
|
|
h.push(e);
|
|
}
|
|
if let Some(e) = person_enrichment_handler {
|
|
h.push(e);
|
|
}
|
|
if let Some((ref conv_handler, _)) = conversion {
|
|
h.push(Arc::clone(conv_handler));
|
|
}
|
|
|
|
h
|
|
};
|
|
|
|
Ok(WorkerApp {
|
|
service: WorkerService::new(consumer_arc, handlers, processed_events)?,
|
|
relay,
|
|
})
|
|
}
|