1 use bytes::BytesMut; 2 use failure::Fail; 3 use rtmp::session::errors::SessionError; 4 5 use networkio::bytes_errors::BytesWriteError; 6 use rtmp::amf0::errors::Amf0WriteError; 7 use rtmp::cache::errors::MetadataError; 8 use tokio::sync::mpsc::error::SendError; 9 10 #[derive(Debug)] 11 pub struct ServerError { 12 pub value: ServerErrorValue, 13 } 14 15 #[derive(Debug, Fail)] 16 pub enum ServerErrorValue { 17 #[fail(display = "server error")] 18 Error, 19 } 20 21 pub struct HttpFLvError { 22 pub value: HttpFLvErrorValue, 23 } 24 25 #[derive(Debug, Fail)] 26 pub enum HttpFLvErrorValue { 27 #[fail(display = "server error")] 28 Error, 29 #[fail(display = "session error")] 30 SessionError(SessionError), 31 #[fail(display = "bytes write error")] 32 BytesWriteError(BytesWriteError), 33 #[fail(display = "amf write error")] 34 Amf0WriteError(Amf0WriteError), 35 #[fail(display = "metadata error")] 36 MetadataError(MetadataError), 37 #[fail(display = "tokio mpsc error")] 38 MpscSendError(SendError<BytesMut>), 39 } 40 41 impl From<SessionError> for HttpFLvError { 42 fn from(error: SessionError) -> Self { 43 HttpFLvError { 44 value: HttpFLvErrorValue::SessionError(error), 45 } 46 } 47 } 48 49 impl From<BytesWriteError> for HttpFLvError { 50 fn from(error: BytesWriteError) -> Self { 51 HttpFLvError { 52 value: HttpFLvErrorValue::BytesWriteError(error), 53 } 54 } 55 } 56 57 impl From<SendError<BytesMut>> for HttpFLvError { 58 fn from(error: SendError<BytesMut>) -> Self { 59 HttpFLvError { 60 value: HttpFLvErrorValue::MpscSendError(error), 61 } 62 } 63 } 64 65 impl From<Amf0WriteError> for HttpFLvError { 66 fn from(error: Amf0WriteError) -> Self { 67 HttpFLvError { 68 value: HttpFLvErrorValue::Amf0WriteError(error), 69 } 70 } 71 } 72 73 impl From<MetadataError> for HttpFLvError { 74 fn from(error: MetadataError) -> Self { 75 HttpFLvError { 76 value: HttpFLvErrorValue::MetadataError(error), 77 } 78 } 79 } 80