swindon 0.7.8

An HTTP edge (frontend) server with smart websockets support 
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

use std::fmt;
use std::net::SocketAddr;

use tk_http::Status;
use tk_http::server::Head;
use trimmer::{Variable, Var, DataError, Output};

use request_id::RequestId;
use logging::context::{Context, AsContext};


pub struct EarlyRequest<'a> {
    pub addr: SocketAddr,
    pub head: &'a Head<'a>,
    pub request_id: RequestId,
}

#[derive(Debug)]
pub struct EarlyResponse {
    pub status: Status,
}

#[derive(Debug)]
pub struct FakeResponse {
}

// Temporary page object
pub struct FakePage<'a> {
    pub request: EarlyRequest<'a>,
    pub response: FakeResponse,
}

pub struct EarlyError<'a> {
    pub request: EarlyRequest<'a>,
    pub response: EarlyResponse,
}

#[derive(Debug)]
pub struct Display<D: fmt::Display + fmt::Debug>(D);

impl<'a> AsContext for EarlyError<'a> {
    fn as_context(&self) -> Context {
        let mut ctx = Context::new();
        ctx.set("request", &self.request);
        ctx.set("response", &self.response);
        ctx
    }
}

impl<'a> AsContext for FakePage<'a> {
    fn as_context(&self) -> Context {
        let mut ctx = Context::new();
        ctx.set("request", &self.request);
        ctx.set("response", &self.response);
        ctx
    }
}

impl<'a> Variable<'a> for EarlyRequest<'a> {
    fn attr<'x>(&'x self, attr: &str) -> Result<Var<'x, 'a>, DataError>
        where 'a: 'x
    {
        match attr {
            // TODO(tailhook) return just IP when trimmer is updated
            "client_ip" => Ok(Var::owned(self.addr.ip())),
            "host" => Ok(Var::owned(
                self.head.host()
                .unwrap_or("-")
                .to_string())),
            "method" => Ok(Var::owned(self.head.method())),
            "path" => Ok(Var::owned(self.head.path())),
            "version" => Ok(Var::owned(Display(self.head.version()))),
            _ => Err(DataError::AttrNotFound),
        }
    }
    fn typename(&self) -> &'static str {
        "EarlyRequest"
    }
}

impl<'a> fmt::Debug for EarlyRequest<'a> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("EarlyRequest")
         .finish()
    }
}

impl<'a> Variable<'a> for EarlyResponse {
    fn attr<'x>(&'x self, attr: &str) -> Result<Var<'x, 'a>, DataError>
        where 'a: 'x
    {
        match attr {
            "status_code" => Ok(Var::owned(self.status.code())),
            _ => Err(DataError::AttrNotFound),
        }
    }
    fn typename(&self) -> &'static str {
        "EarlyResponse"
    }
}

impl<'a> Variable<'a> for FakeResponse {
    fn attr<'x>(&'x self, attr: &str) -> Result<Var<'x, 'a>, DataError>
        where 'a: 'x
    {
        match attr {
            "status_code" => Ok(Var::str("non-404")),
            _ => Err(DataError::AttrNotFound),
        }
    }
    fn typename(&self) -> &'static str {
        "FakeResponse"
    }
}

impl<'a, D: fmt::Display + fmt::Debug + 'a> Variable<'a> for Display<D> {
    fn as_bool(&self) -> Result<bool, DataError> {
        Ok(true)
    }
    fn output(&self) -> Result<Output, DataError> {
        Ok((&self.0).into())
    }
    fn typename(&self) -> &'static str {
        "Display"
    }
}