hyperdriver 0.12.3

The missing middle for Hyper - Servers and Clients with ergonomic APIs
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
105
106
107
108

//! Test hyperdriver client using unix stream transports.
use std::pin::pin;

use camino::Utf8PathBuf;
use chateau::client::conn::transport::unix::{StaticAddressUnixTransport, UnixTransport};
use chateau::stream::unix::UnixStream;
use chateau::stream::unix::{UnixAddr, UnixListener};
use futures_util::StreamExt as _;
use http::StatusCode;
use hyperdriver::bridge::io::TokioIo;
use hyperdriver::client::conn::transport::unix::UnixExtensionTransport;
use hyperdriver::server::conn::Acceptor;
use hyperdriver::{Body, Client};

type BoxError = Box<dyn std::error::Error + Send + Sync + 'static>;

const SOCKET: &str = "test-transport.sock";

#[tokio::test]
async fn transport() -> Result<(), BoxError> {
    let _ = tracing_subscriber::fmt::try_init();

    let dir = tempfile::tempdir().unwrap();

    let listener = UnixListener::bind(dir.path().join(SOCKET)).unwrap();
    let acceptor: Acceptor<UnixListener> = Acceptor::new(listener);
    let server = tokio::spawn(serve_one_h1(acceptor));

    let transport = UnixExtensionTransport::from(UnixTransport::new(Default::default()));
    let mut client = Client::builder()
        .without_pool()
        .with_transport(transport)
        .with_auto_http()
        .without_redirects()
        .without_tls()
        .build();

    let addr = UnixAddr::from_pathbuf(dir.path().join(SOCKET));
    let req = http::Request::get("http://test/")
        .extension(addr)
        .body(Body::empty())?;
    let resp: http::Response<Body> = client.request(req).await?.map(Into::into);

    assert_eq!(resp.status(), StatusCode::OK);
    server.abort();
    let _ = server.await;

    Ok(())
}

#[tokio::test]
async fn static_address_transport() -> Result<(), BoxError> {
    let _ = tracing_subscriber::fmt::try_init();

    let dir = tempfile::tempdir().unwrap();

    let listener = UnixListener::bind(dir.path().join(SOCKET)).unwrap();
    let acceptor: Acceptor<UnixListener> = Acceptor::new(listener);
    let server = tokio::spawn(serve_one_h1(acceptor));

    let path: Utf8PathBuf = dir.path().join(SOCKET).try_into().unwrap();
    let transport: StaticAddressUnixTransport<UnixStream> = StaticAddressUnixTransport::new(path);
    let mut client = Client::builder()
        .without_pool()
        .with_transport(transport)
        .with_auto_http()
        .without_redirects()
        .without_tls()
        .build();

    let req = http::Request::get("http://test/").body(Body::empty())?;
    let resp: http::Response<Body> = client.request(req).await?.map(Into::into);

    assert_eq!(resp.status(), StatusCode::OK);
    server.abort();
    let _ = server.await;

    Ok(())
}

async fn service_ok(
    req: http::Request<hyper::body::Incoming>,
) -> Result<http::Response<hyperdriver::Body>, BoxError> {
    Ok(http::response::Builder::new()
        .status(200)
        .header(
            "O-Host",
            req.headers()
                .get("Host")
                .and_then(|h| h.to_str().ok())
                .unwrap_or("missing"),
        )
        .body(hyperdriver::body::Body::empty())?)
}

async fn serve_one_h1(acceptor: Acceptor<UnixListener>) -> Result<(), BoxError> {
    let mut acceptor = pin!(acceptor);
    let stream = acceptor.next().await.ok_or("no connection")??;

    let service = hyper::service::service_fn(service_ok);

    let conn =
        hyper::server::conn::http1::Builder::new().serve_connection(TokioIo::new(stream), service);

    conn.await?;

    Ok(())
}