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

//! HTTP client errors

// TODO: figure out how best to expose http::Error vs actix_http::Error
pub use actix_http::{
    error::{HttpError, PayloadError},
    header::HeaderValue,
    ws::{HandshakeError as WsHandshakeError, ProtocolError as WsProtocolError},
    StatusCode,
};
use derive_more::{Display, From};
use serde_json::error::Error as JsonError;

pub use crate::client::{ConnectError, FreezeRequestError, InvalidUrl, SendRequestError};

// TODO: address display, error, and from impls

/// Websocket client error
#[derive(Debug, Display, From)]
pub enum WsClientError {
    /// Invalid response status
    #[display(fmt = "Invalid response status")]
    InvalidResponseStatus(StatusCode),

    /// Invalid upgrade header
    #[display(fmt = "Invalid upgrade header")]
    InvalidUpgradeHeader,

    /// Invalid connection header
    #[display(fmt = "Invalid connection header")]
    InvalidConnectionHeader(HeaderValue),

    /// Missing Connection header
    #[display(fmt = "Missing Connection header")]
    MissingConnectionHeader,

    /// Missing Sec-Websocket-Accept header
    #[display(fmt = "Missing Sec-Websocket-Accept header")]
    MissingWebSocketAcceptHeader,

    /// Invalid challenge response
    #[display(fmt = "Invalid challenge response")]
    InvalidChallengeResponse([u8; 28], HeaderValue),

    /// Protocol error
    #[display(fmt = "{}", _0)]
    Protocol(WsProtocolError),

    /// Send request error
    #[display(fmt = "{}", _0)]
    SendRequest(SendRequestError),
}

impl std::error::Error for WsClientError {}

impl From<InvalidUrl> for WsClientError {
    fn from(err: InvalidUrl) -> Self {
        WsClientError::SendRequest(err.into())
    }
}

impl From<HttpError> for WsClientError {
    fn from(err: HttpError) -> Self {
        WsClientError::SendRequest(err.into())
    }
}

/// A set of errors that can occur during parsing json payloads
#[derive(Debug, Display, From)]
pub enum JsonPayloadError {
    /// Content type error
    #[display(fmt = "Content type error")]
    ContentType,
    /// Deserialize error
    #[display(fmt = "Json deserialize error: {}", _0)]
    Deserialize(JsonError),
    /// Payload error
    #[display(fmt = "Error that occur during reading payload: {}", _0)]
    Payload(PayloadError),
}

impl std::error::Error for JsonPayloadError {}