envoy_http 0.0.9

A minimal and pragmatic Rust web application framework built for rapid development
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189

use std::{fmt::Debug, collections::HashMap, any::{TypeId, Any}};

use hyper::{Version, Body, Method, header::{HeaderName, HeaderValue}, Uri};
use routefinder::Captures;

/// ## The context of a request.
///
/// This is a wrapper around a [crate::http::Request] and a [crate::http::Response]
/// that provides access to the request and response
/// as well as some additional information such as the state
/// and parameters.
#[derive(Debug)]
pub struct Context {

    /// The request that was made.
    pub req: crate::Request<Body>,
    ctx: HashMap<TypeId, Box<dyn Any + Send>>,
    /// Any error captured during the request.
    /// The parsed request parameters
    pub params: Vec<Captures<'static, 'static>>,
}


impl Context {
    /// Create a new [Context] with a [crate::http::Request].
    pub(crate) fn new(

        req: crate::Request<Body>,
        params: Vec<Captures<'static, 'static>>,
    ) -> Self {
        Self {
            req,
            ctx: HashMap::new(),
            params,
        }
    }

    /// Access the request's HTTP method.
    #[must_use]
    pub fn method(&self) -> &Method {
        self.req.method()
    }

    /// Access the request's full URI method.
    #[must_use]
    pub fn uri(&self) -> &Uri {
        self.req.uri()
    }

    /// Access the request's HTTP version.
    #[must_use]
    pub fn version(&self) -> Version {
        self.req.version()
    }

    /// Get the destination host for this request.
    ///
    /// This is determined in the following priority:
    /// 1. `Forwarded` header `host` key
    /// 2. The first `X-Forwarded-Host` header
    /// 3. `Host` header
    /// 4. URL domain, if any
    #[must_use]
    pub fn host(&self) -> Option<&str> {
        self.req.uri().host()
    }

    /// Get an HTTP header.
    /// ```
    #[must_use]
    pub fn header(
        &self,
        key: impl Into<HeaderName>,
    ) -> Option<&HeaderValue> {
        self.req.headers().get(key.into())
    }

    /// Get a mutable reference to a header.
    pub fn header_mut(&mut self, name: impl Into<HeaderName>) -> Option<&mut HeaderValue> {
        self.req.headers_mut().get_mut(name.into())
    }

    /// Set an HTTP header.
    pub fn insert_header(
        &mut self,
        name: impl Into<HeaderName>,
        value: impl Into<HeaderValue>,
    ) -> Option<HeaderValue> {
        self.req.headers_mut().insert(name.into(), value.into())
    }

    /// Remove a header.
    pub fn remove_header(&mut self, name: impl Into<HeaderName>) -> Option<HeaderValue> {
        self.req.headers_mut().remove(name.into())
    }

    /// Try borrow a context value
    #[must_use]
    pub fn try_borrow<T: 'static>(&self) -> Option<&T> {
        self.ctx.get(&TypeId::of::<T>()).and_then(|v| v.downcast_ref::<T>())
    }

    /// Borrow a context value
    /// Panics if the value does not exist
    #[must_use]
    pub fn borrow<T: 'static>(&self) -> &T {
        self.try_borrow().unwrap_or_else(|| {
            panic!("Context value `{}` does not exist", std::any::type_name::<T>())
        })
    }

    /// Try borrow a mutable context value
    #[must_use]
    pub fn try_borrow_mut<T: 'static>(&mut self) -> Option<&mut T> {
        self.ctx.get_mut(&TypeId::of::<T>()).and_then(|v| v.downcast_mut::<T>())
    }

    /// Borrow a mutable context value
    /// Panics if the value does not exist
    #[must_use]
    pub fn borrow_mut<T: 'static>(&mut self) -> &mut T {
        match self.try_borrow_mut() {
            Some(v) => v,
            None => panic!("Context value `{}` does not exist", std::any::type_name::<T>()),
        }
    }

    /// Try take a context value
    #[must_use]
    pub fn try_take<T: 'static>(&mut self) -> Option<T> {
        self.ctx.remove(&TypeId::of::<T>()).and_then(|v| v.downcast::<T>().map(|v| *v).ok())
    }

    /// Take a context value
    /// Panics if the value does not exist
    #[must_use]
    pub fn take<T: 'static>(&mut self) -> T {
        match self.try_take() {
            Some(v) => v,
            None => panic!("Context value `{}` does not exist", std::any::type_name::<T>()),
        }
    }

    /// Insert a context value
    pub fn insert<T: Send + 'static>(&mut self, value: T) -> Option<T> {
        self.ctx.insert(TypeId::of::<T>(), Box::new(value)).map(|v| *v.downcast::<T>().unwrap())
    }

    /// Extract and parse a route parameter by name.
    ///
    /// Returns the parameter as a `&str`, borrowed from this `Request`.
    ///
    /// The name should *not* include the leading `:`.
    ///
    /// # Errors
    ///
    /// An error is returned if `key` is not a valid parameter for the route.

    pub fn param(&self, key: &str) -> crate::Result<&str> {
        self.params
            .iter()
            .rev()
            .find_map(|captures| captures.get(key))
            .ok_or_else(|| anyhow::anyhow!("Param \"{}\" not found", key.to_string()).into())
    }

    /// Fetch the wildcard from the route, if it exists
    ///
    /// Returns the parameter as a `&str`, borrowed from this `Request`.

    pub fn wildcard(&self) -> Option<&str> {
        self.params
            .iter()
            .rev()
            .find_map(|captures| captures.wildcard())
    }
}

impl AsRef<crate::Request<Body>> for Context {
    fn as_ref(&self) -> &crate::Request<Body> {
        &self.req
    }
}

impl AsMut<crate::Request<Body>> for Context {
    fn as_mut(&mut self) -> &mut crate::Request<Body> {
        &mut self.req
    }
}