Struct AsyncClient 

pub struct AsyncClient { /* private fields */ }

Async tcp connection builder

async version of crate::tcp::Client, require tokio async runtime

Implementations

impl Client

pub fn new( server_addr: &str, id: &str, local_addr: Option<SocketAddr>, ) -> Result<Self>

set rendezvous server, peer identity, local bind address. if no local address set, choose according server address type(ipv4 or ipv6).

Examples found in repository

examples/demo-async-tcp.rs (line 23)

async fn main() -> Result<(), Box<dyn Error>> {
    let server_addr = "127.0.0.1:8888";

    {
        let server_addr = server_addr.clone();
        spawn(async move { Server::new(server_addr).await?.run().await });
    }

    let t = {
        let server_addr = server_addr.clone();
        spawn(async move {
            let mut c = AsyncClient::new(server_addr, "c1", None).unwrap();
            loop {
                match c.listen().await {
                    Ok(_) => {
                        let (mut s, _) = c.accept().await.unwrap();
                        s.write(b"hello").await.unwrap();
                        break;
                    }
                    _ => {
                        sleep(Duration::from_secs(1)).await;
                        continue;
                    }
                }
            }
        })
    };

    let mut c = AsyncClient::new(server_addr, "c2", None)?;
    let mut s = loop {
        match c.connect("c1").await {
            Ok(s) => break s,
            _ => sleep(Duration::from_secs(1)).await,
        }
    };

    let mut buf = [0u8; 5];
    s.read(&mut buf).await?;

    t.await?;

    Ok(())
}

pub fn as_socket(&self) -> Option<&TcpListener>

expose TcpListener

pub async fn connect(&mut self, target_id: &str) -> Result<TcpStream>

connect to rendezvous server and request a connection to target node.

it will return a TcpStream with remote peer.

the connection with rendezvous server will be drop after return.

Examples found in repository

examples/demo-async-tcp.rs (line 42)

async fn main() -> Result<(), Box<dyn Error>> {
    let server_addr = "127.0.0.1:8888";

    {
        let server_addr = server_addr.clone();
        spawn(async move { Server::new(server_addr).await?.run().await });
    }

    let t = {
        let server_addr = server_addr.clone();
        spawn(async move {
            let mut c = AsyncClient::new(server_addr, "c1", None).unwrap();
            loop {
                match c.listen().await {
                    Ok(_) => {
                        let (mut s, _) = c.accept().await.unwrap();
                        s.write(b"hello").await.unwrap();
                        break;
                    }
                    _ => {
                        sleep(Duration::from_secs(1)).await;
                        continue;
                    }
                }
            }
        })
    };

    let mut c = AsyncClient::new(server_addr, "c2", None)?;
    let mut s = loop {
        match c.connect("c1").await {
            Ok(s) => break s,
            _ => sleep(Duration::from_secs(1)).await,
        }
    };

    let mut buf = [0u8; 5];
    s.read(&mut buf).await?;

    t.await?;

    Ok(())
}

pub async fn listen(&mut self) -> Result<()>

put socket in listen mode, create connection with rendezvous server, wait for peer connection request. if connection with server broken it will auto reconnect.

when received Fsync request from server, attempt to connect remote peer with a very short timeout, this will open the firwall and nat rule for the peer connection that will follow immediately. When the peer connection finally come, the listening socket then accept it as normal.

Examples found in repository

examples/demo-async-tcp.rs (line 25)

async fn main() -> Result<(), Box<dyn Error>> {
    let server_addr = "127.0.0.1:8888";

    {
        let server_addr = server_addr.clone();
        spawn(async move { Server::new(server_addr).await?.run().await });
    }

    let t = {
        let server_addr = server_addr.clone();
        spawn(async move {
            let mut c = AsyncClient::new(server_addr, "c1", None).unwrap();
            loop {
                match c.listen().await {
                    Ok(_) => {
                        let (mut s, _) = c.accept().await.unwrap();
                        s.write(b"hello").await.unwrap();
                        break;
                    }
                    _ => {
                        sleep(Duration::from_secs(1)).await;
                        continue;
                    }
                }
            }
        })
    };

    let mut c = AsyncClient::new(server_addr, "c2", None)?;
    let mut s = loop {
        match c.connect("c1").await {
            Ok(s) => break s,
            _ => sleep(Duration::from_secs(1)).await,
        }
    };

    let mut buf = [0u8; 5];
    s.read(&mut buf).await?;

    t.await?;

    Ok(())
}

pub async fn accept(&mut self) -> Result<(TcpStream, SocketAddr)>

accept remote peer connection

Examples found in repository

examples/demo-async-tcp.rs (line 27)

async fn main() -> Result<(), Box<dyn Error>> {
    let server_addr = "127.0.0.1:8888";

    {
        let server_addr = server_addr.clone();
        spawn(async move { Server::new(server_addr).await?.run().await });
    }

    let t = {
        let server_addr = server_addr.clone();
        spawn(async move {
            let mut c = AsyncClient::new(server_addr, "c1", None).unwrap();
            loop {
                match c.listen().await {
                    Ok(_) => {
                        let (mut s, _) = c.accept().await.unwrap();
                        s.write(b"hello").await.unwrap();
                        break;
                    }
                    _ => {
                        sleep(Duration::from_secs(1)).await;
                        continue;
                    }
                }
            }
        })
    };

    let mut c = AsyncClient::new(server_addr, "c2", None)?;
    let mut s = loop {
        match c.connect("c1").await {
            Ok(s) => break s,
            _ => sleep(Duration::from_secs(1)).await,
        }
    };

    let mut buf = [0u8; 5];
    s.read(&mut buf).await?;

    t.await?;

    Ok(())
}

Trait Implementations

impl Drop for Client

fn drop(&mut self)

Executes the destructor for this type.