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