velen 0.1.10

A simple package for starting a HTTP server
Documentation 
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

pub mod server_utils {
    use std::collections::HashMap;

    use regex::Regex;
    pub fn get_method_path_query(content: &str) -> (String, String, HashMap<String, String>) {
        /* First extract http method and (path + query_params) */
        let outer_re = Regex::new(r"^(GET|POST|DELETE|PUT|HEAD|PATCH) (.+) HTTP").unwrap();
        let outer_caps = outer_re.captures(content).unwrap();

        let method = outer_caps.get(1).unwrap().as_str().to_string();
        let path_with_query = outer_caps.get(2).unwrap().as_str().to_string();

        /* Then extract path and query_param string*/
        let inner_re = Regex::new(r"(.*)\?(.*)").unwrap();
        let inner_caps = inner_re.captures(&path_with_query);

        let path: String;
        let query_string: String;

        if let Some(caps) = inner_caps {
            path = caps.get(1).unwrap().as_str().to_string();
            query_string = caps.get(2).unwrap().as_str().to_string();
        } else {
            /* No Query String is present */
            path = path_with_query;
            query_string = String::from("");
        }

        let query_param_pairs = query_string.split("&");

        /* Then extract individual Key and Values */
        let pair_re = Regex::new(r"(.*)=(.*)").unwrap();

        let mut query_map = HashMap::new();

        for pair in query_param_pairs {
            let pair_caps = pair_re.captures(pair);

            if let Some(caps) = pair_caps {
                let key = caps.get(1).unwrap().as_str().to_string();
                let value = caps.get(2).unwrap().as_str().to_string();

                query_map.insert(key, value);
            }
        }
        return (method, path, query_map);
    }
    pub fn parse_body(content: &str) -> String {
        let mut itr = content.split("\r\n\r\n");
        itr.next();
        let val = itr
            .next()
            .unwrap()
            .trim_end_matches(char::from(0))
            .to_string();
        return val;
    }
    pub fn parse_headers(content: &str) -> HashMap<String, String> {
        let mut headers = HashMap::new();
        let mut itr = content.split("\r\n");
        /* Skip status line */
        itr.next();

        for each_line in itr {
            match each_line {
                "" => {
                    /* "" signifies end of headers and start of request payload */
                    break;
                }
                _ => {
                    let mut key_value_pair = each_line.split(": ");
                    headers.insert(
                        key_value_pair.next().unwrap().to_string(),
                        key_value_pair.next().unwrap().to_string(),
                    );
                }
            }
        }
        return headers;
    }
}