smol-rs
/
polling
mirror of https://github.com/smol-rs/polling
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

review fix

This commit is contained in:
irving ou 2024-02-22 15:03:23 -05:00
parent d4a2ee3e38
commit 7fa4cfc0f5
2 changed files with 17 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

151
examples/tcp_client.rs
View File

@ -1,155 +1,36 @@
#[cfg(target_os = "linux")]
fn main() -> std::io::Result<()> {
use std::net;
use std::{io::Write, time::Duration};
use std::{io, net};
use polling::Event;
use socket2::Type;
use polling::Event;
use socket2::Type;
std::thread::spawn(|| {
let listener = net::TcpListener::bind("0.0.0.0:8080").unwrap();
println!("Listening on {}", listener.local_addr().unwrap());
for stream in listener.incoming() {
let mut stream = stream.unwrap();
stream.write_all(b"Hello, world!\n").unwrap();
}
});
std::thread::sleep(Duration::from_millis(100));
fn main() -> io::Result<()> {
let socket = socket2::Socket::new(socket2::Domain::IPV4, Type::STREAM, None)?;
let poller = polling::Poller::new()?;
unsafe {
poller.add(&socket, Event::new(0, true, true))?;
}
let addr = net::SocketAddr::new(net::Ipv4Addr::LOCALHOST.into(), 8080);
socket.set_nonblocking(true)?;
let _ = socket.connect(&addr.into());
let mut events = polling::Events::new();
poller.wait(&mut events, Some(Duration::from_secs(3)))?;
let event = events.iter().next().expect("no event");
assert!(event.is_interrupt());
let addr = net::SocketAddr::new("127.0.0.1".parse().unwrap(), 8080);
let err = socket.connect(&addr.into()).unwrap_err();
// EINPROGRESS
assert_eq!(115, err.raw_os_error().expect("No OS error"));
poller
.modify(&socket, Event::writable(0))
.expect("modify failed");
events.clear();
poller.wait(&mut events, Some(Duration::from_secs(3)))?;
let event = events.iter().next().expect("no event");
assert!(event.writable);
assert!(!event.is_interrupt());
assert!(!event.is_err().unwrap());
println!("event: {:?}", event);
println!("socket is now writable");
// ========================================================================
// the below is example of a bad socket
println!("testing bad socket");
let bad_socket = socket2::Socket::new(socket2::Domain::IPV4, Type::STREAM, None)?;
let addr = net::SocketAddr::new("127.0.0.1".parse().unwrap(), 12345);
bad_socket.set_nonblocking(true)?;
unsafe {
poller.add(&bad_socket, Event::writable(0))?;
}
events.clear();
poller.wait(&mut events, Some(Duration::from_secs(3)))?;
poller.wait(&mut events, None)?;
let err = bad_socket.connect(&addr.into()).unwrap_err();
assert_eq!(115, err.raw_os_error().expect("No OS error"));
poller
.modify(&bad_socket, Event::writable(0))
.expect("modify failed");
events.clear();
poller.wait(&mut events, Some(Duration::from_secs(3)))?;
let event = events.iter().next().expect("no event");
assert!(event.is_err().unwrap());
println!("bad socket is now in error state");
Ok(())
}
#[cfg(target_os = "windows")]
fn main() -> std::io::Result<()> {
use polling::Event;
use std::io;
use std::{io::Write, time::Duration};
std::thread::spawn(|| {
let listener = std::net::TcpListener::bind("0.0.0.0:8080").unwrap();
println!("Listening on {}", listener.local_addr().unwrap());
for stream in listener.incoming() {
let mut stream = match stream {
Ok(stream) => stream,
Err(_) => {
continue;
}
};
stream.write_all(b"Hello, world!\n").unwrap();
let event = events.iter().next();
let event = match event {
Some(event) => event,
None => {
println!("no event");
return Ok(());
}
});
std::thread::sleep(Duration::from_millis(100));
let socket = socket2::Socket::new(socket2::Domain::IPV4, socket2::Type::STREAM, None)?;
let poller = polling::Poller::new()?;
unsafe {
poller.add(&socket, Event::new(0, true, true))?;
}
socket.set_nonblocking(true)?;
let addr = std::net::SocketAddr::new("127.0.0.1".parse().unwrap(), 8080);
let err = socket.connect(&addr.into()).unwrap_err();
assert_eq!(err.kind(), io::ErrorKind::WouldBlock);
let mut events = polling::Events::new();
poller.wait(&mut events, Some(Duration::from_secs(3)))?;
let event = events.iter().next().expect("no event");
assert!(event.writable);
assert!(!event.is_interrupt());
assert!(!event.is_err().unwrap());
};
println!("event: {:?}", event);
println!("socket is now writable");
// // ========================================================================
// // the below is example of a bad socket
println!("testing bad socket");
let bad_socket = socket2::Socket::new(socket2::Domain::IPV4, socket2::Type::STREAM, None)?;
let addr = std::net::SocketAddr::new("127.0.0.1".parse().unwrap(), 12345);
bad_socket.set_nonblocking(true)?;
bad_socket.connect(&addr.into()).unwrap_err();
unsafe {
poller.add(&bad_socket, Event::writable(0))?;
if event.is_connect_failed().unwrap_or_default() {
println!("connect failed");
}
events.clear();
poller.wait(&mut events, Some(Duration::from_secs(3)))?;
let event = events.iter().next().expect("no event");
assert!(event.is_err().unwrap());
println!("bad socket is now in error state");
Ok(())
}
#[cfg(not(any(target_os = "linux", target_os = "windows")))]
fn main() {
println!("This example is not yet supported on this platform.");
}

2
src/lib.rs
View File

@ -391,7 +391,7 @@ impl Event {
/// Returns `Some(true)` if the connection has failed, `Some(false)` if the connection has not failed,
/// or `None` if the platform does not support detecting this condition.
#[inline]
#[deprecated]
#[deprecated(since = "3.4.0", note = "use `is_err` in combination of is_hub instead, see documentation for `is_err`")]
pub fn is_connect_failed(&self) -> Option<bool> {
self.extra.is_connect_failed()
}