ppaass-v3-protocol 0.1.1

The ppaass v3 protocol
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

use crate::ProtocolError;
use serde::{Deserialize, Serialize};
use std::fmt::{Display, Formatter};
use std::net::{SocketAddr, ToSocketAddrs};
const HTTP_PORT: u16 = 80;

/// The unified address which can support both
/// IP V4, IP V6 and Domain
#[derive(Debug, Clone, Serialize, Deserialize, Hash, Eq, PartialEq)]
pub enum UnifiedAddress {
    Domain { host: String, port: u16 },
    SocketAddress(SocketAddr),
}
impl Display for UnifiedAddress {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            UnifiedAddress::Domain { host, port } => write!(f, "{}:{}", host, port),
            UnifiedAddress::SocketAddress(socket_addr) => match socket_addr {
                SocketAddr::V4(ip_v4_addr) => {
                    write!(f, "{}:{}", ip_v4_addr.ip(), socket_addr.port())
                }
                SocketAddr::V6(ip_v6_addr) => {
                    write!(f, "{}:{}", ip_v6_addr.ip(), socket_addr.port())
                }
            },
        }
    }
}

impl TryFrom<&str> for UnifiedAddress {
    type Error = ProtocolError;
    fn try_from(value: &str) -> Result<Self, Self::Error> {
        value.to_string().try_into()
    }
}

impl TryFrom<String> for UnifiedAddress {
    type Error = ProtocolError;
    fn try_from(value: String) -> Result<Self, Self::Error> {
        if let Ok(ip_address) = value.parse::<SocketAddr>() {
            Ok(Self::SocketAddress(ip_address))
        } else {
            let domain_parts = value.split(":").collect::<Vec<&str>>();
            match domain_parts.len() {
                parts_num if parts_num > 2 => {
                    Err(ProtocolError::ParseUnifiedAddressToDomainAddress(value))
                }
                2 => {
                    let domain = domain_parts[0];
                    let port = domain_parts[1].parse::<u16>().map_err(|_| {
                        ProtocolError::ParseUnifiedAddressToDomainAddress(value.clone())
                    })?;
                    Ok(Self::Domain {
                        host: domain.to_string(),
                        port,
                    })
                }
                _ => {
                    let domain = domain_parts[0];
                    Ok(Self::Domain {
                        host: domain.to_string(),
                        port: HTTP_PORT,
                    })
                }
            }
        }
    }
}
impl TryFrom<UnifiedAddress> for Vec<SocketAddr> {
    type Error = ProtocolError;
    fn try_from(value: UnifiedAddress) -> Result<Self, Self::Error> {
        (&value).try_into()
    }
}

impl TryFrom<&UnifiedAddress> for Vec<SocketAddr> {
    type Error = ProtocolError;
    fn try_from(value: &UnifiedAddress) -> Result<Self, Self::Error> {
        match value {
            UnifiedAddress::Domain { host, port } => {
                let socket_addresses = format!("{host}:{port}").to_socket_addrs()?;
                let socket_addresses = socket_addresses.collect::<Vec<SocketAddr>>();
                Ok(socket_addresses)
            }
            UnifiedAddress::SocketAddress(socket_addr) => Ok(vec![*socket_addr]),
        }
    }
}
impl From<SocketAddr> for UnifiedAddress {
    fn from(value: SocketAddr) -> Self {
        UnifiedAddress::SocketAddress(value)
    }
}

impl From<&SocketAddr> for UnifiedAddress {
    fn from(value: &SocketAddr) -> Self {
        UnifiedAddress::SocketAddress(*value)
    }
}