use std::{marker::PhantomData, str::FromStr, sync::Arc};
use actix_web::{
Error, HttpRequest, HttpResponse, Resource, Responder, Scope,
body::BoxBody,
dev::{Service as _, ServiceFactory, ServiceRequest, ServiceResponse},
guard,
http::{Method, header},
web::{self, Data, Json},
};
use apalis_core::backend::{
Backend, BackendExt, FetchById, Filter, ListAllTasks, ListQueues, ListTasks, ListWorkers,
Metrics, RegisterWorker, Reschedule, ResumeAbandoned, ResumeById, TaskSink, Update, Vacuum,
WaitForCompletion, codec::Codec, queue::Queue,
};
use serde::{Serialize, de::DeserializeOwned};
use tokio::sync::RwLock;
use crate::api::{
actions,
capability::{
LiveResult, RegisterLiveStatus, RegisterRegisterWorker, RegisterReschedule, RegisterResume,
RegisterResumeAbandoned, RegisterUpdate, RegisterVacuum, RescheduleHook, ResumeHook,
STATE_POISON, SharedState, UpdateHook, assert_queue_registered, csrf_token_ok,
validate_queue_name,
},
fetch_queues,
framework::{ApiBuilder, RegisterRoute},
get_all_tasks, get_all_workers, get_task_by_id, get_tasks, get_workers, overview, push_task,
stats_by_queue,
};
#[cfg(feature = "ui")]
use crate::api::ui::ServeUI;
fn csrf_ok(req: &HttpRequest) -> bool {
let cookie = req
.headers()
.get(header::COOKIE)
.and_then(|v| v.to_str().ok());
let csrf = req
.headers()
.get("x-csrf-token")
.and_then(|v| v.to_str().ok());
csrf_token_ok(cookie, csrf)
}
fn csrf_forbidden() -> HttpResponse {
HttpResponse::Forbidden().body("missing or invalid CSRF token")
}
fn is_read_only(method: &Method) -> bool {
matches!(*method, Method::GET | Method::HEAD | Method::OPTIONS)
}
fn guard_csrf(
resource: Resource,
required: bool,
) -> Resource<
impl ServiceFactory<
ServiceRequest,
Config = (),
Response = ServiceResponse<BoxBody>,
Error = Error,
InitError = (),
>,
> {
resource.wrap_fn(move |req, srv| {
let rejected = required && !is_read_only(req.method()) && !csrf_ok(req.request());
let outcome = if rejected {
Err(req.into_response(csrf_forbidden()))
} else {
Ok(srv.call(req))
};
async move {
match outcome {
Ok(forwarded) => forwarded.await,
Err(forbidden) => Ok(forbidden),
}
}
})
}
#[derive(Debug, Clone)]
pub struct Handler<S, T, Compact> {
_phantom: PhantomData<(S, T, Compact)>,
}
impl<S, T, Compact> Handler<S, T, Compact> {
pub async fn get_tasks(
storage: web::Data<RwLock<S>>,
query: web::Query<Filter>,
) -> impl Responder
where
T: Serialize + DeserializeOwned + 'static,
S: ListTasks<T> + Send + 'static + BackendExt,
S::Context: Serialize + 'static,
S::IdType: Serialize + 'static,
<S as Backend>::Error: std::error::Error + 'static,
S::Codec: Codec<T, Compact = Compact> + 'static,
Compact: 'static,
{
let storage = storage.into_inner();
let filter = query.into_inner();
match get_tasks::<S, T, Compact>(storage, filter).await {
Ok(tasks) => HttpResponse::Ok().json(tasks),
Err(e) => HttpResponse::InternalServerError().json(e),
}
}
pub async fn stats_by_queue(storage: web::Data<RwLock<S>>) -> impl Responder
where
S::Error: std::error::Error,
S: Metrics + BackendExt,
{
let storage = storage.into_inner();
match stats_by_queue::<S>(storage).await {
Ok(stats) => HttpResponse::Ok().json(stats),
Err(e) => HttpResponse::InternalServerError().json(e),
}
}
pub async fn get_workers(storage: web::Data<RwLock<S>>) -> impl Responder
where
S: ListWorkers + BackendExt,
S::Error: std::error::Error,
{
let storage = storage.into_inner();
match get_workers::<S>(storage).await {
Ok(workers) => HttpResponse::Ok().json(workers),
Err(e) => HttpResponse::InternalServerError().json(e),
}
}
pub async fn push_task(task: Json<T>, storage: Data<RwLock<S>>) -> impl Responder
where
T: Serialize + DeserializeOwned + 'static,
S: TaskSink<T> + Send + BackendExt,
S::Error: std::error::Error,
S::Codec: Codec<T, Compact = Compact>,
<<S as BackendExt>::Codec as Codec<T>>::Error: std::error::Error,
{
match push_task(task.into_inner(), storage.into_inner()).await {
Ok(()) => HttpResponse::Ok().finish(),
Err(e) => HttpResponse::InternalServerError().json(e),
}
}
pub async fn get_task_by_id(
task_id: web::Path<String>,
storage: web::Data<RwLock<S>>,
) -> impl Responder
where
T: Serialize + DeserializeOwned + 'static,
S: FetchById<T> + 'static,
S::Context: Serialize,
S::IdType: Serialize,
S::Error: std::error::Error,
S::IdType: FromStr,
<<S as Backend>::IdType as FromStr>::Err: std::error::Error,
{
let task_id = task_id.into_inner();
let storage = storage.into_inner();
match get_task_by_id::<S, T>(task_id, storage).await {
Ok(Some(task)) => HttpResponse::Ok().json(task),
Ok(None) => HttpResponse::NotFound().finish(),
Err(e) => HttpResponse::InternalServerError().json(e),
}
}
pub async fn get_all_tasks(
storage: web::Data<RwLock<S>>,
query: web::Query<Filter>,
) -> impl Responder
where
S: ListAllTasks + Send,
S::Context: Serialize,
S::IdType: Serialize,
S::Compact: Serialize,
<S as Backend>::Error: std::error::Error,
<<S as BackendExt>::Codec as Codec<<S as Backend>::Args>>::Error: std::error::Error,
{
let storage = storage.into_inner();
let filter = query.into_inner();
match get_all_tasks::<S>(storage, filter).await {
Ok(tasks) => HttpResponse::Ok().json(tasks),
Err(e) => HttpResponse::InternalServerError().json(e),
}
}
pub async fn get_all_workers(storage: web::Data<RwLock<S>>) -> impl Responder
where
S: ListWorkers,
S::Error: std::error::Error,
{
let storage = storage.into_inner();
match get_all_workers::<S>(storage).await {
Ok(workers) => HttpResponse::Ok().json(workers),
Err(e) => HttpResponse::InternalServerError().json(e),
}
}
pub async fn fetch_queues(storage: web::Data<RwLock<S>>) -> impl Responder
where
S::Error: std::error::Error,
S: ListQueues,
{
let storage = storage.into_inner();
match fetch_queues::<S>(storage).await {
Ok(queues) => HttpResponse::Ok().json(queues),
Err(e) => HttpResponse::InternalServerError().json(e),
}
}
pub async fn overview(storage: web::Data<RwLock<S>>) -> impl Responder
where
S::Error: std::error::Error,
S: Metrics,
{
let storage = storage.into_inner();
match overview::<S>(storage).await {
Ok(stats) => HttpResponse::Ok().json(stats),
Err(e) => HttpResponse::InternalServerError().json(e),
}
}
}
async fn get_capabilities(
state: web::Data<std::sync::Mutex<crate::api::capability::SharedState>>,
) -> impl Responder {
HttpResponse::Ok().json(state.lock().expect(STATE_POISON).capabilities.clone())
}
async fn get_task_by_id_route<S, T>(
task_id: web::Path<String>,
queue: web::Data<Queue>,
state: web::Data<std::sync::Mutex<SharedState>>,
storage: web::Data<RwLock<S>>,
) -> impl Responder
where
T: Serialize + DeserializeOwned + 'static,
S: FetchById<T> + 'static,
S::Context: Serialize,
S::IdType: Serialize,
S::Error: std::error::Error,
S::IdType: FromStr,
<<S as Backend>::IdType as FromStr>::Err: std::error::Error,
{
let task_id = task_id.into_inner();
match get_task_by_id::<S, T>(task_id.clone(), storage.into_inner()).await {
Ok(Some(task)) => {
state
.lock()
.expect(STATE_POISON)
.record_task_queue(&task_id, queue.get_ref().as_ref());
HttpResponse::Ok().json(task)
}
Ok(None) => HttpResponse::NotFound().finish(),
Err(e) => HttpResponse::InternalServerError().json(e),
}
}
async fn retry<S, T, Compact>(
task_id: web::Path<String>,
storage: web::Data<RwLock<S>>,
hook: web::Data<RescheduleHook>,
) -> impl Responder
where
T: Serialize + DeserializeOwned + 'static,
S: TaskSink<T> + FetchById<T> + BackendExt + Send + 'static,
S::Error: std::error::Error,
S::IdType: FromStr,
<S::IdType as FromStr>::Err: std::error::Error,
S::Codec: Codec<T, Compact = Compact>,
<S::Codec as Codec<T>>::Error: std::error::Error,
{
match actions::retry::<S, T, Compact>(task_id.into_inner(), storage.into_inner(), hook.get())
.await
{
Ok(Some(outcome)) => HttpResponse::Ok().json(outcome),
Ok(None) => HttpResponse::NotFound().finish(),
Err(e) => HttpResponse::InternalServerError().json(e),
}
}
async fn bulk<S, T, Compact>(
storage: web::Data<RwLock<S>>,
reschedule_hook: web::Data<RescheduleHook>,
resume_hook: web::Data<ResumeHook>,
update_hook: web::Data<UpdateHook>,
request: Json<apalis_rtui_types::BulkRequest>,
) -> impl Responder
where
T: Serialize + DeserializeOwned + 'static,
S: TaskSink<T> + FetchById<T> + BackendExt + Send + 'static,
S::Error: std::error::Error,
S::IdType: FromStr,
<S::IdType as FromStr>::Err: std::error::Error,
S::Codec: Codec<T, Compact = Compact>,
<S::Codec as Codec<T>>::Error: std::error::Error,
{
let outcome = actions::bulk::<S, T, Compact>(
request.into_inner(),
storage.into_inner(),
reschedule_hook.get(),
resume_hook.get(),
update_hook.get(),
)
.await;
HttpResponse::Ok().json(outcome)
}
async fn reschedule<S>(
task_id: web::Path<String>,
storage: web::Data<RwLock<S>>,
request: Json<apalis_rtui_types::RescheduleRequest>,
) -> impl Responder
where
S: Reschedule + FetchById<<S as Backend>::Args>,
S::Error: std::error::Error,
S::IdType: FromStr,
<S::IdType as FromStr>::Err: std::error::Error,
{
let wait = std::time::Duration::from_secs(request.wait_secs);
match actions::reschedule::<S>(task_id.into_inner(), storage.into_inner(), wait).await {
Ok(Some(outcome)) => HttpResponse::Ok().json(outcome),
Ok(None) => HttpResponse::NotFound().finish(),
Err(e) => HttpResponse::InternalServerError().json(e),
}
}
async fn resume<S>(task_id: web::Path<String>, storage: web::Data<RwLock<S>>) -> impl Responder
where
S: ResumeById,
S::Error: std::error::Error,
S::IdType: FromStr,
<S::IdType as FromStr>::Err: std::error::Error,
{
match actions::resume::<S>(task_id.into_inner(), storage.into_inner()).await {
Ok(Some(outcome)) => HttpResponse::Ok().json(outcome),
Ok(None) => HttpResponse::NotFound().finish(),
Err(e) => HttpResponse::InternalServerError().json(e),
}
}
async fn resume_abandoned<S>(storage: web::Data<RwLock<S>>) -> impl Responder
where
S: ResumeAbandoned,
S::Error: std::error::Error,
{
match actions::resume_abandoned::<S>(storage.into_inner()).await {
Ok(outcome) => HttpResponse::Ok().json(outcome),
Err(e) => HttpResponse::InternalServerError().json(e),
}
}
async fn vacuum<S>(storage: web::Data<RwLock<S>>) -> impl Responder
where
S: Vacuum,
S::Error: std::error::Error,
{
match actions::vacuum::<S>(storage.into_inner()).await {
Ok(outcome) => HttpResponse::Ok().json(outcome),
Err(e) => HttpResponse::InternalServerError().json(e),
}
}
async fn update<S>(
task_id: web::Path<String>,
storage: web::Data<RwLock<S>>,
request: Json<apalis_rtui_types::UpdateRequest>,
) -> impl Responder
where
S: Update + FetchById<<S as Backend>::Args>,
S::Error: std::error::Error,
S::IdType: FromStr,
<S::IdType as FromStr>::Err: std::error::Error,
{
let apalis_rtui_types::UpdateRequest { priority, meta } = request.into_inner();
match actions::update::<S>(task_id.into_inner(), storage.into_inner(), priority, meta).await {
Ok(Some(outcome)) => HttpResponse::Ok().json(outcome),
Ok(None) => HttpResponse::NotFound().finish(),
Err(e) => HttpResponse::InternalServerError().json(e),
}
}
impl ApiBuilder<Scope> {
pub fn register_shared<B, T, Compact>(mut self, backend: B) -> (Self, Arc<RwLock<B>>)
where
B: Metrics + ListWorkers + ListAllTasks + ListQueues + Send + 'static,
B::Context: Serialize,
B::IdType: Serialize,
<B as Backend>::Error: std::error::Error,
B::IdType: FromStr,
<<B as Backend>::IdType as FromStr>::Err: std::error::Error,
Compact: Serialize + 'static,
B::Compact: Serialize,
<<B as BackendExt>::Codec as Codec<<B as Backend>::Args>>::Error: std::error::Error,
T: Serialize + DeserializeOwned + 'static,
B: ListTasks<T> + FetchById<T>,
B::Codec: Codec<T, Compact = Compact>,
<<B as BackendExt>::Codec as Codec<T>>::Error: std::error::Error,
B: TaskSink<T>,
{
let queue = backend.get_queue();
validate_queue_name(queue.as_ref());
let backend = Arc::new(RwLock::new(backend));
let backend_data = web::Data::from(backend.clone());
let (reschedule_hook, resume_hook, update_hook, live_status_hook) = {
let mut state = self.state.lock().expect(STATE_POISON);
state.register_queue(queue.as_ref());
(
state
.reschedule_hook(queue.as_ref())
.expect("invariant: register_queue was just called for this queue"),
state
.resume_hook(queue.as_ref())
.expect("invariant: register_queue was just called for this queue"),
state
.update_hook(queue.as_ref())
.expect("invariant: register_queue was just called for this queue"),
state
.live_status_hook(queue.as_ref())
.expect("invariant: register_queue was just called for this queue"),
)
};
if self.root {
#[allow(unused_mut)]
let mut router = self
.router
.app_data(backend_data.clone())
.app_data(web::Data::from(self.state.clone()))
.route(
"/queues",
web::get().to(Handler::<B, (), Compact>::fetch_queues),
)
.route(
"/tasks",
web::get().to(Handler::<B, (), Compact>::get_all_tasks),
)
.route(
"/workers",
web::get().to(Handler::<B, (), Compact>::get_all_workers),
)
.route(
"/overview",
web::get().to(Handler::<B, (), Compact>::overview),
)
.route("/capabilities", web::get().to(get_capabilities));
#[cfg(feature = "events")]
{
router = router
.app_data(web::Data::from(self.ring.clone()))
.route("/events", web::get().to(sse::new_client))
.route("/events/status", web::get().to(sse::status))
.route("/events/activity", web::get().to(sse::activity));
}
self.router = router;
}
let require_csrf = self.require_csrf_token;
let max_body_size = self.max_body_size;
let state_data = web::Data::from(self.state.clone());
#[cfg(feature = "events")]
let ring_data = web::Data::from(self.ring.clone());
let prefix = format!("/queues/{queue}");
let outfit = |resource: Resource| {
#[allow(unused_mut)]
let mut resource = resource
.app_data(web::Data::new(queue.clone()))
.app_data(backend_data.clone())
.app_data(state_data.clone())
.app_data(web::JsonConfig::default().limit(max_body_size))
.app_data(web::Data::new(reschedule_hook.clone()))
.app_data(web::Data::new(resume_hook.clone()))
.app_data(web::Data::new(update_hook.clone()))
.app_data(web::Data::new(live_status_hook.clone()));
#[cfg(feature = "events")]
{
resource = resource.app_data(ring_data.clone());
}
guard_csrf(resource, require_csrf)
};
#[allow(unused_mut)]
let mut scope = self
.router
.service(outfit(
Resource::new(format!("{prefix}/tasks"))
.guard(guard::Get())
.route(web::get().to(Handler::<B, T, Compact>::get_tasks)),
))
.service(outfit(
Resource::new(format!("{prefix}/stats"))
.guard(guard::Get())
.route(web::get().to(Handler::<B, T, Compact>::stats_by_queue)),
))
.service(outfit(
Resource::new(format!("{prefix}/workers"))
.guard(guard::Get())
.route(web::get().to(Handler::<B, T, Compact>::get_workers)),
))
.service(outfit(
Resource::new(format!("{prefix}/tasks"))
.guard(guard::Put())
.route(web::put().to(Handler::<B, T, Compact>::push_task)),
))
.service(outfit(
Resource::new(format!("{prefix}/tasks/bulk"))
.guard(guard::Post())
.route(web::post().to(bulk::<B, T, Compact>)),
))
.service(outfit(
Resource::new(format!("{prefix}/tasks/{{id}}"))
.guard(guard::Get())
.route(web::get().to(get_task_by_id_route::<B, T>)),
))
.service(outfit(
Resource::new(format!("{prefix}/tasks/{{id}}/retry"))
.guard(guard::Post())
.route(web::post().to(retry::<B, T, Compact>)),
));
#[cfg(feature = "events")]
{
scope = scope.service(outfit(
Resource::new(format!("{prefix}/tasks/{{id}}/events"))
.guard(guard::Get())
.route(web::get().to(sse::task_events)),
));
}
(
Self {
router: scope,
root: false,
state: self.state,
#[cfg(feature = "events")]
ring: self.ring,
max_body_size: self.max_body_size,
require_csrf_token: self.require_csrf_token,
},
backend,
)
}
}
impl<B, T, Compact> RegisterRoute<B, T> for ApiBuilder<Scope>
where
B: Metrics + ListWorkers + ListAllTasks + ListQueues + Send + 'static,
B::Context: Serialize,
B::IdType: Serialize,
<B as Backend>::Error: std::error::Error,
B::IdType: FromStr,
<<B as Backend>::IdType as FromStr>::Err: std::error::Error,
Compact: Serialize + 'static,
B::Compact: Serialize,
<B as Backend>::Error: std::error::Error,
<<B as BackendExt>::Codec as Codec<<B as Backend>::Args>>::Error: std::error::Error,
T: Serialize + DeserializeOwned + 'static,
B: ListTasks<T> + FetchById<T>,
B::Codec: Codec<T, Compact = Compact>,
<<B as BackendExt>::Codec as Codec<T>>::Error: std::error::Error,
B: TaskSink<T>,
{
fn register(self, backend: B) -> Self {
self.register_shared::<B, T, Compact>(backend).0
}
}
fn queue_route(queue: &Queue, suffix: &str) -> String {
format!("/queues/{queue}{suffix}")
}
impl<B> RegisterReschedule<B> for ApiBuilder<Scope>
where
B: Reschedule + FetchById<<B as Backend>::Args> + BackendExt + Send + Sync + 'static,
B::Error: std::error::Error,
B::IdType: FromStr + Send + Sync,
<B::IdType as FromStr>::Err: std::error::Error,
{
fn with_reschedule(mut self, queue: impl Into<Queue>, backend: &Arc<RwLock<B>>) -> Self {
let queue = queue.into();
let key = queue.to_string();
{
let mut state = self.state.lock().expect(STATE_POISON);
assert_queue_registered(&state, &key, "with_reschedule");
state.register_queue(&key);
state
.capabilities
.entry(key.clone())
.or_default()
.reschedule = true;
}
let require_csrf = self.require_csrf_token;
self.router = self.router.service(guard_csrf(
Resource::new(queue_route(&queue, "/tasks/{id}/reschedule"))
.guard(guard::Patch())
.app_data(web::Data::from(backend.clone()))
.app_data(web::JsonConfig::default().limit(self.max_body_size))
.route(web::patch().to(reschedule::<B>)),
require_csrf,
));
if let Some(hook) = self.state.lock().expect(STATE_POISON).reschedule_hook(&key) {
hook.set(actions::reschedule_upgrade(backend.clone()));
}
self
}
}
impl<B> RegisterResume<B> for ApiBuilder<Scope>
where
B: ResumeById + Send + Sync + 'static,
B::Error: std::error::Error,
B::IdType: FromStr + Send + Sync,
<B::IdType as FromStr>::Err: std::error::Error,
{
fn with_resume(mut self, queue: impl Into<Queue>, backend: &Arc<RwLock<B>>) -> Self {
let queue = queue.into();
let key = queue.to_string();
{
let mut state = self.state.lock().expect(STATE_POISON);
assert_queue_registered(&state, &key, "with_resume");
state.register_queue(&key);
state
.capabilities
.entry(key.clone())
.or_default()
.resume_by_id = true;
}
let require_csrf = self.require_csrf_token;
self.router = self.router.service(guard_csrf(
Resource::new(queue_route(&queue, "/tasks/{id}/resume"))
.guard(guard::Post())
.app_data(web::Data::from(backend.clone()))
.route(web::post().to(resume::<B>)),
require_csrf,
));
if let Some(hook) = self.state.lock().expect(STATE_POISON).resume_hook(&key) {
hook.set(actions::resume_upgrade(backend.clone()));
}
self
}
}
impl<B> RegisterResumeAbandoned<B> for ApiBuilder<Scope>
where
B: ResumeAbandoned + Send + Sync + 'static,
B::Error: std::error::Error,
{
fn with_resume_abandoned(mut self, queue: impl Into<Queue>, backend: &Arc<RwLock<B>>) -> Self {
let queue = queue.into();
let key = queue.to_string();
{
let mut state = self.state.lock().expect(STATE_POISON);
assert_queue_registered(&state, &key, "with_resume_abandoned");
state.capabilities.entry(key).or_default().resume_abandoned = true;
}
let require_csrf = self.require_csrf_token;
self.router = self.router.service(guard_csrf(
Resource::new(queue_route(&queue, "/resume-abandoned"))
.guard(guard::Post())
.app_data(web::Data::from(backend.clone()))
.route(web::post().to(resume_abandoned::<B>)),
require_csrf,
));
self
}
}
impl<B> RegisterVacuum<B> for ApiBuilder<Scope>
where
B: Vacuum + Send + Sync + 'static,
B::Error: std::error::Error,
{
fn with_vacuum(mut self, queue: impl Into<Queue>, backend: &Arc<RwLock<B>>) -> Self {
let queue = queue.into();
let key = queue.to_string();
{
let mut state = self.state.lock().expect(STATE_POISON);
assert_queue_registered(&state, &key, "with_vacuum");
state.capabilities.entry(key).or_default().vacuum = true;
}
let require_csrf = self.require_csrf_token;
self.router = self.router.service(guard_csrf(
Resource::new(queue_route(&queue, "/vacuum"))
.guard(guard::Post())
.app_data(web::Data::from(backend.clone()))
.route(web::post().to(vacuum::<B>)),
require_csrf,
));
self
}
}
impl<B> RegisterUpdate<B> for ApiBuilder<Scope>
where
B: Update + FetchById<<B as Backend>::Args> + BackendExt + Send + Sync + 'static,
B::Error: std::error::Error,
B::IdType: FromStr + Send + Sync,
<B::IdType as FromStr>::Err: std::error::Error,
{
fn with_update(mut self, queue: impl Into<Queue>, backend: &Arc<RwLock<B>>) -> Self {
let queue = queue.into();
let key = queue.to_string();
{
let mut state = self.state.lock().expect(STATE_POISON);
assert_queue_registered(&state, &key, "with_update");
state.register_queue(&key);
state.capabilities.entry(key.clone()).or_default().update = true;
}
let require_csrf = self.require_csrf_token;
self.router = self.router.service(guard_csrf(
Resource::new(queue_route(&queue, "/tasks/{id}"))
.guard(guard::Patch())
.app_data(web::Data::from(backend.clone()))
.app_data(web::JsonConfig::default().limit(self.max_body_size))
.route(web::patch().to(update::<B>)),
require_csrf,
));
if let Some(hook) = self.state.lock().expect(STATE_POISON).update_hook(&key) {
hook.set(actions::update_upgrade(backend.clone()));
}
self
}
}
impl<B> RegisterRegisterWorker<B> for ApiBuilder<Scope>
where
B: RegisterWorker + BackendExt + Send + Sync + 'static,
B::Error: std::error::Error,
{
fn with_register_worker(self, queue: impl Into<Queue>, _backend: &Arc<RwLock<B>>) -> Self {
let queue = queue.into();
let key = queue.to_string();
{
let mut state = self.state.lock().expect(STATE_POISON);
assert_queue_registered(&state, &key, "with_register_worker");
state.capabilities.entry(key).or_default().register_worker = true;
}
self
}
}
impl<B> RegisterLiveStatus<B> for ApiBuilder<Scope>
where
B: WaitForCompletion<LiveResult> + BackendExt + Send + Sync + 'static,
B::Error: std::error::Error,
B::IdType: FromStr + Send + Sync,
<B::IdType as FromStr>::Err: std::error::Error,
{
fn with_live_status(self, queue: impl Into<Queue>, backend: &Arc<RwLock<B>>) -> Self {
let queue = queue.into();
let key = queue.to_string();
{
let mut state = self.state.lock().expect(STATE_POISON);
assert_queue_registered(&state, &key, "with_live_status");
state.register_queue(&key);
state
.capabilities
.entry(key.clone())
.or_default()
.live_status = true;
}
if let Some(hook) = self
.state
.lock()
.expect(STATE_POISON)
.live_status_hook(&key)
{
hook.set(actions::live_status_upgrade(key, backend.clone()));
}
self
}
}
#[cfg(feature = "ui")]
mod ui {
use super::ServeUI;
use actix_web::{
HttpRequest, HttpResponse, HttpResponseBuilder,
dev::HttpServiceFactory,
http::{StatusCode, header},
};
impl ServeUI {
fn serve_file(&self, path: &str) -> HttpResponse {
let Some(rendered) = self.render(path) else {
return HttpResponseBuilder::new(StatusCode::NOT_FOUND).finish();
};
let mut response = HttpResponse::Ok();
let mut builder = response.insert_header((header::CONTENT_TYPE, rendered.content_type));
if let Some(cache) = rendered.cache_control {
builder = builder.insert_header((header::CACHE_CONTROL, cache));
}
if let Some(csp) = self.csp_header() {
builder = builder.insert_header((header::CONTENT_SECURITY_POLICY, csp));
}
builder.body(rendered.body)
}
}
impl HttpServiceFactory for ServeUI {
fn register(self, config: &mut actix_web::dev::AppService) {
let resource = actix_web::Resource::new("/{tail:.*}").route(actix_web::web::get().to(
move |req: HttpRequest| {
let this = self.clone();
async move {
let path = req.match_info().query("tail").to_owned();
this.serve_file(&path)
}
},
));
resource.register(config);
}
}
}
#[cfg(feature = "events")]
pub mod sse {
use std::{
pin::Pin,
sync::{Arc, Mutex},
time::Duration,
};
use actix_web::{
Responder,
web::{Data, Path, Query},
};
use actix_web_lab::sse::Event;
use apalis_rtui_types::TaskStatusEvent;
use futures::{Stream, StreamExt, future, stream};
use serde::Deserialize;
use crate::api::{
capability::{LiveStatusHook, SharedState},
sse::{EventRing, StatusFilter, TracingBroadcaster, ring::RING_POISON},
};
#[derive(Debug, Deserialize)]
pub(crate) struct StatusQuery {
#[serde(default)]
queue: Option<String>,
#[serde(default)]
task_id: Option<String>,
}
fn status_sse(events: impl Stream<Item = TaskStatusEvent> + 'static) -> impl Responder {
let stream = events.map(|event| {
Event::Data(
actix_web_lab::sse::Data::new_json(event)
.expect("invariant: TaskStatusEvent always encodes as JSON"),
)
});
actix_web_lab::sse::Sse::from_infallible_stream(stream)
.with_keep_alive(Duration::from_secs(15))
}
pub(crate) async fn status(
query: Query<StatusQuery>,
ring: Data<Mutex<EventRing>>,
broadcaster: Data<Arc<Mutex<TracingBroadcaster>>>,
state: Data<Mutex<SharedState>>,
) -> impl Responder {
let query = query.into_inner();
EventRing::ensure_feeding(&ring, broadcaster.get_ref(), state.into_inner());
let (replay, live) = ring.lock().expect(RING_POISON).subscribe(StatusFilter {
queue: query.queue,
task_id: query.task_id,
});
status_sse(stream::iter(replay).chain(live))
}
pub(crate) async fn activity(
ring: Data<Mutex<EventRing>>,
broadcaster: Data<Arc<Mutex<TracingBroadcaster>>>,
state: Data<Mutex<SharedState>>,
) -> impl Responder {
EventRing::ensure_feeding(&ring, broadcaster.get_ref(), state.into_inner());
let buckets = ring.lock().expect(RING_POISON).activity();
actix_web::HttpResponse::Ok().json(buckets)
}
pub(crate) async fn task_events(
task_id: Path<String>,
hook: Data<LiveStatusHook>,
ring: Data<Mutex<EventRing>>,
broadcaster: Data<Arc<Mutex<TracingBroadcaster>>>,
state: Data<Mutex<SharedState>>,
) -> impl Responder {
let task_id = task_id.into_inner();
let events: Pin<Box<dyn Stream<Item = TaskStatusEvent> + Send>> =
if let Some(upgrade) = hook.get() {
Box::pin(stream::once(upgrade(task_id)).filter_map(future::ready))
} else {
EventRing::ensure_feeding(&ring, broadcaster.get_ref(), state.into_inner());
let (replay, live) = ring.lock().expect(RING_POISON).subscribe(StatusFilter {
queue: None,
task_id: Some(task_id),
});
Box::pin(stream::iter(replay).chain(live))
};
status_sse(events)
}
pub async fn new_client(
broadcaster: Data<Arc<Mutex<TracingBroadcaster>>>,
) -> impl actix_web::Responder {
let rx = broadcaster
.lock()
.expect("invariant: broadcaster mutex is never held across a panic")
.new_client();
actix_web_lab::sse::Sse::from_stream(
rx.filter(|s| futures::future::ready(s.as_ref().is_ok_and(|e| e.span.is_some())))
.map(|entry| {
actix_web_lab::sse::Data::new_json(
entry.map_err(actix_web::error::ErrorInternalServerError)?,
)
.map(Event::Data)
.map_err(actix_web::error::ErrorInternalServerError)
}),
)
.with_keep_alive(Duration::from_secs(60 * 5))
}
}