1use std::io::{self, Read};
4
5use rusttorch_core::{Result, RustTorchError};
6use serde::{Deserialize, Serialize};
7
8#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
21pub struct ResourceLimits {
22 pub max_encoded_bytes: usize,
24 pub max_decoded_bytes: usize,
26 pub max_tensor_elements: usize,
28 pub max_image_dimension: usize,
30 pub max_records: usize,
32 pub max_columns: usize,
34 pub max_string_bytes: usize,
36 pub max_tokens: usize,
38 pub max_columnar_bytes: usize,
40 pub max_media_seconds: u64,
42 pub max_streams: usize,
44}
45
46impl Default for ResourceLimits {
47 fn default() -> Self {
48 Self {
49 max_encoded_bytes: 64 * 1024 * 1024,
50 max_decoded_bytes: 256 * 1024 * 1024,
51 max_tensor_elements: 64 * 1024 * 1024,
52 max_image_dimension: 16_384,
53 max_records: 1_000_000,
54 max_columns: 4_096,
55 max_string_bytes: 1024 * 1024,
56 max_tokens: 1_000_000,
57 max_columnar_bytes: 256 * 1024 * 1024,
58 max_media_seconds: 3_600,
59 max_streams: 32,
60 }
61 }
62}
63
64impl ResourceLimits {
65 pub const fn unlimited() -> Self {
67 Self {
68 max_encoded_bytes: usize::MAX,
69 max_decoded_bytes: usize::MAX,
70 max_tensor_elements: usize::MAX,
71 max_image_dimension: usize::MAX,
72 max_records: usize::MAX,
73 max_columns: usize::MAX,
74 max_string_bytes: usize::MAX,
75 max_tokens: usize::MAX,
76 max_columnar_bytes: usize::MAX,
77 max_media_seconds: u64::MAX,
78 max_streams: usize::MAX,
79 }
80 }
81
82 pub fn check(&self, field: &'static str, actual: usize, maximum: usize) -> Result<()> {
84 if actual > maximum {
85 return Err(RustTorchError::InvalidConfiguration {
86 field,
87 reason: format!("{actual} exceeds resource limit {maximum}"),
88 });
89 }
90 Ok(())
91 }
92
93 pub fn tensor_elements(&self, dimensions: &[usize]) -> Result<usize> {
95 for &dimension in dimensions {
96 self.check("tensor dimension", dimension, i64::MAX as usize)?;
97 }
98 let elements = dimensions
99 .iter()
100 .try_fold(1usize, |n, &d| n.checked_mul(d))
101 .ok_or_else(|| RustTorchError::InvalidConfiguration {
102 field: "tensor elements",
103 reason: "shape product overflows usize".into(),
104 })?;
105 self.check(
106 "tensor elements",
107 elements,
108 self.max_tensor_elements.min(i64::MAX as usize),
109 )?;
110 Ok(elements)
111 }
112
113 pub fn read_encoded(&self, reader: impl Read) -> io::Result<Vec<u8>> {
116 let mut bytes = Vec::new();
117 reader
118 .take((self.max_encoded_bytes as u64).saturating_add(1))
119 .read_to_end(&mut bytes)?;
120 if bytes.len() > self.max_encoded_bytes {
121 return Err(io::Error::new(
122 io::ErrorKind::InvalidData,
123 "encoded resource limit exceeded",
124 ));
125 }
126 Ok(bytes)
127 }
128}
129
130#[cfg(test)]
131mod tests {
132 use super::*;
133 #[test]
134 fn rejects_oversize_inputs_and_shape_overflow() {
135 let limits = ResourceLimits {
136 max_encoded_bytes: 2,
137 max_tensor_elements: 8,
138 ..Default::default()
139 };
140 assert_eq!(limits.read_encoded(&b"ab"[..]).unwrap(), b"ab");
141 assert!(limits.read_encoded(&b"abc"[..]).is_err());
142 assert!(limits.tensor_elements(&[3, 3]).is_err());
143 assert!(
144 ResourceLimits::unlimited()
145 .tensor_elements(&[usize::MAX, 2])
146 .is_err()
147 );
148 }
149}