use std::io::Write;
use std::time::{Duration, Instant};
use crate::engine::StreamError;
pub const SSE_HEAD: &str = "HTTP/1.1 200 OK\r\n\
Content-Type: text/event-stream\r\n\
Cache-Control: no-cache\r\n\
Connection: keep-alive\r\n\
X-Accel-Buffering: no\r\n\
Transfer-Encoding: chunked\r\n\
\r\n";
pub const TERMINATOR: &str = "0\r\n\r\n";
pub const KEEPALIVE: &str = ": keep-alive\n\n";
#[derive(Debug)]
pub struct ChunkedWriter<W: Write> {
inner: W,
head_sent: bool,
terminated: bool,
}
impl<W: Write> ChunkedWriter<W> {
pub fn new(inner: W) -> Self {
ChunkedWriter {
inner,
head_sent: false,
terminated: false,
}
}
pub fn head_sent(&self) -> bool {
self.head_sent
}
pub fn head(&mut self) -> Result<(), StreamError> {
self.inner.write_all(SSE_HEAD.as_bytes())?;
self.inner.flush()?;
self.head_sent = true;
Ok(())
}
pub fn event(&mut self, payload: &str) -> Result<(), StreamError> {
if payload.is_empty() {
return Ok(());
}
let bytes = payload.as_bytes();
write!(self.inner, "{:x}\r\n", bytes.len())?;
self.inner.write_all(bytes)?;
self.inner.write_all(b"\r\n")?;
self.inner.flush()?;
Ok(())
}
pub fn finish(&mut self) -> Result<(), StreamError> {
if self.terminated {
return Ok(());
}
self.terminated = true;
self.inner.write_all(TERMINATOR.as_bytes())?;
self.inner.flush()?;
Ok(())
}
}
#[derive(Debug)]
pub struct StreamState<W: Write> {
writer: ChunkedWriter<W>,
failed: Option<StreamError>,
last_write: Instant,
}
impl<W: Write> StreamState<W> {
pub fn new(writer: W) -> Self {
StreamState {
writer: ChunkedWriter::new(writer),
failed: None,
last_write: Instant::now(),
}
}
pub fn failure(&self) -> Option<StreamError> {
self.failed
}
pub fn head_sent(&self) -> bool {
self.writer.head_sent()
}
pub fn idle_for(&self) -> Duration {
self.last_write.elapsed()
}
pub fn head(&mut self) -> Result<(), StreamError> {
self.record(|w| w.head())
}
pub fn emit(&mut self, payload: &str) -> Result<(), StreamError> {
self.record(|w| w.event(payload))
}
pub fn finish(&mut self) -> Result<(), StreamError> {
self.record(|w| w.finish())
}
fn record(
&mut self,
write: impl FnOnce(&mut ChunkedWriter<W>) -> Result<(), StreamError>,
) -> Result<(), StreamError> {
if let Some(failed) = self.failed {
return Err(failed);
}
match write(&mut self.writer) {
Ok(()) => {
self.last_write = Instant::now();
Ok(())
}
Err(e) => {
self.failed = Some(e);
Err(e)
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_response_head_is_byte_exact() {
assert_eq!(
SSE_HEAD,
"HTTP/1.1 200 OK\r\n\
Content-Type: text/event-stream\r\n\
Cache-Control: no-cache\r\n\
Connection: keep-alive\r\n\
X-Accel-Buffering: no\r\n\
Transfer-Encoding: chunked\r\n\
\r\n"
);
assert!(!SSE_HEAD.to_ascii_lowercase().contains("content-length"));
assert!(SSE_HEAD.ends_with("\r\n\r\n"));
}
#[test]
fn a_chunk_is_hex_length_then_payload_then_crlf() -> Result<(), StreamError> {
let mut writer = ChunkedWriter::new(Vec::new());
writer.event("data: {}\n\n")?;
assert_eq!(writer.inner, b"a\r\ndata: {}\n\n\r\n");
Ok(())
}
#[test]
fn the_chunk_length_is_lowercase_hex_of_the_payload_only() -> Result<(), StreamError> {
let payload = "x".repeat(255);
let mut writer = ChunkedWriter::new(Vec::new());
writer.event(&payload)?;
let out = String::from_utf8(writer.inner).expect("ascii");
assert!(out.starts_with("ff\r\n"), "{:?}", &out[..8]);
assert!(out.ends_with("\r\n"));
assert_eq!(out.len(), 4 + 255 + 2);
Ok(())
}
#[test]
fn the_chunk_length_counts_bytes_not_characters() -> Result<(), StreamError> {
let payload = "data: \"héllo→\"\n\n";
let mut writer = ChunkedWriter::new(Vec::new());
writer.event(payload)?;
let out = writer.inner;
let head = format!("{:x}\r\n", payload.len());
assert!(out.starts_with(head.as_bytes()));
assert_ne!(payload.len(), payload.chars().count());
assert_eq!(out.len(), head.len() + payload.len() + 2);
Ok(())
}
#[test]
fn the_terminator_is_a_zero_length_chunk_and_is_idempotent() -> Result<(), StreamError> {
let mut writer = ChunkedWriter::new(Vec::new());
writer.finish()?;
writer.finish()?;
assert_eq!(writer.inner, b"0\r\n\r\n");
Ok(())
}
#[test]
fn an_empty_payload_is_never_framed() -> Result<(), StreamError> {
let mut writer = ChunkedWriter::new(Vec::new());
writer.event("")?;
assert!(writer.inner.is_empty());
Ok(())
}
#[test]
fn a_whole_stream_frames_and_unframes() -> Result<(), StreamError> {
let mut writer = ChunkedWriter::new(Vec::new());
writer.head()?;
writer.event(KEEPALIVE)?;
writer.event("data: {\"a\":1}\n\n")?;
writer.finish()?;
let out = String::from_utf8(writer.inner).expect("ascii");
let body = out.strip_prefix(SSE_HEAD).expect("head first");
assert_eq!(
body,
format!(
"{:x}\r\n{KEEPALIVE}\r\n{:x}\r\ndata: {{\"a\":1}}\n\n\r\n0\r\n\r\n",
KEEPALIVE.len(),
15
)
);
Ok(())
}
#[test]
fn the_keep_alive_is_an_sse_comment() {
assert!(KEEPALIVE.starts_with(':'));
assert!(!KEEPALIVE.starts_with("data:"));
assert!(KEEPALIVE.ends_with("\n\n"));
assert!(!KEEPALIVE.contains('\r'));
}
#[test]
fn a_write_failure_sticks() {
struct Dead;
impl Write for Dead {
fn write(&mut self, _: &[u8]) -> std::io::Result<usize> {
Err(std::io::Error::from(std::io::ErrorKind::BrokenPipe))
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
let mut state = StreamState::new(Dead);
assert_eq!(state.head(), Err(StreamError::Disconnected));
assert_eq!(state.failure(), Some(StreamError::Disconnected));
assert_eq!(state.emit("data: x\n\n"), Err(StreamError::Disconnected));
}
}