SHARE
TWEET

Untitled

a guest Mar 26th, 2019 87 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. use std::net::{
  2.         TcpListener,
  3.         TcpStream,
  4.         Shutdown,
  5. };
  6. use std::io::prelude::*;
  7. use std::time::Duration;
  8. use std::io;
  9. use std::thread;
  10.  
  11. fn main() {
  12.  
  13.         thread::spawn(|| {
  14.                 let listener = TcpListener::bind("127.0.0.1:8088").expect("Cannot bind in start_listener");
  15.                 for stream in listener.incoming() {
  16.                         let mut s = stream.expect("Cannot accept connection");
  17.                         let mut buf = vec![0u8; 10];
  18.                         println!("# Connect accepted");
  19.                         match s.read(&mut buf) {
  20.                                 Ok(v) if &buf[0..v] == "read".as_bytes() => {
  21.                                         println!("## Test for read()");
  22.                                         s.set_read_timeout(Some(Duration::from_millis(700)));
  23.                                         reader(&mut s)
  24.                                 },
  25.                                 Ok(v) if &buf[0..v] == "exact".as_bytes() => {
  26.                                         println!("## Test for read_exact()");
  27.                                         s.set_read_timeout(Some(Duration::from_millis(700)));
  28.                                         reader_exact(&mut s)
  29.                                 },
  30.                                 Ok(v) => println!("Error: unexpected greeting: {} {:?}", String::from_utf8_lossy(&buf[..v]),&buf[..v]),
  31.                                 Err(r) => println!("Error: cannot read greeting: {}", r)
  32.                         }
  33.                 };
  34.         });
  35.  
  36.         thread::sleep(Duration::from_millis(50));
  37.         writer("127.0.0.1:8088", "read");
  38.         writer("127.0.0.1:8088", "exact");
  39.         thread::sleep(Duration::from_millis(1000));
  40. }
  41.  
  42. #[derive(PartialEq,Debug)]
  43. enum RR {
  44.         Disconnect,
  45.         Read(Vec<u8>),
  46.         Timeout(Vec<u8>),
  47.         Error,
  48.         UnexpectedEof,
  49. }
  50.  
  51. fn reader(mut s: &mut TcpStream) {
  52.         let patterns = [
  53.                 RR::Read("1234".as_bytes().to_vec()),
  54.                 RR::Timeout("".as_bytes().to_vec()),
  55.                 RR::Read("567".as_bytes().to_vec()),
  56.                 RR::Timeout("".as_bytes().to_vec()),
  57.                 RR::Read("89".as_bytes().to_vec()),
  58.                 RR::Timeout("".as_bytes().to_vec()),
  59.                 RR::Read("abcde".as_bytes().to_vec()),
  60.                 RR::Timeout("".as_bytes().to_vec()),
  61.                 RR::Read("fg".as_bytes().to_vec()),
  62.         ];
  63.  
  64.         for pat in &patterns {
  65.                 let r = read(&mut s);
  66.                 assert_eq!(pat, &r);
  67.         }
  68. }
  69.  
  70. fn read(mut s: &mut TcpStream) -> RR {
  71.         let mut buf = vec![0u8; 10];
  72.         // case: read with read_timeout
  73.         match s.read(&mut buf) {
  74.                 Ok(0) => {
  75.                         println!("## read 0 bytes, assume client disconnected");
  76.                         RR::Disconnect
  77.                 }
  78.                 Ok(size) => {
  79.                         println!("## read {} bytes: {}, {:?}", size, String::from_utf8_lossy(&buf[0..size]), &buf[0..size]);
  80.                         RR::Read(buf[0..size].to_vec())
  81.                 },
  82.                 Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
  83.                         dbg!("## read timeout");
  84.                         RR::Timeout("".as_bytes().to_vec())
  85.                 },
  86.                 Err(e) => {
  87.                         println!("## read error: {:?}", e);
  88.                         RR::Error
  89.                 },
  90.         }
  91. }
  92.  
  93. fn reader_exact(mut s: &mut TcpStream) {
  94.         let patterns = [
  95.                 RR::Read("1234".as_bytes().to_vec()),
  96.                 RR::Timeout(vec![0, 0, 0, 0]),
  97.                 RR::Timeout(vec![b'5',b'6',b'7',0]),
  98.                 RR::Timeout(vec![b'8',b'9',0,0]),
  99.                 RR::Read("abcd".as_bytes().to_vec()),
  100.                 RR::Timeout(vec![b'e',0,0,0]),
  101.                 RR::Timeout(vec![b'f',b'g',0,0]),
  102.                 RR::UnexpectedEof,
  103.         ];
  104.  
  105.         for pat in &patterns {
  106.                 let r = read_exact(&mut s, 4);
  107.                 assert_eq!(pat, &r);
  108.         }
  109. }
  110. fn read_exact(mut s: &mut TcpStream, size: usize) -> RR {
  111.         let mut buf = vec![0u8; 10];
  112.         // case: read_exact with read_timeout
  113.         match s.read_exact(&mut buf[..size]) {
  114.                 Ok(()) => {
  115.                         println!("## aread {} bytes: {}, {:?}", size, String::from_utf8_lossy(&buf[0..size]), &buf[0..size]);
  116.                         RR::Read(buf[0..size].to_vec())
  117.                 },
  118.                 Err(ref e) if e.kind() == io::ErrorKind::UnexpectedEof => {
  119.                         println!("## read error, assume client disconnected");
  120.                         RR::UnexpectedEof
  121.                 },
  122.                 Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
  123.                         // at this point read_exact may write some bytes to buffer but not full - these bytes will be lost
  124.                         println!("## read timeout: {}, {:?}", String::from_utf8_lossy(&buf[0..size]), &buf[0..size]);
  125.                         RR::Timeout(buf[0..size].to_vec())
  126.                 },
  127.                 Err(e) => {
  128.                         println!("## read error: {:?}", e);
  129.                         RR::Error
  130.                 },
  131.         }
  132. }
  133.  
  134. fn writer(port: &str, greeting: &str) {
  135.         let mut stream = TcpStream::connect(port).expect(&format!("cannot connect to {}", port));
  136.         stream.set_nodelay(true);
  137.         stream.write(greeting.as_bytes());
  138.         thread::sleep(Duration::from_millis(100));
  139.  
  140.         let patterns = [
  141.                 "1234",
  142.                 "567",
  143.                 "89",
  144.                 "abcde",
  145.                 "fg",
  146.         ];
  147.  
  148.         for i in &patterns {
  149.                 stream.write(i.as_bytes()).expect("cannot write");
  150.                 thread::sleep(Duration::from_millis(1000));
  151.         }
  152.         stream.shutdown(Shutdown::Both).expect("shutdown call failed");
  153. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top