xref: /xiu/protocol/hls/src/errors.rs (revision 27addbf4) 
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 use std::fmt;
11 // use tokio::sync::mpsc::error::SendError;
12 
13 #[derive(Debug)]
14 pub struct ServerError {
15     pub value: ServerErrorValue,
16 }
17 
18 #[derive(Debug, Fail)]
19 pub enum ServerErrorValue {
20     #[fail(display = "server error")]
21     Error,
22 }
23 #[derive(Debug)]
24 pub struct MediaError {
25     pub value: MediaErrorValue,
26 }
27 
28 #[derive(Debug, Fail)]
29 pub enum MediaErrorValue {
30     #[fail(display = "server error")]
31     Error,
32     #[fail(display = "session error")]
33     SessionError(SessionError),
34 
35     #[fail(display = "amf write error")]
36     Amf0WriteError(Amf0WriteError),
37     #[fail(display = "metadata error")]
38     MetadataError(MetadataError),
39     #[fail(display = "flv demuxer error")]
40     FlvDemuxerError(FlvDemuxerError),
41 }
42 
43 impl From<SessionError> for MediaError {
44     fn from(error: SessionError) -> Self {
45         MediaError {
46             value: MediaErrorValue::SessionError(error),
47         }
48     }
49 }
50 
51 impl From<FlvDemuxerError> for MediaError {
52     fn from(error: FlvDemuxerError) -> Self {
53         MediaError {
54             value: MediaErrorValue::FlvDemuxerError(error),
55         }
56     }
57 }
58 
59 impl From<Amf0WriteError> for MediaError {
60     fn from(error: Amf0WriteError) -> Self {
61         MediaError {
62             value: MediaErrorValue::Amf0WriteError(error),
63         }
64     }
65 }
66 
67 impl From<MetadataError> for MediaError {
68     fn from(error: MetadataError) -> Self {
69         MediaError {
70             value: MediaErrorValue::MetadataError(error),
71         }
72     }
73 }
74 
75 impl fmt::Display for MediaError {
76     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
77         fmt::Display::fmt(&self.value, f)
78     }
79 }
80 
81 pub struct HlsError {
82     pub value: HlsErrorValue,
83 }
84 
85 #[derive(Debug, Fail)]
86 pub enum HlsErrorValue {
87     #[fail(display = "server error")]
88     Error,
89     #[fail(display = "session error")]
90     SessionError(SessionError),
91 
92     #[fail(display = "amf write error")]
93     Amf0WriteError(Amf0WriteError),
94     #[fail(display = "metadata error")]
95     MetadataError(MetadataError),
96     #[fail(display = "flv demuxer error")]
97     FlvDemuxerError(FlvDemuxerError),
98     #[fail(display = "media error")]
99     MediaError(MediaError),
100 }
101 
102 impl From<MediaError> for HlsError {
103     fn from(error: MediaError) -> Self {
104         HlsError {
105             value: HlsErrorValue::MediaError(error),
106         }
107     }
108 }
109 
110 impl From<SessionError> for HlsError {
111     fn from(error: SessionError) -> Self {
112         HlsError {
113             value: HlsErrorValue::SessionError(error),
114         }
115     }
116 }
117 
118 impl From<FlvDemuxerError> for HlsError {
119     fn from(error: FlvDemuxerError) -> Self {
120         HlsError {
121             value: HlsErrorValue::FlvDemuxerError(error),
122         }
123     }
124 }
125 
126 impl From<Amf0WriteError> for HlsError {
127     fn from(error: Amf0WriteError) -> Self {
128         HlsError {
129             value: HlsErrorValue::Amf0WriteError(error),
130         }
131     }
132 }
133 
134 impl From<MetadataError> for HlsError {
135     fn from(error: MetadataError) -> Self {
136         HlsError {
137             value: HlsErrorValue::MetadataError(error),
138         }
139     }
140 }
141 
142 impl fmt::Display for HlsError {
143     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
144         fmt::Display::fmt(&self.value, f)
145     }
146 }
147