Skip to main content

day_script_protocol/
memory.rs

1// Copyright © The Daybrite Project
2// SPDX-License-Identifier: MPL-2.0
3
4use serde::{Deserialize, Deserializer, Serialize};
5
6/// A memory threshold in bytes. Accepts an integer byte count or a size string;
7/// serialization uses bytes, so the wire is independent of the author's unit spelling.
8#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
9#[serde(transparent)]
10pub struct MemorySize(pub u64);
11
12impl<'de> Deserialize<'de> for MemorySize {
13    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
14        #[derive(Deserialize)]
15        #[serde(untagged)]
16        enum Input {
17            Bytes(u64),
18            Size(String),
19        }
20        match Input::deserialize(deserializer)? {
21            Input::Bytes(bytes) => Ok(Self(bytes)),
22            Input::Size(size) => parse(&size).map(Self).ok_or_else(|| {
23                serde::de::Error::custom(
24                    "memory size must be a non-negative whole byte count within u64, e.g. 500MB, 1G, or 512MiB",
25                )
26            }),
27        }
28    }
29}
30
31fn parse(size: &str) -> Option<u64> {
32    let size = size.trim();
33    let end = size
34        .find(|c: char| !c.is_ascii_digit() && c != '.')
35        .unwrap_or(size.len());
36    let (number, unit) = size.split_at(end);
37    let multiplier: u128 = match unit.trim().to_ascii_lowercase().as_str() {
38        "" | "b" => 1,
39        "k" | "kb" => 1_000,
40        "m" | "mb" => 1_000_000,
41        "g" | "gb" => 1_000_000_000,
42        "t" | "tb" => 1_000_000_000_000,
43        "kib" => 1 << 10,
44        "mib" => 1 << 20,
45        "gib" => 1 << 30,
46        "tib" => 1 << 40,
47        _ => return None,
48    };
49    let (whole, fraction) = number.split_once('.').unwrap_or((number, ""));
50    if whole.is_empty()
51        || !fraction.bytes().all(|c| c.is_ascii_digit())
52        || (number.contains('.') && fraction.is_empty())
53    {
54        return None;
55    }
56    let scale = 10_u128.checked_pow(fraction.len().try_into().ok()?)?;
57    let numerator = whole
58        .parse::<u128>()
59        .ok()?
60        .checked_mul(scale)?
61        .checked_add(if fraction.is_empty() {
62            0
63        } else {
64            fraction.parse().ok()?
65        })?;
66    let bytes = numerator.checked_mul(multiplier)?;
67    if bytes % scale != 0 {
68        return None;
69    }
70    u64::try_from(bytes / scale).ok()
71}