connect 0.2.4

message queue abstraction over async network streams
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

use async_std::net::{TcpStream, ToSocketAddrs};
use async_tls::client;
use async_tls::TlsConnector;
use futures::AsyncReadExt;
use log::*;

use crate::tls::TlsConnectionMetadata;
use crate::Connection;

impl Connection {
    /// Creates a [`Connection`] that uses a TLS transport.
    ///
    /// # Example
    ///
    /// Please see the [tls-client](https://github.com/sachanganesh/connect-rs/blob/main/examples/tls-client/src/main.rs)
    /// example program for a more thorough showcase.
    ///
    /// Basic usage:
    ///
    /// ```ignore
    /// let mut conn = Connection::tls_client("127.0.0.1:3456", "localhost", client_config.into()).await?;
    /// ```
    pub async fn tls_client<A: ToSocketAddrs + std::fmt::Display>(
        ip_addrs: A,
        domain: &str,
        connector: TlsConnector,
    ) -> anyhow::Result<Self> {
        let stream = TcpStream::connect(&ip_addrs).await?;
        info!("Established client TCP connection to {}", ip_addrs);
        stream.set_nodelay(true)?;

        let local_addr = stream.peer_addr()?;
        let peer_addr = stream.peer_addr()?;

        let encrypted_stream: client::TlsStream<TcpStream> =
            connector.connect(domain, stream).await?;
        info!("Completed TLS handshake with {}", peer_addr);

        Ok(Self::from(TlsConnectionMetadata::Client {
            local_addr,
            peer_addr,
            stream: encrypted_stream,
        }))
    }
}

impl From<TlsConnectionMetadata> for Connection {
    /// Creates a [`Connection`] using a TLS transport from [`TlsConnectionMetadata`].
    fn from(metadata: TlsConnectionMetadata) -> Self {
        match metadata {
            TlsConnectionMetadata::Client {
                local_addr,
                peer_addr,
                stream,
            } => {
                let (read_stream, write_stream) = stream.split();

                Self::new(
                    local_addr,
                    peer_addr,
                    Box::pin(read_stream),
                    Box::pin(write_stream),
                )
            }

            TlsConnectionMetadata::Listener {
                local_addr,
                peer_addr,
                stream,
            } => {
                let (read_stream, write_stream) = stream.split();

                Self::new(
                    local_addr,
                    peer_addr,
                    Box::pin(read_stream),
                    Box::pin(write_stream),
                )
            }
        }
    }
}