use crate::{Error, ErrorKind, Result};
use bytes::Bytes;
use serde::{Serialize, Serializer, de::DeserializeOwned};
use serde_json::value::RawValue;
use std::{
fmt,
sync::{
Arc,
atomic::{AtomicUsize, Ordering},
},
};
#[derive(Clone)]
pub struct RawJson {
bytes: Bytes,
owner: Option<Arc<FrameOwner>>,
}
impl RawJson {
pub fn from_bytes(bytes: Bytes) -> Result<Self> {
if bytes.len() > 128 * 1024 * 1024 {
return Err(Error::new(ErrorKind::ResourceLimit {
resource: "原始 JSON 字节",
}));
}
crate::wire::check_depth(&bytes, 128)
.map_err(|error| Error::with_source(ErrorKind::InvalidArgument, error))?;
let _: &RawValue = serde_json::from_slice(&bytes)
.map_err(|error| Error::with_source(ErrorKind::InvalidArgument, error))?;
Ok(Self { bytes, owner: None })
}
pub fn as_bytes(&self) -> &[u8] {
&self.bytes
}
pub fn decode<T: DeserializeOwned>(&self) -> Result<T> {
serde_json::from_slice(&self.bytes)
.map_err(|error| Error::with_source(ErrorKind::Decode, error))
}
pub(crate) fn backing_len(&self) -> usize {
self.owner
.as_ref()
.map_or(self.bytes.len(), |owner| owner.bytes.len())
}
}
impl fmt::Debug for RawJson {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("RawJson")
.field("len", &self.bytes.len())
.field("backing_len", &self.backing_len())
.finish()
}
}
impl Serialize for RawJson {
fn serialize<S: Serializer>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error> {
let raw: &RawValue =
serde_json::from_slice(&self.bytes).map_err(serde::ser::Error::custom)?;
raw.serialize(serializer)
}
}
pub(crate) struct ByteBudget {
used: AtomicUsize,
limit: usize,
}
impl ByteBudget {
pub(crate) fn new(limit: usize) -> Self {
Self {
used: AtomicUsize::new(0),
limit,
}
}
#[cfg(test)]
pub(crate) fn used(&self) -> usize {
self.used.load(Ordering::Acquire)
}
}
struct FrameOwner {
bytes: Bytes,
budget: Arc<ByteBudget>,
}
impl Drop for FrameOwner {
fn drop(&mut self) {
self.budget
.used
.fetch_sub(self.bytes.len(), Ordering::AcqRel);
}
}
#[derive(Clone)]
pub(crate) struct FrameText {
text: bytestring::ByteString,
_owner: Arc<FrameOwner>,
}
impl FrameText {
pub(crate) fn as_str(&self) -> &str {
&self.text
}
}
#[derive(Clone)]
pub(crate) struct Frame {
owner: Arc<FrameOwner>,
}
impl Frame {
pub(crate) fn new(bytes: Bytes, budget: Arc<ByteBudget>) -> Result<Self> {
let len = bytes.len();
budget
.used
.fetch_update(Ordering::AcqRel, Ordering::Acquire, |used| {
used.checked_add(len).filter(|&total| total <= budget.limit)
})
.map_err(|_| {
Error::new(ErrorKind::ResourceLimit {
resource: "入站 backing 字节",
})
})?;
Ok(Self {
owner: Arc::new(FrameOwner { bytes, budget }),
})
}
#[cfg(test)]
pub(crate) fn as_bytes(&self) -> &[u8] {
&self.owner.bytes
}
pub(crate) fn len(&self) -> usize {
self.owner.bytes.len()
}
pub(crate) fn json(&self, raw: &RawValue) -> Result<RawJson> {
let start = raw.get().as_ptr() as usize;
let base = self.owner.bytes.as_ptr() as usize;
let Some(offset) = start.checked_sub(base) else {
return Err(Error::new(ErrorKind::InvalidArgument));
};
let Some(end) = offset
.checked_add(raw.get().len())
.filter(|&end| end <= self.len())
else {
return Err(Error::new(ErrorKind::InvalidArgument));
};
Ok(RawJson {
bytes: self.owner.bytes.slice(offset..end),
owner: Some(self.owner.clone()),
})
}
pub(crate) fn text(&self, raw: &str) -> Result<FrameText> {
let start = raw.as_ptr() as usize;
let base = self.owner.bytes.as_ptr() as usize;
let Some(offset) = start.checked_sub(base) else {
return Err(Error::new(ErrorKind::InvalidArgument));
};
let Some(end) = offset
.checked_add(raw.len())
.filter(|&end| end <= self.len())
else {
return Err(Error::new(ErrorKind::InvalidArgument));
};
let text = bytestring::ByteString::try_from(self.owner.bytes.slice(offset..end))
.map_err(|error| Error::with_source(ErrorKind::InvalidArgument, error))?;
Ok(FrameText {
text,
_owner: self.owner.clone(),
})
}
pub(crate) fn empty_json(&self) -> RawJson {
RawJson {
bytes: Bytes::from_static(b"{}"),
owner: Some(self.owner.clone()),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn last_reference_owns_permit() {
let bytes = Bytes::from_static(br#"{"id":1,"result":{"x":1}}"#);
let len = bytes.len();
let budget = Arc::new(ByteBudget::new(len));
let frame = Frame::new(bytes, budget.clone()).unwrap();
let envelope = crate::wire::parse(frame.as_bytes(), 1024, 128).unwrap();
let raw = frame.json(envelope.result.unwrap()).unwrap();
assert_eq!(raw.backing_len(), len);
assert_eq!(raw.decode::<serde_json::Value>().unwrap()["x"], 1);
let clone = raw.clone();
drop(raw);
drop(frame);
assert_eq!(budget.used(), len);
assert!(Frame::new(Bytes::from_static(b"{}"), budget.clone()).is_err());
drop(clone);
assert_eq!(budget.used(), 0);
let frame = Frame::new(Bytes::from_static(b"{}"), budget.clone()).unwrap();
let empty = frame.empty_json();
drop(frame);
assert_eq!(budget.used(), 2);
drop(empty);
assert_eq!(budget.used(), 0);
}
#[test]
fn budget_competing_owners_and_exact_depth() {
let budget = Arc::new(ByteBudget::new(2));
let barrier = Arc::new(std::sync::Barrier::new(3));
let workers: Vec<_> = (0..2)
.map(|_| {
let budget = budget.clone();
let barrier = barrier.clone();
std::thread::spawn(move || {
barrier.wait();
let held = Frame::new(Bytes::from_static(b"{}"), budget);
barrier.wait();
held
})
})
.collect();
barrier.wait();
barrier.wait();
let frames: Vec<_> = workers
.into_iter()
.map(|worker| worker.join().unwrap())
.collect();
assert_eq!(frames.iter().filter(|value| value.is_ok()).count(), 1);
assert_eq!(budget.used(), 2);
drop(frames);
assert_eq!(budget.used(), 0);
let exact = format!("{}0{}", "[".repeat(128), "]".repeat(128));
assert!(RawJson::from_bytes(Bytes::from(exact)).is_ok());
}
#[test]
fn shared_method_text_keeps_owner() {
let bytes = Bytes::from_static(r#"{"method":"Echo.消息"}"#.as_bytes());
let budget = Arc::new(ByteBudget::new(1024));
let frame = Frame::new(bytes, budget.clone()).unwrap();
let envelope = crate::wire::parse(frame.as_bytes(), 1024, 128).unwrap();
let method = envelope.method.as_deref().unwrap();
let text = frame.text(method).unwrap();
assert_eq!(text.as_str(), "Echo.消息");
assert_eq!(text.as_str().as_ptr(), method.as_ptr());
assert!(frame.text("external").is_err());
let clone = text.clone();
let len = frame.len();
drop(frame);
drop(text);
assert_eq!(budget.used(), len);
drop(clone);
assert_eq!(budget.used(), 0);
}
#[test]
fn validation_and_external_slice() {
for invalid in [b"".as_slice(), b"null null", b"{", &[255]] {
assert!(RawJson::from_bytes(Bytes::copy_from_slice(invalid)).is_err());
}
let text = format!("{}0{}", "[".repeat(129), "]".repeat(129));
assert!(RawJson::from_bytes(Bytes::from(text)).is_err());
let frame = Frame::new(Bytes::from_static(b"{}"), Arc::new(ByteBudget::new(8))).unwrap();
let other: Box<RawValue> = serde_json::from_str("null").unwrap();
assert!(frame.json(&other).is_err());
assert!(
!format!(
"{:?}",
RawJson::from_bytes(Bytes::from_static(br#""secret""#)).unwrap()
)
.contains("secret")
);
}
}