htrpc 0.0.19

HTTP based RPC library
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
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

use fibers::net::TcpStream;
use futures::Future;
use miasht::server::{Request, Response};
use std::collections::HashMap;
use std::sync::Arc;
use url::Url;

use procedure::EntryPoint;
use types::{HttpMethod, HttpStatus};
use {Error, ErrorKind, Result};

type HandleHttpRequestResult = Box<
    dyn Future<Item = (Response<TcpStream>, Box<dyn AsRef<[u8]> + Send + 'static>), Error = Error>
        + Send
        + 'static,
>;
type HandleHttpRequest =
    Box<dyn Fn(Url, Request<TcpStream>) -> HandleHttpRequestResult + Send + 'static>;

#[derive(Clone)]
pub struct Router {
    trie: Arc<Trie>,
}
unsafe impl Send for Router {}
impl Router {
    pub fn route(
        &self,
        url: &Url,
        request: &Request<TcpStream>,
    ) -> ::std::result::Result<&HandleHttpRequest, HttpStatus> {
        let mut trie = self.trie.root();
        for segment in url.path_segments().expect("Never fails") {
            if let Some(child) = trie.get_child(segment) {
                trie = child;
            } else {
                return Err(HttpStatus::NotFound);
            }
        }
        trie.get_value(request.method())
            .ok_or(HttpStatus::MethodNotAllowed)
    }
}

pub struct RouterBuilder {
    trie: Trie,
}
impl RouterBuilder {
    pub fn new() -> Self {
        RouterBuilder { trie: Trie::new() }
    }
    pub fn finish(self) -> Router {
        Router {
            trie: Arc::new(self.trie),
        }
    }
    pub fn register_handler<H>(
        &mut self,
        method: HttpMethod,
        entry_point: EntryPoint,
        handler: H,
    ) -> Result<()>
    where
        H: Send + 'static + Fn(Url, Request<TcpStream>) -> HandleHttpRequestResult,
    {
        track!(self.trie.insert(method, &entry_point, Box::new(handler)))?;
        Ok(())
    }
}

struct Trie {
    root: TrieNode,
}
impl Trie {
    pub fn new() -> Self {
        Trie {
            root: TrieNode::new(),
        }
    }
    pub fn insert(
        &mut self,
        method: HttpMethod,
        entry_point: &EntryPoint,
        handler: HandleHttpRequest,
    ) -> Result<()> {
        let mut node = &mut self.root;
        for segment in entry_point.segments() {
            use types::PathSegment::*;
            let key = match *segment {
                Val(s) => Some(s),
                Var => None,
            };
            let prev = node;
            node = prev.children.entry(key).or_insert_with(|| TrieNode::new());
        }
        track_assert!(
            !node.leafs.contains_key(&method),
            ErrorKind::Invalid,
            "Conflicted: entry_point={:?}, method={:?}",
            entry_point,
            method
        );
        node.leafs.insert(method, handler);
        Ok(())
    }
    pub fn root(&self) -> &TrieNode {
        &self.root
    }
}

struct TrieNode {
    children: HashMap<Option<&'static str>, TrieNode>,
    leafs: HashMap<HttpMethod, HandleHttpRequest>,
}
impl TrieNode {
    pub fn new() -> Self {
        TrieNode {
            children: HashMap::new(),
            leafs: HashMap::new(),
        }
    }
    pub fn get_child<'a>(&'a self, segment: &str) -> Option<&'a Self> {
        let segment: &'static str = unsafe { &*(segment as *const _) as _ };
        self.children
            .get(&Some(segment))
            .or_else(|| self.children.get(&None))
    }
    pub fn get_value(&self, method: HttpMethod) -> Option<&HandleHttpRequest> {
        self.leafs.get(&method)
    }
}