use std::io::{self, Read, Write};
use serde::Serialize;
use serde_json::Value;
#[derive(Debug)]
pub enum CheckedError {
Stream(Value),
Truncated(String),
Io(io::Error),
}
impl std::fmt::Display for CheckedError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
CheckedError::Stream(v) => write!(f, "stream error: {v}"),
CheckedError::Truncated(m) => write!(f, "truncated stream: {m}"),
CheckedError::Io(e) => write!(f, "{e}"),
}
}
}
impl std::error::Error for CheckedError {}
impl From<io::Error> for CheckedError {
fn from(e: io::Error) -> Self {
CheckedError::Io(e)
}
}
pub fn encode_checked_array<T, I, W>(items: I, writer: &mut W) -> io::Result<usize>
where
T: Serialize,
I: IntoIterator<Item = T>,
W: Write,
{
writer.write_all(b"{\"items\":[")?;
let mut count = 0usize;
for item in items {
if count > 0 {
writer.write_all(b",")?;
}
match serde_json::to_vec(&item) {
Ok(bytes) => writer.write_all(&bytes)?,
Err(e) => {
let err = serde_json::json!({"message": e.to_string(), "type": "SerializeError"});
writer.write_all(b"],\"complete\":false,\"error\":")?;
writer.write_all(&serde_json::to_vec(&err).unwrap_or_default())?;
writer.write_all(b"}")?;
return Err(io::Error::from(e));
}
}
count += 1;
}
writer.write_all(b"],\"complete\":true}")?;
Ok(count)
}
pub struct CheckedArrayIter<R: Read> {
reader: R,
buf: Vec<u8>,
pos: usize,
depth: i64,
max_depth: i64,
in_string: bool,
escape: bool,
header_done: bool,
finished: bool,
eof: bool,
pending: Option<Result<Value, CheckedError>>,
}
pub fn decode_checked_array<R: Read>(reader: R) -> CheckedArrayIter<R> {
CheckedArrayIter {
reader,
buf: Vec::new(),
pos: 0,
depth: 0,
max_depth: 200,
in_string: false,
escape: false,
header_done: false,
finished: false,
eof: false,
pending: None,
}
}
impl<R: Read> CheckedArrayIter<R> {
pub fn with_max_depth(mut self, max_depth: i64) -> Self {
self.max_depth = max_depth;
self
}
fn more(&mut self) -> bool {
if self.eof {
return false;
}
let mut tmp = [0u8; 65536];
match self.reader.read(&mut tmp) {
Ok(0) => {
self.eof = true;
false
}
Ok(k) => {
self.buf.extend_from_slice(&tmp[..k]);
true
}
Err(_) => {
self.eof = true;
false
}
}
}
fn ensure_header(&mut self) -> Result<(), CheckedError> {
const HEADER: &[u8] = b"{\"items\":[";
while self.buf.len() < HEADER.len() {
if !self.more() {
return Err(CheckedError::Truncated(
"stream ended before items array".into(),
));
}
}
if &self.buf[..HEADER.len()] != HEADER {
return Err(CheckedError::Io(io::Error::new(
io::ErrorKind::InvalidData,
"decode_checked_array: not a flatwire checked stream",
)));
}
self.buf.drain(0..HEADER.len());
self.header_done = true;
Ok(())
}
fn finish(&mut self) -> Option<Result<Value, CheckedError>> {
while self.more() {}
let trailer = std::str::from_utf8(&self.buf[self.pos..])
.unwrap_or("")
.trim();
if trailer.is_empty() {
return Some(Err(CheckedError::Truncated(
"stream ended before terminal status".into(),
)));
}
let body = trailer.strip_prefix(',').unwrap_or(trailer);
let obj: Value = match serde_json::from_str(&format!("{{{body}")) {
Ok(v) => v,
Err(e) => return Some(Err(CheckedError::Io(io::Error::from(e)))),
};
match obj.get("complete") {
None => Some(Err(CheckedError::Truncated(
"stream ended before terminal status".into(),
))),
Some(Value::Bool(true)) => None,
_ => {
let err = obj
.get("error")
.cloned()
.unwrap_or_else(|| Value::String("unknown stream error".into()));
Some(Err(CheckedError::Stream(err)))
}
}
}
}
impl<R: Read> Iterator for CheckedArrayIter<R> {
type Item = Result<Value, CheckedError>;
fn next(&mut self) -> Option<Self::Item> {
if let Some(p) = self.pending.take() {
self.finished = true;
return Some(p);
}
if self.finished {
return None;
}
if !self.header_done {
if let Err(e) = self.ensure_header() {
self.finished = true;
return Some(Err(e));
}
}
if self.pos > 0 {
self.buf.drain(0..self.pos);
self.pos = 0;
}
loop {
while self.pos < self.buf.len() {
let ch = self.buf[self.pos];
if self.in_string {
if self.escape {
self.escape = false;
} else if ch == b'\\' {
self.escape = true;
} else if ch == b'"' {
self.in_string = false;
}
self.pos += 1;
continue;
}
match ch {
b'"' => self.in_string = true,
b'{' | b'[' => {
self.depth += 1;
if self.max_depth > 0 && self.depth > self.max_depth {
self.finished = true;
return Some(Err(CheckedError::Io(io::Error::new(
io::ErrorKind::InvalidData,
"decode_checked_array: nesting depth exceeded",
))));
}
}
b']' if self.depth == 0 => {
let s = std::str::from_utf8(&self.buf[..self.pos])
.unwrap_or("")
.trim()
.to_string();
self.pos += 1;
if s.is_empty() {
self.finished = true;
return self.finish();
}
let parsed = serde_json::from_str::<Value>(&s)
.map_err(|e| CheckedError::Io(io::Error::from(e)));
match parsed {
Err(e) => {
self.finished = true;
return Some(Err(e));
}
Ok(v) => {
match self.finish() {
None => self.finished = true,
Some(err) => self.pending = Some(err),
}
return Some(Ok(v));
}
}
}
b'}' | b']' => self.depth -= 1,
b',' if self.depth == 0 => {
let s = std::str::from_utf8(&self.buf[..self.pos])
.unwrap_or("")
.trim()
.to_string();
self.pos += 1;
return Some(
serde_json::from_str(&s)
.map_err(|e| CheckedError::Io(io::Error::from(e))),
);
}
_ => {}
}
self.pos += 1;
}
if !self.more() {
self.finished = true;
return Some(Err(CheckedError::Truncated(
"stream ended inside items array".into(),
)));
}
}
}
}