xref: /xiu/protocol/hls/src/errors.rs (revision 53a2e033) 
1 use bytes::BytesMut;
2 use failure::Fail;
3 
4 use libflv::errors::FlvDemuxerError;
5 use rtmp::session::errors::SessionError;
6 
7 use networkio::bytes_errors::BytesWriteError;
8 use rtmp::amf0::errors::Amf0WriteError;
9 use rtmp::cache::errors::MetadataError;
10 
11 use libmpegts::errors::MpegTsError;
12 use std::fmt;
13 use tokio::sync::broadcast::error::RecvError;
14 
15 // use tokio::sync::mpsc::error::SendError;
16 
17 #[derive(Debug)]
18 pub struct ServerError {
19     pub value: ServerErrorValue,
20 }
21 
22 #[derive(Debug, Fail)]
23 pub enum ServerErrorValue {
24     #[fail(display = "server error")]
25     Error,
26 }
27 #[derive(Debug)]
28 pub struct MediaError {
29     pub value: MediaErrorValue,
30 }
31 
32 #[derive(Debug, Fail)]
33 pub enum MediaErrorValue {
34     #[fail(display = "server error")]
35     Error,
36     #[fail(display = "session error")]
37     SessionError(SessionError),
38     #[fail(display = "amf write error")]
39     Amf0WriteError(Amf0WriteError),
40     #[fail(display = "metadata error")]
41     MetadataError(MetadataError),
42     #[fail(display = "flv demuxer error")]
43     FlvDemuxerError(FlvDemuxerError),
44     #[fail(display = "mpegts error")]
45     MpegTsError(MpegTsError),
46 
47     #[fail(display = "write file error")]
48     IOError(std::io::Error),
49 }
50 
51 impl From<SessionError> for MediaError {
52     fn from(error: SessionError) -> Self {
53         MediaError {
54             value: MediaErrorValue::SessionError(error),
55         }
56     }
57 }
58 
59 impl From<FlvDemuxerError> for MediaError {
60     fn from(error: FlvDemuxerError) -> Self {
61         MediaError {
62             value: MediaErrorValue::FlvDemuxerError(error),
63         }
64     }
65 }
66 
67 impl From<MpegTsError> for MediaError {
68     fn from(error: MpegTsError) -> Self {
69         MediaError {
70             value: MediaErrorValue::MpegTsError(error),
71         }
72     }
73 }
74 
75 impl From<Amf0WriteError> for MediaError {
76     fn from(error: Amf0WriteError) -> Self {
77         MediaError {
78             value: MediaErrorValue::Amf0WriteError(error),
79         }
80     }
81 }
82 
83 impl From<MetadataError> for MediaError {
84     fn from(error: MetadataError) -> Self {
85         MediaError {
86             value: MediaErrorValue::MetadataError(error),
87         }
88     }
89 }
90 
91 impl From<std::io::Error> for MediaError {
92     fn from(error: std::io::Error) -> Self {
93         MediaError {
94             value: MediaErrorValue::IOError(error),
95         }
96     }
97 }
98 
99 impl fmt::Display for MediaError {
100     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
101         fmt::Display::fmt(&self.value, f)
102     }
103 }
104 
105 pub struct HlsError {
106     pub value: HlsErrorValue,
107 }
108 
109 #[derive(Debug, Fail)]
110 pub enum HlsErrorValue {
111     #[fail(display = "server error")]
112     Error,
113     #[fail(display = "session error")]
114     SessionError(SessionError),
115     #[fail(display = "amf write error")]
116     Amf0WriteError(Amf0WriteError),
117     #[fail(display = "metadata error")]
118     MetadataError(MetadataError),
119     #[fail(display = "flv demuxer error")]
120     FlvDemuxerError(FlvDemuxerError),
121     #[fail(display = "media error")]
122     MediaError(MediaError),
123 
124     #[fail(display = "receive error\n")]
125     RecvError(RecvError),
126 }
127 impl From<RecvError> for HlsError {
128     fn from(error: RecvError) -> Self {
129         HlsError {
130             value: HlsErrorValue::RecvError(error),
131         }
132     }
133 }
134 
135 
136 impl From<MediaError> for HlsError {
137     fn from(error: MediaError) -> Self {
138         HlsError {
139             value: HlsErrorValue::MediaError(error),
140         }
141     }
142 }
143 
144 impl From<SessionError> for HlsError {
145     fn from(error: SessionError) -> Self {
146         HlsError {
147             value: HlsErrorValue::SessionError(error),
148         }
149     }
150 }
151 
152 impl From<FlvDemuxerError> for HlsError {
153     fn from(error: FlvDemuxerError) -> Self {
154         HlsError {
155             value: HlsErrorValue::FlvDemuxerError(error),
156         }
157     }
158 }
159 
160 impl From<Amf0WriteError> for HlsError {
161     fn from(error: Amf0WriteError) -> Self {
162         HlsError {
163             value: HlsErrorValue::Amf0WriteError(error),
164         }
165     }
166 }
167 
168 impl From<MetadataError> for HlsError {
169     fn from(error: MetadataError) -> Self {
170         HlsError {
171             value: HlsErrorValue::MetadataError(error),
172         }
173     }
174 }
175 
176 impl fmt::Display for HlsError {
177     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
178         fmt::Display::fmt(&self.value, f)
179     }
180 }
181 // #[derive(Debug, Fail)]
182 // pub struct TsError {
183 //     pub value: TsErrorValue,
184 // }
185 
186 // impl fmt::Display for TsError {
187 //     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
188 //         fmt::Display::fmt(&self.value, f)
189 //     }
190 // }
191 
192 // #[derive(Debug, Fail)]
193 // pub enum TsErrorValue {
194 //     #[fail(display = "write file error")]
195 //     IOError(std::io::Error),
196 // }
197 
198 // impl From<std::io::Error> for TsError {
199 //     fn from(error: std::io::Error) -> Self {
200 //         TsError {
201 //             value: TsErrorValue::IOError(error),
202 //         }
203 //     }
204 // }
205