use bytes::Bytes;
use futures::Stream;
use pin_project_lite::pin_project;
use std::pin::Pin;
use std::task::{Context, Poll};
use thiserror::Error;
const DEFAULT_MAX_EVENT_SIZE: usize = 1024 * 1024;
#[derive(Debug, Error)]
pub enum SseError {
#[error("utf-8 decode error: {0}")]
Utf8(#[from] std::string::FromUtf8Error),
#[error("stream error: {0}")]
Stream(String),
#[error("SSE frame exceeded maximum allowed size")]
FrameTooLarge,
}
#[derive(Debug, Clone, Default)]
pub struct SseEvent {
pub event: Option<String>,
pub data: String,
pub id: Option<String>,
pub retry: Option<u64>,
}
pin_project! {
pub struct SseStream<S, E> {
#[pin]
inner: S,
buffer: Vec<u8>,
max_event_size: usize,
done: bool,
_err: std::marker::PhantomData<E>,
}
}
impl<S, E> SseStream<S, E>
where
S: Stream<Item = Result<Bytes, E>> + Unpin,
{
pub fn new(stream: S) -> Self {
Self::with_max_event_size(stream, DEFAULT_MAX_EVENT_SIZE)
}
pub fn with_max_event_size(stream: S, max_event_size: usize) -> Self {
Self {
inner: stream,
buffer: Vec::new(),
max_event_size,
done: false,
_err: std::marker::PhantomData,
}
}
}
impl<S, E> Stream for SseStream<S, E>
where
S: Stream<Item = Result<Bytes, E>> + Unpin,
E: std::fmt::Display,
{
type Item = Result<SseEvent, SseError>;
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
let this = self.as_mut().get_mut();
loop {
if let Some((frame_len, sep_len)) = find_separator(&this.buffer) {
if frame_len > this.max_event_size {
this.buffer.drain(..frame_len + sep_len);
return Poll::Ready(Some(Err(SseError::FrameTooLarge)));
}
let frame_bytes: Vec<u8> = this.buffer.drain(..frame_len).collect();
this.buffer.drain(..sep_len);
let frame = match String::from_utf8(frame_bytes) {
Ok(s) => s,
Err(e) => return Poll::Ready(Some(Err(SseError::Utf8(e)))),
};
let (event, has_data_line) = try_parse_event(&frame);
if !has_data_line {
continue;
}
return Poll::Ready(Some(Ok(event)));
}
if this.buffer.len() > this.max_event_size {
this.buffer.clear();
return Poll::Ready(Some(Err(SseError::FrameTooLarge)));
}
if this.done {
return Poll::Ready(None);
}
match Pin::new(&mut this.inner).poll_next(cx) {
Poll::Ready(Some(Ok(bytes))) => {
this.buffer.extend_from_slice(&bytes);
}
Poll::Ready(Some(Err(e))) => {
return Poll::Ready(Some(Err(SseError::Stream(e.to_string()))));
}
Poll::Ready(None) => {
this.done = true;
}
Poll::Pending => return Poll::Pending,
}
}
}
}
fn find_separator(buf: &[u8]) -> Option<(usize, usize)> {
if let Some(pos) = find_subsequence(buf, b"\n\n") {
return Some((pos, 2));
}
find_subsequence(buf, b"\r\n\r\n").map(|pos| (pos, 4))
}
fn find_subsequence(haystack: &[u8], needle: &[u8]) -> Option<usize> {
haystack.windows(needle.len()).position(|w| w == needle)
}
fn try_parse_event(frame: &str) -> (SseEvent, bool) {
let mut event = SseEvent::default();
let mut has_data_line = false;
for line in frame.lines() {
if let Some(value) = field_value(line, "data:") {
has_data_line = true;
if event.data.is_empty() {
event.data = value.to_string();
} else {
event.data.push('\n');
event.data.push_str(value);
}
} else if let Some(value) = field_value(line, "event:") {
event.event = Some(value.to_string());
} else if let Some(value) = field_value(line, "id:") {
event.id = Some(value.to_string());
} else if let Some(value) = field_value(line, "retry:") {
event.retry = value.parse().ok();
}
}
(event, has_data_line)
}
fn field_value<'a>(line: &'a str, prefix: &str) -> Option<&'a str> {
let rest = line.strip_prefix(prefix)?;
Some(rest.strip_prefix(' ').unwrap_or(rest))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parse_single_event() {
let (event, has_data_line) = try_parse_event("data: hello world");
assert_eq!(event.data, "hello world");
assert!(has_data_line);
}
#[test]
fn parse_multi_line_data() {
let (event, has_data_line) = try_parse_event("data: line1\ndata: line2");
assert_eq!(event.data, "line1\nline2");
assert!(has_data_line);
}
#[test]
fn parse_event_with_type() {
let (event, has_data_line) = try_parse_event("event: message\ndata: payload");
assert_eq!(event.event.as_deref(), Some("message"));
assert_eq!(event.data, "payload");
assert!(has_data_line);
}
#[test]
fn parse_event_without_data_has_no_data_line() {
let (event, has_data_line) = try_parse_event("event: ping");
assert_eq!(event.event.as_deref(), Some("ping"));
assert!(event.data.is_empty());
assert!(!has_data_line);
}
}