wstomp 0.2.0

A STOMP-over-WebSocket client library for Rust, built on top of awc and async-stomp
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

use async_stomp::{FromServer, Message, ToServer};
use awc::{
    error::{WsClientError, WsProtocolError},
    ws::CloseReason,
};
use tokio::sync::mpsc::error::SendError;

#[derive(Debug)]
pub enum WStompConnectError {
    WsClientError(WsClientError),
    ConnectMessageFailed(Box<SendError<Message<ToServer>>>),
    ReconnectionLimit,
}

/// Custom enum combine events in WebSocket and STOMP
#[derive(Debug)]
pub enum WStompEvent {
    /// Regular message from STOMP protocol
    Message(Message<FromServer>),
    /// WebSocket or STOMP error combined
    Error(WStompError),
}

impl From<WStompError> for WStompEvent {
    fn from(err: WStompError) -> Self {
        Self::Error(err)
    }
}

/// Custom error type to combine WebSocket and STOMP errors.
#[derive(Debug)]
pub enum WStompError {
    /// Error during receiving websocket frames (from awc)
    WsReceive(WsProtocolError),
    /// Error during sending websocket frames (from awc)
    WsSend(WsProtocolError),
    /// Error while decoding (receiving) STOMP message (from async-stomp)
    StompDecoding(anyhow::Error),
    /// Error while encoding (sending) STOMP message (from async-stomp)
    StompEncoding(anyhow::Error),
    /// Incomplete STOMP frame received through WebSocket
    ///
    /// This is a warning that WebSocket protocol finished receiving data, but STOMP protocol
    /// doesn't recognize it as a full STOMP message. Should not happen, can be ignored in most cases.
    IncompleteStompFrame,
    /// Websocket closed connection (with reason)
    WebsocketClosed(Option<CloseReason>),
    /// Can't send ping, probably network problems
    PingFailed(anyhow::Error),
    /// Haven't received pong from last ping
    PingTimeout,
}

impl std::fmt::Display for WStompConnectError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::WsClientError(WsClientError::InvalidResponseStatus(status)) => write!(
                f,
                "WebSocket connection error: server rejected upgrade with HTTP {}",
                status
            ),
            Self::WsClientError(err) => write!(f, "WebSocket connection error: {}", err),
            Self::ConnectMessageFailed(msg) => write!(f, "WebSocket receive error: {}", msg),
            Self::ReconnectionLimit => write!(f, "Reconnection retry limit reached"),
        }
    }
}

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

impl std::fmt::Display for WStompError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::WsReceive(err) => write!(f, "WebSocket receive error: {}", err),
            Self::WsSend(err) => write!(f, "WebSocket send error: {}", err),
            Self::StompDecoding(err) => write!(f, "STOMP decoding error: {}", err),
            Self::StompEncoding(err) => write!(f, "STOMP encoding error: {}", err),
            Self::IncompleteStompFrame => {
                write!(f, "STOMP decoding warning: Dropped incomplete frame")
            }
            Self::WebsocketClosed(reason) => write!(
                f,
                "Websocket closed {}",
                reason
                    .as_ref()
                    .map(|r| r.description.clone().unwrap_or_default())
                    .unwrap_or_default()
            ),
            Self::PingFailed(err) => write!(f, "Websocket ping failed: {err}"),
            Self::PingTimeout => write!(f, "Websocket ping timeout"),
        }
    }
}

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