World's first open-source enterprise world model.
Rust agent-memorybitemporalgraphragknowledge-baseknowledge-graphllmontologypgvectorpostgresqlragrustself-hostedsemantic-searchtemporal-knowledge-graphworld-model
//! 告警中心(0005)。**跨库**:一个顶栏面板,不挂在某个 KB 下面。
//!
//! 可见性不在这里判——它在 `utopia_store::alerts` 的那几条 SQL 里判且只判一次。
//! 路由层只负责取当前用户。
use axum::extract::{Query, State};
use axum::response::sse::{Event, KeepAlive, Sse};
use axum::Json;
use chrono::{DateTime, Utc};
use futures_util::Stream;
use serde::{Deserialize, Serialize};
use serde_json::json;
use std::convert::Infallible;
use tokio::sync::broadcast;
use uuid::Uuid;
use crate::auth::AuthUser;
use crate::error::ApiResult;
use crate::state::{AppEvent, AppState};
/// 一页几组。弹窗里放得下的量——再多就该翻页,而不是让人滚一屏。
const PAGE: i64 = 8;
/// 一页最多能要多少:防的是有人把 limit 写成 100000 让服务端去数全表
const MAX_PAGE: i64 = 50;
#[derive(Deserialize)]
pub struct ListQuery {
/// 搜库名、对象详情、kind 代号。**搜不到界面上那句标题**——
/// 措辞在客户端,服务端没有它(见 store 里 SEARCH 的注释)
#[serde(default)]
pub q: Option<String>,
#[serde(default)]
pub limit: Option<i64>,
#[serde(default)]
pub offset: Option<i64>,
}
/// 一组连着的同类故障。折叠是**读**出来的,存储那边仍是一次故障一行。
#[derive(Serialize)]
pub struct GroupView {
pub kb_id: Option<Uuid>,
pub kb_name: Option<String>,
pub kind: String,
pub severity: String,
pub count: i64,
pub unread: i64,
pub latest_at: DateTime<Utc>,
/// 跟 `latest_at` 一起圈出这一组,标已读时原样发回来
pub earliest_at: DateTime<Utc>,
/// 明细,最多几条,新的在前
pub lines: Vec<serde_json::Value>,
}
#[derive(Serialize)]
pub struct ListResponse {
pub items: Vec<GroupView>,
/// 总**组**数——翻页控件数的是组,不是行
pub total: i64,
}
pub async fn list(
State(state): State<AppState>,
AuthUser(user): AuthUser,
Query(q): Query<ListQuery>,
) -> ApiResult<Json<ListResponse>> {
let limit = q.limit.unwrap_or(PAGE).clamp(1, MAX_PAGE);
let offset = q.offset.unwrap_or(0).max(0);
let page = utopia_store::alerts::list_groups(&state.pool, &user, q.q.as_deref(), limit, offset)
.await?;
Ok(Json(ListResponse {
items: page
.items
.into_iter()
.map(|g| GroupView {
kb_id: g.kb_id,
kb_name: g.kb_name,
kind: g.kind,
severity: g.severity,
count: g.count,
unread: g.unread,
latest_at: g.latest_at,
earliest_at: g.earliest_at,
lines: g.lines,
})
.collect(),
total: page.total,
}))
}
/// 角标。单独一条路由而不是从列表里数:这个每开一页都要。
pub async fn unread(
State(state): State<AppState>,
AuthUser(user): AuthUser,
) -> ApiResult<Json<serde_json::Value>> {
let n = utopia_store::alerts::unread_count(&state.pool, &user).await?;
Ok(Json(json!({ "unread": n })))
}
#[derive(Deserialize)]
pub struct ReadGroupBody {
pub kb_id: Option<Uuid>,
pub kind: String,
/// 组的时间区间,原样来自列表返回的 `earliest_at` / `latest_at`
pub from: DateTime<Utc>,
pub to: DateTime<Utc>,
}
/// 把一整组标已读。**逐人**——读过不等于问题没了,别人的未读不受影响。
///
/// 按时间区间圈而不是发 id 列表:一组可能有几百条。可见性在 store 里照查,
/// 所以猜一个 kind 也标不掉自己看不见的东西。
pub async fn mark_group_read(
State(state): State<AppState>,
AuthUser(user): AuthUser,
Json(b): Json<ReadGroupBody>,
) -> ApiResult<Json<serde_json::Value>> {
let n =
utopia_store::alerts::mark_group_read(&state.pool, &user, b.kb_id, &b.kind, b.from, b.to)
.await?;
Ok(Json(json!({ "marked": n })))
}
/// 全部已读。
pub async fn mark_all_read(
State(state): State<AppState>,
AuthUser(user): AuthUser,
) -> ApiResult<Json<serde_json::Value>> {
let n = utopia_store::alerts::mark_all_read(&state.pool, &user).await?;
Ok(Json(json!({ "marked": n })))
}
/// 全局事件流。KB 那条是 `/kbs/{id}/events`,按库过滤;角标是跨库的,
/// 挂不上去。
///
/// **这里不做任何权限过滤**:事件不带数据,收到的人一律回头重取列表,
/// 而列表那条查询会把不该看的挡掉。代价是没权限的人也被叫醒一次,
/// 换来的是推送这条路上一行权限逻辑都没有——不会出现"推送判得比列表松"。
pub async fn stream(
State(state): State<AppState>,
AuthUser(_user): AuthUser,
) -> ApiResult<Sse<impl Stream<Item = Result<Event, Infallible>>>> {
Ok(alert_event_stream(state.events.subscribe()))
}
fn alert_event_stream(
mut rx: broadcast::Receiver<AppEvent>,
) -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
let stream = async_stream::stream! {
loop {
match rx.recv().await {
Ok(ev) if ev.kind == "alert" => {
yield Ok(Event::default().event("alert").data("{}"));
}
Ok(_) => continue,
// 唯一的告警可能已被其他类型的通知挤掉。结束响应,让 EventSource
// 重连后通过 onRecover 补刷,即使之后再没有新告警。
Err(broadcast::error::RecvError::Lagged(_)) => return,
Err(broadcast::error::RecvError::Closed) => return,
}
}
};
Sse::new(stream).keep_alive(KeepAlive::default())
}
#[cfg(test)]
mod tests {
use super::*;
use axum::response::IntoResponse;
use axum::{routing::get, Router};
use futures_util::{FutureExt, StreamExt};
use std::time::Duration;
#[tokio::test]
async fn lagged_alert_stream_ends_when_non_alert_events_displace_its_only_alert() {
let (sender, _) = broadcast::channel(256);
let route_sender = sender.clone();
let app = Router::new().route(
"/events",
get(move || {
let sender = route_sender.clone();
async move {
let receiver = sender.subscribe();
sender
.send(AppEvent {
kb_id: None,
kind: "alert",
document_id: None,
})
.unwrap();
for _ in 0..257 {
sender
.send(AppEvent {
kb_id: Some(Uuid::now_v7()),
kind: "document",
document_id: None,
})
.unwrap();
}
alert_event_stream(receiver)
}
}),
);
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let address = listener.local_addr().unwrap();
let server = tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
let client = reqwest::Client::builder().no_proxy().build().unwrap();
let request = async {
let response = client
.get(format!("http://{address}/events"))
.send()
.await
.unwrap();
assert_eq!(response.status(), reqwest::StatusCode::OK);
assert_eq!(response.headers()["content-type"], "text/event-stream");
response.text().await.unwrap()
};
// 保留 sender:被过滤的剩余事件不能让漏掉告警的连接一直开着。
let result = tokio::time::timeout(Duration::from_secs(2), request).await;
server.abort();
assert!(result
.expect("a lagged alert SSE response must end")
.is_empty());
}
#[tokio::test]
async fn alert_stream_filters_non_alerts_and_never_exposes_alert_details() {
let (sender, receiver) = broadcast::channel(256);
let response = alert_event_stream(receiver).into_response();
assert_eq!(response.headers()["content-type"], "text/event-stream");
let mut body = response.into_body().into_data_stream();
assert!(body.next().now_or_never().is_none());
sender
.send(AppEvent {
kb_id: Some(Uuid::now_v7()),
kind: "document",
document_id: None,
})
.unwrap();
assert!(body.next().now_or_never().is_none());
sender
.send(AppEvent {
kb_id: Some(Uuid::now_v7()),
kind: "alert",
document_id: Some(Uuid::now_v7()),
})
.unwrap();
let frame = body.next().await.unwrap().unwrap();
assert_eq!(frame.as_ref(), b"event: alert\ndata: {}\n\n");
assert!(body.next().now_or_never().is_none());
drop(sender);
assert!(body.next().await.is_none());
}
#[tokio::test]
async fn dropping_an_alert_response_releases_its_subscription() {
let (sender, receiver) = broadcast::channel(256);
let response = alert_event_stream(receiver).into_response();
assert_eq!(sender.receiver_count(), 1);
drop(response);
assert_eq!(sender.receiver_count(), 0);
}
}