Skip to main content

che_rest/
channels.rs

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}