xref: /xiu/protocol/rtmp/src/session/errors.rs (revision 4435d79d) 
1 use {
2     crate::{
3         amf0::errors::Amf0WriteError,
4         chunk::errors::{PackError, UnpackError},
5         handshake::errors::HandshakeError,
6         messages::errors::MessageError,
7         netconnection::errors::NetConnectionError,
8         netstream::errors::NetStreamError,
9         protocol_control_messages::errors::ControlMessagesError,
10         user_control_messages::errors::EventMessagesError,
11     },
12     failure::{Backtrace, Fail},
13     netio::{bytes_errors::BytesWriteError, netio_errors::NetIOError},
14     std::fmt,
15 };
16 
17 #[derive(Debug)]
18 pub struct SessionError {
19     pub value: SessionErrorValue,
20 }
21 
22 #[derive(Debug, Fail)]
23 pub enum SessionErrorValue {
24     #[fail(display = "amf0 write error: {}", _0)]
25     Amf0WriteError(#[cause] Amf0WriteError),
26     #[fail(display = "bytes write error: {}", _0)]
27     BytesWriteError(#[cause] BytesWriteError),
28     // #[fail(display = "timeout error: {}", _0)]
29     // TimeoutError(#[cause] Elapsed),
30     #[fail(display = "unpack error: {}", _0)]
31     UnPackError(#[cause] UnpackError),
32 
33     #[fail(display = "message error: {}", _0)]
34     MessageError(#[cause] MessageError),
35     #[fail(display = "control message error: {}", _0)]
36     ControlMessagesError(#[cause] ControlMessagesError),
37     #[fail(display = "net connection error: {}", _0)]
38     NetConnectionError(#[cause] NetConnectionError),
39     #[fail(display = "net stream error: {}", _0)]
40     NetStreamError(#[cause] NetStreamError),
41 
42     #[fail(display = "event messages error: {}", _0)]
43     EventMessagesError(#[cause] EventMessagesError),
44     #[fail(display = "net io error: {}", _0)]
45     NetIOError(#[cause] NetIOError),
46     #[fail(display = "pack error: {}", _0)]
47     PackError(#[cause] PackError),
48     #[fail(display = "handshake error: {}", _0)]
49     HandshakeError(#[cause] HandshakeError),
50 
51     #[fail(display = "amf0 count not correct error")]
52     Amf0ValueCountNotCorrect,
53     #[fail(display = "amf0 value type not correct error")]
54     Amf0ValueTypeNotCorrect,
55     #[fail(display = "channel event send error")]
56     ChannelEventSendErr,
57     #[fail(display = "none channel data sender error")]
58     NoneChannelDataSender,
59     #[fail(display = "none channel data receiver error")]
60     NoneChannelDataReceiver,
61     #[fail(display = "send channel data error")]
62     SendChannelDataErr,
63 
64     #[fail(display = "no app name error")]
65     NoAppName,
66 }
67 
68 impl From<Amf0WriteError> for SessionError {
69     fn from(error: Amf0WriteError) -> Self {
70         SessionError {
71             value: SessionErrorValue::Amf0WriteError(error),
72         }
73     }
74 }
75 
76 impl From<BytesWriteError> for SessionError {
77     fn from(error: BytesWriteError) -> Self {
78         SessionError {
79             value: SessionErrorValue::BytesWriteError(error),
80         }
81     }
82 }
83 
84 // impl From<Elapsed> for SessionError {
85 //     fn from(error: Elapsed) -> Self {
86 //         SessionError {
87 //             value: SessionErrorValue::TimeoutError(error),
88 //         }
89 //     }
90 // }
91 
92 impl From<UnpackError> for SessionError {
93     fn from(error: UnpackError) -> Self {
94         SessionError {
95             value: SessionErrorValue::UnPackError(error),
96         }
97     }
98 }
99 
100 impl From<MessageError> for SessionError {
101     fn from(error: MessageError) -> Self {
102         SessionError {
103             value: SessionErrorValue::MessageError(error),
104         }
105     }
106 }
107 
108 impl From<ControlMessagesError> for SessionError {
109     fn from(error: ControlMessagesError) -> Self {
110         SessionError {
111             value: SessionErrorValue::ControlMessagesError(error),
112         }
113     }
114 }
115 
116 impl From<NetConnectionError> for SessionError {
117     fn from(error: NetConnectionError) -> Self {
118         SessionError {
119             value: SessionErrorValue::NetConnectionError(error),
120         }
121     }
122 }
123 
124 impl From<NetStreamError> for SessionError {
125     fn from(error: NetStreamError) -> Self {
126         SessionError {
127             value: SessionErrorValue::NetStreamError(error),
128         }
129     }
130 }
131 
132 impl From<EventMessagesError> for SessionError {
133     fn from(error: EventMessagesError) -> Self {
134         SessionError {
135             value: SessionErrorValue::EventMessagesError(error),
136         }
137     }
138 }
139 
140 impl From<NetIOError> for SessionError {
141     fn from(error: NetIOError) -> Self {
142         SessionError {
143             value: SessionErrorValue::NetIOError(error),
144         }
145     }
146 }
147 
148 impl From<PackError> for SessionError {
149     fn from(error: PackError) -> Self {
150         SessionError {
151             value: SessionErrorValue::PackError(error),
152         }
153     }
154 }
155 
156 impl From<HandshakeError> for SessionError {
157     fn from(error: HandshakeError) -> Self {
158         SessionError {
159             value: SessionErrorValue::HandshakeError(error),
160         }
161     }
162 }
163 
164 impl fmt::Display for SessionError {
165     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
166         fmt::Display::fmt(&self.value, f)
167     }
168 }
169 
170 impl Fail for SessionError {
171     fn cause(&self) -> Option<&dyn Fail> {
172         self.value.cause()
173     }
174 
175     fn backtrace(&self) -> Option<&Backtrace> {
176         self.value.backtrace()
177     }
178 }
179