elfo-network 0.2.0-alpha.21

Distributed actors for elfo
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

use std::net::{IpAddr, SocketAddr};

use derive_more::Display;
use eyre::{Result, WrapErr};
use futures::Stream;
use tracing::warn;
use turmoil06::net::{TcpListener, TcpStream};

pub(super) use turmoil06::net::tcp::{OwnedReadHalf, OwnedWriteHalf};

const DEFAULT_PORT: u16 = 0xE1F0;

#[derive(Clone, Display, PartialEq, Eq)]
#[display("turmoil06(local={local}, peer={peer})")] // TODO: use `valuable` after tracing#1570
pub(crate) struct SocketInfo {
    local: String,
    peer: String,
}

pub(super) struct Socket {
    pub(super) read: OwnedReadHalf,
    pub(super) write: OwnedWriteHalf,
    pub(super) info: SocketInfo,
}

fn prepare_stream(stream: TcpStream) -> Result<Socket> {
    let info = SocketInfo {
        local: stringify_addr(stream.local_addr().wrap_err("cannot get local addr")?),
        peer: stringify_addr(stream.peer_addr().wrap_err("cannot get peer addr")?),
    };

    let (read, write) = stream.into_split();
    Ok(Socket { read, write, info })
}

fn stringify_addr(addr: SocketAddr) -> String {
    let (ip, port) = (addr.ip(), addr.port());
    let host = turmoil06::reverse_lookup(ip).unwrap_or_else(|| ip.to_string());
    format!("{host}:{port}")
}

pub(super) async fn connect(addr: &str) -> Result<Socket> {
    prepare_stream(TcpStream::connect(prepare_addr(addr)).await?)
}

pub(super) async fn listen(addr: &str) -> Result<impl Stream<Item = Socket> + 'static> {
    let listener = TcpListener::bind(prepare_addr(addr)).await?;

    let accept = move |listener: TcpListener| async move {
        loop {
            let result = listener
                .accept()
                .await
                .map_err(Into::into)
                .and_then(|(socket, _)| prepare_stream(socket));

            match result {
                Ok(socket) => return Some((socket, listener)),
                Err(err) => {
                    warn!(
                        message = "cannot accept turmoil connection",
                        error = %err,
                        // TODO: addr
                    );

                    // Continue listening.
                }
            }
        }
    };

    Ok(futures::stream::unfold(listener, accept))
}

fn prepare_addr(addr: &str) -> String {
    if addr.parse::<SocketAddr>().is_ok() {
        return addr.to_string();
    }

    if addr.parse::<IpAddr>().is_ok() {
        return format!("{addr}:{DEFAULT_PORT}");
    }

    if addr.contains(':') {
        addr.to_string()
    } else {
        format!("{addr}:{DEFAULT_PORT}")
    }
}