aboutsummaryrefslogtreecommitdiffstats
path: root/src/api/events.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/api/events.rs')
-rw-r--r--src/api/events.rs266
1 files changed, 266 insertions, 0 deletions
diff --git a/src/api/events.rs b/src/api/events.rs
new file mode 100644
index 0000000..3291f02
--- /dev/null
+++ b/src/api/events.rs
@@ -0,0 +1,266 @@
+//! A swarm holding a store at a node's API (`docs/store.md`, Members): whoever its operator
+//! lets in may have it put events, whoever signed them; it shows its store (its ID, its
+//! checkpoint and its heads), an event it holds, what its fold reads from them, and what
+//! it refused; and its operator has it drop what it took, and take it back.
+
+use axum::{
+ Extension, Json, Router,
+ body::Bytes,
+ extract::{Path, State},
+ http::{StatusCode, header::CONTENT_TYPE},
+ response::{IntoResponse, Response},
+ routing::{get, post},
+};
+use serde::Deserialize;
+use serde_json::{Value as JsonValue, json};
+
+use super::auth::AuthenticatedUser;
+use super::{ApiError, error_response, store_status};
+use crate::document::events;
+use crate::document::typed::{TimestampFormat, Val};
+use crate::document::{ScalarValue, store};
+use crate::federation::fold::Federation;
+use crate::federation::jcs::Json as Jcs;
+use crate::federation::store::Id;
+use crate::federation::store::memory::{Offered, Refusal, Store};
+use crate::state::AppState;
+
+pub(super) fn router() -> Router<AppState> {
+ Router::new()
+ .route("/events", get(summary).post(put))
+ .route("/events/counts", get(counts))
+ .route("/events/refused", get(refused))
+ .route("/events/{id}", get(event))
+ .route("/admin/events/drop", post(drop_taken))
+ .route("/admin/events/allow", post(allow))
+}
+
+/// The answer while the node holds no store.
+fn no_store() -> Response {
+ error_response(
+ StatusCode::NOT_FOUND,
+ "this node holds no store: its swarm holds none, or it hasn't read it yet",
+ None,
+ )
+}
+
+/// `f` of the node's store, as JSON; `no_store` without one.
+fn with_store(state: &AppState, f: impl FnOnce(&Store<Federation>) -> JsonValue) -> Response {
+ match state.holding.with(f) {
+ Some(body) => Json(body).into_response(),
+ None => no_store(),
+ }
+}
+
+fn ids(ids: impl IntoIterator<Item = Id>) -> Vec<String> {
+ ids.into_iter().map(|id| id.to_string()).collect()
+}
+
+/// A JCS value as plain JSON: its integers fit, by what an event may hold.
+fn plain(json: &Jcs) -> JsonValue {
+ serde_json::from_slice(&json.bytes()).unwrap_or(JsonValue::Null)
+}
+
+/// Why the store refused an event, said.
+fn why(refusal: &Refusal) -> String {
+ match refusal {
+ Refusal::None => "none of the federation's events, or larger than it allows".to_owned(),
+ Refusal::Judged(why) => why.0.clone(),
+ Refusal::BuiltOn(id) => format!("it builds on {id}, refused"),
+ Refusal::NotAbove => "it isn't above the checkpoint's heads".to_owned(),
+ Refusal::Own => {
+ "its history takes it, but this node doesn't, by what it took before".to_owned()
+ }
+ Refusal::Dropped => "this node's operator had it drop it".to_owned(),
+ }
+}
+
+/// `GET /events`: the store's ID, its checkpoint's, its heads, and how many events it
+/// took after its checkpoint.
+async fn summary(State(state): State<AppState>) -> Response {
+ with_store(&state, |store| {
+ json!({
+ "store": store.id().to_string(),
+ "checkpoint": Id::of(store.checkpoint()).to_string(),
+ "heads": ids(store.heads()),
+ "taken": store.taken().len(),
+ })
+ })
+}
+
+/// `GET /events/{id}`: an event the store holds, taken or kept by its checkpoint, or its
+/// checkpoint, as its bytes.
+async fn event(State(state): State<AppState>, Path(id): Path<String>) -> Response {
+ let Some(id) = Id::from_hex(&id) else {
+ return error_response(StatusCode::BAD_REQUEST, "not an event's ID", None);
+ };
+ let bytes = state.holding.with(|store| {
+ store
+ .get(&id)
+ .map(<[u8]>::to_vec)
+ .or_else(|| (Id::of(store.checkpoint()) == id).then(|| store.checkpoint().to_vec()))
+ });
+ match bytes {
+ None => no_store(),
+ Some(None) => error_response(StatusCode::NOT_FOUND, "no event this store holds", None),
+ Some(Some(bytes)) => ([(CONTENT_TYPE, "application/json")], bytes).into_response(),
+ }
+}
+
+/// `GET /events/counts`: what counts, as the store reads now: the current version, each
+/// party's keys and nodes, the values at places, and the members.
+async fn counts(State(state): State<AppState>) -> Response {
+ with_store(&state, |store| {
+ let read = store.state();
+ let current = read.current();
+ let parties: serde_json::Map<String, JsonValue> = current
+ .parties
+ .keys()
+ .map(|party| {
+ (
+ party.clone(),
+ json!({
+ "keys": read.keys_of(party, current),
+ "nodes": read.nodes_of(party, current),
+ }),
+ )
+ })
+ .collect();
+ let values: serde_json::Map<String, JsonValue> = read
+ .values()
+ .iter()
+ .map(|(path, value)| (path.clone(), plain(value)))
+ .collect();
+ json!({
+ "version": {
+ "number": current.number,
+ "hash": current.hash.to_string(),
+ "version": plain(&current.json),
+ },
+ "parties": parties,
+ "values": values,
+ "members": read.members(),
+ })
+ })
+}
+
+/// `GET /events/refused`: what the store refused: of its own, by what it took before (the
+/// federation: a version changing another than the one it reads), apart; what its
+/// operator had it drop; and the rest, each with why.
+async fn refused(State(state): State<AppState>) -> Response {
+ with_store(&state, |store| {
+ let (own, dropped) = store.own();
+ let mut rest: Vec<(&Id, &Refusal)> = store
+ .refused()
+ .filter(|(_, refusal)| !matches!(refusal, Refusal::Own | Refusal::Dropped))
+ .collect();
+ rest.sort_unstable_by_key(|(id, _)| **id);
+ json!({
+ "own": ids(own),
+ "dropped": ids(dropped),
+ "refused": rest
+ .into_iter()
+ .map(|(id, refusal)| json!({"id": id.to_string(), "why": why(refusal)}))
+ .collect::<Vec<_>>(),
+ })
+ })
+}
+
+/// `POST /events`: puts an event, the request's body, whoever signed it: offered to the
+/// store, and written into the document at its ID unless the store refuses it. Taken,
+/// held already, or waiting for what it builds on.
+async fn put(
+ State(state): State<AppState>,
+ Extension(AuthenticatedUser(user)): Extension<AuthenticatedUser>,
+ body: Bytes,
+) -> Response {
+ let bytes = body.to_vec();
+ let id = Id::of(&bytes);
+ let became = match state.holding.offer(bytes.clone()) {
+ None => return no_store(),
+ Some(Offered::Refused(refusal)) => {
+ return error_response(
+ StatusCode::UNPROCESSABLE_ENTITY,
+ "the store refuses it",
+ Some(json!({"id": id.to_string(), "why": why(&refusal)})),
+ );
+ }
+ Some(Offered::Taken(_)) => "taken",
+ Some(Offered::Held) => "held",
+ Some(Offered::Waiting) => "waiting",
+ };
+ let written = state
+ .mutate_doc_for(
+ Some(user),
+ crate::document::signatures::Sign::Protocol,
+ move |doc| {
+ if events::bytes(doc, &id).is_none() {
+ store::write_val_path(
+ doc,
+ &events::event(&id),
+ &Val::Scalar(ScalarValue::Bytes(bytes)),
+ store::Writing::sticky(TimestampFormat::default()),
+ )?;
+ }
+ Ok::<(), store::StoreError>(())
+ },
+ )
+ .await;
+ match written {
+ Ok(_) => Json(json!({"id": id.to_string(), "event": became})).into_response(),
+ Err(error) => store_status(error, "Failed to put an event").into_response(),
+ }
+}
+
+/// The events an operator names.
+#[derive(Deserialize)]
+struct Named {
+ ids: Vec<String>,
+}
+
+impl Named {
+ fn ids(&self) -> Result<Vec<Id>, ApiError> {
+ self.ids
+ .iter()
+ .map(|id| {
+ Id::from_hex(id).ok_or_else(|| {
+ ApiError(
+ StatusCode::BAD_REQUEST,
+ Some(format!("{id:?} isn't an event's ID")),
+ )
+ })
+ })
+ .collect()
+ }
+}
+
+/// `POST /admin/events/drop`: drops events the store took after its checkpoint, with
+/// everything built on them, as the operator has the node do: it refuses them from then
+/// on, from whoever brings them, and keeps so across restarts (`--store-file`). What it
+/// dropped, in the order taken.
+async fn drop_taken(State(state): State<AppState>, Json(named): Json<Named>) -> Response {
+ let named = match named.ids() {
+ Ok(ids) => ids,
+ Err(error) => return error.into_response(),
+ };
+ match state.holding.drop_taken(&named) {
+ None => no_store(),
+ Some(Err(why)) => error_response(StatusCode::UNPROCESSABLE_ENTITY, why.0, None),
+ Some(Ok(dropped)) => Json(json!({"dropped": ids(dropped)})).into_response(),
+ }
+}
+
+/// `POST /admin/events/allow`: takes back what the node refused of its own, or dropped,
+/// among the events named, and what was refused for building on them: taken again where
+/// the store takes them, as it reads its document again.
+async fn allow(State(state): State<AppState>, Json(named): Json<Named>) -> Response {
+ let named = match named.ids() {
+ Ok(ids) => ids,
+ Err(error) => return error.into_response(),
+ };
+ if state.holding.allow(&named) {
+ StatusCode::NO_CONTENT.into_response()
+ } else {
+ no_store()
+ }
+}