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