use std::sync::Arc;
use tokio::sync::oneshot;
use tracing::info;
use crate::configuration::Configuration;
use crate::error::Result;
use crate::events::TaskRunnerEventsListener;
use crate::metrics::MetricsSettings;
use super::{TaskHandler, Worker};
pub struct WorkerHost {
handler: TaskHandler,
shutdown_rx: Option<oneshot::Receiver<()>>,
}
impl WorkerHost {
#[must_use]
pub fn builder(config: Configuration) -> WorkerHostBuilder {
WorkerHostBuilder::new(config)
}
pub async fn wait_for_shutdown(mut self) -> Result<()> {
info!("Worker host running, press Ctrl+C to stop");
tokio::select! {
_ = tokio::signal::ctrl_c() => {
info!("Received shutdown signal");
}
() = async {
if let Some(rx) = self.shutdown_rx.take() {
let _ = rx.await;
} else {
std::future::pending::<()>().await;
}
} => {
info!("Received shutdown request");
}
}
self.handler.stop().await
}
pub async fn stop(mut self) -> Result<()> {
self.handler.stop().await
}
#[must_use]
pub fn handler(&self) -> &TaskHandler {
&self.handler
}
pub fn handler_mut(&mut self) -> &mut TaskHandler {
&mut self.handler
}
}
pub struct WorkerHostBuilder {
config: Configuration,
workers: Vec<Arc<dyn Worker>>,
event_listeners: Vec<Arc<dyn TaskRunnerEventsListener>>,
metrics_settings: Option<MetricsSettings>,
shutdown_rx: Option<oneshot::Receiver<()>>,
}
impl WorkerHostBuilder {
pub fn new(config: Configuration) -> Self {
Self {
config,
workers: Vec::new(),
event_listeners: Vec::new(),
metrics_settings: None,
shutdown_rx: None,
}
}
pub fn worker(mut self, worker: impl Worker + 'static) -> Self {
self.workers.push(Arc::new(worker));
self
}
pub fn workers(mut self, workers: impl IntoIterator<Item = Arc<dyn Worker>>) -> Self {
self.workers.extend(workers);
self
}
pub fn event_listener(mut self, listener: impl TaskRunnerEventsListener + 'static) -> Self {
self.event_listeners.push(Arc::new(listener));
self
}
pub fn with_metrics(mut self, settings: MetricsSettings) -> Self {
self.metrics_settings = Some(settings);
self
}
pub fn with_shutdown_channel(self) -> (Self, oneshot::Sender<()>) {
let (tx, rx) = oneshot::channel();
(
Self {
config: self.config,
workers: self.workers,
event_listeners: self.event_listeners,
metrics_settings: self.metrics_settings,
shutdown_rx: Some(rx),
},
tx,
)
}
pub async fn start(self) -> Result<WorkerHost> {
let mut handler = TaskHandler::new(self.config)?;
handler.add_workers(self.workers);
for listener in self.event_listeners {
handler.add_event_listener(listener);
}
if let Some(settings) = self.metrics_settings {
handler.enable_metrics(settings);
}
handler.start().await?;
let shutdown_rx = self.shutdown_rx.or_else(|| {
let (_tx, rx) = oneshot::channel();
Some(rx)
});
Ok(WorkerHost {
handler,
shutdown_rx,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::models::Task;
use crate::worker::{FnWorker, WorkerOutput};
#[tokio::test]
async fn test_worker_host_builder() {
let config = Configuration::new("http://localhost:8080/api");
let builder = WorkerHostBuilder::new(config)
.worker(FnWorker::new("test", |_: Task| async {
Ok(WorkerOutput::completed_with_result("test"))
}));
assert_eq!(builder.workers.len(), 1);
}
}