miasht 0.0.5

Minimum asynchronous HTTP server/client 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

use fibers::net::TcpStream;
use futures::{self, Finished, Future};

use {Error, Server, TransportStream};
use defaults;
use server::{Connection, HandleConnection, HandleSocket};

pub type RawConnection = Connection<TcpStream>;

#[derive(Debug)]
pub struct SimpleHttpServer<A, F> {
    max_request_header_count: usize,
    min_buffer_size: usize,
    max_buffer_size: usize,
    argument: A,
    callback: fn(A, RawConnection) -> F,
}
impl<A, F> SimpleHttpServer<A, F>
where
    A: Clone + Send + 'static,
    F: Future<Item = (), Error = ()> + Send + 'static,
{
    pub fn new(argument: A, callback: fn(A, RawConnection) -> F) -> Self {
        SimpleHttpServer {
            max_request_header_count: defaults::MAX_HEADER_COUNT,
            min_buffer_size: defaults::MIN_BUFFER_SIZE,
            max_buffer_size: defaults::MAX_BUFFER_SIZE,
            argument: argument,
            callback: callback,
        }
    }
}
impl<A, F> SimpleHttpServer<A, F> {
    pub fn max_request_header_count(&mut self, count: usize) -> &mut Self {
        self.max_request_header_count = count;
        self
    }
    pub fn min_buffer_size(&mut self, size: usize) -> &mut Self {
        assert!(size <= self.max_buffer_size);
        self.min_buffer_size = size;
        self
    }
    pub fn max_buffer_size(&mut self, size: usize) -> &mut Self {
        assert!(self.min_buffer_size <= size);
        self.max_buffer_size = size;
        self
    }
}
impl<A, F> Server for SimpleHttpServer<A, F>
where
    A: Clone + Send + 'static,
    F: Future<Item = (), Error = ()> + Send + 'static,
{
    type Transport = TcpStream;
    type SocketHandler = RawSocketHandler;
    type ConnectionHandler = ConnectionHandleCallback<A, TcpStream, F>;
    fn create_handlers(&mut self) -> (Self::SocketHandler, Self::ConnectionHandler) {
        let socket_handler = RawSocketHandler {
            max_request_header_count: self.max_request_header_count,
            min_buffer_size: self.min_buffer_size,
            max_buffer_size: self.max_buffer_size,
        };
        let connection_handler =
            ConnectionHandleCallback::new(self.argument.clone(), self.callback);
        (socket_handler, connection_handler)
    }
}

#[derive(Debug)]
pub struct RawSocketHandler {
    max_request_header_count: usize,
    min_buffer_size: usize,
    max_buffer_size: usize,
}
impl HandleSocket for RawSocketHandler {
    type Transport = TcpStream;
    type Future = Finished<Connection<Self::Transport>, Error>;
    fn handle(self, socket: TcpStream) -> Self::Future {
        let connection = Connection::new(
            socket,
            self.min_buffer_size,
            self.max_buffer_size,
            self.max_request_header_count,
        );
        futures::finished(connection)
    }
}

#[derive(Debug)]
pub struct ConnectionHandleCallback<A, T, F> {
    argument: A,
    callback: fn(A, Connection<T>) -> F,
}
impl<A, T, F> ConnectionHandleCallback<A, T, F>
where
    A: Send + 'static,
    T: TransportStream + 'static,
    F: Future<Item = (), Error = ()> + Send + 'static,
{
    pub fn new(argument: A, callback: fn(A, Connection<T>) -> F) -> Self {
        ConnectionHandleCallback {
            argument: argument,
            callback: callback,
        }
    }
}
impl<A, T, F> HandleConnection for ConnectionHandleCallback<A, T, F>
where
    A: Send + 'static,
    T: TransportStream + 'static,
    F: Future<Item = (), Error = ()> + Send + 'static,
{
    type Transport = T;
    type Future = F;
    fn handle(self, connection: Connection<Self::Transport>) -> Self::Future {
        (self.callback)(self.argument, connection)
    }
}