httimple 0.1.7

Simple HTTP2 package 😃 
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

use std::collections::HashMap;
use proto::frame::data::Data;
use proto::frame::headers::Headers;
use proto::frame::continuation::Continuation;

///
/// A call from the client
/// 

#[derive(Debug)]
pub struct Call {
    headers: HashMap<Vec<u8>, Vec<u8>>,
    data: Vec<u8>,
    end_headers: bool,
    end_stream: bool,
}

impl Call {

    ///
    /// Used internally
    /// 

    pub fn from() -> Call {
        Call { 
            headers: HashMap::new(),
            data: Vec::new(),
            end_headers: false,
            end_stream: false
        }
    }

    ///
    /// Used internally
    /// 

    pub fn is_ready(&self) -> bool {
        self.end_headers && self.end_stream
    }


    ///
    /// Used internally
    /// 


    pub fn insert_data(&mut self, data: Data) {
        self.end_stream = data.is_end_stream();
        self.data.append(&mut data.get_payload());
    }


    ///
    /// Used internally
    /// 


    pub fn insert_headers(&mut self, headers: Headers) {
        self.end_stream = headers.is_end_stream();
        self.end_headers = headers.is_end_headers();
        match headers.get_headers() {   
            Some(headers) => {
                self.insert_all(headers);
            }, 
            None => {
                println!("[ERROR] Headers not decoded...");
            }
        }
    }


    ///
    /// Used internally
    /// 


    pub fn insert_continuation(&mut self, continuation: Continuation) {
        self.end_headers = continuation.is_end_headers();
        self.insert_all(continuation.get_headers());
    }


    ///
    /// Gets the path from the call.
    /// 

    pub fn path(&self) -> Option<&Vec<u8>> {
        for (key, value) in &self.headers {
            println!("{:?} {:?}", String::from_utf8(key.clone()).unwrap(), String::from_utf8(value.clone()).unwrap());
        }
        println!("{:?}", self.headers.get(String::from(":path").as_bytes()));
        self.headers.get(String::from(":path").as_bytes())
    }

    // Helper 

    fn insert_all(&mut self, headers: HashMap<Vec<u8>, Vec<u8>>) {
        for (key, value) in &headers {
            self.headers.insert(key.clone(), value.clone());
        }
    }


    ///
    /// Gets the method from the call
    /// 


    pub fn method(&self) -> String {
        String::from_utf8(self.headers.get(String::from(":method").as_bytes()).unwrap().clone()).unwrap()
    }


    ///
    /// Checks if the call is of the type GET
    /// 

    pub fn is_get(&self) -> bool {
        self.method() == String::from("GET")
    }

    ///
    /// Checks if the call is of the type POST
    /// 


    pub fn is_post(&self) -> bool {
        self.method() == String::from("POST")
    }


}