canary 0.3.3

provides ergonomic abstractions for network communication and more
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

#![cfg(not(target_arch = "wasm32"))]

use crate::channel::handshake::Handshake;
use crate::io::TcpListener;
use crate::io::TcpStream;
use crate::io::ToSocketAddrs;
use crate::Channel;
use crate::Result;

use backoff::ExponentialBackoff;
use derive_more::{From, Into};

#[derive(From, Into)]
#[into(owned, ref, ref_mut)]
#[repr(transparent)]
/// Exposes routes over TCP
pub struct Tcp(TcpListener);

impl Tcp {
    #[inline]
    /// Bind to this address
    /// ```no_run
    /// let tcp = Tcp::bind("127.0.0.1:8080").await?;
    /// while let Ok(chan) = tcp.next().await {
    ///     let mut chan = chan.encrypted().await?;
    ///     chan.send("hello!").await?;
    /// }
    /// ```
    pub async fn bind(addrs: impl ToSocketAddrs) -> Result<Self> {
        let listener = TcpListener::bind(addrs).await?;
        Ok(Tcp(listener))
    }

    #[inline]
    /// get the next channel
    /// ```no_run
    /// while let Ok(chan) = tcp.next().await {
    ///     let mut chan = chan.encrypted().await?;
    ///     chan.send("hello!").await?;
    /// }
    /// ```
    pub async fn next(&self) -> Result<Handshake> {
        let (stream, _) = self.0.accept().await?;
        Ok(Handshake::from(Channel::from_raw(
            stream,
            Default::default(),
            Default::default(),
        )))
    }
    /// connect to address without any backoff strategy
    pub async fn connect_no_backoff(
        addrs: impl ToSocketAddrs + std::fmt::Debug,
    ) -> Result<Handshake> {
        let stream = TcpStream::connect(&addrs).await?;
        Ok(Handshake::from(Channel::from_raw(
            stream,
            Default::default(),
            Default::default(),
        )))
    }
    #[inline]
    /// Connect to the following address with the given id and retry in case of failure
    pub async fn connect(addrs: impl ToSocketAddrs + std::fmt::Debug) -> Result<Handshake> {
        let hs = backoff::future::retry(ExponentialBackoff::default(), || async {
            let stream = TcpStream::connect(&addrs).await?;
            Ok(Handshake::from(Channel::from_raw(
                stream,
                Default::default(),
                Default::default(),
            )))
        })
        .await?;
        Ok(hs)
    }
}