subduction_http_longpoll 0.7.0

HTTP long-poll transport layer for the Subduction sync protocol
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

//! Error types for the HTTP long-poll transport.

use thiserror::Error;

/// Outbound channel closed — no more messages can be sent to the client.
#[derive(Debug, Clone, Copy, Error)]
#[error("outbound channel closed")]
pub struct SendError;

/// Problem while attempting to make a roundtrip call.
#[derive(Debug, Clone, Copy, Error)]
pub enum CallError {
    /// Response oneshot was dropped before a reply arrived.
    #[error("response dropped")]
    ResponseDropped,

    /// Timed out waiting for response.
    #[error("timed out waiting for response")]
    Timeout,

    /// Outbound channel closed.
    #[error("outbound channel closed")]
    ChannelClosed,
}

/// Inbound channel closed — no more messages from the client.
#[derive(Debug, Clone, Copy, Error)]
#[error("inbound channel closed")]
pub struct RecvError;

/// Problem while attempting to gracefully disconnect.
#[derive(Debug, Clone, Copy, Error)]
#[error("disconnected")]
pub struct DisconnectionError;

/// Errors while processing an HTTP long-poll request on the server.
#[cfg(feature = "server")]
#[derive(Debug, Error)]
pub enum ServerError {
    /// The session ID header is missing or malformed.
    #[error("missing or invalid session ID")]
    InvalidSessionId,

    /// No session found for the given ID.
    #[error("session not found")]
    SessionNotFound,

    /// The request body exceeds the maximum allowed size, or failed to read.
    #[error("request body too large")]
    BodyTooLarge,

    /// Internal channel error.
    #[error("channel send error")]
    ChanSend,

    /// The HTTP handshake adapter produced no response bytes.
    #[error("handshake produced no response")]
    HandshakeNoResponse,

    /// The HTTP handshake adapter had no challenge bytes to yield.
    #[error("handshake has no challenge bytes")]
    HandshakeNoChallenge,

    /// Failed to build an HTTP response.
    #[error(transparent)]
    HttpBuild(#[from] hyper::http::Error),
}

/// Errors while connecting as a client.
#[derive(Debug, Error)]
pub enum ClientError {
    /// HTTP request failed.
    #[error("HTTP request error: {0}")]
    Request(alloc::string::String),

    /// Server returned an unexpected status code.
    #[error("unexpected status {status}: {body}")]
    UnexpectedStatus {
        /// The HTTP status code.
        status: u16,
        /// The response body as a string.
        body: alloc::string::String,
    },

    /// Failed to decode handshake response.
    #[error("handshake decode error: {0}")]
    HandshakeDecode(alloc::string::String),

    /// Handshake was rejected by the server.
    #[error("handshake rejected: {reason}")]
    HandshakeRejected {
        /// The rejection reason.
        reason: alloc::string::String,
    },

    /// Authentication error during handshake.
    #[error("authentication error: {0}")]
    Authentication(alloc::string::String),
}