xref: /xiu/protocol/rtmp/src/session/errors.rs (revision 35844cc6) 
1 use crate::amf0::errors::Amf0WriteError;
2 use crate::chunk::errors::PackError;
3 use crate::chunk::errors::UnpackError;
4 use crate::handshake::errors::HandshakeError;
5 use crate::messages::errors::MessageError;
6 use crate::netconnection::errors::NetConnectionError;
7 use crate::netstream::errors::NetStreamError;
8 use crate::protocol_control_messages::errors::ControlMessagesError;
9 use crate::user_control_messages::errors::EventMessagesError;
10 
11 use netio::bytes_errors::BytesWriteError;
12 use netio::netio_errors::NetIOError;
13 
14 use tokio::time::Elapsed;
15 
16 // pub struct ServerError {
17 //     pub value: ServerErrorValue,
18 // }
19 
20 // pub enum ServerErrorValue {
21 //     Amf0WriteError(Amf0WriteError),
22 //     BytesWriteError(BytesWriteError),
23 //     TimeoutError(Elapsed),
24 //     UnPackError(UnpackError),
25 //     MessageError(MessageError),
26 //     ControlMessagesError(ControlMessagesError),
27 //     NetConnectionError(NetConnectionError),
28 //     NetStreamError(NetStreamError),
29 //     EventMessagesError(EventMessagesError),
30 //     NetIOError(NetIOError),
31 //     PackError(PackError),
32 //     Amf0ValueCountNotCorrect,
33 //     Amf0ValueTypeNotCorrect,
34 // }
35 
36 // impl From<Amf0WriteError> for ServerError {
37 //     fn from(error: Amf0WriteError) -> Self {
38 //         ServerError {
39 //             value: ServerErrorValue::Amf0WriteError(error),
40 //         }
41 //     }
42 // }
43 
44 // impl From<BytesWriteError> for ServerError {
45 //     fn from(error: BytesWriteError) -> Self {
46 //         ServerError {
47 //             value: ServerErrorValue::BytesWriteError(error),
48 //         }
49 //     }
50 // }
51 
52 // impl From<Elapsed> for ServerError {
53 //     fn from(error: Elapsed) -> Self {
54 //         ServerError {
55 //             value: ServerErrorValue::TimeoutError(error),
56 //         }
57 //     }
58 // }
59 
60 // impl From<UnpackError> for ServerError {
61 //     fn from(error: UnpackError) -> Self {
62 //         ServerError {
63 //             value: ServerErrorValue::UnPackError(error),
64 //         }
65 //     }
66 // }
67 
68 // impl From<MessageError> for ServerError {
69 //     fn from(error: MessageError) -> Self {
70 //         ServerError {
71 //             value: ServerErrorValue::MessageError(error),
72 //         }
73 //     }
74 // }
75 
76 // impl From<ControlMessagesError> for ServerError {
77 //     fn from(error: ControlMessagesError) -> Self {
78 //         ServerError {
79 //             value: ServerErrorValue::ControlMessagesError(error),
80 //         }
81 //     }
82 // }
83 
84 // impl From<NetConnectionError> for ServerError {
85 //     fn from(error: NetConnectionError) -> Self {
86 //         ServerError {
87 //             value: ServerErrorValue::NetConnectionError(error),
88 //         }
89 //     }
90 // }
91 
92 // impl From<NetStreamError> for ServerError {
93 //     fn from(error: NetStreamError) -> Self {
94 //         ServerError {
95 //             value: ServerErrorValue::NetStreamError(error),
96 //         }
97 //     }
98 // }
99 
100 // impl From<EventMessagesError> for ServerError {
101 //     fn from(error: EventMessagesError) -> Self {
102 //         ServerError {
103 //             value: ServerErrorValue::EventMessagesError(error),
104 //         }
105 //     }
106 // }
107 
108 // impl From<NetIOError> for ServerError {
109 //     fn from(error: NetIOError) -> Self {
110 //         ServerError {
111 //             value: ServerErrorValue::NetIOError(error),
112 //         }
113 //     }
114 // }
115 
116 pub struct SessionError {
117     pub value: SessionErrorValue,
118 }
119 
120 pub enum SessionErrorValue {
121     Amf0WriteError(Amf0WriteError),
122     BytesWriteError(BytesWriteError),
123     TimeoutError(Elapsed),
124     UnPackError(UnpackError),
125     MessageError(MessageError),
126     ControlMessagesError(ControlMessagesError),
127     NetConnectionError(NetConnectionError),
128     NetStreamError(NetStreamError),
129     EventMessagesError(EventMessagesError),
130     NetIOError(NetIOError),
131     PackError(PackError),
132     HandshakeError(HandshakeError),
133 
134     Amf0ValueCountNotCorrect,
135     Amf0ValueTypeNotCorrect,
136 }
137 
138 impl From<Amf0WriteError> for SessionError {
139     fn from(error: Amf0WriteError) -> Self {
140         SessionError {
141             value: SessionErrorValue::Amf0WriteError(error),
142         }
143     }
144 }
145 
146 impl From<BytesWriteError> for SessionError {
147     fn from(error: BytesWriteError) -> Self {
148         SessionError {
149             value: SessionErrorValue::BytesWriteError(error),
150         }
151     }
152 }
153 
154 impl From<Elapsed> for SessionError {
155     fn from(error: Elapsed) -> Self {
156         SessionError {
157             value: SessionErrorValue::TimeoutError(error),
158         }
159     }
160 }
161 
162 impl From<UnpackError> for SessionError {
163     fn from(error: UnpackError) -> Self {
164         SessionError {
165             value: SessionErrorValue::UnPackError(error),
166         }
167     }
168 }
169 
170 impl From<MessageError> for SessionError {
171     fn from(error: MessageError) -> Self {
172         SessionError {
173             value: SessionErrorValue::MessageError(error),
174         }
175     }
176 }
177 
178 impl From<ControlMessagesError> for SessionError {
179     fn from(error: ControlMessagesError) -> Self {
180         SessionError {
181             value: SessionErrorValue::ControlMessagesError(error),
182         }
183     }
184 }
185 
186 impl From<NetConnectionError> for SessionError {
187     fn from(error: NetConnectionError) -> Self {
188         SessionError {
189             value: SessionErrorValue::NetConnectionError(error),
190         }
191     }
192 }
193 
194 impl From<NetStreamError> for SessionError {
195     fn from(error: NetStreamError) -> Self {
196         SessionError {
197             value: SessionErrorValue::NetStreamError(error),
198         }
199     }
200 }
201 
202 impl From<EventMessagesError> for SessionError {
203     fn from(error: EventMessagesError) -> Self {
204         SessionError {
205             value: SessionErrorValue::EventMessagesError(error),
206         }
207     }
208 }
209 
210 impl From<NetIOError> for SessionError {
211     fn from(error: NetIOError) -> Self {
212         SessionError {
213             value: SessionErrorValue::NetIOError(error),
214         }
215     }
216 }
217 
218 impl From<PackError> for SessionError {
219     fn from(error: PackError) -> Self {
220         SessionError {
221             value: SessionErrorValue::PackError(error),
222         }
223     }
224 }
225 
226 impl From<HandshakeError> for SessionError {
227     fn from(error: HandshakeError) -> Self {
228         SessionError {
229             value: SessionErrorValue::HandshakeError(error),
230         }
231     }
232 }
233