1use serde::Deserialize;
2
3fn deserialize_base64<'de, D: serde::Deserializer<'de>>(
4 deserializer: D,
5) -> Result<bytes::Bytes, D::Error> {
6 struct Base64Visitor;
7
8 impl<'de> serde::de::Visitor<'de> for Base64Visitor {
9 type Value = bytes::Bytes;
10
11 fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
12 formatter.write_str("a string containing json data")
13 }
14
15 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
16 where
17 E: serde::de::Error,
18 {
19 use base64::Engine;
20 base64::engine::general_purpose::STANDARD
21 .decode(v)
22 .map(Into::into)
23 .map_err(E::custom)
24 }
25 }
26
27 deserializer.deserialize_str(Base64Visitor)
28}
29
30#[derive(Debug, Clone, Deserialize)]
31#[serde(rename_all = "camelCase")]
32pub struct Stat {
33 pub mode: u32,
34 pub nlink: u64,
35 pub rdev: u64,
36 pub size: u64,
37 pub blksize: u64,
38 pub blocks: u64,
39 pub atime: i64,
40 pub atime_nsec: i64,
41 pub mtime: i64,
42 pub mtime_nsec: i64,
43 pub ctime: i64,
44 pub ctime_nsec: i64,
45}
46
47#[derive(Debug, Clone, Deserialize)]
48#[serde(rename_all = "camelCase")]
49pub struct LookupResult {
50 pub inode: u64,
51 pub stat: Stat,
52}
53
54#[derive(Debug, Clone, Deserialize)]
55#[serde(rename_all = "snake_case", tag = "code")]
56pub enum LookupError {
57 ModelNotFound,
58 SnapshotNotFound,
59 #[serde(rename = "ESTALE")]
60 ESTALE,
61 #[serde(rename = "ENOENT")]
62 ENOENT,
63 #[serde(rename = "ENOTDIR")]
64 ENOTDIR,
65 BadCredentials,
66 TooManyRequests,
67 PaymentRequired,
68 Unknown,
69 #[serde(rename_all = "camelCase")]
70 InvalidParameter {
71 parameter_name: String,
72 reason: String,
73 },
74}
75
76#[derive(Debug, Clone, Deserialize)]
77#[serde(rename_all = "camelCase")]
78pub struct GetattrResult {
79 pub stat: Stat,
80}
81
82#[derive(Debug, Clone, Deserialize)]
83#[serde(rename_all = "snake_case", tag = "code")]
84pub enum GetattrError {
85 ModelNotFound,
86 SnapshotNotFound,
87 #[serde(rename = "ESTALE")]
88 ESTALE,
89 BadCredentials,
90 TooManyRequests,
91 PaymentRequired,
92 Unknown,
93 #[serde(rename_all = "camelCase")]
94 InvalidParameter {
95 parameter_name: String,
96 reason: String,
97 },
98}
99
100#[derive(Debug, Clone, Deserialize)]
101#[serde(rename_all = "camelCase")]
102pub struct SetattrResult {
103 pub stat: Stat,
104}
105
106#[derive(Debug, Clone, Deserialize)]
107#[serde(rename_all = "snake_case", tag = "code")]
108pub enum SetattrError {
109 ModelNotFound,
110 AccessDenied,
111 #[serde(rename = "ESTALE")]
112 ESTALE,
113 #[serde(rename = "EFBIG")]
114 EFBIG,
115 #[serde(rename = "EISDIR")]
116 EISDIR,
117 BadCredentials,
118 TooManyRequests,
119 PaymentRequired,
120 Unknown,
121 #[serde(rename_all = "camelCase")]
122 InvalidParameter {
123 parameter_name: String,
124 reason: String,
125 },
126}
127
128#[derive(Debug, Clone, Deserialize)]
129#[serde(rename_all = "camelCase")]
130pub struct MknodResult {
131 pub inode: u64,
132 pub stat: Stat,
133}
134
135#[derive(Debug, Clone, Deserialize)]
136#[serde(rename_all = "snake_case", tag = "code")]
137pub enum MknodError {
138 ModelNotFound,
139 AccessDenied,
140 #[serde(rename = "ESTALE")]
141 ESTALE,
142 #[serde(rename = "ENOTDIR")]
143 ENOTDIR,
144 #[serde(rename = "EEXIST")]
145 EEXIST,
146 #[serde(rename = "ENOSPC")]
147 ENOSPC,
148 BadCredentials,
149 TooManyRequests,
150 PaymentRequired,
151 Unknown,
152 #[serde(rename_all = "camelCase")]
153 InvalidParameter {
154 parameter_name: String,
155 reason: String,
156 },
157}
158
159#[derive(Debug, Clone, Deserialize)]
160#[serde(rename_all = "camelCase")]
161pub struct ReadResult {
162 #[serde(skip_deserializing)]
163 pub data: bytes::Bytes,
164}
165
166#[derive(Debug, Clone, Deserialize)]
167#[serde(rename_all = "snake_case", tag = "code")]
168pub enum ReadError {
169 ModelNotFound,
170 SnapshotNotFound,
171 #[serde(rename = "ESTALE")]
172 ESTALE,
173 #[serde(rename = "EISDIR")]
174 EISDIR,
175 #[serde(rename = "EINVAL")]
176 EINVAL,
177 BadCredentials,
178 TooManyRequests,
179 PaymentRequired,
180 Unknown,
181 #[serde(rename_all = "camelCase")]
182 InvalidParameter {
183 parameter_name: String,
184 reason: String,
185 },
186}
187
188#[derive(Debug, Clone, Deserialize)]
189#[serde(rename_all = "camelCase")]
190pub struct WriteResult {
191 pub bytes_written: u64,
192}
193
194#[derive(Debug, Clone, Deserialize)]
195#[serde(rename_all = "snake_case", tag = "code")]
196pub enum WriteError {
197 ModelNotFound,
198 AccessDenied,
199 #[serde(rename = "ESTALE")]
200 ESTALE,
201 #[serde(rename = "EISDIR")]
202 EISDIR,
203 #[serde(rename = "ENOSPC")]
204 ENOSPC,
205 #[serde(rename = "EINVAL")]
206 EINVAL,
207 BadCredentials,
208 TooManyRequests,
209 PaymentRequired,
210 Unknown,
211 #[serde(rename_all = "camelCase")]
212 InvalidParameter {
213 parameter_name: String,
214 reason: String,
215 },
216}
217
218#[derive(Debug, Clone, Deserialize)]
219#[serde(rename_all = "camelCase")]
220pub struct SymlinkResult {
221 pub inode: u64,
222 pub stat: Stat,
223}
224
225#[derive(Debug, Clone, Deserialize)]
226#[serde(rename_all = "snake_case", tag = "code")]
227pub enum SymlinkError {
228 ModelNotFound,
229 AccessDenied,
230 #[serde(rename = "ESTALE")]
231 ESTALE,
232 #[serde(rename = "ENOTDIR")]
233 ENOTDIR,
234 #[serde(rename = "EEXIST")]
235 EEXIST,
236 #[serde(rename = "ENOSPC")]
237 ENOSPC,
238 BadCredentials,
239 TooManyRequests,
240 PaymentRequired,
241 Unknown,
242 #[serde(rename_all = "camelCase")]
243 InvalidParameter {
244 parameter_name: String,
245 reason: String,
246 },
247}
248
249#[derive(Debug, Clone, Deserialize)]
250#[serde(rename_all = "camelCase")]
251pub struct ReadlinkResult {
252 #[serde(skip_deserializing)]
253 pub link: bytes::Bytes,
254}
255
256#[derive(Debug, Clone, Deserialize)]
257#[serde(rename_all = "snake_case", tag = "code")]
258pub enum ReadlinkError {
259 ModelNotFound,
260 SnapshotNotFound,
261 #[serde(rename = "ESTALE")]
262 ESTALE,
263 #[serde(rename = "EINVAL")]
264 EINVAL,
265 BadCredentials,
266 TooManyRequests,
267 PaymentRequired,
268 Unknown,
269 #[serde(rename_all = "camelCase")]
270 InvalidParameter {
271 parameter_name: String,
272 reason: String,
273 },
274}
275
276#[derive(Debug, Clone, Deserialize)]
277#[serde(rename_all = "camelCase")]
278pub struct MkdirResult {
279 pub inode: u64,
280 pub stat: Stat,
281}
282
283#[derive(Debug, Clone, Deserialize)]
284#[serde(rename_all = "snake_case", tag = "code")]
285pub enum MkdirError {
286 ModelNotFound,
287 AccessDenied,
288 #[serde(rename = "ESTALE")]
289 ESTALE,
290 #[serde(rename = "ENOTDIR")]
291 ENOTDIR,
292 #[serde(rename = "EEXIST")]
293 EEXIST,
294 #[serde(rename = "ENOSPC")]
295 ENOSPC,
296 BadCredentials,
297 TooManyRequests,
298 PaymentRequired,
299 Unknown,
300 #[serde(rename_all = "camelCase")]
301 InvalidParameter {
302 parameter_name: String,
303 reason: String,
304 },
305}
306
307#[derive(Debug, Clone, Deserialize)]
308#[serde(rename_all = "camelCase")]
309pub struct UnlinkResult {}
310
311#[derive(Debug, Clone, Deserialize)]
312#[serde(rename_all = "snake_case", tag = "code")]
313pub enum UnlinkError {
314 ModelNotFound,
315 AccessDenied,
316 #[serde(rename = "ESTALE")]
317 ESTALE,
318 #[serde(rename = "ENOTDIR")]
319 ENOTDIR,
320 #[serde(rename = "ENOENT")]
321 ENOENT,
322 #[serde(rename = "EISDIR")]
323 EISDIR,
324 BadCredentials,
325 TooManyRequests,
326 PaymentRequired,
327 Unknown,
328 #[serde(rename_all = "camelCase")]
329 InvalidParameter {
330 parameter_name: String,
331 reason: String,
332 },
333}
334
335#[derive(Debug, Clone, Deserialize)]
336#[serde(rename_all = "camelCase")]
337pub struct RmdirResult {}
338
339#[derive(Debug, Clone, Deserialize)]
340#[serde(rename_all = "snake_case", tag = "code")]
341pub enum RmdirError {
342 ModelNotFound,
343 AccessDenied,
344 #[serde(rename = "ESTALE")]
345 ESTALE,
346 #[serde(rename = "ENOTDIR")]
347 ENOTDIR,
348 #[serde(rename = "ENOENT")]
349 ENOENT,
350 #[serde(rename = "ENOTEMPTY")]
351 ENOTEMPTY,
352 BadCredentials,
353 TooManyRequests,
354 PaymentRequired,
355 Unknown,
356 #[serde(rename_all = "camelCase")]
357 InvalidParameter {
358 parameter_name: String,
359 reason: String,
360 },
361}
362
363#[derive(Debug, Clone, Deserialize)]
364#[serde(rename_all = "camelCase")]
365pub struct RenameResult {}
366
367#[derive(Debug, Clone, Deserialize)]
368#[serde(rename_all = "snake_case", tag = "code")]
369pub enum RenameError {
370 ModelNotFound,
371 AccessDenied,
372 #[serde(rename = "ESTALE")]
373 ESTALE,
374 #[serde(rename = "ENOTDIR")]
375 ENOTDIR,
376 #[serde(rename = "ENOENT")]
377 ENOENT,
378 #[serde(rename = "ENOTEMPTY")]
379 ENOTEMPTY,
380 #[serde(rename = "EEXIST")]
381 EEXIST,
382 #[serde(rename = "EISDIR")]
383 EISDIR,
384 #[serde(rename = "ENOSPC")]
385 ENOSPC,
386 BadCredentials,
387 TooManyRequests,
388 PaymentRequired,
389 Unknown,
390 #[serde(rename_all = "camelCase")]
391 InvalidParameter {
392 parameter_name: String,
393 reason: String,
394 },
395}
396
397#[derive(Debug, Clone, Deserialize)]
398#[serde(rename_all = "camelCase")]
399pub struct LinkResult {
400 pub stat: Stat,
401}
402
403#[derive(Debug, Clone, Deserialize)]
404#[serde(rename_all = "snake_case", tag = "code")]
405pub enum LinkError {
406 ModelNotFound,
407 AccessDenied,
408 #[serde(rename = "ESTALE")]
409 ESTALE,
410 #[serde(rename = "ENOTDIR")]
411 ENOTDIR,
412 #[serde(rename = "EPERM")]
413 EPERM,
414 #[serde(rename = "EEXIST")]
415 EEXIST,
416 #[serde(rename = "ENOSPC")]
417 ENOSPC,
418 BadCredentials,
419 TooManyRequests,
420 PaymentRequired,
421 Unknown,
422 #[serde(rename_all = "camelCase")]
423 InvalidParameter {
424 parameter_name: String,
425 reason: String,
426 },
427}
428
429#[derive(Debug, Clone, Deserialize)]
430#[serde(rename_all = "camelCase")]
431pub struct ReaddirEntry {
432 #[serde(deserialize_with = "deserialize_base64")]
434 pub basename: bytes::Bytes,
435 pub filetype: u32,
437 pub ino: u64,
439}
440
441#[derive(Debug, Clone, Deserialize)]
442#[serde(rename_all = "camelCase")]
443pub struct ReaddirResult {
444 pub entries: Vec<ReaddirEntry>,
445}
446
447#[derive(Debug, Clone, Deserialize)]
448#[serde(rename_all = "snake_case", tag = "code")]
449pub enum ReaddirError {
450 ModelNotFound,
451 SnapshotNotFound,
452 #[serde(rename = "ESTALE")]
453 ESTALE,
454 #[serde(rename = "ENOTDIR")]
455 ENOTDIR,
456 BadCredentials,
457 TooManyRequests,
458 PaymentRequired,
459 Unknown,
460 #[serde(rename_all = "camelCase")]
461 InvalidParameter {
462 parameter_name: String,
463 reason: String,
464 },
465}
466
467#[derive(Debug, Clone, Deserialize)]
468#[serde(rename_all = "camelCase")]
469pub struct RmdirAllResult {}
470
471#[derive(Debug, Clone, Deserialize)]
472#[serde(rename_all = "snake_case", tag = "code")]
473pub enum RmdirAllError {
474 ModelNotFound,
475 AccessDenied,
476 #[serde(rename = "ESTALE")]
477 ESTALE,
478 #[serde(rename = "ENOTDIR")]
479 ENOTDIR,
480 #[serde(rename = "ENOENT")]
481 ENOENT,
482 BadCredentials,
483 TooManyRequests,
484 PaymentRequired,
485 Unknown,
486 #[serde(rename_all = "camelCase")]
487 InvalidParameter {
488 parameter_name: String,
489 reason: String,
490 },
491}
492
493#[derive(Debug, Clone, Deserialize)]
494#[serde(rename_all = "camelCase")]
495pub struct CopyResult {}
496
497#[derive(Debug, Clone, Deserialize)]
498#[serde(rename_all = "snake_case", tag = "code")]
499pub enum CopyError {
500 ModelNotFound,
501 AccessDenied,
502 #[serde(rename = "ESTALE")]
503 ESTALE,
504 #[serde(rename = "ENOTDIR")]
505 ENOTDIR,
506 #[serde(rename = "EEXIST")]
507 EEXIST,
508 #[serde(rename = "ENOSPC")]
509 ENOSPC,
510 BadCredentials,
511 TooManyRequests,
512 PaymentRequired,
513 Unknown,
514 #[serde(rename_all = "camelCase")]
515 InvalidParameter {
516 parameter_name: String,
517 reason: String,
518 },
519}