@lovrozagar/honey 0.6.8 → 0.7.1

package/src/client-rust/sse.rs

@@ -1,10 +1,11 @@
 /* Code generated by honey. DO NOT EDIT. */
 
 use crate::errors::{raise_for_status, Error};
-use bytes::Bytes;
 use futures_util::StreamExt;
 
-/// SseEvent represents a single server-sent event.
+/// SseEvent represents a single server-sent event. `id` is the last event id
+/// seen on the stream so far (the spec's sticky "last event ID buffer").
+#[derive(Debug, Clone, Default, PartialEq)]
 pub struct SseEvent {
     pub data: String,
     pub event: String,
@@ -12,156 +13,176 @@ pub struct SseEvent {
     pub retry: i32,
 }
 
-/// parse_sse_stream returns a Stream of SseEvent values read from a reqwest Response.
-/// On non-2xx response it yields a typed error immediately then terminates.
-/// Hand-parsed over reqwest bytes_stream; mirrors Go parseSSEStream line-for-line.
-pub fn parse_sse_stream(
-    resp: reqwest::Response,
-) -> impl futures_util::Stream<Item = Result<SseEvent, Error>> {
-    async_stream::stream! {
-        let status = resp.status().as_u16();
-        if !(200..300).contains(&status) {
-            let body = resp.bytes().await.unwrap_or_default().to_vec();
-            if let Some(err) = raise_for_status(status, body) {
-                yield Err(err);
-            }
-            return;
-        }
+/// Largest single line, and largest data of one event.
+pub const SSE_MAX_LINE: usize = 1024 * 1024;
+pub const SSE_MAX_EVENT: usize = 8 * 1024 * 1024;
 
-        let mut byte_stream = resp.bytes_stream();
-        let mut buf = Vec::<u8>::new();
+/// SseParser is an incremental WHATWG event-stream parser. Lines end in CRLF,
+/// LF or CR; a blank line dispatches; a final event without its blank line is
+/// never dispatched; `id` is sticky; `retry` needs ASCII digits; field values
+/// are not trimmed. Each input byte is scanned once.
+#[derive(Debug, Default)]
+pub struct SseParser {
+    line: Vec<u8>,
+    pending_cr: bool,
+    started: bool,
+    data: String,
+    has_data: bool,
+    event: String,
+    last_id: String,
+    retry: i32,
+}
 
-        while let Some(chunk) = byte_stream.next().await {
-            match chunk {
-                Err(e) => {
-                    yield Err(Error::Transport(e));
-                    return;
+impl SseParser {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// feed consumes a chunk and returns every event it completes.
+    pub fn feed(&mut self, chunk: &[u8]) -> Result<Vec<SseEvent>, Error> {
+        let mut out = Vec::new();
+        for &b in chunk {
+            if self.pending_cr {
+                self.pending_cr = false;
+                if b == b'\n' {
+                    continue;
                 }
-                Ok(bytes) => {
-                    buf.extend_from_slice(&bytes);
-                    loop {
-                        /* find next double-newline delimiter: \r\n\r\n, \n\n, \r\r */
-                        let delim_pos = find_double_newline(&buf);
-                        match delim_pos {
-                            None => break,
-                            Some((start, end)) => {
-                                let block = buf[..start].to_vec();
-                                buf.drain(..end);
-                                let block_str = String::from_utf8_lossy(&block);
-                                let trimmed = block_str.trim();
-                                if !trimmed.is_empty() {
-                                    if let Some(ev) = parse_sse_block(trimmed) {
-                                        yield Ok(ev);
-                                    }
-                                }
-                            }
-                        }
+            }
+            match b {
+                b'\n' | b'\r' => {
+                    if b == b'\r' {
+                        self.pending_cr = true;
+                    }
+                    let line = std::mem::take(&mut self.line);
+                    if let Some(ev) = self.process(&line)? {
+                        out.push(ev);
                     }
                 }
-            }
-        }
-
-        /* flush any remaining data */
-        if !buf.is_empty() {
-            let block_str = String::from_utf8_lossy(&buf);
-            let trimmed = block_str.trim();
-            if !trimmed.is_empty() {
-                if let Some(ev) = parse_sse_block(trimmed) {
-                    yield Ok(ev);
+                _ => {
+                    if self.line.len() >= SSE_MAX_LINE {
+                        return Err(Error::Other("sse line exceeds 1 MiB".into()));
+                    }
+                    self.line.push(b);
                 }
             }
         }
+        Ok(out)
     }
-}
 
-/// find_double_newline returns (content_end, advance) positions for the first
-/// occurrence of \r\n\r\n, \n\n, or \r\r in buf.
-pub(crate) fn find_double_newline(buf: &[u8]) -> Option<(usize, usize)> {
-    let delimiters: &[&[u8]] = &[b"\r\n\r\n", b"\n\n", b"\r\r"];
-    for delim in delimiters {
-        let dlen = delim.len();
-        if buf.len() < dlen {
-            continue;
-        }
-        for i in 0..=(buf.len() - dlen) {
-            if &buf[i..i + dlen] == *delim {
-                return Some((i, i + dlen));
+    fn process(&mut self, raw: &[u8]) -> Result<Option<SseEvent>, Error> {
+        let mut line = String::from_utf8_lossy(raw).into_owned();
+        if !self.started {
+            self.started = true;
+            if let Some(rest) = line.strip_prefix('\u{feff}') {
+                line = rest.to_string();
             }
         }
-    }
-    None
-}
-
-/// parse_sse_block parses a single SSE message block into an SseEvent.
-/// Mirrors Go parseSSEBlock line-for-line:
-/// - colon-prefix lines are comments and skipped
-/// - field/val split on first colon; leading space stripped from val
-/// - data lines joined with \n
-/// - id containing null byte (\0) is ignored per spec
-/// - retry parsed as non-negative i32
-pub(crate) fn parse_sse_block(block: &str) -> Option<SseEvent> {
-    let mut data = String::new();
-    let mut has_data = false;
-    let mut event = String::new();
-    let mut id = String::new();
-    let mut retry: i32 = 0;
-    let mut is_comment = true;
-
-    for raw_line in block.split('\n') {
-        let line = raw_line.trim_end_matches('\r');
+        if line.is_empty() {
+            return Ok(self.dispatch());
+        }
         if line.starts_with(':') {
-            continue;
+            return Ok(None);
         }
-        is_comment = false;
-
-        let (field, val) = if let Some(colon_idx) = line.find(':') {
-            let f = &line[..colon_idx];
-            let v = &line[colon_idx + 1..];
-            let v = v.strip_prefix(' ').unwrap_or(v);
-            (f, v)
-        } else {
-            (line, "")
+        let (field, value) = match line.find(':') {
+            Some(i) => {
+                let v = &line[i + 1..];
+                (&line[..i], v.strip_prefix(' ').unwrap_or(v))
+            }
+            None => (line.as_str(), ""),
         };
-
         match field {
             "data" => {
-                if has_data {
-                    data.push('\n');
-                    data.push_str(val);
-                } else {
-                    data = val.to_string();
-                    has_data = true;
+                if self.has_data {
+                    self.data.push('\n');
                 }
+                if self.data.len() + value.len() > SSE_MAX_EVENT {
+                    return Err(Error::Other("sse event exceeds 8 MiB".into()));
+                }
+                self.data.push_str(value);
+                self.has_data = true;
             }
-            "event" => {
-                event = val.to_string();
-            }
+            "event" => self.event = value.to_string(),
             "id" => {
-                /* per spec: id containing null byte must be ignored */
-                if !val.contains('\0') {
-                    id = val.to_string();
+                if !value.contains('\0') {
+                    self.last_id = value.to_string();
                 }
             }
             "retry" => {
-                use std::str::FromStr;
-                if let Ok(n) = i32::from_str(val) {
-                    if n >= 0 {
-                        retry = n;
+                if !value.is_empty() && value.bytes().all(|c| c.is_ascii_digit()) {
+                    if let Ok(n) = value.parse::<i32>() {
+                        self.retry = n;
                     }
                 }
             }
             _ => {}
         }
+        Ok(None)
     }
 
-    if is_comment || !has_data {
-        return None;
+    fn dispatch(&mut self) -> Option<SseEvent> {
+        let ev = if self.has_data {
+            Some(SseEvent {
+                data: std::mem::take(&mut self.data),
+                event: std::mem::take(&mut self.event),
+                id: self.last_id.clone(),
+                retry: self.retry,
+            })
+        } else {
+            None
+        };
+        self.data.clear();
+        self.has_data = false;
+        self.event.clear();
+        self.retry = 0;
+        ev
     }
+}
 
-    Some(SseEvent { data, event, id, retry })
+/// parse_sse_text parses complete text; used by the conformance vectors.
+pub fn parse_sse_text(chunks: &[&str]) -> Result<Vec<SseEvent>, Error> {
+    let mut p = SseParser::new();
+    let mut out = Vec::new();
+    for c in chunks {
+        out.extend(p.feed(c.as_bytes())?);
+    }
+    Ok(out)
 }
 
-/* suppress unused import warning — Bytes is part of the public API contract */
-const _: fn() = || {
-    let _: Bytes = Bytes::new();
-};
+/// parse_sse_stream returns a Stream of SseEvent values read from a reqwest Response.
+/// On non-2xx response it yields a typed error immediately then terminates.
+pub fn parse_sse_stream(
+    resp: reqwest::Response,
+) -> impl futures_util::Stream<Item = Result<SseEvent, Error>> {
+    async_stream::stream! {
+        let status = resp.status().as_u16();
+        if !(200..300).contains(&status) {
+            let body = resp.bytes().await.unwrap_or_default().to_vec();
+            if let Some(err) = raise_for_status(status, body) {
+                yield Err(err);
+            }
+            return;
+        }
+
+        let mut byte_stream = resp.bytes_stream();
+        let mut parser = SseParser::new();
+        while let Some(chunk) = byte_stream.next().await {
+            match chunk {
+                Err(e) => {
+                    yield Err(Error::Transport(e));
+                    return;
+                }
+                Ok(bytes) => match parser.feed(&bytes) {
+                    Ok(events) => {
+                        for ev in events {
+                            yield Ok(ev);
+                        }
+                    }
+                    Err(e) => {
+                        yield Err(e);
+                        return;
+                    }
+                },
+            }
+        }
+    }
+}

package/src/client-rust/ws.rs

@@ -20,16 +20,17 @@ pub const WS_STATUS_PROTOCOL_ERROR: u16 = 1002;
 type WsStream = WebSocketStream<tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>>;
 
 type WsHandler = Box<dyn Fn(&[u8]) + Send + Sync>;
-type HandlerMap = Mutex<HashMap<String, Vec<WsHandler>>>;
+type SharedHandler = std::sync::Arc<dyn Fn(&[u8]) + Send + Sync>;
+type HandlerMap = Mutex<HashMap<String, Vec<SharedHandler>>>;
 
-/// TypedWebSocket wraps a tokio-tungstenite connection with a buffered pre-OPEN
-/// send queue (flushed once on first read via AtomicBool) and an event fanout
-/// system that mirrors the TS client's .on() escape hatch.
+/// TypedWebSocket wraps a tokio-tungstenite connection with an event fanout
+/// system that mirrors the TS client's .on() escape hatch: "message" handlers
+/// get each payload, "close" handlers the close reason, "error" handlers the
+/// error text.
 pub struct TypedWebSocket {
     conn: WsStream,
-    send_buffer: Option<Vec<u8>>,
-    once: AtomicBool,
     handlers: HandlerMap,
+    closed: AtomicBool,
 }
 
 impl TypedWebSocket {
@@ -37,12 +38,29 @@ impl TypedWebSocket {
     pub fn new(conn: WsStream) -> Self {
         TypedWebSocket {
             conn,
-            send_buffer: None,
-            once: AtomicBool::new(false),
             handlers: Mutex::new(HashMap::new()),
+            closed: AtomicBool::new(false),
         }
     }
 
+    /// send_text writes a text frame as-is.
+    pub async fn send_text(&mut self, text: &str) -> Result<(), Error> {
+        use futures_util::SinkExt;
+        self.conn
+            .send(Message::Text(text.to_string()))
+            .await
+            .map_err(|e| Error::Other(e.to_string()))
+    }
+
+    /// send_binary writes a binary frame as-is.
+    pub async fn send_binary(&mut self, data: &[u8]) -> Result<(), Error> {
+        use futures_util::SinkExt;
+        self.conn
+            .send(Message::Binary(data.to_vec()))
+            .await
+            .map_err(|e| Error::Other(e.to_string()))
+    }
+
     /// send serialises data to JSON and writes it to the WebSocket connection.
     /// Accepts any serde_json::Value or JSON-serializable payload pre-encoded as Value.
     pub async fn send(&mut self, data: &serde_json::Value) -> Result<(), Error> {
@@ -64,15 +82,21 @@ impl TypedWebSocket {
             .map_err(|e| Error::Other(e.to_string()))
     }
 
-    /// close sends a WebSocket close frame with the given status code and reason.
+    /// close sends a WebSocket close frame with the given status code and reason
+    /// (truncated to the 123 bytes a close frame can carry).
     pub async fn close(&mut self, code: u16, reason: &str) -> Result<(), Error> {
         use futures_util::SinkExt;
         use tokio_tungstenite::tungstenite::protocol::frame::coding::CloseCode;
         use tokio_tungstenite::tungstenite::protocol::CloseFrame;
+        let mut end = reason.len().min(123);
+        while !reason.is_char_boundary(end) {
+            end -= 1;
+        }
         let frame = CloseFrame {
             code: CloseCode::from(code),
-            reason: reason.to_string().into(),
+            reason: reason[..end].to_string().into(),
         };
+        self.fire_close(&reason[..end]);
         self.conn
             .send(Message::Close(Some(frame)))
             .await
@@ -80,28 +104,19 @@ impl TypedWebSocket {
     }
 
     /// read reads the next message from the connection.
-    /// On the first call, any pre-OPEN buffered send is flushed via AtomicBool compare_exchange.
     pub async fn read(&mut self) -> Result<Vec<u8>, Error> {
-        use futures_util::{SinkExt, StreamExt};
-
-        /* flush send_buffer exactly once on first read — mirrors Go sync.Once */
-        if self
-            .once
-            .compare_exchange(false, true, Ordering::AcqRel, Ordering::Relaxed)
-            .is_ok()
-        {
-            if let Some(buf) = self.send_buffer.take() {
-                let _ = self
-                    .conn
-                    .send(Message::Text(String::from_utf8_lossy(&buf).into_owned()))
-                    .await;
-            }
-        }
-
+        use futures_util::StreamExt;
         loop {
             match self.conn.next().await {
-                None => return Err(Error::Closed { code: 1006, reason: String::new() }),
-                Some(Err(e)) => return Err(Error::Other(e.to_string())),
+                None => {
+                    self.fire_close("");
+                    return Err(Error::Closed { code: 1006, reason: String::new() });
+                }
+                Some(Err(e)) => {
+                    let msg = e.to_string();
+                    self.fanout("error", msg.as_bytes());
+                    return Err(Error::Other(msg));
+                }
                 Some(Ok(msg)) => {
                     let data = match msg {
                         Message::Text(t) => t.into_bytes(),
@@ -111,7 +126,8 @@ impl TypedWebSocket {
                                 Some(f) => (u16::from(f.code), f.reason.into_owned()),
                                 None => (1005, String::new()),
                             };
-                            return Err(Error::Closed { code, reason })
+                            self.fire_close(&reason);
+                            return Err(Error::Closed { code, reason });
                         }
                         _ => continue,
                     };
@@ -125,19 +141,27 @@ impl TypedWebSocket {
     /// on registers an event handler for a named event.
     /// Supported events: "message", "close", "error", "open".
     pub fn on(&mut self, event: &str, handler: WsHandler) {
-        let mut handlers = self.handlers.lock().unwrap();
+        let mut handlers = self.handlers.lock().unwrap_or_else(|p| p.into_inner());
         handlers
             .entry(event.to_string())
             .or_default()
-            .push(handler);
+            .push(std::sync::Arc::from(handler));
     }
 
+    fn fire_close(&self, reason: &str) {
+        if !self.closed.swap(true, Ordering::AcqRel) {
+            self.fanout("close", reason.as_bytes());
+        }
+    }
+
+    /// fanout calls handlers outside the lock, so a panicking handler cannot poison it.
     fn fanout(&self, event: &str, data: &[u8]) {
-        let handlers = self.handlers.lock().unwrap();
-        if let Some(hs) = handlers.get(event) {
-            for h in hs {
-                h(data);
-            }
+        let hs: Vec<SharedHandler> = {
+            let handlers = self.handlers.lock().unwrap_or_else(|p| p.into_inner());
+            handlers.get(event).cloned().unwrap_or_default()
+        };
+        for h in hs {
+            h(data);
         }
     }
 }