xwt-test-server 0.7.8

The server to use for xwt testing. Not intended to be wasm-compatible. 
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

//! The implementation of the close server.

use crate::handling::{AcceptSessionRequestWith, RouteSession};

pub struct CloseUni;

impl RouteSession for CloseUni {
    const PATH: &'static str = "/close/uni";

    fn handler() -> impl crate::handling::HandleSessionRequest {
        AcceptSessionRequestWith(accept_and_close_uni_streams)
    }
}

pub async fn accept_and_close_uni_streams(
    session: std::sync::Arc<wtransport::Connection>,
) -> Result<(), wtransport::error::ConnectionError> {
    let session = session.as_ref();
    loop {
        let stream = session.accept_uni().await?;
        stream.stop(0u8.into());
    }
}

pub struct CloseUniError;

impl RouteSession for CloseUniError {
    const PATH: &'static str = "/close/uni/error";

    fn handler() -> impl crate::handling::HandleSessionRequest {
        AcceptSessionRequestWith(accept_and_close_uni_streams_with_error_code)
    }
}

pub async fn accept_and_close_uni_streams_with_error_code(
    session: std::sync::Arc<wtransport::Connection>,
) -> Result<(), wtransport::error::ConnectionError> {
    let session = session.as_ref();
    loop {
        let stream = session.accept_uni().await?;
        stream.stop(webtransport_code_to_http_code(123));
    }
}

pub struct CloseBiRecv;

impl RouteSession for CloseBiRecv {
    const PATH: &'static str = "/close/bi/recv";

    fn handler() -> impl crate::handling::HandleSessionRequest {
        AcceptSessionRequestWith(accept_and_close_bi_recv_streams)
    }
}

pub async fn accept_and_close_bi_recv_streams(
    session: std::sync::Arc<wtransport::Connection>,
) -> Result<(), wtransport::error::ConnectionError> {
    let session = session.as_ref();
    loop {
        let (_send_stream, recv_stream) = session.accept_bi().await?;
        recv_stream.stop(0u8.into());
    }
}

pub struct CloseBiRecvError;

impl RouteSession for CloseBiRecvError {
    const PATH: &'static str = "/close/bi/recv/error";

    fn handler() -> impl crate::handling::HandleSessionRequest {
        AcceptSessionRequestWith(accept_and_close_bi_recv_streams_with_error_code)
    }
}

pub async fn accept_and_close_bi_recv_streams_with_error_code(
    session: std::sync::Arc<wtransport::Connection>,
) -> Result<(), wtransport::error::ConnectionError> {
    let session = session.as_ref();
    loop {
        let (_send_stream, recv_stream) = session.accept_bi().await?;
        recv_stream.stop(webtransport_code_to_http_code(123u8.into()));
    }
}

pub struct CloseBiSend;

impl RouteSession for CloseBiSend {
    const PATH: &'static str = "/close/bi/send";

    fn handler() -> impl crate::handling::HandleSessionRequest {
        AcceptSessionRequestWith(accept_and_close_bi_send_streams)
    }
}

#[derive(Debug, thiserror::Error)]
pub enum AcceptAndCloseBiSendStreamsError {
    #[error("connection: {0}")]
    Connection(wtransport::error::ConnectionError),
    #[error("stream write: {0}")]
    StreamWrite(wtransport::error::StreamWriteError),
}

pub async fn accept_and_close_bi_send_streams(
    session: std::sync::Arc<wtransport::Connection>,
) -> Result<(), AcceptAndCloseBiSendStreamsError> {
    let session = session.as_ref();
    loop {
        let (mut send_stream, _recv_stream) = session
            .accept_bi()
            .await
            .map_err(AcceptAndCloseBiSendStreamsError::Connection)?;
        send_stream
            .finish()
            .await
            .map_err(AcceptAndCloseBiSendStreamsError::StreamWrite)?;
    }
}

pub struct CloseBiSendError;

impl RouteSession for CloseBiSendError {
    const PATH: &'static str = "/close/bi/send/error";

    fn handler() -> impl crate::handling::HandleSessionRequest {
        AcceptSessionRequestWith(accept_and_close_bi_send_streams_with_error_code)
    }
}

pub async fn accept_and_close_bi_send_streams_with_error_code(
    session: std::sync::Arc<wtransport::Connection>,
) -> Result<(), wtransport::error::ConnectionError> {
    let session = session.as_ref();
    loop {
        let (mut send_stream, _recv_stream) = session.accept_bi().await?;
        if let Err(wtransport::error::ClosedStream) =
            send_stream.reset(webtransport_code_to_http_code(123))
        {
            tracing::debug!(message = "unable to reset a closed stream");
        }
    }
}

/// Convert the WebTransport error code into the HTTP3 error code.
///
/// We need this because wtransport does not convert error codes at all.
fn webtransport_code_to_http_code(n: u32) -> wtransport::VarInt {
    let first: u64 = 0x52e4a40fa8db;
    let n: u64 = n.into();
    let val: u64 = first + n + (n / 0x1e);
    val.try_into().unwrap()
}