use std::{
str::FromStr,
sync::{Arc, Mutex},
};
use apalis_core::{
backend::{
Backend, BackendExt, FetchById, Filter, ListAllTasks, ListQueues, ListTasks, ListWorkers,
Metrics, QueueInfo, RegisterWorker, Reschedule, ResumeAbandoned, ResumeById, RunningWorker,
Statistic, TaskSink, Update, Vacuum, WaitForCompletion, codec::Codec, queue::Queue,
},
task::Task,
};
use apalis_rtui_types::{
ActionOutcome, ApiError, BulkOutcome, BulkRequest, CapabilityMap, RescheduleRequest,
UpdateRequest,
};
use axum::{
Extension, Json, Router,
extract::{DefaultBodyLimit, Path, Query, rejection::JsonRejection},
http::{StatusCode, header},
middleware,
response::{IntoResponse, Response},
routing::{MethodRouter, get, put},
};
use serde::{Serialize, de::DeserializeOwned};
use tokio::sync::RwLock;
#[cfg(feature = "events")]
use crate::api::capability::LiveStatusHook;
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,
percent_encode_queue, validate_queue_name,
},
framework::{ApiBuilder, RegisterRoute},
};
#[derive(Debug, thiserror::Error)]
pub enum AppError {
#[error("JSON Rejection: {0}")]
JsonRejection(JsonRejection),
#[error("API Error: {0}")]
ApiError(ApiError),
#[error("Resource not found")]
NotFound,
#[error("Missing application state")]
MissingState,
}
impl IntoResponse for AppError {
fn into_response(self) -> Response {
match self {
Self::JsonRejection(rejection) => {
(rejection.status(), rejection.body_text()).into_response()
}
Self::ApiError(err) => {
(StatusCode::INTERNAL_SERVER_ERROR, Json(err).into_response()).into_response()
}
Self::NotFound => (StatusCode::NOT_FOUND, ()).into_response(),
Self::MissingState => (
StatusCode::INTERNAL_SERVER_ERROR,
"Missing application state",
)
.into_response(),
}
}
}
pub type State<B> = Extension<Arc<RwLock<B>>>;
pub async fn get_tasks<S, T, Compact>(
query: Query<Filter>,
storage: State<S>,
) -> Result<Json<Vec<Task<T, S::Context, S::IdType>>>, AppError>
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.0;
let filter = query.0;
crate::api::get_tasks::<S, T, Compact>(storage, filter)
.await
.map(Json)
.map_err(AppError::ApiError)
}
pub async fn stats_by_queue<S>(storage: State<S>) -> Result<Json<Vec<Statistic>>, AppError>
where
S::Error: std::error::Error,
S: Metrics + BackendExt,
{
crate::api::stats_by_queue::<S>(storage.0)
.await
.map(Json)
.map_err(AppError::ApiError)
}
pub async fn get_workers<S>(storage: State<S>) -> Result<Json<Vec<RunningWorker>>, AppError>
where
S: ListWorkers + BackendExt,
S::Error: std::error::Error,
{
crate::api::get_workers::<S>(storage.0)
.await
.map(Json)
.map_err(AppError::ApiError)
}
pub async fn push_task<S, T, Compact>(
storage: State<S>,
task: Json<T>,
) -> Result<Json<()>, AppError>
where
T: Serialize + DeserializeOwned + 'static + Send,
S: TaskSink<T> + 'static + Send + BackendExt,
S::Error: std::error::Error,
S::Codec: Codec<T, Compact = Compact>,
<<S as BackendExt>::Codec as Codec<T>>::Error: std::error::Error,
{
crate::api::push_task(task.0, storage.0)
.await
.map(Json)
.map_err(AppError::ApiError)
}
pub async fn get_task_by_id<S, T>(
Path(task_id): Path<String>,
storage: State<S>,
) -> Result<Json<Task<T, S::Context, S::IdType>>, AppError>
where
T: Serialize + DeserializeOwned + 'static + Send,
S: FetchById<T> + Send + 'static,
S::Context: Serialize + 'static + Send,
S::IdType: Serialize + 'static + Send,
S::Error: std::error::Error,
S::IdType: FromStr + 'static + Send,
<<S as Backend>::IdType as FromStr>::Err: std::error::Error,
{
match crate::api::get_task_by_id::<S, T>(task_id, storage.0).await {
Ok(Some(task)) => Ok(Json(task)),
Ok(None) => Err(AppError::NotFound),
Err(e) => Err(AppError::ApiError(e)),
}
}
async fn get_task_by_id_route<S, T>(
Path(task_id): Path<String>,
Extension(queue): Extension<Queue>,
Extension(state): Extension<Arc<Mutex<SharedState>>>,
storage: State<S>,
) -> Result<Json<Task<T, S::Context, S::IdType>>, AppError>
where
T: Serialize + DeserializeOwned + 'static + Send,
S: FetchById<T> + Send + 'static,
S::Context: Serialize + 'static + Send,
S::IdType: Serialize + 'static + Send,
S::Error: std::error::Error,
S::IdType: FromStr + 'static + Send,
<<S as Backend>::IdType as FromStr>::Err: std::error::Error,
{
match crate::api::get_task_by_id::<S, T>(task_id.clone(), storage.0).await {
Ok(Some(task)) => {
state
.lock()
.expect(STATE_POISON)
.record_task_queue(&task_id, queue.as_ref());
Ok(Json(task))
}
Ok(None) => Err(AppError::NotFound),
Err(e) => Err(AppError::ApiError(e)),
}
}
pub async fn get_all_tasks<S>(
query: Query<Filter>,
storage: State<S>,
) -> Result<Json<Vec<Task<S::Compact, S::Context, S::IdType>>>, AppError>
where
S: ListAllTasks + BackendExt + Send + 'static,
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,
{
crate::api::get_all_tasks::<S>(storage.0, query.0)
.await
.map(Json)
.map_err(AppError::ApiError)
}
pub async fn get_all_workers<S>(storage: State<S>) -> Result<Json<Vec<RunningWorker>>, AppError>
where
S: ListWorkers + 'static,
S::Error: std::error::Error,
{
crate::api::get_all_workers::<S>(storage.0)
.await
.map(Json)
.map_err(AppError::ApiError)
}
pub async fn fetch_queues<S>(storage: State<S>) -> Result<Json<Vec<QueueInfo>>, AppError>
where
S::Error: std::error::Error,
S: ListQueues,
{
crate::api::fetch_queues::<S>(storage.0)
.await
.map(Json)
.map_err(AppError::ApiError)
}
pub async fn overview<S>(storage: State<S>) -> Result<Json<Vec<Statistic>>, AppError>
where
S::Error: std::error::Error,
S: Metrics + 'static,
{
crate::api::overview::<S>(storage.0)
.await
.map(Json)
.map_err(AppError::ApiError)
}
async fn get_capabilities(
Extension(state): Extension<Arc<Mutex<SharedState>>>,
) -> Json<CapabilityMap> {
Json(state.lock().expect(STATE_POISON).capabilities.clone())
}
async fn retry<S, T, Compact>(
Path(task_id): Path<String>,
Extension(storage): Extension<Arc<RwLock<S>>>,
Extension(hook): Extension<RescheduleHook>,
) -> Result<Json<ActionOutcome>, AppError>
where
T: Serialize + DeserializeOwned + Send + 'static,
S: TaskSink<T> + FetchById<T> + BackendExt + Send + Sync + '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, storage, hook.get()).await {
Ok(Some(outcome)) => Ok(Json(outcome)),
Ok(None) => Err(AppError::NotFound),
Err(e) => Err(AppError::ApiError(e)),
}
}
async fn bulk<S, T, Compact>(
Extension(storage): Extension<Arc<RwLock<S>>>,
Extension(reschedule_hook): Extension<RescheduleHook>,
Extension(resume_hook): Extension<ResumeHook>,
Extension(update_hook): Extension<UpdateHook>,
request: Json<BulkRequest>,
) -> Result<Json<BulkOutcome>, AppError>
where
T: Serialize + DeserializeOwned + Send + 'static,
S: TaskSink<T> + FetchById<T> + BackendExt + Send + Sync + '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.0,
storage,
reschedule_hook.get(),
resume_hook.get(),
update_hook.get(),
)
.await;
Ok(Json(outcome))
}
async fn reschedule<S>(
Path(task_id): Path<String>,
Extension(storage): Extension<Arc<RwLock<S>>>,
request: Json<RescheduleRequest>,
) -> Result<Json<ActionOutcome>, AppError>
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.0.wait_secs);
match actions::reschedule::<S>(task_id, storage, wait).await {
Ok(Some(outcome)) => Ok(Json(outcome)),
Ok(None) => Err(AppError::NotFound),
Err(e) => Err(AppError::ApiError(e)),
}
}
async fn resume<S>(
Path(task_id): Path<String>,
Extension(storage): Extension<Arc<RwLock<S>>>,
) -> Result<Json<ActionOutcome>, AppError>
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, storage).await {
Ok(Some(outcome)) => Ok(Json(outcome)),
Ok(None) => Err(AppError::NotFound),
Err(e) => Err(AppError::ApiError(e)),
}
}
async fn resume_abandoned<S>(
Extension(storage): Extension<Arc<RwLock<S>>>,
) -> Result<Json<ActionOutcome>, AppError>
where
S: ResumeAbandoned,
S::Error: std::error::Error,
{
actions::resume_abandoned::<S>(storage)
.await
.map(Json)
.map_err(AppError::ApiError)
}
async fn vacuum<S>(
Extension(storage): Extension<Arc<RwLock<S>>>,
) -> Result<Json<ActionOutcome>, AppError>
where
S: Vacuum,
S::Error: std::error::Error,
{
actions::vacuum::<S>(storage)
.await
.map(Json)
.map_err(AppError::ApiError)
}
async fn update<S>(
Path(task_id): Path<String>,
Extension(storage): Extension<Arc<RwLock<S>>>,
request: Json<UpdateRequest>,
) -> Result<Json<ActionOutcome>, AppError>
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 UpdateRequest { priority, meta } = request.0;
match actions::update::<S>(task_id, storage, priority, meta).await {
Ok(Some(outcome)) => Ok(Json(outcome)),
Ok(None) => Err(AppError::NotFound),
Err(e) => Err(AppError::ApiError(e)),
}
}
async fn require_csrf_middleware(
request: axum::extract::Request,
next: middleware::Next,
) -> Response {
let cookie = request
.headers()
.get(header::COOKIE)
.and_then(|v| v.to_str().ok());
let csrf = request
.headers()
.get("x-csrf-token")
.and_then(|v| v.to_str().ok());
if csrf_token_ok(cookie, csrf) {
next.run(request).await
} else {
(StatusCode::FORBIDDEN, "missing or invalid CSRF token").into_response()
}
}
fn mutating(route: MethodRouter, max_body_size: usize, require_csrf: bool) -> MethodRouter {
let route = route.layer(DefaultBodyLimit::max(max_body_size));
if require_csrf {
route.layer(middleware::from_fn(require_csrf_middleware))
} else {
route
}
}
impl ApiBuilder<Router> {
pub fn register_shared<B, T, Compact>(mut self, backend: B) -> (Self, Arc<RwLock<B>>)
where
B: Metrics + ListWorkers + ListAllTasks + ListQueues,
B::Context: Serialize,
B::IdType: Serialize,
<B as Backend>::Error: std::error::Error,
B::IdType: FromStr + 'static + Send,
<<B as Backend>::IdType as FromStr>::Err: std::error::Error,
Compact: Serialize + 'static + Send,
B::Compact: Serialize + 'static + Send,
B::Context: Serialize + 'static + Send,
<<B as BackendExt>::Codec as Codec<<B as Backend>::Args>>::Error: std::error::Error,
T: Serialize + DeserializeOwned + 'static + Send,
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> + BackendExt + Send + Sync + 'static,
{
let queue = backend.get_queue();
validate_queue_name(queue.as_ref());
let backend = Arc::new(RwLock::new(backend));
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 r = self
.router
.route("/queues", get(fetch_queues::<B>))
.route("/tasks", get(get_all_tasks::<B>))
.route("/workers", get(get_all_workers::<B>))
.route("/overview", get(overview::<B>))
.route("/capabilities", get(get_capabilities));
#[cfg(feature = "events")]
{
r = r
.route("/events", get(sse::new_client))
.route("/events/status", get(sse::status))
.route("/events/activity", get(sse::activity))
.layer(Extension(self.ring.clone()));
}
self.router = r
.layer(Extension(backend.clone()))
.layer(Extension(self.state.clone()));
}
let max_body_size = self.max_body_size;
let require_csrf = self.require_csrf_token;
#[allow(unused_mut)]
let mut inner = Router::new()
.route("/tasks", get(get_tasks::<B, T, Compact>))
.route("/stats", get(stats_by_queue::<B>))
.route("/workers", get(get_workers::<B>))
.route(
"/tasks",
mutating(put(push_task::<B, T, Compact>), max_body_size, require_csrf),
)
.route("/tasks/{task_id}", get(get_task_by_id_route::<B, T>))
.route(
"/tasks/{task_id}/retry",
mutating(
axum::routing::post(retry::<B, T, Compact>),
max_body_size,
require_csrf,
),
)
.route(
"/tasks/bulk",
mutating(
axum::routing::post(bulk::<B, T, Compact>),
max_body_size,
require_csrf,
),
);
#[cfg(feature = "events")]
{
inner = inner
.route("/tasks/{task_id}/events", get(sse::task_events))
.layer(Extension(self.ring.clone()));
}
let scope = self.router.nest(
&format!("/queues/{}", percent_encode_queue(&queue)),
inner
.layer(Extension(queue.clone()))
.layer(Extension(backend.clone()))
.layer(Extension(self.state.clone()))
.layer(Extension(reschedule_hook))
.layer(Extension(resume_hook))
.layer(Extension(update_hook))
.layer(Extension(live_status_hook)),
);
(
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<Router>
where
B: Metrics + ListWorkers + ListAllTasks + ListQueues,
B::Context: Serialize,
B::IdType: Serialize,
<B as Backend>::Error: std::error::Error,
B::IdType: FromStr + 'static + Send,
<<B as Backend>::IdType as FromStr>::Err: std::error::Error,
Compact: Serialize + 'static + Send,
B::Compact: Serialize + 'static + Send,
B::Context: Serialize + 'static + Send,
<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 + Send,
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> + BackendExt + Send + Sync + 'static,
{
fn register(self, backend: B) -> Self {
self.register_shared::<B, T, Compact>(backend).0
}
}
impl<B> RegisterReschedule<B> for ApiBuilder<Router>
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 max_body_size = self.max_body_size;
let require_csrf = self.require_csrf_token;
let path = format!(
"/queues/{}/tasks/{{task_id}}/reschedule",
percent_encode_queue(&queue)
);
self.router = self.router.route(
&path,
mutating(
axum::routing::patch(reschedule::<B>).layer(Extension(backend.clone())),
max_body_size,
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<Router>
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 max_body_size = self.max_body_size;
let require_csrf = self.require_csrf_token;
let path = format!(
"/queues/{}/tasks/{{task_id}}/resume",
percent_encode_queue(&queue)
);
self.router = self.router.route(
&path,
mutating(
axum::routing::post(resume::<B>).layer(Extension(backend.clone())),
max_body_size,
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<Router>
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 max_body_size = self.max_body_size;
let require_csrf = self.require_csrf_token;
let path = format!("/queues/{}/resume-abandoned", percent_encode_queue(&queue));
self.router = self.router.route(
&path,
mutating(
axum::routing::post(resume_abandoned::<B>).layer(Extension(backend.clone())),
max_body_size,
require_csrf,
),
);
self
}
}
impl<B> RegisterVacuum<B> for ApiBuilder<Router>
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 max_body_size = self.max_body_size;
let require_csrf = self.require_csrf_token;
let path = format!("/queues/{}/vacuum", percent_encode_queue(&queue));
self.router = self.router.route(
&path,
mutating(
axum::routing::post(vacuum::<B>).layer(Extension(backend.clone())),
max_body_size,
require_csrf,
),
);
self
}
}
impl<B> RegisterUpdate<B> for ApiBuilder<Router>
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 max_body_size = self.max_body_size;
let require_csrf = self.require_csrf_token;
let path = format!("/queues/{}/tasks/{{task_id}}", percent_encode_queue(&queue));
self.router = self.router.route(
&path,
mutating(
axum::routing::patch(update::<B>).layer(Extension(backend.clone())),
max_body_size,
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<Router>
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<Router>
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 std::{
convert::Infallible,
task::{Context, Poll},
};
use apalis_core::layers::Service;
use axum::{
body::Body,
http::{Request, Response, StatusCode},
};
use crate::api::ui::ServeUI;
impl Service<Request<Body>> for ServeUI {
type Response = Response<Body>;
type Error = Infallible;
type Future = std::future::Ready<Result<Self::Response, Self::Error>>;
fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(()))
}
fn call(&mut self, req: Request<Body>) -> Self::Future {
let path = req.uri().path().to_owned();
let response = match self.render(&path) {
Some(rendered) => {
let mut builder = Response::builder()
.status(StatusCode::OK)
.header("Content-Type", rendered.content_type);
if let Some(cache) = rendered.cache_control {
builder = builder.header("Cache-Control", cache);
}
if let Some(csp) = self.csp_header() {
builder = builder.header("Content-Security-Policy", csp);
}
builder
.body(rendered.body.into())
.expect("invariant: header values are static or already validated")
}
None => Response::builder()
.status(StatusCode::NOT_FOUND)
.body(Vec::new().into())
.expect("invariant: a static 404 response has no invalid headers"),
};
std::future::ready(Ok(response))
}
}
}
#[cfg(feature = "events")]
pub mod sse {
use std::{convert::Infallible, pin::Pin, sync::Mutex, time::Duration};
use apalis_rtui_types::{ActivityBucket, TaskStatusEvent};
use axum::response::{Sse, sse::Event};
use futures::{Stream, StreamExt, channel::mpsc::TryRecvError, future, stream};
use serde::Deserialize;
use crate::api::sse::{EventRing, StatusFilter, TracingBroadcaster, ring::RING_POISON};
use super::*;
pub async fn new_client(
broadcaster: Extension<Arc<Mutex<TracingBroadcaster>>>,
) -> Sse<impl Stream<Item = Result<Event, TryRecvError>>> {
let rx = broadcaster
.lock()
.expect("invariant: broadcaster mutex is never held across a panic")
.new_client();
let stream = rx
.filter(|s| futures::future::ready(s.as_ref().is_ok_and(|e| e.span.is_some())))
.map(|entry| {
Ok(Event::default()
.json_data(entry?)
.expect("invariant: LogEntry always encodes as JSON"))
});
Sse::new(stream).keep_alive(
axum::response::sse::KeepAlive::new()
.interval(Duration::from_secs(1))
.text("keep-alive-text"),
)
}
#[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> + Send + 'static,
) -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
let stream = events.map(|event| {
Ok(Event::default()
.json_data(event)
.expect("invariant: TaskStatusEvent always encodes as JSON"))
});
Sse::new(stream).keep_alive(
axum::response::sse::KeepAlive::new()
.interval(Duration::from_secs(15))
.text("keep-alive"),
)
}
pub(crate) async fn status(
Query(query): Query<StatusQuery>,
Extension(ring): Extension<Arc<Mutex<EventRing>>>,
Extension(broadcaster): Extension<Arc<Mutex<TracingBroadcaster>>>,
Extension(state): Extension<Arc<Mutex<SharedState>>>,
) -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
EventRing::ensure_feeding(&ring, &broadcaster, state);
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(
Extension(ring): Extension<Arc<Mutex<EventRing>>>,
Extension(broadcaster): Extension<Arc<Mutex<TracingBroadcaster>>>,
Extension(state): Extension<Arc<Mutex<SharedState>>>,
) -> Json<Vec<ActivityBucket>> {
EventRing::ensure_feeding(&ring, &broadcaster, state);
Json(ring.lock().expect(RING_POISON).activity())
}
pub(crate) async fn task_events(
Path(task_id): Path<String>,
Extension(hook): Extension<LiveStatusHook>,
Extension(ring): Extension<Arc<Mutex<EventRing>>>,
Extension(broadcaster): Extension<Arc<Mutex<TracingBroadcaster>>>,
Extension(state): Extension<Arc<Mutex<SharedState>>>,
) -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
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, state);
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)
}
}