Skip to main content

industrial_protocols_bridge_socket/
lib.rs

1// Copyright (c) 2026 erik <erik@erik.xyz> — https://erik.xyz
2//! # TCP/UDP Socket 传输
3//!
4//! 提供 [`TcpTransport`] 和 [`UdpTransport`] 两种网络传输实现,
5//! 实现 [`Transport`] trait。支持连接超时和读写超时配置。
6
7use industrial_protocols_kernel::bridge::Transport;
8use std::io::{self, Read, Write};
9use std::net::{TcpStream, ToSocketAddrs, UdpSocket};
10use std::time::Duration;
11
12pub struct TcpTransport {
13    stream: TcpStream,
14    closed: bool,
15}
16
17impl TcpTransport {
18    pub fn connect(addr: impl ToSocketAddrs, timeout_ms: u64) -> io::Result<Self> {
19        let timeout = Duration::from_millis(timeout_ms);
20        let addr = addr
21            .to_socket_addrs()?
22            .next()
23            .ok_or_else(|| io::Error::new(io::ErrorKind::NotFound, "no address resolved"))?;
24        let stream = TcpStream::connect_timeout(&addr, timeout)?;
25        stream.set_read_timeout(Some(timeout))?;
26        stream.set_write_timeout(Some(timeout))?;
27        Ok(TcpTransport {
28            stream,
29            closed: false,
30        })
31    }
32}
33
34impl Transport for TcpTransport {
35    fn send(&mut self, data: &[u8]) -> io::Result<Vec<u8>> {
36        self.stream.write_all(data)?;
37        let mut buf = vec![0u8; 4096];
38        let n = self.stream.read(&mut buf)?;
39        buf.truncate(n);
40        Ok(buf)
41    }
42    fn is_open(&self) -> bool {
43        !self.closed
44    }
45    fn close(&mut self) -> io::Result<()> {
46        self.closed = true;
47        self.stream.shutdown(std::net::Shutdown::Both)
48    }
49}
50
51pub struct UdpTransport {
52    socket: UdpSocket,
53    peer: std::net::SocketAddr,
54}
55
56impl UdpTransport {
57    pub fn bind_and_connect(bind_addr: &str, peer_addr: &str, timeout_ms: u64) -> io::Result<Self> {
58        let socket = UdpSocket::bind(bind_addr)?;
59        let peer = peer_addr
60            .to_socket_addrs()?
61            .next()
62            .ok_or_else(|| io::Error::new(io::ErrorKind::NotFound, "no address resolved"))?;
63        socket.set_read_timeout(Some(Duration::from_millis(timeout_ms)))?;
64        socket.set_write_timeout(Some(Duration::from_millis(timeout_ms)))?;
65        Ok(UdpTransport { socket, peer })
66    }
67}
68
69impl Transport for UdpTransport {
70    fn send(&mut self, data: &[u8]) -> io::Result<Vec<u8>> {
71        self.socket.send_to(data, self.peer)?;
72        let mut buf = vec![0u8; 4096];
73        let (n, _) = self.socket.recv_from(&mut buf)?;
74        buf.truncate(n);
75        Ok(buf)
76    }
77    fn is_open(&self) -> bool {
78        true
79    }
80    fn close(&mut self) -> io::Result<()> {
81        Ok(())
82    }
83}
84
85#[cfg(test)]
86mod tests {
87    use super::*;
88    use std::net::UdpSocket;
89    use std::thread;
90
91    #[test]
92    fn test_tcp_connect_refused() {
93        assert!(TcpTransport::connect("127.0.0.1:19999", 100).is_err());
94    }
95    #[test]
96    fn test_udp_bind_ok() {
97        assert!(UdpTransport::bind_and_connect("127.0.0.1:0", "127.0.0.1:19999", 100).is_ok());
98    }
99
100    #[test]
101    fn test_tcp_echo_roundtrip() {
102        let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
103        let addr = listener.local_addr().unwrap();
104        let server = thread::spawn(move || {
105            let (mut sock, _) = listener.accept().unwrap();
106            let mut buf = [0u8; 1024];
107            loop {
108                match sock.read(&mut buf) {
109                    Ok(0) | Err(_) => break,
110                    Ok(n) => sock.write_all(&buf[..n]).unwrap(),
111                }
112            }
113        });
114        let mut t = TcpTransport::connect(addr, 1000).unwrap();
115        assert!(t.is_open());
116        let resp = t.send(b"ping").unwrap();
117        assert_eq!(resp, b"ping");
118        assert!(t.close().is_ok());
119        assert!(!t.is_open());
120        server.join().unwrap();
121    }
122
123    #[test]
124    fn test_tcp_connect_refused_on_recently_freed_port() {
125        // Grab a free port, release it, then connect: the port is closed.
126        let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
127        let addr = listener.local_addr().unwrap();
128        drop(listener);
129        assert!(TcpTransport::connect(addr, 1000).is_err());
130    }
131
132    #[test]
133    fn test_tcp_connect_unresolvable_address() {
134        assert!(TcpTransport::connect("256.256.256.256:1", 100).is_err());
135    }
136
137    #[test]
138    fn test_tcp_echo_then_server_close() {
139        // Server echoes one packet then closes the connection.
140        let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
141        let addr = listener.local_addr().unwrap();
142        let server = thread::spawn(move || {
143            let (mut sock, _) = listener.accept().unwrap();
144            let mut buf = [0u8; 1024];
145            let n = sock.read(&mut buf).unwrap();
146            sock.write_all(&buf[..n]).unwrap();
147        });
148        let mut t = TcpTransport::connect(addr, 1000).unwrap();
149        assert_eq!(t.send(b"hello").unwrap(), b"hello");
150        server.join().unwrap();
151        // Peer is gone: no echo comes back (EOF or a connection error).
152        if let Ok(v) = t.send(b"again") {
153            assert!(v.is_empty(), "closed peer must not echo data");
154        }
155        // Close is best-effort on a reset socket, but the transport
156        // must report closed, and rejects further writes.
157        let _ = t.close();
158        assert!(!t.is_open());
159        assert!(t.send(b"again").is_err());
160    }
161
162    #[test]
163    fn test_tcp_send_times_out_when_no_peer_responds() {
164        // Listener never accepts: connection succeeds via the backlog,
165        // but the read must time out.
166        let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
167        let addr = listener.local_addr().unwrap();
168        let mut t = TcpTransport::connect(addr, 100).unwrap();
169        assert!(t.send(b"nobody-home").is_err());
170        drop(listener);
171    }
172
173    #[test]
174    fn test_udp_echo_roundtrip() {
175        let server = UdpSocket::bind("127.0.0.1:0").unwrap();
176        let server_addr = server.local_addr().unwrap();
177        let handle = thread::spawn(move || {
178            let mut buf = [0u8; 1024];
179            let (n, from) = server.recv_from(&mut buf).unwrap();
180            server.send_to(&buf[..n], from).unwrap();
181        });
182        let mut t =
183            UdpTransport::bind_and_connect("127.0.0.1:0", &server_addr.to_string(), 1000).unwrap();
184        assert!(t.is_open());
185        let resp = t.send(b"udp-ping").unwrap();
186        assert_eq!(resp, b"udp-ping");
187        assert!(t.close().is_ok());
188        handle.join().unwrap();
189    }
190
191    #[test]
192    fn test_udp_close_idempotent() {
193        let mut t = UdpTransport::bind_and_connect("127.0.0.1:0", "127.0.0.1:9", 100).unwrap();
194        assert!(t.close().is_ok());
195        assert!(t.close().is_ok());
196    }
197}