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

/*
 * Copyright 2017-2022 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, fmt, io};

use futures_channel::mpsc;

use crate::resp;

#[derive(Debug)]
pub enum Error {
    /// A non-specific internal error that prevented an operation from completing
    Internal(String),

    /// An IO error occurred
    IO(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(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(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),
            _ => None,
        }
    }
}

#[cfg(feature = "with-native-tls")]
impl From<native_tls::Error> for Error {
    fn from(err: native_tls::Error) -> Error {
        Error::Tls(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)]
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,
}