envoy_http 0.0.6

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

use std::{fmt::Debug};

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

/// ## 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: typemap::ShareDebugMap,
    /// 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: typemap::ShareDebugMap::custom(),
            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())
    }

    /// Get a context value.
    #[must_use]
    pub fn get<T: Key<Value = T> + Debug + Send + Sync>(&self) -> Option<&T> {
        self.ctx.get::<T>()
    }

    /// Get a mutable reference to value stored in context.
    #[must_use]
    pub fn get_mut<T: Key<Value = T> + Debug + Send + Sync>(&mut self) -> Option<&mut T> {
        self.ctx.get_mut::<T>()
    }

    /// Set a context value.
    pub fn set<T: Key<Value = T> + Debug + Send + Sync>(&mut self, val: T) -> Option<T> {
        self.ctx.insert::<T>(val)
    }

    /// 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
    }
}