undis 0.1.0

serde-compatible redis library
Documentation 
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

//! Connector to a Redis server.
//!
//! For more information, see the [`Connector`](Connector) trait.

use std::fmt::Debug;
use std::marker::Unpin;
use std::net::SocketAddr;
#[cfg(unix)]
use std::path::{Path, PathBuf};

use futures_core::future::BoxFuture;
use tokio::io::{self, AsyncRead, AsyncWrite};
#[cfg(unix)]
use tokio::net::UnixStream;
use tokio::net::{lookup_host, TcpStream};

/// Connector to a Redis server.
///
/// Redis servers accept connection in various way
/// including TCP and Unix domain socket.
/// A `Connector` should have enough information to connect to a certain Redis server
/// and should be capable of producing multiple connections to it.
///
/// Used by the [`Client`](crate::Client) to make pooled connections.
pub trait Connector: Send + Sync {
    /// Connection stream this connector produces.
    type Stream: AsyncRead + AsyncWrite + Debug + Unpin + Send;

    /// Connect to the Redis server and return the stream to it.
    fn connect(&self) -> BoxFuture<'_, io::Result<Self::Stream>>;
}

/// TCP socket connector.
#[derive(Debug)]
pub struct TcpConnector {
    addr: SocketAddr,
}

/// Unix domain socket connector.
#[cfg(unix)]
#[derive(Debug)]
pub struct UnixConnector {
    path: PathBuf,
}

/// DNS lookup error
#[derive(Debug, thiserror::Error)]
pub enum LookupError {
    /// IO error during DNS lookup
    #[error("IO error during DNS lookup")]
    Io(#[from] std::io::Error),
    /// DNS record is not found
    #[error("DNS record not found")]
    NotFound,
}

impl TcpConnector {
    /// Constructs a `TcpConnector` using IP address and port.
    pub fn new(addr: SocketAddr) -> Self {
        TcpConnector { addr }
    }

    /// Constructs a `TcpConnector` from a string representation of a socket address
    /// like `example.com:8080`, `localhost:6379`, or `192.168.0.7:18080`.
    pub async fn lookup(addr: &str) -> Result<Self, LookupError> {
        let addr = lookup_host(addr)
            .await?
            .next()
            .ok_or(LookupError::NotFound)?;
        Ok(TcpConnector::new(addr))
    }
}

impl Connector for TcpConnector {
    type Stream = TcpStream;

    fn connect(&self) -> BoxFuture<'_, io::Result<Self::Stream>> {
        Box::pin(TcpStream::connect(self.addr))
    }
}

#[cfg(unix)]
impl UnixConnector {
    /// Constructs a `UnixConnector`.
    pub fn new<P: AsRef<Path>>(path: P) -> Self {
        UnixConnector {
            path: path.as_ref().to_owned(),
        }
    }
}

#[cfg(unix)]
impl Connector for UnixConnector {
    type Stream = UnixStream;

    fn connect(&self) -> BoxFuture<'_, io::Result<Self::Stream>> {
        Box::pin(UnixStream::connect(&self.path))
    }
}