250 行
8 KiB
Rust
250 行
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,
|
|
},
|
|
}
|
|
}
|