1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
/*
* Copyright 2017-2023 Ben Ashford
*
* Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
* http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
* <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
* option. This file may not be copied, modified, or distributed
* except according to those terms.
*/
//! Error handling
use std::error;
use std::fmt;
use std::io;
use std::sync::Arc;
use futures_channel::mpsc;
use crate::resp;
#[derive(Debug, Clone)]
pub enum Error {
/// A non-specific internal error that prevented an operation from completing
Internal(String),
/// An IO error occurred
IO(Arc<io::Error>),
/// A RESP parsing/serialising error occurred
Resp(String, Option<resp::RespValue>),
/// A remote error
Remote(String),
/// Error creating a connection, or an error with a connection being closed unexpectedly
Connection(ConnectionReason),
/// An unexpected error. In this context "unexpected" means
/// "unexpected because we check ahead of time", it used to maintain the type signature of
/// chains of futures; but it occurring at runtime should be considered a catastrophic
/// failure.
///
/// If any error is propagated this way that needs to be handled, then it should be made into
/// a proper option.
Unexpected(String),
#[cfg(feature = "with-rustls")]
InvalidDnsName,
#[cfg(feature = "with-native-tls")]
Tls(Arc<native_tls::Error>),
}
pub(crate) fn internal(msg: impl Into<String>) -> Error {
Error::Internal(msg.into())
}
pub(crate) fn unexpected(msg: impl Into<String>) -> Error {
Error::Unexpected(msg.into())
}
pub(crate) fn resp(msg: impl Into<String>, resp: resp::RespValue) -> Error {
Error::Resp(msg.into(), Some(resp))
}
impl From<io::Error> for Error {
fn from(err: io::Error) -> Error {
Error::IO(Arc::new(err))
}
}
impl<T: 'static + Send> From<mpsc::TrySendError<T>> for Error {
fn from(err: mpsc::TrySendError<T>) -> Error {
Error::Unexpected(format!("Cannot write to channel: {}", err))
}
}
impl error::Error for Error {
fn source(&self) -> Option<&(dyn error::Error + 'static)> {
match self {
Error::IO(err) => Some(err),
#[cfg(feature = "with-native-tls")]
Error::Tls(err) => Some(err),
_ => None,
}
}
}
#[cfg(feature = "with-native-tls")]
impl From<native_tls::Error> for Error {
fn from(err: native_tls::Error) -> Error {
Error::Tls(Arc::new(err))
}
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
Error::Internal(s) => write!(f, "{}", s),
Error::IO(err) => write!(f, "{}", err),
Error::Resp(s, resp) => write!(f, "{}: {:?}", s, resp),
Error::Remote(s) => write!(f, "{}", s),
Error::Connection(ConnectionReason::Connected) => {
write!(f, "Connection already established")
}
Error::Connection(ConnectionReason::Connecting) => write!(f, "Connection in progress"),
Error::Connection(ConnectionReason::ConnectionFailed) => {
write!(f, "The last attempt to establish a connection failed")
}
Error::Connection(ConnectionReason::NotConnected) => {
write!(f, "Connection has been closed")
}
#[cfg(feature = "with-rustls")]
Error::InvalidDnsName => {
write!(f, "Invalid dns name")
}
#[cfg(feature = "with-native-tls")]
Error::Tls(err) => write!(f, "{}", err),
Error::Unexpected(err) => write!(f, "{}", err),
}
}
}
/// Details of a `ConnectionError`
#[derive(Debug, Copy, Clone)]
pub enum ConnectionReason {
/// An attempt to use a connection while it is in the "connecting" state, clients should try
/// again
Connecting,
/// An attempt was made to reconnect after a connection was established, clients should try
/// again
Connected,
/// Connection failed - this can be returned from a call to reconnect, the actual error will be
/// sent to the client at the next call
ConnectionFailed,
/// The connection is not currently connected, the connection will reconnect asynchronously,
/// clients should try again
NotConnected,
}