anttp 0.26.0

AntTP is an HTTP server for the Autonomi Network
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

#![cfg_attr(test, warn(unused_imports, unused_variables, dead_code))]
use actix_web::HttpRequest;

pub mod archive_controller;
//pub mod pointer_controller;
//pub mod register_controller;
pub mod file_controller;
//pub mod public_archive_controller;
pub mod tarchive_controller;
//pub mod private_scratchpad_controller;
//pub mod public_scratchpad_controller;
pub mod chunk_controller;
//pub mod graph_controller;
pub mod public_data_controller;
pub mod command_controller;
pub mod connect_controller;
//pub mod pnr_controller;
//pub mod key_value_controller;
pub mod resolver_controller;
pub mod crypto_controller;

#[derive(Clone,Debug)]
pub enum StoreType {
    Memory,
    Disk,
    Network
}

impl PartialEq for StoreType {
    fn eq(&self, other: &Self) -> bool {
        match other {
            StoreType::Memory => matches!(self, StoreType::Memory),
            StoreType::Disk => matches!(self, StoreType::Disk),
            StoreType::Network => matches!(self, StoreType::Network),
        }
    }
}

impl From<String> for StoreType {
    fn from(s: String) -> Self {
        match s.to_lowercase().as_str() {
            "memory" => StoreType::Memory,
            "disk" => StoreType::Disk,
            _ => StoreType::Network
        }
    }
}

fn get_store_type(request: &HttpRequest) -> StoreType {
    StoreType::from(
        match request.headers().get("x-store-type") {
            Some(x_store_type) => x_store_type.to_str().unwrap_or("").to_string(),
            None => "".to_string()
        }
    )
}

#[derive(Clone,Debug)]
pub enum DataKey {
    Personal,
    Resolver,
    Custom(String),
}

impl From<String> for DataKey {
    fn from(s: String) -> Self {
        match s.to_lowercase().as_str() {
            "resolver" => DataKey::Resolver,
            "personal" | "" => DataKey::Personal,
            custom => DataKey::Custom(custom.to_string())
        }
    }
}

fn data_key(request: &HttpRequest) -> DataKey {
    match request.headers().get("x-data-key") {
        Some(header_value) => DataKey::from(header_value.to_str().unwrap_or("").to_string()),
        None => DataKey::Personal
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_cache_type_eq() {
        assert_eq!(StoreType::Memory == StoreType::Memory, true);
        assert_eq!(StoreType::Memory == StoreType::Disk, false);
        assert_eq!(StoreType::Memory == StoreType::Network, false);

        assert_eq!(StoreType::Disk == StoreType::Disk, true);
        assert_eq!(StoreType::Disk == StoreType::Memory, false);
        assert_eq!(StoreType::Disk == StoreType::Network, false);

        assert_eq!(StoreType::Network == StoreType::Network, true);
        assert_eq!(StoreType::Network == StoreType::Memory, false);
        assert_eq!(StoreType::Network == StoreType::Disk, false);
    }

    #[test]
    fn test_cache_type_from_string() {
        assert_eq!(StoreType::from("memory".to_string()), StoreType::Memory);
        assert_eq!(StoreType::from("disk".to_string()), StoreType::Disk);
        assert_eq!(StoreType::from("network".to_string()), StoreType::Network);
        assert_eq!(StoreType::from("other".to_string()), StoreType::Network);
        assert_eq!(StoreType::from("".to_string()), StoreType::Network);
    }

    #[test]
    fn test_get_store_type() {
        use actix_web::test::TestRequest;

        let req = TestRequest::default()
            .insert_header(("x-store-type", "memory"))
            .to_http_request();
        assert_eq!(get_store_type(&req), StoreType::Memory);

        let req = TestRequest::default()
            .insert_header(("x-store-type", "disk"))
            .to_http_request();
        assert_eq!(get_store_type(&req), StoreType::Disk);

        let req = TestRequest::default()
            .insert_header(("x-store-type", "network"))
            .to_http_request();
        assert_eq!(get_store_type(&req), StoreType::Network);

        let req = TestRequest::default()
            .to_http_request();
        assert_eq!(get_store_type(&req), StoreType::Network);
    }
}