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