335 lines
13 KiB
Rust
335 lines
13 KiB
Rust
//! `GET /api/notify/deliveries` and `GET /api/notify/dry-run`: what the
|
|
//! notification router has delivered, and what the saved flows would do with
|
|
//! the newest forge events.
|
|
//!
|
|
//! The router keeps the log and the events, so each is a NATS request to it
|
|
//! (`swarm_wire::router_api`). A router that predates them, or none at all,
|
|
//! has no subscriber: the queue answers "no responders" at once and these
|
|
//! answer 503 saying so, as they do when it hears the request and stays
|
|
//! silent. The saved document is what `GET /api/notify/flows` shows; a draft
|
|
//! is run by sending the same request with another document.
|
|
|
|
use axum::Json;
|
|
use axum::extract::{Query, State};
|
|
use axum::http::StatusCode;
|
|
use problem_details::ProblemDetails;
|
|
use serde::Deserialize;
|
|
use serde::de::DeserializeOwned;
|
|
use swarm_wire::notify_flows::Document;
|
|
use swarm_wire::router_api::{
|
|
DELIVERIES_SUBJECT, DRY_RUN_SUBJECT, Deliveries, DeliveriesRequest, DryRun, DryRunRequest,
|
|
REPLY_DEADLINE, Refused,
|
|
};
|
|
use utoipa::IntoParams;
|
|
|
|
use crate::notify_flows::{Stored, open, queue_problem, stored, unreadable};
|
|
use crate::routes::{AppState, error_problem};
|
|
use crate::schedules::{queue, refused};
|
|
|
|
/// Ask the router on `subject` and decode its answer as `T`.
|
|
///
|
|
/// 503: nothing hears the request, or what hears it does not answer in time;
|
|
/// both mean the running router does not have this feature. 502: it answered
|
|
/// with a refusal or with something this build cannot read.
|
|
async fn ask<T: DeserializeOwned>(
|
|
client: &async_nats::Client,
|
|
subject: &str,
|
|
body: Vec<u8>,
|
|
) -> Result<T, ProblemDetails> {
|
|
use async_nats::RequestErrorKind;
|
|
|
|
let sent = async_nats::Request::new()
|
|
.payload(body.into())
|
|
.timeout(Some(REPLY_DEADLINE));
|
|
let reply = client
|
|
.send_request(subject.to_owned(), sent)
|
|
.await
|
|
.map_err(|e| {
|
|
let detail = match e.kind() {
|
|
RequestErrorKind::NoResponders => "the notification router does not answer this: \
|
|
it is not running, or it is an older build than this controller"
|
|
.to_owned(),
|
|
RequestErrorKind::TimedOut => format!(
|
|
"the notification router sent no answer within {}s",
|
|
REPLY_DEADLINE.as_secs()
|
|
),
|
|
_ => format!("asking the notification router failed: {e}"),
|
|
};
|
|
error_problem(StatusCode::SERVICE_UNAVAILABLE, &detail)
|
|
})?;
|
|
if let Ok(answer) = serde_json::from_slice::<T>(&reply.payload) {
|
|
return Ok(answer);
|
|
}
|
|
let detail = match serde_json::from_slice::<Refused>(&reply.payload) {
|
|
Ok(Refused { error }) => format!("the notification router refused: {error}"),
|
|
Err(e) => format!("the notification router's answer did not decode: {e}"),
|
|
};
|
|
Err(error_problem(StatusCode::BAD_GATEWAY, &detail))
|
|
}
|
|
|
|
/// `get_deliveries`'s query.
|
|
#[derive(Deserialize, IntoParams)]
|
|
pub struct DeliveriesQuery {
|
|
/// At most this many rows; 100 when absent, and the log keeps 500.
|
|
limit: Option<usize>,
|
|
}
|
|
|
|
/// The newest deliveries the router made, newest first.
|
|
#[utoipa::path(
|
|
get,
|
|
path = "/api/notify/deliveries",
|
|
params(DeliveriesQuery),
|
|
responses(
|
|
(status = 200, description = "the router's deliveries log, newest first: when, which \
|
|
flow and node, the event and issue, who got it, and whether it went through",
|
|
body = Deliveries),
|
|
(status = 502, description = "the router refused, or its answer did not decode \
|
|
(problem+json)", body = String),
|
|
(status = 503, description = "no swarm queue is configured or connected here, or the \
|
|
router does not answer: it is not running, or it predates the log (problem+json)",
|
|
body = String),
|
|
),
|
|
tag = "notify"
|
|
)]
|
|
pub(crate) async fn get_deliveries(
|
|
State(state): State<AppState>,
|
|
Query(query): Query<DeliveriesQuery>,
|
|
) -> Result<Json<Deliveries>, ProblemDetails> {
|
|
let client = queue(&state).map_err(refused)?;
|
|
let body =
|
|
serde_json::to_vec(&DeliveriesRequest { limit: query.limit }).expect("a request encodes");
|
|
ask(&client, DELIVERIES_SUBJECT, body).await.map(Json)
|
|
}
|
|
|
|
/// The saved flows run over the newest 50 forge events, delivering nothing:
|
|
/// how many events reached each node.
|
|
#[utoipa::path(
|
|
get,
|
|
path = "/api/notify/dry-run",
|
|
responses(
|
|
(status = 200, description = "per flow that would run, the number of the newest 50 \
|
|
events that reached each node", body = DryRun),
|
|
(status = 409, description = "the stored document is not one this build reads \
|
|
(problem+json)", body = String),
|
|
(status = 502, description = "the router refused, or its answer did not decode \
|
|
(problem+json)", body = String),
|
|
(status = 503, description = "no swarm queue is configured or connected here, or the \
|
|
router does not answer: it is not running, or it predates the dry run \
|
|
(problem+json)", body = String),
|
|
(status = 500, description = "the saved flows could not be read (problem+json)",
|
|
body = String),
|
|
),
|
|
tag = "notify"
|
|
)]
|
|
pub(crate) async fn get_dry_run(
|
|
State(state): State<AppState>,
|
|
) -> Result<Json<DryRun>, ProblemDetails> {
|
|
let client = queue(&state).map_err(refused)?;
|
|
let store = open(&client).await.map_err(|e| queue_problem(&e))?;
|
|
let (saved, _) = stored(&store).await.map_err(|e| queue_problem(&e))?;
|
|
let document = match saved {
|
|
Stored::Nothing => Document::default(),
|
|
Stored::Document(doc) => doc,
|
|
Stored::Unreadable(e) => return Err(unreadable(&e)),
|
|
};
|
|
let body = serde_json::to_vec(&DryRunRequest { document }).expect("a request encodes");
|
|
ask(&client, DRY_RUN_SUBJECT, body).await.map(Json)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use futures_util::StreamExt as _;
|
|
use swarm_wire::notify_flows::{self, Document};
|
|
use swarm_wire::router_api::{FlowHits, NodeHits};
|
|
|
|
use super::*;
|
|
use crate::test_nats::TestNats;
|
|
|
|
fn query(limit: Option<usize>) -> Query<DeliveriesQuery> {
|
|
Query(DeliveriesQuery { limit })
|
|
}
|
|
|
|
/// Answer the next request on `subject` with `reply`, handing the request
|
|
/// body back.
|
|
async fn answer(
|
|
client: &async_nats::Client,
|
|
subject: &'static str,
|
|
reply: Vec<u8>,
|
|
) -> tokio::task::JoinHandle<Vec<u8>> {
|
|
let mut requests = client.subscribe(subject).await.expect("subscribed");
|
|
client.flush().await.expect("flushed");
|
|
let client = client.clone();
|
|
tokio::spawn(async move {
|
|
let m = requests.next().await.expect("a request");
|
|
client
|
|
.publish(m.reply.expect("a reply subject"), reply.into())
|
|
.await
|
|
.expect("answered");
|
|
m.payload.to_vec()
|
|
})
|
|
}
|
|
|
|
/// A router that predates the log and the dry run has no subscriber: both
|
|
/// answer 503 with the reason, not 500 and not a hang. The control is the
|
|
/// same two calls with a router answering.
|
|
#[tokio::test]
|
|
async fn without_a_router_that_answers_both_are_unavailable() {
|
|
let nats = TestNats::start();
|
|
let client = nats.client().await;
|
|
let state = crate::agent_limits::tests::state(&client);
|
|
|
|
let deliveries = get_deliveries(State(state.clone()), query(None))
|
|
.await
|
|
.expect_err("nobody answers");
|
|
assert_eq!(deliveries.status, Some(StatusCode::SERVICE_UNAVAILABLE));
|
|
assert!(
|
|
deliveries
|
|
.detail
|
|
.as_deref()
|
|
.unwrap_or_default()
|
|
.contains("older build"),
|
|
"{deliveries:?}"
|
|
);
|
|
let dry = get_dry_run(State(state.clone()))
|
|
.await
|
|
.expect_err("nobody answers");
|
|
assert_eq!(dry.status, Some(StatusCode::SERVICE_UNAVAILABLE));
|
|
assert!(
|
|
dry.detail
|
|
.as_deref()
|
|
.unwrap_or_default()
|
|
.contains("older build"),
|
|
"{dry:?}"
|
|
);
|
|
|
|
// Control: with a router answering, the same calls are 200.
|
|
let rows = answer(&client, DELIVERIES_SUBJECT, br#"{"rows":[]}"#.to_vec()).await;
|
|
let Json(got) = get_deliveries(State(state.clone()), query(None))
|
|
.await
|
|
.expect("answered");
|
|
assert!(got.rows.is_empty());
|
|
rows.await.expect("the router task");
|
|
let hits = DryRun {
|
|
events: 0,
|
|
flows: Vec::new(),
|
|
};
|
|
let dry_run = answer(&client, DRY_RUN_SUBJECT, serde_json::to_vec(&hits).unwrap()).await;
|
|
let Json(got) = get_dry_run(State(state)).await.expect("answered");
|
|
assert_eq!(got, hits);
|
|
dry_run.await.expect("the router task");
|
|
}
|
|
|
|
/// No queue on this host is 503 too.
|
|
#[tokio::test]
|
|
async fn without_a_queue_both_are_unavailable() {
|
|
let (state, _) = crate::routes::tests::state_with_roster();
|
|
let a = get_deliveries(State(state.clone()), query(None))
|
|
.await
|
|
.expect_err("no queue");
|
|
let b = get_dry_run(State(state)).await.expect_err("no queue");
|
|
assert_eq!(a.status, Some(StatusCode::SERVICE_UNAVAILABLE));
|
|
assert_eq!(b.status, Some(StatusCode::SERVICE_UNAVAILABLE));
|
|
}
|
|
|
|
/// The limit reaches the router, and the dry run sends the saved document.
|
|
#[tokio::test]
|
|
async fn the_limit_and_the_saved_document_reach_the_router() {
|
|
let nats = TestNats::start();
|
|
let client = nats.client().await;
|
|
let state = crate::agent_limits::tests::state(&client);
|
|
|
|
let asked = answer(&client, DELIVERIES_SUBJECT, br#"{"rows":[]}"#.to_vec()).await;
|
|
let _ = get_deliveries(State(state.clone()), query(Some(7)))
|
|
.await
|
|
.expect("answered");
|
|
let request: DeliveriesRequest =
|
|
serde_json::from_slice(&asked.await.expect("task")).expect("a request");
|
|
assert_eq!(request.limit, Some(7));
|
|
|
|
// Nothing saved: the default document.
|
|
let reply = DryRun {
|
|
events: 3,
|
|
flows: vec![FlowHits {
|
|
flow: "assigned".to_owned(),
|
|
nodes: vec![NodeHits {
|
|
node: "source".to_owned(),
|
|
hits: 3,
|
|
}],
|
|
}],
|
|
};
|
|
let asked = answer(
|
|
&client,
|
|
DRY_RUN_SUBJECT,
|
|
serde_json::to_vec(&reply).unwrap(),
|
|
)
|
|
.await;
|
|
let Json(got) = get_dry_run(State(state.clone())).await.expect("answered");
|
|
assert_eq!(got, reply);
|
|
let sent: DryRunRequest =
|
|
serde_json::from_slice(&asked.await.expect("task")).expect("a request");
|
|
assert_eq!(sent.document, Document::default());
|
|
|
|
// A saved document: the router gets that one.
|
|
let store = open(&client).await.expect("bucket");
|
|
let saved = Document {
|
|
disabled_builtins: vec!["closed".to_owned()],
|
|
..Document::default()
|
|
};
|
|
store
|
|
.put(
|
|
notify_flows::KEY,
|
|
serde_json::to_vec(&saved).unwrap().into(),
|
|
)
|
|
.await
|
|
.expect("seed");
|
|
let asked = answer(
|
|
&client,
|
|
DRY_RUN_SUBJECT,
|
|
serde_json::to_vec(&reply).unwrap(),
|
|
)
|
|
.await;
|
|
let _ = get_dry_run(State(state)).await.expect("answered");
|
|
let sent: DryRunRequest =
|
|
serde_json::from_slice(&asked.await.expect("task")).expect("a request");
|
|
assert_eq!(sent.document, saved);
|
|
}
|
|
|
|
/// A refusal from the router is 502 with its reason; an unreadable saved
|
|
/// document is 409 and never reaches the router.
|
|
#[tokio::test]
|
|
async fn a_refusal_is_502_and_an_unreadable_document_is_409() {
|
|
let nats = TestNats::start();
|
|
let client = nats.client().await;
|
|
let state = crate::agent_limits::tests::state(&client);
|
|
|
|
let router = answer(
|
|
&client,
|
|
DRY_RUN_SUBJECT,
|
|
br#"{"error":"no events"}"#.to_vec(),
|
|
)
|
|
.await;
|
|
let refused = get_dry_run(State(state.clone()))
|
|
.await
|
|
.expect_err("refused");
|
|
assert_eq!(refused.status, Some(StatusCode::BAD_GATEWAY));
|
|
assert!(
|
|
refused
|
|
.detail
|
|
.as_deref()
|
|
.unwrap_or_default()
|
|
.contains("no events")
|
|
);
|
|
router.await.expect("the router task");
|
|
|
|
let store = open(&client).await.expect("bucket");
|
|
store
|
|
.put(
|
|
notify_flows::KEY,
|
|
br#"{"version":2,"flows":[]}"#.to_vec().into(),
|
|
)
|
|
.await
|
|
.expect("seed");
|
|
let unreadable = get_dry_run(State(state)).await.expect_err("version 2");
|
|
assert_eq!(unreadable.status, Some(StatusCode::CONFLICT));
|
|
}
|
|
}
|