axol 0.2.0

Axol Web Framework
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

use std::time::Duration;

use axol_http::typed_headers::{Error as HeaderError, Header, HeaderName, HeaderValue};

#[derive(Debug)]
pub struct GrpcTimeout(pub Duration);

static GRPC_TIMEOUT: HeaderName = HeaderName::from_static("grpc-timeout");

impl Header for GrpcTimeout {
    fn name() -> &'static HeaderName {
        &GRPC_TIMEOUT
    }

    fn decode<'i, I: Iterator<Item = &'i HeaderValue>>(values: &mut I) -> Result<Self, HeaderError>
    where
        Self: Sized,
    {
        let value = values.next().ok_or_else(HeaderError::invalid)?;
        let value = value.to_str().map_err(|_| HeaderError::invalid())?;
        if value.len() < 2 {
            return Err(HeaderError::invalid());
        }
        let suffix = value.chars().next_back().ok_or_else(HeaderError::invalid)?;
        let count: u64 = value[..value.len() - suffix.len_utf8()]
            .parse()
            .map_err(|_| HeaderError::invalid())?;
        if count > 9999999 {
            return Err(HeaderError::invalid());
        }
        let ns_per_unit: u64 = match suffix {
            'n' => 1,
            'u' => 1000,
            'm' => 1000000,
            'S' => 1000000000,
            'M' => 60000000000,
            'H' => 3600000000000,
            _ => return Err(HeaderError::invalid()),
        };
        let total_ns = count.saturating_mul(ns_per_unit);
        Ok(Self(Duration::from_nanos(total_ns)))
    }

    fn encode<E: Extend<HeaderValue>>(&self, values: &mut E) {
        let ns = self.0.as_nanos().min(u64::MAX as u128) as u64;
        //TODO: we need to add rounding so we don't go over 8 char limit
        if ns.is_multiple_of(3600000000000) {
            values.extend(std::iter::once(
                HeaderValue::from_str(&format!("{}H", ns / 3600000000000)).unwrap(),
            ));
        } else if ns.is_multiple_of(60000000000) {
            values.extend(std::iter::once(
                HeaderValue::from_str(&format!("{}M", ns / 60000000000)).unwrap(),
            ));
        } else if ns.is_multiple_of(1000000000) {
            values.extend(std::iter::once(
                HeaderValue::from_str(&format!("{}S", ns / 1000000000)).unwrap(),
            ));
        } else if ns.is_multiple_of(1000000) {
            values.extend(std::iter::once(
                HeaderValue::from_str(&format!("{}m", ns / 1000000)).unwrap(),
            ));
        } else if ns.is_multiple_of(1000) {
            values.extend(std::iter::once(
                HeaderValue::from_str(&format!("{}u", ns / 1000)).unwrap(),
            ));
        } else {
            values.extend(std::iter::once(
                HeaderValue::from_str(&format!("{}n", ns)).unwrap(),
            ));
        }
    }
}