aitch 0.1.1

A HTTP server toolkit, loosely based on Go's net/http.
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

use std::collections::HashMap;

use http;

use {
    box_handler, Body, BodyStream, BoxedHandler, BoxedResponse, Handler, Responder, ResponseBuilder,
};

/// A simple request router, which determines which handler to call based on the request URI's path.
///
/// This is a simple request router, inspired by Go's [`net/http` `ServeMux`].
///
/// It matches the path component of a HTTP request's URI against a collection of registered path
/// prefixes, and calls the handler whose path prefix most closely matches. (e.g. if both `/path/a`
/// and `/path/ab` are registered, a request for `/path/abc/` will call the latter).
///
/// This router is intended primarily to serve as an example of writing complex middleware using
/// aitch, and library users are encouraged to read its [source code].
///
/// The router is not intended for production applications, and lacks many features that are present
/// in the routers of other web frameworks/toolkits.
///
/// [`net/http` `ServeMux`]: https://golang.org/pkg/net/http/#ServeMux
/// [source code]: ../../src/aitch/middlewares/router.rs.html
///
/// # Example
///
/// ```no_run
/// extern crate aitch;
/// extern crate http;
///
/// use aitch::servers::hyper::Server;
/// use aitch::{middlewares, Responder, ResponseBuilder, Result};
/// use http::Request;
///
/// fn handler1(_req: Request<()>, mut resp: ResponseBuilder) -> impl Responder {
///     resp.body("Handler 1!".to_owned())
/// }
///
/// fn handler2(_req: Request<()>, mut resp: ResponseBuilder) -> impl Responder {
///     resp.body("Handler 2!".to_owned())
/// }
///
/// fn main() -> Result<()> {
///     let mut router = middlewares::SimpleRouter::new();
///     router.register_handler("/", handler1);
///     router.register_handler("/handler2", handler2);
///
///     let handler = middlewares::with_stdout_logging(router);
///
///     let addr = "127.0.0.1:3000".parse()?;
///     println!("Listening on http://{}", addr);
///     Server::new(addr, handler)?.run()
/// }
/// ```

#[derive(Default)]
pub struct SimpleRouter {
    handlers: HashMap<String, BoxedHandler>,
}

impl SimpleRouter {
    /// Creates a new `SimpleRouter`, with no routes registered.
    pub fn new() -> Self {
        SimpleRouter::default()
    }

    /// Registers a handler with the given pattern.
    ///
    /// This method registers a new handler with the router, using the provided pattern.
    ///
    /// See the [module level documentation] for more details on how patterns are matched.
    ///
    /// [module level documentation]: ./index.html
    ///
    /// # Panics
    ///
    /// This method panics if a handler is already registered with the provided pattern.
    pub fn register_handler<S, H, ReqBody>(&mut self, pattern: S, handler: H)
    where
        S: Into<String>,
        H: Handler<ReqBody>,
        ReqBody: Body,
    {
        let pattern = pattern.into();
        if self.handlers.contains_key(&pattern) {
            panic!("SimpleRouter: Tried to register pattern twice: {}", pattern);
        }
        self.handlers.insert(pattern, box_handler(handler));
    }

    /// Returns the handler to be used for a request with the given URI.
    ///
    /// Returns `None` if no handler matches the URI.
    pub fn handler(&self, uri: &http::Uri) -> Option<(&String, &BoxedHandler)> {
        self.handlers
            .iter()
            .filter(|&(pattern, _)| uri.path().starts_with(pattern))
            .max_by_key(|&(pattern, _)| pattern.len())
    }
}

impl Handler<BodyStream> for SimpleRouter {
    type Resp = BoxedResponse;

    fn handle(&self, req: http::Request<BodyStream>, mut resp: ResponseBuilder) -> BoxedResponse {
        match self.handler(req.uri()) {
            Some((_, handler)) => handler.handle(req, resp),
            None => resp.status(http::StatusCode::NOT_FOUND)
                .body(())
                .into_response(),
        }
    }
}