memfaultd 1.26.1

Memfault daemon for embedded Linux systems. Observability, logging, crash reporting, and updating all in one service. Learn more at https://docs.memfault.com/
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

//
// Copyright (c) Memfault, Inc.
// See License.txt for details
use eyre::Result;
use tiny_http::{Request, ResponseBox};

/// Return type of the HttpHandler
pub enum HttpHandlerResult {
    /// Request was processed and response is proposed.
    Response(ResponseBox),
    /// An error occurred while processing the request (will return 500).
    Error(String),
    /// Request not handled by this handler. Continue to next handler.
    NotHandled,
}

/// This little helper makes it possible to use the ? operator in handlers when
/// you have already checked method and path and know that they should handle
/// the request, possibly failing while doing so.
///
/// ```
/// # use eyre::Result;
/// use tiny_http::{Request, Response, ResponseBox};
/// use memfaultd::http_server::{HttpHandler, HttpHandlerResult};
///
/// struct CounterHandler {
///   counter: u32,
/// };
///
/// impl CounterHandler {
///   fn handle_read(&self) -> Result<ResponseBox> {
///     Ok(Response::from_string("42").boxed())
///   }
/// }
///
/// impl HttpHandler for CounterHandler {
///   fn handle_request(&self, r: &mut Request) -> HttpHandlerResult {
///     if r.url() == "/count" {
///       self.handle_read().into()
///     }
///     else {
///       HttpHandlerResult::NotHandled
///     }
///   }
/// }
/// ```
impl From<Result<ResponseBox>> for HttpHandlerResult {
    fn from(r: Result<ResponseBox>) -> Self {
        match r {
            Ok(response) => HttpHandlerResult::Response(response),
            Err(e) => HttpHandlerResult::Error(e.to_string()),
        }
    }
}

/// An HttpHandler can handle a request and send a response.
pub trait HttpHandler: Send {
    /// Handle a request and prepares the response.
    ///
    /// ```
    /// # use eyre::Result;
    /// use tiny_http::{ Request, Response, ResponseBox };
    /// use memfaultd::http_server::{HttpHandler, HttpHandlerResult};
    ///
    /// struct CounterHandler {
    ///   counter: u32,
    /// };
    ///
    /// impl HttpHandler for CounterHandler {
    ///   fn handle_request(&self, r: &mut Request) -> HttpHandlerResult {
    ///     HttpHandlerResult::Response(Response::empty(200).boxed())
    ///   }
    /// }
    ///
    /// ```
    fn handle_request(&self, request: &mut Request) -> HttpHandlerResult;
}

#[cfg(test)]
mod tests {
    use tiny_http::ResponseBox;

    use super::HttpHandlerResult;

    impl HttpHandlerResult {
        pub fn expect(self, m: &'static str) -> ResponseBox {
            match self {
                HttpHandlerResult::Response(response) => response,
                HttpHandlerResult::Error(e) => panic!("{}: HttpHandlerResult::Error({})", m, e),
                HttpHandlerResult::NotHandled => panic!("{}: HttpHandlerResult::Nothandled", m),
            }
        }
    }
}