rama_http_core/h2/codec/
error.rs

1use crate::h2::{frame::StreamIdOverflow, proto::Error};
2
3use std::{error, fmt, io};
4
5/// Errors caused by sending a message
6#[derive(Debug)]
7pub enum SendError {
8    Connection(Error),
9    User(UserError),
10}
11
12/// Errors caused by users of the library
13#[derive(Debug)]
14pub enum UserError {
15    /// The stream ID is no longer accepting frames.
16    InactiveStreamId,
17
18    /// The stream is not currently expecting a frame of this type.
19    UnexpectedFrameType,
20
21    /// The payload size is too big
22    PayloadTooBig,
23
24    /// The application attempted to initiate too many streams to remote.
25    Rejected,
26
27    /// The released capacity is larger than claimed capacity.
28    ReleaseCapacityTooBig,
29
30    /// The stream ID space is overflowed.
31    ///
32    /// A new connection is needed.
33    OverflowedStreamId,
34
35    /// Illegal headers, such as connection-specific headers.
36    MalformedHeaders,
37
38    /// Request submitted with relative URI.
39    MissingUriSchemeAndAuthority,
40
41    /// Calls `SendResponse::poll_reset` after having called `send_response`.
42    PollResetAfterSendResponse,
43
44    /// Calls `PingPong::send_ping` before receiving a pong.
45    SendPingWhilePending,
46
47    /// Tries to update local SETTINGS while ACK has not been received.
48    SendSettingsWhilePending,
49
50    /// Tries to send push promise to peer who has disabled server push
51    PeerDisabledServerPush,
52}
53
54// ===== impl SendError =====
55
56impl error::Error for SendError {}
57
58impl fmt::Display for SendError {
59    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
60        match *self {
61            Self::Connection(ref e) => e.fmt(fmt),
62            Self::User(ref e) => e.fmt(fmt),
63        }
64    }
65}
66
67impl From<io::Error> for SendError {
68    fn from(src: io::Error) -> Self {
69        Self::Connection(src.into())
70    }
71}
72
73impl From<UserError> for SendError {
74    fn from(src: UserError) -> Self {
75        SendError::User(src)
76    }
77}
78
79impl From<StreamIdOverflow> for SendError {
80    fn from(_: StreamIdOverflow) -> Self {
81        UserError::OverflowedStreamId.into()
82    }
83}
84
85// ===== impl UserError =====
86
87impl error::Error for UserError {}
88
89impl fmt::Display for UserError {
90    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
91        fmt.write_str(match *self {
92            UserError::InactiveStreamId => "inactive stream",
93            UserError::UnexpectedFrameType => "unexpected frame type",
94            UserError::PayloadTooBig => "payload too big",
95            UserError::Rejected => "rejected",
96            UserError::ReleaseCapacityTooBig => "release capacity too big",
97            UserError::OverflowedStreamId => "stream ID overflowed",
98            UserError::MalformedHeaders => "malformed headers",
99            UserError::MissingUriSchemeAndAuthority => "request URI missing scheme and authority",
100            UserError::PollResetAfterSendResponse => "poll_reset after send_response is illegal",
101            UserError::SendPingWhilePending => "send_ping before received previous pong",
102            UserError::SendSettingsWhilePending => "sending SETTINGS before received previous ACK",
103            UserError::PeerDisabledServerPush => {
104                "sending PUSH_PROMISE to peer who disabled server push"
105            }
106        })
107    }
108}