use std::collections::HashSet;
use std::fmt;
use serde::de::{
self, DeserializeOwned, DeserializeSeed, Error as _, MapAccess, SeqAccess, Visitor,
};
use crate::job::model::JobWireCodec;
const MAX_JSON_DEPTH: usize = 64;
const MAX_JSON_NODES: usize = 100_000;
pub fn validate_json_payload(bytes: &[u8]) -> core::result::Result<(), String> {
let mut budget = JsonBudget {
nodes: 0,
};
let mut deserializer = serde_json::Deserializer::from_slice(bytes);
StrictJsonSeed {
budget: &mut budget,
depth: 0,
}
.deserialize(&mut deserializer)
.map_err(|error| error.to_string())?;
deserializer.end().map_err(|error| error.to_string())
}
pub fn decode_json_payload<T: DeserializeOwned>(bytes: &[u8]) -> core::result::Result<T, String> {
validate_json_payload(bytes)?;
serde_json::from_slice(bytes).map_err(|error| {
let category = match error.classify() {
serde_json::error::Category::Io => "IO",
serde_json::error::Category::Syntax => "SYNTAX",
serde_json::error::Category::Data => "DATA",
serde_json::error::Category::Eof => "EOF",
};
format!(
"JSON 业务类型解码失败:{category},行 {},列 {}",
error.line(),
error.column()
)
})
}
struct JsonBudget {
nodes: usize,
}
impl JsonBudget {
fn consume<E: de::Error>(&mut self) -> core::result::Result<(), E> {
self.nodes = self.nodes.saturating_add(1);
if self.nodes > MAX_JSON_NODES {
return Err(E::custom("JSON 节点数超过安全上限"));
}
Ok(())
}
}
struct StrictJsonSeed<'a> {
budget: &'a mut JsonBudget,
depth: usize,
}
impl<'de> DeserializeSeed<'de> for StrictJsonSeed<'_> {
type Value = ();
fn deserialize<D>(self, deserializer: D) -> core::result::Result<Self::Value, D::Error>
where
D: serde::Deserializer<'de>,
{
if self.depth > MAX_JSON_DEPTH {
return Err(D::Error::custom("JSON 深度超过安全上限"));
}
self.budget.consume::<D::Error>()?;
deserializer.deserialize_any(StrictJsonVisitor {
budget: self.budget,
depth: self.depth,
})
}
}
struct StrictJsonVisitor<'a> {
budget: &'a mut JsonBudget,
depth: usize,
}
impl<'de> Visitor<'de> for StrictJsonVisitor<'_> {
type Value = ();
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("满足 RedisJob 安全合同的 JSON 值")
}
fn visit_bool<E: de::Error>(self, _value: bool) -> core::result::Result<(), E> {
Ok(())
}
fn visit_i64<E: de::Error>(self, _value: i64) -> core::result::Result<(), E> {
Ok(())
}
fn visit_u64<E: de::Error>(self, _value: u64) -> core::result::Result<(), E> {
Ok(())
}
fn visit_f64<E: de::Error>(self, _value: f64) -> core::result::Result<(), E> {
Ok(())
}
fn visit_str<E: de::Error>(self, _value: &str) -> core::result::Result<(), E> {
Ok(())
}
fn visit_string<E: de::Error>(self, _value: String) -> core::result::Result<(), E> {
Ok(())
}
fn visit_none<E: de::Error>(self) -> core::result::Result<(), E> {
Ok(())
}
fn visit_unit<E: de::Error>(self) -> core::result::Result<(), E> {
Ok(())
}
fn visit_some<D>(self, deserializer: D) -> core::result::Result<(), D::Error>
where
D: serde::Deserializer<'de>,
{
StrictJsonSeed {
budget: self.budget,
depth: self.depth.saturating_add(1),
}
.deserialize(deserializer)
}
fn visit_seq<A>(self, mut sequence: A) -> core::result::Result<(), A::Error>
where
A: SeqAccess<'de>,
{
while sequence
.next_element_seed(StrictJsonSeed {
budget: self.budget,
depth: self.depth.saturating_add(1),
})?
.is_some()
{}
Ok(())
}
fn visit_map<A>(self, mut map: A) -> core::result::Result<(), A::Error>
where
A: MapAccess<'de>,
{
let mut keys = HashSet::new();
while let Some(key) = map.next_key::<String>()? {
self.budget.consume::<A::Error>()?;
if key == "@class" || key == "@type" {
return Err(A::Error::custom("JSON 包含禁止的动态类型元数据"));
}
if !keys.insert(key) {
return Err(A::Error::custom("JSON 对象包含重复键"));
}
map.next_value_seed(StrictJsonSeed {
budget: self.budget,
depth: self.depth.saturating_add(1),
})?;
}
Ok(())
}
}
pub trait JobParameter: Sized {
fn decode(codec: JobWireCodec, bytes: &[u8]) -> core::result::Result<Self, String>;
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct JobPayload {
bytes: Vec<u8>,
codec: JobWireCodec,
schema_id: String,
}
impl JobPayload {
pub fn new(
bytes: impl Into<Vec<u8>>,
codec: JobWireCodec,
schema_id: impl Into<String>,
) -> Self {
Self {
bytes: bytes.into(),
codec,
schema_id: schema_id.into(),
}
}
pub fn bytes(&self) -> &[u8] {
&self.bytes
}
pub fn codec(&self) -> JobWireCodec {
self.codec
}
pub fn schema_id(&self) -> &str {
&self.schema_id
}
}