http-server-rs 0.0.60

Simple, zero-configuration command-line static HTTP server.
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

use futures::StreamExt;
use futures::TryStreamExt;
use futures::stream;
use http::Response as HttpResponse;
use http::Result as HttpResult;
use http_body_util::StreamBody;
use http_body_util::combinators::BoxBody;
use hyper::body::Bytes as HyperBytes;
use hyper::body::Frame;
use hyper::http::response::Builder as ResponseBuilder;
use tokio::io::DuplexStream;

use super::Bytes;
use super::ShutdownSignal;

pub trait ResponseBuilderExt {
  fn body_stream(
    self,
    stream_buffer_size: usize,
  ) -> HttpResult<(
    HttpResponse<BoxBody<HyperBytes, std::io::Error>>,
    DuplexStream,
  )>;
  /// Stream body that ends as soon as shutdown is triggered, so a held-open
  /// stream (e.g. an event stream) can't stall graceful shutdown.
  fn body_stream_until_shutdown(
    self,
    stream_buffer_size: usize,
    shutdown_signal: ShutdownSignal,
  ) -> HttpResult<(
    HttpResponse<BoxBody<HyperBytes, std::io::Error>>,
    DuplexStream,
  )>;
  fn body_from(
    self,
    bytes: impl Into<Bytes>,
  ) -> HttpResult<HttpResponse<BoxBody<HyperBytes, std::io::Error>>>;
}

impl ResponseBuilderExt for ResponseBuilder {
  fn body_stream(
    self,
    stream_buffer_size: usize,
  ) -> HttpResult<(
    HttpResponse<BoxBody<HyperBytes, std::io::Error>>,
    DuplexStream,
  )> {
    let (writer, reader) = tokio::io::duplex(stream_buffer_size);

    let reader_stream = tokio_util::io::ReaderStream::new(reader)
      .map_ok(hyper::body::Frame::data)
      .map_err(std::io::Error::other);

    let stream_body = StreamBody::new(reader_stream);
    let boxed_body: BoxBody<HyperBytes, std::io::Error> =
      BoxBody::<HyperBytes, std::io::Error>::new(stream_body);

    let res: http::Response<BoxBody<HyperBytes, std::io::Error>> = self.body(boxed_body)?;

    Ok((res, writer))
  }

  fn body_stream_until_shutdown(
    self,
    stream_buffer_size: usize,
    shutdown_signal: ShutdownSignal,
  ) -> HttpResult<(
    HttpResponse<BoxBody<HyperBytes, std::io::Error>>,
    DuplexStream,
  )> {
    let (writer, reader) = tokio::io::duplex(stream_buffer_size);

    let reader_stream = tokio_util::io::ReaderStream::new(reader)
      .map_ok(Frame::data)
      .map_err(std::io::Error::other)
      .take_until(shutdown_signal.wait_owned())
      // hyper treats an empty DATA frame as the end of stream
      .chain(stream::once(async { Ok(Frame::data(HyperBytes::new())) }));

    let bodystream = StreamBody::new(reader_stream);
    let boxed_body: BoxBody<HyperBytes, std::io::Error> =
      BoxBody::<HyperBytes, std::io::Error>::new(bodystream);

    let res: http::Response<BoxBody<HyperBytes, std::io::Error>> = self.body(boxed_body)?;

    Ok((res, writer))
  }

  fn body_from(
    self,
    bytes: impl Into<Bytes>,
  ) -> HttpResult<HttpResponse<BoxBody<HyperBytes, std::io::Error>>> {
    self.body(bytes.into().into())
  }
}