rainmaker-components 0.1.0

Component abstractions for rainmaker
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

#![cfg(target_os = "espidf")]

use embedded_svc::http::Headers;

use esp_idf_svc::{
    http::{
        server::{EspHttpConnection, EspHttpServer, Request},
        // Headers,
    },
    io::{Read, Write},
};

use crate::{error::Error, http::base::*};

impl From<esp_idf_svc::http::Method> for HttpMethod {
    fn from(value: esp_idf_svc::http::Method) -> Self {
        use esp_idf_svc::http::Method;
        match value {
            Method::Get => HttpMethod::GET,
            Method::Post => HttpMethod::POST,
            _ => unreachable!(),
        }
    }
}

impl From<HttpMethod> for esp_idf_svc::http::Method {
    fn from(value: HttpMethod) -> Self {
        match value {
            HttpMethod::GET => esp_idf_svc::http::Method::Get,
            HttpMethod::POST => esp_idf_svc::http::Method::Post,
        }
    }

    /* fn from(self) -> esp_idf_svc::http::Method {
    } */
}
// from esp_idf_http_request to custom_request
impl From<&mut Request<&mut EspHttpConnection<'_>>> for HttpRequest {
    fn from(req: &mut Request<&mut EspHttpConnection>) -> Self {
        let buf_len = match req.content_len() {
            Some(l) => l as usize,
            None => 0,
        };
        let mut buf = vec![0; buf_len];
        req.read_exact(&mut buf).unwrap();

        Self {
            method: req.method().into(),
            url: req.uri().to_owned(),
            data: buf,
        }
    }
}

impl HttpServer<esp_idf_svc::http::server::EspHttpServer<'static>> {
    pub fn new(config: HttpConfiguration) -> Result<Self, Error> {
        let http_config = esp_idf_svc::http::server::Configuration {
            http_port: config.port,
            ..Default::default()
        };
        Ok(HttpServer(EspHttpServer::new(&http_config)?))
    }

    pub fn add_listener(
        &mut self,
        path: String,
        method: HttpMethod,
        callback: Box<dyn Fn(HttpRequest) -> HttpResponse + Send + 'static>,
    ) {
        self.0
            .fn_handler(
                path.as_str(),
                method.into(),
                move |mut req| -> Result<(), Error> {
                    let user_req = HttpRequest::from(&mut req);
                    let user_response = callback(user_req);
                    req.into_ok_response()?
                        .write_all(&user_response.get_bytes_vectored())?;
                    Ok(())
                },
            )
            .unwrap();
    }
}