1 use crate::amf0::errors::Amf0WriteError; 2 use crate::chunk::errors::PackError; 3 use crate::chunk::errors::UnpackError; 4 use crate::handshake::errors::HandshakeError; 5 use crate::messages::errors::MessageError; 6 use crate::netconnection::errors::NetConnectionError; 7 use crate::netstream::errors::NetStreamError; 8 use crate::protocol_control_messages::errors::ControlMessagesError; 9 use crate::user_control_messages::errors::EventMessagesError; 10 11 use netio::bytes_errors::BytesWriteError; 12 use netio::netio_errors::NetIOError; 13 14 use tokio::time::Elapsed; 15 16 use failure::{Backtrace, Fail}; 17 use std::fmt; 18 19 #[derive(Debug)] 20 pub struct SessionError { 21 pub value: SessionErrorValue, 22 } 23 24 #[derive(Debug, Fail)] 25 pub enum SessionErrorValue { 26 #[fail(display = "amf0 write error: {}", _0)] 27 Amf0WriteError(#[cause] Amf0WriteError), 28 #[fail(display = "bytes write error: {}", _0)] 29 BytesWriteError(#[cause] BytesWriteError), 30 #[fail(display = "timeout error: {}", _0)] 31 TimeoutError(#[cause] Elapsed), 32 #[fail(display = "unpack error: {}", _0)] 33 UnPackError(#[cause] UnpackError), 34 35 36 #[fail(display = "message error: {}", _0)] 37 MessageError(#[cause] MessageError), 38 #[fail(display = "control message error: {}", _0)] 39 ControlMessagesError(#[cause] ControlMessagesError), 40 #[fail(display = "net connection error: {}", _0)] 41 NetConnectionError(#[cause] NetConnectionError), 42 #[fail(display = "net stream error: {}", _0)] 43 NetStreamError(#[cause] NetStreamError), 44 45 #[fail(display = "event messages error: {}", _0)] 46 EventMessagesError(#[cause] EventMessagesError), 47 #[fail(display = "net io error: {}", _0)] 48 NetIOError(#[cause] NetIOError), 49 #[fail(display = "pack error: {}", _0)] 50 PackError(#[cause] PackError), 51 #[fail(display = "handshake error: {}", _0)] 52 HandshakeError(#[cause] HandshakeError), 53 54 #[fail(display = "amf0 count not correct error")] 55 Amf0ValueCountNotCorrect, 56 #[fail(display = "amf0 value type not correct error")] 57 Amf0ValueTypeNotCorrect, 58 #[fail(display = "channel event send error")] 59 ChannelEventSendErr, 60 #[fail(display = "none channel data sender error")] 61 NoneChannelDataSender, 62 #[fail(display = "none channel data receiver error")] 63 NoneChannelDataReceiver, 64 #[fail(display = "send channel data error")] 65 SendChannelDataErr, 66 67 #[fail(display = "no app name error")] 68 NoAppName, 69 } 70 71 impl From<Amf0WriteError> for SessionError { 72 fn from(error: Amf0WriteError) -> Self { 73 SessionError { 74 value: SessionErrorValue::Amf0WriteError(error), 75 } 76 } 77 } 78 79 impl From<BytesWriteError> for SessionError { 80 fn from(error: BytesWriteError) -> Self { 81 SessionError { 82 value: SessionErrorValue::BytesWriteError(error), 83 } 84 } 85 } 86 87 impl From<Elapsed> for SessionError { 88 fn from(error: Elapsed) -> Self { 89 SessionError { 90 value: SessionErrorValue::TimeoutError(error), 91 } 92 } 93 } 94 95 impl From<UnpackError> for SessionError { 96 fn from(error: UnpackError) -> Self { 97 SessionError { 98 value: SessionErrorValue::UnPackError(error), 99 } 100 } 101 } 102 103 impl From<MessageError> for SessionError { 104 fn from(error: MessageError) -> Self { 105 SessionError { 106 value: SessionErrorValue::MessageError(error), 107 } 108 } 109 } 110 111 impl From<ControlMessagesError> for SessionError { 112 fn from(error: ControlMessagesError) -> Self { 113 SessionError { 114 value: SessionErrorValue::ControlMessagesError(error), 115 } 116 } 117 } 118 119 impl From<NetConnectionError> for SessionError { 120 fn from(error: NetConnectionError) -> Self { 121 SessionError { 122 value: SessionErrorValue::NetConnectionError(error), 123 } 124 } 125 } 126 127 impl From<NetStreamError> for SessionError { 128 fn from(error: NetStreamError) -> Self { 129 SessionError { 130 value: SessionErrorValue::NetStreamError(error), 131 } 132 } 133 } 134 135 impl From<EventMessagesError> for SessionError { 136 fn from(error: EventMessagesError) -> Self { 137 SessionError { 138 value: SessionErrorValue::EventMessagesError(error), 139 } 140 } 141 } 142 143 impl From<NetIOError> for SessionError { 144 fn from(error: NetIOError) -> Self { 145 SessionError { 146 value: SessionErrorValue::NetIOError(error), 147 } 148 } 149 } 150 151 impl From<PackError> for SessionError { 152 fn from(error: PackError) -> Self { 153 SessionError { 154 value: SessionErrorValue::PackError(error), 155 } 156 } 157 } 158 159 impl From<HandshakeError> for SessionError { 160 fn from(error: HandshakeError) -> Self { 161 SessionError { 162 value: SessionErrorValue::HandshakeError(error), 163 } 164 } 165 } 166 167 impl fmt::Display for SessionError { 168 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 169 fmt::Display::fmt(&self.value, f) 170 } 171 } 172 173 impl Fail for SessionError { 174 fn cause(&self) -> Option<&dyn Fail> { 175 self.value.cause() 176 } 177 178 fn backtrace(&self) -> Option<&Backtrace> { 179 self.value.backtrace() 180 } 181 } 182