1use crate::sparql_ast::*;
6use crate::sparql_executor::*;
7use crate::sparql_library::serialisers::sparql_results::ResultFormatter;
8use crate::sparql_parser;
9use crate::sparql_planner::*;
10use crate::NQuin;
11
12use std::collections::HashMap;
13
14#[repr(C)]
16#[derive(Debug, Clone, Copy, PartialEq, Eq)]
17pub enum WebSocketMessageType {
18 Query,
19 Subscribe,
20 Unsubscribe,
21 Result,
22 Error,
23 Close,
24}
25
26#[repr(C)]
28#[derive(Debug, Clone, Copy)]
29pub struct WebSocketMessage {
30 pub msg_type: WebSocketMessageType,
31 pub query_id: u64,
32 pub payload_len: u16,
33}
34
35#[repr(C)]
37#[derive(Debug, Clone, Copy)]
38pub struct WebSocketSession {
39 pub session_id: u64,
40 pub active_query: Option<u64>,
41 pub subscribed: bool,
42}
43
44#[derive(Debug, Clone)]
50pub struct Subscription {
51 pub subscription_id: String,
53 pub client_id: String,
55 pub query: String,
57}
58
59impl Subscription {
60 pub fn new(subscription_id: String, client_id: String, query: String) -> Self {
62 Self {
63 subscription_id,
64 client_id,
65 query,
66 }
67 }
68}
69
70pub struct SparqlWebSocketHandler<'a> {
72 pub quins: &'a [NQuin],
73 pub sessions: [Option<WebSocketSession>; 32],
74 pub session_count: u8,
75 pub subscriptions: HashMap<String, Subscription>,
77 pub initialized: bool,
79}
80
81impl<'a> SparqlWebSocketHandler<'a> {
82 pub fn new(quins: &'a [NQuin]) -> Self {
84 Self {
85 quins,
86 sessions: [None; 32],
87 session_count: 0,
88 subscriptions: HashMap::new(),
89 initialized: false,
90 }
91 }
92
93 pub fn initialize(&mut self) -> Result<(), String> {
97 self.subscriptions.clear();
98 self.initialized = true;
99 Ok(())
100 }
101
102 pub fn register_session(&mut self) -> Result<u64, String> {
104 if self.session_count >= 32 {
105 return Err("Session overflow".to_string());
106 }
107
108 let session_id = self.session_count as u64;
109 self.sessions[self.session_count as usize] = Some(WebSocketSession {
110 session_id,
111 active_query: None,
112 subscribed: false,
113 });
114 self.session_count += 1;
115
116 Ok(session_id)
117 }
118
119 pub fn unregister_session(&mut self, session_id: u64) -> Result<(), String> {
121 for i in 0..self.session_count as usize {
122 if let Some(session) = self.sessions[i] {
123 if session.session_id == session_id {
124 self.sessions[i] = None;
125 return Ok(());
126 }
127 }
128 }
129 Err("Session not found".to_string())
130 }
131
132 pub fn handle_query_formatted(
137 &self,
138 query: &str,
139 format: &str,
140 _session_id: u64,
141 ) -> Result<String, String> {
142 let (sparql_query, ctx) = sparql_parser::parse_sparql(query)?;
144
145 let plan = QueryPlanner::plan(&sparql_query, &ctx)?;
147
148 let executor = QueryExecutor::new(self.quins);
150 let results = executor.execute(&plan, &ctx)?;
151
152 match format.to_lowercase().as_str() {
154 "json" => {
155 let mut output = Vec::new();
156 let vars = match &sparql_query {
157 SparqlQuery::Select(select) => {
158 select.variables[..select.var_count as usize].to_vec()
159 }
160 _ => vec![],
161 };
162 ResultFormatter::format_json(&mut output, &vars, &results, &ctx, None)
163 .map_err(|e| e.to_string())?;
164 Ok(String::from_utf8(output).unwrap())
165 }
166 "xml" => {
167 let mut output = Vec::new();
168 let vars = match &sparql_query {
169 SparqlQuery::Select(select) => {
170 select.variables[..select.var_count as usize].to_vec()
171 }
172 _ => vec![],
173 };
174 ResultFormatter::format_xml(&mut output, &vars, &results, &ctx, None)
175 .map_err(|e| e.to_string())?;
176 Ok(String::from_utf8(output).unwrap())
177 }
178 _ => Err("Unsupported format. Use: xml or json".to_string()),
179 }
180 }
181
182 pub fn stream_query_results(
187 &self,
188 query: &str,
189 chunk_size: usize,
190 _session_id: u64,
191 ) -> Result<Vec<String>, String> {
192 let (sparql_query, ctx) = sparql_parser::parse_sparql(query)?;
194 let plan = QueryPlanner::plan(&sparql_query, &ctx)?;
195 let executor = QueryExecutor::new(self.quins);
196 let results = executor.execute(&plan, &ctx)?;
197
198 let vars = match &sparql_query {
200 SparqlQuery::Select(select) => select.variables[..select.var_count as usize].to_vec(),
201 _ => vec![],
202 };
203
204 let mut chunks = Vec::new();
206 for chunk in results.chunks(chunk_size) {
207 let mut output = Vec::new();
208 ResultFormatter::format_json(&mut output, &vars, chunk, &ctx, None)
209 .map_err(|e| e.to_string())?;
210 chunks.push(String::from_utf8(output).unwrap());
211 }
212
213 Ok(chunks)
214 }
215
216 pub fn subscribe_session(&mut self, session_id: u64, query: &str) -> Result<u64, String> {
221 for i in 0..self.session_count as usize {
223 if let Some(session) = self.sessions[i] {
224 if session.session_id == session_id {
225 let query_hash = crate::lexicon::generate_60bit_token(query.as_bytes());
227 self.sessions[i] = Some(WebSocketSession {
228 session_id,
229 active_query: Some(query_hash),
230 subscribed: true,
231 });
232 return Ok(query_hash);
233 }
234 }
235 }
236 Err("Session not found".to_string())
237 }
238
239 pub fn unsubscribe_session(&mut self, session_id: u64) -> Result<(), String> {
241 for i in 0..self.session_count as usize {
242 if let Some(session) = self.sessions[i] {
243 if session.session_id == session_id {
244 self.sessions[i] = Some(WebSocketSession {
245 session_id,
246 active_query: None,
247 subscribed: false,
248 });
249 return Ok(());
250 }
251 }
252 }
253 Err("Session not found".to_string())
254 }
255
256 pub fn notify_session_subscribers(&self, query_hash: u64) -> Vec<u64> {
259 let mut subscribers = Vec::new();
260
261 for i in 0..self.session_count as usize {
262 if let Some(session) = self.sessions[i] {
263 if session.subscribed && session.active_query == Some(query_hash) {
264 subscribers.push(session.session_id);
265 }
266 }
267 }
268
269 subscribers
270 }
271
272 pub fn subscribe(&mut self, client_id: &str, query: &str) -> Result<String, String> {
285 let token = crate::lexicon::generate_60bit_token(query.as_bytes());
286 let subscription_id = format!("sub-{}-{}", client_id, token);
287 let subscription = Subscription::new(
288 subscription_id.clone(),
289 client_id.to_string(),
290 query.to_string(),
291 );
292 self.subscriptions
293 .insert(subscription_id.clone(), subscription);
294 Ok(subscription_id)
295 }
296
297 pub fn unsubscribe(&mut self, subscription_id: &str) -> Result<(), String> {
300 if self.subscriptions.remove(subscription_id).is_some() {
301 Ok(())
302 } else {
303 Err("Subscription not found".to_string())
304 }
305 }
306
307 pub fn get_subscriptions(&self) -> Vec<&Subscription> {
309 self.subscriptions.values().collect()
310 }
311
312 pub fn subscription_count(&self) -> usize {
314 self.subscriptions.len()
315 }
316
317 pub fn notify_subscribers(&self, event_data: &str) -> Vec<(String, String)> {
324 let mut notifications = Vec::new();
325 for sub in self.subscriptions.values() {
326 let message = format_notification(&sub.subscription_id, &sub.query, event_data);
327 notifications.push((sub.client_id.clone(), message));
328 }
329 notifications
330 }
331
332 pub fn handle_query(&self, query: &str) -> Result<Vec<u8>, String> {
335 let (sparql_query, ctx) = sparql_parser::parse_sparql(query)?;
337
338 let plan = QueryPlanner::plan(&sparql_query, &ctx)?;
340
341 let executor = QueryExecutor::new(self.quins);
343 let results = executor.execute(&plan, &ctx)?;
344
345 let vars = match &sparql_query {
347 SparqlQuery::Select(select) => select.variables[..select.var_count as usize].to_vec(),
348 _ => vec![],
349 };
350 let mut output = Vec::new();
351 ResultFormatter::format_json(&mut output, &vars, &results, &ctx, None)
352 .map_err(|e| e.to_string())?;
353 Ok(output)
354 }
355
356 pub fn stream_results(&self, results: &[u8], chunk_size: usize) -> Vec<Vec<u8>> {
360 if chunk_size == 0 {
361 return vec![results.to_vec()];
364 }
365 results.chunks(chunk_size).map(|c| c.to_vec()).collect()
366 }
367}
368
369impl<'a> Default for SparqlWebSocketHandler<'a> {
370 fn default() -> Self {
371 Self::new(&[])
372 }
373}
374
375fn format_notification(subscription_id: &str, query: &str, event_data: &str) -> String {
381 format!(
382 "{{\"subscriptionId\":\"{}\",\"query\":\"{}\",\"event\":{}}}",
383 escape_json_string(subscription_id),
384 escape_json_string(query),
385 event_data
386 )
387}
388
389fn escape_json_string(s: &str) -> String {
392 let mut out = String::with_capacity(s.len());
393 for c in s.chars() {
394 match c {
395 '"' => out.push_str("\\\""),
396 '\\' => out.push_str("\\\\"),
397 '\n' => out.push_str("\\n"),
398 '\r' => out.push_str("\\r"),
399 '\t' => out.push_str("\\t"),
400 c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
401 c => out.push(c),
402 }
403 }
404 out
405}
406
407#[cfg(test)]
408mod tests {
409 use super::*;
410
411 #[test]
412 fn test_websocket_handler_creation() {
413 let quins = vec![];
414 let handler = SparqlWebSocketHandler::new(&quins);
415 assert_eq!(handler.session_count, 0);
416 }
417
418 #[test]
419 fn test_register_session() {
420 let quins = vec![];
421 let mut handler = SparqlWebSocketHandler::new(&quins);
422
423 let session_id = handler.register_session().unwrap();
424 assert_eq!(session_id, 0);
425 assert_eq!(handler.session_count, 1);
426 }
427
428 #[test]
429 fn test_unregister_session() {
430 let quins = vec![];
431 let mut handler = SparqlWebSocketHandler::new(&quins);
432
433 let session_id = handler.register_session().unwrap();
434 handler.unregister_session(session_id).unwrap();
435 }
436
437 #[test]
438 fn test_subscribe_session() {
439 let quins = vec![];
440 let mut handler = SparqlWebSocketHandler::new(&quins);
441
442 let session_id = handler.register_session().unwrap();
443 let query_hash = handler
444 .subscribe_session(session_id, "SELECT ?s WHERE ?s ?p ?o")
445 .unwrap();
446
447 assert!(query_hash > 0);
448 }
449
450 #[test]
453 fn test_handler_initialize() {
454 let quins = vec![];
455 let mut handler = SparqlWebSocketHandler::new(&quins);
456 assert!(!handler.initialized);
457 handler.initialize().unwrap();
458 assert!(handler.initialized);
459 assert_eq!(handler.subscription_count(), 0);
460 }
461
462 #[test]
463 fn test_subscribe_client_returns_id() {
464 let quins = vec![];
465 let mut handler = SparqlWebSocketHandler::new(&quins);
466
467 let sub_id = handler
468 .subscribe("client-1", "SELECT ?s WHERE { ?s ?p ?o }")
469 .unwrap();
470 assert!(sub_id.starts_with("sub-client-1-"));
471 assert_eq!(handler.subscription_count(), 1);
472 }
473
474 #[test]
475 fn test_subscribe_client_stores_query_and_client() {
476 let quins = vec![];
477 let mut handler = SparqlWebSocketHandler::new(&quins);
478
479 let sub_id = handler
480 .subscribe("client-1", "SELECT ?s WHERE { ?s ?p ?o }")
481 .unwrap();
482 let subs = handler.get_subscriptions();
483 assert_eq!(subs.len(), 1);
484 assert_eq!(subs[0].subscription_id, sub_id);
485 assert_eq!(subs[0].client_id, "client-1");
486 assert_eq!(subs[0].query, "SELECT ?s WHERE { ?s ?p ?o }");
487 }
488
489 #[test]
490 fn test_subscribe_same_query_same_client_stable_id() {
491 let quins = vec![];
492 let mut handler = SparqlWebSocketHandler::new(&quins);
493
494 let id1 = handler
495 .subscribe("client-1", "SELECT ?s WHERE { ?s ?p ?o }")
496 .unwrap();
497 let id2 = handler
498 .subscribe("client-1", "SELECT ?s WHERE { ?s ?p ?o }")
499 .unwrap();
500 assert_eq!(id1, id2);
502 assert_eq!(handler.subscription_count(), 1);
503 }
504
505 #[test]
506 fn test_subscribe_different_clients_separate_subscriptions() {
507 let quins = vec![];
508 let mut handler = SparqlWebSocketHandler::new(&quins);
509
510 handler
511 .subscribe("client-1", "SELECT ?s WHERE { ?s ?p ?o }")
512 .unwrap();
513 handler
514 .subscribe("client-2", "SELECT ?s WHERE { ?s ?p ?o }")
515 .unwrap();
516 assert_eq!(handler.subscription_count(), 2);
517 }
518
519 #[test]
520 fn test_unsubscribe_client_removes_subscription() {
521 let quins = vec![];
522 let mut handler = SparqlWebSocketHandler::new(&quins);
523
524 let sub_id = handler
525 .subscribe("client-1", "SELECT ?s WHERE { ?s ?p ?o }")
526 .unwrap();
527 assert_eq!(handler.subscription_count(), 1);
528
529 handler.unsubscribe(&sub_id).unwrap();
530 assert_eq!(handler.subscription_count(), 0);
531 assert!(handler.get_subscriptions().is_empty());
532 }
533
534 #[test]
535 fn test_unsubscribe_client_unknown_id_errors() {
536 let quins = vec![];
537 let mut handler = SparqlWebSocketHandler::new(&quins);
538 let err = handler.unsubscribe("does-not-exist").unwrap_err();
539 assert!(err.contains("not found"));
540 }
541
542 #[test]
543 fn test_subscription_lifecycle() {
544 let quins = vec![];
545 let mut handler = SparqlWebSocketHandler::new(&quins);
546 handler.initialize().unwrap();
547
548 let id1 = handler
550 .subscribe("client-1", "SELECT ?s WHERE { ?s ?p ?o }")
551 .unwrap();
552 let id2 = handler
553 .subscribe("client-2", "SELECT ?s WHERE { ?s ?p ?o }")
554 .unwrap();
555 assert_eq!(handler.subscription_count(), 2);
556
557 let notifications = handler.notify_subscribers("{\"type\":\"update\"}");
559 assert_eq!(notifications.len(), 2);
560 let client_ids: Vec<&str> = notifications.iter().map(|(c, _)| c.as_str()).collect();
561 assert!(client_ids.contains(&"client-1"));
562 assert!(client_ids.contains(&"client-2"));
563 for (_, msg) in ¬ifications {
564 assert!(msg.contains("\"query\":\"SELECT ?s WHERE { ?s ?p ?o }\""));
565 assert!(msg.contains("\"event\":{\"type\":\"update\"}"));
566 }
567
568 handler.unsubscribe(&id1).unwrap();
570 assert_eq!(handler.subscription_count(), 1);
571 let notifications = handler.notify_subscribers("{\"type\":\"update\"}");
572 assert_eq!(notifications.len(), 1);
573 assert_eq!(notifications[0].0, "client-2");
574
575 handler.unsubscribe(&id2).unwrap();
577 assert_eq!(handler.subscription_count(), 0);
578 assert!(handler.notify_subscribers("event").is_empty());
579 }
580
581 #[test]
582 fn test_notify_subscribers_message_format() {
583 let quins = vec![];
584 let mut handler = SparqlWebSocketHandler::new(&quins);
585 handler
586 .subscribe("client-1", "SELECT ?s WHERE { ?s ?p ?o }")
587 .unwrap();
588
589 let notifications = handler.notify_subscribers("{\"data\":42}");
590 assert_eq!(notifications.len(), 1);
591 let (_client, msg) = ¬ifications[0];
592 assert!(msg.starts_with("{\"subscriptionId\":\""));
593 assert!(msg.contains("\"query\":\"SELECT ?s WHERE { ?s ?p ?o }\""));
594 assert!(msg.contains("\"event\":{\"data\":42}"));
595 }
596
597 #[test]
598 fn test_handle_query_bytes_returns_json() {
599 let quins = vec![];
600 let handler = SparqlWebSocketHandler::new(&quins);
601 let bytes = handler
602 .handle_query("SELECT ?s WHERE { ?s ?p ?o }")
603 .unwrap();
604 let text = String::from_utf8(bytes).unwrap();
606 assert!(text.contains("head") || text.contains("results") || text.contains('{'));
607 }
608
609 #[test]
610 fn test_handle_query_bytes_parse_error() {
611 let quins = vec![];
612 let handler = SparqlWebSocketHandler::new(&quins);
613 let err = handler.handle_query("not sparql").unwrap_err();
614 assert!(!err.is_empty());
615 }
616
617 #[test]
618 fn test_stream_results_bytes_chunks() {
619 let quins = vec![];
620 let handler = SparqlWebSocketHandler::new(&quins);
621 let data: Vec<u8> = (0..25u8).collect();
622 let chunks = handler.stream_results(&data, 10);
623 assert_eq!(chunks.len(), 3);
624 assert_eq!(chunks[0].len(), 10);
625 assert_eq!(chunks[1].len(), 10);
626 assert_eq!(chunks[2].len(), 5);
627 let reassembled: Vec<u8> = chunks.into_iter().flatten().collect();
629 assert_eq!(reassembled, data);
630 }
631
632 #[test]
633 fn test_stream_results_bytes_empty() {
634 let quins = vec![];
635 let handler = SparqlWebSocketHandler::new(&quins);
636 let chunks = handler.stream_results(&[], 10);
637 assert!(chunks.is_empty());
638 }
639
640 #[test]
641 fn test_stream_results_bytes_zero_chunk_size() {
642 let quins = vec![];
643 let handler = SparqlWebSocketHandler::new(&quins);
644 let data: Vec<u8> = (0..5u8).collect();
645 let chunks = handler.stream_results(&data, 0);
647 assert_eq!(chunks.len(), 1);
648 assert_eq!(chunks[0], data);
649 }
650
651 #[test]
652 fn test_format_notification_escapes_quotes() {
653 let msg = format_notification("sub-1", "SELECT \"x\"", "{}");
654 assert!(msg.contains("\\\"x\\\""));
655 assert!(msg.contains("\"event\":{}"));
656 }
657
658 #[test]
659 fn test_escape_json_string() {
660 assert_eq!(escape_json_string("a\"b"), "a\\\"b");
661 assert_eq!(escape_json_string("a\\b"), "a\\\\b");
662 assert_eq!(escape_json_string("a\nb"), "a\\nb");
663 assert_eq!(escape_json_string("plain"), "plain");
664 }
665}