industrial_protocols_bridge_socket/
lib.rs1use 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 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 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 if let Ok(v) = t.send(b"again") {
153 assert!(v.is_empty(), "closed peer must not echo data");
154 }
155 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 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}