use crate::client::WorkerApiClient;
use crate::config::WorkerConfig;
use crate::error::ConfigError;
use crate::poller::WorkerPoller;
use crate::registry::{ActivityExecutor, ActivityImpl, ActivityRegistry, TypedActivity};
use crate::result::ActivityResult;
use crate::{ActivityContext, ActivityError};
use serde::de::DeserializeOwned;
use std::future::Future;
use std::sync::Arc;
use tokio_util::sync::CancellationToken;
pub struct Worker {
poller: WorkerPoller,
shutdown: CancellationToken,
}
#[derive(Clone)]
pub struct WorkerHandle {
token: CancellationToken,
}
impl WorkerHandle {
pub fn shutdown(&self) {
self.token.cancel();
}
}
impl Worker {
pub fn builder() -> WorkerBuilder {
WorkerBuilder {
config: None,
worker: None,
registry: ActivityRegistry::new(),
deferred: Vec::new(),
executor: None,
}
}
pub fn handle(&self) -> WorkerHandle {
WorkerHandle {
token: self.shutdown.clone(),
}
}
pub async fn run(&self) {
self.poller.run().await;
}
pub async fn run_until_shutdown(&self) {
let token = self.shutdown.clone();
tokio::spawn(async move {
shutdown_signal().await;
tracing::info!("Shutdown signal received");
token.cancel();
});
self.run().await;
}
}
async fn shutdown_signal() {
#[cfg(unix)]
{
let mut sigterm = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
.expect("failed to install SIGTERM handler");
tokio::select! {
_ = tokio::signal::ctrl_c() => {}
_ = sigterm.recv() => {}
}
}
#[cfg(not(unix))]
{
let _ = tokio::signal::ctrl_c().await;
}
}
type DeferredRegistration = Box<dyn FnOnce(&mut ActivityRegistry, &str)>;
pub struct WorkerBuilder {
config: Option<WorkerConfig>,
worker: Option<String>,
registry: ActivityRegistry,
deferred: Vec<(String, DeferredRegistration)>,
executor: Option<Arc<dyn ActivityExecutor>>,
}
impl WorkerBuilder {
pub fn config(mut self, config: WorkerConfig) -> Self {
self.config = Some(config);
self
}
pub fn worker(mut self, worker: impl Into<String>) -> Self {
self.worker = Some(worker.into());
self
}
pub fn register(mut self, activity: impl ActivityImpl + 'static) -> Self {
self.registry.register(Arc::new(activity));
self
}
pub fn register_typed(mut self, activity: impl TypedActivity + 'static) -> Self {
self.registry.register_typed(activity);
self
}
pub fn register_fn<P, F, Fut>(mut self, name: impl Into<String>, handler: F) -> Self
where
P: DeserializeOwned + Send + 'static,
F: Fn(P, ActivityContext) -> Fut + Send + Sync + 'static,
Fut: Future<Output = Result<ActivityResult, ActivityError>> + Send + 'static,
{
let name = name.into();
self.deferred.push((
name.clone(),
Box::new(move |registry, worker| registry.register_fn(worker, name, handler)),
));
self
}
pub fn executor(mut self, executor: Arc<dyn ActivityExecutor>) -> Self {
self.executor = Some(executor);
self
}
pub fn build(mut self) -> Result<Worker, ConfigError> {
let mut config = match self.config.take() {
Some(config) => config,
None => WorkerConfig::from_env()?,
};
if let Some(worker) = self.worker {
config.worker = worker;
}
if config.worker.is_empty() {
let mut names = self.registry.worker_names();
match names.len() {
0 => return Err(ConfigError::MissingWorker),
1 => config.worker = names.remove(0),
_ => return Err(ConfigError::AmbiguousWorker(names)),
}
}
let mut registry = self.registry;
for (name, register) in self.deferred {
tracing::debug!(worker = %config.worker, name, "Registering deferred activity");
register(&mut registry, &config.worker);
}
let executor: Arc<dyn ActivityExecutor> = match self.executor {
Some(executor) => executor,
None => Arc::new(registry),
};
let client = match (&config.client_id, &config.client_secret) {
(Some(id), Some(secret)) => {
WorkerApiClient::with_credentials(&config.api_url, id, secret)
}
_ => WorkerApiClient::new(&config.api_url),
};
let poller = WorkerPoller::new(config, client, executor);
let shutdown = poller.shutdown_token();
Ok(Worker { poller, shutdown })
}
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::{Value, json};
fn base_config() -> WorkerConfig {
WorkerConfig {
api_url: "http://localhost:8080".to_string(),
..WorkerConfig::default()
}
}
#[test]
fn build_infers_worker_from_registrations() {
let worker = Worker::builder()
.config(base_config())
.register_fn("echo", |params: Value, _ctx| async move {
Ok(ActivityResult::value("echoed", params))
})
.worker("demo")
.build()
.unwrap();
drop(worker);
}
#[test]
fn build_without_worker_name_fails() {
let result = Worker::builder()
.config(base_config())
.register_fn("echo", |params: Value, _ctx| async move {
Ok(ActivityResult::value("echoed", params))
})
.build();
assert!(matches!(result.err(), Some(ConfigError::MissingWorker)));
}
#[test]
fn build_infers_single_worker_from_trait_impls() {
struct Act;
#[async_trait::async_trait]
impl ActivityImpl for Act {
async fn execute(
&self,
_parameters: Value,
_ctx: &ActivityContext,
) -> Result<ActivityResult, ActivityError> {
Ok(ActivityResult::value("ok", json!(true)))
}
fn name(&self) -> &str {
"act"
}
fn worker(&self) -> &str {
"inferred"
}
}
let worker = Worker::builder()
.config(base_config())
.register(Act)
.build()
.unwrap();
drop(worker);
}
#[tokio::test]
async fn handle_shutdown_stops_run() {
let worker = Worker::builder()
.config(base_config())
.worker("demo")
.register_fn("echo", |params: Value, _ctx| async move {
Ok(ActivityResult::value("echoed", params))
})
.build()
.unwrap();
worker.handle().shutdown();
tokio::time::timeout(std::time::Duration::from_secs(5), worker.run())
.await
.expect("run() should return after shutdown");
}
}