xref: /xiu/protocol/hls/src/errors.rs (revision a4ef5d6c) 
1 use {
2     failure::{Backtrace, Fail},
3     rtmp::{
4         amf0::errors::Amf0WriteError, cache::errors::MetadataError, session::errors::SessionError,
5     },
6     std::fmt,
7     streamhub::errors::ChannelError,
8     tokio::sync::broadcast::error::RecvError,
9     tokio::sync::oneshot::error::RecvError as OneshotRecvError,
10     xflv::errors::FlvDemuxerError,
11     xmpegts::errors::MpegTsError,
12 };
13 
14 #[derive(Debug)]
15 pub struct ServerError {
16     pub value: ServerErrorValue,
17 }
18 
19 #[derive(Debug, Fail)]
20 pub enum ServerErrorValue {
21     #[fail(display = "server error")]
22     Error,
23 }
24 #[derive(Debug)]
25 pub struct MediaError {
26     pub value: MediaErrorValue,
27 }
28 
29 #[derive(Debug, Fail)]
30 pub enum MediaErrorValue {
31     #[fail(display = "server error")]
32     Error,
33     #[fail(display = "channel recv error")]
34     ChannelRecvError,
35     #[fail(display = "session error:{}", _0)]
36     SessionError(#[cause] SessionError),
37     #[fail(display = "amf write error:{}", _0)]
38     Amf0WriteError(#[cause] Amf0WriteError),
39     #[fail(display = "metadata error:{}", _0)]
40     MetadataError(#[cause] MetadataError),
41     #[fail(display = "flv demuxer error:{}", _0)]
42     FlvDemuxerError(#[cause] FlvDemuxerError),
43     #[fail(display = "mpegts error:{}", _0)]
44     MpegTsError(#[cause] MpegTsError),
45     #[fail(display = "write file error:{}", _0)]
46     IOError(#[cause] std::io::Error),
47 }
48 
49 impl From<SessionError> for MediaError {
from(error: SessionError) -> Self50     fn from(error: SessionError) -> Self {
51         MediaError {
52             value: MediaErrorValue::SessionError(error),
53         }
54     }
55 }
56 
57 impl From<FlvDemuxerError> for MediaError {
from(error: FlvDemuxerError) -> Self58     fn from(error: FlvDemuxerError) -> Self {
59         MediaError {
60             value: MediaErrorValue::FlvDemuxerError(error),
61         }
62     }
63 }
64 
65 impl From<MpegTsError> for MediaError {
from(error: MpegTsError) -> Self66     fn from(error: MpegTsError) -> Self {
67         MediaError {
68             value: MediaErrorValue::MpegTsError(error),
69         }
70     }
71 }
72 
73 impl From<Amf0WriteError> for MediaError {
from(error: Amf0WriteError) -> Self74     fn from(error: Amf0WriteError) -> Self {
75         MediaError {
76             value: MediaErrorValue::Amf0WriteError(error),
77         }
78     }
79 }
80 
81 impl From<MetadataError> for MediaError {
from(error: MetadataError) -> Self82     fn from(error: MetadataError) -> Self {
83         MediaError {
84             value: MediaErrorValue::MetadataError(error),
85         }
86     }
87 }
88 
89 impl From<std::io::Error> for MediaError {
from(error: std::io::Error) -> Self90     fn from(error: std::io::Error) -> Self {
91         MediaError {
92             value: MediaErrorValue::IOError(error),
93         }
94     }
95 }
96 
97 impl fmt::Display for MediaError {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result98     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
99         fmt::Display::fmt(&self.value, f)
100     }
101 }
102 
103 impl Fail for MediaError {
cause(&self) -> Option<&dyn Fail>104     fn cause(&self) -> Option<&dyn Fail> {
105         self.value.cause()
106     }
107 
backtrace(&self) -> Option<&Backtrace>108     fn backtrace(&self) -> Option<&Backtrace> {
109         self.value.backtrace()
110     }
111 }
112 
113 pub struct HlsError {
114     pub value: HlsErrorValue,
115 }
116 
117 #[derive(Debug, Fail)]
118 pub enum HlsErrorValue {
119     #[fail(display = "hls error")]
120     Error,
121     #[fail(display = "channel recv error")]
122     ChannelRecvError,
123     #[fail(display = "channel error:{}", _0)]
124     ChannelError(#[cause] ChannelError),
125     #[fail(display = "session error:{}", _0)]
126     SessionError(#[cause] SessionError),
127     #[fail(display = "amf write error:{}", _0)]
128     Amf0WriteError(#[cause] Amf0WriteError),
129     #[fail(display = "metadata error:{}", _0)]
130     MetadataError(#[cause] MetadataError),
131     #[fail(display = "flv demuxer error:{}", _0)]
132     FlvDemuxerError(#[cause] FlvDemuxerError),
133     #[fail(display = "media error:{}", _0)]
134     MediaError(#[cause] MediaError),
135     #[fail(display = "receive error:{}", _0)]
136     RecvError(#[cause] RecvError),
137     #[fail(display = "tokio: oneshot receiver err: {}", _0)]
138     OneshotRecvError(#[cause] OneshotRecvError),
139 }
140 impl From<RecvError> for HlsError {
from(error: RecvError) -> Self141     fn from(error: RecvError) -> Self {
142         HlsError {
143             value: HlsErrorValue::RecvError(error),
144         }
145     }
146 }
147 
148 impl From<MediaError> for HlsError {
from(error: MediaError) -> Self149     fn from(error: MediaError) -> Self {
150         HlsError {
151             value: HlsErrorValue::MediaError(error),
152         }
153     }
154 }
155 
156 impl From<SessionError> for HlsError {
from(error: SessionError) -> Self157     fn from(error: SessionError) -> Self {
158         HlsError {
159             value: HlsErrorValue::SessionError(error),
160         }
161     }
162 }
163 
164 impl From<FlvDemuxerError> for HlsError {
from(error: FlvDemuxerError) -> Self165     fn from(error: FlvDemuxerError) -> Self {
166         HlsError {
167             value: HlsErrorValue::FlvDemuxerError(error),
168         }
169     }
170 }
171 
172 impl From<Amf0WriteError> for HlsError {
from(error: Amf0WriteError) -> Self173     fn from(error: Amf0WriteError) -> Self {
174         HlsError {
175             value: HlsErrorValue::Amf0WriteError(error),
176         }
177     }
178 }
179 
180 impl From<MetadataError> for HlsError {
from(error: MetadataError) -> Self181     fn from(error: MetadataError) -> Self {
182         HlsError {
183             value: HlsErrorValue::MetadataError(error),
184         }
185     }
186 }
187 
188 impl From<ChannelError> for HlsError {
from(error: ChannelError) -> Self189     fn from(error: ChannelError) -> Self {
190         HlsError {
191             value: HlsErrorValue::ChannelError(error),
192         }
193     }
194 }
195 
196 impl From<OneshotRecvError> for HlsError {
from(error: OneshotRecvError) -> Self197     fn from(error: OneshotRecvError) -> Self {
198         HlsError {
199             value: HlsErrorValue::OneshotRecvError(error),
200         }
201     }
202 }
203 
204 impl fmt::Display for HlsError {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result205     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
206         fmt::Display::fmt(&self.value, f)
207     }
208 }
209