AstrBot-Desktop/crates/mock-gateway/src/state.rs

251 行
8 KiB
Rust

use std::{
collections::{HashSet, VecDeque},
sync::atomic::{AtomicU8, AtomicU64, Ordering},
};
use desktop_protocol::{
AcceptedMessage, CapabilityLimits, EventMetadata, GatewayEvent, GatewayEventBody,
PROTOCOL_VERSION, ServerCapabilities,
};
use tokio::sync::{Mutex, RwLock, broadcast, watch};
use uuid::Uuid;
use crate::{AuthMode, MockGatewayConfig, MockInstanceKind, MockScenario};
pub(crate) const FIXED_TIMESTAMP: &str = "2030-01-01T00:00:00Z";
struct SessionTokens {
access: String,
refresh: String,
}
pub(crate) struct AppState {
pub(crate) instance: MockInstanceKind,
pub(crate) server_instance_id: String,
pub(crate) display_name: String,
pub(crate) capabilities: ServerCapabilities,
replay_capacity: usize,
sequence: AtomicU64,
request_sequence: AtomicU64,
auth_mode: AtomicU8,
tokens: RwLock<Option<SessionTokens>>,
event_sender: broadcast::Sender<GatewayEvent>,
disconnect_sender: watch::Sender<u64>,
replay_buffer: Mutex<VecDeque<GatewayEvent>>,
acknowledged_event_ids: Mutex<HashSet<String>>,
}
impl AppState {
pub(crate) fn new(config: &MockGatewayConfig) -> Self {
let (event_sender, _) = broadcast::channel(config.replay_capacity.max(16));
let (disconnect_sender, _) = watch::channel(0_u64);
let initial_auth_mode = if config.scenario == MockScenario::AuthReject {
AuthMode::Reject
} else {
AuthMode::Accept
};
Self {
instance: config.instance,
server_instance_id: config.instance.server_instance_id(),
display_name: config.instance.display_name().to_owned(),
capabilities: capabilities_for(config.instance),
replay_capacity: config.replay_capacity.max(1),
sequence: AtomicU64::new(0),
request_sequence: AtomicU64::new(0),
auth_mode: AtomicU8::new(auth_mode_value(initial_auth_mode)),
tokens: RwLock::new(None),
event_sender,
disconnect_sender,
replay_buffer: Mutex::new(VecDeque::with_capacity(config.replay_capacity.max(1))),
acknowledged_event_ids: Mutex::new(HashSet::new()),
}
}
pub(crate) fn set_auth_mode(&self, mode: AuthMode) {
self.auth_mode
.store(auth_mode_value(mode), Ordering::Release);
}
pub(crate) fn auth_is_rejected(&self) -> bool {
self.auth_mode.load(Ordering::Acquire) == auth_mode_value(AuthMode::Reject)
}
pub(crate) async fn issue_tokens(&self) -> (String, String) {
let tokens = SessionTokens {
access: format!("mock-session-{}", Uuid::new_v4()),
refresh: format!("mock-refresh-{}", Uuid::new_v4()),
};
let response = (tokens.access.clone(), tokens.refresh.clone());
*self.tokens.write().await = Some(tokens);
response
}
pub(crate) async fn refresh_tokens(&self, presented_refresh: &str) -> Option<(String, String)> {
let matches = self
.tokens
.read()
.await
.as_ref()
.is_some_and(|tokens| tokens.refresh == presented_refresh);
if matches && !self.auth_is_rejected() {
Some(self.issue_tokens().await)
} else {
None
}
}
pub(crate) async fn is_authorized(&self, presented_access: Option<&str>) -> bool {
if self.auth_is_rejected() {
return false;
}
let Some(presented_access) = presented_access else {
return false;
};
self.tokens
.read()
.await
.as_ref()
.is_some_and(|tokens| tokens.access == presented_access)
}
pub(crate) fn create_event(
&self,
body: GatewayEventBody,
request_id: Option<String>,
conversation_id: Option<String>,
message_id: Option<String>,
) -> GatewayEvent {
let sequence = self.sequence.fetch_add(1, Ordering::Relaxed) + 1;
let mut metadata = EventMetadata::new(
format!("{}-event-{sequence:06}", self.instance.slug()),
self.server_instance_id.clone(),
FIXED_TIMESTAMP,
sequence,
);
metadata.request_id = request_id;
metadata.conversation_id = conversation_id;
metadata.message_id = message_id;
GatewayEvent::new(metadata, body)
}
pub(crate) async fn publish(&self, event: GatewayEvent) {
let mut replay = self.replay_buffer.lock().await;
replay.push_back(event.clone());
while replay.len() > self.replay_capacity {
replay.pop_front();
}
drop(replay);
let _ = self.event_sender.send(event);
}
pub(crate) fn broadcast_duplicate(&self, event: &GatewayEvent) {
let _ = self.event_sender.send(event.clone());
}
pub(crate) async fn replay_event(&self, event_id: &str) -> bool {
let event = self
.replay_buffer
.lock()
.await
.iter()
.find(|event| event.metadata.event_id == event_id)
.cloned();
if let Some(event) = event {
self.broadcast_duplicate(&event);
true
} else {
false
}
}
pub(crate) async fn events_after(&self, last_event_id: Option<&str>) -> Vec<GatewayEvent> {
let Some(last_event_id) = last_event_id else {
return Vec::new();
};
let replay = self.replay_buffer.lock().await;
let Some(index) = replay
.iter()
.position(|event| event.metadata.event_id == last_event_id)
else {
return Vec::new();
};
replay.iter().skip(index + 1).cloned().collect()
}
pub(crate) fn subscribe_events(&self) -> broadcast::Receiver<GatewayEvent> {
self.event_sender.subscribe()
}
pub(crate) fn subscribe_disconnects(&self) -> watch::Receiver<u64> {
self.disconnect_sender.subscribe()
}
pub(crate) fn disconnect_streams(&self) {
let next = self.disconnect_sender.borrow().wrapping_add(1);
let _ = self.disconnect_sender.send(next);
}
pub(crate) async fn acknowledge(&self, event_id: String) {
self.acknowledged_event_ids.lock().await.insert(event_id);
}
pub(crate) async fn acknowledged_event_ids(&self) -> Vec<String> {
let mut values: Vec<_> = self
.acknowledged_event_ids
.lock()
.await
.iter()
.cloned()
.collect();
values.sort();
values
}
pub(crate) fn accept_message(&self) -> AcceptedMessage {
let sequence = self.request_sequence.fetch_add(1, Ordering::Relaxed) + 1;
AcceptedMessage {
request_id: format!("{}-request-{sequence:06}", self.instance.slug()),
message_id: format!("{}-message-{sequence:06}", self.instance.slug()),
accepted_at: FIXED_TIMESTAMP.to_owned(),
}
}
}
fn auth_mode_value(mode: AuthMode) -> u8 {
match mode {
AuthMode::Accept => 0,
AuthMode::Reject => 1,
}
}
fn capabilities_for(instance: MockInstanceKind) -> ServerCapabilities {
let mut features = vec![
"auth.refresh".to_owned(),
"chat.text".to_owned(),
"events.ack".to_owned(),
"events.sse".to_owned(),
];
let local_action_tools = match instance {
MockInstanceKind::Companion => {
features.push("messages.proactive".to_owned());
Vec::new()
}
MockInstanceKind::Operations => {
features.push("local-actions.proposals".to_owned());
features.push("diagnostics.readonly".to_owned());
vec!["query_recent_event_logs".to_owned()]
}
};
ServerCapabilities {
protocol_versions: vec![PROTOCOL_VERSION.to_owned()],
features,
local_action_tools,
limits: CapabilityLimits {
max_event_bytes: 262_144,
max_message_bytes: 65_536,
replay_window_events: 256,
max_active_connections: 2,
},
}
}