1use std::collections::HashMap;
2
3use axum::{
4 Extension, Router,
5 extract::ws::{Message, WebSocket, WebSocketUpgrade},
6 response::IntoResponse,
7 routing::get,
8};
9use futures_util::{SinkExt, StreamExt};
10use serde::Deserialize;
11use serde_json::{Value, json};
12use tokio::{sync::mpsc, task::JoinHandle};
13
14use crate::{
15 AppModule, AppState, ModuleContext,
16 auth::{CurrentPrincipal, CurrentUser},
17 signals::{SignalError, error_event, signal_event, valid_signal_name},
18};
19
20pub type Channels = crate::signals::SignalBus;
21const MAX_SUBSCRIPTIONS_PER_SOCKET: usize = 32;
22
23pub fn module() -> ChannelsModule {
24 ChannelsModule
25}
26
27#[derive(Clone, Copy)]
28pub struct ChannelsModule;
29
30impl AppModule for ChannelsModule {
31 fn name(&self) -> &'static str {
32 "channels"
33 }
34
35 fn schema(&self) -> che_orm::SchemaSet {
36 che_orm::SchemaSet::new()
37 }
38
39 fn init(&self, context: &mut ModuleContext) {
40 context.route(Router::new().route("/ws/", get(websocket)));
41 }
42}
43
44#[derive(Debug, Deserialize)]
45#[serde(tag = "action", rename_all = "snake_case")]
46enum ClientFrame {
47 Subscribe {
48 signal: Option<String>,
49 channel: Option<String>,
50 },
51 Unsubscribe {
52 signal: Option<String>,
53 channel: Option<String>,
54 },
55}
56
57async fn websocket(
58 Extension(state): Extension<AppState>,
59 current: Option<Extension<CurrentPrincipal>>,
60 ws: WebSocketUpgrade,
61) -> impl IntoResponse {
62 ws.on_upgrade(move |socket| {
63 handle_socket(
64 state,
65 current.map(|current| current.0.auth_user().clone()),
66 socket,
67 )
68 })
69}
70
71async fn handle_socket(state: AppState, user: Option<CurrentUser>, socket: WebSocket) {
72 let (mut sender, mut receiver) = socket.split();
73 let (events_tx, mut events_rx) = mpsc::channel::<Value>(64);
74 let mut subscriptions: HashMap<String, JoinHandle<()>> = HashMap::new();
75
76 loop {
77 tokio::select! {
78 maybe_event = events_rx.recv() => {
79 let Some(event) = maybe_event else { break; };
80 if sender.send(Message::Text(event.to_string().into())).await.is_err() {
81 break;
82 }
83 }
84 maybe_message = receiver.next() => {
85 let Some(Ok(message)) = maybe_message else { break; };
86 match message {
87 Message::Text(text) => handle_text(&state, user.as_ref(), &events_tx, &mut subscriptions, &text).await,
88 Message::Close(_) => break,
89 _ => {}
90 }
91 }
92 }
93 }
94
95 for task in subscriptions.into_values() {
96 task.abort();
97 }
98}
99
100async fn handle_text(
101 state: &AppState,
102 user: Option<&CurrentUser>,
103 events_tx: &mpsc::Sender<Value>,
104 subscriptions: &mut HashMap<String, JoinHandle<()>>,
105 text: &str,
106) {
107 let frame = match serde_json::from_str::<ClientFrame>(text) {
108 Ok(frame) => frame,
109 Err(error) => {
110 send_error(
111 events_tx,
112 "invalid_frame",
113 &format!("invalid JSON frame: {error}"),
114 )
115 .await;
116 return;
117 }
118 };
119
120 match frame {
121 ClientFrame::Subscribe { signal, channel } => {
122 let Some(signal) = signal.or(channel) else {
123 send_error(events_tx, "invalid_frame", "subscribe requires signal").await;
124 return;
125 };
126 subscribe(state, user, events_tx, subscriptions, signal).await;
127 }
128 ClientFrame::Unsubscribe { signal, channel } => {
129 let Some(signal) = signal.or(channel) else {
130 send_error(events_tx, "invalid_frame", "unsubscribe requires signal").await;
131 return;
132 };
133 unsubscribe(events_tx, subscriptions, &signal).await;
134 }
135 }
136}
137
138async fn subscribe(
139 state: &AppState,
140 user: Option<&CurrentUser>,
141 events_tx: &mpsc::Sender<Value>,
142 subscriptions: &mut HashMap<String, JoinHandle<()>>,
143 signal: String,
144) {
145 if !valid_signal_name(&signal) {
146 send_error(events_tx, "invalid_signal", "invalid signal name").await;
147 return;
148 }
149 if let Err(error) = state.signals().check_access(&signal, user) {
150 send_signal_error(events_tx, error).await;
151 return;
152 }
153 if subscriptions.contains_key(&signal) {
154 let _ = events_tx
155 .send(json!({"type": "subscribed", "signal": signal}))
156 .await;
157 return;
158 }
159 if subscriptions.len() >= MAX_SUBSCRIPTIONS_PER_SOCKET {
160 send_error(
161 events_tx,
162 "too_many_subscriptions",
163 "too many subscriptions",
164 )
165 .await;
166 return;
167 }
168
169 let mut receiver = state.signals().subscribe(&signal);
170 let tx = events_tx.clone();
171 let relay_signal = signal.clone();
172 let task = tokio::spawn(async move {
173 loop {
174 match receiver.recv().await {
175 Ok(payload) => {
176 if tx
177 .send(json!(signal_event(relay_signal.clone(), payload)))
178 .await
179 .is_err()
180 {
181 break;
182 }
183 }
184 Err(tokio::sync::broadcast::error::RecvError::Lagged(count)) => {
185 let _ = tx
186 .send(json!({"type": "error", "code": "lagged", "detail": format!("dropped {count} signal event(s)"), "signal": relay_signal}))
187 .await;
188 }
189 Err(tokio::sync::broadcast::error::RecvError::Closed) => break,
190 }
191 }
192 });
193 subscriptions.insert(signal.clone(), task);
194 let _ = events_tx
195 .send(json!({"type": "subscribed", "signal": signal}))
196 .await;
197}
198
199async fn unsubscribe(
200 events_tx: &mpsc::Sender<Value>,
201 subscriptions: &mut HashMap<String, JoinHandle<()>>,
202 signal: &str,
203) {
204 if let Some(task) = subscriptions.remove(signal) {
205 task.abort();
206 }
207 let _ = events_tx
208 .send(json!({"type": "unsubscribed", "signal": signal}))
209 .await;
210}
211
212async fn send_signal_error(events_tx: &mpsc::Sender<Value>, error: SignalError) {
213 send_error(events_tx, error.code(), error.detail()).await;
214}
215
216async fn send_error(events_tx: &mpsc::Sender<Value>, code: &str, detail: &str) {
217 let _ = events_tx.send(error_event(code, detail)).await;
218}