uhttp 0.10.0

Simple http server for humans
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

use std::convert::Infallible;
use std::future::Future;
use std::sync::Arc;

use http_body_util::Full;
use http_body_util::combinators::BoxBody;
use hyper::Response as HyperResponse;
use hyper::body::Bytes as HyperBytes;
use hyper::service::service_fn;
use hyper_util::rt::TokioExecutor;
use hyper_util::rt::TokioIo;
use hyper_util::server::conn::auto;
use tokio::net::TcpListener;
use tokio::net::ToSocketAddrs;

use crate::Request;
use crate::Response;

pub struct Http1Server<F, Fut>
where
  F: 'static + Send + Sync + Fn(Request, Response) -> Fut,
  Fut: 'static + Send + Future<Output = crate::Result<()>>,
{
  handle_func: Arc<F>,
}

impl<F, Fut> Http1Server<F, Fut>
where
  F: 'static + Send + Sync + Fn(Request, Response) -> Fut,
  Fut: 'static + Send + Future<Output = crate::Result<()>>,
{
  pub fn new(handle_func: F) -> Self {
    Self {
      handle_func: Arc::new(handle_func),
    }
  }

  pub async fn listen(
    &self,
    addr: impl ToSocketAddrs,
  ) -> crate::Result<()> {
    let listener: TcpListener = TcpListener::bind(&addr).await?;
    let handler_func_ref = Arc::clone(&self.handle_func);

    loop {
      let Ok((stream, _)) = listener.accept().await else {
        continue;
      };

      let handler_func_ref = handler_func_ref.clone();

      tokio::task::spawn(async move {
        let io = TokioIo::new(stream);

        let service_builder = auto::Builder::new(TokioExecutor::new());
        let service_handler = service_fn(move |req| {
          let request = Request::new(req);

          let (tx_res, rx_res) = tokio::sync::oneshot::channel();
          let response = Response::new(tx_res, HyperResponse::builder());

          let fut = handler_func_ref(request, response);

          tokio::task::spawn(async move {
            match fut.await {
              Ok(_handler_response) => {}
              Err(_handler_error) => {}
            };
          });

          async move {
            Ok::<HyperResponse<BoxBody<HyperBytes, Infallible>>, crate::Error>(match rx_res.await {
              Ok(res) => res,
              Err(err) => handle_error(crate::Error::generic(format!(
                "Unable to complete request {}",
                err
              ))),
            })
          }
        });

        #[cfg(feature = "websocket")]
        service_builder
          .serve_connection_with_upgrades(io, service_handler)
          .await
          .ok();

        #[cfg(not(feature = "websocket"))]
        service_builder
          .serve_connection(io, service_handler)
          .await
          .ok();
      });
    }
  }
}

fn handle_error(error: crate::Error) -> HyperResponse<BoxBody<HyperBytes, Infallible>> {
  let content = HyperBytes::from(format!("{}", error));
  let body = BoxBody::new(Full::new(content));
  let response = HyperResponse::builder().status(500).body(body);
  let Ok(response) = response else { todo!() };
  response
}