rustapi-ws 0.1.508

WebSocket support for RustAPI - Real-time bidirectional communication
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
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

//! WebSocket error types

use std::fmt;

/// Error type for WebSocket operations
#[derive(Debug)]
pub enum WebSocketError {
    /// Invalid WebSocket upgrade request
    InvalidUpgrade(String),
    /// WebSocket handshake failed
    HandshakeFailed(String),
    /// Connection closed unexpectedly
    ConnectionClosed,
    /// Failed to send message
    SendFailed(String),
    /// Failed to receive message
    ReceiveFailed(String),
    /// Message serialization error
    SerializationError(String),
    /// Message deserialization error
    DeserializationError(String),
    /// Protocol error
    ProtocolError(String),
    /// IO error
    IoError(std::io::Error),
    /// Tungstenite error
    Tungstenite(tungstenite::Error),
}

impl fmt::Display for WebSocketError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::InvalidUpgrade(msg) => write!(f, "Invalid WebSocket upgrade request: {}", msg),
            Self::HandshakeFailed(msg) => write!(f, "WebSocket handshake failed: {}", msg),
            Self::ConnectionClosed => write!(f, "Connection closed unexpectedly"),
            Self::SendFailed(msg) => write!(f, "Failed to send message: {}", msg),
            Self::ReceiveFailed(msg) => write!(f, "Failed to receive message: {}", msg),
            Self::SerializationError(msg) => write!(f, "Message serialization error: {}", msg),
            Self::DeserializationError(msg) => write!(f, "Message deserialization error: {}", msg),
            Self::ProtocolError(msg) => write!(f, "WebSocket protocol error: {}", msg),
            Self::IoError(e) => write!(f, "IO error: {}", e),
            Self::Tungstenite(e) => write!(f, "WebSocket error: {}", e),
        }
    }
}

impl std::error::Error for WebSocketError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            Self::IoError(e) => Some(e),
            Self::Tungstenite(e) => Some(e),
            _ => None,
        }
    }
}

impl From<std::io::Error> for WebSocketError {
    fn from(e: std::io::Error) -> Self {
        Self::IoError(e)
    }
}

impl From<tungstenite::Error> for WebSocketError {
    fn from(e: tungstenite::Error) -> Self {
        Self::Tungstenite(e)
    }
}

impl WebSocketError {
    /// Create an invalid upgrade error
    pub fn invalid_upgrade(msg: impl Into<String>) -> Self {
        Self::InvalidUpgrade(msg.into())
    }

    /// Create a handshake failed error
    pub fn handshake_failed(msg: impl Into<String>) -> Self {
        Self::HandshakeFailed(msg.into())
    }

    /// Create a send failed error
    pub fn send_failed(msg: impl Into<String>) -> Self {
        Self::SendFailed(msg.into())
    }

    /// Create a receive failed error
    pub fn receive_failed(msg: impl Into<String>) -> Self {
        Self::ReceiveFailed(msg.into())
    }

    /// Create a serialization error
    pub fn serialization_error(msg: impl Into<String>) -> Self {
        Self::SerializationError(msg.into())
    }

    /// Create a deserialization error
    pub fn deserialization_error(msg: impl Into<String>) -> Self {
        Self::DeserializationError(msg.into())
    }

    /// Create a protocol error
    pub fn protocol_error(msg: impl Into<String>) -> Self {
        Self::ProtocolError(msg.into())
    }
}

impl From<WebSocketError> for rustapi_core::ApiError {
    fn from(err: WebSocketError) -> Self {
        match err {
            WebSocketError::InvalidUpgrade(msg) => {
                rustapi_core::ApiError::bad_request(format!("WebSocket upgrade failed: {}", msg))
            }
            WebSocketError::HandshakeFailed(msg) => {
                rustapi_core::ApiError::bad_request(format!("WebSocket handshake failed: {}", msg))
            }
            _ => rustapi_core::ApiError::internal(err.to_string()),
        }
    }
}

impl From<crate::auth::AuthError> for rustapi_core::ApiError {
    fn from(err: crate::auth::AuthError) -> Self {
        match err {
            crate::auth::AuthError::TokenMissing => {
                rustapi_core::ApiError::unauthorized("Authentication token missing")
            }
            crate::auth::AuthError::TokenExpired => {
                rustapi_core::ApiError::unauthorized("Token has expired")
            }
            crate::auth::AuthError::InvalidSignature => {
                rustapi_core::ApiError::unauthorized("Invalid token signature")
            }
            crate::auth::AuthError::InvalidFormat(msg) => {
                rustapi_core::ApiError::bad_request(format!("Invalid token format: {}", msg))
            }
            crate::auth::AuthError::ValidationFailed(msg) => {
                rustapi_core::ApiError::unauthorized(format!("Token validation failed: {}", msg))
            }
            crate::auth::AuthError::InsufficientPermissions(msg) => {
                rustapi_core::ApiError::forbidden(format!("Insufficient permissions: {}", msg))
            }
        }
    }
}