trillium 1.1.0

a modular toolkit for building async web apps
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

use std::net::SocketAddr;
use trillium_http::{HttpConfig, HttpContext, Swansong, TypeSet, type_set::entry::Entry};

/// This struct represents information about the currently connected
/// server.
///
/// It is passed to [`Handler::init`](crate::Handler::init).

#[derive(Debug, Default)]
pub struct Info(HttpContext);
impl From<HttpContext> for Info {
    fn from(value: HttpContext) -> Self {
        Self(value)
    }
}
impl From<Info> for HttpContext {
    fn from(value: Info) -> Self {
        value.0
    }
}

impl AsRef<TypeSet> for Info {
    fn as_ref(&self) -> &TypeSet {
        self.0.as_ref()
    }
}
impl AsMut<TypeSet> for Info {
    fn as_mut(&mut self) -> &mut TypeSet {
        self.0.as_mut()
    }
}

impl Info {
    /// Returns the `local_addr` of a bound tcp listener, if such a
    /// thing exists for this server
    pub fn tcp_socket_addr(&self) -> Option<&SocketAddr> {
        self.shared_state()
    }

    /// Returns the `local_addr` of a bound unix listener, if such a
    /// thing exists for this server
    #[cfg(unix)]
    pub fn unix_socket_addr(&self) -> Option<&std::os::unix::net::SocketAddr> {
        self.shared_state()
    }

    /// Borrow a type from the shared state [`TypeSet`] on this `Info`.
    pub fn shared_state<T: Send + Sync + 'static>(&self) -> Option<&T> {
        self.0.shared_state().get()
    }

    /// Insert a type into the shared state typeset, returning the previous value if any
    pub fn insert_shared_state<T: Send + Sync + 'static>(&mut self, value: T) -> Option<T> {
        self.0.shared_state_mut().insert(value)
    }

    /// Mutate a type in the shared state typeset
    pub fn shared_state_mut<T: Send + Sync + 'static>(&mut self) -> Option<&mut T> {
        self.0.shared_state_mut().get_mut()
    }

    /// Returns an [`Entry`] into the shared state typeset.
    pub fn shared_state_entry<T: Send + Sync + 'static>(&mut self) -> Entry<'_, T> {
        self.0.shared_state_mut().entry()
    }

    /// chainable interface to insert a type into the shared state typeset
    #[must_use]
    pub fn with_shared_state<T: Send + Sync + 'static>(mut self, value: T) -> Self {
        self.insert_shared_state(value);
        self
    }

    /// borrow the http config
    pub fn config(&self) -> &HttpConfig {
        self.0.config()
    }

    /// mutate the http config
    pub fn config_mut(&mut self) -> &mut HttpConfig {
        self.0.config_mut()
    }

    /// Borrow the [`Swansong`] graceful shutdown interface for this server
    pub fn swansong(&self) -> &Swansong {
        self.0.swansong()
    }
}