From e422e6f7ef47e7fb8cb5a8ec8c258070488b2760 Mon Sep 17 00:00:00 2001 From: PerfectLaugh Date: Mon, 20 Aug 2018 07:27:39 +0800 Subject: [PATCH 1/6] Initial solution for windows mio problem? Idk... --- src/sys/windows/from_raw_arc.rs | 25 ++++++++ src/sys/windows/selector.rs | 47 ++++++++++++++ src/sys/windows/tcp.rs | 40 ++++++++++-- src/sys/windows/udp.rs | 17 +++++ test/mod.rs | 1 + ...st_drop_cancels_interest_and_shuts_down.rs | 62 +++++++++++++++++++ 6 files changed, 188 insertions(+), 4 deletions(-) create mode 100644 test/test_drop_cancels_interest_and_shuts_down.rs diff --git a/src/sys/windows/from_raw_arc.rs b/src/sys/windows/from_raw_arc.rs index b6d38b240..61f0e49cd 100644 --- a/src/sys/windows/from_raw_arc.rs +++ b/src/sys/windows/from_raw_arc.rs @@ -22,6 +22,7 @@ use std::ops::Deref; use std::mem; use std::sync::atomic::{self, AtomicUsize, Ordering}; +use winapi::OVERLAPPED; pub struct FromRawArc { _inner: *mut Inner, @@ -86,6 +87,30 @@ impl Drop for FromRawArc { } } +unsafe impl Send for FromRawArcStore { } +unsafe impl Sync for FromRawArcStore { } + +pub struct FromRawArcStore { + _ptr: *mut OVERLAPPED, + deallocator: fn(*mut OVERLAPPED), +} + +impl FromRawArcStore { + pub fn new(ptr: *mut OVERLAPPED, deallocator: fn(*mut OVERLAPPED)) -> FromRawArcStore { + let store = FromRawArcStore { + _ptr: unsafe { mem::transmute(ptr) }, + deallocator: deallocator, + }; + store + } +} + +impl Drop for FromRawArcStore { + fn drop(&mut self) { + (self.deallocator)(self._ptr); + } +} + #[cfg(test)] mod tests { use super::FromRawArc; diff --git a/src/sys/windows/selector.rs b/src/sys/windows/selector.rs index 21e894b8e..d6a9cc826 100644 --- a/src/sys/windows/selector.rs +++ b/src/sys/windows/selector.rs @@ -6,6 +6,7 @@ use std::os::windows::prelude::*; use std::sync::{Arc, Mutex}; use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT}; use std::time::Duration; +use std::mem; use lazycell::AtomicLazyCell; @@ -16,6 +17,7 @@ use miow::iocp::{CompletionPort, CompletionStatus}; use event_imp::{Event, Evented, Ready}; use poll::{self, Poll}; use sys::windows::buffer_pool::BufferPool; +use sys::windows::from_raw_arc::FromRawArcStore; use {Token, PollOpt}; /// Each Selector has a globally unique(ish) ID associated with it. This ID @@ -48,6 +50,8 @@ struct SelectorInner { /// Primitives will take buffers from this pool to perform I/O operations, /// and once complete they'll be put back in. buffers: Mutex, + + incompletes: Mutex>, } impl Selector { @@ -61,6 +65,7 @@ impl Selector { id: id, port: cp, buffers: Mutex::new(BufferPool::new(256)), + incompletes: Mutex::new(Vec::new()), }), } }) @@ -91,6 +96,20 @@ impl Selector { ret = true; continue; } + // Deadlock will occur if you don't release it first before the callback. + { + let mut incompletes = self.inner.incompletes.lock().unwrap(); + let pos = incompletes.iter().position(|item| item.0 == (status.overlapped() as isize)); + match pos { + Some(pos) => { + let store = incompletes.remove(pos); + mem::forget(store); + }, + None => { + trace!("cannot find store, omiting..."); + } + } + } let callback = unsafe { (*(status.overlapped() as *mut Overlapped)).callback @@ -104,6 +123,16 @@ impl Selector { Ok(ret) } + pub fn store_overlapped_content(&self, ptr: *mut OVERLAPPED, deallocator: fn(*mut OVERLAPPED)) { + let mut incompletes = self.inner.incompletes.lock().unwrap(); + incompletes.push((ptr as isize, FromRawArcStore::new(ptr, deallocator))); + } + + pub fn clean_overlapped_content(&self, ptr: *mut OVERLAPPED) { + let mut incompletes = self.inner.incompletes.lock().unwrap(); + incompletes.retain(|item| ptr as isize != item.0); + } + /// Gets a reference to the underlying `CompletionPort` structure. pub fn port(&self) -> &CompletionPort { &self.inner.port @@ -404,6 +433,24 @@ impl ReadyBinding { .as_ref().unwrap() .deregister(poll) } + + pub fn store_overlapped_content(&self, ptr: *mut OVERLAPPED, deallocator: fn(*mut OVERLAPPED)) { + if let Some(i) = self.binding.selector.borrow() { + let selector = Selector { + inner: i.clone(), + }; + selector.store_overlapped_content(ptr, deallocator); + } + } + + pub fn clean_overlapped_content(&self, ptr: *mut OVERLAPPED) { + if let Some(i) = self.binding.selector.borrow() { + let selector = Selector { + inner: i.clone(), + }; + selector.clean_overlapped_content(ptr); + } + } } fn other(s: &str) -> io::Error { diff --git a/src/sys/windows/tcp.rs b/src/sys/windows/tcp.rs index 40843f6c5..b542e2a06 100644 --- a/src/sys/windows/tcp.rs +++ b/src/sys/windows/tcp.rs @@ -394,13 +394,14 @@ impl StreamImp { self.inner.inner.lock().unwrap() } - fn schedule_connect(&self, addr: &SocketAddr) -> io::Result<()> { + fn schedule_connect(&self, addr: &SocketAddr, me: &mut StreamInner) -> io::Result<()> { unsafe { trace!("scheduling a connect"); self.inner.socket.connect_overlapped(addr, &[], self.inner.read.as_mut_ptr())?; } // see docs above on StreamImp.inner for rationale on forget mem::forget(self.clone()); + me.iocp.store_overlapped_content(self.inner.read.as_mut_ptr(), read_deallocate); Ok(()) } @@ -454,6 +455,7 @@ impl StreamImp { // see docs above on StreamImp.inner for rationale on forget me.read = State::Pending(()); mem::forget(self.clone()); + me.iocp.store_overlapped_content(self.inner.read.as_mut_ptr(), read_deallocate); } Err(e) => { me.read = State::Error(e); @@ -499,6 +501,7 @@ impl StreamImp { // see docs above on StreamImp.inner for rationale on forget me.write = State::Pending((buf, pos)); mem::forget(self.clone()); + me.iocp.store_overlapped_content(self.inner.write.as_mut_ptr(), write_deallocate); break; } Err(e) => { @@ -578,6 +581,20 @@ fn write_done(status: &OVERLAPPED_ENTRY) { } } +fn read_deallocate(ptr: *mut OVERLAPPED) { + let me = StreamImp { + inner: unsafe { overlapped2arc!(ptr, StreamIo, read) }, + }; + drop(me); +} + +fn write_deallocate(ptr: *mut OVERLAPPED) { + let me = StreamImp { + inner: unsafe { overlapped2arc!(ptr, StreamIo, write) }, + }; + drop(me); +} + impl Evented for TcpStream { fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { @@ -595,7 +612,7 @@ impl Evented for TcpStream { // successful connect will worry about generating writable/readable // events and scheduling a new read. if let Some(addr) = me.deferred_connect.take() { - return self.imp.schedule_connect(&addr).map(|_| ()) + return self.imp.schedule_connect(&addr, &mut me).map(|_| ()) } self.post_register(interest, &mut me); Ok(()) @@ -632,11 +649,15 @@ impl Drop for TcpStream { // Note that "Empty" here may mean that a connect is pending, so we // cancel even if that happens as well. unsafe { - match self.inner().read { + let inner = self.inner(); + match inner.read { State::Pending(_) | State::Empty => { trace!("cancelling active TCP read"); drop(super::cancel(&self.imp.inner.socket, &self.imp.inner.read)); + trace!("cleaning remaining overlapped contents"); + inner.iocp.clean_overlapped_content(self.imp.inner.read.as_mut_ptr()); + inner.iocp.clean_overlapped_content(self.imp.inner.write.as_mut_ptr()); } State::Ready(_) | State::Error(_) => {} } @@ -754,6 +775,7 @@ impl ListenerImp { // see docs above on StreamImp.inner for rationale on forget me.accept = State::Pending(socket); mem::forget(self.clone()); + me.iocp.store_overlapped_content(self.inner.accept.as_mut_ptr(), accept_dellocate); } Err(e) => { me.accept = State::Error(e); @@ -794,6 +816,13 @@ fn accept_done(status: &OVERLAPPED_ENTRY) { me2.add_readiness(&mut me, Ready::readable()); } +fn accept_dellocate(ptr: *mut OVERLAPPED) { + let me = ListenerImp { + inner: unsafe { overlapped2arc!(ptr, ListenerIo, accept) }, + }; + drop(me); +} + impl Evented for TcpListener { fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { @@ -836,11 +865,14 @@ impl Drop for TcpListener { fn drop(&mut self) { // If we're still internally reading, we're no longer interested. unsafe { - match self.inner().accept { + let inner = self.inner(); + match inner.accept { State::Pending(_) => { trace!("cancelling active TCP accept"); drop(super::cancel(&self.imp.inner.socket, &self.imp.inner.accept)); + trace!("cleaning remaining overlapped contents"); + inner.iocp.clean_overlapped_content(self.imp.inner.accept.as_mut_ptr()); } State::Empty | State::Ready(_) | diff --git a/src/sys/windows/udp.rs b/src/sys/windows/udp.rs index 4d3fc040f..2e34a2458 100644 --- a/src/sys/windows/udp.rs +++ b/src/sys/windows/udp.rs @@ -113,6 +113,7 @@ impl UdpSocket { }?; me.write = State::Pending(owned_buf); mem::forget(self.imp.clone()); + me.iocp.store_overlapped_content(self.imp.inner.write.as_mut_ptr(), send_deallocate); Ok(amt) } @@ -147,6 +148,7 @@ impl UdpSocket { }?; me.write = State::Pending(owned_buf); mem::forget(self.imp.clone()); + me.iocp.store_overlapped_content(self.imp.inner.write.as_mut_ptr(), send_deallocate); Ok(amt) } @@ -313,6 +315,7 @@ impl Imp { Ok(_) => { me.read = State::Pending(buf); mem::forget(self.clone()); + me.iocp.store_overlapped_content(self.inner.read.as_mut_ptr(), recv_deallocate); } Err(e) => { me.read = State::Error(e); @@ -411,3 +414,17 @@ fn recv_done(status: &OVERLAPPED_ENTRY) { me.read = State::Ready(buf); me2.add_readiness(&mut me, Ready::readable()); } + +fn send_deallocate(ptr: *mut OVERLAPPED) { + let me = Imp { + inner: unsafe { overlapped2arc!(ptr, Io, write) }, + }; + drop(me); +} + +fn recv_deallocate(ptr: *mut OVERLAPPED) { + let me = Imp { + inner: unsafe { overlapped2arc!(ptr, Io, read) }, + }; + drop(me); +} \ No newline at end of file diff --git a/test/mod.rs b/test/mod.rs index 75cda53f4..d88038eae 100644 --- a/test/mod.rs +++ b/test/mod.rs @@ -33,6 +33,7 @@ mod test_tcp_level; mod test_udp_level; mod test_udp_socket; mod test_write_then_drop; +mod test_drop_cancels_interest_and_shuts_down; #[cfg(feature = "with-deprecated")] mod test_notify; diff --git a/test/test_drop_cancels_interest_and_shuts_down.rs b/test/test_drop_cancels_interest_and_shuts_down.rs new file mode 100644 index 000000000..e03fe2d14 --- /dev/null +++ b/test/test_drop_cancels_interest_and_shuts_down.rs @@ -0,0 +1,62 @@ +#[test] +fn drop_cancels_interest_and_shuts_down() { + use mio::net::TcpStream; + use mio::*; + use std::io; + use std::io::Read; + use std::net::TcpListener; + use std::thread; + use std::time::Duration; + + use env_logger; + let _ = env_logger::init(); + let l = TcpListener::bind("127.0.0.1:18000").unwrap(); + let addr = l.local_addr().unwrap(); + + let t = thread::spawn(move || { + let mut s = l.incoming().next().unwrap().unwrap(); + s.set_read_timeout(Some(Duration::from_secs(5))) + .expect("set_read_timeout"); + let r = s.read(&mut [0; 16]); + match r { + Ok(_) => (), + Err(e) => { + if e.kind() != io::ErrorKind::UnexpectedEof { + eprintln!("{}", e); + panic!(e); + } + } + } + }); + + let poll = Poll::new().unwrap(); + let mut s = TcpStream::connect(&addr).unwrap(); + + poll.register( + &s, + Token(1), + Ready::readable() | Ready::writable(), + PollOpt::edge(), + ).unwrap(); + let mut events = Events::with_capacity(16); + 'outer: loop { + poll.poll(&mut events, None).unwrap(); + for event in &events { + if event.token() == Token(1) { + // connected + break 'outer; + } + } + } + + let mut b = [0; 1024]; + match s.read(&mut b) { + Ok(_) => panic!("unexpected ok"), + Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => (), + Err(e) => panic!("unexpected error: {:?}", e), + } + + drop(poll); + drop(s); + t.join().unwrap(); +} From fe3a06e8a65245bf0c34af7ad283d663b51402aa Mon Sep 17 00:00:00 2001 From: PerfectLaugh Date: Mon, 20 Aug 2018 13:57:44 +0800 Subject: [PATCH 2/6] try to fix test code and did the cargo +nightly fmt --- benches/bench_poll.rs | 8 +- src/channel.rs | 101 ++++-- src/deprecated/event_loop.rs | 62 ++-- src/deprecated/handler.rs | 17 +- src/deprecated/io.rs | 2 +- src/deprecated/mod.rs | 30 +- src/deprecated/notify.rs | 26 +- src/deprecated/unix.rs | 140 +++++++-- src/event_imp.rs | 77 ++++- src/io.rs | 2 +- src/lib.rs | 42 ++- src/net/tcp.rs | 86 +++--- src/net/udp.rs | 51 ++-- src/poll.rs | 289 +++++++++++------- src/sys/fuchsia/awakener.rs | 47 +-- src/sys/fuchsia/eventedfd.rs | 118 +++---- src/sys/fuchsia/handles.rs | 31 +- src/sys/fuchsia/mod.rs | 38 +-- src/sys/fuchsia/net.rs | 129 ++++---- src/sys/fuchsia/ready.rs | 8 +- src/sys/fuchsia/selector.rs | 171 ++++++----- src/sys/mod.rs | 28 +- src/sys/unix/awakener.rs | 22 +- src/sys/unix/epoll.rs | 93 ++++-- src/sys/unix/eventedfd.rs | 18 +- src/sys/unix/io.rs | 32 +- src/sys/unix/kqueue.rs | 181 +++++++---- src/sys/unix/mod.rs | 60 +++- src/sys/unix/ready.rs | 101 ++++-- src/sys/unix/tcp.rs | 77 ++--- src/sys/unix/udp.rs | 51 ++-- src/sys/unix/uds.rs | 70 +++-- src/sys/windows/awakener.rs | 20 +- src/sys/windows/buffer_pool.rs | 14 +- src/sys/windows/from_raw_arc.rs | 24 +- src/sys/windows/mod.rs | 14 +- src/sys/windows/selector.rs | 186 +++++------ src/sys/windows/tcp.rs | 256 ++++++++++------ src/sys/windows/udp.rs | 155 ++++++---- src/timer.rs | 136 ++++++--- src/udp.rs | 66 ++-- test/mod.rs | 79 +++-- test/test_battery.rs | 118 ++++--- test/test_broken_pipe.rs | 11 +- test/test_close_on_drop.rs | 26 +- test/test_custom_evented.rs | 97 ++++-- test/test_double_register.rs | 10 +- ...st_drop_cancels_interest_and_shuts_down.rs | 3 +- test/test_echo_server.rs | 116 ++++--- test/test_fuchsia_handles.rs | 19 +- test/test_local_addr_ready.rs | 25 +- test/test_multicast.rs | 32 +- test/test_notify.rs | 22 +- test/test_oneshot.rs | 46 ++- test/test_poll.rs | 6 +- test/test_poll_channel.rs | 150 ++++++--- test/test_register_deregister.rs | 54 ++-- test/test_register_multiple_event_loops.rs | 68 ++++- test/test_reregister_without_poll.rs | 24 +- test/test_smoke.rs | 16 +- test/test_subprocess_pipe.rs | 197 ++++++------ test/test_tcp.rs | 237 ++++++++------ test/test_tcp_level.rs | 93 ++++-- test/test_tick.rs | 17 +- test/test_timer.rs | 168 ++++++---- test/test_udp_level.rs | 60 +++- test/test_udp_socket.rs | 52 ++-- test/test_uds_shutdown.rs | 147 +++++---- test/test_unix_echo_server.rs | 127 ++++++-- test/test_unix_pass_fd.rs | 115 +++++-- test/test_write_then_drop.rs | 52 ++-- 71 files changed, 3289 insertions(+), 1977 deletions(-) diff --git a/benches/bench_poll.rs b/benches/bench_poll.rs index 7d61d0d65..4085b219b 100644 --- a/benches/bench_poll.rs +++ b/benches/bench_poll.rs @@ -4,9 +4,9 @@ extern crate mio; extern crate test; use mio::*; -use test::Bencher; use std::sync::Arc; use std::thread; +use test::Bencher; #[bench] fn bench_poll(bench: &mut Bencher) { @@ -20,11 +20,7 @@ fn bench_poll(bench: &mut Bencher) { let mut set_readiness = vec![]; for i in 0..NUM { - let (r, s) = Registration::new( - &poll, - Token(i), - Ready::readable(), - PollOpt::edge()); + let (r, s) = Registration::new(&poll, Token(i), Ready::readable(), PollOpt::edge()); registrations.push(r); set_readiness.push(s); diff --git a/src/channel.rs b/src/channel.rs index 851378fff..7a3e3e06b 100644 --- a/src/channel.rs +++ b/src/channel.rs @@ -2,14 +2,14 @@ #![allow(unused_imports, deprecated, missing_debug_implementations)] -use {io, Ready, Poll, PollOpt, Registration, SetReadiness, Token}; use event::Evented; -use lazycell::{LazyCell, AtomicLazyCell}; +use lazycell::{AtomicLazyCell, LazyCell}; use std::any::Any; -use std::fmt; use std::error; -use std::sync::{mpsc, Arc}; +use std::fmt; use std::sync::atomic::{AtomicUsize, Ordering}; +use std::sync::{mpsc, Arc}; +use {io, Poll, PollOpt, Ready, Registration, SetReadiness, Token}; /// Creates a new asynchronous channel, where the `Receiver` can be registered /// with `Poll`. @@ -116,12 +116,10 @@ struct Inner { impl Sender { pub fn send(&self, t: T) -> Result<(), SendError> { - self.tx.send(t) - .map_err(SendError::from) - .and_then(|_| { - self.ctl.inc()?; - Ok(()) - }) + self.tx.send(t).map_err(SendError::from).and_then(|_| { + self.ctl.inc()?; + Ok(()) + }) } } @@ -136,21 +134,17 @@ impl Clone for Sender { impl SyncSender { pub fn send(&self, t: T) -> Result<(), SendError> { - self.tx.send(t) - .map_err(From::from) - .and_then(|_| { - self.ctl.inc()?; - Ok(()) - }) + self.tx.send(t).map_err(From::from).and_then(|_| { + self.ctl.inc()?; + Ok(()) + }) } pub fn try_send(&self, t: T) -> Result<(), TrySendError> { - self.tx.try_send(t) - .map_err(From::from) - .and_then(|_| { - self.ctl.inc()?; - Ok(()) - }) + self.tx.try_send(t).map_err(From::from).and_then(|_| { + self.ctl.inc()?; + Ok(()) + }) } } @@ -173,11 +167,23 @@ impl Receiver { } impl Evented for Receiver { - fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.ctl.register(poll, token, interest, opts) } - fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.ctl.reregister(poll, token, interest, opts) } @@ -211,7 +217,9 @@ impl SenderCtl { impl Clone for SenderCtl { fn clone(&self) -> SenderCtl { self.inner.senders.fetch_add(1, Ordering::Relaxed); - SenderCtl { inner: self.inner.clone() } + SenderCtl { + inner: self.inner.clone(), + } } } @@ -250,36 +258,63 @@ impl ReceiverCtl { } impl Evented for ReceiverCtl { - fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { if self.registration.borrow().is_some() { - return Err(io::Error::new(io::ErrorKind::Other, "receiver already registered")); + return Err(io::Error::new( + io::ErrorKind::Other, + "receiver already registered", + )); } let (registration, set_readiness) = Registration::new(poll, token, interest, opts); - if self.inner.pending.load(Ordering::Relaxed) > 0 { // TODO: Don't drop readiness let _ = set_readiness.set_readiness(Ready::readable()); } - self.registration.fill(registration).ok().expect("unexpected state encountered"); - self.inner.set_readiness.fill(set_readiness).ok().expect("unexpected state encountered"); + self.registration + .fill(registration) + .ok() + .expect("unexpected state encountered"); + self.inner + .set_readiness + .fill(set_readiness) + .ok() + .expect("unexpected state encountered"); Ok(()) } - fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { match self.registration.borrow() { Some(registration) => registration.update(poll, token, interest, opts), - None => Err(io::Error::new(io::ErrorKind::Other, "receiver not registered")), + None => Err(io::Error::new( + io::ErrorKind::Other, + "receiver not registered", + )), } } fn deregister(&self, poll: &Poll) -> io::Result<()> { match self.registration.borrow() { Some(registration) => registration.deregister(poll), - None => Err(io::Error::new(io::ErrorKind::Other, "receiver not registered")), + None => Err(io::Error::new( + io::ErrorKind::Other, + "receiver not registered", + )), } } } diff --git a/src/deprecated/event_loop.rs b/src/deprecated/event_loop.rs index a4beab139..825246975 100644 --- a/src/deprecated/event_loop.rs +++ b/src/deprecated/event_loop.rs @@ -1,11 +1,11 @@ -use {channel, Poll, Events, Token}; -use event::Evented; use deprecated::{Handler, NotifyError}; -use event_imp::{Event, Ready, PollOpt}; -use timer::{self, Timer, Timeout}; -use std::{io, fmt, usize}; +use event::Evented; +use event_imp::{Event, PollOpt, Ready}; use std::default::Default; use std::time::Duration; +use std::{fmt, io, usize}; +use timer::{self, Timeout, Timer}; +use {channel, Events, Poll, Token}; #[derive(Debug, Default, Clone)] pub struct EventLoopBuilder { @@ -101,7 +101,6 @@ const NOTIFY: Token = Token(usize::MAX - 1); const TIMER: Token = Token(usize::MAX - 2); impl EventLoop { - /// Constructs a new `EventLoop` using the default configuration values. /// The `EventLoop` will not be running. pub fn new() -> io::Result> { @@ -122,7 +121,12 @@ impl EventLoop { let (tx, rx) = channel::sync_channel(config.notify_capacity); // Register the notification wakeup FD with the IO poller - poll.register(&rx, NOTIFY, Ready::readable(), PollOpt::edge() | PollOpt::oneshot())?; + poll.register( + &rx, + NOTIFY, + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + )?; poll.register(&timer, TIMER, Ready::readable(), PollOpt::edge())?; Ok(EventLoop { @@ -241,15 +245,29 @@ impl EventLoop { } /// Registers an IO handle with the event loop. - pub fn register(&mut self, io: &E, token: Token, interest: Ready, opt: PollOpt) -> io::Result<()> - where E: Evented + pub fn register( + &mut self, + io: &E, + token: Token, + interest: Ready, + opt: PollOpt, + ) -> io::Result<()> + where + E: Evented, { self.poll.register(io, token, interest, opt) } /// Re-Registers an IO handle with the event loop. - pub fn reregister(&mut self, io: &E, token: Token, interest: Ready, opt: PollOpt) -> io::Result<()> - where E: Evented + pub fn reregister( + &mut self, + io: &E, + token: Token, + interest: Ready, + opt: PollOpt, + ) -> io::Result<()> + where + E: Evented, { self.poll.reregister(io, token, interest, opt) } @@ -275,7 +293,10 @@ impl EventLoop { /// /// Warning: kqueue effectively builds in deregister when using edge-triggered mode with /// oneshot. Calling `deregister()` on the socket will cause a TcpStream error. - pub fn deregister(&mut self, io: &E) -> io::Result<()> where E: Evented { + pub fn deregister(&mut self, io: &E) -> io::Result<()> + where + E: Evented, + { self.poll.deregister(io) } @@ -328,7 +349,7 @@ impl EventLoop { match evt.token() { NOTIFY => self.notify(handler), TIMER => self.timer_process(handler), - _ => self.io_event(handler, evt) + _ => self.io_event(handler, evt), } i += 1; @@ -348,7 +369,12 @@ impl EventLoop { } // Re-register - let _ = self.poll.reregister(&self.notify_rx, NOTIFY, Ready::readable(), PollOpt::edge() | PollOpt::oneshot()); + let _ = self.poll.reregister( + &self.notify_rx, + NOTIFY, + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ); } fn timer_process(&mut self, handler: &mut H) { @@ -370,7 +396,7 @@ impl fmt::Debug for EventLoop { /// Sends messages to the EventLoop from other threads. pub struct Sender { - tx: channel::SyncSender + tx: channel::SyncSender, } impl fmt::Debug for Sender { @@ -379,9 +405,11 @@ impl fmt::Debug for Sender { } } -impl Clone for Sender { +impl Clone for Sender { fn clone(&self) -> Sender { - Sender { tx: self.tx.clone() } + Sender { + tx: self.tx.clone(), + } } } diff --git a/src/deprecated/handler.rs b/src/deprecated/handler.rs index db1bc314a..4355b763b 100644 --- a/src/deprecated/handler.rs +++ b/src/deprecated/handler.rs @@ -1,5 +1,5 @@ +use deprecated::EventLoop; use {Ready, Token}; -use deprecated::{EventLoop}; #[allow(unused_variables)] pub trait Handler: Sized { @@ -16,22 +16,17 @@ pub trait Handler: Sized { /// /// This function will only be invoked a single time per socket per event /// loop tick. - fn ready(&mut self, event_loop: &mut EventLoop, token: Token, events: Ready) { - } + fn ready(&mut self, event_loop: &mut EventLoop, token: Token, events: Ready) {} /// Invoked when a message has been received via the event loop's channel. - fn notify(&mut self, event_loop: &mut EventLoop, msg: Self::Message) { - } + fn notify(&mut self, event_loop: &mut EventLoop, msg: Self::Message) {} /// Invoked when a timeout has completed. - fn timeout(&mut self, event_loop: &mut EventLoop, timeout: Self::Timeout) { - } + fn timeout(&mut self, event_loop: &mut EventLoop, timeout: Self::Timeout) {} /// Invoked when `EventLoop` has been interrupted by a signal interrupt. - fn interrupted(&mut self, event_loop: &mut EventLoop) { - } + fn interrupted(&mut self, event_loop: &mut EventLoop) {} /// Invoked at the end of an event loop tick. - fn tick(&mut self, event_loop: &mut EventLoop) { - } + fn tick(&mut self, event_loop: &mut EventLoop) {} } diff --git a/src/deprecated/io.rs b/src/deprecated/io.rs index 16ff27993..accbf911b 100644 --- a/src/deprecated/io.rs +++ b/src/deprecated/io.rs @@ -1,4 +1,4 @@ -use ::io::MapNonBlock; +use io::MapNonBlock; use std::io::{self, Read, Write}; pub trait TryRead { diff --git a/src/deprecated/mod.rs b/src/deprecated/mod.rs index 124a2eee3..52507cbca 100644 --- a/src/deprecated/mod.rs +++ b/src/deprecated/mod.rs @@ -1,36 +1,18 @@ #![allow(deprecated)] mod event_loop; -mod io; mod handler; +mod io; mod notify; #[cfg(all(unix, not(target_os = "fuchsia")))] pub mod unix; -pub use self::event_loop::{ - EventLoop, - EventLoopBuilder, - Sender, -}; -pub use self::io::{ - TryAccept, - TryRead, - TryWrite, -}; -pub use self::handler::{ - Handler, -}; -pub use self::notify::{ - NotifyError, -}; +pub use self::event_loop::{EventLoop, EventLoopBuilder, Sender}; +pub use self::handler::Handler; +pub use self::io::{TryAccept, TryRead, TryWrite}; +pub use self::notify::NotifyError; #[cfg(all(unix, not(target_os = "fuchsia")))] pub use self::unix::{ - pipe, - PipeReader, - PipeWriter, - UnixListener, - UnixSocket, - UnixStream, - Shutdown, + pipe, PipeReader, PipeWriter, Shutdown, UnixListener, UnixSocket, UnixStream, }; diff --git a/src/deprecated/notify.rs b/src/deprecated/notify.rs index c8432d6b0..26fa68e3d 100644 --- a/src/deprecated/notify.rs +++ b/src/deprecated/notify.rs @@ -1,5 +1,5 @@ -use {channel}; -use std::{fmt, io, error, any}; +use channel; +use std::{any, error, fmt, io}; pub enum NotifyError { Io(io::Error), @@ -10,15 +10,9 @@ pub enum NotifyError { impl fmt::Debug for NotifyError { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { match *self { - NotifyError::Io(ref e) => { - write!(fmt, "NotifyError::Io({:?})", e) - } - NotifyError::Full(..) => { - write!(fmt, "NotifyError::Full(..)") - } - NotifyError::Closed(..) => { - write!(fmt, "NotifyError::Closed(..)") - } + NotifyError::Io(ref e) => write!(fmt, "NotifyError::Io({:?})", e), + NotifyError::Full(..) => write!(fmt, "NotifyError::Full(..)"), + NotifyError::Closed(..) => write!(fmt, "NotifyError::Closed(..)"), } } } @@ -26,11 +20,9 @@ impl fmt::Debug for NotifyError { impl fmt::Display for NotifyError { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { match *self { - NotifyError::Io(ref e) => { - write!(fmt, "IO error: {}", e) - } + NotifyError::Io(ref e) => write!(fmt, "IO error: {}", e), NotifyError::Full(..) => write!(fmt, "Full"), - NotifyError::Closed(..) => write!(fmt, "Closed") + NotifyError::Closed(..) => write!(fmt, "Closed"), } } } @@ -40,14 +32,14 @@ impl error::Error for NotifyError { match *self { NotifyError::Io(ref err) => err.description(), NotifyError::Closed(..) => "The receiving end has hung up", - NotifyError::Full(..) => "Queue is full" + NotifyError::Full(..) => "Queue is full", } } fn cause(&self) -> Option<&error::Error> { match *self { NotifyError::Io(ref err) => Some(err), - _ => None + _ => None, } } } diff --git a/src/deprecated/unix.rs b/src/deprecated/unix.rs index 9f93ae931..6282ba64c 100644 --- a/src/deprecated/unix.rs +++ b/src/deprecated/unix.rs @@ -1,11 +1,11 @@ -use {io, sys, Ready, Poll, PollOpt, Token}; -use event::Evented; use deprecated::TryAccept; +use event::Evented; use io::MapNonBlock; use std::io::{Read, Write}; -use std::path::Path; pub use std::net::Shutdown; +use std::path::Path; use std::process; +use {io, sys, Poll, PollOpt, Ready, Token}; pub use sys::Io; @@ -17,8 +17,7 @@ pub struct UnixSocket { impl UnixSocket { /// Returns a new, unbound, non-blocking Unix domain socket pub fn stream() -> io::Result { - sys::UnixSocket::stream() - .map(From::from) + sys::UnixSocket::stream().map(From::from) } /// Connect the socket to the specified address @@ -43,17 +42,28 @@ impl UnixSocket { } pub fn try_clone(&self) -> io::Result { - self.sys.try_clone() - .map(From::from) + self.sys.try_clone().map(From::from) } } impl Evented for UnixSocket { - fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.sys.register(poll, token, interest, opts) } - fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.sys.reregister(poll, token, interest, opts) } @@ -87,8 +97,7 @@ impl UnixStream { } pub fn try_clone(&self) -> io::Result { - self.sys.try_clone() - .map(From::from) + self.sys.try_clone().map(From::from) } pub fn shutdown(&self, how: Shutdown) -> io::Result { @@ -99,7 +108,10 @@ impl UnixStream { self.sys.read_recv_fd(buf) } - pub fn try_read_recv_fd(&mut self, buf: &mut [u8]) -> io::Result)>> { + pub fn try_read_recv_fd( + &mut self, + buf: &mut [u8], + ) -> io::Result)>> { self.read_recv_fd(buf).map_non_block() } @@ -129,11 +141,23 @@ impl Write for UnixStream { } impl Evented for UnixStream { - fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.sys.register(poll, token, interest, opts) } - fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.sys.reregister(poll, token, interest, opts) } @@ -177,11 +201,23 @@ impl UnixListener { } impl Evented for UnixListener { - fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.sys.register(poll, token, interest, opts) } - fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.sys.reregister(poll, token, interest, opts) } @@ -224,16 +260,20 @@ impl PipeReader { pub fn from_stdout(stdout: process::ChildStdout) -> io::Result { match sys::set_nonblock(stdout.as_raw_fd()) { Err(e) => return Err(e), - _ => {}, + _ => {} } - return Ok(PipeReader::from(unsafe { Io::from_raw_fd(stdout.into_raw_fd()) })); + return Ok(PipeReader::from(unsafe { + Io::from_raw_fd(stdout.into_raw_fd()) + })); } pub fn from_stderr(stderr: process::ChildStderr) -> io::Result { match sys::set_nonblock(stderr.as_raw_fd()) { Err(e) => return Err(e), - _ => {}, + _ => {} } - return Ok(PipeReader::from(unsafe { Io::from_raw_fd(stderr.into_raw_fd()) })); + return Ok(PipeReader::from(unsafe { + Io::from_raw_fd(stderr.into_raw_fd()) + })); } } @@ -250,11 +290,23 @@ impl<'a> Read for &'a PipeReader { } impl Evented for PipeReader { - fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.io.register(poll, token, interest, opts) } - fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.io.reregister(poll, token, interest, opts) } @@ -278,9 +330,11 @@ impl PipeWriter { pub fn from_stdin(stdin: process::ChildStdin) -> io::Result { match sys::set_nonblock(stdin.as_raw_fd()) { Err(e) => return Err(e), - _ => {}, + _ => {} } - return Ok(PipeWriter::from(unsafe { Io::from_raw_fd(stdin.into_raw_fd()) })); + return Ok(PipeWriter::from(unsafe { + Io::from_raw_fd(stdin.into_raw_fd()) + })); } } @@ -305,11 +359,23 @@ impl<'a> Write for &'a PipeWriter { } impl Evented for PipeWriter { - fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.io.register(poll, token, interest, opts) } - fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.io.reregister(poll, token, interest, opts) } @@ -330,7 +396,7 @@ impl From for PipeWriter { * */ -use std::os::unix::io::{RawFd, IntoRawFd, AsRawFd, FromRawFd}; +use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; impl IntoRawFd for UnixSocket { fn into_raw_fd(self) -> RawFd { @@ -346,7 +412,9 @@ impl AsRawFd for UnixSocket { impl FromRawFd for UnixSocket { unsafe fn from_raw_fd(fd: RawFd) -> UnixSocket { - UnixSocket { sys: FromRawFd::from_raw_fd(fd) } + UnixSocket { + sys: FromRawFd::from_raw_fd(fd), + } } } @@ -364,7 +432,9 @@ impl AsRawFd for UnixStream { impl FromRawFd for UnixStream { unsafe fn from_raw_fd(fd: RawFd) -> UnixStream { - UnixStream { sys: FromRawFd::from_raw_fd(fd) } + UnixStream { + sys: FromRawFd::from_raw_fd(fd), + } } } @@ -382,7 +452,9 @@ impl AsRawFd for UnixListener { impl FromRawFd for UnixListener { unsafe fn from_raw_fd(fd: RawFd) -> UnixListener { - UnixListener { sys: FromRawFd::from_raw_fd(fd) } + UnixListener { + sys: FromRawFd::from_raw_fd(fd), + } } } @@ -400,7 +472,9 @@ impl AsRawFd for PipeReader { impl FromRawFd for PipeReader { unsafe fn from_raw_fd(fd: RawFd) -> PipeReader { - PipeReader { io: FromRawFd::from_raw_fd(fd) } + PipeReader { + io: FromRawFd::from_raw_fd(fd), + } } } @@ -418,6 +492,8 @@ impl AsRawFd for PipeWriter { impl FromRawFd for PipeWriter { unsafe fn from_raw_fd(fd: RawFd) -> PipeWriter { - PipeWriter { io: FromRawFd::from_raw_fd(fd) } + PipeWriter { + io: FromRawFd::from_raw_fd(fd), + } } } diff --git a/src/event_imp.rs b/src/event_imp.rs index 6c60aad0f..84b2a61ba 100644 --- a/src/event_imp.rs +++ b/src/event_imp.rs @@ -1,5 +1,5 @@ -use {Poll, Token}; use std::{fmt, io, ops}; +use {Poll, Token}; /// A value that may be registered with `Poll` /// @@ -129,7 +129,8 @@ pub trait Evented { /// /// [`Poll::register`]: ../struct.Poll.html#method.register /// [`Registration`]: ../struct.Registration.html - fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()>; + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) + -> io::Result<()>; /// Re-register `self` with the given `Poll` instance. /// @@ -140,7 +141,13 @@ pub trait Evented { /// /// [`Poll::reregister`]: ../struct.Poll.html#method.reregister /// [`SetReadiness::set_readiness`]: ../struct.SetReadiness.html#method.set_readiness - fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()>; + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()>; /// Deregister `self` from the given `Poll` instance /// @@ -155,11 +162,23 @@ pub trait Evented { } impl Evented for Box { - fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.as_ref().register(poll, token, interest, opts) } - fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.as_ref().reregister(poll, token, interest, opts) } @@ -169,11 +188,23 @@ impl Evented for Box { } impl Evented for Box { - fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.as_ref().register(poll, token, interest, opts) } - fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.as_ref().reregister(poll, token, interest, opts) } @@ -183,11 +214,23 @@ impl Evented for Box { } impl Evented for ::std::sync::Arc { - fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.as_ref().register(poll, token, interest, opts) } - fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.as_ref().reregister(poll, token, interest, opts) } @@ -530,11 +573,14 @@ impl fmt::Debug for PollOpt { let flags = [ (PollOpt::edge(), "Edge-Triggered"), (PollOpt::level(), "Level-Triggered"), - (PollOpt::oneshot(), "OneShot")]; + (PollOpt::oneshot(), "OneShot"), + ]; for &(flag, msg) in &flags { if self.contains(flag) { - if one { write!(fmt, " | ")? } + if one { + write!(fmt, " | ")? + } write!(fmt, "{}", msg)?; one = true @@ -1016,11 +1062,14 @@ impl fmt::Debug for Ready { (Ready::readable(), "Readable"), (Ready::writable(), "Writable"), (Ready(ERROR), "Error"), - (Ready(HUP), "Hup")]; + (Ready(HUP), "Hup"), + ]; for &(flag, msg) in &flags { if self.contains(flag) { - if one { write!(fmt, " | ")? } + if one { + write!(fmt, " | ")? + } write!(fmt, "{}", msg)?; one = true @@ -1068,7 +1117,7 @@ fn test_debug_ready() { #[derive(Copy, Clone, Eq, PartialEq, Debug)] pub struct Event { kind: Ready, - token: Token + token: Token, } impl Event { diff --git a/src/io.rs b/src/io.rs index 275001387..f7c9eed98 100644 --- a/src/io.rs +++ b/src/io.rs @@ -1,5 +1,5 @@ // Re-export the io::Result / Error types for convenience -pub use std::io::{Read, Write, Result, Error, ErrorKind}; +pub use std::io::{Error, ErrorKind, Read, Result, Write}; // TODO: Delete this /// A helper trait to provide the map_non_block function on Results. diff --git a/src/lib.rs b/src/lib.rs index d26628fd5..f24145cb7 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -92,12 +92,11 @@ #![doc(html_root_url = "https://docs.rs/mio/0.6.15")] #![crate_name = "mio"] - #![deny(warnings, missing_docs, missing_debug_implementations)] +extern crate iovec; extern crate lazycell; extern crate net2; -extern crate iovec; extern crate slab; #[cfg(target_os = "fuchsia")] @@ -161,27 +160,18 @@ pub mod tcp { #[doc(hidden)] pub mod udp; -pub use poll::{ - Poll, - Registration, - SetReadiness, -}; -pub use event_imp::{ - PollOpt, - Ready, -}; +pub use event_imp::{PollOpt, Ready}; +pub use poll::{Poll, Registration, SetReadiness}; pub use token::Token; pub mod event { //! Readiness event types and utilities. - pub use super::poll::{Events, Iter}; pub use super::event_imp::{Event, Evented}; + pub use super::poll::{Events, Iter}; } -pub use event::{ - Events, -}; +pub use event::Events; #[deprecated(since = "0.6.5", note = "use events:: instead")] #[cfg(feature = "with-deprecated")] @@ -193,7 +183,10 @@ pub use event::{Event, Evented}; #[doc(hidden)] pub use poll::Iter as EventsIter; -#[deprecated(since = "0.6.5", note = "std::io::Error can avoid the allocation now")] +#[deprecated( + since = "0.6.5", + note = "std::io::Error can avoid the allocation now" +)] #[cfg(feature = "with-deprecated")] #[doc(hidden)] pub use io::deprecated::would_block; @@ -201,10 +194,8 @@ pub use io::deprecated::would_block; #[cfg(all(unix, not(target_os = "fuchsia")))] pub mod unix { //! Unix only extensions - pub use sys::{ - EventedFd, - }; pub use sys::unix::UnixReady; + pub use sys::EventedFd; } #[cfg(target_os = "fuchsia")] @@ -216,10 +207,8 @@ pub mod fuchsia { //! This module depends on the [magenta-sys crate](https://crates.io/crates/magenta-sys) //! and so might introduce breaking changes, even on minor releases, //! so long as that crate remains unstable. - pub use sys::{ - EventedHandle, - }; - pub use sys::fuchsia::{FuchsiaReady, zx_signals_t}; + pub use sys::fuchsia::{zx_signals_t, FuchsiaReady}; + pub use sys::EventedHandle; } /// Windows-only extensions to the mio crate. @@ -275,7 +264,7 @@ pub mod fuchsia { #[cfg(windows)] pub mod windows { - pub use sys::{Overlapped, Binding}; + pub use sys::{Binding, Overlapped}; } #[cfg(feature = "with-deprecated")] @@ -293,6 +282,9 @@ mod convert { pub fn millis(duration: Duration) -> u64 { // Round up. let millis = (duration.subsec_nanos() + NANOS_PER_MILLI - 1) / NANOS_PER_MILLI; - duration.as_secs().saturating_mul(MILLIS_PER_SEC).saturating_add(millis as u64) + duration + .as_secs() + .saturating_mul(MILLIS_PER_SEC) + .saturating_add(millis as u64) } } diff --git a/src/net/tcp.rs b/src/net/tcp.rs index dfde91a65..cc272870b 100644 --- a/src/net/tcp.rs +++ b/src/net/tcp.rs @@ -6,18 +6,17 @@ //! matter the target platform. //! /// [portability guidelines]: ../struct.Poll.html#portability - use std::fmt; use std::io::{Read, Write}; -use std::net::{self, SocketAddr, SocketAddrV4, SocketAddrV6, Ipv4Addr, Ipv6Addr}; +use std::net::{self, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6}; use std::time::Duration; -use net2::TcpBuilder; use iovec::IoVec; +use net2::TcpBuilder; -use {io, sys, Ready, Poll, PollOpt, Token}; use event::Evented; use poll::SelectorId; +use {io, sys, Poll, PollOpt, Ready, Token}; /* * @@ -70,15 +69,13 @@ use std::net::Shutdown; // TODO: remove when fuchsia's set_nonblocking is fixed in libstd #[cfg(target_os = "fuchsia")] fn set_nonblocking(stream: &net::TcpStream) -> io::Result<()> { - sys::set_nonblock( - ::std::os::unix::io::AsRawFd::as_raw_fd(stream)) + sys::set_nonblock(::std::os::unix::io::AsRawFd::as_raw_fd(stream)) } #[cfg(not(target_os = "fuchsia"))] fn set_nonblocking(stream: &net::TcpStream) -> io::Result<()> { stream.set_nonblocking(true) } - impl TcpStream { /// Create a new TCP stream and issue a non-blocking connect to the /// specified address. @@ -120,8 +117,7 @@ impl TcpStream { /// loop. Note that on Windows you must `bind` a socket before it can be /// connected, so if a custom `TcpBuilder` is used it should be bound /// (perhaps to `INADDR_ANY`) before this method is called. - pub fn connect_stream(stream: net::TcpStream, - addr: &SocketAddr) -> io::Result { + pub fn connect_stream(stream: net::TcpStream, addr: &SocketAddr) -> io::Result { Ok(TcpStream { sys: sys::TcpStream::connect(stream, addr)?, selector_id: SelectorId::new(), @@ -164,11 +160,9 @@ impl TcpStream { /// data, and options set on one stream will be propagated to the other /// stream. pub fn try_clone(&self) -> io::Result { - self.sys.try_clone().map(|s| { - TcpStream { - sys: s, - selector_id: self.selector_id.clone(), - } + self.sys.try_clone().map(|s| TcpStream { + sys: s, + selector_id: self.selector_id.clone(), }) } @@ -326,11 +320,8 @@ impl TcpStream { #[cfg(feature = "with-deprecated")] #[doc(hidden)] pub fn keepalive_ms(&self) -> io::Result> { - self.keepalive().map(|v| { - v.map(|v| { - ::convert::millis(v) as u32 - }) - }) + self.keepalive() + .map(|v| v.map(|v| ::convert::millis(v) as u32)) } /// Get the value of the `SO_ERROR` option on this socket. @@ -437,14 +428,24 @@ impl<'a> Write for &'a TcpStream { } impl Evented for TcpStream { - fn register(&self, poll: &Poll, token: Token, - interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.selector_id.associate_selector(poll)?; self.sys.register(poll, token, interest, opts) } - fn reregister(&self, poll: &Poll, token: Token, - interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.sys.reregister(poll, token, interest, opts) } @@ -541,8 +542,7 @@ impl TcpListener { #[deprecated(since = "0.6.13", note = "use from_std instead")] #[cfg(feature = "with-deprecated")] #[doc(hidden)] - pub fn from_listener(listener: net::TcpListener, _: &SocketAddr) - -> io::Result { + pub fn from_listener(listener: net::TcpListener, _: &SocketAddr) -> io::Result { TcpListener::from_std(listener) } @@ -556,11 +556,9 @@ impl TcpListener { /// /// The address provided must be the address that the listener is bound to. pub fn from_std(listener: net::TcpListener) -> io::Result { - sys::TcpListener::new(listener).map(|s| { - TcpListener { - sys: s, - selector_id: SelectorId::new(), - } + sys::TcpListener::new(listener).map(|s| TcpListener { + sys: s, + selector_id: SelectorId::new(), }) } @@ -598,11 +596,9 @@ impl TcpListener { /// object references. Both handles can be used to accept incoming /// connections and options set on one listener will affect the other. pub fn try_clone(&self) -> io::Result { - self.sys.try_clone().map(|s| { - TcpListener { - sys: s, - selector_id: self.selector_id.clone(), - } + self.sys.try_clone().map(|s| TcpListener { + sys: s, + selector_id: self.selector_id.clone(), }) } @@ -655,14 +651,24 @@ impl TcpListener { } impl Evented for TcpListener { - fn register(&self, poll: &Poll, token: Token, - interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.selector_id.associate_selector(poll)?; self.sys.register(poll, token, interest, opts) } - fn reregister(&self, poll: &Poll, token: Token, - interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.sys.reregister(poll, token, interest, opts) } @@ -684,7 +690,7 @@ impl fmt::Debug for TcpListener { */ #[cfg(all(unix, not(target_os = "fuchsia")))] -use std::os::unix::io::{IntoRawFd, AsRawFd, FromRawFd, RawFd}; +use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; #[cfg(all(unix, not(target_os = "fuchsia")))] impl IntoRawFd for TcpStream { diff --git a/src/net/udp.rs b/src/net/udp.rs index d82cebc2b..9eeadfa3e 100644 --- a/src/net/udp.rs +++ b/src/net/udp.rs @@ -5,13 +5,12 @@ //! [portability guidelines] are followed, the behavior should be identical no //! matter the target platform. //! -/// [portability guidelines]: ../struct.Poll.html#portability - -use {io, sys, Ready, Poll, PollOpt, Token}; use event::Evented; use poll::SelectorId; use std::fmt; use std::net::{self, Ipv4Addr, Ipv6Addr, SocketAddr}; +/// [portability guidelines]: ../struct.Poll.html#portability +use {io, sys, Poll, PollOpt, Ready, Token}; /// A User Datagram Protocol socket. /// @@ -196,13 +195,10 @@ impl UdpSocket { /// # } /// ``` pub fn try_clone(&self) -> io::Result { - self.sys.try_clone() - .map(|s| { - UdpSocket { - sys: s, - selector_id: self.selector_id.clone(), - } - }) + self.sys.try_clone().map(|s| UdpSocket { + sys: s, + selector_id: self.selector_id.clone(), + }) } /// Sends data on the socket to the given address. On success, returns the @@ -472,9 +468,7 @@ impl UdpSocket { /// address of the local interface with which the system should join the /// multicast group. If it's equal to `INADDR_ANY` then an appropriate /// interface is chosen by the system. - pub fn join_multicast_v4(&self, - multiaddr: &Ipv4Addr, - interface: &Ipv4Addr) -> io::Result<()> { + pub fn join_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> { self.sys.join_multicast_v4(multiaddr, interface) } @@ -483,9 +477,7 @@ impl UdpSocket { /// This function specifies a new multicast group for this socket to join. /// The address must be a valid multicast address, and `interface` is the /// index of the interface to join/leave (or 0 to indicate any interface). - pub fn join_multicast_v6(&self, - multiaddr: &Ipv6Addr, - interface: u32) -> io::Result<()> { + pub fn join_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> { self.sys.join_multicast_v6(multiaddr, interface) } @@ -495,9 +487,7 @@ impl UdpSocket { /// [`join_multicast_v4`][link]. /// /// [link]: #method.join_multicast_v4 - pub fn leave_multicast_v4(&self, - multiaddr: &Ipv4Addr, - interface: &Ipv4Addr) -> io::Result<()> { + pub fn leave_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> { self.sys.leave_multicast_v4(multiaddr, interface) } @@ -507,9 +497,7 @@ impl UdpSocket { /// [`join_multicast_v6`][link]. /// /// [link]: #method.join_multicast_v6 - pub fn leave_multicast_v6(&self, - multiaddr: &Ipv6Addr, - interface: u32) -> io::Result<()> { + pub fn leave_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> { self.sys.leave_multicast_v6(multiaddr, interface) } @@ -545,12 +533,24 @@ impl UdpSocket { } impl Evented for UdpSocket { - fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.selector_id.associate_selector(poll)?; self.sys.register(poll, token, interest, opts) } - fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.sys.reregister(poll, token, interest, opts) } @@ -572,7 +572,7 @@ impl fmt::Debug for UdpSocket { */ #[cfg(all(unix, not(target_os = "fuchsia")))] -use std::os::unix::io::{IntoRawFd, AsRawFd, FromRawFd, RawFd}; +use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; #[cfg(all(unix, not(target_os = "fuchsia")))] impl IntoRawFd for UdpSocket { @@ -597,4 +597,3 @@ impl FromRawFd for UdpSocket { } } } - diff --git a/src/poll.rs b/src/poll.rs index a2fcf23df..3e7754d03 100644 --- a/src/poll.rs +++ b/src/poll.rs @@ -1,16 +1,16 @@ -use {sys, Token}; -use event_imp::{self as event, Ready, Event, Evented, PollOpt}; -use std::{fmt, io, ptr, usize}; +use event_imp::{self as event, Event, Evented, PollOpt, Ready}; use std::cell::UnsafeCell; -use std::{mem, ops, isize}; #[cfg(all(unix, not(target_os = "fuchsia")))] use std::os::unix::io::AsRawFd; #[cfg(all(unix, not(target_os = "fuchsia")))] use std::os::unix::io::RawFd; -use std::sync::{Arc, Mutex, Condvar}; -use std::sync::atomic::{AtomicUsize, AtomicPtr, AtomicBool}; -use std::sync::atomic::Ordering::{self, Acquire, Release, AcqRel, Relaxed, SeqCst}; +use std::sync::atomic::Ordering::{self, AcqRel, Acquire, Relaxed, Release, SeqCst}; +use std::sync::atomic::{AtomicBool, AtomicPtr, AtomicUsize}; +use std::sync::{Arc, Condvar, Mutex}; use std::time::{Duration, Instant}; +use std::{fmt, io, ptr, usize}; +use std::{isize, mem, ops}; +use {sys, Token}; // Poll is backed by two readiness queues. The first is a system readiness queue // represented by `sys::Selector`. The system readiness queue handles events @@ -61,7 +61,6 @@ use std::time::{Duration, Instant}; // // [1] http://www.1024cores.net/home/lock-free-algorithms/queues/intrusive-mpsc-node-based-queue - /// Polls for readiness events on all registered values. /// /// `Poll` allows a program to monitor a large number of `Evented` types, @@ -660,7 +659,12 @@ impl Poll { }; // Register the notification wakeup FD with the IO poller - poll.readiness_queue.inner.awakener.register(&poll, AWAKEN, Ready::readable(), PollOpt::edge())?; + poll.readiness_queue.inner.awakener.register( + &poll, + AWAKEN, + Ready::readable(), + PollOpt::edge(), + )?; Ok(poll) } @@ -772,8 +776,15 @@ impl Poll { /// # try_main().unwrap(); /// # } /// ``` - pub fn register(&self, handle: &E, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> - where E: Evented + pub fn register( + &self, + handle: &E, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> + where + E: Evented, { validate_args(token)?; @@ -843,8 +854,15 @@ impl Poll { /// [`register`]: #method.register /// [`readable`]: struct.Ready.html#method.readable /// [`writable`]: struct.Ready.html#method.writable - pub fn reregister(&self, handle: &E, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> - where E: Evented + pub fn reregister( + &self, + handle: &E, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> + where + E: Evented, { validate_args(token)?; @@ -900,7 +918,8 @@ impl Poll { /// # } /// ``` pub fn deregister(&self, handle: &E) -> io::Result<()> - where E: Evented + where + E: Evented, { trace!("deregistering handle with poller"); @@ -1012,11 +1031,20 @@ impl Poll { /// /// If `poll` is inturrupted while blocking, it will transparently retry the syscall. If you /// want to handle signals yourself, however, use `poll_interruptible`. - pub fn poll_interruptible(&self, events: &mut Events, timeout: Option) -> io::Result { + pub fn poll_interruptible( + &self, + events: &mut Events, + timeout: Option, + ) -> io::Result { self.poll1(events, timeout, true) } - fn poll1(&self, events: &mut Events, mut timeout: Option, interruptible: bool) -> io::Result { + fn poll1( + &self, + events: &mut Events, + mut timeout: Option, + interruptible: bool, + ) -> io::Result { let zero = Some(Duration::from_millis(0)); // At a high level, the synchronization strategy is to acquire access to @@ -1122,9 +1150,7 @@ impl Poll { l } - None => { - self.condvar.wait(lock).unwrap() - } + None => self.condvar.wait(lock).unwrap(), }; // Reload the state @@ -1149,7 +1175,12 @@ impl Poll { } #[inline] - fn poll2(&self, events: &mut Events, mut timeout: Option, interruptible: bool) -> io::Result { + fn poll2( + &self, + events: &mut Events, + mut timeout: Option, + interruptible: bool, + ) -> io::Result { // Compute the timeout value passed to the system selector. If the // readiness queue has pending nodes, we still want to poll the system // selector for new events, but we don't want to block the thread to @@ -1211,8 +1242,7 @@ fn validate_args(token: Token) -> io::Result<()> { impl fmt::Debug for Poll { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("Poll") - .finish() + fmt.debug_struct("Poll").finish() } } @@ -1358,14 +1388,20 @@ impl Events { } } - #[deprecated(since="0.6.10", note="Index access removed in favor of iterator only API.")] + #[deprecated( + since = "0.6.10", + note = "Index access removed in favor of iterator only API." + )] #[doc(hidden)] pub fn get(&self, idx: usize) -> Option { self.inner.get(idx) } #[doc(hidden)] - #[deprecated(since="0.6.10", note="Index access removed in favor of iterator only API.")] + #[deprecated( + since = "0.6.10", + note = "Index access removed in favor of iterator only API." + )] pub fn len(&self) -> usize { self.inner.len() } @@ -1428,7 +1464,7 @@ impl Events { pub fn iter(&self) -> Iter { Iter { inner: self, - pos: 0 + pos: 0, } } @@ -1529,9 +1565,12 @@ pub fn selector(poll: &Poll) -> &sys::Selector { // TODO: get rid of this, windows depends on it for now #[allow(dead_code)] -pub fn new_registration(poll: &Poll, token: Token, ready: Ready, opt: PollOpt) - -> (Registration, SetReadiness) -{ +pub fn new_registration( + poll: &Poll, + token: Token, + ready: Ready, + opt: PollOpt, +) -> (Registration, SetReadiness) { Registration::new_priv(poll, token, ready, opt) } @@ -1586,18 +1625,19 @@ impl Registration { // Allocate the registration node. The new node will have `ref_count` // set to 2: one SetReadiness, one Registration. let node = Box::into_raw(Box::new(ReadinessNode::new( - ptr::null_mut(), Token(0), Ready::empty(), PollOpt::empty(), 2))); + ptr::null_mut(), + Token(0), + Ready::empty(), + PollOpt::empty(), + 2, + ))); let registration = Registration { - inner: RegistrationInner { - node: node, - }, + inner: RegistrationInner { node: node }, }; let set_readiness = SetReadiness { - inner: RegistrationInner { - node: node, - }, + inner: RegistrationInner { node: node }, }; (registration, set_readiness) @@ -1606,16 +1646,22 @@ impl Registration { #[deprecated(since = "0.6.5", note = "use `new2` instead")] #[cfg(feature = "with-deprecated")] #[doc(hidden)] - pub fn new(poll: &Poll, token: Token, interest: Ready, opt: PollOpt) - -> (Registration, SetReadiness) - { + pub fn new( + poll: &Poll, + token: Token, + interest: Ready, + opt: PollOpt, + ) -> (Registration, SetReadiness) { Registration::new_priv(poll, token, interest, opt) } // TODO: Get rid of this (windows depends on it for now) - fn new_priv(poll: &Poll, token: Token, interest: Ready, opt: PollOpt) - -> (Registration, SetReadiness) - { + fn new_priv( + poll: &Poll, + token: Token, + interest: Ready, + opt: PollOpt, + ) -> (Registration, SetReadiness) { is_send::(); is_sync::(); is_send::(); @@ -1629,19 +1675,14 @@ impl Registration { // Allocate the registration node. The new node will have `ref_count` // set to 3: one SetReadiness, one Registration, and one Poll handle. - let node = Box::into_raw(Box::new(ReadinessNode::new( - queue, token, interest, opt, 3))); + let node = Box::into_raw(Box::new(ReadinessNode::new(queue, token, interest, opt, 3))); let registration = Registration { - inner: RegistrationInner { - node: node, - }, + inner: RegistrationInner { node: node }, }; let set_readiness = SetReadiness { - inner: RegistrationInner { - node: node, - }, + inner: RegistrationInner { node: node }, }; (registration, set_readiness) @@ -1650,7 +1691,13 @@ impl Registration { #[deprecated(since = "0.6.5", note = "use `Evented` impl")] #[cfg(feature = "with-deprecated")] #[doc(hidden)] - pub fn update(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + pub fn update( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.inner.update(poll, token, interest, opts) } @@ -1658,21 +1705,35 @@ impl Registration { #[cfg(feature = "with-deprecated")] #[doc(hidden)] pub fn deregister(&self, poll: &Poll) -> io::Result<()> { - self.inner.update(poll, Token(0), Ready::empty(), PollOpt::empty()) + self.inner + .update(poll, Token(0), Ready::empty(), PollOpt::empty()) } } impl Evented for Registration { - fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.inner.update(poll, token, interest, opts) } - fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.inner.update(poll, token, interest, opts) } fn deregister(&self, poll: &Poll) -> io::Result<()> { - self.inner.update(poll, Token(0), Ready::empty(), PollOpt::empty()) + self.inner + .update(poll, Token(0), Ready::empty(), PollOpt::empty()) } } @@ -1690,8 +1751,7 @@ impl Drop for Registration { impl fmt::Debug for Registration { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("Registration") - .finish() + fmt.debug_struct("Registration").finish() } } @@ -1814,8 +1874,7 @@ impl SetReadiness { impl fmt::Debug for SetReadiness { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("SetReadiness") - .finish() + f.debug_struct("SetReadiness").finish() } } @@ -1885,8 +1944,7 @@ impl RegistrationInner { if queue.is_null() { // Attempt to set the queue pointer. `Release` ordering synchronizes // with `Acquire` in `ensure_with_wakeup`. - let actual = self.readiness_queue.compare_and_swap( - queue, other, Release); + let actual = self.readiness_queue.compare_and_swap(queue, other, Release); if actual.is_null() { // The CAS succeeded, this means that the node's ref count @@ -1910,13 +1968,19 @@ impl RegistrationInner { // The CAS failed, another thread set the queue pointer, so ensure // that the pointer and `other` match if actual != other { - return Err(io::Error::new(io::ErrorKind::Other, "registration handle associated with another `Poll` instance")); + return Err(io::Error::new( + io::ErrorKind::Other, + "registration handle associated with another `Poll` instance", + )); } } queue = other; } else if queue != other { - return Err(io::Error::new(io::ErrorKind::Other, "registration handle associated with another `Poll` instance")); + return Err(io::Error::new( + io::ErrorKind::Other, + "registration handle associated with another `Poll` instance", + )); } unsafe { @@ -2105,7 +2169,7 @@ impl ReadinessQueue { end_marker: end_marker, sleep_marker: sleep_marker, closed_marker: closed_marker, - }) + }), }) } @@ -2116,8 +2180,7 @@ impl ReadinessQueue { // loop where `Poll::poll` will keep dequeuing nodes it enqueues. let mut until = ptr::null_mut(); - 'outer: - while dst.len() < dst.capacity() { + 'outer: while dst.len() < dst.capacity() { // Dequeue a node. If the queue is in an inconsistent state, then // stop polling. `Poll::poll` will be called again shortly and enter // a syscall, which should be enough to enable the other thread to @@ -2240,10 +2303,15 @@ impl ReadinessQueue { // Before inserting a node into the queue, the next pointer has to be // set to null. Again, this is only safe to do when the node is not // currently in the queue, but we already have ensured this. - self.inner.sleep_marker.next_readiness.store(ptr::null_mut(), Relaxed); + self.inner + .sleep_marker + .next_readiness + .store(ptr::null_mut(), Relaxed); - let actual = self.inner.head_readiness.compare_and_swap( - end_marker, sleep_marker, AcqRel); + let actual = self + .inner + .head_readiness + .compare_and_swap(end_marker, sleep_marker, AcqRel); debug_assert!(actual != sleep_marker); @@ -2258,7 +2326,9 @@ impl ReadinessQueue { debug_assert!(self.inner.end_marker.next_readiness.load(Relaxed).is_null()); // Update tail pointer. - unsafe { *self.inner.tail_readiness.get() = sleep_marker; } + unsafe { + *self.inner.tail_readiness.get() = sleep_marker; + } true } } @@ -2360,7 +2430,8 @@ impl ReadinessQueueInner { let mut tail = *self.tail_readiness.get(); let mut next = (*tail).next_readiness.load(Acquire); - if tail == self.end_marker() || tail == self.sleep_marker() || tail == self.closed_marker() { + if tail == self.end_marker() || tail == self.sleep_marker() || tail == self.closed_marker() + { if next.is_null() { return Dequeue::Empty; } @@ -2418,12 +2489,13 @@ impl ReadinessQueueInner { impl ReadinessNode { /// Return a new `ReadinessNode`, initialized with a ref_count of 3. - fn new(queue: *mut (), - token: Token, - interest: Ready, - opt: PollOpt, - ref_count: usize) -> ReadinessNode - { + fn new( + queue: *mut (), + token: Token, + interest: Ready, + opt: PollOpt, + ref_count: usize, + ) -> ReadinessNode { ReadinessNode { state: AtomicState::new(interest, opt), // Only the first token is set, the others are initialized to 0 @@ -2514,13 +2586,23 @@ impl AtomicState { } /// Stores a state if the current state is the same as `current`. - fn compare_and_swap(&self, current: ReadinessState, new: ReadinessState, order: Ordering) -> ReadinessState { - self.inner.compare_and_swap(current.into(), new.into(), order).into() + fn compare_and_swap( + &self, + current: ReadinessState, + new: ReadinessState, + order: Ordering, + ) -> ReadinessState { + self.inner + .compare_and_swap(current.into(), new.into(), order) + .into() } // Returns `true` if the node should be queued fn flag_as_dropped(&self) -> bool { - let prev: ReadinessState = self.inner.fetch_or(DROPPED_MASK | QUEUED_MASK, Release).into(); + let prev: ReadinessState = self + .inner + .fetch_or(DROPPED_MASK | QUEUED_MASK, Release) + .into(); // The flag should not have been previously set debug_assert!(!prev.is_dropped()); @@ -2545,7 +2627,7 @@ impl ReadinessState { } #[inline] - fn get(&self, mask: usize, shift: usize) -> usize{ + fn get(&self, mask: usize, shift: usize) -> usize { (self.0 >> shift) & mask } @@ -2643,30 +2725,24 @@ impl ReadinessState { let wr = self.token_write_pos(); match wr { - 0 => { - match rd { - 1 => 2, - 2 => 1, - 0 => 1, - _ => unreachable!(), - } - } - 1 => { - match rd { - 0 => 2, - 2 => 0, - 1 => 2, - _ => unreachable!(), - } - } - 2 => { - match rd { - 0 => 1, - 1 => 0, - 2 => 0, - _ => unreachable!(), - } - } + 0 => match rd { + 1 => 2, + 2 => 1, + 0 => 1, + _ => unreachable!(), + }, + 1 => match rd { + 0 => 2, + 2 => 0, + 1 => 2, + _ => unreachable!(), + }, + 2 => match rd { + 0 => 1, + 1 => 0, + 2 => 0, + _ => unreachable!(), + }, _ => unreachable!(), } } @@ -2709,7 +2785,10 @@ impl SelectorId { let selector_id = self.id.load(Ordering::SeqCst); if selector_id != 0 && selector_id != poll.selector.id() { - Err(io::Error::new(io::ErrorKind::Other, "socket already registered")) + Err(io::Error::new( + io::ErrorKind::Other, + "socket already registered", + )) } else { self.id.store(poll.selector.id(), Ordering::SeqCst); Ok(()) diff --git a/src/sys/fuchsia/awakener.rs b/src/sys/fuchsia/awakener.rs index 19bc76242..d92f63673 100644 --- a/src/sys/fuchsia/awakener.rs +++ b/src/sys/fuchsia/awakener.rs @@ -1,6 +1,6 @@ -use {io, poll, Evented, Ready, Poll, PollOpt, Token}; -use zircon; use std::sync::{Arc, Mutex, Weak}; +use zircon; +use {io, poll, Evented, Poll, PollOpt, Ready, Token}; pub struct Awakener { /// Token and weak reference to the port on which Awakener was registered. @@ -13,21 +13,25 @@ impl Awakener { /// Create a new `Awakener`. pub fn new() -> io::Result { Ok(Awakener { - inner: Mutex::new(None) + inner: Mutex::new(None), }) } /// Send a wakeup signal to the `Selector` on which the `Awakener` was registered. pub fn wakeup(&self) -> io::Result<()> { let inner_locked = self.inner.lock().unwrap(); - let &(token, ref weak_port) = - inner_locked.as_ref().expect("Called wakeup on unregistered awakener."); + let &(token, ref weak_port) = inner_locked + .as_ref() + .expect("Called wakeup on unregistered awakener."); let port = weak_port.upgrade().expect("Tried to wakeup a closed port."); let status = 0; // arbitrary let packet = zircon::Packet::from_user_packet( - token.0 as u64, status, zircon::UserPacket::from_u8_array([0; 32])); + token.0 as u64, + status, + zircon::UserPacket::from_u8_array([0; 32]), + ); Ok(port.queue(&packet)?) } @@ -36,12 +40,13 @@ impl Awakener { } impl Evented for Awakener { - fn register(&self, - poll: &Poll, - token: Token, - _events: Ready, - _opts: PollOpt) -> io::Result<()> - { + fn register( + &self, + poll: &Poll, + token: Token, + _events: Ready, + _opts: PollOpt, + ) -> io::Result<()> { let mut inner_locked = self.inner.lock().unwrap(); if inner_locked.is_some() { panic!("Called register on already-registered Awakener."); @@ -51,23 +56,23 @@ impl Evented for Awakener { Ok(()) } - fn reregister(&self, - poll: &Poll, - token: Token, - _events: Ready, - _opts: PollOpt) -> io::Result<()> - { + fn reregister( + &self, + poll: &Poll, + token: Token, + _events: Ready, + _opts: PollOpt, + ) -> io::Result<()> { let mut inner_locked = self.inner.lock().unwrap(); *inner_locked = Some((token, Arc::downgrade(poll::selector(poll).port()))); Ok(()) } - fn deregister(&self, _poll: &Poll) -> io::Result<()> - { + fn deregister(&self, _poll: &Poll) -> io::Result<()> { let mut inner_locked = self.inner.lock().unwrap(); *inner_locked = None; Ok(()) } -} \ No newline at end of file +} diff --git a/src/sys/fuchsia/eventedfd.rs b/src/sys/fuchsia/eventedfd.rs index e23d0c4a1..df1c94bab 100644 --- a/src/sys/fuchsia/eventedfd.rs +++ b/src/sys/fuchsia/eventedfd.rs @@ -1,11 +1,11 @@ -use {io, poll, Evented, Ready, Poll, PollOpt, Token}; use libc; -use zircon; -use zircon::AsHandleRef; -use sys::fuchsia::{DontDrop, poll_opts_to_wait_async, sys}; use std::mem; use std::os::unix::io::RawFd; use std::sync::{Arc, Mutex}; +use sys::fuchsia::{poll_opts_to_wait_async, sys, DontDrop}; +use zircon; +use zircon::AsHandleRef; +use {io, poll, Evented, Poll, PollOpt, Ready, Token}; /// Properties of an `EventedFd`'s current registration #[derive(Debug)] @@ -16,15 +16,15 @@ pub struct EventedFdRegistration { } impl EventedFdRegistration { - unsafe fn new(token: Token, - raw_handle: sys::zx_handle_t, - rereg_signals: Option<(zircon::Signals, zircon::WaitAsyncOpts)>, - ) -> Self - { + unsafe fn new( + token: Token, + raw_handle: sys::zx_handle_t, + rereg_signals: Option<(zircon::Signals, zircon::WaitAsyncOpts)>, + ) -> Self { EventedFdRegistration { token: token, handle: DontDrop::new(zircon::Handle::from_raw(raw_handle)), - rereg_signals: rereg_signals + rereg_signals: rereg_signals, } } @@ -53,14 +53,12 @@ impl EventedFdInner { let registration_opt = self.registration.lock().unwrap(); if let Some(ref registration) = *registration_opt { if let Some((rereg_signals, rereg_opts)) = registration.rereg_signals { - let _res = - registration - .handle.inner_ref() - .wait_async_handle( - port, - registration.token.0 as u64, - rereg_signals, - rereg_opts); + let _res = registration.handle.inner_ref().wait_async_handle( + port, + registration.token.0 as u64, + rereg_signals, + rereg_opts, + ); } } } @@ -95,26 +93,31 @@ unsafe impl Send for EventedFdInner {} #[derive(Clone, Debug)] pub struct EventedFd { - pub inner: Arc + pub inner: Arc, } impl EventedFd { pub unsafe fn new(fd: RawFd) -> Self { let fdio = sys::__fdio_fd_to_io(fd); - assert!(fdio != ::std::ptr::null(), "FileDescriptor given to EventedFd must be valid."); + assert!( + fdio != ::std::ptr::null(), + "FileDescriptor given to EventedFd must be valid." + ); EventedFd { inner: Arc::new(EventedFdInner { registration: Mutex::new(None), fd: fd, fdio: fdio, - }) + }), } } - fn handle_and_signals_for_events(&self, interest: Ready, opts: PollOpt) - -> (sys::zx_handle_t, zircon::Signals) - { + fn handle_and_signals_for_events( + &self, + interest: Ready, + opts: PollOpt, + ) -> (sys::zx_handle_t, zircon::Signals) { let epoll_events = ioevent_to_epoll(interest, opts); unsafe { @@ -132,12 +135,13 @@ impl EventedFd { poll: &Poll, token: Token, interest: Ready, - opts: PollOpt) -> io::Result<()> - { + opts: PollOpt, + ) -> io::Result<()> { if registration.is_some() { return Err(io::Error::new( io::ErrorKind::AlreadyExists, - "Called register on an already registered file descriptor.")); + "Called register on an already registered file descriptor.", + )); } let (raw_handle, signals) = self.handle_and_signals_for_events(interest, opts); @@ -145,7 +149,11 @@ impl EventedFd { let needs_rereg = opts.is_level() && !opts.is_oneshot(); // If we need to reregister, then each registration should be `oneshot` - let opts = opts | if needs_rereg { PollOpt::oneshot() } else { PollOpt::empty() }; + let opts = opts | if needs_rereg { + PollOpt::oneshot() + } else { + PollOpt::empty() + }; let rereg_signals = if needs_rereg { Some((signals, poll_opts_to_wait_async(opts))) @@ -153,15 +161,14 @@ impl EventedFd { None }; - *registration = Some( - unsafe { EventedFdRegistration::new(token, raw_handle, rereg_signals) } - ); + *registration = + Some(unsafe { EventedFdRegistration::new(token, raw_handle, rereg_signals) }); // We don't have ownership of the handle, so we can't drop it let handle = DontDrop::new(unsafe { zircon::Handle::from_raw(raw_handle) }); - let registered = poll::selector(poll) - .register_fd(handle.inner_ref(), self, token, signals, opts); + let registered = + poll::selector(poll).register_fd(handle.inner_ref(), self, token, signals, opts); if registered.is_err() { *registration = None; @@ -173,14 +180,15 @@ impl EventedFd { fn deregister_with_lock( &self, registration: &mut Option, - poll: &Poll) -> io::Result<()> - { + poll: &Poll, + ) -> io::Result<()> { let old_registration = if let Some(old_reg) = registration.take() { old_reg } else { return Err(io::Error::new( io::ErrorKind::NotFound, - "Called rereregister on an unregistered file descriptor.")) + "Called rereregister on an unregistered file descriptor.", + )); }; poll::selector(poll) @@ -189,38 +197,36 @@ impl EventedFd { } impl Evented for EventedFd { - fn register(&self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt) -> io::Result<()> - { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.register_with_lock( &mut *self.inner.registration.lock().unwrap(), poll, token, interest, - opts) + opts, + ) } - fn reregister(&self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt) -> io::Result<()> - { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { // Take out the registration lock let mut registration_lock = self.inner.registration.lock().unwrap(); // Deregister self.deregister_with_lock(&mut *registration_lock, poll)?; - self.register_with_lock( - &mut *registration_lock, - poll, - token, - interest, - opts) + self.register_with_lock(&mut *registration_lock, poll, token, interest, opts) } fn deregister(&self, poll: &Poll) -> io::Result<()> { @@ -231,7 +237,7 @@ impl Evented for EventedFd { fn ioevent_to_epoll(interest: Ready, opts: PollOpt) -> u32 { use event_imp::ready_from_usize; - const HUP: usize = 0b01000; + const HUP: usize = 0b01000; let mut kind = 0; diff --git a/src/sys/fuchsia/handles.rs b/src/sys/fuchsia/handles.rs index ae6f07f6d..c64e5bc8b 100644 --- a/src/sys/fuchsia/handles.rs +++ b/src/sys/fuchsia/handles.rs @@ -1,6 +1,6 @@ -use {io, poll, Evented, Ready, Poll, PollOpt, Token}; -use zircon_sys::zx_handle_t; use std::sync::Mutex; +use zircon_sys::zx_handle_t; +use {io, poll, Evented, Poll, PollOpt, Ready, Token}; /// Wrapper for registering a `HandleBase` type with mio. #[derive(Debug)] @@ -32,12 +32,13 @@ impl EventedHandle { } impl Evented for EventedHandle { - fn register(&self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt) -> io::Result<()> - { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { let mut this_token = self.token.lock().unwrap(); { poll::selector(poll).register_handle(self.handle, token, interest, opts)?; @@ -46,12 +47,13 @@ impl Evented for EventedHandle { Ok(()) } - fn reregister(&self, + fn reregister( + &self, poll: &Poll, token: Token, interest: Ready, - opts: PollOpt) -> io::Result<()> - { + opts: PollOpt, + ) -> io::Result<()> { let mut this_token = self.token.lock().unwrap(); { poll::selector(poll).deregister_handle(self.handle, token)?; @@ -64,10 +66,13 @@ impl Evented for EventedHandle { fn deregister(&self, poll: &Poll) -> io::Result<()> { let mut this_token = self.token.lock().unwrap(); - let token = if let Some(token) = *this_token { token } else { + let token = if let Some(token) = *this_token { + token + } else { return Err(io::Error::new( io::ErrorKind::NotFound, - "Attempted to deregister an unregistered handle.")) + "Attempted to deregister an unregistered handle.", + )); }; { poll::selector(poll).deregister_handle(self.handle, token)?; diff --git a/src/sys/fuchsia/mod.rs b/src/sys/fuchsia/mod.rs index 10728fc8d..c44e62704 100644 --- a/src/sys/fuchsia/mod.rs +++ b/src/sys/fuchsia/mod.rs @@ -1,14 +1,14 @@ -use {io, Ready, PollOpt}; use libc; -use zircon; use std::mem; use std::net::{IpAddr, Ipv4Addr, SocketAddr}; use std::ops::{Deref, DerefMut}; use std::os::unix::io::RawFd; +use zircon; +use {io, PollOpt, Ready}; mod awakener; -mod handles; mod eventedfd; +mod handles; mod net; mod ready; mod selector; @@ -19,8 +19,8 @@ use self::ready::assert_fuchsia_ready_repr; pub use self::awakener::Awakener; pub use self::handles::EventedHandle; pub use self::net::{TcpListener, TcpStream, UdpSocket}; +pub use self::ready::{zx_signals_t, FuchsiaReady}; pub use self::selector::{Events, Selector}; -pub use self::ready::{FuchsiaReady, zx_signals_t}; // Set non-blocking (workaround since the std version doesn't work in fuchsia) // TODO: fix the std version and replace this @@ -32,12 +32,12 @@ pub fn set_nonblock(fd: RawFd) -> io::Result<()> { unsafe fn recv_from(fd: RawFd, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> { let flags = 0; - let n = cvt( - libc::recv(fd, - buf.as_mut_ptr() as *mut libc::c_void, - buf.len(), - flags) - )?; + let n = cvt(libc::recv( + fd, + buf.as_mut_ptr() as *mut libc::c_void, + buf.len(), + flags, + ))?; // random address-- we don't use it let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080); @@ -63,8 +63,8 @@ mod sys { pub flags: u32, } - #[link(name="fdio")] - extern { + #[link(name = "fdio")] + extern "C" { pub fn __fdio_fd_to_io(fd: RawFd) -> *const fdio_t; pub fn __fdio_release(io: *const fdio_t); @@ -74,11 +74,7 @@ mod sys { handle_out: &mut zx_handle_t, signals_out: &mut zx_signals_t, ); - pub fn __fdio_wait_end( - io: *const fdio_t, - signals: zx_signals_t, - events_out: &mut u32, - ); + pub fn __fdio_wait_end(io: *const fdio_t, signals: zx_signals_t, events_out: &mut u32); } } @@ -121,11 +117,15 @@ trait IsMinusOne { } impl IsMinusOne for i32 { - fn is_minus_one(&self) -> bool { *self == -1 } + fn is_minus_one(&self) -> bool { + *self == -1 + } } impl IsMinusOne for isize { - fn is_minus_one(&self) -> bool { *self == -1 } + fn is_minus_one(&self) -> bool { + *self == -1 + } } fn cvt(t: T) -> ::io::Result { diff --git a/src/sys/fuchsia/net.rs b/src/sys/fuchsia/net.rs index d43ad27bb..a323760d2 100644 --- a/src/sys/fuchsia/net.rs +++ b/src/sys/fuchsia/net.rs @@ -1,16 +1,16 @@ -use {io, Evented, Ready, Poll, PollOpt, Token}; -use iovec::IoVec; use iovec::unix as iovec; +use iovec::IoVec; use libc; use net2::TcpStreamExt; #[allow(unused_imports)] // only here for Rust 1.8 use net2::UdpSocketExt; -use sys::fuchsia::{recv_from, set_nonblock, EventedFd, DontDrop}; use std::cmp; use std::io::{Read, Write}; use std::net::{self, Ipv4Addr, Ipv6Addr, SocketAddr}; use std::os::unix::io::AsRawFd; use std::time::Duration; +use sys::fuchsia::{recv_from, set_nonblock, DontDrop, EventedFd}; +use {io, Evented, Poll, PollOpt, Ready, Token}; #[derive(Debug)] pub struct TcpStream { @@ -34,7 +34,7 @@ impl TcpStream { return Ok(TcpStream { io: DontDrop::new(stream), evented_fd: evented_fd, - }) + }); } pub fn from_stream(stream: net::TcpStream) -> TcpStream { @@ -136,9 +136,7 @@ impl TcpStream { unsafe { let slice = iovec::as_os_slice_mut(bufs); let len = cmp::min(::max_value() as usize, slice.len()); - let rc = libc::readv(self.io.as_raw_fd(), - slice.as_ptr(), - len as libc::c_int); + let rc = libc::readv(self.io.as_raw_fd(), slice.as_ptr(), len as libc::c_int); if rc < 0 { Err(io::Error::last_os_error()) } else { @@ -151,9 +149,7 @@ impl TcpStream { unsafe { let slice = iovec::as_os_slice(bufs); let len = cmp::min(::max_value() as usize, slice.len()); - let rc = libc::writev(self.io.as_raw_fd(), - slice.as_ptr(), - len as libc::c_int); + let rc = libc::writev(self.io.as_raw_fd(), slice.as_ptr(), len as libc::c_int); if rc < 0 { Err(io::Error::last_os_error()) } else { @@ -179,21 +175,23 @@ impl<'a> Write for &'a TcpStream { } impl Evented for TcpStream { - fn register(&self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt) -> io::Result<()> - { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.evented_fd.register(poll, token, interest, opts) } - fn reregister(&self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt) -> io::Result<()> - { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.evented_fd.reregister(poll, token, interest, opts) } @@ -238,10 +236,13 @@ impl TcpListener { self.io.accept().and_then(|(s, a)| { set_nonblock(s.as_raw_fd())?; let evented_fd = unsafe { EventedFd::new(s.as_raw_fd()) }; - return Ok((TcpStream { - io: DontDrop::new(s), - evented_fd: evented_fd, - }, a)) + return Ok(( + TcpStream { + io: DontDrop::new(s), + evented_fd: evented_fd, + }, + a, + )); }) } @@ -269,21 +270,23 @@ impl TcpListener { } impl Evented for TcpListener { - fn register(&self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt) -> io::Result<()> - { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.evented_fd.register(poll, token, interest, opts) } - fn reregister(&self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt) -> io::Result<()> - { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.evented_fd.reregister(poll, token, interest, opts) } @@ -315,9 +318,7 @@ impl UdpSocket { } pub fn try_clone(&self) -> io::Result { - self.io.try_clone().and_then(|io| { - UdpSocket::new(io) - }) + self.io.try_clone().and_then(|io| UdpSocket::new(io)) } pub fn send_to(&self, buf: &[u8], target: &SocketAddr) -> io::Result { @@ -336,8 +337,7 @@ impl UdpSocket { self.io.recv(buf) } - pub fn connect(&self, addr: SocketAddr) - -> io::Result<()> { + pub fn connect(&self, addr: SocketAddr) -> io::Result<()> { self.io.connect(addr) } @@ -381,27 +381,19 @@ impl UdpSocket { self.io.set_ttl(ttl) } - pub fn join_multicast_v4(&self, - multiaddr: &Ipv4Addr, - interface: &Ipv4Addr) -> io::Result<()> { + pub fn join_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> { self.io.join_multicast_v4(multiaddr, interface) } - pub fn join_multicast_v6(&self, - multiaddr: &Ipv6Addr, - interface: u32) -> io::Result<()> { + pub fn join_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> { self.io.join_multicast_v6(multiaddr, interface) } - pub fn leave_multicast_v4(&self, - multiaddr: &Ipv4Addr, - interface: &Ipv4Addr) -> io::Result<()> { + pub fn leave_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> { self.io.leave_multicast_v4(multiaddr, interface) } - pub fn leave_multicast_v6(&self, - multiaddr: &Ipv6Addr, - interface: u32) -> io::Result<()> { + pub fn leave_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> { self.io.leave_multicast_v6(multiaddr, interface) } @@ -413,28 +405,29 @@ impl UdpSocket { self.io.only_v6() } - pub fn take_error(&self) -> io::Result> { self.io.take_error() } } impl Evented for UdpSocket { - fn register(&self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt) -> io::Result<()> - { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.evented_fd.register(poll, token, interest, opts) } - fn reregister(&self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt) -> io::Result<()> - { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.evented_fd.reregister(poll, token, interest, opts) } diff --git a/src/sys/fuchsia/ready.rs b/src/sys/fuchsia/ready.rs index 97854f8c0..d4f472038 100644 --- a/src/sys/fuchsia/ready.rs +++ b/src/sys/fuchsia/ready.rs @@ -1,10 +1,6 @@ -use event_imp::{Ready, ready_as_usize, ready_from_usize}; -pub use zircon_sys::{ - zx_signals_t, - ZX_OBJECT_READABLE, - ZX_OBJECT_WRITABLE, -}; +use event_imp::{ready_as_usize, ready_from_usize, Ready}; use std::ops; +pub use zircon_sys::{zx_signals_t, ZX_OBJECT_READABLE, ZX_OBJECT_WRITABLE}; // The following impls are valid because Fuchsia and mio both represent // "readable" as `1 << 0` and "writable" as `1 << 2`. diff --git a/src/sys/fuchsia/selector.rs b/src/sys/fuchsia/selector.rs index 27226ac5f..920067057 100644 --- a/src/sys/fuchsia/selector.rs +++ b/src/sys/fuchsia/selector.rs @@ -1,22 +1,18 @@ -use {io, Event, PollOpt, Ready, Token}; -use sys::fuchsia::{ - assert_fuchsia_ready_repr, - epoll_event_to_ready, - poll_opts_to_wait_async, - EventedFd, - EventedFdInner, - FuchsiaReady, -}; -use zircon; -use zircon::AsHandleRef; -use zircon_sys::zx_handle_t; use std::collections::hash_map; use std::fmt; use std::mem; -use std::sync::atomic::{AtomicBool, AtomicUsize, ATOMIC_USIZE_INIT, Ordering}; +use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering, ATOMIC_USIZE_INIT}; use std::sync::{Arc, Mutex, Weak}; use std::time::Duration; use sys; +use sys::fuchsia::{ + assert_fuchsia_ready_repr, epoll_event_to_ready, poll_opts_to_wait_async, EventedFd, + EventedFdInner, FuchsiaReady, +}; +use zircon; +use zircon::AsHandleRef; +use zircon_sys::zx_handle_t; +use {io, Event, PollOpt, Ready, Token}; /// The kind of registration-- file descriptor or handle. /// @@ -33,7 +29,8 @@ fn key_from_token_and_type(token: Token, reg_type: RegType) -> io::Result { if (key & msb) != 0 { return Err(io::Error::new( io::ErrorKind::InvalidInput, - "Most-significant bit of token must remain unset.")); + "Most-significant bit of token must remain unset.", + )); } Ok(match reg_type { @@ -50,7 +47,7 @@ fn token_and_type_from_key(key: u64) -> (Token, RegType) { RegType::Fd } else { RegType::Handle - } + }, ) } @@ -94,9 +91,7 @@ impl Selector { // compatible with Ready. assert_fuchsia_ready_repr(); - let port = Arc::new( - zircon::Port::create(zircon::PortOpts::Default)? - ); + let port = Arc::new(zircon::Port::create(zircon::PortOpts::Default)?); // offset by 1 to avoid choosing 0 as the id of a selector let id = NEXT_ID.fetch_add(1, Ordering::Relaxed) + 1; @@ -119,7 +114,9 @@ impl Selector { } /// Returns a reference to the underlying port `Arc`. - pub fn port(&self) -> &Arc { &self.port } + pub fn port(&self) -> &Arc { + &self.port + } /// Reregisters all registrations pointed to by the `tokens_to_rereg` list /// if `has_tokens_to_rereg`. @@ -130,8 +127,7 @@ impl Selector { let mut tokens = self.tokens_to_rereg.lock().unwrap(); let token_to_fd = self.token_to_fd.lock().unwrap(); for token in tokens.drain(0..) { - if let Some(eventedfd) = token_to_fd.get(&token) - .and_then(|h| h.upgrade()) { + if let Some(eventedfd) = token_to_fd.get(&token).and_then(|h| h.upgrade()) { eventedfd.rereg_for_level(&self.port); } } @@ -140,19 +136,22 @@ impl Selector { Ok(()) } - pub fn select(&self, - evts: &mut Events, - _awakener: Token, - timeout: Option) -> io::Result - { + pub fn select( + &self, + evts: &mut Events, + _awakener: Token, + timeout: Option, + ) -> io::Result { evts.clear(); self.reregister_handles()?; let deadline = match timeout { Some(duration) => { - let nanos = duration.as_secs().saturating_mul(1_000_000_000) - .saturating_add(duration.subsec_nanos() as u64); + let nanos = duration + .as_secs() + .saturating_mul(1_000_000_000) + .saturating_add(duration.subsec_nanos() as u64); zircon::deadline_after(nanos) } @@ -166,12 +165,8 @@ impl Selector { }; let observed_signals = match packet.contents() { - zircon::PacketContents::SignalOne(signal_packet) => { - signal_packet.observed() - } - zircon::PacketContents::SignalRep(signal_packet) => { - signal_packet.observed() - } + zircon::PacketContents::SignalOne(signal_packet) => signal_packet.observed(), + zircon::PacketContents::SignalRep(signal_packet) => signal_packet.observed(), zircon::PacketContents::User(_user_packet) => { // User packets are only ever sent by an Awakener return Ok(true); @@ -184,18 +179,22 @@ impl Selector { match reg_type { RegType::Handle => { // We can return immediately-- no lookup or registration necessary. - evts.events.push(Event::new(Ready::from(observed_signals), token)); + evts.events + .push(Event::new(Ready::from(observed_signals), token)); Ok(false) - }, + } RegType::Fd => { // Convert the signals to epoll events using __fdio_wait_end, // and add to reregistration list if necessary. let events: u32; { - let handle = if let Some(handle) = - self.token_to_fd.lock().unwrap() + let handle = if let Some(handle) = self + .token_to_fd + .lock() + .unwrap() .get(&token) - .and_then(|h| h.upgrade()) { + .and_then(|h| h.upgrade()) + { handle } else { // This handle is apparently in the process of removal. @@ -205,7 +204,11 @@ impl Selector { events = unsafe { let mut events: u32 = mem::uninitialized(); - sys::fuchsia::sys::__fdio_wait_end(handle.fdio(), observed_signals, &mut events); + sys::fuchsia::sys::__fdio_wait_end( + handle.fdio(), + observed_signals, + &mut events, + ); events }; @@ -228,33 +231,39 @@ impl Selector { } } - evts.events.push(Event::new(epoll_event_to_ready(events), token)); + evts.events + .push(Event::new(epoll_event_to_ready(events), token)); Ok(false) - }, + } } } /// Register event interests for the given IO handle with the OS - pub fn register_fd(&self, - handle: &zircon::Handle, - fd: &EventedFd, - token: Token, - signals: zircon::Signals, - poll_opts: PollOpt) -> io::Result<()> - { + pub fn register_fd( + &self, + handle: &zircon::Handle, + fd: &EventedFd, + token: Token, + signals: zircon::Signals, + poll_opts: PollOpt, + ) -> io::Result<()> { { let mut token_to_fd = self.token_to_fd.lock().unwrap(); match token_to_fd.entry(token) { - hash_map::Entry::Occupied(_) => - return Err(io::Error::new(io::ErrorKind::AlreadyExists, - "Attempted to register a filedescriptor on an existing token.")), + hash_map::Entry::Occupied(_) => { + return Err(io::Error::new( + io::ErrorKind::AlreadyExists, + "Attempted to register a filedescriptor on an existing token.", + )) + } hash_map::Entry::Vacant(slot) => slot.insert(Arc::downgrade(&fd.inner)), }; } let wait_async_opts = poll_opts_to_wait_async(poll_opts); - let wait_res = handle.wait_async_handle(&self.port, token.0 as u64, signals, wait_async_opts); + let wait_res = + handle.wait_async_handle(&self.port, token.0 as u64, signals, wait_async_opts); if wait_res.is_err() { self.token_to_fd.lock().unwrap().remove(&token); @@ -269,44 +278,52 @@ impl Selector { // We ignore NotFound errors since oneshots are automatically deregistered, // but mio will attempt to deregister them manually. - self.port.cancel(&*handle, token.0 as u64) + self.port + .cancel(&*handle, token.0 as u64) .map_err(io::Error::from) - .or_else(|e| if e.kind() == io::ErrorKind::NotFound { - Ok(()) - } else { - Err(e) + .or_else(|e| { + if e.kind() == io::ErrorKind::NotFound { + Ok(()) + } else { + Err(e) + } }) } - pub fn register_handle(&self, - handle: zx_handle_t, - token: Token, - interests: Ready, - poll_opts: PollOpt) -> io::Result<()> - { + pub fn register_handle( + &self, + handle: zx_handle_t, + token: Token, + interests: Ready, + poll_opts: PollOpt, + ) -> io::Result<()> { if poll_opts.is_level() && !poll_opts.is_oneshot() { - return Err(io::Error::new(io::ErrorKind::InvalidInput, - "Repeated level-triggered events are not supported on Fuchsia handles.")); + return Err(io::Error::new( + io::ErrorKind::InvalidInput, + "Repeated level-triggered events are not supported on Fuchsia handles.", + )); } let temp_handle = unsafe { zircon::Handle::from_raw(handle) }; let res = temp_handle.wait_async_handle( - &self.port, - key_from_token_and_type(token, RegType::Handle)?, - FuchsiaReady::from(interests).into_zx_signals(), - poll_opts_to_wait_async(poll_opts)); + &self.port, + key_from_token_and_type(token, RegType::Handle)?, + FuchsiaReady::from(interests).into_zx_signals(), + poll_opts_to_wait_async(poll_opts), + ); mem::forget(temp_handle); Ok(res?) } - - pub fn deregister_handle(&self, handle: zx_handle_t, token: Token) -> io::Result<()> - { + pub fn deregister_handle(&self, handle: zx_handle_t, token: Token) -> io::Result<()> { let temp_handle = unsafe { zircon::Handle::from_raw(handle) }; - let res = self.port.cancel(&temp_handle, key_from_token_and_type(token, RegType::Handle)?); + let res = self.port.cancel( + &temp_handle, + key_from_token_and_type(token, RegType::Handle)?, + ); mem::forget(temp_handle); @@ -315,14 +332,16 @@ impl Selector { } pub struct Events { - events: Vec + events: Vec, } impl Events { pub fn with_capacity(_u: usize) -> Events { // The Fuchsia selector only handles one event at a time, // so we ignore the default capacity and set it to one. - Events { events: Vec::with_capacity(1) } + Events { + events: Vec::with_capacity(1), + } } pub fn len(&self) -> usize { self.events.len() diff --git a/src/sys/mod.rs b/src/sys/mod.rs index 8a1705db6..108026b86 100644 --- a/src/sys/mod.rs +++ b/src/sys/mod.rs @@ -1,15 +1,7 @@ #[cfg(all(unix, not(target_os = "fuchsia")))] pub use self::unix::{ - Awakener, - EventedFd, - Events, - Io, - Selector, - TcpStream, - TcpListener, + pipe, set_nonblock, Awakener, EventedFd, Events, Io, Selector, TcpListener, TcpStream, UdpSocket, - pipe, - set_nonblock, }; #[cfg(all(unix, not(target_os = "fuchsia")))] @@ -24,14 +16,7 @@ pub mod unix; #[cfg(windows)] pub use self::windows::{ - Awakener, - Events, - Selector, - TcpStream, - TcpListener, - UdpSocket, - Overlapped, - Binding, + Awakener, Binding, Events, Overlapped, Selector, TcpListener, TcpStream, UdpSocket, }; #[cfg(windows)] @@ -39,14 +24,7 @@ mod windows; #[cfg(target_os = "fuchsia")] pub use self::fuchsia::{ - Awakener, - Events, - EventedHandle, - Selector, - TcpStream, - TcpListener, - UdpSocket, - set_nonblock, + set_nonblock, Awakener, EventedHandle, Events, Selector, TcpListener, TcpStream, UdpSocket, }; #[cfg(target_os = "fuchsia")] diff --git a/src/sys/unix/awakener.rs b/src/sys/unix/awakener.rs index 9cc367a78..aae76730e 100644 --- a/src/sys/unix/awakener.rs +++ b/src/sys/unix/awakener.rs @@ -2,10 +2,10 @@ pub use self::pipe::Awakener; /// Default awakener backed by a pipe mod pipe { - use sys::unix; - use {io, Ready, Poll, PollOpt, Token}; use event::Evented; use std::io::{Read, Write}; + use sys::unix; + use {io, Poll, PollOpt, Ready, Token}; /* * @@ -47,7 +47,7 @@ mod pipe { loop { // Consume data until all bytes are purged match (&self.reader).read(&mut buf) { - Ok(i) if i > 0 => {}, + Ok(i) if i > 0 => {} _ => return, } } @@ -59,11 +59,23 @@ mod pipe { } impl Evented for Awakener { - fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.reader().register(poll, token, interest, opts) } - fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.reader().reregister(poll, token, interest, opts) } diff --git a/src/sys/unix/epoll.rs b/src/sys/unix/epoll.rs index 50b2a14e4..c2ad3432b 100644 --- a/src/sys/unix/epoll.rs +++ b/src/sys/unix/epoll.rs @@ -6,13 +6,13 @@ use std::time::Duration; use std::{cmp, i32}; use libc::{self, c_int}; -use libc::{EPOLLERR, EPOLLHUP, EPOLLRDHUP, EPOLLONESHOT}; -use libc::{EPOLLET, EPOLLOUT, EPOLLIN, EPOLLPRI}; +use libc::{EPOLLERR, EPOLLHUP, EPOLLONESHOT, EPOLLRDHUP}; +use libc::{EPOLLET, EPOLLIN, EPOLLOUT, EPOLLPRI}; -use {io, Ready, PollOpt, Token}; use event_imp::Event; -use sys::unix::{cvt, UnixReady}; use sys::unix::io::set_cloexec; +use sys::unix::{cvt, UnixReady}; +use {io, PollOpt, Ready, Token}; /// Each Selector has a globally unique(ish) ID associated with it. This ID /// gets tracked by `TcpStream`, `TcpListener`, etc... when they are first @@ -36,9 +36,7 @@ impl Selector { dlsym!(fn epoll_create1(c_int) -> c_int); match epoll_create1.get() { - Some(epoll_create1_fn) => { - cvt(epoll_create1_fn(libc::EPOLL_CLOEXEC))? - } + Some(epoll_create1_fn) => cvt(epoll_create1_fn(libc::EPOLL_CLOEXEC))?, None => { let fd = cvt(libc::epoll_create(1024))?; drop(set_cloexec(fd)); @@ -50,10 +48,7 @@ impl Selector { // offset by 1 to avoid choosing 0 as the id of a selector let id = NEXT_ID.fetch_add(1, Ordering::Relaxed) + 1; - Ok(Selector { - id: id, - epfd: epfd, - }) + Ok(Selector { id: id, epfd: epfd }) } pub fn id(&self) -> usize { @@ -61,7 +56,12 @@ impl Selector { } /// Wait for events from the OS - pub fn select(&self, evts: &mut Events, awakener: Token, timeout: Option) -> io::Result { + pub fn select( + &self, + evts: &mut Events, + awakener: Token, + timeout: Option, + ) -> io::Result { let timeout_ms = timeout .map(|to| cmp::min(millis(to), i32::MAX as u64) as i32) .unwrap_or(-1); @@ -69,10 +69,12 @@ impl Selector { // Wait for epoll events for at most timeout_ms milliseconds evts.clear(); unsafe { - let cnt = cvt(libc::epoll_wait(self.epfd, - evts.events.as_mut_ptr(), - evts.events.capacity() as i32, - timeout_ms))?; + let cnt = cvt(libc::epoll_wait( + self.epfd, + evts.events.as_mut_ptr(), + evts.events.capacity() as i32, + timeout_ms, + ))?; let cnt = cnt as usize; evts.events.set_len(cnt); @@ -88,27 +90,49 @@ impl Selector { } /// Register event interests for the given IO handle with the OS - pub fn register(&self, fd: RawFd, token: Token, interests: Ready, opts: PollOpt) -> io::Result<()> { + pub fn register( + &self, + fd: RawFd, + token: Token, + interests: Ready, + opts: PollOpt, + ) -> io::Result<()> { let mut info = libc::epoll_event { events: ioevent_to_epoll(interests, opts), - u64: usize::from(token) as u64 + u64: usize::from(token) as u64, }; unsafe { - cvt(libc::epoll_ctl(self.epfd, libc::EPOLL_CTL_ADD, fd, &mut info))?; + cvt(libc::epoll_ctl( + self.epfd, + libc::EPOLL_CTL_ADD, + fd, + &mut info, + ))?; Ok(()) } } /// Register event interests for the given IO handle with the OS - pub fn reregister(&self, fd: RawFd, token: Token, interests: Ready, opts: PollOpt) -> io::Result<()> { + pub fn reregister( + &self, + fd: RawFd, + token: Token, + interests: Ready, + opts: PollOpt, + ) -> io::Result<()> { let mut info = libc::epoll_event { events: ioevent_to_epoll(interests, opts), - u64: usize::from(token) as u64 + u64: usize::from(token) as u64, }; unsafe { - cvt(libc::epoll_ctl(self.epfd, libc::EPOLL_CTL_MOD, fd, &mut info))?; + cvt(libc::epoll_ctl( + self.epfd, + libc::EPOLL_CTL_MOD, + fd, + &mut info, + ))?; Ok(()) } } @@ -118,13 +142,15 @@ impl Selector { // The &info argument should be ignored by the system, // but linux < 2.6.9 required it to be not null. // For compatibility, we provide a dummy EpollEvent. - let mut info = libc::epoll_event { - events: 0, - u64: 0, - }; + let mut info = libc::epoll_event { events: 0, u64: 0 }; unsafe { - cvt(libc::epoll_ctl(self.epfd, libc::EPOLL_CTL_DEL, fd, &mut info))?; + cvt(libc::epoll_ctl( + self.epfd, + libc::EPOLL_CTL_DEL, + fd, + &mut info, + ))?; Ok(()) } } @@ -181,7 +207,7 @@ pub struct Events { impl Events { pub fn with_capacity(u: usize) -> Events { Events { - events: Vec::with_capacity(u) + events: Vec::with_capacity(u), } } @@ -232,12 +258,14 @@ impl Events { pub fn push_event(&mut self, event: Event) { self.events.push(libc::epoll_event { events: ioevent_to_epoll(event.readiness(), PollOpt::empty()), - u64: usize::from(event.token()) as u64 + u64: usize::from(event.token()) as u64, }); } pub fn clear(&mut self) { - unsafe { self.events.set_len(0); } + unsafe { + self.events.set_len(0); + } } } @@ -252,5 +280,8 @@ const MILLIS_PER_SEC: u64 = 1_000; pub fn millis(duration: Duration) -> u64 { // Round up. let millis = (duration.subsec_nanos() + NANOS_PER_MILLI - 1) / NANOS_PER_MILLI; - duration.as_secs().saturating_mul(MILLIS_PER_SEC).saturating_add(millis as u64) + duration + .as_secs() + .saturating_mul(MILLIS_PER_SEC) + .saturating_add(millis as u64) } diff --git a/src/sys/unix/eventedfd.rs b/src/sys/unix/eventedfd.rs index 6331062cb..1f9b5a27c 100644 --- a/src/sys/unix/eventedfd.rs +++ b/src/sys/unix/eventedfd.rs @@ -1,6 +1,6 @@ -use {io, poll, Ready, Poll, PollOpt, Token}; use event::Evented; use std::os::unix::io::RawFd; +use {io, poll, Poll, PollOpt, Ready, Token}; /* * @@ -92,11 +92,23 @@ use std::os::unix::io::RawFd; pub struct EventedFd<'a>(pub &'a RawFd); impl<'a> Evented for EventedFd<'a> { - fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { poll::selector(poll).register(*self.0, token, interest, opts) } - fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { poll::selector(poll).reregister(*self.0, token, interest, opts) } diff --git a/src/sys/unix/io.rs b/src/sys/unix/io.rs index 47a3a70d1..61bb8cecc 100644 --- a/src/sys/unix/io.rs +++ b/src/sys/unix/io.rs @@ -1,18 +1,18 @@ use std::fs::File; use std::io::{Read, Write}; -use std::os::unix::io::{IntoRawFd, AsRawFd, FromRawFd, RawFd}; +use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; use libc; -use {io, Ready, Poll, PollOpt, Token}; use event::Evented; -use unix::EventedFd; use sys::unix::cvt; +use unix::EventedFd; +use {io, Poll, PollOpt, Ready, Token}; pub fn set_nonblock(fd: libc::c_int) -> io::Result<()> { unsafe { let flags = libc::fcntl(fd, libc::F_GETFL); - cvt(libc::fcntl(fd, libc::F_SETFL, flags | libc::O_NONBLOCK)).map(|_|()) + cvt(libc::fcntl(fd, libc::F_SETFL, flags | libc::O_NONBLOCK)).map(|_| ()) } } @@ -38,13 +38,17 @@ pub struct Io { impl Io { /// Try to clone the FD pub fn try_clone(&self) -> io::Result { - Ok(Io { fd: self.fd.try_clone()? }) + Ok(Io { + fd: self.fd.try_clone()?, + }) } } impl FromRawFd for Io { unsafe fn from_raw_fd(fd: RawFd) -> Io { - Io { fd: File::from_raw_fd(fd) } + Io { + fd: File::from_raw_fd(fd), + } } } @@ -61,11 +65,23 @@ impl AsRawFd for Io { } impl Evented for Io { - fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { EventedFd(&self.as_raw_fd()).register(poll, token, interest, opts) } - fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { EventedFd(&self.as_raw_fd()).reregister(poll, token, interest, opts) } diff --git a/src/sys/unix/kqueue.rs b/src/sys/unix/kqueue.rs index 89a5da112..f86ace5bc 100644 --- a/src/sys/unix/kqueue.rs +++ b/src/sys/unix/kqueue.rs @@ -1,18 +1,18 @@ -use std::{cmp, fmt, ptr}; +use std::collections::HashMap; #[cfg(not(target_os = "netbsd"))] use std::os::raw::{c_int, c_short}; use std::os::unix::io::AsRawFd; use std::os::unix::io::RawFd; -use std::collections::HashMap; use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT}; use std::time::Duration; +use std::{cmp, fmt, ptr}; use libc::{self, time_t}; -use {io, Ready, PollOpt, Token}; use event_imp::{self as event, Event}; -use sys::unix::{cvt, UnixReady}; use sys::unix::io::set_cloexec; +use sys::unix::{cvt, UnixReady}; +use {io, PollOpt, Ready, Token}; /// Each Selector has a globally unique(ish) ID associated with it. This ID /// gets tracked by `TcpStream`, `TcpListener`, etc... when they are first @@ -45,7 +45,7 @@ macro_rules! kevent { data: 0, udata: $data as UData, } - } + }; } pub struct Selector { @@ -60,66 +60,93 @@ impl Selector { let kq = unsafe { cvt(libc::kqueue())? }; drop(set_cloexec(kq)); - Ok(Selector { - id: id, - kq: kq, - }) + Ok(Selector { id: id, kq: kq }) } pub fn id(&self) -> usize { self.id } - pub fn select(&self, evts: &mut Events, awakener: Token, timeout: Option) -> io::Result { - let timeout = timeout.map(|to| { - libc::timespec { - tv_sec: cmp::min(to.as_secs(), time_t::max_value() as u64) as time_t, - tv_nsec: to.subsec_nanos() as libc::c_long, - } + pub fn select( + &self, + evts: &mut Events, + awakener: Token, + timeout: Option, + ) -> io::Result { + let timeout = timeout.map(|to| libc::timespec { + tv_sec: cmp::min(to.as_secs(), time_t::max_value() as u64) as time_t, + tv_nsec: to.subsec_nanos() as libc::c_long, }); - let timeout = timeout.as_ref().map(|s| s as *const _).unwrap_or(ptr::null_mut()); + let timeout = timeout + .as_ref() + .map(|s| s as *const _) + .unwrap_or(ptr::null_mut()); evts.clear(); unsafe { - let cnt = cvt(libc::kevent(self.kq, - ptr::null(), - 0, - evts.sys_events.0.as_mut_ptr(), - evts.sys_events.0.capacity() as Count, - timeout))?; + let cnt = cvt(libc::kevent( + self.kq, + ptr::null(), + 0, + evts.sys_events.0.as_mut_ptr(), + evts.sys_events.0.capacity() as Count, + timeout, + ))?; evts.sys_events.0.set_len(cnt as usize); Ok(evts.coalesce(awakener)) } } - pub fn register(&self, fd: RawFd, token: Token, interests: Ready, opts: PollOpt) -> io::Result<()> { + pub fn register( + &self, + fd: RawFd, + token: Token, + interests: Ready, + opts: PollOpt, + ) -> io::Result<()> { trace!("registering; token={:?}; interests={:?}", token, interests); - let flags = if opts.contains(PollOpt::edge()) { libc::EV_CLEAR } else { 0 } | - if opts.contains(PollOpt::oneshot()) { libc::EV_ONESHOT } else { 0 } | - libc::EV_RECEIPT; + let flags = if opts.contains(PollOpt::edge()) { + libc::EV_CLEAR + } else { + 0 + } | if opts.contains(PollOpt::oneshot()) { + libc::EV_ONESHOT + } else { + 0 + } | libc::EV_RECEIPT; unsafe { - let r = if interests.contains(Ready::readable()) { libc::EV_ADD } else { libc::EV_DELETE }; - let w = if interests.contains(Ready::writable()) { libc::EV_ADD } else { libc::EV_DELETE }; + let r = if interests.contains(Ready::readable()) { + libc::EV_ADD + } else { + libc::EV_DELETE + }; + let w = if interests.contains(Ready::writable()) { + libc::EV_ADD + } else { + libc::EV_DELETE + }; let mut changes = [ kevent!(fd, libc::EVFILT_READ, flags | r, usize::from(token)), kevent!(fd, libc::EVFILT_WRITE, flags | w, usize::from(token)), ]; - cvt(libc::kevent(self.kq, - changes.as_ptr(), - changes.len() as Count, - changes.as_mut_ptr(), - changes.len() as Count, - ::std::ptr::null()))?; + cvt(libc::kevent( + self.kq, + changes.as_ptr(), + changes.len() as Count, + changes.as_mut_ptr(), + changes.len() as Count, + ::std::ptr::null(), + ))?; for change in changes.iter() { debug_assert_eq!(change.flags & libc::EV_ERROR, libc::EV_ERROR); // Test to see if an error happened if change.data == 0 { - continue + continue; } // Older versions of OSX (10.11 and 10.10 have been witnessed) @@ -135,15 +162,20 @@ impl Selector { // ignore `EPIPE` here instead of propagating it. // // More info can be found at carllerche/mio#582 - if change.data as i32 == libc::EPIPE && - change.filter == libc::EVFILT_WRITE as Filter { - continue + if change.data as i32 == libc::EPIPE + && change.filter == libc::EVFILT_WRITE as Filter + { + continue; } // ignore ENOENT error for EV_DELETE - let orig_flags = if change.filter == libc::EVFILT_READ as Filter { r } else { w }; + let orig_flags = if change.filter == libc::EVFILT_READ as Filter { + r + } else { + w + }; if change.data as i32 == libc::ENOENT && orig_flags & libc::EV_DELETE != 0 { - continue + continue; } return Err(::std::io::Error::from_raw_os_error(change.data as i32)); @@ -152,7 +184,13 @@ impl Selector { } } - pub fn reregister(&self, fd: RawFd, token: Token, interests: Ready, opts: PollOpt) -> io::Result<()> { + pub fn reregister( + &self, + fd: RawFd, + token: Token, + interests: Ready, + opts: PollOpt, + ) -> io::Result<()> { // Just need to call register here since EV_ADD is a mod if already // registered self.register(fd, token, interests, opts) @@ -163,24 +201,26 @@ impl Selector { // EV_RECEIPT is a nice way to apply changes and get back per-event results while not // draining the actual changes. let filter = libc::EV_DELETE | libc::EV_RECEIPT; -#[cfg(not(target_os = "netbsd"))] + #[cfg(not(target_os = "netbsd"))] let mut changes = [ kevent!(fd, libc::EVFILT_READ, filter, ptr::null_mut()), kevent!(fd, libc::EVFILT_WRITE, filter, ptr::null_mut()), ]; -#[cfg(target_os = "netbsd")] + #[cfg(target_os = "netbsd")] let mut changes = [ kevent!(fd, libc::EVFILT_READ, filter, 0), kevent!(fd, libc::EVFILT_WRITE, filter, 0), ]; - cvt(libc::kevent(self.kq, - changes.as_ptr(), - changes.len() as Count, - changes.as_mut_ptr(), - changes.len() as Count, - ::std::ptr::null())).map(|_| ())?; + cvt(libc::kevent( + self.kq, + changes.as_ptr(), + changes.len() as Count, + changes.as_mut_ptr(), + changes.len() as Count, + ::std::ptr::null(), + )).map(|_| ())?; if changes[0].data as i32 == libc::ENOENT && changes[1].data as i32 == libc::ENOENT { return Err(::std::io::Error::from_raw_os_error(changes[0].data as i32)); @@ -235,7 +275,7 @@ impl Events { Events { sys_events: KeventList(Vec::with_capacity(cap)), events: Vec::with_capacity(cap), - event_map: HashMap::with_capacity(cap) + event_map: HashMap::with_capacity(cap), } } @@ -274,13 +314,11 @@ impl Events { continue; } - let idx = *self.event_map.entry(token) - .or_insert(len); + let idx = *self.event_map.entry(token).or_insert(len); if idx == len { // New entry, insert the default self.events.push(Event::new(Ready::empty(), token)); - } if e.flags & libc::EV_ERROR != 0 { @@ -292,14 +330,20 @@ impl Events { } else if e.filter == libc::EVFILT_WRITE as Filter { event::kind_mut(&mut self.events[idx]).insert(Ready::writable()); } -#[cfg(any(target_os = "dragonfly", - target_os = "freebsd", target_os = "ios", target_os = "macos"))] + #[cfg( + any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos" + ) + )] { if e.filter == libc::EVFILT_AIO { event::kind_mut(&mut self.events[idx]).insert(UnixReady::aio()); } } -#[cfg(any(target_os = "freebsd"))] + #[cfg(any(target_os = "freebsd"))] { if e.filter == libc::EVFILT_LIO { event::kind_mut(&mut self.events[idx]).insert(UnixReady::lio()); @@ -341,8 +385,8 @@ impl fmt::Debug for Events { #[test] fn does_not_register_rw() { - use {Poll, Ready, PollOpt, Token}; use unix::EventedFd; + use {Poll, PollOpt, Ready, Token}; let kq = unsafe { libc::kqueue() }; let kqf = EventedFd(&kq); @@ -350,16 +394,29 @@ fn does_not_register_rw() { // registering kqueue fd will fail if write is requested (On anything but some versions of OS // X) - poll.register(&kqf, Token(1234), Ready::readable(), - PollOpt::edge() | PollOpt::oneshot()).unwrap(); + poll.register( + &kqf, + Token(1234), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); } -#[cfg(any(target_os = "dragonfly", - target_os = "freebsd", target_os = "ios", target_os = "macos"))] +#[cfg( + any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos" + ) +)] #[test] fn test_coalesce_aio() { let mut events = Events::with_capacity(1); - events.sys_events.0.push(kevent!(0x1234, libc::EVFILT_AIO, 0, 42)); + events + .sys_events + .0 + .push(kevent!(0x1234, libc::EVFILT_AIO, 0, 42)); events.coalesce(Token(0)); assert!(events.events[0].readiness() == UnixReady::aio().into()); assert!(events.events[0].token() == Token(42)); diff --git a/src/sys/unix/mod.rs b/src/sys/unix/mod.rs index 39e604554..a32e36da4 100644 --- a/src/sys/unix/mod.rs +++ b/src/sys/unix/mod.rs @@ -3,20 +3,48 @@ use libc::{self, c_int}; #[macro_use] pub mod dlsym; -#[cfg(any(target_os = "linux", target_os = "android", target_os = "solaris"))] +#[cfg( + any( + target_os = "linux", + target_os = "android", + target_os = "solaris" + ) +)] mod epoll; -#[cfg(any(target_os = "linux", target_os = "android", target_os = "solaris"))] +#[cfg( + any( + target_os = "linux", + target_os = "android", + target_os = "solaris" + ) +)] pub use self::epoll::{Events, Selector}; -#[cfg(any(target_os = "bitrig", target_os = "dragonfly", - target_os = "freebsd", target_os = "ios", target_os = "macos", - target_os = "netbsd", target_os = "openbsd"))] +#[cfg( + any( + target_os = "bitrig", + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos", + target_os = "netbsd", + target_os = "openbsd" + ) +)] mod kqueue; -#[cfg(any(target_os = "bitrig", target_os = "dragonfly", - target_os = "freebsd", target_os = "ios", target_os = "macos", - target_os = "netbsd", target_os = "openbsd"))] +#[cfg( + any( + target_os = "bitrig", + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos", + target_os = "netbsd", + target_os = "openbsd" + ) +)] pub use self::kqueue::{Events, Selector}; mod awakener; @@ -31,9 +59,9 @@ mod uds; pub use self::awakener::Awakener; pub use self::eventedfd::EventedFd; -pub use self::io::{Io, set_nonblock}; +pub use self::io::{set_nonblock, Io}; pub use self::ready::{UnixReady, READY_ALL}; -pub use self::tcp::{TcpStream, TcpListener}; +pub use self::tcp::{TcpListener, TcpStream}; pub use self::udp::UdpSocket; #[cfg(feature = "with-deprecated")] @@ -63,9 +91,7 @@ pub fn pipe() -> ::io::Result<(Io, Io)> { } } - unsafe { - Ok((Io::from_raw_fd(pipes[0]), Io::from_raw_fd(pipes[1]))) - } + unsafe { Ok((Io::from_raw_fd(pipes[0]), Io::from_raw_fd(pipes[1]))) } } trait IsMinusOne { @@ -73,10 +99,14 @@ trait IsMinusOne { } impl IsMinusOne for i32 { - fn is_minus_one(&self) -> bool { *self == -1 } + fn is_minus_one(&self) -> bool { + *self == -1 + } } impl IsMinusOne for isize { - fn is_minus_one(&self) -> bool { *self == -1 } + fn is_minus_one(&self) -> bool { + *self == -1 + } } fn cvt(t: T) -> ::io::Result { diff --git a/src/sys/unix/ready.rs b/src/sys/unix/ready.rs index 398fc17cc..8eaa12b01 100644 --- a/src/sys/unix/ready.rs +++ b/src/sys/unix/ready.rs @@ -1,7 +1,7 @@ -use event_imp::{Ready, ready_as_usize, ready_from_usize}; +use event_imp::{ready_as_usize, ready_from_usize, Ready}; -use std::ops; use std::fmt; +use std::ops; /// Unix specific extensions to `Ready` /// @@ -93,21 +93,35 @@ use std::fmt; pub struct UnixReady(Ready); const ERROR: usize = 0b000100; -const HUP: usize = 0b001000; - -#[cfg(any(target_os = "dragonfly", - target_os = "freebsd", target_os = "ios", target_os = "macos"))] -const AIO: usize = 0b010000; - -#[cfg(not(any(target_os = "dragonfly", - target_os = "freebsd", target_os = "ios", target_os = "macos")))] -const AIO: usize = 0b000000; +const HUP: usize = 0b001000; + +#[cfg( + any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos" + ) +)] +const AIO: usize = 0b010000; + +#[cfg( + not( + any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos" + ) + ) +)] +const AIO: usize = 0b000000; #[cfg(any(target_os = "freebsd"))] -const LIO: usize = 0b100000; +const LIO: usize = 0b100000; #[cfg(not(any(target_os = "freebsd")))] -const LIO: usize = 0b000000; +const LIO: usize = 0b000000; // Export to support `Ready::all` pub const READY_ALL: usize = ERROR | HUP | AIO | LIO; @@ -129,15 +143,32 @@ impl UnixReady { /// /// [`Poll`]: ../struct.Poll.html #[inline] - #[cfg(any(target_os = "dragonfly", - target_os = "freebsd", target_os = "ios", target_os = "macos"))] + #[cfg( + any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos" + ) + )] pub fn aio() -> UnixReady { UnixReady(ready_from_usize(AIO)) } - #[cfg(not(any(target_os = "dragonfly", - target_os = "freebsd", target_os = "ios", target_os = "macos")))] - #[deprecated(since = "0.6.12", note = "this function is now platform specific")] + #[cfg( + not( + any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos" + ) + ) + )] + #[deprecated( + since = "0.6.12", + note = "this function is now platform specific" + )] #[doc(hidden)] pub fn aio() -> UnixReady { UnixReady(Ready::empty()) @@ -235,16 +266,33 @@ impl UnixReady { /// /// [`Poll`]: ../struct.Poll.html #[inline] - #[cfg(any(target_os = "dragonfly", - target_os = "freebsd", target_os = "ios", target_os = "macos"))] + #[cfg( + any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos" + ) + )] pub fn is_aio(&self) -> bool { self.contains(ready_from_usize(AIO)) } - #[deprecated(since = "0.6.12", note = "this function is now platform specific")] + #[deprecated( + since = "0.6.12", + note = "this function is now platform specific" + )] #[cfg(feature = "with-deprecated")] - #[cfg(not(any(target_os = "dragonfly", - target_os = "freebsd", target_os = "ios", target_os = "macos")))] + #[cfg( + not( + any( + target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos" + ) + ) + )] #[doc(hidden)] pub fn is_aio(&self) -> bool { false @@ -408,11 +456,14 @@ impl fmt::Debug for UnixReady { (UnixReady::error(), "Error"), (UnixReady::hup(), "Hup"), #[allow(deprecated)] - (UnixReady::aio(), "Aio")]; + (UnixReady::aio(), "Aio"), + ]; for &(flag, msg) in &flags { if self.contains(flag) { - if one { write!(fmt, " | ")? } + if one { + write!(fmt, " | ")? + } write!(fmt, "{}", msg)?; one = true diff --git a/src/sys/unix/tcp.rs b/src/sys/unix/tcp.rs index a5f6dba11..12b5110e1 100644 --- a/src/sys/unix/tcp.rs +++ b/src/sys/unix/tcp.rs @@ -2,16 +2,16 @@ use std::cmp; use std::fmt; use std::io::{Read, Write}; use std::net::{self, SocketAddr}; -use std::os::unix::io::{RawFd, FromRawFd, IntoRawFd, AsRawFd}; +use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; use std::time::Duration; +use iovec::unix as iovec; +use iovec::IoVec; use libc; use net2::TcpStreamExt; -use iovec::IoVec; -use iovec::unix as iovec; -use {io, Ready, Poll, PollOpt, Token}; use event::Evented; +use {io, Poll, PollOpt, Ready, Token}; use sys::unix::eventedfd::EventedFd; use sys::unix::io::set_nonblock; @@ -34,15 +34,11 @@ impl TcpStream { Err(e) => return Err(e), } - Ok(TcpStream { - inner: stream, - }) + Ok(TcpStream { inner: stream }) } pub fn from_stream(stream: net::TcpStream) -> TcpStream { - TcpStream { - inner: stream, - } + TcpStream { inner: stream } } pub fn peer_addr(&self) -> io::Result { @@ -54,11 +50,7 @@ impl TcpStream { } pub fn try_clone(&self) -> io::Result { - self.inner.try_clone().map(|s| { - TcpStream { - inner: s, - } - }) + self.inner.try_clone().map(|s| TcpStream { inner: s }) } pub fn shutdown(&self, how: net::Shutdown) -> io::Result<()> { @@ -133,9 +125,7 @@ impl TcpStream { unsafe { let slice = iovec::as_os_slice_mut(bufs); let len = cmp::min(::max_value() as usize, slice.len()); - let rc = libc::readv(self.inner.as_raw_fd(), - slice.as_ptr(), - len as libc::c_int); + let rc = libc::readv(self.inner.as_raw_fd(), slice.as_ptr(), len as libc::c_int); if rc < 0 { Err(io::Error::last_os_error()) } else { @@ -148,9 +138,7 @@ impl TcpStream { unsafe { let slice = iovec::as_os_slice(bufs); let len = cmp::min(::max_value() as usize, slice.len()); - let rc = libc::writev(self.inner.as_raw_fd(), - slice.as_ptr(), - len as libc::c_int); + let rc = libc::writev(self.inner.as_raw_fd(), slice.as_ptr(), len as libc::c_int); if rc < 0 { Err(io::Error::last_os_error()) } else { @@ -177,13 +165,23 @@ impl<'a> Write for &'a TcpStream { } impl Evented for TcpStream { - fn register(&self, poll: &Poll, token: Token, - interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { EventedFd(&self.as_raw_fd()).register(poll, token, interest, opts) } - fn reregister(&self, poll: &Poll, token: Token, - interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { EventedFd(&self.as_raw_fd()).reregister(poll, token, interest, opts) } @@ -221,9 +219,7 @@ impl AsRawFd for TcpStream { impl TcpListener { pub fn new(inner: net::TcpListener) -> io::Result { set_nonblock(inner.as_raw_fd())?; - Ok(TcpListener { - inner: inner, - }) + Ok(TcpListener { inner: inner }) } pub fn local_addr(&self) -> io::Result { @@ -231,11 +227,7 @@ impl TcpListener { } pub fn try_clone(&self) -> io::Result { - self.inner.try_clone().map(|s| { - TcpListener { - inner: s, - } - }) + self.inner.try_clone().map(|s| TcpListener { inner: s }) } pub fn accept(&self) -> io::Result<(net::TcpStream, SocketAddr)> { @@ -266,13 +258,23 @@ impl TcpListener { } impl Evented for TcpListener { - fn register(&self, poll: &Poll, token: Token, - interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { EventedFd(&self.as_raw_fd()).register(poll, token, interest, opts) } - fn reregister(&self, poll: &Poll, token: Token, - interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { EventedFd(&self.as_raw_fd()).reregister(poll, token, interest, opts) } @@ -306,4 +308,3 @@ impl AsRawFd for TcpListener { self.inner.as_raw_fd() } } - diff --git a/src/sys/unix/udp.rs b/src/sys/unix/udp.rs index fee1528cd..64ec77600 100644 --- a/src/sys/unix/udp.rs +++ b/src/sys/unix/udp.rs @@ -1,9 +1,9 @@ -use {io, Ready, Poll, PollOpt, Token}; use event::Evented; -use unix::EventedFd; use std::fmt; use std::net::{self, Ipv4Addr, Ipv6Addr, SocketAddr}; -use std::os::unix::io::{RawFd, IntoRawFd, AsRawFd, FromRawFd}; +use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; +use unix::EventedFd; +use {io, Poll, PollOpt, Ready, Token}; #[allow(unused_imports)] // only here for Rust 1.8 use net2::UdpSocketExt; @@ -15,9 +15,7 @@ pub struct UdpSocket { impl UdpSocket { pub fn new(socket: net::UdpSocket) -> io::Result { socket.set_nonblocking(true)?; - Ok(UdpSocket { - io: socket, - }) + Ok(UdpSocket { io: socket }) } pub fn local_addr(&self) -> io::Result { @@ -25,11 +23,7 @@ impl UdpSocket { } pub fn try_clone(&self) -> io::Result { - self.io.try_clone().map(|io| { - UdpSocket { - io: io, - } - }) + self.io.try_clone().map(|io| UdpSocket { io: io }) } pub fn send_to(&self, buf: &[u8], target: &SocketAddr) -> io::Result { @@ -48,8 +42,7 @@ impl UdpSocket { self.io.recv(buf) } - pub fn connect(&self, addr: SocketAddr) - -> io::Result<()> { + pub fn connect(&self, addr: SocketAddr) -> io::Result<()> { self.io.connect(addr) } @@ -93,27 +86,19 @@ impl UdpSocket { self.io.set_ttl(ttl) } - pub fn join_multicast_v4(&self, - multiaddr: &Ipv4Addr, - interface: &Ipv4Addr) -> io::Result<()> { + pub fn join_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> { self.io.join_multicast_v4(multiaddr, interface) } - pub fn join_multicast_v6(&self, - multiaddr: &Ipv6Addr, - interface: u32) -> io::Result<()> { + pub fn join_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> { self.io.join_multicast_v6(multiaddr, interface) } - pub fn leave_multicast_v4(&self, - multiaddr: &Ipv4Addr, - interface: &Ipv4Addr) -> io::Result<()> { + pub fn leave_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> { self.io.leave_multicast_v4(multiaddr, interface) } - pub fn leave_multicast_v6(&self, - multiaddr: &Ipv6Addr, - interface: u32) -> io::Result<()> { + pub fn leave_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> { self.io.leave_multicast_v6(multiaddr, interface) } @@ -131,11 +116,23 @@ impl UdpSocket { } impl Evented for UdpSocket { - fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { EventedFd(&self.as_raw_fd()).register(poll, token, interest, opts) } - fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { EventedFd(&self.as_raw_fd()).reregister(poll, token, interest, opts) } diff --git a/src/sys/unix/uds.rs b/src/sys/unix/uds.rs index e2888b23a..408852f9f 100644 --- a/src/sys/unix/uds.rs +++ b/src/sys/unix/uds.rs @@ -6,33 +6,38 @@ use std::path::Path; use libc; -use {io, Ready, Poll, PollOpt, Token}; use event::Evented; +use sys::unix::io::{set_cloexec, set_nonblock}; use sys::unix::{cvt, Io}; -use sys::unix::io::{set_nonblock, set_cloexec}; +use {io, Poll, PollOpt, Ready, Token}; trait MyInto { fn my_into(self) -> T; } impl MyInto for usize { - fn my_into(self) -> u32 { self as u32 } + fn my_into(self) -> u32 { + self as u32 + } } impl MyInto for usize { - fn my_into(self) -> usize { self } + fn my_into(self) -> usize { + self + } } -unsafe fn sockaddr_un(path: &Path) - -> io::Result<(libc::sockaddr_un, libc::socklen_t)> { +unsafe fn sockaddr_un(path: &Path) -> io::Result<(libc::sockaddr_un, libc::socklen_t)> { let mut addr: libc::sockaddr_un = mem::zeroed(); addr.sun_family = libc::AF_UNIX as libc::sa_family_t; let bytes = path.as_os_str().as_bytes(); if bytes.len() >= addr.sun_path.len() { - return Err(io::Error::new(io::ErrorKind::InvalidInput, - "path must be shorter than SUN_LEN")) + return Err(io::Error::new( + io::ErrorKind::InvalidInput, + "path must be shorter than SUN_LEN", + )); } for (dst, src) in addr.sun_path.iter_mut().zip(bytes.iter()) { *dst = *src as libc::c_char; @@ -95,9 +100,11 @@ impl UnixSocket { pub fn connect + ?Sized>(&self, addr: &P) -> io::Result<()> { unsafe { let (addr, len) = sockaddr_un(addr.as_ref())?; - cvt(libc::connect(self.as_raw_fd(), - &addr as *const _ as *const _, - len))?; + cvt(libc::connect( + self.as_raw_fd(), + &addr as *const _ as *const _, + len, + ))?; Ok(()) } } @@ -112,9 +119,7 @@ impl UnixSocket { pub fn accept(&self) -> io::Result { unsafe { - let fd = cvt(libc::accept(self.as_raw_fd(), - 0 as *mut _, - 0 as *mut _))?; + let fd = cvt(libc::accept(self.as_raw_fd(), 0 as *mut _, 0 as *mut _))?; let fd = Io::from_raw_fd(fd); set_cloexec(fd.as_raw_fd())?; set_nonblock(fd.as_raw_fd())?; @@ -126,15 +131,19 @@ impl UnixSocket { pub fn bind + ?Sized>(&self, addr: &P) -> io::Result<()> { unsafe { let (addr, len) = sockaddr_un(addr.as_ref())?; - cvt(libc::bind(self.as_raw_fd(), - &addr as *const _ as *const _, - len))?; + cvt(libc::bind( + self.as_raw_fd(), + &addr as *const _ as *const _, + len, + ))?; Ok(()) } } pub fn try_clone(&self) -> io::Result { - Ok(UnixSocket { io: self.io.try_clone()? }) + Ok(UnixSocket { + io: self.io.try_clone()?, + }) } pub fn shutdown(&self, how: Shutdown) -> io::Result<()> { @@ -169,8 +178,8 @@ impl UnixSocket { const SCM_RIGHTS: libc::c_int = 1; - let fd = if cmsg.hdr.cmsg_level == libc::SOL_SOCKET && - cmsg.hdr.cmsg_type == SCM_RIGHTS { + let fd = if cmsg.hdr.cmsg_level == libc::SOL_SOCKET && cmsg.hdr.cmsg_type == SCM_RIGHTS + { Some(cmsg.data[0]) } else { None @@ -222,11 +231,23 @@ impl Write for UnixSocket { } impl Evented for UnixSocket { - fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.io.register(poll, token, interest, opts) } - fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.io.reregister(poll, token, interest, opts) } @@ -235,7 +256,6 @@ impl Evented for UnixSocket { } } - impl From for UnixSocket { fn from(io: Io) -> UnixSocket { UnixSocket { io: io } @@ -244,7 +264,9 @@ impl From for UnixSocket { impl FromRawFd for UnixSocket { unsafe fn from_raw_fd(fd: RawFd) -> UnixSocket { - UnixSocket { io: Io::from_raw_fd(fd) } + UnixSocket { + io: Io::from_raw_fd(fd), + } } } diff --git a/src/sys/windows/awakener.rs b/src/sys/windows/awakener.rs index c913bc93f..6f125772a 100644 --- a/src/sys/windows/awakener.rs +++ b/src/sys/windows/awakener.rs @@ -1,9 +1,9 @@ use std::sync::Mutex; -use miow::iocp::CompletionStatus; -use {io, poll, Ready, Poll, PollOpt, Token}; use event::Evented; +use miow::iocp::CompletionStatus; use sys::windows::Selector; +use {io, poll, Poll, PollOpt, Ready, Token}; pub struct Awakener { inner: Mutex>, @@ -29,9 +29,7 @@ impl Awakener { // If we haven't been registered with an event loop yet just silently // succeed. if let Some(inner) = self.inner.lock().unwrap().as_ref() { - let status = CompletionStatus::new(0, - usize::from(inner.token), - 0 as *mut _); + let status = CompletionStatus::new(0, usize::from(inner.token), 0 as *mut _); inner.selector.port().post(status)?; } Ok(()) @@ -43,8 +41,7 @@ impl Awakener { } impl Evented for Awakener { - fn register(&self, poll: &Poll, token: Token, events: Ready, - opts: PollOpt) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, events: Ready, opts: PollOpt) -> io::Result<()> { assert_eq!(opts, PollOpt::edge()); assert_eq!(events, Ready::readable()); *self.inner.lock().unwrap() = Some(AwakenerInner { @@ -54,8 +51,13 @@ impl Evented for Awakener { Ok(()) } - fn reregister(&self, poll: &Poll, token: Token, events: Ready, - opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + events: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.register(poll, token, events, opts) } diff --git a/src/sys/windows/buffer_pool.rs b/src/sys/windows/buffer_pool.rs index 86754593f..877b28ca2 100644 --- a/src/sys/windows/buffer_pool.rs +++ b/src/sys/windows/buffer_pool.rs @@ -4,16 +4,22 @@ pub struct BufferPool { impl BufferPool { pub fn new(cap: usize) -> BufferPool { - BufferPool { pool: Vec::with_capacity(cap) } + BufferPool { + pool: Vec::with_capacity(cap), + } } pub fn get(&mut self, default_cap: usize) -> Vec { - self.pool.pop().unwrap_or_else(|| Vec::with_capacity(default_cap)) + self.pool + .pop() + .unwrap_or_else(|| Vec::with_capacity(default_cap)) } pub fn put(&mut self, mut buf: Vec) { - if self.pool.len() < self.pool.capacity(){ - unsafe { buf.set_len(0); } + if self.pool.len() < self.pool.capacity() { + unsafe { + buf.set_len(0); + } self.pool.push(buf); } } diff --git a/src/sys/windows/from_raw_arc.rs b/src/sys/windows/from_raw_arc.rs index 61f0e49cd..b2ea3c767 100644 --- a/src/sys/windows/from_raw_arc.rs +++ b/src/sys/windows/from_raw_arc.rs @@ -19,8 +19,8 @@ //! * The compiler doesn't understand that the pointer in `FromRawArc` is never //! null, so Option> is not a nullable pointer. -use std::ops::Deref; use std::mem; +use std::ops::Deref; use std::sync::atomic::{self, AtomicUsize, Ordering}; use winapi::OVERLAPPED; @@ -28,8 +28,8 @@ pub struct FromRawArc { _inner: *mut Inner, } -unsafe impl Send for FromRawArc { } -unsafe impl Sync for FromRawArc { } +unsafe impl Send for FromRawArc {} +unsafe impl Sync for FromRawArc {} #[repr(C)] struct Inner { @@ -43,14 +43,18 @@ impl FromRawArc { data: data, cnt: AtomicUsize::new(1), }); - FromRawArc { _inner: unsafe { mem::transmute(x) } } + FromRawArc { + _inner: unsafe { mem::transmute(x) }, + } } pub unsafe fn from_raw(ptr: *mut T) -> FromRawArc { // Note that if we could use `mem::transmute` here to get a libstd Arc // (guaranteed) then we could just use std::sync::Arc, but this is the // crucial reason this currently exists. - FromRawArc { _inner: ptr as *mut Inner } + FromRawArc { + _inner: ptr as *mut Inner, + } } } @@ -62,7 +66,9 @@ impl Clone for FromRawArc { unsafe { (*self._inner).cnt.fetch_add(1, Ordering::Relaxed); } - FromRawArc { _inner: self._inner } + FromRawArc { + _inner: self._inner, + } } } @@ -79,7 +85,7 @@ impl Drop for FromRawArc { unsafe { // Atomic orderings lifted from the standard library if (*self._inner).cnt.fetch_sub(1, Ordering::Release) != 1 { - return + return; } atomic::fence(Ordering::Acquire); drop(mem::transmute::<_, Box>(self._inner)); @@ -87,8 +93,8 @@ impl Drop for FromRawArc { } } -unsafe impl Send for FromRawArcStore { } -unsafe impl Sync for FromRawArcStore { } +unsafe impl Send for FromRawArcStore {} +unsafe impl Sync for FromRawArcStore {} pub struct FromRawArcStore { _ptr: *mut OVERLAPPED, diff --git a/src/sys/windows/mod.rs b/src/sys/windows/mod.rs index dad70b0c1..e9d9cec5e 100644 --- a/src/sys/windows/mod.rs +++ b/src/sys/windows/mod.rs @@ -145,23 +145,23 @@ use winapi; mod awakener; #[macro_use] mod selector; +mod buffer_pool; +mod from_raw_arc; mod tcp; mod udp; -mod from_raw_arc; -mod buffer_pool; pub use self::awakener::Awakener; -pub use self::selector::{Events, Selector, Overlapped, Binding}; -pub use self::tcp::{TcpStream, TcpListener}; +pub use self::selector::{Binding, Events, Overlapped, Selector}; +pub use self::tcp::{TcpListener, TcpStream}; pub use self::udp::UdpSocket; #[derive(Copy, Clone)] enum Family { - V4, V6, + V4, + V6, } -unsafe fn cancel(socket: &AsRawSocket, - overlapped: &Overlapped) -> io::Result<()> { +unsafe fn cancel(socket: &AsRawSocket, overlapped: &Overlapped) -> io::Result<()> { let handle = socket.as_raw_socket() as winapi::HANDLE; let ret = kernel32::CancelIoEx(handle, overlapped.as_mut_ptr()); if ret == 0 { diff --git a/src/sys/windows/selector.rs b/src/sys/windows/selector.rs index d6a9cc826..cb7b02ab5 100644 --- a/src/sys/windows/selector.rs +++ b/src/sys/windows/selector.rs @@ -1,24 +1,24 @@ #![allow(deprecated)] -use std::{fmt, io}; use std::cell::UnsafeCell; +use std::mem; use std::os::windows::prelude::*; -use std::sync::{Arc, Mutex}; use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT}; +use std::sync::{Arc, Mutex}; use std::time::Duration; -use std::mem; +use std::{fmt, io}; use lazycell::AtomicLazyCell; -use winapi::*; use miow; use miow::iocp::{CompletionPort, CompletionStatus}; +use winapi::*; use event_imp::{Event, Evented, Ready}; use poll::{self, Poll}; use sys::windows::buffer_pool::BufferPool; use sys::windows::from_raw_arc::FromRawArcStore; -use {Token, PollOpt}; +use {PollOpt, Token}; /// Each Selector has a globally unique(ish) ID associated with it. This ID /// gets tracked by `TcpStream`, `TcpListener`, etc... when they are first @@ -59,22 +59,22 @@ impl Selector { // offset by 1 to avoid choosing 0 as the id of a selector let id = NEXT_ID.fetch_add(1, Ordering::Relaxed) + 1; - CompletionPort::new(1).map(|cp| { - Selector { - inner: Arc::new(SelectorInner { - id: id, - port: cp, - buffers: Mutex::new(BufferPool::new(256)), - incompletes: Mutex::new(Vec::new()), - }), - } + CompletionPort::new(1).map(|cp| Selector { + inner: Arc::new(SelectorInner { + id: id, + port: cp, + buffers: Mutex::new(BufferPool::new(256)), + incompletes: Mutex::new(Vec::new()), + }), }) } - pub fn select(&self, - events: &mut Events, - awakener: Token, - timeout: Option) -> io::Result { + pub fn select( + &self, + events: &mut Events, + awakener: Token, + timeout: Option, + ) -> io::Result { trace!("select; timeout={:?}", timeout); // Clear out the previous list of I/O events and get some more! @@ -99,21 +99,21 @@ impl Selector { // Deadlock will occur if you don't release it first before the callback. { let mut incompletes = self.inner.incompletes.lock().unwrap(); - let pos = incompletes.iter().position(|item| item.0 == (status.overlapped() as isize)); + let pos = incompletes + .iter() + .position(|item| item.0 == (status.overlapped() as isize)); match pos { Some(pos) => { let store = incompletes.remove(pos); mem::forget(store); - }, + } None => { trace!("cannot find store, omiting..."); } } } - let callback = unsafe { - (*(status.overlapped() as *mut Overlapped)).callback - }; + let callback = unsafe { (*(status.overlapped() as *mut Overlapped)).callback }; trace!("select; -> got overlapped"); callback(status.entry()); @@ -141,7 +141,9 @@ impl Selector { /// Gets a new reference to this selector, although all underlying data /// structures will refer to the same completion port. pub fn clone_ref(&self) -> Selector { - Selector { inner: self.inner.clone() } + Selector { + inner: self.inner.clone(), + } } /// Return the `Selector`'s identifier @@ -186,7 +188,9 @@ impl Binding { /// /// Won't actually do anything until associated with a `Poll` loop. pub fn new() -> Binding { - Binding { selector: AtomicLazyCell::new() } + Binding { + selector: AtomicLazyCell::new(), + } } /// Registers a new handle with the `Poll` specified, also assigning the @@ -205,10 +209,12 @@ impl Binding { /// Specifically they must all be instances of the `Overlapped` type in /// this crate. More information about this can be found on the /// `windows` module in this crate. - pub unsafe fn register_handle(&self, - handle: &AsRawHandle, - token: Token, - poll: &Poll) -> io::Result<()> { + pub unsafe fn register_handle( + &self, + handle: &AsRawHandle, + token: Token, + poll: &Poll, + ) -> io::Result<()> { let selector = poll::selector(poll); // Ignore errors, we'll see them on the next line. @@ -219,10 +225,12 @@ impl Binding { } /// Same as `register_handle` but for sockets. - pub unsafe fn register_socket(&self, - handle: &AsRawSocket, - token: Token, - poll: &Poll) -> io::Result<()> { + pub unsafe fn register_socket( + &self, + handle: &AsRawSocket, + token: Token, + poll: &Poll, + ) -> io::Result<()> { let selector = poll::selector(poll); drop(self.selector.fill(selector.inner.clone())); self.check_same_selector(poll)?; @@ -246,18 +254,22 @@ impl Binding { /// /// This function is unsafe for similar reasons to `register`. That is, /// there may be pending I/O events and such which aren't handled correctly. - pub unsafe fn reregister_handle(&self, - _handle: &AsRawHandle, - _token: Token, - poll: &Poll) -> io::Result<()> { + pub unsafe fn reregister_handle( + &self, + _handle: &AsRawHandle, + _token: Token, + poll: &Poll, + ) -> io::Result<()> { self.check_same_selector(poll) } /// Same as `reregister_handle`, but for sockets. - pub unsafe fn reregister_socket(&self, - _socket: &AsRawSocket, - _token: Token, - poll: &Poll) -> io::Result<()> { + pub unsafe fn reregister_socket( + &self, + _socket: &AsRawSocket, + _token: Token, + poll: &Poll, + ) -> io::Result<()> { self.check_same_selector(poll) } @@ -274,16 +286,12 @@ impl Binding { /// /// This function is unsafe for similar reasons to `register`. That is, /// there may be pending I/O events and such which aren't handled correctly. - pub unsafe fn deregister_handle(&self, - _handle: &AsRawHandle, - poll: &Poll) -> io::Result<()> { + pub unsafe fn deregister_handle(&self, _handle: &AsRawHandle, poll: &Poll) -> io::Result<()> { self.check_same_selector(poll) } /// Same as `deregister_handle`, but for sockets. - pub unsafe fn deregister_socket(&self, - _socket: &AsRawSocket, - poll: &Poll) -> io::Result<()> { + pub unsafe fn deregister_socket(&self, _socket: &AsRawSocket, poll: &Poll) -> io::Result<()> { self.check_same_selector(poll) } @@ -291,16 +299,14 @@ impl Binding { let selector = poll::selector(poll); match self.selector.borrow() { Some(prev) if prev.identical(&selector.inner) => Ok(()), - Some(_) | - None => Err(other("socket already registered")), + Some(_) | None => Err(other("socket already registered")), } } } impl fmt::Debug for Binding { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("Binding") - .finish() + f.debug_struct("Binding").finish() } } @@ -377,14 +383,15 @@ impl ReadyBinding { /// Returns an error if we're already registered with another event loop, /// and otherwise just reassociates ourselves with the event loop to /// possible change tokens. - pub fn register_socket(&mut self, - socket: &AsRawSocket, - poll: &Poll, - token: Token, - events: Ready, - opts: PollOpt, - registration: &Mutex>) - -> io::Result<()> { + pub fn register_socket( + &mut self, + socket: &AsRawSocket, + poll: &Poll, + token: Token, + events: Ready, + opts: PollOpt, + registration: &Mutex>, + ) -> io::Result<()> { trace!("register {:?} {:?}", token, events); unsafe { self.binding.register_socket(socket, token, poll)?; @@ -397,57 +404,61 @@ impl ReadyBinding { } /// Implementation of `Evented::reregister` function. - pub fn reregister_socket(&mut self, - socket: &AsRawSocket, - poll: &Poll, - token: Token, - events: Ready, - opts: PollOpt, - registration: &Mutex>) - -> io::Result<()> { + pub fn reregister_socket( + &mut self, + socket: &AsRawSocket, + poll: &Poll, + token: Token, + events: Ready, + opts: PollOpt, + registration: &Mutex>, + ) -> io::Result<()> { trace!("reregister {:?} {:?}", token, events); unsafe { self.binding.reregister_socket(socket, token, poll)?; } - registration.lock().unwrap() - .as_mut().unwrap() - .reregister(poll, token, events, opts) + registration + .lock() + .unwrap() + .as_mut() + .unwrap() + .reregister(poll, token, events, opts) } /// Implementation of the `Evented::deregister` function. /// /// Doesn't allow registration with another event loop, just shuts down /// readiness notifications and such. - pub fn deregister(&mut self, - socket: &AsRawSocket, - poll: &Poll, - registration: &Mutex>) - -> io::Result<()> { + pub fn deregister( + &mut self, + socket: &AsRawSocket, + poll: &Poll, + registration: &Mutex>, + ) -> io::Result<()> { trace!("deregistering"); unsafe { self.binding.deregister_socket(socket, poll)?; } - registration.lock().unwrap() - .as_ref().unwrap() - .deregister(poll) + registration + .lock() + .unwrap() + .as_ref() + .unwrap() + .deregister(poll) } pub fn store_overlapped_content(&self, ptr: *mut OVERLAPPED, deallocator: fn(*mut OVERLAPPED)) { if let Some(i) = self.binding.selector.borrow() { - let selector = Selector { - inner: i.clone(), - }; + let selector = Selector { inner: i.clone() }; selector.store_overlapped_content(ptr, deallocator); } } pub fn clean_overlapped_content(&self, ptr: *mut OVERLAPPED) { if let Some(i) = self.binding.selector.borrow() { - let selector = Selector { - inner: i.clone(), - }; + let selector = Selector { inner: i.clone() }; selector.clean_overlapped_content(ptr); } } @@ -561,16 +572,13 @@ impl Overlapped { /// This can be useful when only a shared borrow is held and the overlapped /// pointer needs to be passed down to winapi. pub fn as_mut_ptr(&self) -> *mut OVERLAPPED { - unsafe { - (*self.inner.get()).raw() - } + unsafe { (*self.inner.get()).raw() } } } impl fmt::Debug for Overlapped { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("Overlapped") - .finish() + f.debug_struct("Overlapped").finish() } } diff --git a/src/sys/windows/tcp.rs b/src/sys/windows/tcp.rs index b542e2a06..6df9d7866 100644 --- a/src/sys/windows/tcp.rs +++ b/src/sys/windows/tcp.rs @@ -1,22 +1,22 @@ use std::fmt; -use std::io::{self, Read, ErrorKind}; +use std::io::{self, ErrorKind, Read}; use std::mem; -use std::net::{self, SocketAddr, Shutdown}; +use std::net::{self, Shutdown, SocketAddr}; use std::os::windows::prelude::*; use std::sync::{Mutex, MutexGuard}; use std::time::Duration; +use iovec::IoVec; use miow::iocp::CompletionStatus; use miow::net::*; use net2::{TcpBuilder, TcpStreamExt as Net2TcpExt}; use winapi::*; -use iovec::IoVec; -use {poll, Ready, Poll, PollOpt, Token}; use event::Evented; use sys::windows::from_raw_arc::FromRawArc; use sys::windows::selector::{Overlapped, ReadyBinding}; use sys::windows::Family; +use {poll, Poll, PollOpt, Ready, Token}; pub struct TcpStream { /// Separately stored implementation to ensure that the `Drop` @@ -85,15 +85,14 @@ struct ListenerInner { } enum State { - Empty, // no I/O operation in progress - Pending(T), // an I/O operation is in progress - Ready(U), // I/O has finished with this value - Error(io::Error), // there was an I/O error + Empty, // no I/O operation in progress + Pending(T), // an I/O operation is in progress + Ready(U), // I/O has finished with this value + Error(io::Error), // there was an I/O error } impl TcpStream { - fn new(socket: net::TcpStream, - deferred_connect: Option) -> TcpStream { + fn new(socket: net::TcpStream, deferred_connect: Option) -> TcpStream { TcpStream { registration: Mutex::new(None), imp: StreamImp { @@ -113,8 +112,7 @@ impl TcpStream { } } - pub fn connect(socket: net::TcpStream, addr: &SocketAddr) - -> io::Result { + pub fn connect(socket: net::TcpStream, addr: &SocketAddr) -> io::Result { socket.set_nonblocking(true)?; Ok(TcpStream::new(socket, Some(*addr))) } @@ -132,7 +130,11 @@ impl TcpStream { } pub fn try_clone(&self) -> io::Result { - self.imp.inner.socket.try_clone().map(|s| TcpStream::new(s, None)) + self.imp + .inner + .socket + .try_clone() + .map(|s| TcpStream::new(s, None)) } pub fn shutdown(&self, how: Shutdown) -> io::Result<()> { @@ -197,7 +199,7 @@ impl TcpStream { pub fn take_error(&self) -> io::Result> { if let Some(e) = self.imp.inner.socket.take_error()? { - return Ok(Some(e)) + return Ok(Some(e)); } // If the syscall didn't return anything then also check to see if we've @@ -236,8 +238,7 @@ impl TcpStream { match me.read { // Empty == we're not associated yet, and if we're pending then // these are both cases where we return "would block" - State::Empty | - State::Pending(()) => return Err(io::ErrorKind::WouldBlock.into()), + State::Empty | State::Pending(()) => return Err(io::ErrorKind::WouldBlock.into()), // If we got a delayed error as part of a `read_overlapped` below, // return that here. Also schedule another read in case it was @@ -248,7 +249,7 @@ impl TcpStream { _ => panic!(), }; self.imp.schedule_read(&mut me); - return Err(e) + return Err(e); } // If we're ready for a read then some previous 0-byte read has @@ -331,14 +332,14 @@ impl TcpStream { if amt > 0 && e.kind() == io::ErrorKind::WouldBlock { me.read = State::Empty; self.imp.schedule_read(&mut me); - return Ok(amt) + return Ok(amt); } else if amt > 0 { me.read = State::Error(e); - return Ok(amt) + return Ok(amt); } else { me.read = State::Empty; self.imp.schedule_read(&mut me); - return Err(e) + return Err(e); } } } @@ -363,16 +364,16 @@ impl TcpStream { State::Error(e) => return Err(e), other => { me.write = other; - return Err(io::ErrorKind::WouldBlock.into()) + return Err(io::ErrorKind::WouldBlock.into()); } } if !me.iocp.registered() { - return Err(io::ErrorKind::WouldBlock.into()) + return Err(io::ErrorKind::WouldBlock.into()); } if bufs.len() == 0 { - return Ok(0) + return Ok(0); } let len = bufs.iter().map(|b| b.len()).fold(0, |a, b| a + b); @@ -397,11 +398,14 @@ impl StreamImp { fn schedule_connect(&self, addr: &SocketAddr, me: &mut StreamInner) -> io::Result<()> { unsafe { trace!("scheduling a connect"); - self.inner.socket.connect_overlapped(addr, &[], self.inner.read.as_mut_ptr())?; + self.inner + .socket + .connect_overlapped(addr, &[], self.inner.read.as_mut_ptr())?; } // see docs above on StreamImp.inner for rationale on forget mem::forget(self.clone()); - me.iocp.store_overlapped_content(self.inner.read.as_mut_ptr(), read_deallocate); + me.iocp + .store_overlapped_content(self.inner.read.as_mut_ptr(), read_deallocate); Ok(()) } @@ -422,11 +426,14 @@ impl StreamImp { _ => return, } - me.iocp.set_readiness(me.iocp.readiness() - Ready::readable()); + me.iocp + .set_readiness(me.iocp.readiness() - Ready::readable()); trace!("scheduling a read"); let res = unsafe { - self.inner.socket.read_overlapped(&mut [], self.inner.read.as_mut_ptr()) + self.inner + .socket + .read_overlapped(&mut [], self.inner.read.as_mut_ptr()) }; match res { // Note that `Ok(true)` means that this completed immediately and @@ -455,7 +462,8 @@ impl StreamImp { // see docs above on StreamImp.inner for rationale on forget me.read = State::Pending(()); mem::forget(self.clone()); - me.iocp.store_overlapped_content(self.inner.read.as_mut_ptr(), read_deallocate); + me.iocp + .store_overlapped_content(self.inner.read.as_mut_ptr(), read_deallocate); } Err(e) => { me.read = State::Error(e); @@ -473,18 +481,17 @@ impl StreamImp { /// /// A new writable event (e.g. allowing another write) will only happen once /// the buffer has been written completely (or hit an error). - fn schedule_write(&self, - buf: Vec, - mut pos: usize, - me: &mut StreamInner) { - + fn schedule_write(&self, buf: Vec, mut pos: usize, me: &mut StreamInner) { // About to write, clear any pending level triggered events - me.iocp.set_readiness(me.iocp.readiness() - Ready::writable()); + me.iocp + .set_readiness(me.iocp.readiness() - Ready::writable()); loop { trace!("scheduling a write of {} bytes", buf[pos..].len()); let ret = unsafe { - self.inner.socket.write_overlapped(&buf[pos..], self.inner.write.as_mut_ptr()) + self.inner + .socket + .write_overlapped(&buf[pos..], self.inner.write.as_mut_ptr()) }; match ret { Ok(Some(transferred_bytes)) if me.instant_notify => { @@ -501,7 +508,8 @@ impl StreamImp { // see docs above on StreamImp.inner for rationale on forget me.write = State::Pending((buf, pos)); mem::forget(self.clone()); - me.iocp.store_overlapped_content(self.inner.write.as_mut_ptr(), write_deallocate); + me.iocp + .store_overlapped_content(self.inner.write.as_mut_ptr(), write_deallocate); break; } Err(e) => { @@ -537,7 +545,7 @@ fn read_done(status: &OVERLAPPED_ENTRY) { trace!("finished a read: {}", status.bytes_transferred()); assert_eq!(status.bytes_transferred(), 0); me.read = State::Ready(()); - return me2.add_readiness(&mut me, Ready::readable()) + return me2.add_readiness(&mut me, Ready::readable()); } s => me.read = s, } @@ -596,11 +604,22 @@ fn write_deallocate(ptr: *mut OVERLAPPED) { } impl Evented for TcpStream { - fn register(&self, poll: &Poll, token: Token, - interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { let mut me = self.inner(); - me.iocp.register_socket(&self.imp.inner.socket, poll, token, - interest, opts, &self.registration)?; + me.iocp.register_socket( + &self.imp.inner.socket, + poll, + token, + interest, + opts, + &self.registration, + )?; unsafe { super::no_notify_on_instant_completion(self.imp.inner.socket.as_raw_socket() as HANDLE)?; @@ -612,31 +631,42 @@ impl Evented for TcpStream { // successful connect will worry about generating writable/readable // events and scheduling a new read. if let Some(addr) = me.deferred_connect.take() { - return self.imp.schedule_connect(&addr, &mut me).map(|_| ()) + return self.imp.schedule_connect(&addr, &mut me).map(|_| ()); } self.post_register(interest, &mut me); Ok(()) } - fn reregister(&self, poll: &Poll, token: Token, - interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { let mut me = self.inner(); - me.iocp.reregister_socket(&self.imp.inner.socket, poll, token, - interest, opts, &self.registration)?; + me.iocp.reregister_socket( + &self.imp.inner.socket, + poll, + token, + interest, + opts, + &self.registration, + )?; self.post_register(interest, &mut me); Ok(()) } fn deregister(&self, poll: &Poll) -> io::Result<()> { - self.inner().iocp.deregister(&self.imp.inner.socket, - poll, &self.registration) + self.inner() + .iocp + .deregister(&self.imp.inner.socket, poll, &self.registration) } } impl fmt::Debug for TcpStream { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("TcpStream") - .finish() + f.debug_struct("TcpStream").finish() } } @@ -653,11 +683,14 @@ impl Drop for TcpStream { match inner.read { State::Pending(_) | State::Empty => { trace!("cancelling active TCP read"); - drop(super::cancel(&self.imp.inner.socket, - &self.imp.inner.read)); + drop(super::cancel(&self.imp.inner.socket, &self.imp.inner.read)); trace!("cleaning remaining overlapped contents"); - inner.iocp.clean_overlapped_content(self.imp.inner.read.as_mut_ptr()); - inner.iocp.clean_overlapped_content(self.imp.inner.write.as_mut_ptr()); + inner + .iocp + .clean_overlapped_content(self.imp.inner.read.as_mut_ptr()); + inner + .iocp + .clean_overlapped_content(self.imp.inner.write.as_mut_ptr()); } State::Ready(_) | State::Error(_) => {} } @@ -666,13 +699,15 @@ impl Drop for TcpStream { } impl TcpListener { - pub fn new(socket: net::TcpListener) - -> io::Result { + pub fn new(socket: net::TcpListener) -> io::Result { let addr = socket.local_addr()?; - Ok(TcpListener::new_family(socket, match addr { - SocketAddr::V4(..) => Family::V4, - SocketAddr::V6(..) => Family::V6, - })) + Ok(TcpListener::new_family( + socket, + match addr { + SocketAddr::V4(..) => Family::V4, + SocketAddr::V6(..) => Family::V6, + }, + )) } fn new_family(socket: net::TcpListener, family: Family) -> TcpListener { @@ -709,7 +744,7 @@ impl TcpListener { self.imp.schedule_accept(&mut me); - return ret + return ret; } pub fn local_addr(&self) -> io::Result { @@ -717,9 +752,11 @@ impl TcpListener { } pub fn try_clone(&self) -> io::Result { - self.imp.inner.socket.try_clone().map(|s| { - TcpListener::new_family(s, self.imp.inner.family) - }) + self.imp + .inner + .socket + .try_clone() + .map(|s| TcpListener::new_family(s, self.imp.inner.family)) } #[allow(deprecated)] @@ -757,25 +794,30 @@ impl ListenerImp { fn schedule_accept(&self, me: &mut ListenerInner) { match me.accept { State::Empty => {} - _ => return + _ => return, } - me.iocp.set_readiness(me.iocp.readiness() - Ready::readable()); + me.iocp + .set_readiness(me.iocp.readiness() - Ready::readable()); let res = match self.inner.family { Family::V4 => TcpBuilder::new_v4(), Family::V6 => TcpBuilder::new_v6(), }.and_then(|builder| unsafe { trace!("scheduling an accept"); - self.inner.socket.accept_overlapped(&builder, &mut me.accept_buf, - self.inner.accept.as_mut_ptr()) + self.inner.socket.accept_overlapped( + &builder, + &mut me.accept_buf, + self.inner.accept.as_mut_ptr(), + ) }); match res { Ok((socket, _)) => { // see docs above on StreamImp.inner for rationale on forget me.accept = State::Pending(socket); mem::forget(self.clone()); - me.iocp.store_overlapped_content(self.inner.accept.as_mut_ptr(), accept_dellocate); + me.iocp + .store_overlapped_content(self.inner.accept.as_mut_ptr(), accept_dellocate); } Err(e) => { me.accept = State::Error(e); @@ -802,13 +844,15 @@ fn accept_done(status: &OVERLAPPED_ENTRY) { _ => unreachable!(), }; trace!("finished an accept"); - let result = me2.inner.socket.accept_complete(&socket).and_then(|()| { - me.accept_buf.parse(&me2.inner.socket) - }).and_then(|buf| { - buf.remote().ok_or_else(|| { - io::Error::new(ErrorKind::Other, "could not obtain remote address") - }) - }); + let result = me2 + .inner + .socket + .accept_complete(&socket) + .and_then(|()| me.accept_buf.parse(&me2.inner.socket)) + .and_then(|buf| { + buf.remote() + .ok_or_else(|| io::Error::new(ErrorKind::Other, "could not obtain remote address")) + }); me.accept = match result { Ok(remote_addr) => State::Ready((socket, remote_addr)), Err(e) => State::Error(e), @@ -824,11 +868,22 @@ fn accept_dellocate(ptr: *mut OVERLAPPED) { } impl Evented for TcpListener { - fn register(&self, poll: &Poll, token: Token, - interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { let mut me = self.inner(); - me.iocp.register_socket(&self.imp.inner.socket, poll, token, - interest, opts, &self.registration)?; + me.iocp.register_socket( + &self.imp.inner.socket, + poll, + token, + interest, + opts, + &self.registration, + )?; unsafe { super::no_notify_on_instant_completion(self.imp.inner.socket.as_raw_socket() as HANDLE)?; @@ -839,25 +894,36 @@ impl Evented for TcpListener { Ok(()) } - fn reregister(&self, poll: &Poll, token: Token, - interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { let mut me = self.inner(); - me.iocp.reregister_socket(&self.imp.inner.socket, poll, token, - interest, opts, &self.registration)?; + me.iocp.reregister_socket( + &self.imp.inner.socket, + poll, + token, + interest, + opts, + &self.registration, + )?; self.imp.schedule_accept(&mut me); Ok(()) } fn deregister(&self, poll: &Poll) -> io::Result<()> { - self.inner().iocp.deregister(&self.imp.inner.socket, - poll, &self.registration) + self.inner() + .iocp + .deregister(&self.imp.inner.socket, poll, &self.registration) } } impl fmt::Debug for TcpListener { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("TcpListener") - .finish() + f.debug_struct("TcpListener").finish() } } @@ -869,14 +935,16 @@ impl Drop for TcpListener { match inner.accept { State::Pending(_) => { trace!("cancelling active TCP accept"); - drop(super::cancel(&self.imp.inner.socket, - &self.imp.inner.accept)); + drop(super::cancel( + &self.imp.inner.socket, + &self.imp.inner.accept, + )); trace!("cleaning remaining overlapped contents"); - inner.iocp.clean_overlapped_content(self.imp.inner.accept.as_mut_ptr()); + inner + .iocp + .clean_overlapped_content(self.imp.inner.accept.as_mut_ptr()); } - State::Empty | - State::Ready(_) | - State::Error(_) => {} + State::Empty | State::Ready(_) | State::Error(_) => {} } } } diff --git a/src/sys/windows/udp.rs b/src/sys/windows/udp.rs index 2e34a2458..dc6ee7aaf 100644 --- a/src/sys/windows/udp.rs +++ b/src/sys/windows/udp.rs @@ -4,23 +4,23 @@ //! something seems odd you may also want to try the docs over there. use std::fmt; -use std::io::prelude::*; use std::io; +use std::io::prelude::*; use std::mem; use std::net::{self, Ipv4Addr, Ipv6Addr, SocketAddr}; use std::sync::{Mutex, MutexGuard}; -#[allow(unused_imports)] -use net2::{UdpBuilder, UdpSocketExt}; -use winapi::*; use miow::iocp::CompletionStatus; use miow::net::SocketAddrBuf; use miow::net::UdpSocketExt as MiowUdpSocketExt; +#[allow(unused_imports)] +use net2::{UdpBuilder, UdpSocketExt}; +use winapi::*; -use {poll, Ready, Poll, PollOpt, Token}; use event::Evented; use sys::windows::from_raw_arc::FromRawArc; use sys::windows::selector::{Overlapped, ReadyBinding}; +use {poll, Poll, PollOpt, Ready, Token}; pub struct UdpSocket { imp: Imp, @@ -87,8 +87,7 @@ impl UdpSocket { /// TODO: This... may be wrong in the long run. We're reporting that we /// successfully wrote all of the bytes in `buf` but it's possible /// that we don't actually end up writing all of them! - pub fn send_to(&self, buf: &[u8], target: &SocketAddr) - -> io::Result { + pub fn send_to(&self, buf: &[u8], target: &SocketAddr) -> io::Result { let mut me = self.inner(); let me = &mut *me; @@ -98,7 +97,7 @@ impl UdpSocket { } if !me.iocp.registered() { - return Err(io::ErrorKind::WouldBlock.into()) + return Err(io::ErrorKind::WouldBlock.into()); } let interest = me.iocp.readiness(); @@ -108,12 +107,16 @@ impl UdpSocket { let amt = owned_buf.write(buf)?; unsafe { trace!("scheduling a send"); - self.imp.inner.socket.send_to_overlapped(&owned_buf, target, - self.imp.inner.write.as_mut_ptr()) + self.imp.inner.socket.send_to_overlapped( + &owned_buf, + target, + self.imp.inner.write.as_mut_ptr(), + ) }?; me.write = State::Pending(owned_buf); mem::forget(self.imp.clone()); - me.iocp.store_overlapped_content(self.imp.inner.write.as_mut_ptr(), send_deallocate); + me.iocp + .store_overlapped_content(self.imp.inner.write.as_mut_ptr(), send_deallocate); Ok(amt) } @@ -133,7 +136,7 @@ impl UdpSocket { } if !me.iocp.registered() { - return Err(io::ErrorKind::WouldBlock.into()) + return Err(io::ErrorKind::WouldBlock.into()); } let interest = me.iocp.readiness(); @@ -143,12 +146,15 @@ impl UdpSocket { let amt = owned_buf.write(buf)?; unsafe { trace!("scheduling a send"); - self.imp.inner.socket.send_overlapped(&owned_buf, self.imp.inner.write.as_mut_ptr()) - + self.imp + .inner + .socket + .send_overlapped(&owned_buf, self.imp.inner.write.as_mut_ptr()) }?; me.write = State::Pending(owned_buf); mem::forget(self.imp.clone()); - me.iocp.store_overlapped_content(self.imp.inner.write.as_mut_ptr(), send_deallocate); + me.iocp + .store_overlapped_content(self.imp.inner.write.as_mut_ptr(), send_deallocate); Ok(amt) } @@ -156,7 +162,10 @@ impl UdpSocket { let mut me = self.inner(); match mem::replace(&mut me.read, State::Empty) { State::Empty => Err(io::ErrorKind::WouldBlock.into()), - State::Pending(b) => { me.read = State::Pending(b); Err(io::ErrorKind::WouldBlock.into()) } + State::Pending(b) => { + me.read = State::Pending(b); + Err(io::ErrorKind::WouldBlock.into()) + } State::Ready(data) => { // If we weren't provided enough space to receive the message // then don't actually read any data, just return an error. @@ -168,8 +177,10 @@ impl UdpSocket { buf.write(&data).unwrap(); Ok((data.len(), addr)) } else { - Err(io::Error::new(io::ErrorKind::Other, - "failed to parse socket address")) + Err(io::Error::new( + io::ErrorKind::Other, + "failed to parse socket address", + )) }; me.iocp.put_buffer(data); self.imp.schedule_read_from(&mut me); @@ -183,10 +194,9 @@ impl UdpSocket { } } - pub fn recv(&self, buf: &mut [u8]) - -> io::Result { + pub fn recv(&self, buf: &mut [u8]) -> io::Result { //Since recv_from can be used on connected sockets just call it and drop the address. - self.recv_from(buf).map(|(size,_)| size) + self.recv_from(buf).map(|(size, _)| size) } pub fn connect(&self, addr: SocketAddr) -> io::Result<()> { @@ -233,28 +243,32 @@ impl UdpSocket { self.imp.inner.socket.set_ttl(ttl) } - pub fn join_multicast_v4(&self, - multiaddr: &Ipv4Addr, - interface: &Ipv4Addr) -> io::Result<()> { - self.imp.inner.socket.join_multicast_v4(multiaddr, interface) + pub fn join_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> { + self.imp + .inner + .socket + .join_multicast_v4(multiaddr, interface) } - pub fn join_multicast_v6(&self, - multiaddr: &Ipv6Addr, - interface: u32) -> io::Result<()> { - self.imp.inner.socket.join_multicast_v6(multiaddr, interface) + pub fn join_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> { + self.imp + .inner + .socket + .join_multicast_v6(multiaddr, interface) } - pub fn leave_multicast_v4(&self, - multiaddr: &Ipv4Addr, - interface: &Ipv4Addr) -> io::Result<()> { - self.imp.inner.socket.leave_multicast_v4(multiaddr, interface) + pub fn leave_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> { + self.imp + .inner + .socket + .leave_multicast_v4(multiaddr, interface) } - pub fn leave_multicast_v6(&self, - multiaddr: &Ipv6Addr, - interface: u32) -> io::Result<()> { - self.imp.inner.socket.leave_multicast_v6(multiaddr, interface) + pub fn leave_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> { + self.imp + .inner + .socket + .leave_multicast_v6(multiaddr, interface) } pub fn set_only_v6(&self, only_v6: bool) -> io::Result<()> { @@ -308,14 +322,18 @@ impl Imp { trace!("scheduling a read"); let cap = buf.capacity(); buf.set_len(cap); - self.inner.socket.recv_from_overlapped(&mut buf, &mut me.read_buf, - self.inner.read.as_mut_ptr()) + self.inner.socket.recv_from_overlapped( + &mut buf, + &mut me.read_buf, + self.inner.read.as_mut_ptr(), + ) }; match res { Ok(_) => { me.read = State::Pending(buf); mem::forget(self.clone()); - me.iocp.store_overlapped_content(self.inner.read.as_mut_ptr(), recv_deallocate); + me.iocp + .store_overlapped_content(self.inner.read.as_mut_ptr(), recv_deallocate); } Err(e) => { me.read = State::Error(e); @@ -332,36 +350,56 @@ impl Imp { } impl Evented for UdpSocket { - fn register(&self, poll: &Poll, token: Token, - interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { let mut me = self.inner(); - me.iocp.register_socket(&self.imp.inner.socket, - poll, token, interest, opts, - &self.registration)?; + me.iocp.register_socket( + &self.imp.inner.socket, + poll, + token, + interest, + opts, + &self.registration, + )?; self.post_register(interest, &mut me); Ok(()) } - fn reregister(&self, poll: &Poll, token: Token, - interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { let mut me = self.inner(); - me.iocp.reregister_socket(&self.imp.inner.socket, - poll, token, interest, - opts, &self.registration)?; + me.iocp.reregister_socket( + &self.imp.inner.socket, + poll, + token, + interest, + opts, + &self.registration, + )?; self.post_register(interest, &mut me); Ok(()) } fn deregister(&self, poll: &Poll) -> io::Result<()> { - self.inner().iocp.deregister(&self.imp.inner.socket, - poll, &self.registration) + self.inner() + .iocp + .deregister(&self.imp.inner.socket, poll, &self.registration) } } impl fmt::Debug for UdpSocket { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("UdpSocket") - .finish() + f.debug_struct("UdpSocket").finish() } } @@ -375,12 +413,9 @@ impl Drop for UdpSocket { unsafe { match inner.read { State::Pending(_) => { - drop(super::cancel(&self.imp.inner.socket, - &self.imp.inner.read)); + drop(super::cancel(&self.imp.inner.socket, &self.imp.inner.read)); } - State::Empty | - State::Ready(_) | - State::Error(_) => {} + State::Empty | State::Ready(_) | State::Error(_) => {} } } } @@ -427,4 +462,4 @@ fn recv_deallocate(ptr: *mut OVERLAPPED) { inner: unsafe { overlapped2arc!(ptr, Io, read) }, }; drop(me); -} \ No newline at end of file +} diff --git a/src/timer.rs b/src/timer.rs index 0b762ea38..63d0324a6 100644 --- a/src/timer.rs +++ b/src/timer.rs @@ -2,14 +2,14 @@ #![allow(deprecated, missing_debug_implementations)] -use {convert, io, Ready, Poll, PollOpt, Registration, SetReadiness, Token}; use event::Evented; use lazycell::LazyCell; use slab::Slab; -use std::{cmp, error, fmt, u64, usize, iter, thread}; -use std::sync::Arc; use std::sync::atomic::{AtomicUsize, Ordering}; +use std::sync::Arc; use std::time::{Duration, Instant}; +use std::{cmp, error, fmt, iter, thread, u64, usize}; +use {convert, io, Poll, PollOpt, Ready, Registration, SetReadiness, Token}; use self::TimerErrorKind::TimerOverflow; @@ -83,7 +83,7 @@ struct Entry { struct EntryLinks { tick: Tick, prev: Token, - next: Token + next: Token, } type Tick = u64; @@ -97,7 +97,6 @@ pub type Result = ::std::result::Result; // TODO: remove pub type TimerResult = Result; - /// Deprecated and unused. #[derive(Debug)] pub struct TimerError; @@ -131,7 +130,12 @@ impl Builder { } pub fn build(self) -> Timer { - Timer::new(convert::millis(self.tick), self.num_slots, self.capacity, Instant::now()) + Timer::new( + convert::millis(self.tick), + self.num_slots, + self.capacity, + Instant::now(), + ) } } @@ -150,8 +154,11 @@ impl Timer { let num_slots = num_slots.next_power_of_two(); let capacity = capacity.next_power_of_two(); let mask = (num_slots as u64) - 1; - let wheel = iter::repeat(WheelEntry { next_tick: TICK_MAX, head: EMPTY }) - .take(num_slots).collect(); + let wheel = iter::repeat(WheelEntry { + next_tick: TICK_MAX, + head: EMPTY, + }).take(num_slots) + .collect(); Timer { tick_ms: tick_ms, @@ -172,7 +179,12 @@ impl Timer { fn set_timeout_at(&mut self, delay_from_start: Duration, state: T) -> Result { let mut tick = duration_to_tick(delay_from_start, self.tick_ms); - trace!("setting timeout; delay={:?}; tick={:?}; current-tick={:?}", delay_from_start, tick, self.tick); + trace!( + "setting timeout; delay={:?}; tick={:?}; current-tick={:?}", + delay_from_start, + tick, + self.tick + ); // Always target at least 1 tick in the future if tick <= self.tick { @@ -210,14 +222,14 @@ impl Timer { // Return the new timeout Ok(Timeout { token: token, - tick: tick + tick: tick, }) } pub fn cancel_timeout(&mut self, timeout: &Timeout) -> Option { let links = match self.entries.get(timeout.token.into()) { Some(e) => e.links, - None => return None + None => return None, }; // Sanity check @@ -235,7 +247,11 @@ impl Timer { } fn poll_to(&mut self, mut target_tick: Tick) -> Option { - trace!("tick_to; target_tick={}; current_tick={}", target_tick, self.tick); + trace!( + "tick_to; target_tick={}; current_tick={}", + target_tick, + self.tick + ); if target_tick < self.tick { target_tick = self.tick; @@ -299,8 +315,11 @@ impl Timer { } fn unlink(&mut self, links: &EntryLinks, token: Token) { - trace!("unlinking timeout; slot={}; token={:?}", - self.slot_for(links.tick), token); + trace!( + "unlinking timeout; slot={}; token={:?}", + self.slot_for(links.tick), + token + ); if links.prev == EMPTY { let slot = self.slot_for(links.tick); @@ -333,7 +352,10 @@ impl Timer { // Attempt to move the wakeup time forward trace!("advancing the wakeup time; target={}; curr={}", tick, curr); - let actual = inner.wakeup_state.compare_and_swap(curr, tick as usize, Ordering::Release); + let actual = + inner + .wakeup_state + .compare_and_swap(curr, tick as usize, Ordering::Release); if actual == curr { // Signal to the wakeup thread that the wakeup time has @@ -374,9 +396,18 @@ impl Default for Timer { } impl Evented for Timer { - fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { if self.inner.borrow().is_some() { - return Err(io::Error::new(io::ErrorKind::Other, "timer already registered")); + return Err(io::Error::new( + io::ErrorKind::Other, + "timer already registered", + )); } let (registration, set_readiness) = Registration::new(poll, token, interest, opts); @@ -384,14 +415,18 @@ impl Evented for Timer { let thread_handle = spawn_wakeup_thread( wakeup_state.clone(), set_readiness.clone(), - self.start, self.tick_ms); - - self.inner.fill(Inner { - registration: registration, - set_readiness: set_readiness, - wakeup_state: wakeup_state, - wakeup_thread: thread_handle, - }).ok().expect("timer already registered"); + self.start, + self.tick_ms, + ); + + self.inner + .fill(Inner { + registration: registration, + set_readiness: set_readiness, + wakeup_state: wakeup_state, + wakeup_thread: thread_handle, + }).ok() + .expect("timer already registered"); if let Some(next_tick) = self.next_tick() { self.schedule_readiness(next_tick); @@ -400,17 +435,29 @@ impl Evented for Timer { Ok(()) } - fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { match self.inner.borrow() { Some(inner) => inner.registration.update(poll, token, interest, opts), - None => Err(io::Error::new(io::ErrorKind::Other, "receiver not registered")), + None => Err(io::Error::new( + io::ErrorKind::Other, + "receiver not registered", + )), } } fn deregister(&self, poll: &Poll) -> io::Result<()> { match self.inner.borrow() { Some(inner) => inner.registration.deregister(poll), - None => Err(io::Error::new(io::ErrorKind::Other, "receiver not registered")), + None => Err(io::Error::new( + io::ErrorKind::Other, + "receiver not registered", + )), } } } @@ -424,7 +471,12 @@ impl fmt::Debug for Inner { } } -fn spawn_wakeup_thread(state: WakeupState, set_readiness: SetReadiness, start: Instant, tick_ms: u64) -> thread::JoinHandle<()> { +fn spawn_wakeup_thread( + state: WakeupState, + set_readiness: SetReadiness, + start: Instant, + tick_ms: u64, +) -> thread::JoinHandle<()> { thread::spawn(move || { let mut sleep_until_tick = state.load(Ordering::Acquire) as Tick; @@ -435,7 +487,11 @@ fn spawn_wakeup_thread(state: WakeupState, set_readiness: SetReadiness, start: I let now_tick = current_tick(start, tick_ms); - trace!("wakeup thread: sleep_until_tick={:?}; now_tick={:?}", sleep_until_tick, now_tick); + trace!( + "wakeup thread: sleep_until_tick={:?}; now_tick={:?}", + sleep_until_tick, + now_tick + ); if now_tick < sleep_until_tick { // Calling park_timeout with u64::MAX leads to undefined @@ -444,19 +500,29 @@ fn spawn_wakeup_thread(state: WakeupState, set_readiness: SetReadiness, start: I // on large values, simply use a blocking park. match tick_ms.checked_mul(sleep_until_tick - now_tick) { Some(sleep_duration) => { - trace!("sleeping; tick_ms={}; now_tick={}; sleep_until_tick={}; duration={:?}", - tick_ms, now_tick, sleep_until_tick, sleep_duration); + trace!( + "sleeping; tick_ms={}; now_tick={}; sleep_until_tick={}; duration={:?}", + tick_ms, + now_tick, + sleep_until_tick, + sleep_duration + ); thread::park_timeout(Duration::from_millis(sleep_duration)); } None => { - trace!("sleeping; tick_ms={}; now_tick={}; blocking sleep", - tick_ms, now_tick); + trace!( + "sleeping; tick_ms={}; now_tick={}; blocking sleep", + tick_ms, + now_tick + ); thread::park(); } } sleep_until_tick = state.load(Ordering::Acquire) as Tick; } else { - let actual = state.compare_and_swap(sleep_until_tick as usize, usize::MAX, Ordering::AcqRel) as Tick; + let actual = + state.compare_and_swap(sleep_until_tick as usize, usize::MAX, Ordering::AcqRel) + as Tick; if actual == sleep_until_tick { trace!("setting readiness from wakeup thread"); diff --git a/src/udp.rs b/src/udp.rs index a71bd2191..3601061ce 100644 --- a/src/udp.rs +++ b/src/udp.rs @@ -9,11 +9,11 @@ #![allow(deprecated)] -use {sys, Ready, Poll, PollOpt, Token}; -use io::{self, MapNonBlock}; use event::Evented; +use io::{self, MapNonBlock}; use poll::SelectorId; use std::net::{self, Ipv4Addr, Ipv6Addr, SocketAddr}; +use {sys, Poll, PollOpt, Ready, Token}; /// A User Datagram Protocol socket. /// @@ -61,13 +61,10 @@ impl UdpSocket { /// object references. Both handles will read and write the same port, and /// options set on one socket will be propagated to the other. pub fn try_clone(&self) -> io::Result { - self.sys.try_clone() - .map(|s| { - UdpSocket { - sys: s, - selector_id: self.selector_id.clone(), - } - }) + self.sys.try_clone().map(|s| UdpSocket { + sys: s, + selector_id: self.selector_id.clone(), + }) } /// Sends data on the socket to the given address. On success, returns the @@ -75,8 +72,7 @@ impl UdpSocket { /// /// Address type can be any implementor of `ToSocketAddrs` trait. See its /// documentation for concrete examples. - pub fn send_to(&self, buf: &[u8], target: &SocketAddr) - -> io::Result> { + pub fn send_to(&self, buf: &[u8], target: &SocketAddr) -> io::Result> { self.sys.send_to(buf, target).map_non_block() } @@ -91,15 +87,13 @@ impl UdpSocket { /// /// Assuming the function has read `n` bytes, slicing `&buf[..n]` provides /// efficient access with iterators and boundary checks. - pub fn recv_from(&self, buf: &mut [u8]) - -> io::Result> { + pub fn recv_from(&self, buf: &mut [u8]) -> io::Result> { self.sys.recv_from(buf).map_non_block() } /// Sends data on the socket to the address previously bound via connect(). On success, /// returns the number of bytes written. - pub fn send(&self, buf: &[u8]) - -> io::Result> { + pub fn send(&self, buf: &[u8]) -> io::Result> { self.sys.send(buf).map_non_block() } @@ -114,16 +108,14 @@ impl UdpSocket { /// /// Assuming the function has read `n` bytes, slicing `&buf[..n]` provides /// efficient access with iterators and boundary checks. - pub fn recv(&self, buf: &mut [u8]) - -> io::Result> { + pub fn recv(&self, buf: &mut [u8]) -> io::Result> { self.sys.recv(buf).map_non_block() } - /// Connects the UDP socket setting the default destination for `send()` + /// Connects the UDP socket setting the default destination for `send()` /// and limiting packets that are read via `recv` from the address specified /// in `addr`. - pub fn connect(&self, addr: SocketAddr) - -> io::Result<()> { + pub fn connect(&self, addr: SocketAddr) -> io::Result<()> { self.sys.connect(addr) } @@ -226,9 +218,7 @@ impl UdpSocket { /// address of the local interface with which the system should join the /// multicast group. If it's equal to `INADDR_ANY` then an appropriate /// interface is chosen by the system. - pub fn join_multicast_v4(&self, - multiaddr: &Ipv4Addr, - interface: &Ipv4Addr) -> io::Result<()> { + pub fn join_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> { self.sys.join_multicast_v4(multiaddr, interface) } @@ -237,9 +227,7 @@ impl UdpSocket { /// This function specifies a new multicast group for this socket to join. /// The address must be a valid multicast address, and `interface` is the /// index of the interface to join/leave (or 0 to indicate any interface). - pub fn join_multicast_v6(&self, - multiaddr: &Ipv6Addr, - interface: u32) -> io::Result<()> { + pub fn join_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> { self.sys.join_multicast_v6(multiaddr, interface) } @@ -249,9 +237,7 @@ impl UdpSocket { /// [`join_multicast_v4`][link]. /// /// [link]: #method.join_multicast_v4 - pub fn leave_multicast_v4(&self, - multiaddr: &Ipv4Addr, - interface: &Ipv4Addr) -> io::Result<()> { + pub fn leave_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> { self.sys.leave_multicast_v4(multiaddr, interface) } @@ -261,9 +247,7 @@ impl UdpSocket { /// [`join_multicast_v6`][link]. /// /// [link]: #method.join_multicast_v6 - pub fn leave_multicast_v6(&self, - multiaddr: &Ipv6Addr, - interface: u32) -> io::Result<()> { + pub fn leave_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> { self.sys.leave_multicast_v6(multiaddr, interface) } @@ -278,12 +262,24 @@ impl UdpSocket { } impl Evented for UdpSocket { - fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn register( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.selector_id.associate_selector(poll)?; self.sys.register(poll, token, interest, opts) } - fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { + fn reregister( + &self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt, + ) -> io::Result<()> { self.sys.reregister(poll, token, interest, opts) } @@ -299,7 +295,7 @@ impl Evented for UdpSocket { */ #[cfg(all(unix, not(target_os = "fuchsia")))] -use std::os::unix::io::{IntoRawFd, AsRawFd, FromRawFd, RawFd}; +use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; #[cfg(all(unix, not(target_os = "fuchsia")))] impl IntoRawFd for UdpSocket { diff --git a/test/mod.rs b/test/mod.rs index d88038eae..855ec4ee5 100644 --- a/test/mod.rs +++ b/test/mod.rs @@ -1,7 +1,7 @@ #![allow(deprecated)] -extern crate mio; extern crate bytes; +extern crate mio; extern crate net2; #[macro_use] @@ -16,9 +16,10 @@ extern crate fuchsia_zircon as zircon; pub use ports::localhost; -mod test_custom_evented; mod test_close_on_drop; +mod test_custom_evented; mod test_double_register; +mod test_drop_cancels_interest_and_shuts_down; mod test_echo_server; mod test_local_addr_ready; mod test_multicast; @@ -33,7 +34,6 @@ mod test_tcp_level; mod test_udp_level; mod test_udp_socket; mod test_write_then_drop; -mod test_drop_cancels_interest_and_shuts_down; #[cfg(feature = "with-deprecated")] mod test_notify; @@ -44,41 +44,54 @@ mod test_tick; // The following tests are for deprecated features. Only run these tests on // platforms that were supported from before the features were deprecated -#[cfg(any(target_os = "macos", target_os = "linux", target_os = "windows"))] -#[cfg(feature = "with-deprecated")] -mod test_timer; -#[cfg(any(target_os = "macos", target_os = "linux", target_os = "windows"))] +#[cfg( + any( + target_os = "macos", + target_os = "linux", + target_os = "windows" + ) +)] #[cfg(feature = "with-deprecated")] mod test_battery; +#[cfg( + any( + target_os = "macos", + target_os = "linux", + target_os = "windows" + ) +)] +#[cfg(feature = "with-deprecated")] +mod test_timer; #[cfg(any(target_os = "macos", target_os = "linux"))] #[cfg(feature = "with-deprecated")] -mod test_unix_echo_server; +mod test_broken_pipe; #[cfg(any(target_os = "macos", target_os = "linux"))] #[cfg(feature = "with-deprecated")] -mod test_unix_pass_fd; +mod test_subprocess_pipe; #[cfg(any(target_os = "macos", target_os = "linux"))] #[cfg(feature = "with-deprecated")] mod test_uds_shutdown; #[cfg(any(target_os = "macos", target_os = "linux"))] #[cfg(feature = "with-deprecated")] -mod test_subprocess_pipe; +mod test_unix_echo_server; #[cfg(any(target_os = "macos", target_os = "linux"))] #[cfg(feature = "with-deprecated")] -mod test_broken_pipe; +mod test_unix_pass_fd; #[cfg(any(target_os = "fuchsia"))] mod test_fuchsia_handles; use bytes::{Buf, MutBuf}; +use mio::event::Event; +use mio::{Events, Poll}; use std::io::{self, Read, Write}; use std::time::Duration; -use mio::{Events, Poll}; -use mio::event::Event; pub trait TryRead { fn try_read_buf(&mut self, buf: &mut B) -> io::Result> - where Self : Sized + where + Self: Sized, { // Reads the length of the slice supplied by buf.mut_bytes into the buffer // This is not guaranteed to consume an entire datagram or segment. @@ -88,7 +101,9 @@ pub trait TryRead { let res = self.try_read(unsafe { buf.mut_bytes() }); if let Ok(Some(cnt)) = res { - unsafe { buf.advance(cnt); } + unsafe { + buf.advance(cnt); + } } res @@ -99,7 +114,8 @@ pub trait TryRead { pub trait TryWrite { fn try_write_buf(&mut self, buf: &mut B) -> io::Result> - where Self : Sized + where + Self: Sized, { let res = self.try_write(buf.bytes()); @@ -158,8 +174,8 @@ impl MapNonBlock for io::Result { mod ports { use std::net::SocketAddr; use std::str::FromStr; - use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT}; use std::sync::atomic::Ordering::SeqCst; + use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT}; // Helper for getting a unique port for the task run // TODO: Reuse ports to not spam the system @@ -188,24 +204,28 @@ pub fn sleep_ms(ms: u64) { thread::sleep(Duration::from_millis(ms)); } -pub fn expect_events(poll: &Poll, - event_buffer: &mut Events, - poll_try_count: usize, - mut expected: Vec) -{ +pub fn expect_events( + poll: &Poll, + event_buffer: &mut Events, + poll_try_count: usize, + mut expected: Vec, +) { const MS: u64 = 1_000; for _ in 0..poll_try_count { - poll.poll(event_buffer, Some(Duration::from_millis(MS))).unwrap(); + poll.poll(event_buffer, Some(Duration::from_millis(MS))) + .unwrap(); for event in event_buffer.iter() { let pos_opt = match expected.iter().position(|exp_event| { - (event.token() == exp_event.token()) && - event.readiness().contains(exp_event.readiness()) + (event.token() == exp_event.token()) + && event.readiness().contains(exp_event.readiness()) }) { Some(x) => Some(x), None => None, }; - if let Some(pos) = pos_opt { expected.remove(pos); } + if let Some(pos) = pos_opt { + expected.remove(pos); + } } if expected.len() == 0 { @@ -213,6 +233,9 @@ pub fn expect_events(poll: &Poll, } } - assert!(expected.len() == 0, "The following expected events were not found: {:?}", expected); + assert!( + expected.len() == 0, + "The following expected events were not found: {:?}", + expected + ); } - diff --git a/test/test_battery.rs b/test/test_battery.rs index d91819651..741fd815a 100644 --- a/test/test_battery.rs +++ b/test/test_battery.rs @@ -1,11 +1,11 @@ -use {localhost, sleep_ms, TryRead, TryWrite}; -use mio::*; use mio::deprecated::{EventLoop, EventLoopBuilder, Handler}; use mio::net::{TcpListener, TcpStream}; -use std::collections::LinkedList; +use mio::*; use slab::Slab; -use std::{io, thread}; +use std::collections::LinkedList; use std::time::Duration; +use std::{io, thread}; +use {localhost, sleep_ms, TryRead, TryWrite}; // Don't touch the connection slab const SERVER: Token = Token(10_000_000); @@ -20,26 +20,28 @@ struct EchoConn { sock: TcpStream, token: Option, count: usize, - buf: Vec + buf: Vec, } impl EchoConn { fn new(sock: TcpStream) -> EchoConn { - let mut ec = - EchoConn { + let mut ec = EchoConn { sock: sock, token: None, buf: Vec::with_capacity(22), - count: 0 + count: 0, }; unsafe { ec.buf.set_len(22) }; ec } fn writable(&mut self, event_loop: &mut EventLoop) -> io::Result<()> { - event_loop.reregister(&self.sock, self.token.unwrap(), - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot()) + event_loop.reregister( + &self.sock, + self.token.unwrap(), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ) } fn readable(&mut self, event_loop: &mut EventLoop) -> io::Result<()> { @@ -60,17 +62,21 @@ impl EchoConn { Err(_) => { break; } - }; } - event_loop.reregister(&self.sock, self.token.unwrap(), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()) + event_loop.reregister( + &self.sock, + self.token.unwrap(), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ) } } struct EchoServer { sock: TcpListener, - conns: Slab + conns: Slab, } impl EchoServer { @@ -78,26 +84,29 @@ impl EchoServer { debug!("server accepting socket"); let sock = self.sock.accept().unwrap().0; - let conn = EchoConn::new(sock,); + let conn = EchoConn::new(sock); let tok = self.conns.insert(conn); // Register the connection self.conns[tok].token = Some(Token(tok)); - event_loop.register(&self.conns[tok].sock, Token(tok), Ready::readable(), - PollOpt::edge() | PollOpt::oneshot()) - .ok().expect("could not register socket with event loop"); + event_loop + .register( + &self.conns[tok].sock, + Token(tok), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ).ok() + .expect("could not register socket with event loop"); Ok(()) } - fn conn_readable(&mut self, event_loop: &mut EventLoop, - tok: Token) -> io::Result<()> { + fn conn_readable(&mut self, event_loop: &mut EventLoop, tok: Token) -> io::Result<()> { debug!("server conn readable; tok={:?}", tok); self.conn(tok).readable(event_loop) } - fn conn_writable(&mut self, event_loop: &mut EventLoop, - tok: Token) -> io::Result<()> { + fn conn_writable(&mut self, event_loop: &mut EventLoop, tok: Token) -> io::Result<()> { debug!("server conn writable; tok={:?}", tok); self.conn(tok).writable(event_loop) } @@ -111,19 +120,17 @@ struct EchoClient { sock: TcpStream, backlog: LinkedList, token: Token, - count: u32 + count: u32, } - // Sends a message and expects to receive the same exact message, one at a time impl EchoClient { fn new(sock: TcpStream, tok: Token) -> EchoClient { - EchoClient { sock: sock, backlog: LinkedList::new(), token: tok, - count: 0 + count: 0, } } @@ -135,7 +142,10 @@ impl EchoClient { debug!("client socket writable"); while self.backlog.len() > 0 { - match self.sock.try_write(self.backlog.front().unwrap().as_bytes()) { + match self + .sock + .try_write(self.backlog.front().unwrap().as_bytes()) + { Ok(None) => { break; } @@ -146,12 +156,20 @@ impl EchoClient { info!("Sent {} messages", self.count); } } - Err(e) => { debug!("not implemented; client err={:?}", e); break; } + Err(e) => { + debug!("not implemented; client err={:?}", e); + break; + } } } if self.backlog.len() > 0 { - event_loop.reregister(&self.sock, self.token, Ready::writable(), - PollOpt::edge() | PollOpt::oneshot()).unwrap(); + event_loop + .reregister( + &self.sock, + self.token, + Ready::writable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); } Ok(()) @@ -179,21 +197,19 @@ impl Handler for Echo { type Timeout = usize; type Message = String; - fn ready(&mut self, event_loop: &mut EventLoop, token: Token, - events: Ready) { - + fn ready(&mut self, event_loop: &mut EventLoop, token: Token, events: Ready) { if events.is_readable() { match token { SERVER => self.server.accept(event_loop).unwrap(), CLIENT => self.client.readable(event_loop).unwrap(), - i => self.server.conn_readable(event_loop, i).unwrap() + i => self.server.conn_readable(event_loop, i).unwrap(), } } if events.is_writable() { match token { SERVER => panic!("received writable for token 0"), CLIENT => self.client.writable(event_loop).unwrap(), - _ => self.server.conn_writable(event_loop, token).unwrap() + _ => self.server.conn_writable(event_loop, token).unwrap(), } } } @@ -205,15 +221,17 @@ impl Handler for Echo { if self.client.count % 10000 == 0 { info!("Sent {} bytes: count {}", n, self.client.count); } - }, + } _ => { self.client.backlog.push_back(msg); - event_loop.reregister( - &self.client.sock, - self.client.token, - Ready::writable(), - PollOpt::edge() | PollOpt::oneshot()).unwrap(); + event_loop + .reregister( + &self.client.sock, + self.client.token, + Ready::writable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); } } } @@ -236,14 +254,24 @@ pub fn test_echo_server() { let srv = TcpListener::bind(&addr).unwrap(); info!("listen for connections"); - event_loop.register(&srv, SERVER, Ready::readable(), - PollOpt::edge() | PollOpt::oneshot()).unwrap(); + event_loop + .register( + &srv, + SERVER, + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); let sock = TcpStream::connect(&addr).unwrap(); // Connect to the server - event_loop.register(&sock, CLIENT, Ready::writable(), - PollOpt::edge() | PollOpt::oneshot()).unwrap(); + event_loop + .register( + &sock, + CLIENT, + Ready::writable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); let chan = event_loop.channel(); let go = move || { diff --git a/test/test_broken_pipe.rs b/test/test_broken_pipe.rs index 1cd0ca746..44f26ce7e 100644 --- a/test/test_broken_pipe.rs +++ b/test/test_broken_pipe.rs @@ -1,5 +1,5 @@ -use mio::{Token, Ready, PollOpt}; use mio::deprecated::{unix, EventLoop, Handler}; +use mio::{PollOpt, Ready, Token}; use std::time::Duration; pub struct BrokenPipeHandler; @@ -19,10 +19,13 @@ pub fn broken_pipe() { let mut event_loop: EventLoop = EventLoop::new().unwrap(); let (reader, _) = unix::pipe().unwrap(); - event_loop.register(&reader, Token(1), Ready::all(), PollOpt::edge()) - .unwrap(); + event_loop + .register(&reader, Token(1), Ready::all(), PollOpt::edge()) + .unwrap(); let mut handler = BrokenPipeHandler; drop(reader); - event_loop.run_once(&mut handler, Some(Duration::from_millis(1000))).unwrap(); + event_loop + .run_once(&mut handler, Some(Duration::from_millis(1000))) + .unwrap(); } diff --git a/test/test_close_on_drop.rs b/test/test_close_on_drop.rs index c429d3bf2..f35e6d8c6 100644 --- a/test/test_close_on_drop.rs +++ b/test/test_close_on_drop.rs @@ -1,9 +1,9 @@ -use {localhost, TryRead}; -use mio::{Events, Poll, PollOpt, Ready, Token}; use bytes::ByteBuf; use mio::net::{TcpListener, TcpStream}; +use mio::{Events, Poll, PollOpt, Ready, Token}; +use {localhost, TryRead}; -use self::TestState::{Initial, AfterRead}; +use self::TestState::{AfterRead, Initial}; const SERVER: Token = Token(0); const CLIENT: Token = Token(1); @@ -47,7 +47,7 @@ impl TestHandler { let mut buf = [0; 4096]; debug!("GOT={:?}", self.cli.try_read(&mut buf[..])); self.state = AfterRead; - }, + } AfterRead => {} } @@ -56,12 +56,13 @@ impl TestHandler { match self.cli.try_read_buf(&mut buf) { Ok(Some(0)) => self.shutdown = true, Ok(_) => panic!("the client socket should not be readable"), - Err(e) => panic!("Unexpected error {:?}", e) + Err(e) => panic!("Unexpected error {:?}", e), } } - _ => panic!("received unknown token {:?}", tok) + _ => panic!("received unknown token {:?}", tok), } - poll.reregister(&self.cli, CLIENT, Ready::readable(), PollOpt::edge()).unwrap(); + poll.reregister(&self.cli, CLIENT, Ready::readable(), PollOpt::edge()) + .unwrap(); } fn handle_write(&mut self, poll: &mut Poll, tok: Token, _: Ready) { @@ -69,9 +70,10 @@ impl TestHandler { SERVER => panic!("received writable for token 0"), CLIENT => { debug!("client connected"); - poll.reregister(&self.cli, CLIENT, Ready::readable(), PollOpt::edge()).unwrap(); + poll.reregister(&self.cli, CLIENT, Ready::readable(), PollOpt::edge()) + .unwrap(); } - _ => panic!("received unknown token {:?}", tok) + _ => panic!("received unknown token {:?}", tok), } } } @@ -88,12 +90,14 @@ pub fn test_close_on_drop() { // == Create & setup server socket let srv = TcpListener::bind(&addr).unwrap(); - poll.register(&srv, SERVER, Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&srv, SERVER, Ready::readable(), PollOpt::edge()) + .unwrap(); // == Create & setup client socket let sock = TcpStream::connect(&addr).unwrap(); - poll.register(&sock, CLIENT, Ready::writable(), PollOpt::edge()).unwrap(); + poll.register(&sock, CLIENT, Ready::writable(), PollOpt::edge()) + .unwrap(); // == Create storage for events let mut events = Events::with_capacity(1024); diff --git a/test/test_custom_evented.rs b/test/test_custom_evented.rs index 8c996f4a7..14af2e523 100644 --- a/test/test_custom_evented.rs +++ b/test/test_custom_evented.rs @@ -1,5 +1,5 @@ -use mio::{Events, Poll, PollOpt, Ready, Registration, SetReadiness, Token}; use mio::event::Evented; +use mio::{Events, Poll, PollOpt, Ready, Registration, SetReadiness, Token}; use std::time::Duration; #[test] @@ -8,14 +8,19 @@ fn smoke() { let mut events = Events::with_capacity(128); let (r, set) = Registration::new2(); - r.register(&poll, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); + r.register(&poll, Token(0), Ready::readable(), PollOpt::edge()) + .unwrap(); - let n = poll.poll(&mut events, Some(Duration::from_millis(0))).unwrap(); + let n = poll + .poll(&mut events, Some(Duration::from_millis(0))) + .unwrap(); assert_eq!(n, 0); set.set_readiness(Ready::readable()).unwrap(); - let n = poll.poll(&mut events, Some(Duration::from_millis(0))).unwrap(); + let n = poll + .poll(&mut events, Some(Duration::from_millis(0))) + .unwrap(); assert_eq!(n, 1); assert_eq!(events.get(0).unwrap().token(), Token(0)); @@ -47,7 +52,8 @@ fn set_readiness_before_register() { b1.wait(); // now register - poll.register(&r, Token(123), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&r, Token(123), Ready::readable(), PollOpt::edge()) + .unwrap(); loop { let n = poll.poll(&mut events, None).unwrap(); @@ -65,17 +71,23 @@ fn set_readiness_before_register() { } } -#[cfg(any(target_os = "linux", target_os = "macos", target_os = "windows"))] +#[cfg( + any( + target_os = "linux", + target_os = "macos", + target_os = "windows" + ) +)] mod stress { - use mio::{Events, Poll, PollOpt, Ready, Registration, SetReadiness, Token}; use mio::event::Evented; + use mio::{Events, Poll, PollOpt, Ready, Registration, SetReadiness, Token}; use std::time::Duration; #[test] fn single_threaded_poll() { - use std::sync::Arc; use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering::{Acquire, Release}; + use std::sync::Arc; use std::thread; const NUM_ATTEMPTS: usize = 30; @@ -87,11 +99,13 @@ mod stress { let poll = Poll::new().unwrap(); let mut events = Events::with_capacity(NUM_REGISTRATIONS); - let registrations: Vec<_> = (0..NUM_REGISTRATIONS).map(|i| { - let (r, s) = Registration::new2(); - r.register(&poll, Token(i), Ready::readable(), PollOpt::edge()).unwrap(); - (r, s) - }).collect(); + let registrations: Vec<_> = (0..NUM_REGISTRATIONS) + .map(|i| { + let (r, s) = Registration::new2(); + r.register(&poll, Token(i), Ready::readable(), PollOpt::edge()) + .unwrap(); + (r, s) + }).collect(); let mut ready: Vec<_> = (0..NUM_REGISTRATIONS).map(|_| Ready::empty()).collect(); @@ -109,7 +123,9 @@ mod stress { set_readiness[i].set_readiness(Ready::readable()).unwrap(); set_readiness[i].set_readiness(Ready::empty()).unwrap(); set_readiness[i].set_readiness(Ready::writable()).unwrap(); - set_readiness[i].set_readiness(Ready::readable() | Ready::writable()).unwrap(); + set_readiness[i] + .set_readiness(Ready::readable() | Ready::writable()) + .unwrap(); set_readiness[i].set_readiness(Ready::empty()).unwrap(); } } @@ -125,10 +141,12 @@ mod stress { while remaining.load(Acquire) > 0 { // Set interest for (i, &(ref r, _)) in registrations.iter().enumerate() { - r.reregister(&poll, Token(i), Ready::writable(), PollOpt::edge()).unwrap(); + r.reregister(&poll, Token(i), Ready::writable(), PollOpt::edge()) + .unwrap(); } - poll.poll(&mut events, Some(Duration::from_millis(0))).unwrap(); + poll.poll(&mut events, Some(Duration::from_millis(0))) + .unwrap(); for event in &events { ready[event.token().0] = event.readiness(); @@ -137,14 +155,16 @@ mod stress { // Update registration // Set interest for (i, &(ref r, _)) in registrations.iter().enumerate() { - r.reregister(&poll, Token(i), Ready::readable(), PollOpt::edge()).unwrap(); + r.reregister(&poll, Token(i), Ready::readable(), PollOpt::edge()) + .unwrap(); } } // Finall polls, repeat until readiness-queue empty loop { // Might not read all events from custom-event-queue at once, implementation dependend - poll.poll(&mut events, Some(Duration::from_millis(0))).unwrap(); + poll.poll(&mut events, Some(Duration::from_millis(0))) + .unwrap(); if events.is_empty() { // no more events in readiness queue pending break; @@ -163,9 +183,9 @@ mod stress { #[test] fn multi_threaded_poll() { - use std::sync::{Arc, Barrier}; - use std::sync::atomic::{AtomicUsize}; + use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering::{Relaxed, SeqCst}; + use std::sync::{Arc, Barrier}; use std::thread; const ENTRIES: usize = 10_000; @@ -192,7 +212,9 @@ mod stress { // Create entries for i in 0..ENTRIES { let (registration, set_readiness) = Registration::new2(); - registration.register(&poll, Token(i), Ready::readable(), PollOpt::edge()).unwrap(); + registration + .register(&poll, Token(i), Ready::readable(), PollOpt::edge()) + .unwrap(); entries.push(Entry { registration: registration, @@ -227,12 +249,13 @@ mod stress { let mut n = 0; - while total.load(SeqCst) < NUM { // A poll timeout is necessary here because there may be more // than one threads blocked in `poll` when the final wakeup // notification arrives (and only notifies one thread). - n += poll.poll(&mut events, Some(Duration::from_millis(100))).unwrap(); + n += poll + .poll(&mut events, Some(Duration::from_millis(100))) + .unwrap(); let mut num_this_tick = 0; @@ -265,9 +288,7 @@ mod stress { })); } - let _: Vec<_> = threads.into_iter() - .map(|th| th.join().unwrap()) - .collect(); + let _: Vec<_> = threads.into_iter().map(|th| th.join().unwrap()).collect(); for entry in entries.iter() { assert_eq!(PER_ENTRY, entry.num.load(Relaxed)); @@ -279,9 +300,9 @@ mod stress { const N: usize = 8; const ITER: usize = 1_000; - use std::sync::{Arc, Barrier}; use std::sync::atomic::AtomicBool; use std::sync::atomic::Ordering::{Acquire, Release}; + use std::sync::{Arc, Barrier}; use std::thread; let poll = Poll::new().unwrap(); @@ -292,7 +313,8 @@ mod stress { for i in 0..N { let (registration, set_readiness) = Registration::new2(); - poll.register(®istration, Token(i), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(®istration, Token(i), Ready::readable(), PollOpt::edge()) + .unwrap(); registrations.push(registration); @@ -323,7 +345,6 @@ mod stress { let mut final_ready = vec![false; N]; - for _ in 0..5 { poll.poll(&mut events, None).unwrap(); @@ -344,8 +365,8 @@ mod stress { #[test] fn drop_registration_from_non_main_thread() { - use std::thread; use std::sync::mpsc::channel; + use std::thread; const THREADS: usize = 8; const ITERS: usize = 50_000; @@ -372,7 +393,13 @@ fn drop_registration_from_non_main_thread() { let mut index: usize = 0; for _ in 0..ITERS { let (registration, set_readiness) = Registration::new2(); - registration.register(&mut poll, Token(token_index), Ready::readable(), PollOpt::edge()).unwrap(); + registration + .register( + &mut poll, + Token(token_index), + Ready::readable(), + PollOpt::edge(), + ).unwrap(); let _ = senders[index].send((registration, set_readiness)); token_index += 1; @@ -381,7 +408,13 @@ fn drop_registration_from_non_main_thread() { index = 0; let (registration, set_readiness) = Registration::new2(); - registration.register(&mut poll, Token(token_index), Ready::readable(), PollOpt::edge()).unwrap(); + registration + .register( + &mut poll, + Token(token_index), + Ready::readable(), + PollOpt::edge(), + ).unwrap(); let _ = set_readiness.set_readiness(Ready::readable()); drop(registration); drop(set_readiness); diff --git a/test/test_double_register.rs b/test/test_double_register.rs index c3d011c81..6c95d12ea 100644 --- a/test/test_double_register.rs +++ b/test/test_double_register.rs @@ -3,8 +3,8 @@ #[test] #[cfg(any(target_os = "linux", target_os = "windows"))] pub fn test_double_register() { - use mio::*; use mio::net::TcpListener; + use mio::*; let poll = Poll::new().unwrap(); @@ -12,6 +12,10 @@ pub fn test_double_register() { let l = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); // Register the listener with `Poll` - poll.register(&l, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); - assert!(poll.register(&l, Token(1), Ready::readable(), PollOpt::edge()).is_err()); + poll.register(&l, Token(0), Ready::readable(), PollOpt::edge()) + .unwrap(); + assert!( + poll.register(&l, Token(1), Ready::readable(), PollOpt::edge()) + .is_err() + ); } diff --git a/test/test_drop_cancels_interest_and_shuts_down.rs b/test/test_drop_cancels_interest_and_shuts_down.rs index e03fe2d14..9a3288aef 100644 --- a/test/test_drop_cancels_interest_and_shuts_down.rs +++ b/test/test_drop_cancels_interest_and_shuts_down.rs @@ -10,7 +10,7 @@ fn drop_cancels_interest_and_shuts_down() { use env_logger; let _ = env_logger::init(); - let l = TcpListener::bind("127.0.0.1:18000").unwrap(); + let l = TcpListener::bind("127.0.0.1:0").unwrap(); let addr = l.local_addr().unwrap(); let t = thread::spawn(move || { @@ -22,7 +22,6 @@ fn drop_cancels_interest_and_shuts_down() { Ok(_) => (), Err(e) => { if e.kind() != io::ErrorKind::UnexpectedEof { - eprintln!("{}", e); panic!(e); } } diff --git a/test/test_echo_server.rs b/test/test_echo_server.rs index c0eda942b..be4d934ab 100644 --- a/test/test_echo_server.rs +++ b/test/test_echo_server.rs @@ -1,9 +1,9 @@ -use {localhost, TryRead, TryWrite}; -use mio::{Events, Poll, PollOpt, Ready, Token}; -use mio::net::{TcpListener, TcpStream}; use bytes::{Buf, ByteBuf, MutByteBuf, SliceBuf}; +use mio::net::{TcpListener, TcpStream}; +use mio::{Events, Poll, PollOpt, Ready, Token}; use slab::Slab; use std::io; +use {localhost, TryRead, TryWrite}; const SERVER: Token = Token(10_000_000); const CLIENT: Token = Token(10_000_001); @@ -13,7 +13,7 @@ struct EchoConn { buf: Option, mut_buf: Option, token: Option, - interest: Ready + interest: Ready, } impl EchoConn { @@ -48,9 +48,17 @@ impl EchoConn { Err(e) => debug!("not implemented; client err={:?}", e), } - assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); - poll.reregister(&self.sock, self.token.unwrap(), self.interest, - PollOpt::edge() | PollOpt::oneshot()) + assert!( + self.interest.is_readable() || self.interest.is_writable(), + "actual={:?}", + self.interest + ); + poll.reregister( + &self.sock, + self.token.unwrap(), + self.interest, + PollOpt::edge() | PollOpt::oneshot(), + ) } fn readable(&mut self, poll: &mut Poll) -> io::Result<()> { @@ -74,18 +82,25 @@ impl EchoConn { debug!("not implemented; client err={:?}", e); self.interest.remove(Ready::readable()); } - }; - assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); - poll.reregister(&self.sock, self.token.unwrap(), self.interest, - PollOpt::edge()) + assert!( + self.interest.is_readable() || self.interest.is_writable(), + "actual={:?}", + self.interest + ); + poll.reregister( + &self.sock, + self.token.unwrap(), + self.interest, + PollOpt::edge(), + ) } } struct EchoServer { sock: TcpListener, - conns: Slab + conns: Slab, } impl EchoServer { @@ -93,26 +108,28 @@ impl EchoServer { debug!("server accepting socket"); let sock = self.sock.accept().unwrap().0; - let conn = EchoConn::new(sock,); + let conn = EchoConn::new(sock); let tok = self.conns.insert(conn); // Register the connection self.conns[tok].token = Some(Token(tok)); - poll.register(&self.conns[tok].sock, Token(tok), Ready::readable(), - PollOpt::edge() | PollOpt::oneshot()) - .ok().expect("could not register socket with event loop"); + poll.register( + &self.conns[tok].sock, + Token(tok), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ).ok() + .expect("could not register socket with event loop"); Ok(()) } - fn conn_readable(&mut self, poll: &mut Poll, - tok: Token) -> io::Result<()> { + fn conn_readable(&mut self, poll: &mut Poll, tok: Token) -> io::Result<()> { debug!("server conn readable; tok={:?}", tok); self.conn(tok).readable(poll) } - fn conn_writable(&mut self, poll: &mut Poll, - tok: Token) -> io::Result<()> { + fn conn_writable(&mut self, poll: &mut Poll, tok: Token) -> io::Result<()> { debug!("server conn writable; tok={:?}", tok); self.conn(tok).writable(poll) } @@ -133,10 +150,9 @@ struct EchoClient { shutdown: bool, } - // Sends a message and expects to receive the same exact message, one at a time impl EchoClient { - fn new(sock: TcpStream, tok: Token, mut msgs: Vec<&'static str>) -> EchoClient { + fn new(sock: TcpStream, tok: Token, mut msgs: Vec<&'static str>) -> EchoClient { let curr = msgs.remove(0); EchoClient { @@ -188,9 +204,17 @@ impl EchoClient { }; if !self.interest.is_empty() { - assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); - poll.reregister(&self.sock, self.token, self.interest, - PollOpt::edge() | PollOpt::oneshot())?; + assert!( + self.interest.is_readable() || self.interest.is_writable(), + "actual={:?}", + self.interest + ); + poll.reregister( + &self.sock, + self.token, + self.interest, + PollOpt::edge() | PollOpt::oneshot(), + )?; } Ok(()) @@ -209,12 +233,16 @@ impl EchoClient { self.interest.insert(Ready::readable()); self.interest.remove(Ready::writable()); } - Err(e) => debug!("not implemented; client err={:?}", e) + Err(e) => debug!("not implemented; client err={:?}", e), } if self.interest.is_readable() || self.interest.is_writable() { - try!(poll.reregister(&self.sock, self.token, self.interest, - PollOpt::edge() | PollOpt::oneshot())); + try!(poll.reregister( + &self.sock, + self.token, + self.interest, + PollOpt::edge() | PollOpt::oneshot() + )); } Ok(()) @@ -233,8 +261,12 @@ impl EchoClient { self.rx = SliceBuf::wrap(curr.as_bytes()); self.interest.insert(Ready::writable()); - poll.reregister(&self.sock, self.token, self.interest, - PollOpt::edge() | PollOpt::oneshot()) + poll.reregister( + &self.sock, + self.token, + self.interest, + PollOpt::edge() | PollOpt::oneshot(), + ) } } @@ -248,9 +280,9 @@ impl Echo { Echo { server: EchoServer { sock: srv, - conns: Slab::with_capacity(128) + conns: Slab::with_capacity(128), }, - client: EchoClient::new(client, CLIENT, msgs) + client: EchoClient::new(client, CLIENT, msgs), } } } @@ -264,14 +296,22 @@ pub fn test_echo_server() { let srv = TcpListener::bind(&addr).unwrap(); info!("listen for connections"); - poll.register(&srv, SERVER, Ready::readable(), - PollOpt::edge() | PollOpt::oneshot()).unwrap(); + poll.register( + &srv, + SERVER, + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); let sock = TcpStream::connect(&addr).unwrap(); // Connect to the server - poll.register(&sock, CLIENT, Ready::writable(), - PollOpt::edge() | PollOpt::oneshot()).unwrap(); + poll.register( + &sock, + CLIENT, + Ready::writable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); // == Create storage for events let mut events = Events::with_capacity(1024); @@ -287,7 +327,7 @@ pub fn test_echo_server() { match event.token() { SERVER => handler.server.accept(&mut poll).unwrap(), CLIENT => handler.client.readable(&mut poll).unwrap(), - i => handler.server.conn_readable(&mut poll, i).unwrap() + i => handler.server.conn_readable(&mut poll, i).unwrap(), } } @@ -295,7 +335,7 @@ pub fn test_echo_server() { match event.token() { SERVER => panic!("received writable for token 0"), CLIENT => handler.client.writable(&mut poll).unwrap(), - i => handler.server.conn_writable(&mut poll, i).unwrap() + i => handler.server.conn_writable(&mut poll, i).unwrap(), }; } } diff --git a/test/test_fuchsia_handles.rs b/test/test_fuchsia_handles.rs index 85a14327f..56578a07e 100644 --- a/test/test_fuchsia_handles.rs +++ b/test/test_fuchsia_handles.rs @@ -1,7 +1,7 @@ -use mio::*; use mio::fuchsia::EventedHandle; -use zircon::{self, AsHandleRef}; +use mio::*; use std::time::Duration; +use zircon::{self, AsHandleRef}; const MS: u64 = 1_000; @@ -14,17 +14,24 @@ pub fn test_fuchsia_channel() { let (channel0, channel1) = zircon::Channel::create(zircon::ChannelOpts::Normal).unwrap(); let channel1_evented = unsafe { EventedHandle::new(channel1.raw_handle()) }; - poll.register(&channel1_evented, Token(1), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register( + &channel1_evented, + Token(1), + Ready::readable(), + PollOpt::edge(), + ).unwrap(); - poll.poll(event_buffer, Some(Duration::from_millis(MS))).unwrap(); + poll.poll(event_buffer, Some(Duration::from_millis(MS))) + .unwrap(); assert_eq!(event_buffer.len(), 0); channel0.write(&[1, 2, 3], &mut vec![], 0).unwrap(); - poll.poll(event_buffer, Some(Duration::from_millis(MS))).unwrap(); + poll.poll(event_buffer, Some(Duration::from_millis(MS))) + .unwrap(); let event = event_buffer.get(0).unwrap(); assert_eq!(event.token(), Token(1)); assert!(event.readiness().is_readable()); poll.deregister(&channel1_evented).unwrap(); -} \ No newline at end of file +} diff --git a/test/test_local_addr_ready.rs b/test/test_local_addr_ready.rs index 2e97f5244..3ebb1bdf4 100644 --- a/test/test_local_addr_ready.rs +++ b/test/test_local_addr_ready.rs @@ -1,6 +1,6 @@ -use {TryWrite}; -use mio::{Events, Poll, PollOpt, Ready, Token}; use mio::net::{TcpListener, TcpStream}; +use mio::{Events, Poll, PollOpt, Ready, Token}; +use TryWrite; const LISTEN: Token = Token(0); const CLIENT: Token = Token(1); @@ -20,12 +20,12 @@ fn local_addr_ready() { let addr = server.local_addr().unwrap(); let poll = Poll::new().unwrap(); - poll.register(&server, LISTEN, Ready::readable(), - PollOpt::edge()).unwrap(); + poll.register(&server, LISTEN, Ready::readable(), PollOpt::edge()) + .unwrap(); let sock = TcpStream::connect(&addr).unwrap(); - poll.register(&sock, CLIENT, Ready::readable(), - PollOpt::edge()).unwrap(); + poll.register(&sock, CLIENT, Ready::readable(), PollOpt::edge()) + .unwrap(); let mut events = Events::with_capacity(1024); @@ -43,16 +43,19 @@ fn local_addr_ready() { match event.token() { LISTEN => { let sock = handler.listener.accept().unwrap().0; - poll.register(&sock, - SERVER, - Ready::writable(), - PollOpt::edge()).unwrap(); + poll.register(&sock, SERVER, Ready::writable(), PollOpt::edge()) + .unwrap(); handler.accepted = Some(sock); } SERVER => { handler.accepted.as_ref().unwrap().peer_addr().unwrap(); handler.accepted.as_ref().unwrap().local_addr().unwrap(); - handler.accepted.as_mut().unwrap().try_write(&[1, 2, 3]).unwrap(); + handler + .accepted + .as_mut() + .unwrap() + .try_write(&[1, 2, 3]) + .unwrap(); handler.accepted = None; } CLIENT => { diff --git a/test/test_multicast.rs b/test/test_multicast.rs index 09efcbd7a..ad0e37aab 100644 --- a/test/test_multicast.rs +++ b/test/test_multicast.rs @@ -2,12 +2,12 @@ // Figure out why! #![cfg(not(target_os = "android"))] -use mio::{Events, Poll, PollOpt, Ready, Token}; -use mio::net::UdpSocket; use bytes::{Buf, MutBuf, RingBuf, SliceBuf}; -use std::str; -use std::net::IpAddr; use localhost; +use mio::net::UdpSocket; +use mio::{Events, Poll, PollOpt, Ready, Token}; +use std::net::IpAddr; +use std::str; const LISTENER: Token = Token(0); const SENDER: Token = Token(1); @@ -42,15 +42,17 @@ impl UdpHandler { debug!("We are receiving a datagram now..."); match unsafe { self.rx.recv_from(self.rx_buf.mut_bytes()) } { Ok((cnt, addr)) => { - unsafe { MutBuf::advance(&mut self.rx_buf, cnt); } + unsafe { + MutBuf::advance(&mut self.rx_buf, cnt); + } assert_eq!(addr.ip(), self.localhost); } res => panic!("unexpected result: {:?}", res), } assert!(str::from_utf8(self.rx_buf.bytes()).unwrap() == self.msg); self.shutdown = true; - }, - _ => () + } + _ => (), } } @@ -60,8 +62,8 @@ impl UdpHandler { let addr = self.rx.local_addr().unwrap(); let cnt = self.tx.send_to(self.buf.bytes(), &addr).unwrap(); self.buf.advance(cnt); - }, - _ => () + } + _ => (), } } } @@ -80,16 +82,20 @@ pub fn test_multicast() { info!("Joining group 227.1.1.100"); let any = "0.0.0.0".parse().unwrap(); - rx.join_multicast_v4(&"227.1.1.100".parse().unwrap(), &any).unwrap(); + rx.join_multicast_v4(&"227.1.1.100".parse().unwrap(), &any) + .unwrap(); info!("Joining group 227.1.1.101"); - rx.join_multicast_v4(&"227.1.1.101".parse().unwrap(), &any).unwrap(); + rx.join_multicast_v4(&"227.1.1.101".parse().unwrap(), &any) + .unwrap(); info!("Registering SENDER"); - poll.register(&tx, SENDER, Ready::writable(), PollOpt::edge()).unwrap(); + poll.register(&tx, SENDER, Ready::writable(), PollOpt::edge()) + .unwrap(); info!("Registering LISTENER"); - poll.register(&rx, LISTENER, Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&rx, LISTENER, Ready::readable(), PollOpt::edge()) + .unwrap(); let mut events = Events::with_capacity(1024); diff --git a/test/test_notify.rs b/test/test_notify.rs index c2b36b5cd..137285d9d 100644 --- a/test/test_notify.rs +++ b/test/test_notify.rs @@ -1,19 +1,19 @@ -use {localhost, sleep_ms}; -use mio::*; -use mio::deprecated::{EventLoop, EventLoopBuilder, Handler, Sender, NotifyError}; +use mio::deprecated::{EventLoop, EventLoopBuilder, Handler, NotifyError, Sender}; use mio::net::TcpListener; +use mio::*; use std::thread; +use {localhost, sleep_ms}; struct TestHandler { sender: Sender, - notify: usize + notify: usize, } impl TestHandler { fn new(sender: Sender) -> TestHandler { TestHandler { sender: sender, - notify: 0 + notify: 0, } } } @@ -32,7 +32,7 @@ impl Handler for TestHandler { assert!(msg == "Second", "actual={}", msg); event_loop.shutdown(); } - v => panic!("unexpected value for notify; val={}", v) + v => panic!("unexpected value for notify; val={}", v), } self.notify += 1; @@ -49,7 +49,13 @@ pub fn test_notify() { // Setup a server socket so that the event loop blocks let srv = TcpListener::bind(&addr).unwrap(); - event_loop.register(&srv, Token(0), Ready::readable() | Ready::writable(), PollOpt::edge()).unwrap(); + event_loop + .register( + &srv, + Token(0), + Ready::readable() | Ready::writable(), + PollOpt::edge(), + ).unwrap(); let sender = event_loop.channel(); @@ -120,7 +126,7 @@ pub fn test_notify_capacity() { #[test] pub fn test_notify_drop() { - use std::sync::mpsc::{self,Sender}; + use std::sync::mpsc::{self, Sender}; use std::thread; struct MessageDrop(Sender); diff --git a/test/test_oneshot.rs b/test/test_oneshot.rs index 4dca219b7..09c9ac652 100644 --- a/test/test_oneshot.rs +++ b/test/test_oneshot.rs @@ -1,5 +1,5 @@ -use mio::*; use mio::net::{TcpListener, TcpStream}; +use mio::*; use std::io::*; use std::time::Duration; @@ -16,17 +16,24 @@ pub fn test_tcp_edge_oneshot() { let l = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); // Register the listener with `Poll` - poll.register(&l, Token(0), Ready::readable(), PollOpt::level()).unwrap(); + poll.register(&l, Token(0), Ready::readable(), PollOpt::level()) + .unwrap(); // Connect a socket, we are going to write to it let mut s1 = TcpStream::connect(&l.local_addr().unwrap()).unwrap(); - poll.register(&s1, Token(1), Ready::writable(), PollOpt::level()).unwrap(); + poll.register(&s1, Token(1), Ready::writable(), PollOpt::level()) + .unwrap(); wait_for(&mut poll, &mut events, Token(0)); // Get pair let (mut s2, _) = l.accept().unwrap(); - poll.register(&s2, Token(2), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); + poll.register( + &s2, + Token(2), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); wait_for(&mut poll, &mut events, Token(1)); @@ -41,10 +48,20 @@ pub fn test_tcp_edge_oneshot() { assert_eq!(1, s2.read(&mut buf).unwrap()); assert_eq!(*byte, buf[0]); - poll.reregister(&s2, Token(2), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); + poll.reregister( + &s2, + Token(2), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); if *byte == b'o' { - poll.reregister(&s2, Token(2), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); + poll.reregister( + &s2, + Token(2), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); } } } @@ -53,12 +70,19 @@ fn wait_for(poll: &mut Poll, events: &mut Events, token: Token) { loop { poll.poll(events, Some(Duration::from_millis(MS))).unwrap(); - let cnt = (0..events.len()).map(|i| events.get(i).unwrap()) - .filter(|e| e.token() == token) - .count(); + let cnt = (0..events.len()) + .map(|i| events.get(i).unwrap()) + .filter(|e| e.token() == token) + .count(); - assert!(cnt < 2, "token appeared multiple times in poll results; cnt={:}", cnt); + assert!( + cnt < 2, + "token appeared multiple times in poll results; cnt={:}", + cnt + ); - if cnt == 1 { return }; + if cnt == 1 { + return; + }; } } diff --git a/test/test_poll.rs b/test/test_poll.rs index e259d89e2..bbabdee1b 100644 --- a/test/test_poll.rs +++ b/test/test_poll.rs @@ -8,8 +8,10 @@ fn test_poll_closes_fd() { let mut events = Events::with_capacity(4); let (registration, set_readiness) = Registration::new2(); - poll.register(®istration, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); - poll.poll(&mut events, Some(Duration::from_millis(0))).unwrap(); + poll.register(®istration, Token(0), Ready::readable(), PollOpt::edge()) + .unwrap(); + poll.poll(&mut events, Some(Duration::from_millis(0))) + .unwrap(); drop(poll); drop(set_readiness); diff --git a/test/test_poll_channel.rs b/test/test_poll_channel.rs index f7ce05053..d3cf1089a 100644 --- a/test/test_poll_channel.rs +++ b/test/test_poll_channel.rs @@ -1,9 +1,9 @@ -use {expect_events, sleep_ms}; -use mio::{channel, Events, Poll, PollOpt, Ready, Token}; use mio::event::Event; +use mio::{channel, Events, Poll, PollOpt, Ready, Token}; use std::sync::mpsc::TryRecvError; use std::thread; use std::time::Duration; +use {expect_events, sleep_ms}; #[test] pub fn test_poll_channel_edge() { @@ -11,17 +11,22 @@ pub fn test_poll_channel_edge() { let mut events = Events::with_capacity(1024); let (tx, rx) = channel::channel(); - poll.register(&rx, Token(123), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&rx, Token(123), Ready::readable(), PollOpt::edge()) + .unwrap(); // Wait, but nothing should happen - let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); assert_eq!(0, num); // Push the value tx.send("hello").unwrap(); // Polling will contain the event - let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); assert_eq!(1, num); let event = events.get(0).unwrap(); @@ -29,21 +34,27 @@ pub fn test_poll_channel_edge() { assert_eq!(event.readiness(), Ready::readable()); // Poll again and there should be no events - let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); assert_eq!(0, num); // Read the value assert_eq!("hello", rx.try_recv().unwrap()); // Poll again, nothing - let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); assert_eq!(0, num); // Push a value tx.send("goodbye").unwrap(); // Have an event - let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); assert_eq!(1, num); let event = events.get(0).unwrap(); @@ -56,7 +67,9 @@ pub fn test_poll_channel_edge() { // Drop the sender half drop(tx); - let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); assert_eq!(1, num); let event = events.get(0).unwrap(); @@ -67,7 +80,6 @@ pub fn test_poll_channel_edge() { Err(TryRecvError::Disconnected) => {} no => panic!("unexpected value {:?}", no), } - } #[test] @@ -76,17 +88,26 @@ pub fn test_poll_channel_oneshot() { let mut events = Events::with_capacity(1024); let (tx, rx) = channel::channel(); - poll.register(&rx, Token(123), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); + poll.register( + &rx, + Token(123), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); // Wait, but nothing should happen - let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); assert_eq!(0, num); // Push the value tx.send("hello").unwrap(); // Polling will contain the event - let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); assert_eq!(1, num); let event = events.get(0).unwrap(); @@ -94,29 +115,42 @@ pub fn test_poll_channel_oneshot() { assert_eq!(event.readiness(), Ready::readable()); // Poll again and there should be no events - let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); assert_eq!(0, num); // Read the value assert_eq!("hello", rx.try_recv().unwrap()); // Poll again, nothing - let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); assert_eq!(0, num); // Push a value tx.send("goodbye").unwrap(); // Poll again, nothing - let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); assert_eq!(0, num); // Reregistering will re-trigger the notification for _ in 0..3 { - poll.reregister(&rx, Token(123), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); + poll.reregister( + &rx, + Token(123), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); // Have an event - let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); assert_eq!(1, num); let event = events.get(0).unwrap(); @@ -127,16 +161,30 @@ pub fn test_poll_channel_oneshot() { // Get the value assert_eq!("goodbye", rx.try_recv().unwrap()); - poll.reregister(&rx, Token(123), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); + poll.reregister( + &rx, + Token(123), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); // Have an event - let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); assert_eq!(0, num); - poll.reregister(&rx, Token(123), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); + poll.reregister( + &rx, + Token(123), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); // Have an event - let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); assert_eq!(0, num); } @@ -146,10 +194,13 @@ pub fn test_poll_channel_level() { let mut events = Events::with_capacity(1024); let (tx, rx) = channel::channel(); - poll.register(&rx, Token(123), Ready::readable(), PollOpt::level()).unwrap(); + poll.register(&rx, Token(123), Ready::readable(), PollOpt::level()) + .unwrap(); // Wait, but nothing should happen - let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); assert_eq!(0, num); // Push the value @@ -157,7 +208,9 @@ pub fn test_poll_channel_level() { // Polling will contain the event for i in 0..5 { - let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); assert!(1 == num, "actually got {} on iteration {}", num, i); let event = events.get(0).unwrap(); @@ -169,7 +222,9 @@ pub fn test_poll_channel_level() { assert_eq!("hello", rx.try_recv().unwrap()); // Wait, but nothing should happen - let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); assert_eq!(0, num); } @@ -179,17 +234,22 @@ pub fn test_poll_channel_writable() { let mut events = Events::with_capacity(1024); let (tx, rx) = channel::channel(); - poll.register(&rx, Token(123), Ready::writable(), PollOpt::edge()).unwrap(); + poll.register(&rx, Token(123), Ready::writable(), PollOpt::edge()) + .unwrap(); // Wait, but nothing should happen - let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); assert_eq!(0, num); // Push the value tx.send("hello").unwrap(); // Wait, but nothing should happen - let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); assert_eq!(0, num); } @@ -199,7 +259,8 @@ pub fn test_dropping_receive_before_poll() { let mut events = Events::with_capacity(1024); let (tx, rx) = channel::channel(); - poll.register(&rx, Token(123), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&rx, Token(123), Ready::readable(), PollOpt::edge()) + .unwrap(); // Push the value tx.send("hello").unwrap(); @@ -208,7 +269,9 @@ pub fn test_dropping_receive_before_poll() { drop(rx); // Wait, but nothing should happen - let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); assert_eq!(0, num); } @@ -224,8 +287,10 @@ pub fn test_mixing_channel_with_socket() { let l = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); // Register the listener with `Poll` - poll.register(&l, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); - poll.register(&rx, Token(1), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&l, Token(0), Ready::readable(), PollOpt::edge()) + .unwrap(); + poll.register(&rx, Token(1), Ready::readable(), PollOpt::edge()) + .unwrap(); // Push a value onto the channel tx.send("hello").unwrap(); @@ -234,15 +299,21 @@ pub fn test_mixing_channel_with_socket() { let s1 = TcpStream::connect(&l.local_addr().unwrap()).unwrap(); // Register the socket - poll.register(&s1, Token(2), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&s1, Token(2), Ready::readable(), PollOpt::edge()) + .unwrap(); // Sleep a bit to ensure it arrives at dest sleep_ms(250); - expect_events(&poll, &mut events, 2, vec![ - Event::new(Ready::empty(), Token(0)), - Event::new(Ready::empty(), Token(1)), - ]); + expect_events( + &poll, + &mut events, + 2, + vec![ + Event::new(Ready::empty(), Token(0)), + Event::new(Ready::empty(), Token(1)), + ], + ); } #[test] @@ -256,7 +327,8 @@ pub fn test_sending_from_other_thread_while_polling() { for _ in 0..ITERATIONS { let (tx, rx) = channel::channel(); - poll.register(&rx, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&rx, Token(0), Ready::readable(), PollOpt::edge()) + .unwrap(); for _ in 0..THREADS { let tx = tx.clone(); diff --git a/test/test_register_deregister.rs b/test/test_register_deregister.rs index a82698f91..c3d11a398 100644 --- a/test/test_register_deregister.rs +++ b/test/test_register_deregister.rs @@ -1,9 +1,9 @@ -use {expect_events, localhost, TryWrite}; -use mio::{Events, Poll, PollOpt, Ready, Token}; +use bytes::SliceBuf; use mio::event::Event; use mio::net::{TcpListener, TcpStream}; -use bytes::SliceBuf; +use mio::{Events, Poll, PollOpt, Ready, Token}; use std::time::Duration; +use {expect_events, localhost, TryWrite}; const SERVER: Token = Token(0); const CLIENT: Token = Token(1); @@ -28,13 +28,15 @@ impl TestHandler { SERVER => { trace!("handle_read; token=SERVER"); let mut sock = self.server.accept().unwrap().0; - sock.try_write_buf(&mut SliceBuf::wrap("foobar".as_bytes())).unwrap(); + sock.try_write_buf(&mut SliceBuf::wrap("foobar".as_bytes())) + .unwrap(); } CLIENT => { trace!("handle_read; token=CLIENT"); assert!(self.state == 0, "unexpected state {}", self.state); self.state = 1; - poll.reregister(&self.client, CLIENT, Ready::writable(), PollOpt::level()).unwrap(); + poll.reregister(&self.client, CLIENT, Ready::writable(), PollOpt::level()) + .unwrap(); } _ => panic!("unexpected token"), } @@ -65,12 +67,14 @@ pub fn test_register_deregister() { let server = TcpListener::bind(&addr).unwrap(); info!("register server socket"); - poll.register(&server, SERVER, Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&server, SERVER, Ready::readable(), PollOpt::edge()) + .unwrap(); let client = TcpStream::connect(&addr).unwrap(); // Register client socket only as writable - poll.register(&client, CLIENT, Ready::readable(), PollOpt::level()).unwrap(); + poll.register(&client, CLIENT, Ready::readable(), PollOpt::level()) + .unwrap(); let mut handler = TestHandler::new(server, client); @@ -89,7 +93,8 @@ pub fn test_register_deregister() { } } - poll.poll(&mut events, Some(Duration::from_millis(100))).unwrap(); + poll.poll(&mut events, Some(Duration::from_millis(100))) + .unwrap(); assert_eq!(events.len(), 0); } @@ -101,23 +106,36 @@ pub fn test_register_empty_interest() { let sock = TcpListener::bind(&addr).unwrap(); - poll.register(&sock, Token(0), Ready::empty(), PollOpt::edge()).unwrap(); + poll.register(&sock, Token(0), Ready::empty(), PollOpt::edge()) + .unwrap(); let client = TcpStream::connect(&addr).unwrap(); // The connect is not guaranteed to have started until it is registered // https://docs.rs/mio/0.6.10/mio/struct.Poll.html#registering-handles - poll.register(&client, Token(1), Ready::empty(), PollOpt::edge()).unwrap(); + poll.register(&client, Token(1), Ready::empty(), PollOpt::edge()) + .unwrap(); // sock is registered with empty interest, we should not receive any event - poll.poll(&mut events, Some(Duration::from_millis(100))).unwrap(); - assert_eq!(events.len(), 0, "Received unexpected event: {:?}", events.get(0).unwrap()); + poll.poll(&mut events, Some(Duration::from_millis(100))) + .unwrap(); + assert_eq!( + events.len(), + 0, + "Received unexpected event: {:?}", + events.get(0).unwrap() + ); // now sock is reregistered with readable, we should receive the pending event - poll.reregister(&sock, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); - expect_events(&poll, &mut events, 2, vec![ - Event::new(Ready::readable(), Token(0)) - ]); - - poll.reregister(&sock, Token(0), Ready::empty(), PollOpt::edge()).unwrap(); + poll.reregister(&sock, Token(0), Ready::readable(), PollOpt::edge()) + .unwrap(); + expect_events( + &poll, + &mut events, + 2, + vec![Event::new(Ready::readable(), Token(0))], + ); + + poll.reregister(&sock, Token(0), Ready::empty(), PollOpt::edge()) + .unwrap(); } diff --git a/test/test_register_multiple_event_loops.rs b/test/test_register_multiple_event_loops.rs index 9204afaf6..14182c6d5 100644 --- a/test/test_register_multiple_event_loops.rs +++ b/test/test_register_multiple_event_loops.rs @@ -1,6 +1,6 @@ use localhost; -use mio::*; use mio::net::{TcpListener, TcpStream, UdpSocket}; +use mio::*; use std::io::ErrorKind; #[test] @@ -9,33 +9,65 @@ fn test_tcp_register_multiple_event_loops() { let listener = TcpListener::bind(&addr).unwrap(); let poll1 = Poll::new().unwrap(); - poll1.register(&listener, Token(0), Ready::readable() | Ready::writable(), PollOpt::edge()).unwrap(); + poll1 + .register( + &listener, + Token(0), + Ready::readable() | Ready::writable(), + PollOpt::edge(), + ).unwrap(); let poll2 = Poll::new().unwrap(); // Try registering the same socket with the initial one - let res = poll2.register(&listener, Token(0), Ready::readable() | Ready::writable(), PollOpt::edge()); + let res = poll2.register( + &listener, + Token(0), + Ready::readable() | Ready::writable(), + PollOpt::edge(), + ); assert!(res.is_err()); assert_eq!(res.unwrap_err().kind(), ErrorKind::Other); // Try cloning the socket and registering it again let listener2 = listener.try_clone().unwrap(); - let res = poll2.register(&listener2, Token(0), Ready::readable() | Ready::writable(), PollOpt::edge()); + let res = poll2.register( + &listener2, + Token(0), + Ready::readable() | Ready::writable(), + PollOpt::edge(), + ); assert!(res.is_err()); assert_eq!(res.unwrap_err().kind(), ErrorKind::Other); // Try the stream let stream = TcpStream::connect(&addr).unwrap(); - poll1.register(&stream, Token(1), Ready::readable() | Ready::writable(), PollOpt::edge()).unwrap(); + poll1 + .register( + &stream, + Token(1), + Ready::readable() | Ready::writable(), + PollOpt::edge(), + ).unwrap(); - let res = poll2.register(&stream, Token(1), Ready::readable() | Ready::writable(), PollOpt::edge()); + let res = poll2.register( + &stream, + Token(1), + Ready::readable() | Ready::writable(), + PollOpt::edge(), + ); assert!(res.is_err()); assert_eq!(res.unwrap_err().kind(), ErrorKind::Other); // Try cloning the socket and registering it again let stream2 = stream.try_clone().unwrap(); - let res = poll2.register(&stream2, Token(1), Ready::readable() | Ready::writable(), PollOpt::edge()); + let res = poll2.register( + &stream2, + Token(1), + Ready::readable() | Ready::writable(), + PollOpt::edge(), + ); assert!(res.is_err()); assert_eq!(res.unwrap_err().kind(), ErrorKind::Other); } @@ -46,18 +78,34 @@ fn test_udp_register_multiple_event_loops() { let socket = UdpSocket::bind(&addr).unwrap(); let poll1 = Poll::new().unwrap(); - poll1.register(&socket, Token(0), Ready::readable() | Ready::writable(), PollOpt::edge()).unwrap(); + poll1 + .register( + &socket, + Token(0), + Ready::readable() | Ready::writable(), + PollOpt::edge(), + ).unwrap(); let poll2 = Poll::new().unwrap(); // Try registering the same socket with the initial one - let res = poll2.register(&socket, Token(0), Ready::readable() | Ready::writable(), PollOpt::edge()); + let res = poll2.register( + &socket, + Token(0), + Ready::readable() | Ready::writable(), + PollOpt::edge(), + ); assert!(res.is_err()); assert_eq!(res.unwrap_err().kind(), ErrorKind::Other); // Try cloning the socket and registering it again let socket2 = socket.try_clone().unwrap(); - let res = poll2.register(&socket2, Token(0), Ready::readable() | Ready::writable(), PollOpt::edge()); + let res = poll2.register( + &socket2, + Token(0), + Ready::readable() | Ready::writable(), + PollOpt::edge(), + ); assert!(res.is_err()); assert_eq!(res.unwrap_err().kind(), ErrorKind::Other); } diff --git a/test/test_reregister_without_poll.rs b/test/test_reregister_without_poll.rs index 45d5aca49..aeed33330 100644 --- a/test/test_reregister_without_poll.rs +++ b/test/test_reregister_without_poll.rs @@ -1,6 +1,6 @@ -use {sleep_ms}; -use mio::*; use mio::net::{TcpListener, TcpStream}; +use mio::*; +use sleep_ms; use std::time::Duration; const MS: u64 = 1_000; @@ -14,15 +14,27 @@ pub fn test_reregister_different_without_poll() { let l = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); // Register the listener with `Poll` - poll.register(&l, Token(0), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); + poll.register( + &l, + Token(0), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); let s1 = TcpStream::connect(&l.local_addr().unwrap()).unwrap(); - poll.register(&s1, Token(2), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&s1, Token(2), Ready::readable(), PollOpt::edge()) + .unwrap(); sleep_ms(MS); - poll.reregister(&l, Token(0), Ready::writable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); + poll.reregister( + &l, + Token(0), + Ready::writable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); - poll.poll(&mut events, Some(Duration::from_millis(MS))).unwrap(); + poll.poll(&mut events, Some(Duration::from_millis(MS))) + .unwrap(); assert_eq!(events.len(), 0); } diff --git a/test/test_smoke.rs b/test/test_smoke.rs index 96f7d3c9e..79eba01da 100644 --- a/test/test_smoke.rs +++ b/test/test_smoke.rs @@ -1,14 +1,15 @@ extern crate mio; -use mio::{Events, Poll, Token, Ready, PollOpt}; use mio::net::TcpListener; +use mio::{Events, Poll, PollOpt, Ready, Token}; use std::time::Duration; #[test] fn run_once_with_nothing() { let mut events = Events::with_capacity(1024); let poll = Poll::new().unwrap(); - poll.poll(&mut events, Some(Duration::from_millis(100))).unwrap(); + poll.poll(&mut events, Some(Duration::from_millis(100))) + .unwrap(); } #[test] @@ -16,8 +17,13 @@ fn add_then_drop() { let mut events = Events::with_capacity(1024); let l = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); let poll = Poll::new().unwrap(); - poll.register(&l, Token(1), Ready::readable() | Ready::writable(), PollOpt::edge()).unwrap(); + poll.register( + &l, + Token(1), + Ready::readable() | Ready::writable(), + PollOpt::edge(), + ).unwrap(); drop(l); - poll.poll(&mut events, Some(Duration::from_millis(100))).unwrap(); - + poll.poll(&mut events, Some(Duration::from_millis(100))) + .unwrap(); } diff --git a/test/test_subprocess_pipe.rs b/test/test_subprocess_pipe.rs index 2bcf13248..6dc4d3d9e 100644 --- a/test/test_subprocess_pipe.rs +++ b/test/test_subprocess_pipe.rs @@ -1,42 +1,45 @@ -use {TryRead, TryWrite}; -use std::mem; +use mio::deprecated::unix::{PipeReader, PipeWriter}; +use mio::deprecated::{EventLoop, Handler}; use mio::*; use std::io; -use mio::deprecated::{EventLoop, Handler}; -use mio::deprecated::unix::{PipeReader, PipeWriter}; -use std::process::{Command, Stdio, Child}; - +use std::mem; +use std::process::{Child, Command, Stdio}; +use {TryRead, TryWrite}; struct SubprocessClient { stdin: Option, stdout: Option, stderr: Option, - stdin_token : Token, - stdout_token : Token, - stderr_token : Token, - output : Vec, - output_stderr : Vec, - input : Vec, - input_offset : usize, - buf : [u8; 65536], + stdin_token: Token, + stdout_token: Token, + stderr_token: Token, + output: Vec, + output_stderr: Vec, + input: Vec, + input_offset: usize, + buf: [u8; 65536], } - // Sends a message and expects to receive the same exact message, one at a time impl SubprocessClient { - fn new(stdin: Option, stdout : Option, stderr : Option, data : &[u8]) -> SubprocessClient { + fn new( + stdin: Option, + stdout: Option, + stderr: Option, + data: &[u8], + ) -> SubprocessClient { SubprocessClient { stdin: stdin, stdout: stdout, stderr: stderr, - stdin_token : Token(0), - stdout_token : Token(1), - stderr_token : Token(2), - output : Vec::::new(), - output_stderr : Vec::::new(), - buf : [0; 65536], - input : data.to_vec(), - input_offset : 0, + stdin_token: Token(0), + stdout_token: Token(1), + stderr_token: Token(2), + output: Vec::::new(), + output_stderr: Vec::::new(), + buf: [0; 65536], + input: data.to_vec(), + input_offset: 0, } } @@ -44,26 +47,25 @@ impl SubprocessClient { let mut eof = false; match self.stdout { None => unreachable!(), - Some (ref mut stdout) => match stdout.try_read(&mut self.buf[..]) { - Ok(None) => { - } + Some(ref mut stdout) => match stdout.try_read(&mut self.buf[..]) { + Ok(None) => {} Ok(Some(r)) => { if r == 0 { eof = true; } else { - self.output.extend(&self.buf[0..r]); + self.output.extend(&self.buf[0..r]); } } Err(e) => { return Err(e); } - } + }, }; if eof { drop(self.stdout.take()); match self.stderr { None => event_loop.shutdown(), - Some(_) => {}, + Some(_) => {} } } return Ok(()); @@ -74,8 +76,7 @@ impl SubprocessClient { match self.stderr { None => unreachable!(), Some(ref mut stderr) => match stderr.try_read(&mut self.buf[..]) { - Ok(None) => { - } + Ok(None) => {} Ok(Some(r)) => { if r == 0 { eof = true; @@ -86,14 +87,14 @@ impl SubprocessClient { Err(e) => { return Err(e); } - } + }, }; if eof { - drop(self.stderr.take()); - match self.stdout { - None => event_loop.shutdown(), - Some(_) => {}, - } + drop(self.stderr.take()); + match self.stdout { + None => event_loop.shutdown(), + Some(_) => {} + } } return Ok(()); } @@ -103,41 +104,38 @@ impl SubprocessClient { match self.stdin { None => unreachable!(), Some(ref mut stdin) => match stdin.try_write(&(&self.input)[self.input_offset..]) { - Ok(None) => { - }, + Ok(None) => {} Ok(Some(r)) => { if r == 0 { ok = false; } else { self.input_offset += r; } - }, + } Err(_) => { ok = false; - }, - } + } + }, } if self.input_offset == self.input.len() || !ok { drop(self.stdin.take()); match self.stderr { None => match self.stdout { - None => event_loop.shutdown(), - Some(_) => {}, + None => event_loop.shutdown(), + Some(_) => {} }, - Some(_) => {}, + Some(_) => {} } } return Ok(()); } - } impl Handler for SubprocessClient { type Timeout = usize; type Message = (); - fn ready(&mut self, event_loop: &mut EventLoop, token: Token, - _: Ready) { + fn ready(&mut self, event_loop: &mut EventLoop, token: Token, _: Ready) { if token == self.stderr_token { let _x = self.readable_stderr(event_loop); } else { @@ -149,17 +147,14 @@ impl Handler for SubprocessClient { } } - - - -const TEST_DATA : [u8; 1024 * 4096] = [42; 1024 * 4096]; -pub fn subprocess_communicate(mut process : Child, input : &[u8]) -> (Vec, Vec) { +const TEST_DATA: [u8; 1024 * 4096] = [42; 1024 * 4096]; +pub fn subprocess_communicate(mut process: Child, input: &[u8]) -> (Vec, Vec) { let mut event_loop = EventLoop::::new().unwrap(); - let stdin : Option; - let stdin_exists : bool; + let stdin: Option; + let stdin_exists: bool; match process.stdin { - None => stdin_exists = false, - Some(_) => stdin_exists = true, + None => stdin_exists = false, + Some(_) => stdin_exists = true, } if stdin_exists { match PipeWriter::from_stdin(process.stdin.take().unwrap()) { @@ -169,11 +164,11 @@ pub fn subprocess_communicate(mut process : Child, input : &[u8]) -> (Vec, V } else { stdin = None; } - let stdout_exists : bool; - let stdout : Option; + let stdout_exists: bool; + let stdout: Option; match process.stdout { - None => stdout_exists = false, - Some(_) => stdout_exists = true, + None => stdout_exists = false, + Some(_) => stdout_exists = true, } if stdout_exists { match PipeReader::from_stdout(process.stdout.take().unwrap()) { @@ -183,42 +178,54 @@ pub fn subprocess_communicate(mut process : Child, input : &[u8]) -> (Vec, V } else { stdout = None; } - let stderr_exists : bool; - let stderr : Option; + let stderr_exists: bool; + let stderr: Option; match process.stderr { - None => stderr_exists = false, - Some(_) => stderr_exists = true, + None => stderr_exists = false, + Some(_) => stderr_exists = true, } if stderr_exists { match PipeReader::from_stderr(process.stderr.take().unwrap()) { - Err(e) => panic!(e), - Ok(pipe) => stderr = Some(pipe), + Err(e) => panic!(e), + Ok(pipe) => stderr = Some(pipe), } } else { stderr = None } - let mut subprocess = SubprocessClient::new(stdin, - stdout, - stderr, - input); + let mut subprocess = SubprocessClient::new(stdin, stdout, stderr, input); match subprocess.stdout { - Some(ref sub_stdout) => event_loop.register(sub_stdout, subprocess.stdout_token, Ready::readable(), - PollOpt::level()).unwrap(), - None => {}, + Some(ref sub_stdout) => event_loop + .register( + sub_stdout, + subprocess.stdout_token, + Ready::readable(), + PollOpt::level(), + ).unwrap(), + None => {} } match subprocess.stderr { - Some(ref sub_stderr) => event_loop.register(sub_stderr, subprocess.stderr_token, Ready::readable(), - PollOpt::level()).unwrap(), - None => {}, + Some(ref sub_stderr) => event_loop + .register( + sub_stderr, + subprocess.stderr_token, + Ready::readable(), + PollOpt::level(), + ).unwrap(), + None => {} } // Connect to the server match subprocess.stdin { - Some (ref sub_stdin) => event_loop.register(sub_stdin, subprocess.stdin_token, Ready::writable(), - PollOpt::level()).unwrap(), - None => {}, + Some(ref sub_stdin) => event_loop + .register( + sub_stdin, + subprocess.stdin_token, + Ready::writable(), + PollOpt::level(), + ).unwrap(), + None => {} } // Start the event loop @@ -232,18 +239,18 @@ pub fn subprocess_communicate(mut process : Child, input : &[u8]) -> (Vec, V #[test] fn test_subprocess_pipe() { - let process = - Command::new("/bin/cat") - .stdin(Stdio::piped()) - .stdout(Stdio::piped()) - .stderr(Stdio::piped()) - .spawn().unwrap(); - let (ret_stdout, ret_stderr) = subprocess_communicate(process, &TEST_DATA[..]); - assert_eq!(TEST_DATA.len(), ret_stdout.len()); - assert_eq!(0usize, ret_stderr.len()); - let mut i : usize = 0; - for item in TEST_DATA.iter() { - assert_eq!(*item, ret_stdout[i]); - i += 1; - } + let process = Command::new("/bin/cat") + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn() + .unwrap(); + let (ret_stdout, ret_stderr) = subprocess_communicate(process, &TEST_DATA[..]); + assert_eq!(TEST_DATA.len(), ret_stdout.len()); + assert_eq!(0usize, ret_stderr.len()); + let mut i: usize = 0; + for item in TEST_DATA.iter() { + assert_eq!(*item, ret_stdout[i]); + i += 1; + } } diff --git a/test/test_tcp.rs b/test/test_tcp.rs index 2587c314f..729629579 100644 --- a/test/test_tcp.rs +++ b/test/test_tcp.rs @@ -1,6 +1,6 @@ use std::cmp; -use std::io::prelude::*; use std::io; +use std::io::prelude::*; use std::net; use std::sync::mpsc::channel; use std::thread; @@ -8,14 +8,18 @@ use std::time::Duration; use net2::{self, TcpStreamExt}; -use {TryRead, TryWrite}; -use mio::{Token, Ready, PollOpt, Poll, Events}; use iovec::IoVec; use mio::net::{TcpListener, TcpStream}; +use mio::{Events, Poll, PollOpt, Ready, Token}; +use {TryRead, TryWrite}; #[test] fn accept() { - struct H { hit: bool, listener: TcpListener, shutdown: bool } + struct H { + hit: bool, + listener: TcpListener, + shutdown: bool, + } let l = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); let addr = l.local_addr().unwrap(); @@ -26,11 +30,16 @@ fn accept() { let poll = Poll::new().unwrap(); - poll.register(&l, Token(1), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&l, Token(1), Ready::readable(), PollOpt::edge()) + .unwrap(); let mut events = Events::with_capacity(128); - let mut h = H { hit: false, listener: l, shutdown: false }; + let mut h = H { + hit: false, + listener: l, + shutdown: false, + }; while !h.shutdown { poll.poll(&mut events, None).unwrap(); @@ -49,7 +58,10 @@ fn accept() { #[test] fn connect() { - struct H { hit: u32, shutdown: bool } + struct H { + hit: u32, + shutdown: bool, + } let l = net::TcpListener::bind("127.0.0.1:0").unwrap(); let addr = l.local_addr().unwrap(); @@ -66,11 +78,19 @@ fn connect() { let poll = Poll::new().unwrap(); let s = TcpStream::connect(&addr).unwrap(); - poll.register(&s, Token(1), Ready::readable() | Ready::writable(), PollOpt::edge()).unwrap(); + poll.register( + &s, + Token(1), + Ready::readable() | Ready::writable(), + PollOpt::edge(), + ).unwrap(); let mut events = Events::with_capacity(128); - let mut h = H { hit: 0, shutdown: false }; + let mut h = H { + hit: 0, + shutdown: false, + }; while !h.shutdown { poll.poll(&mut events, None).unwrap(); @@ -110,7 +130,11 @@ fn connect() { #[test] fn read() { const N: usize = 16 * 1024 * 1024; - struct H { amt: usize, socket: TcpStream, shutdown: bool } + struct H { + amt: usize, + socket: TcpStream, + shutdown: bool, + } let l = net::TcpListener::bind("127.0.0.1:0").unwrap(); let addr = l.local_addr().unwrap(); @@ -127,11 +151,16 @@ fn read() { let poll = Poll::new().unwrap(); let s = TcpStream::connect(&addr).unwrap(); - poll.register(&s, Token(1), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&s, Token(1), Ready::readable(), PollOpt::edge()) + .unwrap(); let mut events = Events::with_capacity(128); - let mut h = H { amt: 0, socket: s, shutdown: false }; + let mut h = H { + amt: 0, + socket: s, + shutdown: false, + }; while !h.shutdown { poll.poll(&mut events, None).unwrap(); @@ -142,11 +171,11 @@ fn read() { if let Some(amt) = h.socket.try_read(&mut b).unwrap() { h.amt += amt; } else { - break + break; } if h.amt >= N { h.shutdown = true; - break + break; } } } @@ -157,7 +186,11 @@ fn read() { #[test] fn peek() { const N: usize = 16 * 1024 * 1024; - struct H { amt: usize, socket: TcpStream, shutdown: bool } + struct H { + amt: usize, + socket: TcpStream, + shutdown: bool, + } let l = net::TcpListener::bind("127.0.0.1:0").unwrap(); let addr = l.local_addr().unwrap(); @@ -174,11 +207,16 @@ fn peek() { let poll = Poll::new().unwrap(); let s = TcpStream::connect(&addr).unwrap(); - poll.register(&s, Token(1), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&s, Token(1), Ready::readable(), PollOpt::edge()) + .unwrap(); let mut events = Events::with_capacity(128); - let mut h = H { amt: 0, socket: s, shutdown: false }; + let mut h = H { + amt: 0, + socket: s, + shutdown: false, + }; while !h.shutdown { poll.poll(&mut events, None).unwrap(); @@ -187,9 +225,7 @@ fn peek() { let mut b = [0; 1024]; match h.socket.peek(&mut b) { Ok(_) => (), - Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => { - continue - }, + Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => continue, Err(e) => panic!("unexpected error: {:?}", e), } @@ -197,11 +233,11 @@ fn peek() { if let Some(amt) = h.socket.try_read(&mut b).unwrap() { h.amt += amt; } else { - break + break; } if h.amt >= N { h.shutdown = true; - break + break; } } } @@ -230,20 +266,15 @@ fn read_bufs() { let s = TcpStream::connect(&addr).unwrap(); - poll.register(&s, Token(1), Ready::readable(), PollOpt::level()).unwrap(); + poll.register(&s, Token(1), Ready::readable(), PollOpt::level()) + .unwrap(); let b1 = &mut [0; 10][..]; let b2 = &mut [0; 383][..]; let b3 = &mut [0; 28][..]; let b4 = &mut [0; 8][..]; let b5 = &mut [0; 128][..]; - let mut b: [&mut IoVec; 5] = [ - b1.into(), - b2.into(), - b3.into(), - b4.into(), - b5.into(), - ]; + let mut b: [&mut IoVec; 5] = [b1.into(), b2.into(), b3.into(), b4.into(), b5.into()]; let mut so_far = 0; loop { @@ -258,7 +289,7 @@ fn read_bufs() { match s.read_bufs(&mut b) { Ok(0) => { assert_eq!(so_far, N); - break + break; } Ok(mut n) => { so_far += n; @@ -269,7 +300,7 @@ fn read_bufs() { } n = n.saturating_sub(buf.len()); if n == 0 { - break + break; } } assert_eq!(n, 0); @@ -284,7 +315,11 @@ fn read_bufs() { #[test] fn write() { const N: usize = 16 * 1024 * 1024; - struct H { amt: usize, socket: TcpStream, shutdown: bool } + struct H { + amt: usize, + socket: TcpStream, + shutdown: bool, + } let l = net::TcpListener::bind("127.0.0.1:0").unwrap(); let addr = l.local_addr().unwrap(); @@ -301,11 +336,16 @@ fn write() { let poll = Poll::new().unwrap(); let s = TcpStream::connect(&addr).unwrap(); - poll.register(&s, Token(1), Ready::writable(), PollOpt::edge()).unwrap(); + poll.register(&s, Token(1), Ready::writable(), PollOpt::edge()) + .unwrap(); let mut events = Events::with_capacity(128); - let mut h = H { amt: 0, socket: s, shutdown: false }; + let mut h = H { + amt: 0, + socket: s, + shutdown: false, + }; while !h.shutdown { poll.poll(&mut events, None).unwrap(); @@ -316,11 +356,11 @@ fn write() { if let Some(amt) = h.socket.try_write(&b).unwrap() { h.amt += amt; } else { - break + break; } if h.amt >= N { h.shutdown = true; - break + break; } } } @@ -354,20 +394,15 @@ fn write_bufs() { let poll = Poll::new().unwrap(); let mut events = Events::with_capacity(128); let s = TcpStream::connect(&addr).unwrap(); - poll.register(&s, Token(1), Ready::writable(), PollOpt::level()).unwrap(); + poll.register(&s, Token(1), Ready::writable(), PollOpt::level()) + .unwrap(); let b1 = &[1; 10][..]; let b2 = &[1; 383][..]; let b3 = &[1; 28][..]; let b4 = &[1; 8][..]; let b5 = &[1; 128][..]; - let b: [&IoVec; 5] = [ - b1.into(), - b2.into(), - b3.into(), - b4.into(), - b5.into(), - ]; + let b: [&IoVec; 5] = [b1.into(), b2.into(), b3.into(), b4.into(), b5.into()]; let mut so_far = 0; while so_far < N { @@ -384,26 +419,38 @@ fn write_bufs() { #[test] fn connect_then_close() { - struct H { listener: TcpListener, shutdown: bool } + struct H { + listener: TcpListener, + shutdown: bool, + } let poll = Poll::new().unwrap(); let l = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); let s = TcpStream::connect(&l.local_addr().unwrap()).unwrap(); - poll.register(&l, Token(1), Ready::readable(), PollOpt::edge()).unwrap(); - poll.register(&s, Token(2), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&l, Token(1), Ready::readable(), PollOpt::edge()) + .unwrap(); + poll.register(&s, Token(2), Ready::readable(), PollOpt::edge()) + .unwrap(); let mut events = Events::with_capacity(128); - let mut h = H { listener: l, shutdown: false }; + let mut h = H { + listener: l, + shutdown: false, + }; while !h.shutdown { poll.poll(&mut events, None).unwrap(); for event in &events { if event.token() == Token(1) { let s = h.listener.accept().unwrap().0; - poll.register(&s, Token(3), Ready::readable() | Ready::writable(), - PollOpt::edge()).unwrap(); + poll.register( + &s, + Token(3), + Ready::readable() | Ready::writable(), + PollOpt::edge(), + ).unwrap(); drop(s); } else if event.token() == Token(2) { h.shutdown = true; @@ -417,12 +464,14 @@ fn listen_then_close() { let poll = Poll::new().unwrap(); let l = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); - poll.register(&l, Token(1), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&l, Token(1), Ready::readable(), PollOpt::edge()) + .unwrap(); drop(l); let mut events = Events::with_capacity(128); - poll.poll(&mut events, Some(Duration::from_millis(100))).unwrap(); + poll.poll(&mut events, Some(Duration::from_millis(100))) + .unwrap(); for event in &events { if event.token() == Token(1) { @@ -431,11 +480,9 @@ fn listen_then_close() { } } -fn assert_send() { -} +fn assert_send() {} -fn assert_sync() { -} +fn assert_sync() {} #[test] fn test_tcp_sockets_are_send() { @@ -462,7 +509,7 @@ fn multiple_writes_immediate_success() { let mut s = l.accept().unwrap().0; let mut b = [0; 1024]; let mut amt = 0; - while amt < 1024*N { + while amt < 1024 * N { for byte in b.iter_mut() { *byte = 0; } @@ -476,7 +523,8 @@ fn multiple_writes_immediate_success() { let poll = Poll::new().unwrap(); let mut s = TcpStream::connect(&addr).unwrap(); - poll.register(&s, Token(1), Ready::writable(), PollOpt::level()).unwrap(); + poll.register(&s, Token(1), Ready::writable(), PollOpt::level()) + .unwrap(); let mut events = Events::with_capacity(16); // Wait for our TCP stream to connect @@ -484,7 +532,7 @@ fn multiple_writes_immediate_success() { poll.poll(&mut events, None).unwrap(); for event in events.iter() { if event.token() == Token(1) && event.readiness().is_writable() { - break 'outer + break 'outer; } } } @@ -507,8 +555,7 @@ fn connection_reset_by_peer() { let addr = l.local_addr().unwrap(); // Connect client - let client = net2::TcpBuilder::new_v4().unwrap() - .to_tcp_stream().unwrap(); + let client = net2::TcpBuilder::new_v4().unwrap().to_tcp_stream().unwrap(); client.set_linger(Some(Duration::from_millis(0))).unwrap(); client.connect(&addr).unwrap(); @@ -517,15 +564,20 @@ fn connection_reset_by_peer() { let client = TcpStream::from_stream(client).unwrap(); // Register server - poll.register(&l, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&l, Token(0), Ready::readable(), PollOpt::edge()) + .unwrap(); // Register interest in the client - poll.register(&client, Token(1), Ready::readable() | Ready::writable(), PollOpt::edge()).unwrap(); + poll.register( + &client, + Token(1), + Ready::readable() | Ready::writable(), + PollOpt::edge(), + ).unwrap(); // Wait for listener to be ready let mut server; - 'outer: - loop { + 'outer: loop { poll.poll(&mut events, None).unwrap(); for event in &events { @@ -549,8 +601,8 @@ fn connection_reset_by_peer() { thread::sleep(Duration::from_millis(100)); // Register interest in the server socket - poll.register(&server, Token(3), Ready::readable(), PollOpt::edge()).unwrap(); - + poll.register(&server, Token(3), Ready::readable(), PollOpt::edge()) + .unwrap(); loop { poll.poll(&mut events, None).unwrap(); @@ -560,8 +612,7 @@ fn connection_reset_by_peer() { assert!(event.readiness().is_readable()); match server.read(&mut buf) { - Ok(0) | - Err(_) => {}, + Ok(0) | Err(_) => {} Ok(x) => panic!("expected empty buffer but read {} bytes", x), } @@ -569,7 +620,6 @@ fn connection_reset_by_peer() { } } } - } #[test] @@ -585,20 +635,20 @@ fn connect_error() { // Connection failed synchronously. This is not a bug, but it // unfortunately doesn't get us the code coverage we want. return; - }, - Err(e) => panic!("TcpStream::connect unexpected error {:?}", e) + } + Err(e) => panic!("TcpStream::connect unexpected error {:?}", e), }; - poll.register(&l, Token(0), Ready::writable(), PollOpt::edge()).unwrap(); + poll.register(&l, Token(0), Ready::writable(), PollOpt::edge()) + .unwrap(); - 'outer: - loop { + 'outer: loop { poll.poll(&mut events, None).unwrap(); for event in &events { if event.token() == Token(0) { assert!(event.readiness().is_writable()); - break 'outer + break 'outer; } } } @@ -621,20 +671,19 @@ fn write_error() { }); let mut s = TcpStream::connect(&addr).unwrap(); - poll.register(&s, - Token(0), - Ready::readable() | Ready::writable(), - PollOpt::edge()).unwrap(); - - let mut wait_writable = || { - 'outer: - loop { - poll.poll(&mut events, None).unwrap(); - - for event in &events { - if event.token() == Token(0) && event.readiness().is_writable() { - break 'outer - } + poll.register( + &s, + Token(0), + Ready::readable() | Ready::writable(), + PollOpt::edge(), + ).unwrap(); + + let mut wait_writable = || 'outer: loop { + poll.poll(&mut events, None).unwrap(); + + for event in &events { + if event.token() == Token(0) && event.readiness().is_writable() { + break 'outer; } } }; @@ -648,12 +697,10 @@ fn write_error() { loop { match s.write(&buf) { Ok(_) => {} - Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => { - wait_writable() - } + Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => wait_writable(), Err(e) => { println!("good error: {}", e); - break + break; } } } diff --git a/test/test_tcp_level.rs b/test/test_tcp_level.rs index e52385c3d..aa56f0c7a 100644 --- a/test/test_tcp_level.rs +++ b/test/test_tcp_level.rs @@ -1,9 +1,9 @@ -use {expect_events, sleep_ms, TryRead}; -use mio::{Events, Poll, PollOpt, Ready, Token}; use mio::event::Event; use mio::net::{TcpListener, TcpStream}; +use mio::{Events, Poll, PollOpt, Ready, Token}; use std::io::Write; use std::time::Duration; +use {expect_events, sleep_ms, TryRead}; const MS: u64 = 1_000; @@ -16,20 +16,24 @@ pub fn test_tcp_listener_level_triggered() { let l = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); // Register the listener with `Poll` - poll.register(&l, Token(0), Ready::readable(), PollOpt::level()).unwrap(); + poll.register(&l, Token(0), Ready::readable(), PollOpt::level()) + .unwrap(); let s1 = TcpStream::connect(&l.local_addr().unwrap()).unwrap(); - poll.register(&s1, Token(1), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&s1, Token(1), Ready::readable(), PollOpt::edge()) + .unwrap(); while filter(&pevents, Token(0)).len() == 0 { - poll.poll(&mut pevents, Some(Duration::from_millis(MS))).unwrap(); + poll.poll(&mut pevents, Some(Duration::from_millis(MS))) + .unwrap(); } let events = filter(&pevents, Token(0)); assert_eq!(events.len(), 1); assert_eq!(events[0], Event::new(Ready::readable(), Token(0))); - poll.poll(&mut pevents, Some(Duration::from_millis(MS))).unwrap(); + poll.poll(&mut pevents, Some(Duration::from_millis(MS))) + .unwrap(); let events = filter(&pevents, Token(0)); assert_eq!(events.len(), 1); assert_eq!(events[0], Event::new(Ready::readable(), Token(0))); @@ -37,15 +41,18 @@ pub fn test_tcp_listener_level_triggered() { // Accept the connection then test that the events stop let _ = l.accept().unwrap(); - poll.poll(&mut pevents, Some(Duration::from_millis(MS))).unwrap(); + poll.poll(&mut pevents, Some(Duration::from_millis(MS))) + .unwrap(); let events = filter(&pevents, Token(0)); assert!(events.is_empty(), "actual={:?}", events); let s3 = TcpStream::connect(&l.local_addr().unwrap()).unwrap(); - poll.register(&s3, Token(2), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&s3, Token(2), Ready::readable(), PollOpt::edge()) + .unwrap(); while filter(&pevents, Token(0)).len() == 0 { - poll.poll(&mut pevents, Some(Duration::from_millis(MS))).unwrap(); + poll.poll(&mut pevents, Some(Duration::from_millis(MS))) + .unwrap(); } let events = filter(&pevents, Token(0)); @@ -54,7 +61,8 @@ pub fn test_tcp_listener_level_triggered() { drop(l); - poll.poll(&mut pevents, Some(Duration::from_millis(MS))).unwrap(); + poll.poll(&mut pevents, Some(Duration::from_millis(MS))) + .unwrap(); let events = filter(&pevents, Token(0)); assert!(events.is_empty()); } @@ -69,18 +77,29 @@ pub fn test_tcp_stream_level_triggered() { let l = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); // Register the listener with `Poll` - poll.register(&l, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&l, Token(0), Ready::readable(), PollOpt::edge()) + .unwrap(); let mut s1 = TcpStream::connect(&l.local_addr().unwrap()).unwrap(); - poll.register(&s1, Token(1), Ready::readable() | Ready::writable(), PollOpt::level()).unwrap(); + poll.register( + &s1, + Token(1), + Ready::readable() | Ready::writable(), + PollOpt::level(), + ).unwrap(); // Sleep a bit to ensure it arrives at dest sleep_ms(250); - expect_events(&poll, &mut pevents, 2, vec![ - Event::new(Ready::readable(), Token(0)), - Event::new(Ready::writable(), Token(1)), - ]); + expect_events( + &poll, + &mut pevents, + 2, + vec![ + Event::new(Ready::readable(), Token(0)), + Event::new(Ready::writable(), Token(1)), + ], + ); // Server side of socket let (mut s1_tx, _) = l.accept().unwrap(); @@ -88,12 +107,16 @@ pub fn test_tcp_stream_level_triggered() { // Sleep a bit to ensure it arrives at dest sleep_ms(250); - expect_events(&poll, &mut pevents, 2, vec![ - Event::new(Ready::writable(), Token(1)) - ]); + expect_events( + &poll, + &mut pevents, + 2, + vec![Event::new(Ready::writable(), Token(1))], + ); // Register the socket - poll.register(&s1_tx, Token(123), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&s1_tx, Token(123), Ready::readable(), PollOpt::edge()) + .unwrap(); debug!("writing some data ----------"); @@ -107,36 +130,44 @@ pub fn test_tcp_stream_level_triggered() { debug!("looking at rx end ----------"); // Poll rx end - expect_events(&poll, &mut pevents, 2, vec![ - Event::new(Ready::readable(), Token(1)) - ]); + expect_events( + &poll, + &mut pevents, + 2, + vec![Event::new(Ready::readable(), Token(1))], + ); debug!("reading ----------"); // Reading the data should clear it let mut res = vec![]; - while s1.try_read_buf(&mut res).unwrap().is_some() { - } + while s1.try_read_buf(&mut res).unwrap().is_some() {} assert_eq!(res, b"hello world!"); debug!("checking just read ----------"); - expect_events(&poll, &mut pevents, 1, vec![ - Event::new(Ready::writable(), Token(1))]); + expect_events( + &poll, + &mut pevents, + 1, + vec![Event::new(Ready::writable(), Token(1))], + ); // Closing the socket clears all active level events drop(s1); debug!("checking everything is gone ----------"); - poll.poll(&mut pevents, Some(Duration::from_millis(MS))).unwrap(); + poll.poll(&mut pevents, Some(Duration::from_millis(MS))) + .unwrap(); let events = filter(&pevents, Token(1)); assert!(events.is_empty()); } fn filter(events: &Events, token: Token) -> Vec { - (0..events.len()).map(|i| events.get(i).unwrap()) - .filter(|e| e.token() == token) - .collect() + (0..events.len()) + .map(|i| events.get(i).unwrap()) + .filter(|e| e.token() == token) + .collect() } diff --git a/test/test_tick.rs b/test/test_tick.rs index 76587eb32..aa3c61889 100644 --- a/test/test_tick.rs +++ b/test/test_tick.rs @@ -1,7 +1,7 @@ -use mio::*; use mio::deprecated::{EventLoop, Handler}; use mio::net::{TcpListener, TcpStream}; -use {sleep_ms}; +use mio::*; +use sleep_ms; struct TestHandler { tick: usize, @@ -10,10 +10,7 @@ struct TestHandler { impl TestHandler { fn new() -> TestHandler { - TestHandler { - tick: 0, - state: 0, - } + TestHandler { tick: 0, state: 0 } } } @@ -46,10 +43,14 @@ pub fn test_tick() { let mut event_loop = EventLoop::new().ok().expect("Couldn't make event loop"); let listener = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); - event_loop.register(&listener, Token(0), Ready::readable(), PollOpt::level()).unwrap(); + event_loop + .register(&listener, Token(0), Ready::readable(), PollOpt::level()) + .unwrap(); let client = TcpStream::connect(&listener.local_addr().unwrap()).unwrap(); - event_loop.register(&client, Token(1), Ready::readable(), PollOpt::edge()).unwrap(); + event_loop + .register(&client, Token(1), Ready::readable(), PollOpt::edge()) + .unwrap(); sleep_ms(250); diff --git a/test/test_timer.rs b/test/test_timer.rs index 63d7fb53d..e16bda319 100644 --- a/test/test_timer.rs +++ b/test/test_timer.rs @@ -1,21 +1,23 @@ -use {sleep_ms, TryRead, TryWrite}; -use mio::*; use mio::deprecated::{EventLoop, Handler}; -use mio::timer::{Timer}; +use mio::timer::Timer; +use mio::*; +use {sleep_ms, TryRead, TryWrite}; -use mio::net::{TcpListener, TcpStream}; use bytes::{Buf, ByteBuf, SliceBuf}; use localhost; +use mio::net::{TcpListener, TcpStream}; use std::time::Duration; -use self::TestState::{Initial, AfterRead}; +use self::TestState::{AfterRead, Initial}; #[test] fn test_basic_timer_without_poll() { let mut timer = Timer::default(); // Set the timeout - timer.set_timeout(Duration::from_millis(200), "hello").unwrap(); + timer + .set_timeout(Duration::from_millis(200), "hello") + .unwrap(); // Nothing when polled immediately assert!(timer.poll().is_none()); @@ -35,8 +37,11 @@ fn test_basic_timer_with_poll_edge_set_timeout_after_register() { let mut events = Events::with_capacity(1024); let mut timer = Timer::default(); - poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); - timer.set_timeout(Duration::from_millis(200), "hello").unwrap(); + poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()) + .unwrap(); + timer + .set_timeout(Duration::from_millis(200), "hello") + .unwrap(); let elapsed = elapsed(|| { let num = poll.poll(&mut events, None).unwrap(); @@ -59,8 +64,11 @@ fn test_basic_timer_with_poll_edge_set_timeout_before_register() { let mut events = Events::with_capacity(1024); let mut timer = Timer::default(); - timer.set_timeout(Duration::from_millis(200), "hello").unwrap(); - poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); + timer + .set_timeout(Duration::from_millis(200), "hello") + .unwrap(); + poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()) + .unwrap(); let elapsed = elapsed(|| { let num = poll.poll(&mut events, None).unwrap(); @@ -83,10 +91,15 @@ fn test_setting_later_timeout_then_earlier_one() { let mut events = Events::with_capacity(1024); let mut timer = Timer::default(); - poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()) + .unwrap(); - timer.set_timeout(Duration::from_millis(600), "hello").unwrap(); - timer.set_timeout(Duration::from_millis(200), "world").unwrap(); + timer + .set_timeout(Duration::from_millis(600), "hello") + .unwrap(); + timer + .set_timeout(Duration::from_millis(200), "world") + .unwrap(); let elapsed = elapsed(|| { let num = poll.poll(&mut events, None).unwrap(); @@ -119,16 +132,17 @@ fn test_timer_with_looping_wheel() { let poll = Poll::new().unwrap(); let mut events = Events::with_capacity(1024); - let mut timer = timer::Builder::default() - .num_slots(2) - .build(); + let mut timer = timer::Builder::default().num_slots(2).build(); - poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()) + .unwrap(); - const TOKENS: &'static [ &'static str ] = &[ "hello", "world", "some", "thing" ]; + const TOKENS: &'static [&'static str] = &["hello", "world", "some", "thing"]; for (i, msg) in TOKENS.iter().enumerate() { - timer.set_timeout(Duration::from_millis(500 * (i as u64 + 1)), msg).unwrap(); + timer + .set_timeout(Duration::from_millis(500 * (i as u64 + 1)), msg) + .unwrap(); } for msg in TOKENS { @@ -140,10 +154,14 @@ fn test_timer_with_looping_wheel() { assert_eq!(Ready::readable(), events.get(0).unwrap().readiness()); }); - assert!(is_about(500, elapsed), "actual={:?}; msg={:?}", elapsed, msg); + assert!( + is_about(500, elapsed), + "actual={:?}; msg={:?}", + elapsed, + msg + ); assert_eq!(Some(msg), timer.poll()); assert_eq!(None, timer.poll()); - } } @@ -155,9 +173,12 @@ fn test_edge_without_polling() { let mut events = Events::with_capacity(1024); let mut timer = Timer::default(); - poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()) + .unwrap(); - timer.set_timeout(Duration::from_millis(400), "hello").unwrap(); + timer + .set_timeout(Duration::from_millis(400), "hello") + .unwrap(); let ms = elapsed(|| { let num = poll.poll(&mut events, None).unwrap(); @@ -169,7 +190,9 @@ fn test_edge_without_polling() { assert!(is_about(400, ms), "actual={:?}", ms); let ms = elapsed(|| { - let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); assert_eq!(num, 0); }); @@ -184,9 +207,12 @@ fn test_level_triggered() { let mut events = Events::with_capacity(1024); let mut timer = Timer::default(); - poll.register(&timer, Token(0), Ready::readable(), PollOpt::level()).unwrap(); + poll.register(&timer, Token(0), Ready::readable(), PollOpt::level()) + .unwrap(); - timer.set_timeout(Duration::from_millis(400), "hello").unwrap(); + timer + .set_timeout(Duration::from_millis(400), "hello") + .unwrap(); let ms = elapsed(|| { let num = poll.poll(&mut events, None).unwrap(); @@ -215,9 +241,16 @@ fn test_edge_oneshot_triggered() { let mut events = Events::with_capacity(1024); let mut timer = Timer::default(); - poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); + poll.register( + &timer, + Token(0), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); - timer.set_timeout(Duration::from_millis(200), "hello").unwrap(); + timer + .set_timeout(Duration::from_millis(200), "hello") + .unwrap(); let ms = elapsed(|| { let num = poll.poll(&mut events, None).unwrap(); @@ -227,13 +260,20 @@ fn test_edge_oneshot_triggered() { assert!(is_about(200, ms), "actual={:?}", ms); let ms = elapsed(|| { - let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); + let num = poll + .poll(&mut events, Some(Duration::from_millis(300))) + .unwrap(); assert_eq!(num, 0); }); assert!(is_about(300, ms), "actual={:?}", ms); - poll.reregister(&timer, Token(0), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); + poll.reregister( + &timer, + Token(0), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); let ms = elapsed(|| { let num = poll.poll(&mut events, None).unwrap(); @@ -254,7 +294,8 @@ fn test_cancel_timeout() { timer.cancel_timeout(&timeout); let poll = Poll::new().unwrap(); - poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()) + .unwrap(); let mut events = Events::with_capacity(16); @@ -315,7 +356,7 @@ enum TestState { struct TestHandler { srv: TcpListener, cli: TcpStream, - state: TestState + state: TestState, } impl TestHandler { @@ -323,22 +364,29 @@ impl TestHandler { TestHandler { srv: srv, cli: cli, - state: Initial + state: Initial, } } - fn handle_read(&mut self, event_loop: &mut EventLoop, - tok: Token, _events: Ready) { + fn handle_read(&mut self, event_loop: &mut EventLoop, tok: Token, _events: Ready) { match tok { SERVER => { debug!("server connection ready for accept"); let conn = self.srv.accept().unwrap().0; - event_loop.register(&conn, CONN, Ready::readable() | Ready::writable(), - PollOpt::edge()).unwrap(); - event_loop.timeout(conn, Duration::from_millis(200)).unwrap(); - - event_loop.reregister(&self.srv, SERVER, Ready::readable(), - PollOpt::edge()).unwrap(); + event_loop + .register( + &conn, + CONN, + Ready::readable() | Ready::writable(), + PollOpt::edge(), + ).unwrap(); + event_loop + .timeout(conn, Duration::from_millis(200)) + .unwrap(); + + event_loop + .reregister(&self.srv, SERVER, Ready::readable(), PollOpt::edge()) + .unwrap(); } CLIENT => { debug!("client readable"); @@ -361,17 +409,20 @@ impl TestHandler { } } - event_loop.reregister(&self.cli, CLIENT, - Ready::readable() | Ready::hup(), - PollOpt::edge()).unwrap(); + event_loop + .reregister( + &self.cli, + CLIENT, + Ready::readable() | Ready::hup(), + PollOpt::edge(), + ).unwrap(); } CONN => {} _ => panic!("received unknown token {:?}", tok), } } - fn handle_write(&mut self, event_loop: &mut EventLoop, - tok: Token, _: Ready) { + fn handle_write(&mut self, event_loop: &mut EventLoop, tok: Token, _: Ready) { match tok { SERVER => panic!("received writable for token 0"), CLIENT => debug!("client connected"), @@ -379,8 +430,9 @@ impl TestHandler { _ => panic!("received unknown token {:?}", tok), } - event_loop.reregister(&self.cli, CLIENT, Ready::readable(), - PollOpt::edge()).unwrap(); + event_loop + .reregister(&self.cli, CLIENT, Ready::readable(), PollOpt::edge()) + .unwrap(); } } @@ -400,7 +452,9 @@ impl Handler for TestHandler { fn timeout(&mut self, _event_loop: &mut EventLoop, mut sock: TcpStream) { debug!("timeout handler : writing to socket"); - sock.try_write_buf(&mut SliceBuf::wrap(b"zomg")).unwrap().unwrap(); + sock.try_write_buf(&mut SliceBuf::wrap(b"zomg")) + .unwrap() + .unwrap(); } } @@ -417,12 +471,24 @@ pub fn test_old_timer() { info!("listening for connections"); - event_loop.register(&srv, SERVER, Ready::readable() | Ready::writable(), PollOpt::edge()).unwrap(); + event_loop + .register( + &srv, + SERVER, + Ready::readable() | Ready::writable(), + PollOpt::edge(), + ).unwrap(); let sock = TcpStream::connect(&addr).unwrap(); // Connect to the server - event_loop.register(&sock, CLIENT, Ready::readable() | Ready::writable(), PollOpt::edge()).unwrap(); + event_loop + .register( + &sock, + CLIENT, + Ready::readable() | Ready::writable(), + PollOpt::edge(), + ).unwrap(); // Init the handler let mut handler = TestHandler::new(srv, sock); diff --git a/test/test_udp_level.rs b/test/test_udp_level.rs index 7e19d54b3..e8e1a87ed 100644 --- a/test/test_udp_level.rs +++ b/test/test_udp_level.rs @@ -1,6 +1,6 @@ -use mio::{Events, Poll, PollOpt, Ready, Token}; use mio::event::Event; use mio::net::UdpSocket; +use mio::{Events, Poll, PollOpt, Ready, Token}; use {expect_events, sleep_ms}; #[test] @@ -14,39 +14,67 @@ pub fn test_udp_level_triggered() { let tx = UdpSocket::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); let rx = UdpSocket::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); - poll.register(&tx, Token(0), Ready::readable() | Ready::writable(), PollOpt::level()).unwrap(); - poll.register(&rx, Token(1), Ready::readable() | Ready::writable(), PollOpt::level()).unwrap(); - + poll.register( + &tx, + Token(0), + Ready::readable() | Ready::writable(), + PollOpt::level(), + ).unwrap(); + poll.register( + &rx, + Token(1), + Ready::readable() | Ready::writable(), + PollOpt::level(), + ).unwrap(); for _ in 0..2 { - expect_events(poll, events, 2, vec![ - Event::new(Ready::writable(), Token(0)), - Event::new(Ready::writable(), Token(1)), - ]); + expect_events( + poll, + events, + 2, + vec![ + Event::new(Ready::writable(), Token(0)), + Event::new(Ready::writable(), Token(1)), + ], + ); } - tx.send_to(b"hello world!", &rx.local_addr().unwrap()).unwrap(); + tx.send_to(b"hello world!", &rx.local_addr().unwrap()) + .unwrap(); sleep_ms(250); for _ in 0..2 { - expect_events(poll, events, 2, vec![ - Event::new(Ready::readable() | Ready::writable(), Token(1)) - ]); + expect_events( + poll, + events, + 2, + vec![Event::new(Ready::readable() | Ready::writable(), Token(1))], + ); } let mut buf = [0; 200]; while rx.recv_from(&mut buf).is_ok() {} for _ in 0..2 { - expect_events(poll, events, 4, vec![Event::new(Ready::writable(), Token(1))]); + expect_events( + poll, + events, + 4, + vec![Event::new(Ready::writable(), Token(1))], + ); } - tx.send_to(b"hello world!", &rx.local_addr().unwrap()).unwrap(); + tx.send_to(b"hello world!", &rx.local_addr().unwrap()) + .unwrap(); sleep_ms(250); - expect_events(poll, events, 10, - vec![Event::new(Ready::readable() | Ready::writable(), Token(1))]); + expect_events( + poll, + events, + 10, + vec![Event::new(Ready::readable() | Ready::writable(), Token(1))], + ); drop(rx); } diff --git a/test/test_udp_socket.rs b/test/test_udp_socket.rs index dcb2e6cb9..d4504e2e9 100644 --- a/test/test_udp_socket.rs +++ b/test/test_udp_socket.rs @@ -1,10 +1,10 @@ -use mio::{Events, Poll, PollOpt, Ready, Token}; +use bytes::{Buf, MutBuf, RingBuf, SliceBuf}; +use localhost; use mio::net::UdpSocket; -use bytes::{Buf, RingBuf, SliceBuf, MutBuf}; +use mio::{Events, Poll, PollOpt, Ready, Token}; use std::io::ErrorKind; use std::str; use std::time; -use localhost; const LISTENER: Token = Token(0); const SENDER: Token = Token(1); @@ -20,7 +20,7 @@ pub struct UdpHandlerSendRecv { } impl UdpHandlerSendRecv { - fn new(tx: UdpSocket, rx: UdpSocket, connected: bool, msg : &'static str) -> UdpHandlerSendRecv { + fn new(tx: UdpSocket, rx: UdpSocket, connected: bool, msg: &'static str) -> UdpHandlerSendRecv { UdpHandlerSendRecv { tx: tx, rx: rx, @@ -33,11 +33,9 @@ impl UdpHandlerSendRecv { } } -fn assert_send() { -} +fn assert_send() {} -fn assert_sync() { -} +fn assert_sync() {} #[cfg(test)] fn test_send_recv_udp(tx: UdpSocket, rx: UdpSocket, connected: bool) { @@ -49,13 +47,18 @@ fn test_send_recv_udp(tx: UdpSocket, rx: UdpSocket, connected: bool) { // ensure that the sockets are non-blocking let mut buf = [0; 128]; - assert_eq!(ErrorKind::WouldBlock, rx.recv_from(&mut buf).unwrap_err().kind()); + assert_eq!( + ErrorKind::WouldBlock, + rx.recv_from(&mut buf).unwrap_err().kind() + ); info!("Registering SENDER"); - poll.register(&tx, SENDER, Ready::writable(), PollOpt::edge()).unwrap(); + poll.register(&tx, SENDER, Ready::writable(), PollOpt::edge()) + .unwrap(); info!("Registering LISTENER"); - poll.register(&rx, LISTENER, Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&rx, LISTENER, Ready::readable(), PollOpt::edge()) + .unwrap(); let mut events = Events::with_capacity(1024); @@ -78,11 +81,13 @@ fn test_send_recv_udp(tx: UdpSocket, rx: UdpSocket, connected: bool) { } }; - unsafe { MutBuf::advance(&mut handler.rx_buf, cnt); } + unsafe { + MutBuf::advance(&mut handler.rx_buf, cnt); + } assert!(str::from_utf8(handler.rx_buf.bytes()).unwrap() == handler.msg); handler.shutdown = true; - }, - _ => () + } + _ => (), } } @@ -97,7 +102,7 @@ fn test_send_recv_udp(tx: UdpSocket, rx: UdpSocket, connected: bool) { }; handler.buf.advance(cnt); - }, + } _ => {} } } @@ -145,7 +150,7 @@ pub fn test_udp_socket_discard() { let tx_addr = tx.local_addr().unwrap(); let rx_addr = rx.local_addr().unwrap(); - + assert!(tx.connect(rx_addr).is_ok()); assert!(udp_outside.connect(rx_addr).is_ok()); assert!(rx.connect(tx_addr).is_ok()); @@ -155,20 +160,21 @@ pub fn test_udp_socket_discard() { let r = udp_outside.send("hello world".as_bytes()); assert!(r.is_ok() || r.unwrap_err().kind() == ErrorKind::WouldBlock); - poll.register(&rx, LISTENER, Ready::readable(), PollOpt::edge()).unwrap(); - poll.register(&tx, SENDER, Ready::writable(), PollOpt::edge()).unwrap(); + poll.register(&rx, LISTENER, Ready::readable(), PollOpt::edge()) + .unwrap(); + poll.register(&tx, SENDER, Ready::writable(), PollOpt::edge()) + .unwrap(); let mut events = Events::with_capacity(1024); - poll.poll(&mut events, Some(time::Duration::from_secs(5))).unwrap(); + poll.poll(&mut events, Some(time::Duration::from_secs(5))) + .unwrap(); for event in &events { if event.readiness().is_readable() { match event.token() { - LISTENER => { - assert!(false, "Expected to no receive a packet but got something") - }, - _ => () + LISTENER => assert!(false, "Expected to no receive a packet but got something"), + _ => (), } } } diff --git a/test/test_uds_shutdown.rs b/test/test_uds_shutdown.rs index 58d2431e8..563ab4562 100644 --- a/test/test_uds_shutdown.rs +++ b/test/test_uds_shutdown.rs @@ -1,12 +1,12 @@ -use {TryRead, TryWrite}; -use mio::*; -use mio::deprecated::{EventLoop, Handler}; -use mio::deprecated::unix::*; use bytes::{Buf, ByteBuf, MutByteBuf, SliceBuf}; +use mio::deprecated::unix::*; +use mio::deprecated::{EventLoop, Handler}; +use mio::*; use slab::Slab; use std::io; use std::path::PathBuf; use tempdir::TempDir; +use {TryRead, TryWrite}; const SERVER: Token = Token(10_000_000); const CLIENT: Token = Token(10_000_001); @@ -16,7 +16,7 @@ struct EchoConn { buf: Option, mut_buf: Option, token: Option, - interest: Ready + interest: Ready, } impl EchoConn { @@ -26,7 +26,7 @@ impl EchoConn { buf: None, mut_buf: Some(ByteBuf::mut_with_capacity(2048)), token: None, - interest: Ready::hup() + interest: Ready::hup(), } } @@ -48,15 +48,19 @@ impl EchoConn { self.interest.insert(Ready::readable()); self.interest.remove(Ready::writable()); match self.sock.shutdown(Shutdown::Write) { - Err(e) => panic!(e), - _ => {}, + Err(e) => panic!(e), + _ => {} } } Err(e) => debug!("not implemented; client err={:?}", e), } - event_loop.reregister(&self.sock, self.token.unwrap(), self.interest, - PollOpt::edge() | PollOpt::oneshot()) + event_loop.reregister( + &self.sock, + self.token.unwrap(), + self.interest, + PollOpt::edge() | PollOpt::oneshot(), + ) } fn readable(&mut self, event_loop: &mut EventLoop) -> io::Result<()> { @@ -80,17 +84,20 @@ impl EchoConn { debug!("not implemented; client err={:?}", e); self.interest.remove(Ready::readable()); } - }; - event_loop.reregister(&self.sock, self.token.unwrap(), self.interest, - PollOpt::edge()) + event_loop.reregister( + &self.sock, + self.token.unwrap(), + self.interest, + PollOpt::edge(), + ) } } struct EchoServer { sock: UnixListener, - conns: Slab + conns: Slab, } impl EchoServer { @@ -98,26 +105,29 @@ impl EchoServer { debug!("server accepting socket"); let sock = self.sock.accept().unwrap(); - let conn = EchoConn::new(sock,); + let conn = EchoConn::new(sock); let tok = self.conns.insert(conn); // Register the connection self.conns[tok].token = Some(Token(tok)); - event_loop.register(&self.conns[tok].sock, Token(tok), Ready::readable(), - PollOpt::edge() | PollOpt::oneshot()) - .ok().expect("could not register socket with event loop"); + event_loop + .register( + &self.conns[tok].sock, + Token(tok), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ).ok() + .expect("could not register socket with event loop"); Ok(()) } - fn conn_readable(&mut self, event_loop: &mut EventLoop, - tok: Token) -> io::Result<()> { + fn conn_readable(&mut self, event_loop: &mut EventLoop, tok: Token) -> io::Result<()> { debug!("server conn readable; tok={:?}", tok); self.conn(tok).readable(event_loop) } - fn conn_writable(&mut self, event_loop: &mut EventLoop, - tok: Token) -> io::Result<()> { + fn conn_writable(&mut self, event_loop: &mut EventLoop, tok: Token) -> io::Result<()> { debug!("server conn writable; tok={:?}", tok); self.conn(tok).writable(event_loop) } @@ -134,13 +144,12 @@ struct EchoClient { rx: SliceBuf<'static>, mut_buf: Option, token: Token, - interest: Ready + interest: Ready, } - // Sends a message and expects to receive the same exact message, one at a time impl EchoClient { - fn new(sock: UnixStream, tok: Token, mut msgs: Vec<&'static str>) -> EchoClient { + fn new(sock: UnixStream, tok: Token, mut msgs: Vec<&'static str>) -> EchoClient { let curr = msgs.remove(0); EchoClient { @@ -150,7 +159,7 @@ impl EchoClient { rx: SliceBuf::wrap(curr.as_bytes()), mut_buf: Some(ByteBuf::mut_with_capacity(2048)), token: tok, - interest: Ready::none() + interest: Ready::none(), } } @@ -167,24 +176,24 @@ impl EchoClient { Ok(Some(r)) => { if r == 0 { self.interest.remove(Ready::readable()); - event_loop.shutdown(); + event_loop.shutdown(); } else { - debug!("CLIENT : We read {} bytes!", r); + debug!("CLIENT : We read {} bytes!", r); - // prepare for reading - let mut buf = buf.flip(); + // prepare for reading + let mut buf = buf.flip(); - while buf.has_remaining() { - let actual = buf.read_byte().unwrap(); - let expect = self.rx.read_byte().unwrap(); + while buf.has_remaining() { + let actual = buf.read_byte().unwrap(); + let expect = self.rx.read_byte().unwrap(); - assert!(actual == expect, "actual={}; expect={}", actual, expect); - } + assert!(actual == expect, "actual={}; expect={}", actual, expect); + } - self.mut_buf = Some(buf.flip()); - if !self.rx.has_remaining() { - self.next_msg(event_loop).unwrap(); - } + self.mut_buf = Some(buf.flip()); + if !self.rx.has_remaining() { + self.next_msg(event_loop).unwrap(); + } } } Err(e) => { @@ -192,8 +201,12 @@ impl EchoClient { } }; - event_loop.reregister(&self.sock, self.token, self.interest, - PollOpt::edge() | PollOpt::oneshot()) + event_loop.reregister( + &self.sock, + self.token, + self.interest, + PollOpt::edge() | PollOpt::oneshot(), + ) } fn writable(&mut self, event_loop: &mut EventLoop) -> io::Result<()> { @@ -209,16 +222,19 @@ impl EchoClient { self.interest.insert(Ready::readable()); self.interest.remove(Ready::writable()); } - Err(e) => debug!("not implemented; client err={:?}", e) + Err(e) => debug!("not implemented; client err={:?}", e), } - event_loop.reregister(&self.sock, self.token, self.interest, - PollOpt::edge() | PollOpt::oneshot()) + event_loop.reregister( + &self.sock, + self.token, + self.interest, + PollOpt::edge() | PollOpt::oneshot(), + ) } fn next_msg(&mut self, event_loop: &mut EventLoop) -> io::Result<()> { if self.msgs.is_empty() { - return Ok(()); } @@ -229,8 +245,12 @@ impl EchoClient { self.rx = SliceBuf::wrap(curr.as_bytes()); self.interest.insert(Ready::writable()); - event_loop.reregister(&self.sock, self.token, self.interest, - PollOpt::edge() | PollOpt::oneshot()) + event_loop.reregister( + &self.sock, + self.token, + self.interest, + PollOpt::edge() | PollOpt::oneshot(), + ) } } @@ -244,9 +264,9 @@ impl Echo { Echo { server: EchoServer { sock: srv, - conns: Slab::with_capacity(128) + conns: Slab::with_capacity(128), }, - client: EchoClient::new(client, CLIENT, msgs) + client: EchoClient::new(client, CLIENT, msgs), } } } @@ -255,14 +275,13 @@ impl Handler for Echo { type Timeout = usize; type Message = (); - fn ready(&mut self, event_loop: &mut EventLoop, token: Token, - events: Ready) { + fn ready(&mut self, event_loop: &mut EventLoop, token: Token, events: Ready) { debug!("ready {:?} {:?}", token, events); if events.is_readable() { match token { SERVER => self.server.accept(event_loop).unwrap(), CLIENT => self.client.readable(event_loop).unwrap(), - i => self.server.conn_readable(event_loop, i).unwrap() + i => self.server.conn_readable(event_loop, i).unwrap(), } } @@ -270,7 +289,7 @@ impl Handler for Echo { match token { SERVER => panic!("received writable for token 0"), CLIENT => self.client.writable(event_loop).unwrap(), - _ => self.server.conn_writable(event_loop, token).unwrap() + _ => self.server.conn_writable(event_loop, token).unwrap(), }; } } @@ -286,15 +305,27 @@ pub fn test_echo_server() { let srv = UnixListener::bind(&addr).unwrap(); - event_loop.register(&srv, SERVER, Ready::readable(), - PollOpt::edge() | PollOpt::oneshot()).unwrap(); + event_loop + .register( + &srv, + SERVER, + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); let sock = UnixStream::connect(&addr).unwrap(); // Connect to the server - event_loop.register(&sock, CLIENT, Ready::writable(), - PollOpt::edge() | PollOpt::oneshot()).unwrap(); + event_loop + .register( + &sock, + CLIENT, + Ready::writable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); // Start the event loop - event_loop.run(&mut Echo::new(srv, sock, vec!["foo", "bar"])).unwrap(); + event_loop + .run(&mut Echo::new(srv, sock, vec!["foo", "bar"])) + .unwrap(); } diff --git a/test/test_unix_echo_server.rs b/test/test_unix_echo_server.rs index 6f3dd4b69..0ef2bb9d7 100644 --- a/test/test_unix_echo_server.rs +++ b/test/test_unix_echo_server.rs @@ -1,12 +1,12 @@ -use {TryRead, TryWrite}; -use mio::*; -use mio::deprecated::{EventLoop, Handler}; -use mio::deprecated::unix::*; use bytes::{Buf, ByteBuf, MutByteBuf, SliceBuf}; +use mio::deprecated::unix::*; +use mio::deprecated::{EventLoop, Handler}; +use mio::*; use slab::Slab; -use std::path::PathBuf; use std::io; +use std::path::PathBuf; use tempdir::TempDir; +use {TryRead, TryWrite}; const SERVER: Token = Token(10_000_000); const CLIENT: Token = Token(10_000_001); @@ -50,8 +50,17 @@ impl EchoConn { Err(e) => debug!("not implemented; client err={:?}", e), } - assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); - event_loop.reregister(&self.sock, self.token.unwrap(), self.interest, PollOpt::edge() | PollOpt::oneshot()) + assert!( + self.interest.is_readable() || self.interest.is_writable(), + "actual={:?}", + self.interest + ); + event_loop.reregister( + &self.sock, + self.token.unwrap(), + self.interest, + PollOpt::edge() | PollOpt::oneshot(), + ) } fn readable(&mut self, event_loop: &mut EventLoop) -> io::Result<()> { @@ -75,17 +84,25 @@ impl EchoConn { debug!("not implemented; client err={:?}", e); self.interest.remove(Ready::readable()); } - }; - assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); - event_loop.reregister(&self.sock, self.token.unwrap(), self.interest, PollOpt::edge() | PollOpt::oneshot()) + assert!( + self.interest.is_readable() || self.interest.is_writable(), + "actual={:?}", + self.interest + ); + event_loop.reregister( + &self.sock, + self.token.unwrap(), + self.interest, + PollOpt::edge() | PollOpt::oneshot(), + ) } } struct EchoServer { sock: UnixListener, - conns: Slab + conns: Slab, } impl EchoServer { @@ -98,8 +115,14 @@ impl EchoServer { // Register the connection self.conns[tok].token = Some(Token(tok)); - event_loop.register(&self.conns[tok].sock, Token(tok), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()) - .ok().expect("could not register socket with event loop"); + event_loop + .register( + &self.conns[tok].sock, + Token(tok), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ).ok() + .expect("could not register socket with event loop"); Ok(()) } @@ -129,10 +152,9 @@ struct EchoClient { interest: Ready, } - // Sends a message and expects to receive the same exact message, one at a time impl EchoClient { - fn new(sock: UnixStream, tok: Token, mut msgs: Vec<&'static str>) -> EchoClient { + fn new(sock: UnixStream, tok: Token, mut msgs: Vec<&'static str>) -> EchoClient { let curr = msgs.remove(0); EchoClient { @@ -162,7 +184,11 @@ impl EchoClient { // prepare for reading let mut buf = buf.flip(); - debug!("CLIENT : buf = {:?} -- rx = {:?}", buf.bytes(), self.rx.bytes()); + debug!( + "CLIENT : buf = {:?} -- rx = {:?}", + buf.bytes(), + self.rx.bytes() + ); while buf.has_remaining() { let actual = buf.read_byte().unwrap(); let expect = self.rx.read_byte().unwrap(); @@ -184,8 +210,17 @@ impl EchoClient { }; if !self.interest.is_none() { - assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); - event_loop.reregister(&self.sock, self.token, self.interest, PollOpt::edge() | PollOpt::oneshot())?; + assert!( + self.interest.is_readable() || self.interest.is_writable(), + "actual={:?}", + self.interest + ); + event_loop.reregister( + &self.sock, + self.token, + self.interest, + PollOpt::edge() | PollOpt::oneshot(), + )?; } Ok(()) @@ -204,11 +239,20 @@ impl EchoClient { self.interest.insert(Ready::readable()); self.interest.remove(Ready::writable()); } - Err(e) => debug!("not implemented; client err={:?}", e) + Err(e) => debug!("not implemented; client err={:?}", e), } - assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); - event_loop.reregister(&self.sock, self.token, self.interest, PollOpt::edge() | PollOpt::oneshot()) + assert!( + self.interest.is_readable() || self.interest.is_writable(), + "actual={:?}", + self.interest + ); + event_loop.reregister( + &self.sock, + self.token, + self.interest, + PollOpt::edge() | PollOpt::oneshot(), + ) } fn next_msg(&mut self, event_loop: &mut EventLoop) -> io::Result<()> { @@ -224,8 +268,17 @@ impl EchoClient { self.rx = SliceBuf::wrap(curr.as_bytes()); self.interest.insert(Ready::writable()); - assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); - event_loop.reregister(&self.sock, self.token, self.interest, PollOpt::edge() | PollOpt::oneshot()) + assert!( + self.interest.is_readable() || self.interest.is_writable(), + "actual={:?}", + self.interest + ); + event_loop.reregister( + &self.sock, + self.token, + self.interest, + PollOpt::edge() | PollOpt::oneshot(), + ) } } @@ -239,9 +292,9 @@ impl Echo { Echo { server: EchoServer { sock: srv, - conns: Slab::with_capacity(128) + conns: Slab::with_capacity(128), }, - client: EchoClient::new(client, CLIENT, msgs) + client: EchoClient::new(client, CLIENT, msgs), } } } @@ -255,7 +308,7 @@ impl Handler for Echo { match token { SERVER => self.server.accept(event_loop).unwrap(), CLIENT => self.client.readable(event_loop).unwrap(), - i => self.server.conn_readable(event_loop, i).unwrap() + i => self.server.conn_readable(event_loop, i).unwrap(), }; } @@ -263,7 +316,7 @@ impl Handler for Echo { match token { SERVER => panic!("received writable for token 0"), CLIENT => self.client.writable(event_loop).unwrap(), - _ => self.server.conn_writable(event_loop, token).unwrap() + _ => self.server.conn_writable(event_loop, token).unwrap(), }; } } @@ -280,13 +333,27 @@ pub fn test_unix_echo_server() { let srv = UnixListener::bind(&addr).unwrap(); info!("listen for connections"); - event_loop.register(&srv, SERVER, Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); + event_loop + .register( + &srv, + SERVER, + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); let sock = UnixStream::connect(&addr).unwrap(); // Connect to the server - event_loop.register(&sock, CLIENT, Ready::writable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); + event_loop + .register( + &sock, + CLIENT, + Ready::writable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); // Start the event loop - event_loop.run(&mut Echo::new(srv, sock, vec!["foo", "bar"])).unwrap(); + event_loop + .run(&mut Echo::new(srv, sock, vec!["foo", "bar"])) + .unwrap(); } diff --git a/test/test_unix_pass_fd.rs b/test/test_unix_pass_fd.rs index f43ec2273..438fbc26f 100644 --- a/test/test_unix_pass_fd.rs +++ b/test/test_unix_pass_fd.rs @@ -1,13 +1,13 @@ -use {TryRead, TryWrite}; -use mio::*; -use mio::deprecated::{EventLoop, Handler}; -use mio::deprecated::unix::*; use bytes::{Buf, ByteBuf, SliceBuf}; +use mio::deprecated::unix::*; +use mio::deprecated::{EventLoop, Handler}; +use mio::*; use slab::Slab; -use std::path::PathBuf; use std::io::{self, Read}; use std::os::unix::io::{AsRawFd, FromRawFd}; +use std::path::PathBuf; use tempdir::TempDir; +use {TryRead, TryWrite}; const SERVER: Token = Token(10_000_000); const CLIENT: Token = Token(10_000_001); @@ -48,8 +48,17 @@ impl EchoConn { Err(e) => debug!("not implemented; client err={:?}", e), } - assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); - event_loop.reregister(&self.sock, self.token.unwrap(), self.interest, PollOpt::edge() | PollOpt::oneshot()) + assert!( + self.interest.is_readable() || self.interest.is_writable(), + "actual={:?}", + self.interest + ); + event_loop.reregister( + &self.sock, + self.token.unwrap(), + self.interest, + PollOpt::edge() | PollOpt::oneshot(), + ) } fn readable(&mut self, event_loop: &mut EventLoop) -> io::Result<()> { @@ -68,7 +77,6 @@ impl EchoConn { debug!("not implemented; client err={:?}", e); self.interest.remove(Ready::readable()); } - }; // create fd to pass back. Assume that the write will work @@ -89,14 +97,23 @@ impl EchoConn { } self.pipe_fd = Some(rd); - assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); - event_loop.reregister(&self.sock, self.token.unwrap(), self.interest, PollOpt::edge() | PollOpt::oneshot()) + assert!( + self.interest.is_readable() || self.interest.is_writable(), + "actual={:?}", + self.interest + ); + event_loop.reregister( + &self.sock, + self.token.unwrap(), + self.interest, + PollOpt::edge() | PollOpt::oneshot(), + ) } } struct EchoServer { sock: UnixListener, - conns: Slab + conns: Slab, } impl EchoServer { @@ -109,8 +126,14 @@ impl EchoServer { // Register the connection self.conns[tok].token = Some(Token(tok)); - event_loop.register(&self.conns[tok].sock, Token(tok), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()) - .ok().expect("could not register socket with event loop"); + event_loop + .register( + &self.conns[tok].sock, + Token(tok), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ).ok() + .expect("could not register socket with event loop"); Ok(()) } @@ -139,10 +162,9 @@ struct EchoClient { interest: Ready, } - // Sends a message and expects to receive the same exact message, one at a time impl EchoClient { - fn new(sock: UnixStream, tok: Token, mut msgs: Vec<&'static str>) -> EchoClient { + fn new(sock: UnixStream, tok: Token, mut msgs: Vec<&'static str>) -> EchoClient { let curr = msgs.remove(0); EchoClient { @@ -199,8 +221,17 @@ impl EchoClient { } if !self.interest.is_none() { - assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); - event_loop.reregister(&self.sock, self.token, self.interest, PollOpt::edge() | PollOpt::oneshot())?; + assert!( + self.interest.is_readable() || self.interest.is_writable(), + "actual={:?}", + self.interest + ); + event_loop.reregister( + &self.sock, + self.token, + self.interest, + PollOpt::edge() | PollOpt::oneshot(), + )?; } Ok(()) @@ -219,11 +250,20 @@ impl EchoClient { self.interest.insert(Ready::readable()); self.interest.remove(Ready::writable()); } - Err(e) => debug!("not implemented; client err={:?}", e) + Err(e) => debug!("not implemented; client err={:?}", e), } - assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); - event_loop.reregister(&self.sock, self.token, self.interest, PollOpt::edge() | PollOpt::oneshot()) + assert!( + self.interest.is_readable() || self.interest.is_writable(), + "actual={:?}", + self.interest + ); + event_loop.reregister( + &self.sock, + self.token, + self.interest, + PollOpt::edge() | PollOpt::oneshot(), + ) } fn next_msg(&mut self, event_loop: &mut EventLoop) -> io::Result<()> { @@ -239,7 +279,12 @@ impl EchoClient { self.rx = SliceBuf::wrap(curr.as_bytes()); self.interest.insert(Ready::writable()); - event_loop.reregister(&self.sock, self.token, self.interest, PollOpt::edge() | PollOpt::oneshot()) + event_loop.reregister( + &self.sock, + self.token, + self.interest, + PollOpt::edge() | PollOpt::oneshot(), + ) } } @@ -253,9 +298,9 @@ impl Echo { Echo { server: EchoServer { sock: srv, - conns: Slab::with_capacity(128) + conns: Slab::with_capacity(128), }, - client: EchoClient::new(client, CLIENT, msgs) + client: EchoClient::new(client, CLIENT, msgs), } } } @@ -269,7 +314,7 @@ impl Handler for Echo { match token { SERVER => self.server.accept(event_loop).unwrap(), CLIENT => self.client.readable(event_loop).unwrap(), - i => self.server.conn_readable(event_loop, i).unwrap() + i => self.server.conn_readable(event_loop, i).unwrap(), }; } @@ -277,7 +322,7 @@ impl Handler for Echo { match token { SERVER => panic!("received writable for token 0"), CLIENT => self.client.writable(event_loop).unwrap(), - _ => self.server.conn_writable(event_loop, token).unwrap() + _ => self.server.conn_writable(event_loop, token).unwrap(), }; } } @@ -294,13 +339,27 @@ pub fn test_unix_pass_fd() { let srv = UnixListener::bind(&addr).unwrap(); info!("listen for connections"); - event_loop.register(&srv, SERVER, Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); + event_loop + .register( + &srv, + SERVER, + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); let sock = UnixStream::connect(&addr).unwrap(); // Connect to the server - event_loop.register(&sock, CLIENT, Ready::writable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); + event_loop + .register( + &sock, + CLIENT, + Ready::writable(), + PollOpt::edge() | PollOpt::oneshot(), + ).unwrap(); // Start the event loop - event_loop.run(&mut Echo::new(srv, sock, vec!["foo", "bar"])).unwrap(); + event_loop + .run(&mut Echo::new(srv, sock, vec!["foo", "bar"])) + .unwrap(); } diff --git a/test/test_write_then_drop.rs b/test/test_write_then_drop.rs index aa478eaf4..64f3191d0 100644 --- a/test/test_write_then_drop.rs +++ b/test/test_write_then_drop.rs @@ -1,8 +1,8 @@ -use std::io::{Write, Read}; +use std::io::{Read, Write}; use mio::event::Evented; use mio::net::{TcpListener, TcpStream}; -use mio::{Poll, Events, Ready, PollOpt, Token}; +use mio::{Events, Poll, PollOpt, Ready, Token}; #[test] fn write_then_drop() { @@ -14,14 +14,10 @@ fn write_then_drop() { let poll = Poll::new().unwrap(); - a.register(&poll, - Token(1), - Ready::readable(), - PollOpt::edge()).unwrap(); - s.register(&poll, - Token(3), - Ready::empty(), - PollOpt::edge()).unwrap(); + a.register(&poll, Token(1), Ready::readable(), PollOpt::edge()) + .unwrap(); + s.register(&poll, Token(3), Ready::empty(), PollOpt::edge()) + .unwrap(); let mut events = Events::with_capacity(1024); while events.len() == 0 { @@ -32,10 +28,8 @@ fn write_then_drop() { let mut s2 = a.accept().unwrap().0; - s2.register(&poll, - Token(2), - Ready::writable(), - PollOpt::edge()).unwrap(); + s2.register(&poll, Token(2), Ready::writable(), PollOpt::edge()) + .unwrap(); let mut events = Events::with_capacity(1024); while events.len() == 0 { @@ -47,10 +41,8 @@ fn write_then_drop() { s2.write(&[1, 2, 3, 4]).unwrap(); drop(s2); - s.reregister(&poll, - Token(3), - Ready::readable(), - PollOpt::edge()).unwrap(); + s.reregister(&poll, Token(3), Ready::readable(), PollOpt::edge()) + .unwrap(); let mut events = Events::with_capacity(1024); while events.len() == 0 { poll.poll(&mut events, None).unwrap(); @@ -73,14 +65,10 @@ fn write_then_deregister() { let poll = Poll::new().unwrap(); - a.register(&poll, - Token(1), - Ready::readable(), - PollOpt::edge()).unwrap(); - s.register(&poll, - Token(3), - Ready::empty(), - PollOpt::edge()).unwrap(); + a.register(&poll, Token(1), Ready::readable(), PollOpt::edge()) + .unwrap(); + s.register(&poll, Token(3), Ready::empty(), PollOpt::edge()) + .unwrap(); let mut events = Events::with_capacity(1024); while events.len() == 0 { @@ -91,10 +79,8 @@ fn write_then_deregister() { let mut s2 = a.accept().unwrap().0; - s2.register(&poll, - Token(2), - Ready::writable(), - PollOpt::edge()).unwrap(); + s2.register(&poll, Token(2), Ready::writable(), PollOpt::edge()) + .unwrap(); let mut events = Events::with_capacity(1024); while events.len() == 0 { @@ -106,10 +92,8 @@ fn write_then_deregister() { s2.write(&[1, 2, 3, 4]).unwrap(); s2.deregister(&poll).unwrap(); - s.reregister(&poll, - Token(3), - Ready::readable(), - PollOpt::edge()).unwrap(); + s.reregister(&poll, Token(3), Ready::readable(), PollOpt::edge()) + .unwrap(); let mut events = Events::with_capacity(1024); while events.len() == 0 { poll.poll(&mut events, None).unwrap(); From 15e980d16f1b337433fe5f4f17534b1ba06d5a82 Mon Sep 17 00:00:00 2001 From: PerfectLaugh Date: Tue, 21 Aug 2018 08:09:53 +0800 Subject: [PATCH 3/6] Revert "try to fix test code and did the cargo +nightly fmt" This reverts commit fe3a06e8a65245bf0c34af7ad283d663b51402aa. --- benches/bench_poll.rs | 8 +- src/channel.rs | 101 ++---- src/deprecated/event_loop.rs | 62 ++-- src/deprecated/handler.rs | 17 +- src/deprecated/io.rs | 2 +- src/deprecated/mod.rs | 30 +- src/deprecated/notify.rs | 26 +- src/deprecated/unix.rs | 140 ++------- src/event_imp.rs | 77 +---- src/io.rs | 2 +- src/lib.rs | 42 +-- src/net/tcp.rs | 86 +++--- src/net/udp.rs | 51 ++-- src/poll.rs | 289 +++++++----------- src/sys/fuchsia/awakener.rs | 47 ++- src/sys/fuchsia/eventedfd.rs | 118 ++++--- src/sys/fuchsia/handles.rs | 31 +- src/sys/fuchsia/mod.rs | 38 +-- src/sys/fuchsia/net.rs | 129 ++++---- src/sys/fuchsia/ready.rs | 8 +- src/sys/fuchsia/selector.rs | 171 +++++------ src/sys/mod.rs | 28 +- src/sys/unix/awakener.rs | 22 +- src/sys/unix/epoll.rs | 93 ++---- src/sys/unix/eventedfd.rs | 18 +- src/sys/unix/io.rs | 32 +- src/sys/unix/kqueue.rs | 181 ++++------- src/sys/unix/mod.rs | 60 +--- src/sys/unix/ready.rs | 101 ++---- src/sys/unix/tcp.rs | 77 +++-- src/sys/unix/udp.rs | 51 ++-- src/sys/unix/uds.rs | 70 ++--- src/sys/windows/awakener.rs | 20 +- src/sys/windows/buffer_pool.rs | 14 +- src/sys/windows/from_raw_arc.rs | 24 +- src/sys/windows/mod.rs | 14 +- src/sys/windows/selector.rs | 186 ++++++----- src/sys/windows/tcp.rs | 256 ++++++---------- src/sys/windows/udp.rs | 155 ++++------ src/timer.rs | 136 +++------ src/udp.rs | 66 ++-- test/mod.rs | 79 ++--- test/test_battery.rs | 118 +++---- test/test_broken_pipe.rs | 11 +- test/test_close_on_drop.rs | 26 +- test/test_custom_evented.rs | 97 ++---- test/test_double_register.rs | 10 +- ...st_drop_cancels_interest_and_shuts_down.rs | 3 +- test/test_echo_server.rs | 116 +++---- test/test_fuchsia_handles.rs | 19 +- test/test_local_addr_ready.rs | 25 +- test/test_multicast.rs | 32 +- test/test_notify.rs | 22 +- test/test_oneshot.rs | 46 +-- test/test_poll.rs | 6 +- test/test_poll_channel.rs | 150 +++------ test/test_register_deregister.rs | 54 ++-- test/test_register_multiple_event_loops.rs | 68 +---- test/test_reregister_without_poll.rs | 24 +- test/test_smoke.rs | 16 +- test/test_subprocess_pipe.rs | 197 ++++++------ test/test_tcp.rs | 237 ++++++-------- test/test_tcp_level.rs | 93 ++---- test/test_tick.rs | 17 +- test/test_timer.rs | 168 ++++------ test/test_udp_level.rs | 60 +--- test/test_udp_socket.rs | 52 ++-- test/test_uds_shutdown.rs | 147 ++++----- test/test_unix_echo_server.rs | 127 ++------ test/test_unix_pass_fd.rs | 115 ++----- test/test_write_then_drop.rs | 52 ++-- 71 files changed, 1977 insertions(+), 3289 deletions(-) diff --git a/benches/bench_poll.rs b/benches/bench_poll.rs index 4085b219b..7d61d0d65 100644 --- a/benches/bench_poll.rs +++ b/benches/bench_poll.rs @@ -4,9 +4,9 @@ extern crate mio; extern crate test; use mio::*; +use test::Bencher; use std::sync::Arc; use std::thread; -use test::Bencher; #[bench] fn bench_poll(bench: &mut Bencher) { @@ -20,7 +20,11 @@ fn bench_poll(bench: &mut Bencher) { let mut set_readiness = vec![]; for i in 0..NUM { - let (r, s) = Registration::new(&poll, Token(i), Ready::readable(), PollOpt::edge()); + let (r, s) = Registration::new( + &poll, + Token(i), + Ready::readable(), + PollOpt::edge()); registrations.push(r); set_readiness.push(s); diff --git a/src/channel.rs b/src/channel.rs index 7a3e3e06b..851378fff 100644 --- a/src/channel.rs +++ b/src/channel.rs @@ -2,14 +2,14 @@ #![allow(unused_imports, deprecated, missing_debug_implementations)] +use {io, Ready, Poll, PollOpt, Registration, SetReadiness, Token}; use event::Evented; -use lazycell::{AtomicLazyCell, LazyCell}; +use lazycell::{LazyCell, AtomicLazyCell}; use std::any::Any; -use std::error; use std::fmt; -use std::sync::atomic::{AtomicUsize, Ordering}; +use std::error; use std::sync::{mpsc, Arc}; -use {io, Poll, PollOpt, Ready, Registration, SetReadiness, Token}; +use std::sync::atomic::{AtomicUsize, Ordering}; /// Creates a new asynchronous channel, where the `Receiver` can be registered /// with `Poll`. @@ -116,10 +116,12 @@ struct Inner { impl Sender { pub fn send(&self, t: T) -> Result<(), SendError> { - self.tx.send(t).map_err(SendError::from).and_then(|_| { - self.ctl.inc()?; - Ok(()) - }) + self.tx.send(t) + .map_err(SendError::from) + .and_then(|_| { + self.ctl.inc()?; + Ok(()) + }) } } @@ -134,17 +136,21 @@ impl Clone for Sender { impl SyncSender { pub fn send(&self, t: T) -> Result<(), SendError> { - self.tx.send(t).map_err(From::from).and_then(|_| { - self.ctl.inc()?; - Ok(()) - }) + self.tx.send(t) + .map_err(From::from) + .and_then(|_| { + self.ctl.inc()?; + Ok(()) + }) } pub fn try_send(&self, t: T) -> Result<(), TrySendError> { - self.tx.try_send(t).map_err(From::from).and_then(|_| { - self.ctl.inc()?; - Ok(()) - }) + self.tx.try_send(t) + .map_err(From::from) + .and_then(|_| { + self.ctl.inc()?; + Ok(()) + }) } } @@ -167,23 +173,11 @@ impl Receiver { } impl Evented for Receiver { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.ctl.register(poll, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.ctl.reregister(poll, token, interest, opts) } @@ -217,9 +211,7 @@ impl SenderCtl { impl Clone for SenderCtl { fn clone(&self) -> SenderCtl { self.inner.senders.fetch_add(1, Ordering::Relaxed); - SenderCtl { - inner: self.inner.clone(), - } + SenderCtl { inner: self.inner.clone() } } } @@ -258,63 +250,36 @@ impl ReceiverCtl { } impl Evented for ReceiverCtl { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { if self.registration.borrow().is_some() { - return Err(io::Error::new( - io::ErrorKind::Other, - "receiver already registered", - )); + return Err(io::Error::new(io::ErrorKind::Other, "receiver already registered")); } let (registration, set_readiness) = Registration::new(poll, token, interest, opts); + if self.inner.pending.load(Ordering::Relaxed) > 0 { // TODO: Don't drop readiness let _ = set_readiness.set_readiness(Ready::readable()); } - self.registration - .fill(registration) - .ok() - .expect("unexpected state encountered"); - self.inner - .set_readiness - .fill(set_readiness) - .ok() - .expect("unexpected state encountered"); + self.registration.fill(registration).ok().expect("unexpected state encountered"); + self.inner.set_readiness.fill(set_readiness).ok().expect("unexpected state encountered"); Ok(()) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { match self.registration.borrow() { Some(registration) => registration.update(poll, token, interest, opts), - None => Err(io::Error::new( - io::ErrorKind::Other, - "receiver not registered", - )), + None => Err(io::Error::new(io::ErrorKind::Other, "receiver not registered")), } } fn deregister(&self, poll: &Poll) -> io::Result<()> { match self.registration.borrow() { Some(registration) => registration.deregister(poll), - None => Err(io::Error::new( - io::ErrorKind::Other, - "receiver not registered", - )), + None => Err(io::Error::new(io::ErrorKind::Other, "receiver not registered")), } } } diff --git a/src/deprecated/event_loop.rs b/src/deprecated/event_loop.rs index 825246975..a4beab139 100644 --- a/src/deprecated/event_loop.rs +++ b/src/deprecated/event_loop.rs @@ -1,11 +1,11 @@ -use deprecated::{Handler, NotifyError}; +use {channel, Poll, Events, Token}; use event::Evented; -use event_imp::{Event, PollOpt, Ready}; +use deprecated::{Handler, NotifyError}; +use event_imp::{Event, Ready, PollOpt}; +use timer::{self, Timer, Timeout}; +use std::{io, fmt, usize}; use std::default::Default; use std::time::Duration; -use std::{fmt, io, usize}; -use timer::{self, Timeout, Timer}; -use {channel, Events, Poll, Token}; #[derive(Debug, Default, Clone)] pub struct EventLoopBuilder { @@ -101,6 +101,7 @@ const NOTIFY: Token = Token(usize::MAX - 1); const TIMER: Token = Token(usize::MAX - 2); impl EventLoop { + /// Constructs a new `EventLoop` using the default configuration values. /// The `EventLoop` will not be running. pub fn new() -> io::Result> { @@ -121,12 +122,7 @@ impl EventLoop { let (tx, rx) = channel::sync_channel(config.notify_capacity); // Register the notification wakeup FD with the IO poller - poll.register( - &rx, - NOTIFY, - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - )?; + poll.register(&rx, NOTIFY, Ready::readable(), PollOpt::edge() | PollOpt::oneshot())?; poll.register(&timer, TIMER, Ready::readable(), PollOpt::edge())?; Ok(EventLoop { @@ -245,29 +241,15 @@ impl EventLoop { } /// Registers an IO handle with the event loop. - pub fn register( - &mut self, - io: &E, - token: Token, - interest: Ready, - opt: PollOpt, - ) -> io::Result<()> - where - E: Evented, + pub fn register(&mut self, io: &E, token: Token, interest: Ready, opt: PollOpt) -> io::Result<()> + where E: Evented { self.poll.register(io, token, interest, opt) } /// Re-Registers an IO handle with the event loop. - pub fn reregister( - &mut self, - io: &E, - token: Token, - interest: Ready, - opt: PollOpt, - ) -> io::Result<()> - where - E: Evented, + pub fn reregister(&mut self, io: &E, token: Token, interest: Ready, opt: PollOpt) -> io::Result<()> + where E: Evented { self.poll.reregister(io, token, interest, opt) } @@ -293,10 +275,7 @@ impl EventLoop { /// /// Warning: kqueue effectively builds in deregister when using edge-triggered mode with /// oneshot. Calling `deregister()` on the socket will cause a TcpStream error. - pub fn deregister(&mut self, io: &E) -> io::Result<()> - where - E: Evented, - { + pub fn deregister(&mut self, io: &E) -> io::Result<()> where E: Evented { self.poll.deregister(io) } @@ -349,7 +328,7 @@ impl EventLoop { match evt.token() { NOTIFY => self.notify(handler), TIMER => self.timer_process(handler), - _ => self.io_event(handler, evt), + _ => self.io_event(handler, evt) } i += 1; @@ -369,12 +348,7 @@ impl EventLoop { } // Re-register - let _ = self.poll.reregister( - &self.notify_rx, - NOTIFY, - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ); + let _ = self.poll.reregister(&self.notify_rx, NOTIFY, Ready::readable(), PollOpt::edge() | PollOpt::oneshot()); } fn timer_process(&mut self, handler: &mut H) { @@ -396,7 +370,7 @@ impl fmt::Debug for EventLoop { /// Sends messages to the EventLoop from other threads. pub struct Sender { - tx: channel::SyncSender, + tx: channel::SyncSender } impl fmt::Debug for Sender { @@ -405,11 +379,9 @@ impl fmt::Debug for Sender { } } -impl Clone for Sender { +impl Clone for Sender { fn clone(&self) -> Sender { - Sender { - tx: self.tx.clone(), - } + Sender { tx: self.tx.clone() } } } diff --git a/src/deprecated/handler.rs b/src/deprecated/handler.rs index 4355b763b..db1bc314a 100644 --- a/src/deprecated/handler.rs +++ b/src/deprecated/handler.rs @@ -1,5 +1,5 @@ -use deprecated::EventLoop; use {Ready, Token}; +use deprecated::{EventLoop}; #[allow(unused_variables)] pub trait Handler: Sized { @@ -16,17 +16,22 @@ pub trait Handler: Sized { /// /// This function will only be invoked a single time per socket per event /// loop tick. - fn ready(&mut self, event_loop: &mut EventLoop, token: Token, events: Ready) {} + fn ready(&mut self, event_loop: &mut EventLoop, token: Token, events: Ready) { + } /// Invoked when a message has been received via the event loop's channel. - fn notify(&mut self, event_loop: &mut EventLoop, msg: Self::Message) {} + fn notify(&mut self, event_loop: &mut EventLoop, msg: Self::Message) { + } /// Invoked when a timeout has completed. - fn timeout(&mut self, event_loop: &mut EventLoop, timeout: Self::Timeout) {} + fn timeout(&mut self, event_loop: &mut EventLoop, timeout: Self::Timeout) { + } /// Invoked when `EventLoop` has been interrupted by a signal interrupt. - fn interrupted(&mut self, event_loop: &mut EventLoop) {} + fn interrupted(&mut self, event_loop: &mut EventLoop) { + } /// Invoked at the end of an event loop tick. - fn tick(&mut self, event_loop: &mut EventLoop) {} + fn tick(&mut self, event_loop: &mut EventLoop) { + } } diff --git a/src/deprecated/io.rs b/src/deprecated/io.rs index accbf911b..16ff27993 100644 --- a/src/deprecated/io.rs +++ b/src/deprecated/io.rs @@ -1,4 +1,4 @@ -use io::MapNonBlock; +use ::io::MapNonBlock; use std::io::{self, Read, Write}; pub trait TryRead { diff --git a/src/deprecated/mod.rs b/src/deprecated/mod.rs index 52507cbca..124a2eee3 100644 --- a/src/deprecated/mod.rs +++ b/src/deprecated/mod.rs @@ -1,18 +1,36 @@ #![allow(deprecated)] mod event_loop; -mod handler; mod io; +mod handler; mod notify; #[cfg(all(unix, not(target_os = "fuchsia")))] pub mod unix; -pub use self::event_loop::{EventLoop, EventLoopBuilder, Sender}; -pub use self::handler::Handler; -pub use self::io::{TryAccept, TryRead, TryWrite}; -pub use self::notify::NotifyError; +pub use self::event_loop::{ + EventLoop, + EventLoopBuilder, + Sender, +}; +pub use self::io::{ + TryAccept, + TryRead, + TryWrite, +}; +pub use self::handler::{ + Handler, +}; +pub use self::notify::{ + NotifyError, +}; #[cfg(all(unix, not(target_os = "fuchsia")))] pub use self::unix::{ - pipe, PipeReader, PipeWriter, Shutdown, UnixListener, UnixSocket, UnixStream, + pipe, + PipeReader, + PipeWriter, + UnixListener, + UnixSocket, + UnixStream, + Shutdown, }; diff --git a/src/deprecated/notify.rs b/src/deprecated/notify.rs index 26fa68e3d..c8432d6b0 100644 --- a/src/deprecated/notify.rs +++ b/src/deprecated/notify.rs @@ -1,5 +1,5 @@ -use channel; -use std::{any, error, fmt, io}; +use {channel}; +use std::{fmt, io, error, any}; pub enum NotifyError { Io(io::Error), @@ -10,9 +10,15 @@ pub enum NotifyError { impl fmt::Debug for NotifyError { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { match *self { - NotifyError::Io(ref e) => write!(fmt, "NotifyError::Io({:?})", e), - NotifyError::Full(..) => write!(fmt, "NotifyError::Full(..)"), - NotifyError::Closed(..) => write!(fmt, "NotifyError::Closed(..)"), + NotifyError::Io(ref e) => { + write!(fmt, "NotifyError::Io({:?})", e) + } + NotifyError::Full(..) => { + write!(fmt, "NotifyError::Full(..)") + } + NotifyError::Closed(..) => { + write!(fmt, "NotifyError::Closed(..)") + } } } } @@ -20,9 +26,11 @@ impl fmt::Debug for NotifyError { impl fmt::Display for NotifyError { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { match *self { - NotifyError::Io(ref e) => write!(fmt, "IO error: {}", e), + NotifyError::Io(ref e) => { + write!(fmt, "IO error: {}", e) + } NotifyError::Full(..) => write!(fmt, "Full"), - NotifyError::Closed(..) => write!(fmt, "Closed"), + NotifyError::Closed(..) => write!(fmt, "Closed") } } } @@ -32,14 +40,14 @@ impl error::Error for NotifyError { match *self { NotifyError::Io(ref err) => err.description(), NotifyError::Closed(..) => "The receiving end has hung up", - NotifyError::Full(..) => "Queue is full", + NotifyError::Full(..) => "Queue is full" } } fn cause(&self) -> Option<&error::Error> { match *self { NotifyError::Io(ref err) => Some(err), - _ => None, + _ => None } } } diff --git a/src/deprecated/unix.rs b/src/deprecated/unix.rs index 6282ba64c..9f93ae931 100644 --- a/src/deprecated/unix.rs +++ b/src/deprecated/unix.rs @@ -1,11 +1,11 @@ -use deprecated::TryAccept; +use {io, sys, Ready, Poll, PollOpt, Token}; use event::Evented; +use deprecated::TryAccept; use io::MapNonBlock; use std::io::{Read, Write}; -pub use std::net::Shutdown; use std::path::Path; +pub use std::net::Shutdown; use std::process; -use {io, sys, Poll, PollOpt, Ready, Token}; pub use sys::Io; @@ -17,7 +17,8 @@ pub struct UnixSocket { impl UnixSocket { /// Returns a new, unbound, non-blocking Unix domain socket pub fn stream() -> io::Result { - sys::UnixSocket::stream().map(From::from) + sys::UnixSocket::stream() + .map(From::from) } /// Connect the socket to the specified address @@ -42,28 +43,17 @@ impl UnixSocket { } pub fn try_clone(&self) -> io::Result { - self.sys.try_clone().map(From::from) + self.sys.try_clone() + .map(From::from) } } impl Evented for UnixSocket { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.sys.register(poll, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.sys.reregister(poll, token, interest, opts) } @@ -97,7 +87,8 @@ impl UnixStream { } pub fn try_clone(&self) -> io::Result { - self.sys.try_clone().map(From::from) + self.sys.try_clone() + .map(From::from) } pub fn shutdown(&self, how: Shutdown) -> io::Result { @@ -108,10 +99,7 @@ impl UnixStream { self.sys.read_recv_fd(buf) } - pub fn try_read_recv_fd( - &mut self, - buf: &mut [u8], - ) -> io::Result)>> { + pub fn try_read_recv_fd(&mut self, buf: &mut [u8]) -> io::Result)>> { self.read_recv_fd(buf).map_non_block() } @@ -141,23 +129,11 @@ impl Write for UnixStream { } impl Evented for UnixStream { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.sys.register(poll, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.sys.reregister(poll, token, interest, opts) } @@ -201,23 +177,11 @@ impl UnixListener { } impl Evented for UnixListener { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.sys.register(poll, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.sys.reregister(poll, token, interest, opts) } @@ -260,20 +224,16 @@ impl PipeReader { pub fn from_stdout(stdout: process::ChildStdout) -> io::Result { match sys::set_nonblock(stdout.as_raw_fd()) { Err(e) => return Err(e), - _ => {} + _ => {}, } - return Ok(PipeReader::from(unsafe { - Io::from_raw_fd(stdout.into_raw_fd()) - })); + return Ok(PipeReader::from(unsafe { Io::from_raw_fd(stdout.into_raw_fd()) })); } pub fn from_stderr(stderr: process::ChildStderr) -> io::Result { match sys::set_nonblock(stderr.as_raw_fd()) { Err(e) => return Err(e), - _ => {} + _ => {}, } - return Ok(PipeReader::from(unsafe { - Io::from_raw_fd(stderr.into_raw_fd()) - })); + return Ok(PipeReader::from(unsafe { Io::from_raw_fd(stderr.into_raw_fd()) })); } } @@ -290,23 +250,11 @@ impl<'a> Read for &'a PipeReader { } impl Evented for PipeReader { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.io.register(poll, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.io.reregister(poll, token, interest, opts) } @@ -330,11 +278,9 @@ impl PipeWriter { pub fn from_stdin(stdin: process::ChildStdin) -> io::Result { match sys::set_nonblock(stdin.as_raw_fd()) { Err(e) => return Err(e), - _ => {} + _ => {}, } - return Ok(PipeWriter::from(unsafe { - Io::from_raw_fd(stdin.into_raw_fd()) - })); + return Ok(PipeWriter::from(unsafe { Io::from_raw_fd(stdin.into_raw_fd()) })); } } @@ -359,23 +305,11 @@ impl<'a> Write for &'a PipeWriter { } impl Evented for PipeWriter { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.io.register(poll, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.io.reregister(poll, token, interest, opts) } @@ -396,7 +330,7 @@ impl From for PipeWriter { * */ -use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; +use std::os::unix::io::{RawFd, IntoRawFd, AsRawFd, FromRawFd}; impl IntoRawFd for UnixSocket { fn into_raw_fd(self) -> RawFd { @@ -412,9 +346,7 @@ impl AsRawFd for UnixSocket { impl FromRawFd for UnixSocket { unsafe fn from_raw_fd(fd: RawFd) -> UnixSocket { - UnixSocket { - sys: FromRawFd::from_raw_fd(fd), - } + UnixSocket { sys: FromRawFd::from_raw_fd(fd) } } } @@ -432,9 +364,7 @@ impl AsRawFd for UnixStream { impl FromRawFd for UnixStream { unsafe fn from_raw_fd(fd: RawFd) -> UnixStream { - UnixStream { - sys: FromRawFd::from_raw_fd(fd), - } + UnixStream { sys: FromRawFd::from_raw_fd(fd) } } } @@ -452,9 +382,7 @@ impl AsRawFd for UnixListener { impl FromRawFd for UnixListener { unsafe fn from_raw_fd(fd: RawFd) -> UnixListener { - UnixListener { - sys: FromRawFd::from_raw_fd(fd), - } + UnixListener { sys: FromRawFd::from_raw_fd(fd) } } } @@ -472,9 +400,7 @@ impl AsRawFd for PipeReader { impl FromRawFd for PipeReader { unsafe fn from_raw_fd(fd: RawFd) -> PipeReader { - PipeReader { - io: FromRawFd::from_raw_fd(fd), - } + PipeReader { io: FromRawFd::from_raw_fd(fd) } } } @@ -492,8 +418,6 @@ impl AsRawFd for PipeWriter { impl FromRawFd for PipeWriter { unsafe fn from_raw_fd(fd: RawFd) -> PipeWriter { - PipeWriter { - io: FromRawFd::from_raw_fd(fd), - } + PipeWriter { io: FromRawFd::from_raw_fd(fd) } } } diff --git a/src/event_imp.rs b/src/event_imp.rs index 84b2a61ba..6c60aad0f 100644 --- a/src/event_imp.rs +++ b/src/event_imp.rs @@ -1,5 +1,5 @@ -use std::{fmt, io, ops}; use {Poll, Token}; +use std::{fmt, io, ops}; /// A value that may be registered with `Poll` /// @@ -129,8 +129,7 @@ pub trait Evented { /// /// [`Poll::register`]: ../struct.Poll.html#method.register /// [`Registration`]: ../struct.Registration.html - fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) - -> io::Result<()>; + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()>; /// Re-register `self` with the given `Poll` instance. /// @@ -141,13 +140,7 @@ pub trait Evented { /// /// [`Poll::reregister`]: ../struct.Poll.html#method.reregister /// [`SetReadiness::set_readiness`]: ../struct.SetReadiness.html#method.set_readiness - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()>; + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()>; /// Deregister `self` from the given `Poll` instance /// @@ -162,23 +155,11 @@ pub trait Evented { } impl Evented for Box { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.as_ref().register(poll, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.as_ref().reregister(poll, token, interest, opts) } @@ -188,23 +169,11 @@ impl Evented for Box { } impl Evented for Box { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.as_ref().register(poll, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.as_ref().reregister(poll, token, interest, opts) } @@ -214,23 +183,11 @@ impl Evented for Box { } impl Evented for ::std::sync::Arc { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.as_ref().register(poll, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.as_ref().reregister(poll, token, interest, opts) } @@ -573,14 +530,11 @@ impl fmt::Debug for PollOpt { let flags = [ (PollOpt::edge(), "Edge-Triggered"), (PollOpt::level(), "Level-Triggered"), - (PollOpt::oneshot(), "OneShot"), - ]; + (PollOpt::oneshot(), "OneShot")]; for &(flag, msg) in &flags { if self.contains(flag) { - if one { - write!(fmt, " | ")? - } + if one { write!(fmt, " | ")? } write!(fmt, "{}", msg)?; one = true @@ -1062,14 +1016,11 @@ impl fmt::Debug for Ready { (Ready::readable(), "Readable"), (Ready::writable(), "Writable"), (Ready(ERROR), "Error"), - (Ready(HUP), "Hup"), - ]; + (Ready(HUP), "Hup")]; for &(flag, msg) in &flags { if self.contains(flag) { - if one { - write!(fmt, " | ")? - } + if one { write!(fmt, " | ")? } write!(fmt, "{}", msg)?; one = true @@ -1117,7 +1068,7 @@ fn test_debug_ready() { #[derive(Copy, Clone, Eq, PartialEq, Debug)] pub struct Event { kind: Ready, - token: Token, + token: Token } impl Event { diff --git a/src/io.rs b/src/io.rs index f7c9eed98..275001387 100644 --- a/src/io.rs +++ b/src/io.rs @@ -1,5 +1,5 @@ // Re-export the io::Result / Error types for convenience -pub use std::io::{Error, ErrorKind, Read, Result, Write}; +pub use std::io::{Read, Write, Result, Error, ErrorKind}; // TODO: Delete this /// A helper trait to provide the map_non_block function on Results. diff --git a/src/lib.rs b/src/lib.rs index f24145cb7..d26628fd5 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -92,11 +92,12 @@ #![doc(html_root_url = "https://docs.rs/mio/0.6.15")] #![crate_name = "mio"] + #![deny(warnings, missing_docs, missing_debug_implementations)] -extern crate iovec; extern crate lazycell; extern crate net2; +extern crate iovec; extern crate slab; #[cfg(target_os = "fuchsia")] @@ -160,18 +161,27 @@ pub mod tcp { #[doc(hidden)] pub mod udp; -pub use event_imp::{PollOpt, Ready}; -pub use poll::{Poll, Registration, SetReadiness}; +pub use poll::{ + Poll, + Registration, + SetReadiness, +}; +pub use event_imp::{ + PollOpt, + Ready, +}; pub use token::Token; pub mod event { //! Readiness event types and utilities. - pub use super::event_imp::{Event, Evented}; pub use super::poll::{Events, Iter}; + pub use super::event_imp::{Event, Evented}; } -pub use event::Events; +pub use event::{ + Events, +}; #[deprecated(since = "0.6.5", note = "use events:: instead")] #[cfg(feature = "with-deprecated")] @@ -183,10 +193,7 @@ pub use event::{Event, Evented}; #[doc(hidden)] pub use poll::Iter as EventsIter; -#[deprecated( - since = "0.6.5", - note = "std::io::Error can avoid the allocation now" -)] +#[deprecated(since = "0.6.5", note = "std::io::Error can avoid the allocation now")] #[cfg(feature = "with-deprecated")] #[doc(hidden)] pub use io::deprecated::would_block; @@ -194,8 +201,10 @@ pub use io::deprecated::would_block; #[cfg(all(unix, not(target_os = "fuchsia")))] pub mod unix { //! Unix only extensions + pub use sys::{ + EventedFd, + }; pub use sys::unix::UnixReady; - pub use sys::EventedFd; } #[cfg(target_os = "fuchsia")] @@ -207,8 +216,10 @@ pub mod fuchsia { //! This module depends on the [magenta-sys crate](https://crates.io/crates/magenta-sys) //! and so might introduce breaking changes, even on minor releases, //! so long as that crate remains unstable. - pub use sys::fuchsia::{zx_signals_t, FuchsiaReady}; - pub use sys::EventedHandle; + pub use sys::{ + EventedHandle, + }; + pub use sys::fuchsia::{FuchsiaReady, zx_signals_t}; } /// Windows-only extensions to the mio crate. @@ -264,7 +275,7 @@ pub mod fuchsia { #[cfg(windows)] pub mod windows { - pub use sys::{Binding, Overlapped}; + pub use sys::{Overlapped, Binding}; } #[cfg(feature = "with-deprecated")] @@ -282,9 +293,6 @@ mod convert { pub fn millis(duration: Duration) -> u64 { // Round up. let millis = (duration.subsec_nanos() + NANOS_PER_MILLI - 1) / NANOS_PER_MILLI; - duration - .as_secs() - .saturating_mul(MILLIS_PER_SEC) - .saturating_add(millis as u64) + duration.as_secs().saturating_mul(MILLIS_PER_SEC).saturating_add(millis as u64) } } diff --git a/src/net/tcp.rs b/src/net/tcp.rs index cc272870b..dfde91a65 100644 --- a/src/net/tcp.rs +++ b/src/net/tcp.rs @@ -6,17 +6,18 @@ //! matter the target platform. //! /// [portability guidelines]: ../struct.Poll.html#portability + use std::fmt; use std::io::{Read, Write}; -use std::net::{self, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6}; +use std::net::{self, SocketAddr, SocketAddrV4, SocketAddrV6, Ipv4Addr, Ipv6Addr}; use std::time::Duration; -use iovec::IoVec; use net2::TcpBuilder; +use iovec::IoVec; +use {io, sys, Ready, Poll, PollOpt, Token}; use event::Evented; use poll::SelectorId; -use {io, sys, Poll, PollOpt, Ready, Token}; /* * @@ -69,13 +70,15 @@ use std::net::Shutdown; // TODO: remove when fuchsia's set_nonblocking is fixed in libstd #[cfg(target_os = "fuchsia")] fn set_nonblocking(stream: &net::TcpStream) -> io::Result<()> { - sys::set_nonblock(::std::os::unix::io::AsRawFd::as_raw_fd(stream)) + sys::set_nonblock( + ::std::os::unix::io::AsRawFd::as_raw_fd(stream)) } #[cfg(not(target_os = "fuchsia"))] fn set_nonblocking(stream: &net::TcpStream) -> io::Result<()> { stream.set_nonblocking(true) } + impl TcpStream { /// Create a new TCP stream and issue a non-blocking connect to the /// specified address. @@ -117,7 +120,8 @@ impl TcpStream { /// loop. Note that on Windows you must `bind` a socket before it can be /// connected, so if a custom `TcpBuilder` is used it should be bound /// (perhaps to `INADDR_ANY`) before this method is called. - pub fn connect_stream(stream: net::TcpStream, addr: &SocketAddr) -> io::Result { + pub fn connect_stream(stream: net::TcpStream, + addr: &SocketAddr) -> io::Result { Ok(TcpStream { sys: sys::TcpStream::connect(stream, addr)?, selector_id: SelectorId::new(), @@ -160,9 +164,11 @@ impl TcpStream { /// data, and options set on one stream will be propagated to the other /// stream. pub fn try_clone(&self) -> io::Result { - self.sys.try_clone().map(|s| TcpStream { - sys: s, - selector_id: self.selector_id.clone(), + self.sys.try_clone().map(|s| { + TcpStream { + sys: s, + selector_id: self.selector_id.clone(), + } }) } @@ -320,8 +326,11 @@ impl TcpStream { #[cfg(feature = "with-deprecated")] #[doc(hidden)] pub fn keepalive_ms(&self) -> io::Result> { - self.keepalive() - .map(|v| v.map(|v| ::convert::millis(v) as u32)) + self.keepalive().map(|v| { + v.map(|v| { + ::convert::millis(v) as u32 + }) + }) } /// Get the value of the `SO_ERROR` option on this socket. @@ -428,24 +437,14 @@ impl<'a> Write for &'a TcpStream { } impl Evented for TcpStream { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { self.selector_id.associate_selector(poll)?; self.sys.register(poll, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { self.sys.reregister(poll, token, interest, opts) } @@ -542,7 +541,8 @@ impl TcpListener { #[deprecated(since = "0.6.13", note = "use from_std instead")] #[cfg(feature = "with-deprecated")] #[doc(hidden)] - pub fn from_listener(listener: net::TcpListener, _: &SocketAddr) -> io::Result { + pub fn from_listener(listener: net::TcpListener, _: &SocketAddr) + -> io::Result { TcpListener::from_std(listener) } @@ -556,9 +556,11 @@ impl TcpListener { /// /// The address provided must be the address that the listener is bound to. pub fn from_std(listener: net::TcpListener) -> io::Result { - sys::TcpListener::new(listener).map(|s| TcpListener { - sys: s, - selector_id: SelectorId::new(), + sys::TcpListener::new(listener).map(|s| { + TcpListener { + sys: s, + selector_id: SelectorId::new(), + } }) } @@ -596,9 +598,11 @@ impl TcpListener { /// object references. Both handles can be used to accept incoming /// connections and options set on one listener will affect the other. pub fn try_clone(&self) -> io::Result { - self.sys.try_clone().map(|s| TcpListener { - sys: s, - selector_id: self.selector_id.clone(), + self.sys.try_clone().map(|s| { + TcpListener { + sys: s, + selector_id: self.selector_id.clone(), + } }) } @@ -651,24 +655,14 @@ impl TcpListener { } impl Evented for TcpListener { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { self.selector_id.associate_selector(poll)?; self.sys.register(poll, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { self.sys.reregister(poll, token, interest, opts) } @@ -690,7 +684,7 @@ impl fmt::Debug for TcpListener { */ #[cfg(all(unix, not(target_os = "fuchsia")))] -use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; +use std::os::unix::io::{IntoRawFd, AsRawFd, FromRawFd, RawFd}; #[cfg(all(unix, not(target_os = "fuchsia")))] impl IntoRawFd for TcpStream { diff --git a/src/net/udp.rs b/src/net/udp.rs index 9eeadfa3e..d82cebc2b 100644 --- a/src/net/udp.rs +++ b/src/net/udp.rs @@ -5,12 +5,13 @@ //! [portability guidelines] are followed, the behavior should be identical no //! matter the target platform. //! +/// [portability guidelines]: ../struct.Poll.html#portability + +use {io, sys, Ready, Poll, PollOpt, Token}; use event::Evented; use poll::SelectorId; use std::fmt; use std::net::{self, Ipv4Addr, Ipv6Addr, SocketAddr}; -/// [portability guidelines]: ../struct.Poll.html#portability -use {io, sys, Poll, PollOpt, Ready, Token}; /// A User Datagram Protocol socket. /// @@ -195,10 +196,13 @@ impl UdpSocket { /// # } /// ``` pub fn try_clone(&self) -> io::Result { - self.sys.try_clone().map(|s| UdpSocket { - sys: s, - selector_id: self.selector_id.clone(), - }) + self.sys.try_clone() + .map(|s| { + UdpSocket { + sys: s, + selector_id: self.selector_id.clone(), + } + }) } /// Sends data on the socket to the given address. On success, returns the @@ -468,7 +472,9 @@ impl UdpSocket { /// address of the local interface with which the system should join the /// multicast group. If it's equal to `INADDR_ANY` then an appropriate /// interface is chosen by the system. - pub fn join_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> { + pub fn join_multicast_v4(&self, + multiaddr: &Ipv4Addr, + interface: &Ipv4Addr) -> io::Result<()> { self.sys.join_multicast_v4(multiaddr, interface) } @@ -477,7 +483,9 @@ impl UdpSocket { /// This function specifies a new multicast group for this socket to join. /// The address must be a valid multicast address, and `interface` is the /// index of the interface to join/leave (or 0 to indicate any interface). - pub fn join_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> { + pub fn join_multicast_v6(&self, + multiaddr: &Ipv6Addr, + interface: u32) -> io::Result<()> { self.sys.join_multicast_v6(multiaddr, interface) } @@ -487,7 +495,9 @@ impl UdpSocket { /// [`join_multicast_v4`][link]. /// /// [link]: #method.join_multicast_v4 - pub fn leave_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> { + pub fn leave_multicast_v4(&self, + multiaddr: &Ipv4Addr, + interface: &Ipv4Addr) -> io::Result<()> { self.sys.leave_multicast_v4(multiaddr, interface) } @@ -497,7 +507,9 @@ impl UdpSocket { /// [`join_multicast_v6`][link]. /// /// [link]: #method.join_multicast_v6 - pub fn leave_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> { + pub fn leave_multicast_v6(&self, + multiaddr: &Ipv6Addr, + interface: u32) -> io::Result<()> { self.sys.leave_multicast_v6(multiaddr, interface) } @@ -533,24 +545,12 @@ impl UdpSocket { } impl Evented for UdpSocket { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.selector_id.associate_selector(poll)?; self.sys.register(poll, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.sys.reregister(poll, token, interest, opts) } @@ -572,7 +572,7 @@ impl fmt::Debug for UdpSocket { */ #[cfg(all(unix, not(target_os = "fuchsia")))] -use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; +use std::os::unix::io::{IntoRawFd, AsRawFd, FromRawFd, RawFd}; #[cfg(all(unix, not(target_os = "fuchsia")))] impl IntoRawFd for UdpSocket { @@ -597,3 +597,4 @@ impl FromRawFd for UdpSocket { } } } + diff --git a/src/poll.rs b/src/poll.rs index 3e7754d03..a2fcf23df 100644 --- a/src/poll.rs +++ b/src/poll.rs @@ -1,16 +1,16 @@ -use event_imp::{self as event, Event, Evented, PollOpt, Ready}; +use {sys, Token}; +use event_imp::{self as event, Ready, Event, Evented, PollOpt}; +use std::{fmt, io, ptr, usize}; use std::cell::UnsafeCell; +use std::{mem, ops, isize}; #[cfg(all(unix, not(target_os = "fuchsia")))] use std::os::unix::io::AsRawFd; #[cfg(all(unix, not(target_os = "fuchsia")))] use std::os::unix::io::RawFd; -use std::sync::atomic::Ordering::{self, AcqRel, Acquire, Relaxed, Release, SeqCst}; -use std::sync::atomic::{AtomicBool, AtomicPtr, AtomicUsize}; -use std::sync::{Arc, Condvar, Mutex}; +use std::sync::{Arc, Mutex, Condvar}; +use std::sync::atomic::{AtomicUsize, AtomicPtr, AtomicBool}; +use std::sync::atomic::Ordering::{self, Acquire, Release, AcqRel, Relaxed, SeqCst}; use std::time::{Duration, Instant}; -use std::{fmt, io, ptr, usize}; -use std::{isize, mem, ops}; -use {sys, Token}; // Poll is backed by two readiness queues. The first is a system readiness queue // represented by `sys::Selector`. The system readiness queue handles events @@ -61,6 +61,7 @@ use {sys, Token}; // // [1] http://www.1024cores.net/home/lock-free-algorithms/queues/intrusive-mpsc-node-based-queue + /// Polls for readiness events on all registered values. /// /// `Poll` allows a program to monitor a large number of `Evented` types, @@ -659,12 +660,7 @@ impl Poll { }; // Register the notification wakeup FD with the IO poller - poll.readiness_queue.inner.awakener.register( - &poll, - AWAKEN, - Ready::readable(), - PollOpt::edge(), - )?; + poll.readiness_queue.inner.awakener.register(&poll, AWAKEN, Ready::readable(), PollOpt::edge())?; Ok(poll) } @@ -776,15 +772,8 @@ impl Poll { /// # try_main().unwrap(); /// # } /// ``` - pub fn register( - &self, - handle: &E, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> - where - E: Evented, + pub fn register(&self, handle: &E, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> + where E: Evented { validate_args(token)?; @@ -854,15 +843,8 @@ impl Poll { /// [`register`]: #method.register /// [`readable`]: struct.Ready.html#method.readable /// [`writable`]: struct.Ready.html#method.writable - pub fn reregister( - &self, - handle: &E, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> - where - E: Evented, + pub fn reregister(&self, handle: &E, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> + where E: Evented { validate_args(token)?; @@ -918,8 +900,7 @@ impl Poll { /// # } /// ``` pub fn deregister(&self, handle: &E) -> io::Result<()> - where - E: Evented, + where E: Evented { trace!("deregistering handle with poller"); @@ -1031,20 +1012,11 @@ impl Poll { /// /// If `poll` is inturrupted while blocking, it will transparently retry the syscall. If you /// want to handle signals yourself, however, use `poll_interruptible`. - pub fn poll_interruptible( - &self, - events: &mut Events, - timeout: Option, - ) -> io::Result { + pub fn poll_interruptible(&self, events: &mut Events, timeout: Option) -> io::Result { self.poll1(events, timeout, true) } - fn poll1( - &self, - events: &mut Events, - mut timeout: Option, - interruptible: bool, - ) -> io::Result { + fn poll1(&self, events: &mut Events, mut timeout: Option, interruptible: bool) -> io::Result { let zero = Some(Duration::from_millis(0)); // At a high level, the synchronization strategy is to acquire access to @@ -1150,7 +1122,9 @@ impl Poll { l } - None => self.condvar.wait(lock).unwrap(), + None => { + self.condvar.wait(lock).unwrap() + } }; // Reload the state @@ -1175,12 +1149,7 @@ impl Poll { } #[inline] - fn poll2( - &self, - events: &mut Events, - mut timeout: Option, - interruptible: bool, - ) -> io::Result { + fn poll2(&self, events: &mut Events, mut timeout: Option, interruptible: bool) -> io::Result { // Compute the timeout value passed to the system selector. If the // readiness queue has pending nodes, we still want to poll the system // selector for new events, but we don't want to block the thread to @@ -1242,7 +1211,8 @@ fn validate_args(token: Token) -> io::Result<()> { impl fmt::Debug for Poll { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("Poll").finish() + fmt.debug_struct("Poll") + .finish() } } @@ -1388,20 +1358,14 @@ impl Events { } } - #[deprecated( - since = "0.6.10", - note = "Index access removed in favor of iterator only API." - )] + #[deprecated(since="0.6.10", note="Index access removed in favor of iterator only API.")] #[doc(hidden)] pub fn get(&self, idx: usize) -> Option { self.inner.get(idx) } #[doc(hidden)] - #[deprecated( - since = "0.6.10", - note = "Index access removed in favor of iterator only API." - )] + #[deprecated(since="0.6.10", note="Index access removed in favor of iterator only API.")] pub fn len(&self) -> usize { self.inner.len() } @@ -1464,7 +1428,7 @@ impl Events { pub fn iter(&self) -> Iter { Iter { inner: self, - pos: 0, + pos: 0 } } @@ -1565,12 +1529,9 @@ pub fn selector(poll: &Poll) -> &sys::Selector { // TODO: get rid of this, windows depends on it for now #[allow(dead_code)] -pub fn new_registration( - poll: &Poll, - token: Token, - ready: Ready, - opt: PollOpt, -) -> (Registration, SetReadiness) { +pub fn new_registration(poll: &Poll, token: Token, ready: Ready, opt: PollOpt) + -> (Registration, SetReadiness) +{ Registration::new_priv(poll, token, ready, opt) } @@ -1625,19 +1586,18 @@ impl Registration { // Allocate the registration node. The new node will have `ref_count` // set to 2: one SetReadiness, one Registration. let node = Box::into_raw(Box::new(ReadinessNode::new( - ptr::null_mut(), - Token(0), - Ready::empty(), - PollOpt::empty(), - 2, - ))); + ptr::null_mut(), Token(0), Ready::empty(), PollOpt::empty(), 2))); let registration = Registration { - inner: RegistrationInner { node: node }, + inner: RegistrationInner { + node: node, + }, }; let set_readiness = SetReadiness { - inner: RegistrationInner { node: node }, + inner: RegistrationInner { + node: node, + }, }; (registration, set_readiness) @@ -1646,22 +1606,16 @@ impl Registration { #[deprecated(since = "0.6.5", note = "use `new2` instead")] #[cfg(feature = "with-deprecated")] #[doc(hidden)] - pub fn new( - poll: &Poll, - token: Token, - interest: Ready, - opt: PollOpt, - ) -> (Registration, SetReadiness) { + pub fn new(poll: &Poll, token: Token, interest: Ready, opt: PollOpt) + -> (Registration, SetReadiness) + { Registration::new_priv(poll, token, interest, opt) } // TODO: Get rid of this (windows depends on it for now) - fn new_priv( - poll: &Poll, - token: Token, - interest: Ready, - opt: PollOpt, - ) -> (Registration, SetReadiness) { + fn new_priv(poll: &Poll, token: Token, interest: Ready, opt: PollOpt) + -> (Registration, SetReadiness) + { is_send::(); is_sync::(); is_send::(); @@ -1675,14 +1629,19 @@ impl Registration { // Allocate the registration node. The new node will have `ref_count` // set to 3: one SetReadiness, one Registration, and one Poll handle. - let node = Box::into_raw(Box::new(ReadinessNode::new(queue, token, interest, opt, 3))); + let node = Box::into_raw(Box::new(ReadinessNode::new( + queue, token, interest, opt, 3))); let registration = Registration { - inner: RegistrationInner { node: node }, + inner: RegistrationInner { + node: node, + }, }; let set_readiness = SetReadiness { - inner: RegistrationInner { node: node }, + inner: RegistrationInner { + node: node, + }, }; (registration, set_readiness) @@ -1691,13 +1650,7 @@ impl Registration { #[deprecated(since = "0.6.5", note = "use `Evented` impl")] #[cfg(feature = "with-deprecated")] #[doc(hidden)] - pub fn update( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + pub fn update(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.inner.update(poll, token, interest, opts) } @@ -1705,35 +1658,21 @@ impl Registration { #[cfg(feature = "with-deprecated")] #[doc(hidden)] pub fn deregister(&self, poll: &Poll) -> io::Result<()> { - self.inner - .update(poll, Token(0), Ready::empty(), PollOpt::empty()) + self.inner.update(poll, Token(0), Ready::empty(), PollOpt::empty()) } } impl Evented for Registration { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.inner.update(poll, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.inner.update(poll, token, interest, opts) } fn deregister(&self, poll: &Poll) -> io::Result<()> { - self.inner - .update(poll, Token(0), Ready::empty(), PollOpt::empty()) + self.inner.update(poll, Token(0), Ready::empty(), PollOpt::empty()) } } @@ -1751,7 +1690,8 @@ impl Drop for Registration { impl fmt::Debug for Registration { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("Registration").finish() + fmt.debug_struct("Registration") + .finish() } } @@ -1874,7 +1814,8 @@ impl SetReadiness { impl fmt::Debug for SetReadiness { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("SetReadiness").finish() + f.debug_struct("SetReadiness") + .finish() } } @@ -1944,7 +1885,8 @@ impl RegistrationInner { if queue.is_null() { // Attempt to set the queue pointer. `Release` ordering synchronizes // with `Acquire` in `ensure_with_wakeup`. - let actual = self.readiness_queue.compare_and_swap(queue, other, Release); + let actual = self.readiness_queue.compare_and_swap( + queue, other, Release); if actual.is_null() { // The CAS succeeded, this means that the node's ref count @@ -1968,19 +1910,13 @@ impl RegistrationInner { // The CAS failed, another thread set the queue pointer, so ensure // that the pointer and `other` match if actual != other { - return Err(io::Error::new( - io::ErrorKind::Other, - "registration handle associated with another `Poll` instance", - )); + return Err(io::Error::new(io::ErrorKind::Other, "registration handle associated with another `Poll` instance")); } } queue = other; } else if queue != other { - return Err(io::Error::new( - io::ErrorKind::Other, - "registration handle associated with another `Poll` instance", - )); + return Err(io::Error::new(io::ErrorKind::Other, "registration handle associated with another `Poll` instance")); } unsafe { @@ -2169,7 +2105,7 @@ impl ReadinessQueue { end_marker: end_marker, sleep_marker: sleep_marker, closed_marker: closed_marker, - }), + }) }) } @@ -2180,7 +2116,8 @@ impl ReadinessQueue { // loop where `Poll::poll` will keep dequeuing nodes it enqueues. let mut until = ptr::null_mut(); - 'outer: while dst.len() < dst.capacity() { + 'outer: + while dst.len() < dst.capacity() { // Dequeue a node. If the queue is in an inconsistent state, then // stop polling. `Poll::poll` will be called again shortly and enter // a syscall, which should be enough to enable the other thread to @@ -2303,15 +2240,10 @@ impl ReadinessQueue { // Before inserting a node into the queue, the next pointer has to be // set to null. Again, this is only safe to do when the node is not // currently in the queue, but we already have ensured this. - self.inner - .sleep_marker - .next_readiness - .store(ptr::null_mut(), Relaxed); + self.inner.sleep_marker.next_readiness.store(ptr::null_mut(), Relaxed); - let actual = self - .inner - .head_readiness - .compare_and_swap(end_marker, sleep_marker, AcqRel); + let actual = self.inner.head_readiness.compare_and_swap( + end_marker, sleep_marker, AcqRel); debug_assert!(actual != sleep_marker); @@ -2326,9 +2258,7 @@ impl ReadinessQueue { debug_assert!(self.inner.end_marker.next_readiness.load(Relaxed).is_null()); // Update tail pointer. - unsafe { - *self.inner.tail_readiness.get() = sleep_marker; - } + unsafe { *self.inner.tail_readiness.get() = sleep_marker; } true } } @@ -2430,8 +2360,7 @@ impl ReadinessQueueInner { let mut tail = *self.tail_readiness.get(); let mut next = (*tail).next_readiness.load(Acquire); - if tail == self.end_marker() || tail == self.sleep_marker() || tail == self.closed_marker() - { + if tail == self.end_marker() || tail == self.sleep_marker() || tail == self.closed_marker() { if next.is_null() { return Dequeue::Empty; } @@ -2489,13 +2418,12 @@ impl ReadinessQueueInner { impl ReadinessNode { /// Return a new `ReadinessNode`, initialized with a ref_count of 3. - fn new( - queue: *mut (), - token: Token, - interest: Ready, - opt: PollOpt, - ref_count: usize, - ) -> ReadinessNode { + fn new(queue: *mut (), + token: Token, + interest: Ready, + opt: PollOpt, + ref_count: usize) -> ReadinessNode + { ReadinessNode { state: AtomicState::new(interest, opt), // Only the first token is set, the others are initialized to 0 @@ -2586,23 +2514,13 @@ impl AtomicState { } /// Stores a state if the current state is the same as `current`. - fn compare_and_swap( - &self, - current: ReadinessState, - new: ReadinessState, - order: Ordering, - ) -> ReadinessState { - self.inner - .compare_and_swap(current.into(), new.into(), order) - .into() + fn compare_and_swap(&self, current: ReadinessState, new: ReadinessState, order: Ordering) -> ReadinessState { + self.inner.compare_and_swap(current.into(), new.into(), order).into() } // Returns `true` if the node should be queued fn flag_as_dropped(&self) -> bool { - let prev: ReadinessState = self - .inner - .fetch_or(DROPPED_MASK | QUEUED_MASK, Release) - .into(); + let prev: ReadinessState = self.inner.fetch_or(DROPPED_MASK | QUEUED_MASK, Release).into(); // The flag should not have been previously set debug_assert!(!prev.is_dropped()); @@ -2627,7 +2545,7 @@ impl ReadinessState { } #[inline] - fn get(&self, mask: usize, shift: usize) -> usize { + fn get(&self, mask: usize, shift: usize) -> usize{ (self.0 >> shift) & mask } @@ -2725,24 +2643,30 @@ impl ReadinessState { let wr = self.token_write_pos(); match wr { - 0 => match rd { - 1 => 2, - 2 => 1, - 0 => 1, - _ => unreachable!(), - }, - 1 => match rd { - 0 => 2, - 2 => 0, - 1 => 2, - _ => unreachable!(), - }, - 2 => match rd { - 0 => 1, - 1 => 0, - 2 => 0, - _ => unreachable!(), - }, + 0 => { + match rd { + 1 => 2, + 2 => 1, + 0 => 1, + _ => unreachable!(), + } + } + 1 => { + match rd { + 0 => 2, + 2 => 0, + 1 => 2, + _ => unreachable!(), + } + } + 2 => { + match rd { + 0 => 1, + 1 => 0, + 2 => 0, + _ => unreachable!(), + } + } _ => unreachable!(), } } @@ -2785,10 +2709,7 @@ impl SelectorId { let selector_id = self.id.load(Ordering::SeqCst); if selector_id != 0 && selector_id != poll.selector.id() { - Err(io::Error::new( - io::ErrorKind::Other, - "socket already registered", - )) + Err(io::Error::new(io::ErrorKind::Other, "socket already registered")) } else { self.id.store(poll.selector.id(), Ordering::SeqCst); Ok(()) diff --git a/src/sys/fuchsia/awakener.rs b/src/sys/fuchsia/awakener.rs index d92f63673..19bc76242 100644 --- a/src/sys/fuchsia/awakener.rs +++ b/src/sys/fuchsia/awakener.rs @@ -1,6 +1,6 @@ -use std::sync::{Arc, Mutex, Weak}; +use {io, poll, Evented, Ready, Poll, PollOpt, Token}; use zircon; -use {io, poll, Evented, Poll, PollOpt, Ready, Token}; +use std::sync::{Arc, Mutex, Weak}; pub struct Awakener { /// Token and weak reference to the port on which Awakener was registered. @@ -13,25 +13,21 @@ impl Awakener { /// Create a new `Awakener`. pub fn new() -> io::Result { Ok(Awakener { - inner: Mutex::new(None), + inner: Mutex::new(None) }) } /// Send a wakeup signal to the `Selector` on which the `Awakener` was registered. pub fn wakeup(&self) -> io::Result<()> { let inner_locked = self.inner.lock().unwrap(); - let &(token, ref weak_port) = inner_locked - .as_ref() - .expect("Called wakeup on unregistered awakener."); + let &(token, ref weak_port) = + inner_locked.as_ref().expect("Called wakeup on unregistered awakener."); let port = weak_port.upgrade().expect("Tried to wakeup a closed port."); let status = 0; // arbitrary let packet = zircon::Packet::from_user_packet( - token.0 as u64, - status, - zircon::UserPacket::from_u8_array([0; 32]), - ); + token.0 as u64, status, zircon::UserPacket::from_u8_array([0; 32])); Ok(port.queue(&packet)?) } @@ -40,13 +36,12 @@ impl Awakener { } impl Evented for Awakener { - fn register( - &self, - poll: &Poll, - token: Token, - _events: Ready, - _opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, + poll: &Poll, + token: Token, + _events: Ready, + _opts: PollOpt) -> io::Result<()> + { let mut inner_locked = self.inner.lock().unwrap(); if inner_locked.is_some() { panic!("Called register on already-registered Awakener."); @@ -56,23 +51,23 @@ impl Evented for Awakener { Ok(()) } - fn reregister( - &self, - poll: &Poll, - token: Token, - _events: Ready, - _opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, + poll: &Poll, + token: Token, + _events: Ready, + _opts: PollOpt) -> io::Result<()> + { let mut inner_locked = self.inner.lock().unwrap(); *inner_locked = Some((token, Arc::downgrade(poll::selector(poll).port()))); Ok(()) } - fn deregister(&self, _poll: &Poll) -> io::Result<()> { + fn deregister(&self, _poll: &Poll) -> io::Result<()> + { let mut inner_locked = self.inner.lock().unwrap(); *inner_locked = None; Ok(()) } -} +} \ No newline at end of file diff --git a/src/sys/fuchsia/eventedfd.rs b/src/sys/fuchsia/eventedfd.rs index df1c94bab..e23d0c4a1 100644 --- a/src/sys/fuchsia/eventedfd.rs +++ b/src/sys/fuchsia/eventedfd.rs @@ -1,11 +1,11 @@ +use {io, poll, Evented, Ready, Poll, PollOpt, Token}; use libc; +use zircon; +use zircon::AsHandleRef; +use sys::fuchsia::{DontDrop, poll_opts_to_wait_async, sys}; use std::mem; use std::os::unix::io::RawFd; use std::sync::{Arc, Mutex}; -use sys::fuchsia::{poll_opts_to_wait_async, sys, DontDrop}; -use zircon; -use zircon::AsHandleRef; -use {io, poll, Evented, Poll, PollOpt, Ready, Token}; /// Properties of an `EventedFd`'s current registration #[derive(Debug)] @@ -16,15 +16,15 @@ pub struct EventedFdRegistration { } impl EventedFdRegistration { - unsafe fn new( - token: Token, - raw_handle: sys::zx_handle_t, - rereg_signals: Option<(zircon::Signals, zircon::WaitAsyncOpts)>, - ) -> Self { + unsafe fn new(token: Token, + raw_handle: sys::zx_handle_t, + rereg_signals: Option<(zircon::Signals, zircon::WaitAsyncOpts)>, + ) -> Self + { EventedFdRegistration { token: token, handle: DontDrop::new(zircon::Handle::from_raw(raw_handle)), - rereg_signals: rereg_signals, + rereg_signals: rereg_signals } } @@ -53,12 +53,14 @@ impl EventedFdInner { let registration_opt = self.registration.lock().unwrap(); if let Some(ref registration) = *registration_opt { if let Some((rereg_signals, rereg_opts)) = registration.rereg_signals { - let _res = registration.handle.inner_ref().wait_async_handle( - port, - registration.token.0 as u64, - rereg_signals, - rereg_opts, - ); + let _res = + registration + .handle.inner_ref() + .wait_async_handle( + port, + registration.token.0 as u64, + rereg_signals, + rereg_opts); } } } @@ -93,31 +95,26 @@ unsafe impl Send for EventedFdInner {} #[derive(Clone, Debug)] pub struct EventedFd { - pub inner: Arc, + pub inner: Arc } impl EventedFd { pub unsafe fn new(fd: RawFd) -> Self { let fdio = sys::__fdio_fd_to_io(fd); - assert!( - fdio != ::std::ptr::null(), - "FileDescriptor given to EventedFd must be valid." - ); + assert!(fdio != ::std::ptr::null(), "FileDescriptor given to EventedFd must be valid."); EventedFd { inner: Arc::new(EventedFdInner { registration: Mutex::new(None), fd: fd, fdio: fdio, - }), + }) } } - fn handle_and_signals_for_events( - &self, - interest: Ready, - opts: PollOpt, - ) -> (sys::zx_handle_t, zircon::Signals) { + fn handle_and_signals_for_events(&self, interest: Ready, opts: PollOpt) + -> (sys::zx_handle_t, zircon::Signals) + { let epoll_events = ioevent_to_epoll(interest, opts); unsafe { @@ -135,13 +132,12 @@ impl EventedFd { poll: &Poll, token: Token, interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + opts: PollOpt) -> io::Result<()> + { if registration.is_some() { return Err(io::Error::new( io::ErrorKind::AlreadyExists, - "Called register on an already registered file descriptor.", - )); + "Called register on an already registered file descriptor.")); } let (raw_handle, signals) = self.handle_and_signals_for_events(interest, opts); @@ -149,11 +145,7 @@ impl EventedFd { let needs_rereg = opts.is_level() && !opts.is_oneshot(); // If we need to reregister, then each registration should be `oneshot` - let opts = opts | if needs_rereg { - PollOpt::oneshot() - } else { - PollOpt::empty() - }; + let opts = opts | if needs_rereg { PollOpt::oneshot() } else { PollOpt::empty() }; let rereg_signals = if needs_rereg { Some((signals, poll_opts_to_wait_async(opts))) @@ -161,14 +153,15 @@ impl EventedFd { None }; - *registration = - Some(unsafe { EventedFdRegistration::new(token, raw_handle, rereg_signals) }); + *registration = Some( + unsafe { EventedFdRegistration::new(token, raw_handle, rereg_signals) } + ); // We don't have ownership of the handle, so we can't drop it let handle = DontDrop::new(unsafe { zircon::Handle::from_raw(raw_handle) }); - let registered = - poll::selector(poll).register_fd(handle.inner_ref(), self, token, signals, opts); + let registered = poll::selector(poll) + .register_fd(handle.inner_ref(), self, token, signals, opts); if registered.is_err() { *registration = None; @@ -180,15 +173,14 @@ impl EventedFd { fn deregister_with_lock( &self, registration: &mut Option, - poll: &Poll, - ) -> io::Result<()> { + poll: &Poll) -> io::Result<()> + { let old_registration = if let Some(old_reg) = registration.take() { old_reg } else { return Err(io::Error::new( io::ErrorKind::NotFound, - "Called rereregister on an unregistered file descriptor.", - )); + "Called rereregister on an unregistered file descriptor.")) }; poll::selector(poll) @@ -197,36 +189,38 @@ impl EventedFd { } impl Evented for EventedFd { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt) -> io::Result<()> + { self.register_with_lock( &mut *self.inner.registration.lock().unwrap(), poll, token, interest, - opts, - ) + opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt) -> io::Result<()> + { // Take out the registration lock let mut registration_lock = self.inner.registration.lock().unwrap(); // Deregister self.deregister_with_lock(&mut *registration_lock, poll)?; - self.register_with_lock(&mut *registration_lock, poll, token, interest, opts) + self.register_with_lock( + &mut *registration_lock, + poll, + token, + interest, + opts) } fn deregister(&self, poll: &Poll) -> io::Result<()> { @@ -237,7 +231,7 @@ impl Evented for EventedFd { fn ioevent_to_epoll(interest: Ready, opts: PollOpt) -> u32 { use event_imp::ready_from_usize; - const HUP: usize = 0b01000; + const HUP: usize = 0b01000; let mut kind = 0; diff --git a/src/sys/fuchsia/handles.rs b/src/sys/fuchsia/handles.rs index c64e5bc8b..ae6f07f6d 100644 --- a/src/sys/fuchsia/handles.rs +++ b/src/sys/fuchsia/handles.rs @@ -1,6 +1,6 @@ -use std::sync::Mutex; +use {io, poll, Evented, Ready, Poll, PollOpt, Token}; use zircon_sys::zx_handle_t; -use {io, poll, Evented, Poll, PollOpt, Ready, Token}; +use std::sync::Mutex; /// Wrapper for registering a `HandleBase` type with mio. #[derive(Debug)] @@ -32,13 +32,12 @@ impl EventedHandle { } impl Evented for EventedHandle { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt) -> io::Result<()> + { let mut this_token = self.token.lock().unwrap(); { poll::selector(poll).register_handle(self.handle, token, interest, opts)?; @@ -47,13 +46,12 @@ impl Evented for EventedHandle { Ok(()) } - fn reregister( - &self, + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + opts: PollOpt) -> io::Result<()> + { let mut this_token = self.token.lock().unwrap(); { poll::selector(poll).deregister_handle(self.handle, token)?; @@ -66,13 +64,10 @@ impl Evented for EventedHandle { fn deregister(&self, poll: &Poll) -> io::Result<()> { let mut this_token = self.token.lock().unwrap(); - let token = if let Some(token) = *this_token { - token - } else { + let token = if let Some(token) = *this_token { token } else { return Err(io::Error::new( io::ErrorKind::NotFound, - "Attempted to deregister an unregistered handle.", - )); + "Attempted to deregister an unregistered handle.")) }; { poll::selector(poll).deregister_handle(self.handle, token)?; diff --git a/src/sys/fuchsia/mod.rs b/src/sys/fuchsia/mod.rs index c44e62704..10728fc8d 100644 --- a/src/sys/fuchsia/mod.rs +++ b/src/sys/fuchsia/mod.rs @@ -1,14 +1,14 @@ +use {io, Ready, PollOpt}; use libc; +use zircon; use std::mem; use std::net::{IpAddr, Ipv4Addr, SocketAddr}; use std::ops::{Deref, DerefMut}; use std::os::unix::io::RawFd; -use zircon; -use {io, PollOpt, Ready}; mod awakener; -mod eventedfd; mod handles; +mod eventedfd; mod net; mod ready; mod selector; @@ -19,8 +19,8 @@ use self::ready::assert_fuchsia_ready_repr; pub use self::awakener::Awakener; pub use self::handles::EventedHandle; pub use self::net::{TcpListener, TcpStream, UdpSocket}; -pub use self::ready::{zx_signals_t, FuchsiaReady}; pub use self::selector::{Events, Selector}; +pub use self::ready::{FuchsiaReady, zx_signals_t}; // Set non-blocking (workaround since the std version doesn't work in fuchsia) // TODO: fix the std version and replace this @@ -32,12 +32,12 @@ pub fn set_nonblock(fd: RawFd) -> io::Result<()> { unsafe fn recv_from(fd: RawFd, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> { let flags = 0; - let n = cvt(libc::recv( - fd, - buf.as_mut_ptr() as *mut libc::c_void, - buf.len(), - flags, - ))?; + let n = cvt( + libc::recv(fd, + buf.as_mut_ptr() as *mut libc::c_void, + buf.len(), + flags) + )?; // random address-- we don't use it let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080); @@ -63,8 +63,8 @@ mod sys { pub flags: u32, } - #[link(name = "fdio")] - extern "C" { + #[link(name="fdio")] + extern { pub fn __fdio_fd_to_io(fd: RawFd) -> *const fdio_t; pub fn __fdio_release(io: *const fdio_t); @@ -74,7 +74,11 @@ mod sys { handle_out: &mut zx_handle_t, signals_out: &mut zx_signals_t, ); - pub fn __fdio_wait_end(io: *const fdio_t, signals: zx_signals_t, events_out: &mut u32); + pub fn __fdio_wait_end( + io: *const fdio_t, + signals: zx_signals_t, + events_out: &mut u32, + ); } } @@ -117,15 +121,11 @@ trait IsMinusOne { } impl IsMinusOne for i32 { - fn is_minus_one(&self) -> bool { - *self == -1 - } + fn is_minus_one(&self) -> bool { *self == -1 } } impl IsMinusOne for isize { - fn is_minus_one(&self) -> bool { - *self == -1 - } + fn is_minus_one(&self) -> bool { *self == -1 } } fn cvt(t: T) -> ::io::Result { diff --git a/src/sys/fuchsia/net.rs b/src/sys/fuchsia/net.rs index a323760d2..d43ad27bb 100644 --- a/src/sys/fuchsia/net.rs +++ b/src/sys/fuchsia/net.rs @@ -1,16 +1,16 @@ -use iovec::unix as iovec; +use {io, Evented, Ready, Poll, PollOpt, Token}; use iovec::IoVec; +use iovec::unix as iovec; use libc; use net2::TcpStreamExt; #[allow(unused_imports)] // only here for Rust 1.8 use net2::UdpSocketExt; +use sys::fuchsia::{recv_from, set_nonblock, EventedFd, DontDrop}; use std::cmp; use std::io::{Read, Write}; use std::net::{self, Ipv4Addr, Ipv6Addr, SocketAddr}; use std::os::unix::io::AsRawFd; use std::time::Duration; -use sys::fuchsia::{recv_from, set_nonblock, DontDrop, EventedFd}; -use {io, Evented, Poll, PollOpt, Ready, Token}; #[derive(Debug)] pub struct TcpStream { @@ -34,7 +34,7 @@ impl TcpStream { return Ok(TcpStream { io: DontDrop::new(stream), evented_fd: evented_fd, - }); + }) } pub fn from_stream(stream: net::TcpStream) -> TcpStream { @@ -136,7 +136,9 @@ impl TcpStream { unsafe { let slice = iovec::as_os_slice_mut(bufs); let len = cmp::min(::max_value() as usize, slice.len()); - let rc = libc::readv(self.io.as_raw_fd(), slice.as_ptr(), len as libc::c_int); + let rc = libc::readv(self.io.as_raw_fd(), + slice.as_ptr(), + len as libc::c_int); if rc < 0 { Err(io::Error::last_os_error()) } else { @@ -149,7 +151,9 @@ impl TcpStream { unsafe { let slice = iovec::as_os_slice(bufs); let len = cmp::min(::max_value() as usize, slice.len()); - let rc = libc::writev(self.io.as_raw_fd(), slice.as_ptr(), len as libc::c_int); + let rc = libc::writev(self.io.as_raw_fd(), + slice.as_ptr(), + len as libc::c_int); if rc < 0 { Err(io::Error::last_os_error()) } else { @@ -175,23 +179,21 @@ impl<'a> Write for &'a TcpStream { } impl Evented for TcpStream { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt) -> io::Result<()> + { self.evented_fd.register(poll, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt) -> io::Result<()> + { self.evented_fd.reregister(poll, token, interest, opts) } @@ -236,13 +238,10 @@ impl TcpListener { self.io.accept().and_then(|(s, a)| { set_nonblock(s.as_raw_fd())?; let evented_fd = unsafe { EventedFd::new(s.as_raw_fd()) }; - return Ok(( - TcpStream { - io: DontDrop::new(s), - evented_fd: evented_fd, - }, - a, - )); + return Ok((TcpStream { + io: DontDrop::new(s), + evented_fd: evented_fd, + }, a)) }) } @@ -270,23 +269,21 @@ impl TcpListener { } impl Evented for TcpListener { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt) -> io::Result<()> + { self.evented_fd.register(poll, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt) -> io::Result<()> + { self.evented_fd.reregister(poll, token, interest, opts) } @@ -318,7 +315,9 @@ impl UdpSocket { } pub fn try_clone(&self) -> io::Result { - self.io.try_clone().and_then(|io| UdpSocket::new(io)) + self.io.try_clone().and_then(|io| { + UdpSocket::new(io) + }) } pub fn send_to(&self, buf: &[u8], target: &SocketAddr) -> io::Result { @@ -337,7 +336,8 @@ impl UdpSocket { self.io.recv(buf) } - pub fn connect(&self, addr: SocketAddr) -> io::Result<()> { + pub fn connect(&self, addr: SocketAddr) + -> io::Result<()> { self.io.connect(addr) } @@ -381,19 +381,27 @@ impl UdpSocket { self.io.set_ttl(ttl) } - pub fn join_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> { + pub fn join_multicast_v4(&self, + multiaddr: &Ipv4Addr, + interface: &Ipv4Addr) -> io::Result<()> { self.io.join_multicast_v4(multiaddr, interface) } - pub fn join_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> { + pub fn join_multicast_v6(&self, + multiaddr: &Ipv6Addr, + interface: u32) -> io::Result<()> { self.io.join_multicast_v6(multiaddr, interface) } - pub fn leave_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> { + pub fn leave_multicast_v4(&self, + multiaddr: &Ipv4Addr, + interface: &Ipv4Addr) -> io::Result<()> { self.io.leave_multicast_v4(multiaddr, interface) } - pub fn leave_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> { + pub fn leave_multicast_v6(&self, + multiaddr: &Ipv6Addr, + interface: u32) -> io::Result<()> { self.io.leave_multicast_v6(multiaddr, interface) } @@ -405,29 +413,28 @@ impl UdpSocket { self.io.only_v6() } + pub fn take_error(&self) -> io::Result> { self.io.take_error() } } impl Evented for UdpSocket { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt) -> io::Result<()> + { self.evented_fd.register(poll, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, + poll: &Poll, + token: Token, + interest: Ready, + opts: PollOpt) -> io::Result<()> + { self.evented_fd.reregister(poll, token, interest, opts) } diff --git a/src/sys/fuchsia/ready.rs b/src/sys/fuchsia/ready.rs index d4f472038..97854f8c0 100644 --- a/src/sys/fuchsia/ready.rs +++ b/src/sys/fuchsia/ready.rs @@ -1,6 +1,10 @@ -use event_imp::{ready_as_usize, ready_from_usize, Ready}; +use event_imp::{Ready, ready_as_usize, ready_from_usize}; +pub use zircon_sys::{ + zx_signals_t, + ZX_OBJECT_READABLE, + ZX_OBJECT_WRITABLE, +}; use std::ops; -pub use zircon_sys::{zx_signals_t, ZX_OBJECT_READABLE, ZX_OBJECT_WRITABLE}; // The following impls are valid because Fuchsia and mio both represent // "readable" as `1 << 0` and "writable" as `1 << 2`. diff --git a/src/sys/fuchsia/selector.rs b/src/sys/fuchsia/selector.rs index 920067057..27226ac5f 100644 --- a/src/sys/fuchsia/selector.rs +++ b/src/sys/fuchsia/selector.rs @@ -1,18 +1,22 @@ +use {io, Event, PollOpt, Ready, Token}; +use sys::fuchsia::{ + assert_fuchsia_ready_repr, + epoll_event_to_ready, + poll_opts_to_wait_async, + EventedFd, + EventedFdInner, + FuchsiaReady, +}; +use zircon; +use zircon::AsHandleRef; +use zircon_sys::zx_handle_t; use std::collections::hash_map; use std::fmt; use std::mem; -use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering, ATOMIC_USIZE_INIT}; +use std::sync::atomic::{AtomicBool, AtomicUsize, ATOMIC_USIZE_INIT, Ordering}; use std::sync::{Arc, Mutex, Weak}; use std::time::Duration; use sys; -use sys::fuchsia::{ - assert_fuchsia_ready_repr, epoll_event_to_ready, poll_opts_to_wait_async, EventedFd, - EventedFdInner, FuchsiaReady, -}; -use zircon; -use zircon::AsHandleRef; -use zircon_sys::zx_handle_t; -use {io, Event, PollOpt, Ready, Token}; /// The kind of registration-- file descriptor or handle. /// @@ -29,8 +33,7 @@ fn key_from_token_and_type(token: Token, reg_type: RegType) -> io::Result { if (key & msb) != 0 { return Err(io::Error::new( io::ErrorKind::InvalidInput, - "Most-significant bit of token must remain unset.", - )); + "Most-significant bit of token must remain unset.")); } Ok(match reg_type { @@ -47,7 +50,7 @@ fn token_and_type_from_key(key: u64) -> (Token, RegType) { RegType::Fd } else { RegType::Handle - }, + } ) } @@ -91,7 +94,9 @@ impl Selector { // compatible with Ready. assert_fuchsia_ready_repr(); - let port = Arc::new(zircon::Port::create(zircon::PortOpts::Default)?); + let port = Arc::new( + zircon::Port::create(zircon::PortOpts::Default)? + ); // offset by 1 to avoid choosing 0 as the id of a selector let id = NEXT_ID.fetch_add(1, Ordering::Relaxed) + 1; @@ -114,9 +119,7 @@ impl Selector { } /// Returns a reference to the underlying port `Arc`. - pub fn port(&self) -> &Arc { - &self.port - } + pub fn port(&self) -> &Arc { &self.port } /// Reregisters all registrations pointed to by the `tokens_to_rereg` list /// if `has_tokens_to_rereg`. @@ -127,7 +130,8 @@ impl Selector { let mut tokens = self.tokens_to_rereg.lock().unwrap(); let token_to_fd = self.token_to_fd.lock().unwrap(); for token in tokens.drain(0..) { - if let Some(eventedfd) = token_to_fd.get(&token).and_then(|h| h.upgrade()) { + if let Some(eventedfd) = token_to_fd.get(&token) + .and_then(|h| h.upgrade()) { eventedfd.rereg_for_level(&self.port); } } @@ -136,22 +140,19 @@ impl Selector { Ok(()) } - pub fn select( - &self, - evts: &mut Events, - _awakener: Token, - timeout: Option, - ) -> io::Result { + pub fn select(&self, + evts: &mut Events, + _awakener: Token, + timeout: Option) -> io::Result + { evts.clear(); self.reregister_handles()?; let deadline = match timeout { Some(duration) => { - let nanos = duration - .as_secs() - .saturating_mul(1_000_000_000) - .saturating_add(duration.subsec_nanos() as u64); + let nanos = duration.as_secs().saturating_mul(1_000_000_000) + .saturating_add(duration.subsec_nanos() as u64); zircon::deadline_after(nanos) } @@ -165,8 +166,12 @@ impl Selector { }; let observed_signals = match packet.contents() { - zircon::PacketContents::SignalOne(signal_packet) => signal_packet.observed(), - zircon::PacketContents::SignalRep(signal_packet) => signal_packet.observed(), + zircon::PacketContents::SignalOne(signal_packet) => { + signal_packet.observed() + } + zircon::PacketContents::SignalRep(signal_packet) => { + signal_packet.observed() + } zircon::PacketContents::User(_user_packet) => { // User packets are only ever sent by an Awakener return Ok(true); @@ -179,22 +184,18 @@ impl Selector { match reg_type { RegType::Handle => { // We can return immediately-- no lookup or registration necessary. - evts.events - .push(Event::new(Ready::from(observed_signals), token)); + evts.events.push(Event::new(Ready::from(observed_signals), token)); Ok(false) - } + }, RegType::Fd => { // Convert the signals to epoll events using __fdio_wait_end, // and add to reregistration list if necessary. let events: u32; { - let handle = if let Some(handle) = self - .token_to_fd - .lock() - .unwrap() + let handle = if let Some(handle) = + self.token_to_fd.lock().unwrap() .get(&token) - .and_then(|h| h.upgrade()) - { + .and_then(|h| h.upgrade()) { handle } else { // This handle is apparently in the process of removal. @@ -204,11 +205,7 @@ impl Selector { events = unsafe { let mut events: u32 = mem::uninitialized(); - sys::fuchsia::sys::__fdio_wait_end( - handle.fdio(), - observed_signals, - &mut events, - ); + sys::fuchsia::sys::__fdio_wait_end(handle.fdio(), observed_signals, &mut events); events }; @@ -231,39 +228,33 @@ impl Selector { } } - evts.events - .push(Event::new(epoll_event_to_ready(events), token)); + evts.events.push(Event::new(epoll_event_to_ready(events), token)); Ok(false) - } + }, } } /// Register event interests for the given IO handle with the OS - pub fn register_fd( - &self, - handle: &zircon::Handle, - fd: &EventedFd, - token: Token, - signals: zircon::Signals, - poll_opts: PollOpt, - ) -> io::Result<()> { + pub fn register_fd(&self, + handle: &zircon::Handle, + fd: &EventedFd, + token: Token, + signals: zircon::Signals, + poll_opts: PollOpt) -> io::Result<()> + { { let mut token_to_fd = self.token_to_fd.lock().unwrap(); match token_to_fd.entry(token) { - hash_map::Entry::Occupied(_) => { - return Err(io::Error::new( - io::ErrorKind::AlreadyExists, - "Attempted to register a filedescriptor on an existing token.", - )) - } + hash_map::Entry::Occupied(_) => + return Err(io::Error::new(io::ErrorKind::AlreadyExists, + "Attempted to register a filedescriptor on an existing token.")), hash_map::Entry::Vacant(slot) => slot.insert(Arc::downgrade(&fd.inner)), }; } let wait_async_opts = poll_opts_to_wait_async(poll_opts); - let wait_res = - handle.wait_async_handle(&self.port, token.0 as u64, signals, wait_async_opts); + let wait_res = handle.wait_async_handle(&self.port, token.0 as u64, signals, wait_async_opts); if wait_res.is_err() { self.token_to_fd.lock().unwrap().remove(&token); @@ -278,52 +269,44 @@ impl Selector { // We ignore NotFound errors since oneshots are automatically deregistered, // but mio will attempt to deregister them manually. - self.port - .cancel(&*handle, token.0 as u64) + self.port.cancel(&*handle, token.0 as u64) .map_err(io::Error::from) - .or_else(|e| { - if e.kind() == io::ErrorKind::NotFound { - Ok(()) - } else { - Err(e) - } + .or_else(|e| if e.kind() == io::ErrorKind::NotFound { + Ok(()) + } else { + Err(e) }) } - pub fn register_handle( - &self, - handle: zx_handle_t, - token: Token, - interests: Ready, - poll_opts: PollOpt, - ) -> io::Result<()> { + pub fn register_handle(&self, + handle: zx_handle_t, + token: Token, + interests: Ready, + poll_opts: PollOpt) -> io::Result<()> + { if poll_opts.is_level() && !poll_opts.is_oneshot() { - return Err(io::Error::new( - io::ErrorKind::InvalidInput, - "Repeated level-triggered events are not supported on Fuchsia handles.", - )); + return Err(io::Error::new(io::ErrorKind::InvalidInput, + "Repeated level-triggered events are not supported on Fuchsia handles.")); } let temp_handle = unsafe { zircon::Handle::from_raw(handle) }; let res = temp_handle.wait_async_handle( - &self.port, - key_from_token_and_type(token, RegType::Handle)?, - FuchsiaReady::from(interests).into_zx_signals(), - poll_opts_to_wait_async(poll_opts), - ); + &self.port, + key_from_token_and_type(token, RegType::Handle)?, + FuchsiaReady::from(interests).into_zx_signals(), + poll_opts_to_wait_async(poll_opts)); mem::forget(temp_handle); Ok(res?) } - pub fn deregister_handle(&self, handle: zx_handle_t, token: Token) -> io::Result<()> { + + pub fn deregister_handle(&self, handle: zx_handle_t, token: Token) -> io::Result<()> + { let temp_handle = unsafe { zircon::Handle::from_raw(handle) }; - let res = self.port.cancel( - &temp_handle, - key_from_token_and_type(token, RegType::Handle)?, - ); + let res = self.port.cancel(&temp_handle, key_from_token_and_type(token, RegType::Handle)?); mem::forget(temp_handle); @@ -332,16 +315,14 @@ impl Selector { } pub struct Events { - events: Vec, + events: Vec } impl Events { pub fn with_capacity(_u: usize) -> Events { // The Fuchsia selector only handles one event at a time, // so we ignore the default capacity and set it to one. - Events { - events: Vec::with_capacity(1), - } + Events { events: Vec::with_capacity(1) } } pub fn len(&self) -> usize { self.events.len() diff --git a/src/sys/mod.rs b/src/sys/mod.rs index 108026b86..8a1705db6 100644 --- a/src/sys/mod.rs +++ b/src/sys/mod.rs @@ -1,7 +1,15 @@ #[cfg(all(unix, not(target_os = "fuchsia")))] pub use self::unix::{ - pipe, set_nonblock, Awakener, EventedFd, Events, Io, Selector, TcpListener, TcpStream, + Awakener, + EventedFd, + Events, + Io, + Selector, + TcpStream, + TcpListener, UdpSocket, + pipe, + set_nonblock, }; #[cfg(all(unix, not(target_os = "fuchsia")))] @@ -16,7 +24,14 @@ pub mod unix; #[cfg(windows)] pub use self::windows::{ - Awakener, Binding, Events, Overlapped, Selector, TcpListener, TcpStream, UdpSocket, + Awakener, + Events, + Selector, + TcpStream, + TcpListener, + UdpSocket, + Overlapped, + Binding, }; #[cfg(windows)] @@ -24,7 +39,14 @@ mod windows; #[cfg(target_os = "fuchsia")] pub use self::fuchsia::{ - set_nonblock, Awakener, EventedHandle, Events, Selector, TcpListener, TcpStream, UdpSocket, + Awakener, + Events, + EventedHandle, + Selector, + TcpStream, + TcpListener, + UdpSocket, + set_nonblock, }; #[cfg(target_os = "fuchsia")] diff --git a/src/sys/unix/awakener.rs b/src/sys/unix/awakener.rs index aae76730e..9cc367a78 100644 --- a/src/sys/unix/awakener.rs +++ b/src/sys/unix/awakener.rs @@ -2,10 +2,10 @@ pub use self::pipe::Awakener; /// Default awakener backed by a pipe mod pipe { + use sys::unix; + use {io, Ready, Poll, PollOpt, Token}; use event::Evented; use std::io::{Read, Write}; - use sys::unix; - use {io, Poll, PollOpt, Ready, Token}; /* * @@ -47,7 +47,7 @@ mod pipe { loop { // Consume data until all bytes are purged match (&self.reader).read(&mut buf) { - Ok(i) if i > 0 => {} + Ok(i) if i > 0 => {}, _ => return, } } @@ -59,23 +59,11 @@ mod pipe { } impl Evented for Awakener { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.reader().register(poll, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.reader().reregister(poll, token, interest, opts) } diff --git a/src/sys/unix/epoll.rs b/src/sys/unix/epoll.rs index c2ad3432b..50b2a14e4 100644 --- a/src/sys/unix/epoll.rs +++ b/src/sys/unix/epoll.rs @@ -6,13 +6,13 @@ use std::time::Duration; use std::{cmp, i32}; use libc::{self, c_int}; -use libc::{EPOLLERR, EPOLLHUP, EPOLLONESHOT, EPOLLRDHUP}; -use libc::{EPOLLET, EPOLLIN, EPOLLOUT, EPOLLPRI}; +use libc::{EPOLLERR, EPOLLHUP, EPOLLRDHUP, EPOLLONESHOT}; +use libc::{EPOLLET, EPOLLOUT, EPOLLIN, EPOLLPRI}; +use {io, Ready, PollOpt, Token}; use event_imp::Event; -use sys::unix::io::set_cloexec; use sys::unix::{cvt, UnixReady}; -use {io, PollOpt, Ready, Token}; +use sys::unix::io::set_cloexec; /// Each Selector has a globally unique(ish) ID associated with it. This ID /// gets tracked by `TcpStream`, `TcpListener`, etc... when they are first @@ -36,7 +36,9 @@ impl Selector { dlsym!(fn epoll_create1(c_int) -> c_int); match epoll_create1.get() { - Some(epoll_create1_fn) => cvt(epoll_create1_fn(libc::EPOLL_CLOEXEC))?, + Some(epoll_create1_fn) => { + cvt(epoll_create1_fn(libc::EPOLL_CLOEXEC))? + } None => { let fd = cvt(libc::epoll_create(1024))?; drop(set_cloexec(fd)); @@ -48,7 +50,10 @@ impl Selector { // offset by 1 to avoid choosing 0 as the id of a selector let id = NEXT_ID.fetch_add(1, Ordering::Relaxed) + 1; - Ok(Selector { id: id, epfd: epfd }) + Ok(Selector { + id: id, + epfd: epfd, + }) } pub fn id(&self) -> usize { @@ -56,12 +61,7 @@ impl Selector { } /// Wait for events from the OS - pub fn select( - &self, - evts: &mut Events, - awakener: Token, - timeout: Option, - ) -> io::Result { + pub fn select(&self, evts: &mut Events, awakener: Token, timeout: Option) -> io::Result { let timeout_ms = timeout .map(|to| cmp::min(millis(to), i32::MAX as u64) as i32) .unwrap_or(-1); @@ -69,12 +69,10 @@ impl Selector { // Wait for epoll events for at most timeout_ms milliseconds evts.clear(); unsafe { - let cnt = cvt(libc::epoll_wait( - self.epfd, - evts.events.as_mut_ptr(), - evts.events.capacity() as i32, - timeout_ms, - ))?; + let cnt = cvt(libc::epoll_wait(self.epfd, + evts.events.as_mut_ptr(), + evts.events.capacity() as i32, + timeout_ms))?; let cnt = cnt as usize; evts.events.set_len(cnt); @@ -90,49 +88,27 @@ impl Selector { } /// Register event interests for the given IO handle with the OS - pub fn register( - &self, - fd: RawFd, - token: Token, - interests: Ready, - opts: PollOpt, - ) -> io::Result<()> { + pub fn register(&self, fd: RawFd, token: Token, interests: Ready, opts: PollOpt) -> io::Result<()> { let mut info = libc::epoll_event { events: ioevent_to_epoll(interests, opts), - u64: usize::from(token) as u64, + u64: usize::from(token) as u64 }; unsafe { - cvt(libc::epoll_ctl( - self.epfd, - libc::EPOLL_CTL_ADD, - fd, - &mut info, - ))?; + cvt(libc::epoll_ctl(self.epfd, libc::EPOLL_CTL_ADD, fd, &mut info))?; Ok(()) } } /// Register event interests for the given IO handle with the OS - pub fn reregister( - &self, - fd: RawFd, - token: Token, - interests: Ready, - opts: PollOpt, - ) -> io::Result<()> { + pub fn reregister(&self, fd: RawFd, token: Token, interests: Ready, opts: PollOpt) -> io::Result<()> { let mut info = libc::epoll_event { events: ioevent_to_epoll(interests, opts), - u64: usize::from(token) as u64, + u64: usize::from(token) as u64 }; unsafe { - cvt(libc::epoll_ctl( - self.epfd, - libc::EPOLL_CTL_MOD, - fd, - &mut info, - ))?; + cvt(libc::epoll_ctl(self.epfd, libc::EPOLL_CTL_MOD, fd, &mut info))?; Ok(()) } } @@ -142,15 +118,13 @@ impl Selector { // The &info argument should be ignored by the system, // but linux < 2.6.9 required it to be not null. // For compatibility, we provide a dummy EpollEvent. - let mut info = libc::epoll_event { events: 0, u64: 0 }; + let mut info = libc::epoll_event { + events: 0, + u64: 0, + }; unsafe { - cvt(libc::epoll_ctl( - self.epfd, - libc::EPOLL_CTL_DEL, - fd, - &mut info, - ))?; + cvt(libc::epoll_ctl(self.epfd, libc::EPOLL_CTL_DEL, fd, &mut info))?; Ok(()) } } @@ -207,7 +181,7 @@ pub struct Events { impl Events { pub fn with_capacity(u: usize) -> Events { Events { - events: Vec::with_capacity(u), + events: Vec::with_capacity(u) } } @@ -258,14 +232,12 @@ impl Events { pub fn push_event(&mut self, event: Event) { self.events.push(libc::epoll_event { events: ioevent_to_epoll(event.readiness(), PollOpt::empty()), - u64: usize::from(event.token()) as u64, + u64: usize::from(event.token()) as u64 }); } pub fn clear(&mut self) { - unsafe { - self.events.set_len(0); - } + unsafe { self.events.set_len(0); } } } @@ -280,8 +252,5 @@ const MILLIS_PER_SEC: u64 = 1_000; pub fn millis(duration: Duration) -> u64 { // Round up. let millis = (duration.subsec_nanos() + NANOS_PER_MILLI - 1) / NANOS_PER_MILLI; - duration - .as_secs() - .saturating_mul(MILLIS_PER_SEC) - .saturating_add(millis as u64) + duration.as_secs().saturating_mul(MILLIS_PER_SEC).saturating_add(millis as u64) } diff --git a/src/sys/unix/eventedfd.rs b/src/sys/unix/eventedfd.rs index 1f9b5a27c..6331062cb 100644 --- a/src/sys/unix/eventedfd.rs +++ b/src/sys/unix/eventedfd.rs @@ -1,6 +1,6 @@ +use {io, poll, Ready, Poll, PollOpt, Token}; use event::Evented; use std::os::unix::io::RawFd; -use {io, poll, Poll, PollOpt, Ready, Token}; /* * @@ -92,23 +92,11 @@ use {io, poll, Poll, PollOpt, Ready, Token}; pub struct EventedFd<'a>(pub &'a RawFd); impl<'a> Evented for EventedFd<'a> { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { poll::selector(poll).register(*self.0, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { poll::selector(poll).reregister(*self.0, token, interest, opts) } diff --git a/src/sys/unix/io.rs b/src/sys/unix/io.rs index 61bb8cecc..47a3a70d1 100644 --- a/src/sys/unix/io.rs +++ b/src/sys/unix/io.rs @@ -1,18 +1,18 @@ use std::fs::File; use std::io::{Read, Write}; -use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; +use std::os::unix::io::{IntoRawFd, AsRawFd, FromRawFd, RawFd}; use libc; +use {io, Ready, Poll, PollOpt, Token}; use event::Evented; -use sys::unix::cvt; use unix::EventedFd; -use {io, Poll, PollOpt, Ready, Token}; +use sys::unix::cvt; pub fn set_nonblock(fd: libc::c_int) -> io::Result<()> { unsafe { let flags = libc::fcntl(fd, libc::F_GETFL); - cvt(libc::fcntl(fd, libc::F_SETFL, flags | libc::O_NONBLOCK)).map(|_| ()) + cvt(libc::fcntl(fd, libc::F_SETFL, flags | libc::O_NONBLOCK)).map(|_|()) } } @@ -38,17 +38,13 @@ pub struct Io { impl Io { /// Try to clone the FD pub fn try_clone(&self) -> io::Result { - Ok(Io { - fd: self.fd.try_clone()?, - }) + Ok(Io { fd: self.fd.try_clone()? }) } } impl FromRawFd for Io { unsafe fn from_raw_fd(fd: RawFd) -> Io { - Io { - fd: File::from_raw_fd(fd), - } + Io { fd: File::from_raw_fd(fd) } } } @@ -65,23 +61,11 @@ impl AsRawFd for Io { } impl Evented for Io { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { EventedFd(&self.as_raw_fd()).register(poll, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { EventedFd(&self.as_raw_fd()).reregister(poll, token, interest, opts) } diff --git a/src/sys/unix/kqueue.rs b/src/sys/unix/kqueue.rs index f86ace5bc..89a5da112 100644 --- a/src/sys/unix/kqueue.rs +++ b/src/sys/unix/kqueue.rs @@ -1,18 +1,18 @@ -use std::collections::HashMap; +use std::{cmp, fmt, ptr}; #[cfg(not(target_os = "netbsd"))] use std::os::raw::{c_int, c_short}; use std::os::unix::io::AsRawFd; use std::os::unix::io::RawFd; +use std::collections::HashMap; use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT}; use std::time::Duration; -use std::{cmp, fmt, ptr}; use libc::{self, time_t}; +use {io, Ready, PollOpt, Token}; use event_imp::{self as event, Event}; -use sys::unix::io::set_cloexec; use sys::unix::{cvt, UnixReady}; -use {io, PollOpt, Ready, Token}; +use sys::unix::io::set_cloexec; /// Each Selector has a globally unique(ish) ID associated with it. This ID /// gets tracked by `TcpStream`, `TcpListener`, etc... when they are first @@ -45,7 +45,7 @@ macro_rules! kevent { data: 0, udata: $data as UData, } - }; + } } pub struct Selector { @@ -60,93 +60,66 @@ impl Selector { let kq = unsafe { cvt(libc::kqueue())? }; drop(set_cloexec(kq)); - Ok(Selector { id: id, kq: kq }) + Ok(Selector { + id: id, + kq: kq, + }) } pub fn id(&self) -> usize { self.id } - pub fn select( - &self, - evts: &mut Events, - awakener: Token, - timeout: Option, - ) -> io::Result { - let timeout = timeout.map(|to| libc::timespec { - tv_sec: cmp::min(to.as_secs(), time_t::max_value() as u64) as time_t, - tv_nsec: to.subsec_nanos() as libc::c_long, + pub fn select(&self, evts: &mut Events, awakener: Token, timeout: Option) -> io::Result { + let timeout = timeout.map(|to| { + libc::timespec { + tv_sec: cmp::min(to.as_secs(), time_t::max_value() as u64) as time_t, + tv_nsec: to.subsec_nanos() as libc::c_long, + } }); - let timeout = timeout - .as_ref() - .map(|s| s as *const _) - .unwrap_or(ptr::null_mut()); + let timeout = timeout.as_ref().map(|s| s as *const _).unwrap_or(ptr::null_mut()); evts.clear(); unsafe { - let cnt = cvt(libc::kevent( - self.kq, - ptr::null(), - 0, - evts.sys_events.0.as_mut_ptr(), - evts.sys_events.0.capacity() as Count, - timeout, - ))?; + let cnt = cvt(libc::kevent(self.kq, + ptr::null(), + 0, + evts.sys_events.0.as_mut_ptr(), + evts.sys_events.0.capacity() as Count, + timeout))?; evts.sys_events.0.set_len(cnt as usize); Ok(evts.coalesce(awakener)) } } - pub fn register( - &self, - fd: RawFd, - token: Token, - interests: Ready, - opts: PollOpt, - ) -> io::Result<()> { + pub fn register(&self, fd: RawFd, token: Token, interests: Ready, opts: PollOpt) -> io::Result<()> { trace!("registering; token={:?}; interests={:?}", token, interests); - let flags = if opts.contains(PollOpt::edge()) { - libc::EV_CLEAR - } else { - 0 - } | if opts.contains(PollOpt::oneshot()) { - libc::EV_ONESHOT - } else { - 0 - } | libc::EV_RECEIPT; + let flags = if opts.contains(PollOpt::edge()) { libc::EV_CLEAR } else { 0 } | + if opts.contains(PollOpt::oneshot()) { libc::EV_ONESHOT } else { 0 } | + libc::EV_RECEIPT; unsafe { - let r = if interests.contains(Ready::readable()) { - libc::EV_ADD - } else { - libc::EV_DELETE - }; - let w = if interests.contains(Ready::writable()) { - libc::EV_ADD - } else { - libc::EV_DELETE - }; + let r = if interests.contains(Ready::readable()) { libc::EV_ADD } else { libc::EV_DELETE }; + let w = if interests.contains(Ready::writable()) { libc::EV_ADD } else { libc::EV_DELETE }; let mut changes = [ kevent!(fd, libc::EVFILT_READ, flags | r, usize::from(token)), kevent!(fd, libc::EVFILT_WRITE, flags | w, usize::from(token)), ]; - cvt(libc::kevent( - self.kq, - changes.as_ptr(), - changes.len() as Count, - changes.as_mut_ptr(), - changes.len() as Count, - ::std::ptr::null(), - ))?; + cvt(libc::kevent(self.kq, + changes.as_ptr(), + changes.len() as Count, + changes.as_mut_ptr(), + changes.len() as Count, + ::std::ptr::null()))?; for change in changes.iter() { debug_assert_eq!(change.flags & libc::EV_ERROR, libc::EV_ERROR); // Test to see if an error happened if change.data == 0 { - continue; + continue } // Older versions of OSX (10.11 and 10.10 have been witnessed) @@ -162,20 +135,15 @@ impl Selector { // ignore `EPIPE` here instead of propagating it. // // More info can be found at carllerche/mio#582 - if change.data as i32 == libc::EPIPE - && change.filter == libc::EVFILT_WRITE as Filter - { - continue; + if change.data as i32 == libc::EPIPE && + change.filter == libc::EVFILT_WRITE as Filter { + continue } // ignore ENOENT error for EV_DELETE - let orig_flags = if change.filter == libc::EVFILT_READ as Filter { - r - } else { - w - }; + let orig_flags = if change.filter == libc::EVFILT_READ as Filter { r } else { w }; if change.data as i32 == libc::ENOENT && orig_flags & libc::EV_DELETE != 0 { - continue; + continue } return Err(::std::io::Error::from_raw_os_error(change.data as i32)); @@ -184,13 +152,7 @@ impl Selector { } } - pub fn reregister( - &self, - fd: RawFd, - token: Token, - interests: Ready, - opts: PollOpt, - ) -> io::Result<()> { + pub fn reregister(&self, fd: RawFd, token: Token, interests: Ready, opts: PollOpt) -> io::Result<()> { // Just need to call register here since EV_ADD is a mod if already // registered self.register(fd, token, interests, opts) @@ -201,26 +163,24 @@ impl Selector { // EV_RECEIPT is a nice way to apply changes and get back per-event results while not // draining the actual changes. let filter = libc::EV_DELETE | libc::EV_RECEIPT; - #[cfg(not(target_os = "netbsd"))] +#[cfg(not(target_os = "netbsd"))] let mut changes = [ kevent!(fd, libc::EVFILT_READ, filter, ptr::null_mut()), kevent!(fd, libc::EVFILT_WRITE, filter, ptr::null_mut()), ]; - #[cfg(target_os = "netbsd")] +#[cfg(target_os = "netbsd")] let mut changes = [ kevent!(fd, libc::EVFILT_READ, filter, 0), kevent!(fd, libc::EVFILT_WRITE, filter, 0), ]; - cvt(libc::kevent( - self.kq, - changes.as_ptr(), - changes.len() as Count, - changes.as_mut_ptr(), - changes.len() as Count, - ::std::ptr::null(), - )).map(|_| ())?; + cvt(libc::kevent(self.kq, + changes.as_ptr(), + changes.len() as Count, + changes.as_mut_ptr(), + changes.len() as Count, + ::std::ptr::null())).map(|_| ())?; if changes[0].data as i32 == libc::ENOENT && changes[1].data as i32 == libc::ENOENT { return Err(::std::io::Error::from_raw_os_error(changes[0].data as i32)); @@ -275,7 +235,7 @@ impl Events { Events { sys_events: KeventList(Vec::with_capacity(cap)), events: Vec::with_capacity(cap), - event_map: HashMap::with_capacity(cap), + event_map: HashMap::with_capacity(cap) } } @@ -314,11 +274,13 @@ impl Events { continue; } - let idx = *self.event_map.entry(token).or_insert(len); + let idx = *self.event_map.entry(token) + .or_insert(len); if idx == len { // New entry, insert the default self.events.push(Event::new(Ready::empty(), token)); + } if e.flags & libc::EV_ERROR != 0 { @@ -330,20 +292,14 @@ impl Events { } else if e.filter == libc::EVFILT_WRITE as Filter { event::kind_mut(&mut self.events[idx]).insert(Ready::writable()); } - #[cfg( - any( - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", - target_os = "macos" - ) - )] +#[cfg(any(target_os = "dragonfly", + target_os = "freebsd", target_os = "ios", target_os = "macos"))] { if e.filter == libc::EVFILT_AIO { event::kind_mut(&mut self.events[idx]).insert(UnixReady::aio()); } } - #[cfg(any(target_os = "freebsd"))] +#[cfg(any(target_os = "freebsd"))] { if e.filter == libc::EVFILT_LIO { event::kind_mut(&mut self.events[idx]).insert(UnixReady::lio()); @@ -385,8 +341,8 @@ impl fmt::Debug for Events { #[test] fn does_not_register_rw() { + use {Poll, Ready, PollOpt, Token}; use unix::EventedFd; - use {Poll, PollOpt, Ready, Token}; let kq = unsafe { libc::kqueue() }; let kqf = EventedFd(&kq); @@ -394,29 +350,16 @@ fn does_not_register_rw() { // registering kqueue fd will fail if write is requested (On anything but some versions of OS // X) - poll.register( - &kqf, - Token(1234), - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + poll.register(&kqf, Token(1234), Ready::readable(), + PollOpt::edge() | PollOpt::oneshot()).unwrap(); } -#[cfg( - any( - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", - target_os = "macos" - ) -)] +#[cfg(any(target_os = "dragonfly", + target_os = "freebsd", target_os = "ios", target_os = "macos"))] #[test] fn test_coalesce_aio() { let mut events = Events::with_capacity(1); - events - .sys_events - .0 - .push(kevent!(0x1234, libc::EVFILT_AIO, 0, 42)); + events.sys_events.0.push(kevent!(0x1234, libc::EVFILT_AIO, 0, 42)); events.coalesce(Token(0)); assert!(events.events[0].readiness() == UnixReady::aio().into()); assert!(events.events[0].token() == Token(42)); diff --git a/src/sys/unix/mod.rs b/src/sys/unix/mod.rs index a32e36da4..39e604554 100644 --- a/src/sys/unix/mod.rs +++ b/src/sys/unix/mod.rs @@ -3,48 +3,20 @@ use libc::{self, c_int}; #[macro_use] pub mod dlsym; -#[cfg( - any( - target_os = "linux", - target_os = "android", - target_os = "solaris" - ) -)] +#[cfg(any(target_os = "linux", target_os = "android", target_os = "solaris"))] mod epoll; -#[cfg( - any( - target_os = "linux", - target_os = "android", - target_os = "solaris" - ) -)] +#[cfg(any(target_os = "linux", target_os = "android", target_os = "solaris"))] pub use self::epoll::{Events, Selector}; -#[cfg( - any( - target_os = "bitrig", - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", - target_os = "macos", - target_os = "netbsd", - target_os = "openbsd" - ) -)] +#[cfg(any(target_os = "bitrig", target_os = "dragonfly", + target_os = "freebsd", target_os = "ios", target_os = "macos", + target_os = "netbsd", target_os = "openbsd"))] mod kqueue; -#[cfg( - any( - target_os = "bitrig", - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", - target_os = "macos", - target_os = "netbsd", - target_os = "openbsd" - ) -)] +#[cfg(any(target_os = "bitrig", target_os = "dragonfly", + target_os = "freebsd", target_os = "ios", target_os = "macos", + target_os = "netbsd", target_os = "openbsd"))] pub use self::kqueue::{Events, Selector}; mod awakener; @@ -59,9 +31,9 @@ mod uds; pub use self::awakener::Awakener; pub use self::eventedfd::EventedFd; -pub use self::io::{set_nonblock, Io}; +pub use self::io::{Io, set_nonblock}; pub use self::ready::{UnixReady, READY_ALL}; -pub use self::tcp::{TcpListener, TcpStream}; +pub use self::tcp::{TcpStream, TcpListener}; pub use self::udp::UdpSocket; #[cfg(feature = "with-deprecated")] @@ -91,7 +63,9 @@ pub fn pipe() -> ::io::Result<(Io, Io)> { } } - unsafe { Ok((Io::from_raw_fd(pipes[0]), Io::from_raw_fd(pipes[1]))) } + unsafe { + Ok((Io::from_raw_fd(pipes[0]), Io::from_raw_fd(pipes[1]))) + } } trait IsMinusOne { @@ -99,14 +73,10 @@ trait IsMinusOne { } impl IsMinusOne for i32 { - fn is_minus_one(&self) -> bool { - *self == -1 - } + fn is_minus_one(&self) -> bool { *self == -1 } } impl IsMinusOne for isize { - fn is_minus_one(&self) -> bool { - *self == -1 - } + fn is_minus_one(&self) -> bool { *self == -1 } } fn cvt(t: T) -> ::io::Result { diff --git a/src/sys/unix/ready.rs b/src/sys/unix/ready.rs index 8eaa12b01..398fc17cc 100644 --- a/src/sys/unix/ready.rs +++ b/src/sys/unix/ready.rs @@ -1,7 +1,7 @@ -use event_imp::{ready_as_usize, ready_from_usize, Ready}; +use event_imp::{Ready, ready_as_usize, ready_from_usize}; -use std::fmt; use std::ops; +use std::fmt; /// Unix specific extensions to `Ready` /// @@ -93,35 +93,21 @@ use std::ops; pub struct UnixReady(Ready); const ERROR: usize = 0b000100; -const HUP: usize = 0b001000; - -#[cfg( - any( - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", - target_os = "macos" - ) -)] -const AIO: usize = 0b010000; - -#[cfg( - not( - any( - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", - target_os = "macos" - ) - ) -)] -const AIO: usize = 0b000000; +const HUP: usize = 0b001000; + +#[cfg(any(target_os = "dragonfly", + target_os = "freebsd", target_os = "ios", target_os = "macos"))] +const AIO: usize = 0b010000; + +#[cfg(not(any(target_os = "dragonfly", + target_os = "freebsd", target_os = "ios", target_os = "macos")))] +const AIO: usize = 0b000000; #[cfg(any(target_os = "freebsd"))] -const LIO: usize = 0b100000; +const LIO: usize = 0b100000; #[cfg(not(any(target_os = "freebsd")))] -const LIO: usize = 0b000000; +const LIO: usize = 0b000000; // Export to support `Ready::all` pub const READY_ALL: usize = ERROR | HUP | AIO | LIO; @@ -143,32 +129,15 @@ impl UnixReady { /// /// [`Poll`]: ../struct.Poll.html #[inline] - #[cfg( - any( - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", - target_os = "macos" - ) - )] + #[cfg(any(target_os = "dragonfly", + target_os = "freebsd", target_os = "ios", target_os = "macos"))] pub fn aio() -> UnixReady { UnixReady(ready_from_usize(AIO)) } - #[cfg( - not( - any( - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", - target_os = "macos" - ) - ) - )] - #[deprecated( - since = "0.6.12", - note = "this function is now platform specific" - )] + #[cfg(not(any(target_os = "dragonfly", + target_os = "freebsd", target_os = "ios", target_os = "macos")))] + #[deprecated(since = "0.6.12", note = "this function is now platform specific")] #[doc(hidden)] pub fn aio() -> UnixReady { UnixReady(Ready::empty()) @@ -266,33 +235,16 @@ impl UnixReady { /// /// [`Poll`]: ../struct.Poll.html #[inline] - #[cfg( - any( - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", - target_os = "macos" - ) - )] + #[cfg(any(target_os = "dragonfly", + target_os = "freebsd", target_os = "ios", target_os = "macos"))] pub fn is_aio(&self) -> bool { self.contains(ready_from_usize(AIO)) } - #[deprecated( - since = "0.6.12", - note = "this function is now platform specific" - )] + #[deprecated(since = "0.6.12", note = "this function is now platform specific")] #[cfg(feature = "with-deprecated")] - #[cfg( - not( - any( - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", - target_os = "macos" - ) - ) - )] + #[cfg(not(any(target_os = "dragonfly", + target_os = "freebsd", target_os = "ios", target_os = "macos")))] #[doc(hidden)] pub fn is_aio(&self) -> bool { false @@ -456,14 +408,11 @@ impl fmt::Debug for UnixReady { (UnixReady::error(), "Error"), (UnixReady::hup(), "Hup"), #[allow(deprecated)] - (UnixReady::aio(), "Aio"), - ]; + (UnixReady::aio(), "Aio")]; for &(flag, msg) in &flags { if self.contains(flag) { - if one { - write!(fmt, " | ")? - } + if one { write!(fmt, " | ")? } write!(fmt, "{}", msg)?; one = true diff --git a/src/sys/unix/tcp.rs b/src/sys/unix/tcp.rs index 12b5110e1..a5f6dba11 100644 --- a/src/sys/unix/tcp.rs +++ b/src/sys/unix/tcp.rs @@ -2,16 +2,16 @@ use std::cmp; use std::fmt; use std::io::{Read, Write}; use std::net::{self, SocketAddr}; -use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; +use std::os::unix::io::{RawFd, FromRawFd, IntoRawFd, AsRawFd}; use std::time::Duration; -use iovec::unix as iovec; -use iovec::IoVec; use libc; use net2::TcpStreamExt; +use iovec::IoVec; +use iovec::unix as iovec; +use {io, Ready, Poll, PollOpt, Token}; use event::Evented; -use {io, Poll, PollOpt, Ready, Token}; use sys::unix::eventedfd::EventedFd; use sys::unix::io::set_nonblock; @@ -34,11 +34,15 @@ impl TcpStream { Err(e) => return Err(e), } - Ok(TcpStream { inner: stream }) + Ok(TcpStream { + inner: stream, + }) } pub fn from_stream(stream: net::TcpStream) -> TcpStream { - TcpStream { inner: stream } + TcpStream { + inner: stream, + } } pub fn peer_addr(&self) -> io::Result { @@ -50,7 +54,11 @@ impl TcpStream { } pub fn try_clone(&self) -> io::Result { - self.inner.try_clone().map(|s| TcpStream { inner: s }) + self.inner.try_clone().map(|s| { + TcpStream { + inner: s, + } + }) } pub fn shutdown(&self, how: net::Shutdown) -> io::Result<()> { @@ -125,7 +133,9 @@ impl TcpStream { unsafe { let slice = iovec::as_os_slice_mut(bufs); let len = cmp::min(::max_value() as usize, slice.len()); - let rc = libc::readv(self.inner.as_raw_fd(), slice.as_ptr(), len as libc::c_int); + let rc = libc::readv(self.inner.as_raw_fd(), + slice.as_ptr(), + len as libc::c_int); if rc < 0 { Err(io::Error::last_os_error()) } else { @@ -138,7 +148,9 @@ impl TcpStream { unsafe { let slice = iovec::as_os_slice(bufs); let len = cmp::min(::max_value() as usize, slice.len()); - let rc = libc::writev(self.inner.as_raw_fd(), slice.as_ptr(), len as libc::c_int); + let rc = libc::writev(self.inner.as_raw_fd(), + slice.as_ptr(), + len as libc::c_int); if rc < 0 { Err(io::Error::last_os_error()) } else { @@ -165,23 +177,13 @@ impl<'a> Write for &'a TcpStream { } impl Evented for TcpStream { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { EventedFd(&self.as_raw_fd()).register(poll, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { EventedFd(&self.as_raw_fd()).reregister(poll, token, interest, opts) } @@ -219,7 +221,9 @@ impl AsRawFd for TcpStream { impl TcpListener { pub fn new(inner: net::TcpListener) -> io::Result { set_nonblock(inner.as_raw_fd())?; - Ok(TcpListener { inner: inner }) + Ok(TcpListener { + inner: inner, + }) } pub fn local_addr(&self) -> io::Result { @@ -227,7 +231,11 @@ impl TcpListener { } pub fn try_clone(&self) -> io::Result { - self.inner.try_clone().map(|s| TcpListener { inner: s }) + self.inner.try_clone().map(|s| { + TcpListener { + inner: s, + } + }) } pub fn accept(&self) -> io::Result<(net::TcpStream, SocketAddr)> { @@ -258,23 +266,13 @@ impl TcpListener { } impl Evented for TcpListener { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { EventedFd(&self.as_raw_fd()).register(poll, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { EventedFd(&self.as_raw_fd()).reregister(poll, token, interest, opts) } @@ -308,3 +306,4 @@ impl AsRawFd for TcpListener { self.inner.as_raw_fd() } } + diff --git a/src/sys/unix/udp.rs b/src/sys/unix/udp.rs index 64ec77600..fee1528cd 100644 --- a/src/sys/unix/udp.rs +++ b/src/sys/unix/udp.rs @@ -1,9 +1,9 @@ +use {io, Ready, Poll, PollOpt, Token}; use event::Evented; +use unix::EventedFd; use std::fmt; use std::net::{self, Ipv4Addr, Ipv6Addr, SocketAddr}; -use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; -use unix::EventedFd; -use {io, Poll, PollOpt, Ready, Token}; +use std::os::unix::io::{RawFd, IntoRawFd, AsRawFd, FromRawFd}; #[allow(unused_imports)] // only here for Rust 1.8 use net2::UdpSocketExt; @@ -15,7 +15,9 @@ pub struct UdpSocket { impl UdpSocket { pub fn new(socket: net::UdpSocket) -> io::Result { socket.set_nonblocking(true)?; - Ok(UdpSocket { io: socket }) + Ok(UdpSocket { + io: socket, + }) } pub fn local_addr(&self) -> io::Result { @@ -23,7 +25,11 @@ impl UdpSocket { } pub fn try_clone(&self) -> io::Result { - self.io.try_clone().map(|io| UdpSocket { io: io }) + self.io.try_clone().map(|io| { + UdpSocket { + io: io, + } + }) } pub fn send_to(&self, buf: &[u8], target: &SocketAddr) -> io::Result { @@ -42,7 +48,8 @@ impl UdpSocket { self.io.recv(buf) } - pub fn connect(&self, addr: SocketAddr) -> io::Result<()> { + pub fn connect(&self, addr: SocketAddr) + -> io::Result<()> { self.io.connect(addr) } @@ -86,19 +93,27 @@ impl UdpSocket { self.io.set_ttl(ttl) } - pub fn join_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> { + pub fn join_multicast_v4(&self, + multiaddr: &Ipv4Addr, + interface: &Ipv4Addr) -> io::Result<()> { self.io.join_multicast_v4(multiaddr, interface) } - pub fn join_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> { + pub fn join_multicast_v6(&self, + multiaddr: &Ipv6Addr, + interface: u32) -> io::Result<()> { self.io.join_multicast_v6(multiaddr, interface) } - pub fn leave_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> { + pub fn leave_multicast_v4(&self, + multiaddr: &Ipv4Addr, + interface: &Ipv4Addr) -> io::Result<()> { self.io.leave_multicast_v4(multiaddr, interface) } - pub fn leave_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> { + pub fn leave_multicast_v6(&self, + multiaddr: &Ipv6Addr, + interface: u32) -> io::Result<()> { self.io.leave_multicast_v6(multiaddr, interface) } @@ -116,23 +131,11 @@ impl UdpSocket { } impl Evented for UdpSocket { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { EventedFd(&self.as_raw_fd()).register(poll, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { EventedFd(&self.as_raw_fd()).reregister(poll, token, interest, opts) } diff --git a/src/sys/unix/uds.rs b/src/sys/unix/uds.rs index 408852f9f..e2888b23a 100644 --- a/src/sys/unix/uds.rs +++ b/src/sys/unix/uds.rs @@ -6,38 +6,33 @@ use std::path::Path; use libc; +use {io, Ready, Poll, PollOpt, Token}; use event::Evented; -use sys::unix::io::{set_cloexec, set_nonblock}; use sys::unix::{cvt, Io}; -use {io, Poll, PollOpt, Ready, Token}; +use sys::unix::io::{set_nonblock, set_cloexec}; trait MyInto { fn my_into(self) -> T; } impl MyInto for usize { - fn my_into(self) -> u32 { - self as u32 - } + fn my_into(self) -> u32 { self as u32 } } impl MyInto for usize { - fn my_into(self) -> usize { - self - } + fn my_into(self) -> usize { self } } -unsafe fn sockaddr_un(path: &Path) -> io::Result<(libc::sockaddr_un, libc::socklen_t)> { +unsafe fn sockaddr_un(path: &Path) + -> io::Result<(libc::sockaddr_un, libc::socklen_t)> { let mut addr: libc::sockaddr_un = mem::zeroed(); addr.sun_family = libc::AF_UNIX as libc::sa_family_t; let bytes = path.as_os_str().as_bytes(); if bytes.len() >= addr.sun_path.len() { - return Err(io::Error::new( - io::ErrorKind::InvalidInput, - "path must be shorter than SUN_LEN", - )); + return Err(io::Error::new(io::ErrorKind::InvalidInput, + "path must be shorter than SUN_LEN")) } for (dst, src) in addr.sun_path.iter_mut().zip(bytes.iter()) { *dst = *src as libc::c_char; @@ -100,11 +95,9 @@ impl UnixSocket { pub fn connect + ?Sized>(&self, addr: &P) -> io::Result<()> { unsafe { let (addr, len) = sockaddr_un(addr.as_ref())?; - cvt(libc::connect( - self.as_raw_fd(), - &addr as *const _ as *const _, - len, - ))?; + cvt(libc::connect(self.as_raw_fd(), + &addr as *const _ as *const _, + len))?; Ok(()) } } @@ -119,7 +112,9 @@ impl UnixSocket { pub fn accept(&self) -> io::Result { unsafe { - let fd = cvt(libc::accept(self.as_raw_fd(), 0 as *mut _, 0 as *mut _))?; + let fd = cvt(libc::accept(self.as_raw_fd(), + 0 as *mut _, + 0 as *mut _))?; let fd = Io::from_raw_fd(fd); set_cloexec(fd.as_raw_fd())?; set_nonblock(fd.as_raw_fd())?; @@ -131,19 +126,15 @@ impl UnixSocket { pub fn bind + ?Sized>(&self, addr: &P) -> io::Result<()> { unsafe { let (addr, len) = sockaddr_un(addr.as_ref())?; - cvt(libc::bind( - self.as_raw_fd(), - &addr as *const _ as *const _, - len, - ))?; + cvt(libc::bind(self.as_raw_fd(), + &addr as *const _ as *const _, + len))?; Ok(()) } } pub fn try_clone(&self) -> io::Result { - Ok(UnixSocket { - io: self.io.try_clone()?, - }) + Ok(UnixSocket { io: self.io.try_clone()? }) } pub fn shutdown(&self, how: Shutdown) -> io::Result<()> { @@ -178,8 +169,8 @@ impl UnixSocket { const SCM_RIGHTS: libc::c_int = 1; - let fd = if cmsg.hdr.cmsg_level == libc::SOL_SOCKET && cmsg.hdr.cmsg_type == SCM_RIGHTS - { + let fd = if cmsg.hdr.cmsg_level == libc::SOL_SOCKET && + cmsg.hdr.cmsg_type == SCM_RIGHTS { Some(cmsg.data[0]) } else { None @@ -231,23 +222,11 @@ impl Write for UnixSocket { } impl Evented for UnixSocket { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.io.register(poll, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.io.reregister(poll, token, interest, opts) } @@ -256,6 +235,7 @@ impl Evented for UnixSocket { } } + impl From for UnixSocket { fn from(io: Io) -> UnixSocket { UnixSocket { io: io } @@ -264,9 +244,7 @@ impl From for UnixSocket { impl FromRawFd for UnixSocket { unsafe fn from_raw_fd(fd: RawFd) -> UnixSocket { - UnixSocket { - io: Io::from_raw_fd(fd), - } + UnixSocket { io: Io::from_raw_fd(fd) } } } diff --git a/src/sys/windows/awakener.rs b/src/sys/windows/awakener.rs index 6f125772a..c913bc93f 100644 --- a/src/sys/windows/awakener.rs +++ b/src/sys/windows/awakener.rs @@ -1,9 +1,9 @@ use std::sync::Mutex; -use event::Evented; use miow::iocp::CompletionStatus; +use {io, poll, Ready, Poll, PollOpt, Token}; +use event::Evented; use sys::windows::Selector; -use {io, poll, Poll, PollOpt, Ready, Token}; pub struct Awakener { inner: Mutex>, @@ -29,7 +29,9 @@ impl Awakener { // If we haven't been registered with an event loop yet just silently // succeed. if let Some(inner) = self.inner.lock().unwrap().as_ref() { - let status = CompletionStatus::new(0, usize::from(inner.token), 0 as *mut _); + let status = CompletionStatus::new(0, + usize::from(inner.token), + 0 as *mut _); inner.selector.port().post(status)?; } Ok(()) @@ -41,7 +43,8 @@ impl Awakener { } impl Evented for Awakener { - fn register(&self, poll: &Poll, token: Token, events: Ready, opts: PollOpt) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, events: Ready, + opts: PollOpt) -> io::Result<()> { assert_eq!(opts, PollOpt::edge()); assert_eq!(events, Ready::readable()); *self.inner.lock().unwrap() = Some(AwakenerInner { @@ -51,13 +54,8 @@ impl Evented for Awakener { Ok(()) } - fn reregister( - &self, - poll: &Poll, - token: Token, - events: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, events: Ready, + opts: PollOpt) -> io::Result<()> { self.register(poll, token, events, opts) } diff --git a/src/sys/windows/buffer_pool.rs b/src/sys/windows/buffer_pool.rs index 877b28ca2..86754593f 100644 --- a/src/sys/windows/buffer_pool.rs +++ b/src/sys/windows/buffer_pool.rs @@ -4,22 +4,16 @@ pub struct BufferPool { impl BufferPool { pub fn new(cap: usize) -> BufferPool { - BufferPool { - pool: Vec::with_capacity(cap), - } + BufferPool { pool: Vec::with_capacity(cap) } } pub fn get(&mut self, default_cap: usize) -> Vec { - self.pool - .pop() - .unwrap_or_else(|| Vec::with_capacity(default_cap)) + self.pool.pop().unwrap_or_else(|| Vec::with_capacity(default_cap)) } pub fn put(&mut self, mut buf: Vec) { - if self.pool.len() < self.pool.capacity() { - unsafe { - buf.set_len(0); - } + if self.pool.len() < self.pool.capacity(){ + unsafe { buf.set_len(0); } self.pool.push(buf); } } diff --git a/src/sys/windows/from_raw_arc.rs b/src/sys/windows/from_raw_arc.rs index b2ea3c767..61f0e49cd 100644 --- a/src/sys/windows/from_raw_arc.rs +++ b/src/sys/windows/from_raw_arc.rs @@ -19,8 +19,8 @@ //! * The compiler doesn't understand that the pointer in `FromRawArc` is never //! null, so Option> is not a nullable pointer. -use std::mem; use std::ops::Deref; +use std::mem; use std::sync::atomic::{self, AtomicUsize, Ordering}; use winapi::OVERLAPPED; @@ -28,8 +28,8 @@ pub struct FromRawArc { _inner: *mut Inner, } -unsafe impl Send for FromRawArc {} -unsafe impl Sync for FromRawArc {} +unsafe impl Send for FromRawArc { } +unsafe impl Sync for FromRawArc { } #[repr(C)] struct Inner { @@ -43,18 +43,14 @@ impl FromRawArc { data: data, cnt: AtomicUsize::new(1), }); - FromRawArc { - _inner: unsafe { mem::transmute(x) }, - } + FromRawArc { _inner: unsafe { mem::transmute(x) } } } pub unsafe fn from_raw(ptr: *mut T) -> FromRawArc { // Note that if we could use `mem::transmute` here to get a libstd Arc // (guaranteed) then we could just use std::sync::Arc, but this is the // crucial reason this currently exists. - FromRawArc { - _inner: ptr as *mut Inner, - } + FromRawArc { _inner: ptr as *mut Inner } } } @@ -66,9 +62,7 @@ impl Clone for FromRawArc { unsafe { (*self._inner).cnt.fetch_add(1, Ordering::Relaxed); } - FromRawArc { - _inner: self._inner, - } + FromRawArc { _inner: self._inner } } } @@ -85,7 +79,7 @@ impl Drop for FromRawArc { unsafe { // Atomic orderings lifted from the standard library if (*self._inner).cnt.fetch_sub(1, Ordering::Release) != 1 { - return; + return } atomic::fence(Ordering::Acquire); drop(mem::transmute::<_, Box>(self._inner)); @@ -93,8 +87,8 @@ impl Drop for FromRawArc { } } -unsafe impl Send for FromRawArcStore {} -unsafe impl Sync for FromRawArcStore {} +unsafe impl Send for FromRawArcStore { } +unsafe impl Sync for FromRawArcStore { } pub struct FromRawArcStore { _ptr: *mut OVERLAPPED, diff --git a/src/sys/windows/mod.rs b/src/sys/windows/mod.rs index e9d9cec5e..dad70b0c1 100644 --- a/src/sys/windows/mod.rs +++ b/src/sys/windows/mod.rs @@ -145,23 +145,23 @@ use winapi; mod awakener; #[macro_use] mod selector; -mod buffer_pool; -mod from_raw_arc; mod tcp; mod udp; +mod from_raw_arc; +mod buffer_pool; pub use self::awakener::Awakener; -pub use self::selector::{Binding, Events, Overlapped, Selector}; -pub use self::tcp::{TcpListener, TcpStream}; +pub use self::selector::{Events, Selector, Overlapped, Binding}; +pub use self::tcp::{TcpStream, TcpListener}; pub use self::udp::UdpSocket; #[derive(Copy, Clone)] enum Family { - V4, - V6, + V4, V6, } -unsafe fn cancel(socket: &AsRawSocket, overlapped: &Overlapped) -> io::Result<()> { +unsafe fn cancel(socket: &AsRawSocket, + overlapped: &Overlapped) -> io::Result<()> { let handle = socket.as_raw_socket() as winapi::HANDLE; let ret = kernel32::CancelIoEx(handle, overlapped.as_mut_ptr()); if ret == 0 { diff --git a/src/sys/windows/selector.rs b/src/sys/windows/selector.rs index cb7b02ab5..d6a9cc826 100644 --- a/src/sys/windows/selector.rs +++ b/src/sys/windows/selector.rs @@ -1,24 +1,24 @@ #![allow(deprecated)] +use std::{fmt, io}; use std::cell::UnsafeCell; -use std::mem; use std::os::windows::prelude::*; -use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT}; use std::sync::{Arc, Mutex}; +use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT}; use std::time::Duration; -use std::{fmt, io}; +use std::mem; use lazycell::AtomicLazyCell; +use winapi::*; use miow; use miow::iocp::{CompletionPort, CompletionStatus}; -use winapi::*; use event_imp::{Event, Evented, Ready}; use poll::{self, Poll}; use sys::windows::buffer_pool::BufferPool; use sys::windows::from_raw_arc::FromRawArcStore; -use {PollOpt, Token}; +use {Token, PollOpt}; /// Each Selector has a globally unique(ish) ID associated with it. This ID /// gets tracked by `TcpStream`, `TcpListener`, etc... when they are first @@ -59,22 +59,22 @@ impl Selector { // offset by 1 to avoid choosing 0 as the id of a selector let id = NEXT_ID.fetch_add(1, Ordering::Relaxed) + 1; - CompletionPort::new(1).map(|cp| Selector { - inner: Arc::new(SelectorInner { - id: id, - port: cp, - buffers: Mutex::new(BufferPool::new(256)), - incompletes: Mutex::new(Vec::new()), - }), + CompletionPort::new(1).map(|cp| { + Selector { + inner: Arc::new(SelectorInner { + id: id, + port: cp, + buffers: Mutex::new(BufferPool::new(256)), + incompletes: Mutex::new(Vec::new()), + }), + } }) } - pub fn select( - &self, - events: &mut Events, - awakener: Token, - timeout: Option, - ) -> io::Result { + pub fn select(&self, + events: &mut Events, + awakener: Token, + timeout: Option) -> io::Result { trace!("select; timeout={:?}", timeout); // Clear out the previous list of I/O events and get some more! @@ -99,21 +99,21 @@ impl Selector { // Deadlock will occur if you don't release it first before the callback. { let mut incompletes = self.inner.incompletes.lock().unwrap(); - let pos = incompletes - .iter() - .position(|item| item.0 == (status.overlapped() as isize)); + let pos = incompletes.iter().position(|item| item.0 == (status.overlapped() as isize)); match pos { Some(pos) => { let store = incompletes.remove(pos); mem::forget(store); - } + }, None => { trace!("cannot find store, omiting..."); } } } - let callback = unsafe { (*(status.overlapped() as *mut Overlapped)).callback }; + let callback = unsafe { + (*(status.overlapped() as *mut Overlapped)).callback + }; trace!("select; -> got overlapped"); callback(status.entry()); @@ -141,9 +141,7 @@ impl Selector { /// Gets a new reference to this selector, although all underlying data /// structures will refer to the same completion port. pub fn clone_ref(&self) -> Selector { - Selector { - inner: self.inner.clone(), - } + Selector { inner: self.inner.clone() } } /// Return the `Selector`'s identifier @@ -188,9 +186,7 @@ impl Binding { /// /// Won't actually do anything until associated with a `Poll` loop. pub fn new() -> Binding { - Binding { - selector: AtomicLazyCell::new(), - } + Binding { selector: AtomicLazyCell::new() } } /// Registers a new handle with the `Poll` specified, also assigning the @@ -209,12 +205,10 @@ impl Binding { /// Specifically they must all be instances of the `Overlapped` type in /// this crate. More information about this can be found on the /// `windows` module in this crate. - pub unsafe fn register_handle( - &self, - handle: &AsRawHandle, - token: Token, - poll: &Poll, - ) -> io::Result<()> { + pub unsafe fn register_handle(&self, + handle: &AsRawHandle, + token: Token, + poll: &Poll) -> io::Result<()> { let selector = poll::selector(poll); // Ignore errors, we'll see them on the next line. @@ -225,12 +219,10 @@ impl Binding { } /// Same as `register_handle` but for sockets. - pub unsafe fn register_socket( - &self, - handle: &AsRawSocket, - token: Token, - poll: &Poll, - ) -> io::Result<()> { + pub unsafe fn register_socket(&self, + handle: &AsRawSocket, + token: Token, + poll: &Poll) -> io::Result<()> { let selector = poll::selector(poll); drop(self.selector.fill(selector.inner.clone())); self.check_same_selector(poll)?; @@ -254,22 +246,18 @@ impl Binding { /// /// This function is unsafe for similar reasons to `register`. That is, /// there may be pending I/O events and such which aren't handled correctly. - pub unsafe fn reregister_handle( - &self, - _handle: &AsRawHandle, - _token: Token, - poll: &Poll, - ) -> io::Result<()> { + pub unsafe fn reregister_handle(&self, + _handle: &AsRawHandle, + _token: Token, + poll: &Poll) -> io::Result<()> { self.check_same_selector(poll) } /// Same as `reregister_handle`, but for sockets. - pub unsafe fn reregister_socket( - &self, - _socket: &AsRawSocket, - _token: Token, - poll: &Poll, - ) -> io::Result<()> { + pub unsafe fn reregister_socket(&self, + _socket: &AsRawSocket, + _token: Token, + poll: &Poll) -> io::Result<()> { self.check_same_selector(poll) } @@ -286,12 +274,16 @@ impl Binding { /// /// This function is unsafe for similar reasons to `register`. That is, /// there may be pending I/O events and such which aren't handled correctly. - pub unsafe fn deregister_handle(&self, _handle: &AsRawHandle, poll: &Poll) -> io::Result<()> { + pub unsafe fn deregister_handle(&self, + _handle: &AsRawHandle, + poll: &Poll) -> io::Result<()> { self.check_same_selector(poll) } /// Same as `deregister_handle`, but for sockets. - pub unsafe fn deregister_socket(&self, _socket: &AsRawSocket, poll: &Poll) -> io::Result<()> { + pub unsafe fn deregister_socket(&self, + _socket: &AsRawSocket, + poll: &Poll) -> io::Result<()> { self.check_same_selector(poll) } @@ -299,14 +291,16 @@ impl Binding { let selector = poll::selector(poll); match self.selector.borrow() { Some(prev) if prev.identical(&selector.inner) => Ok(()), - Some(_) | None => Err(other("socket already registered")), + Some(_) | + None => Err(other("socket already registered")), } } } impl fmt::Debug for Binding { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("Binding").finish() + f.debug_struct("Binding") + .finish() } } @@ -383,15 +377,14 @@ impl ReadyBinding { /// Returns an error if we're already registered with another event loop, /// and otherwise just reassociates ourselves with the event loop to /// possible change tokens. - pub fn register_socket( - &mut self, - socket: &AsRawSocket, - poll: &Poll, - token: Token, - events: Ready, - opts: PollOpt, - registration: &Mutex>, - ) -> io::Result<()> { + pub fn register_socket(&mut self, + socket: &AsRawSocket, + poll: &Poll, + token: Token, + events: Ready, + opts: PollOpt, + registration: &Mutex>) + -> io::Result<()> { trace!("register {:?} {:?}", token, events); unsafe { self.binding.register_socket(socket, token, poll)?; @@ -404,61 +397,57 @@ impl ReadyBinding { } /// Implementation of `Evented::reregister` function. - pub fn reregister_socket( - &mut self, - socket: &AsRawSocket, - poll: &Poll, - token: Token, - events: Ready, - opts: PollOpt, - registration: &Mutex>, - ) -> io::Result<()> { + pub fn reregister_socket(&mut self, + socket: &AsRawSocket, + poll: &Poll, + token: Token, + events: Ready, + opts: PollOpt, + registration: &Mutex>) + -> io::Result<()> { trace!("reregister {:?} {:?}", token, events); unsafe { self.binding.reregister_socket(socket, token, poll)?; } - registration - .lock() - .unwrap() - .as_mut() - .unwrap() - .reregister(poll, token, events, opts) + registration.lock().unwrap() + .as_mut().unwrap() + .reregister(poll, token, events, opts) } /// Implementation of the `Evented::deregister` function. /// /// Doesn't allow registration with another event loop, just shuts down /// readiness notifications and such. - pub fn deregister( - &mut self, - socket: &AsRawSocket, - poll: &Poll, - registration: &Mutex>, - ) -> io::Result<()> { + pub fn deregister(&mut self, + socket: &AsRawSocket, + poll: &Poll, + registration: &Mutex>) + -> io::Result<()> { trace!("deregistering"); unsafe { self.binding.deregister_socket(socket, poll)?; } - registration - .lock() - .unwrap() - .as_ref() - .unwrap() - .deregister(poll) + registration.lock().unwrap() + .as_ref().unwrap() + .deregister(poll) } pub fn store_overlapped_content(&self, ptr: *mut OVERLAPPED, deallocator: fn(*mut OVERLAPPED)) { if let Some(i) = self.binding.selector.borrow() { - let selector = Selector { inner: i.clone() }; + let selector = Selector { + inner: i.clone(), + }; selector.store_overlapped_content(ptr, deallocator); } } pub fn clean_overlapped_content(&self, ptr: *mut OVERLAPPED) { if let Some(i) = self.binding.selector.borrow() { - let selector = Selector { inner: i.clone() }; + let selector = Selector { + inner: i.clone(), + }; selector.clean_overlapped_content(ptr); } } @@ -572,13 +561,16 @@ impl Overlapped { /// This can be useful when only a shared borrow is held and the overlapped /// pointer needs to be passed down to winapi. pub fn as_mut_ptr(&self) -> *mut OVERLAPPED { - unsafe { (*self.inner.get()).raw() } + unsafe { + (*self.inner.get()).raw() + } } } impl fmt::Debug for Overlapped { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("Overlapped").finish() + f.debug_struct("Overlapped") + .finish() } } diff --git a/src/sys/windows/tcp.rs b/src/sys/windows/tcp.rs index 6df9d7866..b542e2a06 100644 --- a/src/sys/windows/tcp.rs +++ b/src/sys/windows/tcp.rs @@ -1,22 +1,22 @@ use std::fmt; -use std::io::{self, ErrorKind, Read}; +use std::io::{self, Read, ErrorKind}; use std::mem; -use std::net::{self, Shutdown, SocketAddr}; +use std::net::{self, SocketAddr, Shutdown}; use std::os::windows::prelude::*; use std::sync::{Mutex, MutexGuard}; use std::time::Duration; -use iovec::IoVec; use miow::iocp::CompletionStatus; use miow::net::*; use net2::{TcpBuilder, TcpStreamExt as Net2TcpExt}; use winapi::*; +use iovec::IoVec; +use {poll, Ready, Poll, PollOpt, Token}; use event::Evented; use sys::windows::from_raw_arc::FromRawArc; use sys::windows::selector::{Overlapped, ReadyBinding}; use sys::windows::Family; -use {poll, Poll, PollOpt, Ready, Token}; pub struct TcpStream { /// Separately stored implementation to ensure that the `Drop` @@ -85,14 +85,15 @@ struct ListenerInner { } enum State { - Empty, // no I/O operation in progress - Pending(T), // an I/O operation is in progress - Ready(U), // I/O has finished with this value - Error(io::Error), // there was an I/O error + Empty, // no I/O operation in progress + Pending(T), // an I/O operation is in progress + Ready(U), // I/O has finished with this value + Error(io::Error), // there was an I/O error } impl TcpStream { - fn new(socket: net::TcpStream, deferred_connect: Option) -> TcpStream { + fn new(socket: net::TcpStream, + deferred_connect: Option) -> TcpStream { TcpStream { registration: Mutex::new(None), imp: StreamImp { @@ -112,7 +113,8 @@ impl TcpStream { } } - pub fn connect(socket: net::TcpStream, addr: &SocketAddr) -> io::Result { + pub fn connect(socket: net::TcpStream, addr: &SocketAddr) + -> io::Result { socket.set_nonblocking(true)?; Ok(TcpStream::new(socket, Some(*addr))) } @@ -130,11 +132,7 @@ impl TcpStream { } pub fn try_clone(&self) -> io::Result { - self.imp - .inner - .socket - .try_clone() - .map(|s| TcpStream::new(s, None)) + self.imp.inner.socket.try_clone().map(|s| TcpStream::new(s, None)) } pub fn shutdown(&self, how: Shutdown) -> io::Result<()> { @@ -199,7 +197,7 @@ impl TcpStream { pub fn take_error(&self) -> io::Result> { if let Some(e) = self.imp.inner.socket.take_error()? { - return Ok(Some(e)); + return Ok(Some(e)) } // If the syscall didn't return anything then also check to see if we've @@ -238,7 +236,8 @@ impl TcpStream { match me.read { // Empty == we're not associated yet, and if we're pending then // these are both cases where we return "would block" - State::Empty | State::Pending(()) => return Err(io::ErrorKind::WouldBlock.into()), + State::Empty | + State::Pending(()) => return Err(io::ErrorKind::WouldBlock.into()), // If we got a delayed error as part of a `read_overlapped` below, // return that here. Also schedule another read in case it was @@ -249,7 +248,7 @@ impl TcpStream { _ => panic!(), }; self.imp.schedule_read(&mut me); - return Err(e); + return Err(e) } // If we're ready for a read then some previous 0-byte read has @@ -332,14 +331,14 @@ impl TcpStream { if amt > 0 && e.kind() == io::ErrorKind::WouldBlock { me.read = State::Empty; self.imp.schedule_read(&mut me); - return Ok(amt); + return Ok(amt) } else if amt > 0 { me.read = State::Error(e); - return Ok(amt); + return Ok(amt) } else { me.read = State::Empty; self.imp.schedule_read(&mut me); - return Err(e); + return Err(e) } } } @@ -364,16 +363,16 @@ impl TcpStream { State::Error(e) => return Err(e), other => { me.write = other; - return Err(io::ErrorKind::WouldBlock.into()); + return Err(io::ErrorKind::WouldBlock.into()) } } if !me.iocp.registered() { - return Err(io::ErrorKind::WouldBlock.into()); + return Err(io::ErrorKind::WouldBlock.into()) } if bufs.len() == 0 { - return Ok(0); + return Ok(0) } let len = bufs.iter().map(|b| b.len()).fold(0, |a, b| a + b); @@ -398,14 +397,11 @@ impl StreamImp { fn schedule_connect(&self, addr: &SocketAddr, me: &mut StreamInner) -> io::Result<()> { unsafe { trace!("scheduling a connect"); - self.inner - .socket - .connect_overlapped(addr, &[], self.inner.read.as_mut_ptr())?; + self.inner.socket.connect_overlapped(addr, &[], self.inner.read.as_mut_ptr())?; } // see docs above on StreamImp.inner for rationale on forget mem::forget(self.clone()); - me.iocp - .store_overlapped_content(self.inner.read.as_mut_ptr(), read_deallocate); + me.iocp.store_overlapped_content(self.inner.read.as_mut_ptr(), read_deallocate); Ok(()) } @@ -426,14 +422,11 @@ impl StreamImp { _ => return, } - me.iocp - .set_readiness(me.iocp.readiness() - Ready::readable()); + me.iocp.set_readiness(me.iocp.readiness() - Ready::readable()); trace!("scheduling a read"); let res = unsafe { - self.inner - .socket - .read_overlapped(&mut [], self.inner.read.as_mut_ptr()) + self.inner.socket.read_overlapped(&mut [], self.inner.read.as_mut_ptr()) }; match res { // Note that `Ok(true)` means that this completed immediately and @@ -462,8 +455,7 @@ impl StreamImp { // see docs above on StreamImp.inner for rationale on forget me.read = State::Pending(()); mem::forget(self.clone()); - me.iocp - .store_overlapped_content(self.inner.read.as_mut_ptr(), read_deallocate); + me.iocp.store_overlapped_content(self.inner.read.as_mut_ptr(), read_deallocate); } Err(e) => { me.read = State::Error(e); @@ -481,17 +473,18 @@ impl StreamImp { /// /// A new writable event (e.g. allowing another write) will only happen once /// the buffer has been written completely (or hit an error). - fn schedule_write(&self, buf: Vec, mut pos: usize, me: &mut StreamInner) { + fn schedule_write(&self, + buf: Vec, + mut pos: usize, + me: &mut StreamInner) { + // About to write, clear any pending level triggered events - me.iocp - .set_readiness(me.iocp.readiness() - Ready::writable()); + me.iocp.set_readiness(me.iocp.readiness() - Ready::writable()); loop { trace!("scheduling a write of {} bytes", buf[pos..].len()); let ret = unsafe { - self.inner - .socket - .write_overlapped(&buf[pos..], self.inner.write.as_mut_ptr()) + self.inner.socket.write_overlapped(&buf[pos..], self.inner.write.as_mut_ptr()) }; match ret { Ok(Some(transferred_bytes)) if me.instant_notify => { @@ -508,8 +501,7 @@ impl StreamImp { // see docs above on StreamImp.inner for rationale on forget me.write = State::Pending((buf, pos)); mem::forget(self.clone()); - me.iocp - .store_overlapped_content(self.inner.write.as_mut_ptr(), write_deallocate); + me.iocp.store_overlapped_content(self.inner.write.as_mut_ptr(), write_deallocate); break; } Err(e) => { @@ -545,7 +537,7 @@ fn read_done(status: &OVERLAPPED_ENTRY) { trace!("finished a read: {}", status.bytes_transferred()); assert_eq!(status.bytes_transferred(), 0); me.read = State::Ready(()); - return me2.add_readiness(&mut me, Ready::readable()); + return me2.add_readiness(&mut me, Ready::readable()) } s => me.read = s, } @@ -604,22 +596,11 @@ fn write_deallocate(ptr: *mut OVERLAPPED) { } impl Evented for TcpStream { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { let mut me = self.inner(); - me.iocp.register_socket( - &self.imp.inner.socket, - poll, - token, - interest, - opts, - &self.registration, - )?; + me.iocp.register_socket(&self.imp.inner.socket, poll, token, + interest, opts, &self.registration)?; unsafe { super::no_notify_on_instant_completion(self.imp.inner.socket.as_raw_socket() as HANDLE)?; @@ -631,42 +612,31 @@ impl Evented for TcpStream { // successful connect will worry about generating writable/readable // events and scheduling a new read. if let Some(addr) = me.deferred_connect.take() { - return self.imp.schedule_connect(&addr, &mut me).map(|_| ()); + return self.imp.schedule_connect(&addr, &mut me).map(|_| ()) } self.post_register(interest, &mut me); Ok(()) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { let mut me = self.inner(); - me.iocp.reregister_socket( - &self.imp.inner.socket, - poll, - token, - interest, - opts, - &self.registration, - )?; + me.iocp.reregister_socket(&self.imp.inner.socket, poll, token, + interest, opts, &self.registration)?; self.post_register(interest, &mut me); Ok(()) } fn deregister(&self, poll: &Poll) -> io::Result<()> { - self.inner() - .iocp - .deregister(&self.imp.inner.socket, poll, &self.registration) + self.inner().iocp.deregister(&self.imp.inner.socket, + poll, &self.registration) } } impl fmt::Debug for TcpStream { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("TcpStream").finish() + f.debug_struct("TcpStream") + .finish() } } @@ -683,14 +653,11 @@ impl Drop for TcpStream { match inner.read { State::Pending(_) | State::Empty => { trace!("cancelling active TCP read"); - drop(super::cancel(&self.imp.inner.socket, &self.imp.inner.read)); + drop(super::cancel(&self.imp.inner.socket, + &self.imp.inner.read)); trace!("cleaning remaining overlapped contents"); - inner - .iocp - .clean_overlapped_content(self.imp.inner.read.as_mut_ptr()); - inner - .iocp - .clean_overlapped_content(self.imp.inner.write.as_mut_ptr()); + inner.iocp.clean_overlapped_content(self.imp.inner.read.as_mut_ptr()); + inner.iocp.clean_overlapped_content(self.imp.inner.write.as_mut_ptr()); } State::Ready(_) | State::Error(_) => {} } @@ -699,15 +666,13 @@ impl Drop for TcpStream { } impl TcpListener { - pub fn new(socket: net::TcpListener) -> io::Result { + pub fn new(socket: net::TcpListener) + -> io::Result { let addr = socket.local_addr()?; - Ok(TcpListener::new_family( - socket, - match addr { - SocketAddr::V4(..) => Family::V4, - SocketAddr::V6(..) => Family::V6, - }, - )) + Ok(TcpListener::new_family(socket, match addr { + SocketAddr::V4(..) => Family::V4, + SocketAddr::V6(..) => Family::V6, + })) } fn new_family(socket: net::TcpListener, family: Family) -> TcpListener { @@ -744,7 +709,7 @@ impl TcpListener { self.imp.schedule_accept(&mut me); - return ret; + return ret } pub fn local_addr(&self) -> io::Result { @@ -752,11 +717,9 @@ impl TcpListener { } pub fn try_clone(&self) -> io::Result { - self.imp - .inner - .socket - .try_clone() - .map(|s| TcpListener::new_family(s, self.imp.inner.family)) + self.imp.inner.socket.try_clone().map(|s| { + TcpListener::new_family(s, self.imp.inner.family) + }) } #[allow(deprecated)] @@ -794,30 +757,25 @@ impl ListenerImp { fn schedule_accept(&self, me: &mut ListenerInner) { match me.accept { State::Empty => {} - _ => return, + _ => return } - me.iocp - .set_readiness(me.iocp.readiness() - Ready::readable()); + me.iocp.set_readiness(me.iocp.readiness() - Ready::readable()); let res = match self.inner.family { Family::V4 => TcpBuilder::new_v4(), Family::V6 => TcpBuilder::new_v6(), }.and_then(|builder| unsafe { trace!("scheduling an accept"); - self.inner.socket.accept_overlapped( - &builder, - &mut me.accept_buf, - self.inner.accept.as_mut_ptr(), - ) + self.inner.socket.accept_overlapped(&builder, &mut me.accept_buf, + self.inner.accept.as_mut_ptr()) }); match res { Ok((socket, _)) => { // see docs above on StreamImp.inner for rationale on forget me.accept = State::Pending(socket); mem::forget(self.clone()); - me.iocp - .store_overlapped_content(self.inner.accept.as_mut_ptr(), accept_dellocate); + me.iocp.store_overlapped_content(self.inner.accept.as_mut_ptr(), accept_dellocate); } Err(e) => { me.accept = State::Error(e); @@ -844,15 +802,13 @@ fn accept_done(status: &OVERLAPPED_ENTRY) { _ => unreachable!(), }; trace!("finished an accept"); - let result = me2 - .inner - .socket - .accept_complete(&socket) - .and_then(|()| me.accept_buf.parse(&me2.inner.socket)) - .and_then(|buf| { - buf.remote() - .ok_or_else(|| io::Error::new(ErrorKind::Other, "could not obtain remote address")) - }); + let result = me2.inner.socket.accept_complete(&socket).and_then(|()| { + me.accept_buf.parse(&me2.inner.socket) + }).and_then(|buf| { + buf.remote().ok_or_else(|| { + io::Error::new(ErrorKind::Other, "could not obtain remote address") + }) + }); me.accept = match result { Ok(remote_addr) => State::Ready((socket, remote_addr)), Err(e) => State::Error(e), @@ -868,22 +824,11 @@ fn accept_dellocate(ptr: *mut OVERLAPPED) { } impl Evented for TcpListener { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { let mut me = self.inner(); - me.iocp.register_socket( - &self.imp.inner.socket, - poll, - token, - interest, - opts, - &self.registration, - )?; + me.iocp.register_socket(&self.imp.inner.socket, poll, token, + interest, opts, &self.registration)?; unsafe { super::no_notify_on_instant_completion(self.imp.inner.socket.as_raw_socket() as HANDLE)?; @@ -894,36 +839,25 @@ impl Evented for TcpListener { Ok(()) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { let mut me = self.inner(); - me.iocp.reregister_socket( - &self.imp.inner.socket, - poll, - token, - interest, - opts, - &self.registration, - )?; + me.iocp.reregister_socket(&self.imp.inner.socket, poll, token, + interest, opts, &self.registration)?; self.imp.schedule_accept(&mut me); Ok(()) } fn deregister(&self, poll: &Poll) -> io::Result<()> { - self.inner() - .iocp - .deregister(&self.imp.inner.socket, poll, &self.registration) + self.inner().iocp.deregister(&self.imp.inner.socket, + poll, &self.registration) } } impl fmt::Debug for TcpListener { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("TcpListener").finish() + f.debug_struct("TcpListener") + .finish() } } @@ -935,16 +869,14 @@ impl Drop for TcpListener { match inner.accept { State::Pending(_) => { trace!("cancelling active TCP accept"); - drop(super::cancel( - &self.imp.inner.socket, - &self.imp.inner.accept, - )); + drop(super::cancel(&self.imp.inner.socket, + &self.imp.inner.accept)); trace!("cleaning remaining overlapped contents"); - inner - .iocp - .clean_overlapped_content(self.imp.inner.accept.as_mut_ptr()); + inner.iocp.clean_overlapped_content(self.imp.inner.accept.as_mut_ptr()); } - State::Empty | State::Ready(_) | State::Error(_) => {} + State::Empty | + State::Ready(_) | + State::Error(_) => {} } } } diff --git a/src/sys/windows/udp.rs b/src/sys/windows/udp.rs index dc6ee7aaf..2e34a2458 100644 --- a/src/sys/windows/udp.rs +++ b/src/sys/windows/udp.rs @@ -4,23 +4,23 @@ //! something seems odd you may also want to try the docs over there. use std::fmt; -use std::io; use std::io::prelude::*; +use std::io; use std::mem; use std::net::{self, Ipv4Addr, Ipv6Addr, SocketAddr}; use std::sync::{Mutex, MutexGuard}; -use miow::iocp::CompletionStatus; -use miow::net::SocketAddrBuf; -use miow::net::UdpSocketExt as MiowUdpSocketExt; #[allow(unused_imports)] use net2::{UdpBuilder, UdpSocketExt}; use winapi::*; +use miow::iocp::CompletionStatus; +use miow::net::SocketAddrBuf; +use miow::net::UdpSocketExt as MiowUdpSocketExt; +use {poll, Ready, Poll, PollOpt, Token}; use event::Evented; use sys::windows::from_raw_arc::FromRawArc; use sys::windows::selector::{Overlapped, ReadyBinding}; -use {poll, Poll, PollOpt, Ready, Token}; pub struct UdpSocket { imp: Imp, @@ -87,7 +87,8 @@ impl UdpSocket { /// TODO: This... may be wrong in the long run. We're reporting that we /// successfully wrote all of the bytes in `buf` but it's possible /// that we don't actually end up writing all of them! - pub fn send_to(&self, buf: &[u8], target: &SocketAddr) -> io::Result { + pub fn send_to(&self, buf: &[u8], target: &SocketAddr) + -> io::Result { let mut me = self.inner(); let me = &mut *me; @@ -97,7 +98,7 @@ impl UdpSocket { } if !me.iocp.registered() { - return Err(io::ErrorKind::WouldBlock.into()); + return Err(io::ErrorKind::WouldBlock.into()) } let interest = me.iocp.readiness(); @@ -107,16 +108,12 @@ impl UdpSocket { let amt = owned_buf.write(buf)?; unsafe { trace!("scheduling a send"); - self.imp.inner.socket.send_to_overlapped( - &owned_buf, - target, - self.imp.inner.write.as_mut_ptr(), - ) + self.imp.inner.socket.send_to_overlapped(&owned_buf, target, + self.imp.inner.write.as_mut_ptr()) }?; me.write = State::Pending(owned_buf); mem::forget(self.imp.clone()); - me.iocp - .store_overlapped_content(self.imp.inner.write.as_mut_ptr(), send_deallocate); + me.iocp.store_overlapped_content(self.imp.inner.write.as_mut_ptr(), send_deallocate); Ok(amt) } @@ -136,7 +133,7 @@ impl UdpSocket { } if !me.iocp.registered() { - return Err(io::ErrorKind::WouldBlock.into()); + return Err(io::ErrorKind::WouldBlock.into()) } let interest = me.iocp.readiness(); @@ -146,15 +143,12 @@ impl UdpSocket { let amt = owned_buf.write(buf)?; unsafe { trace!("scheduling a send"); - self.imp - .inner - .socket - .send_overlapped(&owned_buf, self.imp.inner.write.as_mut_ptr()) + self.imp.inner.socket.send_overlapped(&owned_buf, self.imp.inner.write.as_mut_ptr()) + }?; me.write = State::Pending(owned_buf); mem::forget(self.imp.clone()); - me.iocp - .store_overlapped_content(self.imp.inner.write.as_mut_ptr(), send_deallocate); + me.iocp.store_overlapped_content(self.imp.inner.write.as_mut_ptr(), send_deallocate); Ok(amt) } @@ -162,10 +156,7 @@ impl UdpSocket { let mut me = self.inner(); match mem::replace(&mut me.read, State::Empty) { State::Empty => Err(io::ErrorKind::WouldBlock.into()), - State::Pending(b) => { - me.read = State::Pending(b); - Err(io::ErrorKind::WouldBlock.into()) - } + State::Pending(b) => { me.read = State::Pending(b); Err(io::ErrorKind::WouldBlock.into()) } State::Ready(data) => { // If we weren't provided enough space to receive the message // then don't actually read any data, just return an error. @@ -177,10 +168,8 @@ impl UdpSocket { buf.write(&data).unwrap(); Ok((data.len(), addr)) } else { - Err(io::Error::new( - io::ErrorKind::Other, - "failed to parse socket address", - )) + Err(io::Error::new(io::ErrorKind::Other, + "failed to parse socket address")) }; me.iocp.put_buffer(data); self.imp.schedule_read_from(&mut me); @@ -194,9 +183,10 @@ impl UdpSocket { } } - pub fn recv(&self, buf: &mut [u8]) -> io::Result { + pub fn recv(&self, buf: &mut [u8]) + -> io::Result { //Since recv_from can be used on connected sockets just call it and drop the address. - self.recv_from(buf).map(|(size, _)| size) + self.recv_from(buf).map(|(size,_)| size) } pub fn connect(&self, addr: SocketAddr) -> io::Result<()> { @@ -243,32 +233,28 @@ impl UdpSocket { self.imp.inner.socket.set_ttl(ttl) } - pub fn join_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> { - self.imp - .inner - .socket - .join_multicast_v4(multiaddr, interface) + pub fn join_multicast_v4(&self, + multiaddr: &Ipv4Addr, + interface: &Ipv4Addr) -> io::Result<()> { + self.imp.inner.socket.join_multicast_v4(multiaddr, interface) } - pub fn join_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> { - self.imp - .inner - .socket - .join_multicast_v6(multiaddr, interface) + pub fn join_multicast_v6(&self, + multiaddr: &Ipv6Addr, + interface: u32) -> io::Result<()> { + self.imp.inner.socket.join_multicast_v6(multiaddr, interface) } - pub fn leave_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> { - self.imp - .inner - .socket - .leave_multicast_v4(multiaddr, interface) + pub fn leave_multicast_v4(&self, + multiaddr: &Ipv4Addr, + interface: &Ipv4Addr) -> io::Result<()> { + self.imp.inner.socket.leave_multicast_v4(multiaddr, interface) } - pub fn leave_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> { - self.imp - .inner - .socket - .leave_multicast_v6(multiaddr, interface) + pub fn leave_multicast_v6(&self, + multiaddr: &Ipv6Addr, + interface: u32) -> io::Result<()> { + self.imp.inner.socket.leave_multicast_v6(multiaddr, interface) } pub fn set_only_v6(&self, only_v6: bool) -> io::Result<()> { @@ -322,18 +308,14 @@ impl Imp { trace!("scheduling a read"); let cap = buf.capacity(); buf.set_len(cap); - self.inner.socket.recv_from_overlapped( - &mut buf, - &mut me.read_buf, - self.inner.read.as_mut_ptr(), - ) + self.inner.socket.recv_from_overlapped(&mut buf, &mut me.read_buf, + self.inner.read.as_mut_ptr()) }; match res { Ok(_) => { me.read = State::Pending(buf); mem::forget(self.clone()); - me.iocp - .store_overlapped_content(self.inner.read.as_mut_ptr(), recv_deallocate); + me.iocp.store_overlapped_content(self.inner.read.as_mut_ptr(), recv_deallocate); } Err(e) => { me.read = State::Error(e); @@ -350,56 +332,36 @@ impl Imp { } impl Evented for UdpSocket { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { let mut me = self.inner(); - me.iocp.register_socket( - &self.imp.inner.socket, - poll, - token, - interest, - opts, - &self.registration, - )?; + me.iocp.register_socket(&self.imp.inner.socket, + poll, token, interest, opts, + &self.registration)?; self.post_register(interest, &mut me); Ok(()) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, + interest: Ready, opts: PollOpt) -> io::Result<()> { let mut me = self.inner(); - me.iocp.reregister_socket( - &self.imp.inner.socket, - poll, - token, - interest, - opts, - &self.registration, - )?; + me.iocp.reregister_socket(&self.imp.inner.socket, + poll, token, interest, + opts, &self.registration)?; self.post_register(interest, &mut me); Ok(()) } fn deregister(&self, poll: &Poll) -> io::Result<()> { - self.inner() - .iocp - .deregister(&self.imp.inner.socket, poll, &self.registration) + self.inner().iocp.deregister(&self.imp.inner.socket, + poll, &self.registration) } } impl fmt::Debug for UdpSocket { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("UdpSocket").finish() + f.debug_struct("UdpSocket") + .finish() } } @@ -413,9 +375,12 @@ impl Drop for UdpSocket { unsafe { match inner.read { State::Pending(_) => { - drop(super::cancel(&self.imp.inner.socket, &self.imp.inner.read)); + drop(super::cancel(&self.imp.inner.socket, + &self.imp.inner.read)); } - State::Empty | State::Ready(_) | State::Error(_) => {} + State::Empty | + State::Ready(_) | + State::Error(_) => {} } } } @@ -462,4 +427,4 @@ fn recv_deallocate(ptr: *mut OVERLAPPED) { inner: unsafe { overlapped2arc!(ptr, Io, read) }, }; drop(me); -} +} \ No newline at end of file diff --git a/src/timer.rs b/src/timer.rs index 63d0324a6..0b762ea38 100644 --- a/src/timer.rs +++ b/src/timer.rs @@ -2,14 +2,14 @@ #![allow(deprecated, missing_debug_implementations)] +use {convert, io, Ready, Poll, PollOpt, Registration, SetReadiness, Token}; use event::Evented; use lazycell::LazyCell; use slab::Slab; -use std::sync::atomic::{AtomicUsize, Ordering}; +use std::{cmp, error, fmt, u64, usize, iter, thread}; use std::sync::Arc; +use std::sync::atomic::{AtomicUsize, Ordering}; use std::time::{Duration, Instant}; -use std::{cmp, error, fmt, iter, thread, u64, usize}; -use {convert, io, Poll, PollOpt, Ready, Registration, SetReadiness, Token}; use self::TimerErrorKind::TimerOverflow; @@ -83,7 +83,7 @@ struct Entry { struct EntryLinks { tick: Tick, prev: Token, - next: Token, + next: Token } type Tick = u64; @@ -97,6 +97,7 @@ pub type Result = ::std::result::Result; // TODO: remove pub type TimerResult = Result; + /// Deprecated and unused. #[derive(Debug)] pub struct TimerError; @@ -130,12 +131,7 @@ impl Builder { } pub fn build(self) -> Timer { - Timer::new( - convert::millis(self.tick), - self.num_slots, - self.capacity, - Instant::now(), - ) + Timer::new(convert::millis(self.tick), self.num_slots, self.capacity, Instant::now()) } } @@ -154,11 +150,8 @@ impl Timer { let num_slots = num_slots.next_power_of_two(); let capacity = capacity.next_power_of_two(); let mask = (num_slots as u64) - 1; - let wheel = iter::repeat(WheelEntry { - next_tick: TICK_MAX, - head: EMPTY, - }).take(num_slots) - .collect(); + let wheel = iter::repeat(WheelEntry { next_tick: TICK_MAX, head: EMPTY }) + .take(num_slots).collect(); Timer { tick_ms: tick_ms, @@ -179,12 +172,7 @@ impl Timer { fn set_timeout_at(&mut self, delay_from_start: Duration, state: T) -> Result { let mut tick = duration_to_tick(delay_from_start, self.tick_ms); - trace!( - "setting timeout; delay={:?}; tick={:?}; current-tick={:?}", - delay_from_start, - tick, - self.tick - ); + trace!("setting timeout; delay={:?}; tick={:?}; current-tick={:?}", delay_from_start, tick, self.tick); // Always target at least 1 tick in the future if tick <= self.tick { @@ -222,14 +210,14 @@ impl Timer { // Return the new timeout Ok(Timeout { token: token, - tick: tick, + tick: tick }) } pub fn cancel_timeout(&mut self, timeout: &Timeout) -> Option { let links = match self.entries.get(timeout.token.into()) { Some(e) => e.links, - None => return None, + None => return None }; // Sanity check @@ -247,11 +235,7 @@ impl Timer { } fn poll_to(&mut self, mut target_tick: Tick) -> Option { - trace!( - "tick_to; target_tick={}; current_tick={}", - target_tick, - self.tick - ); + trace!("tick_to; target_tick={}; current_tick={}", target_tick, self.tick); if target_tick < self.tick { target_tick = self.tick; @@ -315,11 +299,8 @@ impl Timer { } fn unlink(&mut self, links: &EntryLinks, token: Token) { - trace!( - "unlinking timeout; slot={}; token={:?}", - self.slot_for(links.tick), - token - ); + trace!("unlinking timeout; slot={}; token={:?}", + self.slot_for(links.tick), token); if links.prev == EMPTY { let slot = self.slot_for(links.tick); @@ -352,10 +333,7 @@ impl Timer { // Attempt to move the wakeup time forward trace!("advancing the wakeup time; target={}; curr={}", tick, curr); - let actual = - inner - .wakeup_state - .compare_and_swap(curr, tick as usize, Ordering::Release); + let actual = inner.wakeup_state.compare_and_swap(curr, tick as usize, Ordering::Release); if actual == curr { // Signal to the wakeup thread that the wakeup time has @@ -396,18 +374,9 @@ impl Default for Timer { } impl Evented for Timer { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { if self.inner.borrow().is_some() { - return Err(io::Error::new( - io::ErrorKind::Other, - "timer already registered", - )); + return Err(io::Error::new(io::ErrorKind::Other, "timer already registered")); } let (registration, set_readiness) = Registration::new(poll, token, interest, opts); @@ -415,18 +384,14 @@ impl Evented for Timer { let thread_handle = spawn_wakeup_thread( wakeup_state.clone(), set_readiness.clone(), - self.start, - self.tick_ms, - ); - - self.inner - .fill(Inner { - registration: registration, - set_readiness: set_readiness, - wakeup_state: wakeup_state, - wakeup_thread: thread_handle, - }).ok() - .expect("timer already registered"); + self.start, self.tick_ms); + + self.inner.fill(Inner { + registration: registration, + set_readiness: set_readiness, + wakeup_state: wakeup_state, + wakeup_thread: thread_handle, + }).ok().expect("timer already registered"); if let Some(next_tick) = self.next_tick() { self.schedule_readiness(next_tick); @@ -435,29 +400,17 @@ impl Evented for Timer { Ok(()) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { match self.inner.borrow() { Some(inner) => inner.registration.update(poll, token, interest, opts), - None => Err(io::Error::new( - io::ErrorKind::Other, - "receiver not registered", - )), + None => Err(io::Error::new(io::ErrorKind::Other, "receiver not registered")), } } fn deregister(&self, poll: &Poll) -> io::Result<()> { match self.inner.borrow() { Some(inner) => inner.registration.deregister(poll), - None => Err(io::Error::new( - io::ErrorKind::Other, - "receiver not registered", - )), + None => Err(io::Error::new(io::ErrorKind::Other, "receiver not registered")), } } } @@ -471,12 +424,7 @@ impl fmt::Debug for Inner { } } -fn spawn_wakeup_thread( - state: WakeupState, - set_readiness: SetReadiness, - start: Instant, - tick_ms: u64, -) -> thread::JoinHandle<()> { +fn spawn_wakeup_thread(state: WakeupState, set_readiness: SetReadiness, start: Instant, tick_ms: u64) -> thread::JoinHandle<()> { thread::spawn(move || { let mut sleep_until_tick = state.load(Ordering::Acquire) as Tick; @@ -487,11 +435,7 @@ fn spawn_wakeup_thread( let now_tick = current_tick(start, tick_ms); - trace!( - "wakeup thread: sleep_until_tick={:?}; now_tick={:?}", - sleep_until_tick, - now_tick - ); + trace!("wakeup thread: sleep_until_tick={:?}; now_tick={:?}", sleep_until_tick, now_tick); if now_tick < sleep_until_tick { // Calling park_timeout with u64::MAX leads to undefined @@ -500,29 +444,19 @@ fn spawn_wakeup_thread( // on large values, simply use a blocking park. match tick_ms.checked_mul(sleep_until_tick - now_tick) { Some(sleep_duration) => { - trace!( - "sleeping; tick_ms={}; now_tick={}; sleep_until_tick={}; duration={:?}", - tick_ms, - now_tick, - sleep_until_tick, - sleep_duration - ); + trace!("sleeping; tick_ms={}; now_tick={}; sleep_until_tick={}; duration={:?}", + tick_ms, now_tick, sleep_until_tick, sleep_duration); thread::park_timeout(Duration::from_millis(sleep_duration)); } None => { - trace!( - "sleeping; tick_ms={}; now_tick={}; blocking sleep", - tick_ms, - now_tick - ); + trace!("sleeping; tick_ms={}; now_tick={}; blocking sleep", + tick_ms, now_tick); thread::park(); } } sleep_until_tick = state.load(Ordering::Acquire) as Tick; } else { - let actual = - state.compare_and_swap(sleep_until_tick as usize, usize::MAX, Ordering::AcqRel) - as Tick; + let actual = state.compare_and_swap(sleep_until_tick as usize, usize::MAX, Ordering::AcqRel) as Tick; if actual == sleep_until_tick { trace!("setting readiness from wakeup thread"); diff --git a/src/udp.rs b/src/udp.rs index 3601061ce..a71bd2191 100644 --- a/src/udp.rs +++ b/src/udp.rs @@ -9,11 +9,11 @@ #![allow(deprecated)] -use event::Evented; +use {sys, Ready, Poll, PollOpt, Token}; use io::{self, MapNonBlock}; +use event::Evented; use poll::SelectorId; use std::net::{self, Ipv4Addr, Ipv6Addr, SocketAddr}; -use {sys, Poll, PollOpt, Ready, Token}; /// A User Datagram Protocol socket. /// @@ -61,10 +61,13 @@ impl UdpSocket { /// object references. Both handles will read and write the same port, and /// options set on one socket will be propagated to the other. pub fn try_clone(&self) -> io::Result { - self.sys.try_clone().map(|s| UdpSocket { - sys: s, - selector_id: self.selector_id.clone(), - }) + self.sys.try_clone() + .map(|s| { + UdpSocket { + sys: s, + selector_id: self.selector_id.clone(), + } + }) } /// Sends data on the socket to the given address. On success, returns the @@ -72,7 +75,8 @@ impl UdpSocket { /// /// Address type can be any implementor of `ToSocketAddrs` trait. See its /// documentation for concrete examples. - pub fn send_to(&self, buf: &[u8], target: &SocketAddr) -> io::Result> { + pub fn send_to(&self, buf: &[u8], target: &SocketAddr) + -> io::Result> { self.sys.send_to(buf, target).map_non_block() } @@ -87,13 +91,15 @@ impl UdpSocket { /// /// Assuming the function has read `n` bytes, slicing `&buf[..n]` provides /// efficient access with iterators and boundary checks. - pub fn recv_from(&self, buf: &mut [u8]) -> io::Result> { + pub fn recv_from(&self, buf: &mut [u8]) + -> io::Result> { self.sys.recv_from(buf).map_non_block() } /// Sends data on the socket to the address previously bound via connect(). On success, /// returns the number of bytes written. - pub fn send(&self, buf: &[u8]) -> io::Result> { + pub fn send(&self, buf: &[u8]) + -> io::Result> { self.sys.send(buf).map_non_block() } @@ -108,14 +114,16 @@ impl UdpSocket { /// /// Assuming the function has read `n` bytes, slicing `&buf[..n]` provides /// efficient access with iterators and boundary checks. - pub fn recv(&self, buf: &mut [u8]) -> io::Result> { + pub fn recv(&self, buf: &mut [u8]) + -> io::Result> { self.sys.recv(buf).map_non_block() } - /// Connects the UDP socket setting the default destination for `send()` + /// Connects the UDP socket setting the default destination for `send()` /// and limiting packets that are read via `recv` from the address specified /// in `addr`. - pub fn connect(&self, addr: SocketAddr) -> io::Result<()> { + pub fn connect(&self, addr: SocketAddr) + -> io::Result<()> { self.sys.connect(addr) } @@ -218,7 +226,9 @@ impl UdpSocket { /// address of the local interface with which the system should join the /// multicast group. If it's equal to `INADDR_ANY` then an appropriate /// interface is chosen by the system. - pub fn join_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> { + pub fn join_multicast_v4(&self, + multiaddr: &Ipv4Addr, + interface: &Ipv4Addr) -> io::Result<()> { self.sys.join_multicast_v4(multiaddr, interface) } @@ -227,7 +237,9 @@ impl UdpSocket { /// This function specifies a new multicast group for this socket to join. /// The address must be a valid multicast address, and `interface` is the /// index of the interface to join/leave (or 0 to indicate any interface). - pub fn join_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> { + pub fn join_multicast_v6(&self, + multiaddr: &Ipv6Addr, + interface: u32) -> io::Result<()> { self.sys.join_multicast_v6(multiaddr, interface) } @@ -237,7 +249,9 @@ impl UdpSocket { /// [`join_multicast_v4`][link]. /// /// [link]: #method.join_multicast_v4 - pub fn leave_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> { + pub fn leave_multicast_v4(&self, + multiaddr: &Ipv4Addr, + interface: &Ipv4Addr) -> io::Result<()> { self.sys.leave_multicast_v4(multiaddr, interface) } @@ -247,7 +261,9 @@ impl UdpSocket { /// [`join_multicast_v6`][link]. /// /// [link]: #method.join_multicast_v6 - pub fn leave_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> { + pub fn leave_multicast_v6(&self, + multiaddr: &Ipv6Addr, + interface: u32) -> io::Result<()> { self.sys.leave_multicast_v6(multiaddr, interface) } @@ -262,24 +278,12 @@ impl UdpSocket { } impl Evented for UdpSocket { - fn register( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.selector_id.associate_selector(poll)?; self.sys.register(poll, token, interest, opts) } - fn reregister( - &self, - poll: &Poll, - token: Token, - interest: Ready, - opts: PollOpt, - ) -> io::Result<()> { + fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> { self.sys.reregister(poll, token, interest, opts) } @@ -295,7 +299,7 @@ impl Evented for UdpSocket { */ #[cfg(all(unix, not(target_os = "fuchsia")))] -use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; +use std::os::unix::io::{IntoRawFd, AsRawFd, FromRawFd, RawFd}; #[cfg(all(unix, not(target_os = "fuchsia")))] impl IntoRawFd for UdpSocket { diff --git a/test/mod.rs b/test/mod.rs index 855ec4ee5..d88038eae 100644 --- a/test/mod.rs +++ b/test/mod.rs @@ -1,7 +1,7 @@ #![allow(deprecated)] -extern crate bytes; extern crate mio; +extern crate bytes; extern crate net2; #[macro_use] @@ -16,10 +16,9 @@ extern crate fuchsia_zircon as zircon; pub use ports::localhost; -mod test_close_on_drop; mod test_custom_evented; +mod test_close_on_drop; mod test_double_register; -mod test_drop_cancels_interest_and_shuts_down; mod test_echo_server; mod test_local_addr_ready; mod test_multicast; @@ -34,6 +33,7 @@ mod test_tcp_level; mod test_udp_level; mod test_udp_socket; mod test_write_then_drop; +mod test_drop_cancels_interest_and_shuts_down; #[cfg(feature = "with-deprecated")] mod test_notify; @@ -44,54 +44,41 @@ mod test_tick; // The following tests are for deprecated features. Only run these tests on // platforms that were supported from before the features were deprecated -#[cfg( - any( - target_os = "macos", - target_os = "linux", - target_os = "windows" - ) -)] -#[cfg(feature = "with-deprecated")] -mod test_battery; -#[cfg( - any( - target_os = "macos", - target_os = "linux", - target_os = "windows" - ) -)] +#[cfg(any(target_os = "macos", target_os = "linux", target_os = "windows"))] #[cfg(feature = "with-deprecated")] mod test_timer; +#[cfg(any(target_os = "macos", target_os = "linux", target_os = "windows"))] +#[cfg(feature = "with-deprecated")] +mod test_battery; #[cfg(any(target_os = "macos", target_os = "linux"))] #[cfg(feature = "with-deprecated")] -mod test_broken_pipe; +mod test_unix_echo_server; #[cfg(any(target_os = "macos", target_os = "linux"))] #[cfg(feature = "with-deprecated")] -mod test_subprocess_pipe; +mod test_unix_pass_fd; #[cfg(any(target_os = "macos", target_os = "linux"))] #[cfg(feature = "with-deprecated")] mod test_uds_shutdown; #[cfg(any(target_os = "macos", target_os = "linux"))] #[cfg(feature = "with-deprecated")] -mod test_unix_echo_server; +mod test_subprocess_pipe; #[cfg(any(target_os = "macos", target_os = "linux"))] #[cfg(feature = "with-deprecated")] -mod test_unix_pass_fd; +mod test_broken_pipe; #[cfg(any(target_os = "fuchsia"))] mod test_fuchsia_handles; use bytes::{Buf, MutBuf}; -use mio::event::Event; -use mio::{Events, Poll}; use std::io::{self, Read, Write}; use std::time::Duration; +use mio::{Events, Poll}; +use mio::event::Event; pub trait TryRead { fn try_read_buf(&mut self, buf: &mut B) -> io::Result> - where - Self: Sized, + where Self : Sized { // Reads the length of the slice supplied by buf.mut_bytes into the buffer // This is not guaranteed to consume an entire datagram or segment. @@ -101,9 +88,7 @@ pub trait TryRead { let res = self.try_read(unsafe { buf.mut_bytes() }); if let Ok(Some(cnt)) = res { - unsafe { - buf.advance(cnt); - } + unsafe { buf.advance(cnt); } } res @@ -114,8 +99,7 @@ pub trait TryRead { pub trait TryWrite { fn try_write_buf(&mut self, buf: &mut B) -> io::Result> - where - Self: Sized, + where Self : Sized { let res = self.try_write(buf.bytes()); @@ -174,8 +158,8 @@ impl MapNonBlock for io::Result { mod ports { use std::net::SocketAddr; use std::str::FromStr; - use std::sync::atomic::Ordering::SeqCst; use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT}; + use std::sync::atomic::Ordering::SeqCst; // Helper for getting a unique port for the task run // TODO: Reuse ports to not spam the system @@ -204,28 +188,24 @@ pub fn sleep_ms(ms: u64) { thread::sleep(Duration::from_millis(ms)); } -pub fn expect_events( - poll: &Poll, - event_buffer: &mut Events, - poll_try_count: usize, - mut expected: Vec, -) { +pub fn expect_events(poll: &Poll, + event_buffer: &mut Events, + poll_try_count: usize, + mut expected: Vec) +{ const MS: u64 = 1_000; for _ in 0..poll_try_count { - poll.poll(event_buffer, Some(Duration::from_millis(MS))) - .unwrap(); + poll.poll(event_buffer, Some(Duration::from_millis(MS))).unwrap(); for event in event_buffer.iter() { let pos_opt = match expected.iter().position(|exp_event| { - (event.token() == exp_event.token()) - && event.readiness().contains(exp_event.readiness()) + (event.token() == exp_event.token()) && + event.readiness().contains(exp_event.readiness()) }) { Some(x) => Some(x), None => None, }; - if let Some(pos) = pos_opt { - expected.remove(pos); - } + if let Some(pos) = pos_opt { expected.remove(pos); } } if expected.len() == 0 { @@ -233,9 +213,6 @@ pub fn expect_events( } } - assert!( - expected.len() == 0, - "The following expected events were not found: {:?}", - expected - ); + assert!(expected.len() == 0, "The following expected events were not found: {:?}", expected); } + diff --git a/test/test_battery.rs b/test/test_battery.rs index 741fd815a..d91819651 100644 --- a/test/test_battery.rs +++ b/test/test_battery.rs @@ -1,11 +1,11 @@ +use {localhost, sleep_ms, TryRead, TryWrite}; +use mio::*; use mio::deprecated::{EventLoop, EventLoopBuilder, Handler}; use mio::net::{TcpListener, TcpStream}; -use mio::*; -use slab::Slab; use std::collections::LinkedList; -use std::time::Duration; +use slab::Slab; use std::{io, thread}; -use {localhost, sleep_ms, TryRead, TryWrite}; +use std::time::Duration; // Don't touch the connection slab const SERVER: Token = Token(10_000_000); @@ -20,28 +20,26 @@ struct EchoConn { sock: TcpStream, token: Option, count: usize, - buf: Vec, + buf: Vec } impl EchoConn { fn new(sock: TcpStream) -> EchoConn { - let mut ec = EchoConn { + let mut ec = + EchoConn { sock: sock, token: None, buf: Vec::with_capacity(22), - count: 0, + count: 0 }; unsafe { ec.buf.set_len(22) }; ec } fn writable(&mut self, event_loop: &mut EventLoop) -> io::Result<()> { - event_loop.reregister( - &self.sock, - self.token.unwrap(), - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ) + event_loop.reregister(&self.sock, self.token.unwrap(), + Ready::readable(), + PollOpt::edge() | PollOpt::oneshot()) } fn readable(&mut self, event_loop: &mut EventLoop) -> io::Result<()> { @@ -62,21 +60,17 @@ impl EchoConn { Err(_) => { break; } + }; } - event_loop.reregister( - &self.sock, - self.token.unwrap(), - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ) + event_loop.reregister(&self.sock, self.token.unwrap(), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()) } } struct EchoServer { sock: TcpListener, - conns: Slab, + conns: Slab } impl EchoServer { @@ -84,29 +78,26 @@ impl EchoServer { debug!("server accepting socket"); let sock = self.sock.accept().unwrap().0; - let conn = EchoConn::new(sock); + let conn = EchoConn::new(sock,); let tok = self.conns.insert(conn); // Register the connection self.conns[tok].token = Some(Token(tok)); - event_loop - .register( - &self.conns[tok].sock, - Token(tok), - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ).ok() - .expect("could not register socket with event loop"); + event_loop.register(&self.conns[tok].sock, Token(tok), Ready::readable(), + PollOpt::edge() | PollOpt::oneshot()) + .ok().expect("could not register socket with event loop"); Ok(()) } - fn conn_readable(&mut self, event_loop: &mut EventLoop, tok: Token) -> io::Result<()> { + fn conn_readable(&mut self, event_loop: &mut EventLoop, + tok: Token) -> io::Result<()> { debug!("server conn readable; tok={:?}", tok); self.conn(tok).readable(event_loop) } - fn conn_writable(&mut self, event_loop: &mut EventLoop, tok: Token) -> io::Result<()> { + fn conn_writable(&mut self, event_loop: &mut EventLoop, + tok: Token) -> io::Result<()> { debug!("server conn writable; tok={:?}", tok); self.conn(tok).writable(event_loop) } @@ -120,17 +111,19 @@ struct EchoClient { sock: TcpStream, backlog: LinkedList, token: Token, - count: u32, + count: u32 } + // Sends a message and expects to receive the same exact message, one at a time impl EchoClient { fn new(sock: TcpStream, tok: Token) -> EchoClient { + EchoClient { sock: sock, backlog: LinkedList::new(), token: tok, - count: 0, + count: 0 } } @@ -142,10 +135,7 @@ impl EchoClient { debug!("client socket writable"); while self.backlog.len() > 0 { - match self - .sock - .try_write(self.backlog.front().unwrap().as_bytes()) - { + match self.sock.try_write(self.backlog.front().unwrap().as_bytes()) { Ok(None) => { break; } @@ -156,20 +146,12 @@ impl EchoClient { info!("Sent {} messages", self.count); } } - Err(e) => { - debug!("not implemented; client err={:?}", e); - break; - } + Err(e) => { debug!("not implemented; client err={:?}", e); break; } } } if self.backlog.len() > 0 { - event_loop - .reregister( - &self.sock, - self.token, - Ready::writable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + event_loop.reregister(&self.sock, self.token, Ready::writable(), + PollOpt::edge() | PollOpt::oneshot()).unwrap(); } Ok(()) @@ -197,19 +179,21 @@ impl Handler for Echo { type Timeout = usize; type Message = String; - fn ready(&mut self, event_loop: &mut EventLoop, token: Token, events: Ready) { + fn ready(&mut self, event_loop: &mut EventLoop, token: Token, + events: Ready) { + if events.is_readable() { match token { SERVER => self.server.accept(event_loop).unwrap(), CLIENT => self.client.readable(event_loop).unwrap(), - i => self.server.conn_readable(event_loop, i).unwrap(), + i => self.server.conn_readable(event_loop, i).unwrap() } } if events.is_writable() { match token { SERVER => panic!("received writable for token 0"), CLIENT => self.client.writable(event_loop).unwrap(), - _ => self.server.conn_writable(event_loop, token).unwrap(), + _ => self.server.conn_writable(event_loop, token).unwrap() } } } @@ -221,17 +205,15 @@ impl Handler for Echo { if self.client.count % 10000 == 0 { info!("Sent {} bytes: count {}", n, self.client.count); } - } + }, _ => { self.client.backlog.push_back(msg); - event_loop - .reregister( - &self.client.sock, - self.client.token, - Ready::writable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + event_loop.reregister( + &self.client.sock, + self.client.token, + Ready::writable(), + PollOpt::edge() | PollOpt::oneshot()).unwrap(); } } } @@ -254,24 +236,14 @@ pub fn test_echo_server() { let srv = TcpListener::bind(&addr).unwrap(); info!("listen for connections"); - event_loop - .register( - &srv, - SERVER, - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + event_loop.register(&srv, SERVER, Ready::readable(), + PollOpt::edge() | PollOpt::oneshot()).unwrap(); let sock = TcpStream::connect(&addr).unwrap(); // Connect to the server - event_loop - .register( - &sock, - CLIENT, - Ready::writable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + event_loop.register(&sock, CLIENT, Ready::writable(), + PollOpt::edge() | PollOpt::oneshot()).unwrap(); let chan = event_loop.channel(); let go = move || { diff --git a/test/test_broken_pipe.rs b/test/test_broken_pipe.rs index 44f26ce7e..1cd0ca746 100644 --- a/test/test_broken_pipe.rs +++ b/test/test_broken_pipe.rs @@ -1,5 +1,5 @@ +use mio::{Token, Ready, PollOpt}; use mio::deprecated::{unix, EventLoop, Handler}; -use mio::{PollOpt, Ready, Token}; use std::time::Duration; pub struct BrokenPipeHandler; @@ -19,13 +19,10 @@ pub fn broken_pipe() { let mut event_loop: EventLoop = EventLoop::new().unwrap(); let (reader, _) = unix::pipe().unwrap(); - event_loop - .register(&reader, Token(1), Ready::all(), PollOpt::edge()) - .unwrap(); + event_loop.register(&reader, Token(1), Ready::all(), PollOpt::edge()) + .unwrap(); let mut handler = BrokenPipeHandler; drop(reader); - event_loop - .run_once(&mut handler, Some(Duration::from_millis(1000))) - .unwrap(); + event_loop.run_once(&mut handler, Some(Duration::from_millis(1000))).unwrap(); } diff --git a/test/test_close_on_drop.rs b/test/test_close_on_drop.rs index f35e6d8c6..c429d3bf2 100644 --- a/test/test_close_on_drop.rs +++ b/test/test_close_on_drop.rs @@ -1,9 +1,9 @@ +use {localhost, TryRead}; +use mio::{Events, Poll, PollOpt, Ready, Token}; use bytes::ByteBuf; use mio::net::{TcpListener, TcpStream}; -use mio::{Events, Poll, PollOpt, Ready, Token}; -use {localhost, TryRead}; -use self::TestState::{AfterRead, Initial}; +use self::TestState::{Initial, AfterRead}; const SERVER: Token = Token(0); const CLIENT: Token = Token(1); @@ -47,7 +47,7 @@ impl TestHandler { let mut buf = [0; 4096]; debug!("GOT={:?}", self.cli.try_read(&mut buf[..])); self.state = AfterRead; - } + }, AfterRead => {} } @@ -56,13 +56,12 @@ impl TestHandler { match self.cli.try_read_buf(&mut buf) { Ok(Some(0)) => self.shutdown = true, Ok(_) => panic!("the client socket should not be readable"), - Err(e) => panic!("Unexpected error {:?}", e), + Err(e) => panic!("Unexpected error {:?}", e) } } - _ => panic!("received unknown token {:?}", tok), + _ => panic!("received unknown token {:?}", tok) } - poll.reregister(&self.cli, CLIENT, Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.reregister(&self.cli, CLIENT, Ready::readable(), PollOpt::edge()).unwrap(); } fn handle_write(&mut self, poll: &mut Poll, tok: Token, _: Ready) { @@ -70,10 +69,9 @@ impl TestHandler { SERVER => panic!("received writable for token 0"), CLIENT => { debug!("client connected"); - poll.reregister(&self.cli, CLIENT, Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.reregister(&self.cli, CLIENT, Ready::readable(), PollOpt::edge()).unwrap(); } - _ => panic!("received unknown token {:?}", tok), + _ => panic!("received unknown token {:?}", tok) } } } @@ -90,14 +88,12 @@ pub fn test_close_on_drop() { // == Create & setup server socket let srv = TcpListener::bind(&addr).unwrap(); - poll.register(&srv, SERVER, Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&srv, SERVER, Ready::readable(), PollOpt::edge()).unwrap(); // == Create & setup client socket let sock = TcpStream::connect(&addr).unwrap(); - poll.register(&sock, CLIENT, Ready::writable(), PollOpt::edge()) - .unwrap(); + poll.register(&sock, CLIENT, Ready::writable(), PollOpt::edge()).unwrap(); // == Create storage for events let mut events = Events::with_capacity(1024); diff --git a/test/test_custom_evented.rs b/test/test_custom_evented.rs index 14af2e523..8c996f4a7 100644 --- a/test/test_custom_evented.rs +++ b/test/test_custom_evented.rs @@ -1,5 +1,5 @@ -use mio::event::Evented; use mio::{Events, Poll, PollOpt, Ready, Registration, SetReadiness, Token}; +use mio::event::Evented; use std::time::Duration; #[test] @@ -8,19 +8,14 @@ fn smoke() { let mut events = Events::with_capacity(128); let (r, set) = Registration::new2(); - r.register(&poll, Token(0), Ready::readable(), PollOpt::edge()) - .unwrap(); + r.register(&poll, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); - let n = poll - .poll(&mut events, Some(Duration::from_millis(0))) - .unwrap(); + let n = poll.poll(&mut events, Some(Duration::from_millis(0))).unwrap(); assert_eq!(n, 0); set.set_readiness(Ready::readable()).unwrap(); - let n = poll - .poll(&mut events, Some(Duration::from_millis(0))) - .unwrap(); + let n = poll.poll(&mut events, Some(Duration::from_millis(0))).unwrap(); assert_eq!(n, 1); assert_eq!(events.get(0).unwrap().token(), Token(0)); @@ -52,8 +47,7 @@ fn set_readiness_before_register() { b1.wait(); // now register - poll.register(&r, Token(123), Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&r, Token(123), Ready::readable(), PollOpt::edge()).unwrap(); loop { let n = poll.poll(&mut events, None).unwrap(); @@ -71,23 +65,17 @@ fn set_readiness_before_register() { } } -#[cfg( - any( - target_os = "linux", - target_os = "macos", - target_os = "windows" - ) -)] +#[cfg(any(target_os = "linux", target_os = "macos", target_os = "windows"))] mod stress { - use mio::event::Evented; use mio::{Events, Poll, PollOpt, Ready, Registration, SetReadiness, Token}; + use mio::event::Evented; use std::time::Duration; #[test] fn single_threaded_poll() { + use std::sync::Arc; use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering::{Acquire, Release}; - use std::sync::Arc; use std::thread; const NUM_ATTEMPTS: usize = 30; @@ -99,13 +87,11 @@ mod stress { let poll = Poll::new().unwrap(); let mut events = Events::with_capacity(NUM_REGISTRATIONS); - let registrations: Vec<_> = (0..NUM_REGISTRATIONS) - .map(|i| { - let (r, s) = Registration::new2(); - r.register(&poll, Token(i), Ready::readable(), PollOpt::edge()) - .unwrap(); - (r, s) - }).collect(); + let registrations: Vec<_> = (0..NUM_REGISTRATIONS).map(|i| { + let (r, s) = Registration::new2(); + r.register(&poll, Token(i), Ready::readable(), PollOpt::edge()).unwrap(); + (r, s) + }).collect(); let mut ready: Vec<_> = (0..NUM_REGISTRATIONS).map(|_| Ready::empty()).collect(); @@ -123,9 +109,7 @@ mod stress { set_readiness[i].set_readiness(Ready::readable()).unwrap(); set_readiness[i].set_readiness(Ready::empty()).unwrap(); set_readiness[i].set_readiness(Ready::writable()).unwrap(); - set_readiness[i] - .set_readiness(Ready::readable() | Ready::writable()) - .unwrap(); + set_readiness[i].set_readiness(Ready::readable() | Ready::writable()).unwrap(); set_readiness[i].set_readiness(Ready::empty()).unwrap(); } } @@ -141,12 +125,10 @@ mod stress { while remaining.load(Acquire) > 0 { // Set interest for (i, &(ref r, _)) in registrations.iter().enumerate() { - r.reregister(&poll, Token(i), Ready::writable(), PollOpt::edge()) - .unwrap(); + r.reregister(&poll, Token(i), Ready::writable(), PollOpt::edge()).unwrap(); } - poll.poll(&mut events, Some(Duration::from_millis(0))) - .unwrap(); + poll.poll(&mut events, Some(Duration::from_millis(0))).unwrap(); for event in &events { ready[event.token().0] = event.readiness(); @@ -155,16 +137,14 @@ mod stress { // Update registration // Set interest for (i, &(ref r, _)) in registrations.iter().enumerate() { - r.reregister(&poll, Token(i), Ready::readable(), PollOpt::edge()) - .unwrap(); + r.reregister(&poll, Token(i), Ready::readable(), PollOpt::edge()).unwrap(); } } // Finall polls, repeat until readiness-queue empty loop { // Might not read all events from custom-event-queue at once, implementation dependend - poll.poll(&mut events, Some(Duration::from_millis(0))) - .unwrap(); + poll.poll(&mut events, Some(Duration::from_millis(0))).unwrap(); if events.is_empty() { // no more events in readiness queue pending break; @@ -183,9 +163,9 @@ mod stress { #[test] fn multi_threaded_poll() { - use std::sync::atomic::AtomicUsize; - use std::sync::atomic::Ordering::{Relaxed, SeqCst}; use std::sync::{Arc, Barrier}; + use std::sync::atomic::{AtomicUsize}; + use std::sync::atomic::Ordering::{Relaxed, SeqCst}; use std::thread; const ENTRIES: usize = 10_000; @@ -212,9 +192,7 @@ mod stress { // Create entries for i in 0..ENTRIES { let (registration, set_readiness) = Registration::new2(); - registration - .register(&poll, Token(i), Ready::readable(), PollOpt::edge()) - .unwrap(); + registration.register(&poll, Token(i), Ready::readable(), PollOpt::edge()).unwrap(); entries.push(Entry { registration: registration, @@ -249,13 +227,12 @@ mod stress { let mut n = 0; + while total.load(SeqCst) < NUM { // A poll timeout is necessary here because there may be more // than one threads blocked in `poll` when the final wakeup // notification arrives (and only notifies one thread). - n += poll - .poll(&mut events, Some(Duration::from_millis(100))) - .unwrap(); + n += poll.poll(&mut events, Some(Duration::from_millis(100))).unwrap(); let mut num_this_tick = 0; @@ -288,7 +265,9 @@ mod stress { })); } - let _: Vec<_> = threads.into_iter().map(|th| th.join().unwrap()).collect(); + let _: Vec<_> = threads.into_iter() + .map(|th| th.join().unwrap()) + .collect(); for entry in entries.iter() { assert_eq!(PER_ENTRY, entry.num.load(Relaxed)); @@ -300,9 +279,9 @@ mod stress { const N: usize = 8; const ITER: usize = 1_000; + use std::sync::{Arc, Barrier}; use std::sync::atomic::AtomicBool; use std::sync::atomic::Ordering::{Acquire, Release}; - use std::sync::{Arc, Barrier}; use std::thread; let poll = Poll::new().unwrap(); @@ -313,8 +292,7 @@ mod stress { for i in 0..N { let (registration, set_readiness) = Registration::new2(); - poll.register(®istration, Token(i), Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(®istration, Token(i), Ready::readable(), PollOpt::edge()).unwrap(); registrations.push(registration); @@ -345,6 +323,7 @@ mod stress { let mut final_ready = vec![false; N]; + for _ in 0..5 { poll.poll(&mut events, None).unwrap(); @@ -365,8 +344,8 @@ mod stress { #[test] fn drop_registration_from_non_main_thread() { - use std::sync::mpsc::channel; use std::thread; + use std::sync::mpsc::channel; const THREADS: usize = 8; const ITERS: usize = 50_000; @@ -393,13 +372,7 @@ fn drop_registration_from_non_main_thread() { let mut index: usize = 0; for _ in 0..ITERS { let (registration, set_readiness) = Registration::new2(); - registration - .register( - &mut poll, - Token(token_index), - Ready::readable(), - PollOpt::edge(), - ).unwrap(); + registration.register(&mut poll, Token(token_index), Ready::readable(), PollOpt::edge()).unwrap(); let _ = senders[index].send((registration, set_readiness)); token_index += 1; @@ -408,13 +381,7 @@ fn drop_registration_from_non_main_thread() { index = 0; let (registration, set_readiness) = Registration::new2(); - registration - .register( - &mut poll, - Token(token_index), - Ready::readable(), - PollOpt::edge(), - ).unwrap(); + registration.register(&mut poll, Token(token_index), Ready::readable(), PollOpt::edge()).unwrap(); let _ = set_readiness.set_readiness(Ready::readable()); drop(registration); drop(set_readiness); diff --git a/test/test_double_register.rs b/test/test_double_register.rs index 6c95d12ea..c3d011c81 100644 --- a/test/test_double_register.rs +++ b/test/test_double_register.rs @@ -3,8 +3,8 @@ #[test] #[cfg(any(target_os = "linux", target_os = "windows"))] pub fn test_double_register() { - use mio::net::TcpListener; use mio::*; + use mio::net::TcpListener; let poll = Poll::new().unwrap(); @@ -12,10 +12,6 @@ pub fn test_double_register() { let l = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); // Register the listener with `Poll` - poll.register(&l, Token(0), Ready::readable(), PollOpt::edge()) - .unwrap(); - assert!( - poll.register(&l, Token(1), Ready::readable(), PollOpt::edge()) - .is_err() - ); + poll.register(&l, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); + assert!(poll.register(&l, Token(1), Ready::readable(), PollOpt::edge()).is_err()); } diff --git a/test/test_drop_cancels_interest_and_shuts_down.rs b/test/test_drop_cancels_interest_and_shuts_down.rs index 9a3288aef..e03fe2d14 100644 --- a/test/test_drop_cancels_interest_and_shuts_down.rs +++ b/test/test_drop_cancels_interest_and_shuts_down.rs @@ -10,7 +10,7 @@ fn drop_cancels_interest_and_shuts_down() { use env_logger; let _ = env_logger::init(); - let l = TcpListener::bind("127.0.0.1:0").unwrap(); + let l = TcpListener::bind("127.0.0.1:18000").unwrap(); let addr = l.local_addr().unwrap(); let t = thread::spawn(move || { @@ -22,6 +22,7 @@ fn drop_cancels_interest_and_shuts_down() { Ok(_) => (), Err(e) => { if e.kind() != io::ErrorKind::UnexpectedEof { + eprintln!("{}", e); panic!(e); } } diff --git a/test/test_echo_server.rs b/test/test_echo_server.rs index be4d934ab..c0eda942b 100644 --- a/test/test_echo_server.rs +++ b/test/test_echo_server.rs @@ -1,9 +1,9 @@ -use bytes::{Buf, ByteBuf, MutByteBuf, SliceBuf}; -use mio::net::{TcpListener, TcpStream}; +use {localhost, TryRead, TryWrite}; use mio::{Events, Poll, PollOpt, Ready, Token}; +use mio::net::{TcpListener, TcpStream}; +use bytes::{Buf, ByteBuf, MutByteBuf, SliceBuf}; use slab::Slab; use std::io; -use {localhost, TryRead, TryWrite}; const SERVER: Token = Token(10_000_000); const CLIENT: Token = Token(10_000_001); @@ -13,7 +13,7 @@ struct EchoConn { buf: Option, mut_buf: Option, token: Option, - interest: Ready, + interest: Ready } impl EchoConn { @@ -48,17 +48,9 @@ impl EchoConn { Err(e) => debug!("not implemented; client err={:?}", e), } - assert!( - self.interest.is_readable() || self.interest.is_writable(), - "actual={:?}", - self.interest - ); - poll.reregister( - &self.sock, - self.token.unwrap(), - self.interest, - PollOpt::edge() | PollOpt::oneshot(), - ) + assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); + poll.reregister(&self.sock, self.token.unwrap(), self.interest, + PollOpt::edge() | PollOpt::oneshot()) } fn readable(&mut self, poll: &mut Poll) -> io::Result<()> { @@ -82,25 +74,18 @@ impl EchoConn { debug!("not implemented; client err={:?}", e); self.interest.remove(Ready::readable()); } + }; - assert!( - self.interest.is_readable() || self.interest.is_writable(), - "actual={:?}", - self.interest - ); - poll.reregister( - &self.sock, - self.token.unwrap(), - self.interest, - PollOpt::edge(), - ) + assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); + poll.reregister(&self.sock, self.token.unwrap(), self.interest, + PollOpt::edge()) } } struct EchoServer { sock: TcpListener, - conns: Slab, + conns: Slab } impl EchoServer { @@ -108,28 +93,26 @@ impl EchoServer { debug!("server accepting socket"); let sock = self.sock.accept().unwrap().0; - let conn = EchoConn::new(sock); + let conn = EchoConn::new(sock,); let tok = self.conns.insert(conn); // Register the connection self.conns[tok].token = Some(Token(tok)); - poll.register( - &self.conns[tok].sock, - Token(tok), - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ).ok() - .expect("could not register socket with event loop"); + poll.register(&self.conns[tok].sock, Token(tok), Ready::readable(), + PollOpt::edge() | PollOpt::oneshot()) + .ok().expect("could not register socket with event loop"); Ok(()) } - fn conn_readable(&mut self, poll: &mut Poll, tok: Token) -> io::Result<()> { + fn conn_readable(&mut self, poll: &mut Poll, + tok: Token) -> io::Result<()> { debug!("server conn readable; tok={:?}", tok); self.conn(tok).readable(poll) } - fn conn_writable(&mut self, poll: &mut Poll, tok: Token) -> io::Result<()> { + fn conn_writable(&mut self, poll: &mut Poll, + tok: Token) -> io::Result<()> { debug!("server conn writable; tok={:?}", tok); self.conn(tok).writable(poll) } @@ -150,9 +133,10 @@ struct EchoClient { shutdown: bool, } + // Sends a message and expects to receive the same exact message, one at a time impl EchoClient { - fn new(sock: TcpStream, tok: Token, mut msgs: Vec<&'static str>) -> EchoClient { + fn new(sock: TcpStream, tok: Token, mut msgs: Vec<&'static str>) -> EchoClient { let curr = msgs.remove(0); EchoClient { @@ -204,17 +188,9 @@ impl EchoClient { }; if !self.interest.is_empty() { - assert!( - self.interest.is_readable() || self.interest.is_writable(), - "actual={:?}", - self.interest - ); - poll.reregister( - &self.sock, - self.token, - self.interest, - PollOpt::edge() | PollOpt::oneshot(), - )?; + assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); + poll.reregister(&self.sock, self.token, self.interest, + PollOpt::edge() | PollOpt::oneshot())?; } Ok(()) @@ -233,16 +209,12 @@ impl EchoClient { self.interest.insert(Ready::readable()); self.interest.remove(Ready::writable()); } - Err(e) => debug!("not implemented; client err={:?}", e), + Err(e) => debug!("not implemented; client err={:?}", e) } if self.interest.is_readable() || self.interest.is_writable() { - try!(poll.reregister( - &self.sock, - self.token, - self.interest, - PollOpt::edge() | PollOpt::oneshot() - )); + try!(poll.reregister(&self.sock, self.token, self.interest, + PollOpt::edge() | PollOpt::oneshot())); } Ok(()) @@ -261,12 +233,8 @@ impl EchoClient { self.rx = SliceBuf::wrap(curr.as_bytes()); self.interest.insert(Ready::writable()); - poll.reregister( - &self.sock, - self.token, - self.interest, - PollOpt::edge() | PollOpt::oneshot(), - ) + poll.reregister(&self.sock, self.token, self.interest, + PollOpt::edge() | PollOpt::oneshot()) } } @@ -280,9 +248,9 @@ impl Echo { Echo { server: EchoServer { sock: srv, - conns: Slab::with_capacity(128), + conns: Slab::with_capacity(128) }, - client: EchoClient::new(client, CLIENT, msgs), + client: EchoClient::new(client, CLIENT, msgs) } } } @@ -296,22 +264,14 @@ pub fn test_echo_server() { let srv = TcpListener::bind(&addr).unwrap(); info!("listen for connections"); - poll.register( - &srv, - SERVER, - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + poll.register(&srv, SERVER, Ready::readable(), + PollOpt::edge() | PollOpt::oneshot()).unwrap(); let sock = TcpStream::connect(&addr).unwrap(); // Connect to the server - poll.register( - &sock, - CLIENT, - Ready::writable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + poll.register(&sock, CLIENT, Ready::writable(), + PollOpt::edge() | PollOpt::oneshot()).unwrap(); // == Create storage for events let mut events = Events::with_capacity(1024); @@ -327,7 +287,7 @@ pub fn test_echo_server() { match event.token() { SERVER => handler.server.accept(&mut poll).unwrap(), CLIENT => handler.client.readable(&mut poll).unwrap(), - i => handler.server.conn_readable(&mut poll, i).unwrap(), + i => handler.server.conn_readable(&mut poll, i).unwrap() } } @@ -335,7 +295,7 @@ pub fn test_echo_server() { match event.token() { SERVER => panic!("received writable for token 0"), CLIENT => handler.client.writable(&mut poll).unwrap(), - i => handler.server.conn_writable(&mut poll, i).unwrap(), + i => handler.server.conn_writable(&mut poll, i).unwrap() }; } } diff --git a/test/test_fuchsia_handles.rs b/test/test_fuchsia_handles.rs index 56578a07e..85a14327f 100644 --- a/test/test_fuchsia_handles.rs +++ b/test/test_fuchsia_handles.rs @@ -1,7 +1,7 @@ -use mio::fuchsia::EventedHandle; use mio::*; -use std::time::Duration; +use mio::fuchsia::EventedHandle; use zircon::{self, AsHandleRef}; +use std::time::Duration; const MS: u64 = 1_000; @@ -14,24 +14,17 @@ pub fn test_fuchsia_channel() { let (channel0, channel1) = zircon::Channel::create(zircon::ChannelOpts::Normal).unwrap(); let channel1_evented = unsafe { EventedHandle::new(channel1.raw_handle()) }; - poll.register( - &channel1_evented, - Token(1), - Ready::readable(), - PollOpt::edge(), - ).unwrap(); + poll.register(&channel1_evented, Token(1), Ready::readable(), PollOpt::edge()).unwrap(); - poll.poll(event_buffer, Some(Duration::from_millis(MS))) - .unwrap(); + poll.poll(event_buffer, Some(Duration::from_millis(MS))).unwrap(); assert_eq!(event_buffer.len(), 0); channel0.write(&[1, 2, 3], &mut vec![], 0).unwrap(); - poll.poll(event_buffer, Some(Duration::from_millis(MS))) - .unwrap(); + poll.poll(event_buffer, Some(Duration::from_millis(MS))).unwrap(); let event = event_buffer.get(0).unwrap(); assert_eq!(event.token(), Token(1)); assert!(event.readiness().is_readable()); poll.deregister(&channel1_evented).unwrap(); -} +} \ No newline at end of file diff --git a/test/test_local_addr_ready.rs b/test/test_local_addr_ready.rs index 3ebb1bdf4..2e97f5244 100644 --- a/test/test_local_addr_ready.rs +++ b/test/test_local_addr_ready.rs @@ -1,6 +1,6 @@ -use mio::net::{TcpListener, TcpStream}; +use {TryWrite}; use mio::{Events, Poll, PollOpt, Ready, Token}; -use TryWrite; +use mio::net::{TcpListener, TcpStream}; const LISTEN: Token = Token(0); const CLIENT: Token = Token(1); @@ -20,12 +20,12 @@ fn local_addr_ready() { let addr = server.local_addr().unwrap(); let poll = Poll::new().unwrap(); - poll.register(&server, LISTEN, Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&server, LISTEN, Ready::readable(), + PollOpt::edge()).unwrap(); let sock = TcpStream::connect(&addr).unwrap(); - poll.register(&sock, CLIENT, Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&sock, CLIENT, Ready::readable(), + PollOpt::edge()).unwrap(); let mut events = Events::with_capacity(1024); @@ -43,19 +43,16 @@ fn local_addr_ready() { match event.token() { LISTEN => { let sock = handler.listener.accept().unwrap().0; - poll.register(&sock, SERVER, Ready::writable(), PollOpt::edge()) - .unwrap(); + poll.register(&sock, + SERVER, + Ready::writable(), + PollOpt::edge()).unwrap(); handler.accepted = Some(sock); } SERVER => { handler.accepted.as_ref().unwrap().peer_addr().unwrap(); handler.accepted.as_ref().unwrap().local_addr().unwrap(); - handler - .accepted - .as_mut() - .unwrap() - .try_write(&[1, 2, 3]) - .unwrap(); + handler.accepted.as_mut().unwrap().try_write(&[1, 2, 3]).unwrap(); handler.accepted = None; } CLIENT => { diff --git a/test/test_multicast.rs b/test/test_multicast.rs index ad0e37aab..09efcbd7a 100644 --- a/test/test_multicast.rs +++ b/test/test_multicast.rs @@ -2,12 +2,12 @@ // Figure out why! #![cfg(not(target_os = "android"))] -use bytes::{Buf, MutBuf, RingBuf, SliceBuf}; -use localhost; -use mio::net::UdpSocket; use mio::{Events, Poll, PollOpt, Ready, Token}; -use std::net::IpAddr; +use mio::net::UdpSocket; +use bytes::{Buf, MutBuf, RingBuf, SliceBuf}; use std::str; +use std::net::IpAddr; +use localhost; const LISTENER: Token = Token(0); const SENDER: Token = Token(1); @@ -42,17 +42,15 @@ impl UdpHandler { debug!("We are receiving a datagram now..."); match unsafe { self.rx.recv_from(self.rx_buf.mut_bytes()) } { Ok((cnt, addr)) => { - unsafe { - MutBuf::advance(&mut self.rx_buf, cnt); - } + unsafe { MutBuf::advance(&mut self.rx_buf, cnt); } assert_eq!(addr.ip(), self.localhost); } res => panic!("unexpected result: {:?}", res), } assert!(str::from_utf8(self.rx_buf.bytes()).unwrap() == self.msg); self.shutdown = true; - } - _ => (), + }, + _ => () } } @@ -62,8 +60,8 @@ impl UdpHandler { let addr = self.rx.local_addr().unwrap(); let cnt = self.tx.send_to(self.buf.bytes(), &addr).unwrap(); self.buf.advance(cnt); - } - _ => (), + }, + _ => () } } } @@ -82,20 +80,16 @@ pub fn test_multicast() { info!("Joining group 227.1.1.100"); let any = "0.0.0.0".parse().unwrap(); - rx.join_multicast_v4(&"227.1.1.100".parse().unwrap(), &any) - .unwrap(); + rx.join_multicast_v4(&"227.1.1.100".parse().unwrap(), &any).unwrap(); info!("Joining group 227.1.1.101"); - rx.join_multicast_v4(&"227.1.1.101".parse().unwrap(), &any) - .unwrap(); + rx.join_multicast_v4(&"227.1.1.101".parse().unwrap(), &any).unwrap(); info!("Registering SENDER"); - poll.register(&tx, SENDER, Ready::writable(), PollOpt::edge()) - .unwrap(); + poll.register(&tx, SENDER, Ready::writable(), PollOpt::edge()).unwrap(); info!("Registering LISTENER"); - poll.register(&rx, LISTENER, Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&rx, LISTENER, Ready::readable(), PollOpt::edge()).unwrap(); let mut events = Events::with_capacity(1024); diff --git a/test/test_notify.rs b/test/test_notify.rs index 137285d9d..c2b36b5cd 100644 --- a/test/test_notify.rs +++ b/test/test_notify.rs @@ -1,19 +1,19 @@ -use mio::deprecated::{EventLoop, EventLoopBuilder, Handler, NotifyError, Sender}; -use mio::net::TcpListener; +use {localhost, sleep_ms}; use mio::*; +use mio::deprecated::{EventLoop, EventLoopBuilder, Handler, Sender, NotifyError}; +use mio::net::TcpListener; use std::thread; -use {localhost, sleep_ms}; struct TestHandler { sender: Sender, - notify: usize, + notify: usize } impl TestHandler { fn new(sender: Sender) -> TestHandler { TestHandler { sender: sender, - notify: 0, + notify: 0 } } } @@ -32,7 +32,7 @@ impl Handler for TestHandler { assert!(msg == "Second", "actual={}", msg); event_loop.shutdown(); } - v => panic!("unexpected value for notify; val={}", v), + v => panic!("unexpected value for notify; val={}", v) } self.notify += 1; @@ -49,13 +49,7 @@ pub fn test_notify() { // Setup a server socket so that the event loop blocks let srv = TcpListener::bind(&addr).unwrap(); - event_loop - .register( - &srv, - Token(0), - Ready::readable() | Ready::writable(), - PollOpt::edge(), - ).unwrap(); + event_loop.register(&srv, Token(0), Ready::readable() | Ready::writable(), PollOpt::edge()).unwrap(); let sender = event_loop.channel(); @@ -126,7 +120,7 @@ pub fn test_notify_capacity() { #[test] pub fn test_notify_drop() { - use std::sync::mpsc::{self, Sender}; + use std::sync::mpsc::{self,Sender}; use std::thread; struct MessageDrop(Sender); diff --git a/test/test_oneshot.rs b/test/test_oneshot.rs index 09c9ac652..4dca219b7 100644 --- a/test/test_oneshot.rs +++ b/test/test_oneshot.rs @@ -1,5 +1,5 @@ -use mio::net::{TcpListener, TcpStream}; use mio::*; +use mio::net::{TcpListener, TcpStream}; use std::io::*; use std::time::Duration; @@ -16,24 +16,17 @@ pub fn test_tcp_edge_oneshot() { let l = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); // Register the listener with `Poll` - poll.register(&l, Token(0), Ready::readable(), PollOpt::level()) - .unwrap(); + poll.register(&l, Token(0), Ready::readable(), PollOpt::level()).unwrap(); // Connect a socket, we are going to write to it let mut s1 = TcpStream::connect(&l.local_addr().unwrap()).unwrap(); - poll.register(&s1, Token(1), Ready::writable(), PollOpt::level()) - .unwrap(); + poll.register(&s1, Token(1), Ready::writable(), PollOpt::level()).unwrap(); wait_for(&mut poll, &mut events, Token(0)); // Get pair let (mut s2, _) = l.accept().unwrap(); - poll.register( - &s2, - Token(2), - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + poll.register(&s2, Token(2), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); wait_for(&mut poll, &mut events, Token(1)); @@ -48,20 +41,10 @@ pub fn test_tcp_edge_oneshot() { assert_eq!(1, s2.read(&mut buf).unwrap()); assert_eq!(*byte, buf[0]); - poll.reregister( - &s2, - Token(2), - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + poll.reregister(&s2, Token(2), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); if *byte == b'o' { - poll.reregister( - &s2, - Token(2), - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + poll.reregister(&s2, Token(2), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); } } } @@ -70,19 +53,12 @@ fn wait_for(poll: &mut Poll, events: &mut Events, token: Token) { loop { poll.poll(events, Some(Duration::from_millis(MS))).unwrap(); - let cnt = (0..events.len()) - .map(|i| events.get(i).unwrap()) - .filter(|e| e.token() == token) - .count(); + let cnt = (0..events.len()).map(|i| events.get(i).unwrap()) + .filter(|e| e.token() == token) + .count(); - assert!( - cnt < 2, - "token appeared multiple times in poll results; cnt={:}", - cnt - ); + assert!(cnt < 2, "token appeared multiple times in poll results; cnt={:}", cnt); - if cnt == 1 { - return; - }; + if cnt == 1 { return }; } } diff --git a/test/test_poll.rs b/test/test_poll.rs index bbabdee1b..e259d89e2 100644 --- a/test/test_poll.rs +++ b/test/test_poll.rs @@ -8,10 +8,8 @@ fn test_poll_closes_fd() { let mut events = Events::with_capacity(4); let (registration, set_readiness) = Registration::new2(); - poll.register(®istration, Token(0), Ready::readable(), PollOpt::edge()) - .unwrap(); - poll.poll(&mut events, Some(Duration::from_millis(0))) - .unwrap(); + poll.register(®istration, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); + poll.poll(&mut events, Some(Duration::from_millis(0))).unwrap(); drop(poll); drop(set_readiness); diff --git a/test/test_poll_channel.rs b/test/test_poll_channel.rs index d3cf1089a..f7ce05053 100644 --- a/test/test_poll_channel.rs +++ b/test/test_poll_channel.rs @@ -1,9 +1,9 @@ -use mio::event::Event; +use {expect_events, sleep_ms}; use mio::{channel, Events, Poll, PollOpt, Ready, Token}; +use mio::event::Event; use std::sync::mpsc::TryRecvError; use std::thread; use std::time::Duration; -use {expect_events, sleep_ms}; #[test] pub fn test_poll_channel_edge() { @@ -11,22 +11,17 @@ pub fn test_poll_channel_edge() { let mut events = Events::with_capacity(1024); let (tx, rx) = channel::channel(); - poll.register(&rx, Token(123), Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&rx, Token(123), Ready::readable(), PollOpt::edge()).unwrap(); // Wait, but nothing should happen - let num = poll - .poll(&mut events, Some(Duration::from_millis(300))) - .unwrap(); + let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); assert_eq!(0, num); // Push the value tx.send("hello").unwrap(); // Polling will contain the event - let num = poll - .poll(&mut events, Some(Duration::from_millis(300))) - .unwrap(); + let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); assert_eq!(1, num); let event = events.get(0).unwrap(); @@ -34,27 +29,21 @@ pub fn test_poll_channel_edge() { assert_eq!(event.readiness(), Ready::readable()); // Poll again and there should be no events - let num = poll - .poll(&mut events, Some(Duration::from_millis(300))) - .unwrap(); + let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); assert_eq!(0, num); // Read the value assert_eq!("hello", rx.try_recv().unwrap()); // Poll again, nothing - let num = poll - .poll(&mut events, Some(Duration::from_millis(300))) - .unwrap(); + let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); assert_eq!(0, num); // Push a value tx.send("goodbye").unwrap(); // Have an event - let num = poll - .poll(&mut events, Some(Duration::from_millis(300))) - .unwrap(); + let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); assert_eq!(1, num); let event = events.get(0).unwrap(); @@ -67,9 +56,7 @@ pub fn test_poll_channel_edge() { // Drop the sender half drop(tx); - let num = poll - .poll(&mut events, Some(Duration::from_millis(300))) - .unwrap(); + let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); assert_eq!(1, num); let event = events.get(0).unwrap(); @@ -80,6 +67,7 @@ pub fn test_poll_channel_edge() { Err(TryRecvError::Disconnected) => {} no => panic!("unexpected value {:?}", no), } + } #[test] @@ -88,26 +76,17 @@ pub fn test_poll_channel_oneshot() { let mut events = Events::with_capacity(1024); let (tx, rx) = channel::channel(); - poll.register( - &rx, - Token(123), - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + poll.register(&rx, Token(123), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); // Wait, but nothing should happen - let num = poll - .poll(&mut events, Some(Duration::from_millis(300))) - .unwrap(); + let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); assert_eq!(0, num); // Push the value tx.send("hello").unwrap(); // Polling will contain the event - let num = poll - .poll(&mut events, Some(Duration::from_millis(300))) - .unwrap(); + let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); assert_eq!(1, num); let event = events.get(0).unwrap(); @@ -115,42 +94,29 @@ pub fn test_poll_channel_oneshot() { assert_eq!(event.readiness(), Ready::readable()); // Poll again and there should be no events - let num = poll - .poll(&mut events, Some(Duration::from_millis(300))) - .unwrap(); + let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); assert_eq!(0, num); // Read the value assert_eq!("hello", rx.try_recv().unwrap()); // Poll again, nothing - let num = poll - .poll(&mut events, Some(Duration::from_millis(300))) - .unwrap(); + let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); assert_eq!(0, num); // Push a value tx.send("goodbye").unwrap(); // Poll again, nothing - let num = poll - .poll(&mut events, Some(Duration::from_millis(300))) - .unwrap(); + let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); assert_eq!(0, num); // Reregistering will re-trigger the notification for _ in 0..3 { - poll.reregister( - &rx, - Token(123), - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + poll.reregister(&rx, Token(123), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); // Have an event - let num = poll - .poll(&mut events, Some(Duration::from_millis(300))) - .unwrap(); + let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); assert_eq!(1, num); let event = events.get(0).unwrap(); @@ -161,30 +127,16 @@ pub fn test_poll_channel_oneshot() { // Get the value assert_eq!("goodbye", rx.try_recv().unwrap()); - poll.reregister( - &rx, - Token(123), - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + poll.reregister(&rx, Token(123), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); // Have an event - let num = poll - .poll(&mut events, Some(Duration::from_millis(300))) - .unwrap(); + let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); assert_eq!(0, num); - poll.reregister( - &rx, - Token(123), - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + poll.reregister(&rx, Token(123), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); // Have an event - let num = poll - .poll(&mut events, Some(Duration::from_millis(300))) - .unwrap(); + let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); assert_eq!(0, num); } @@ -194,13 +146,10 @@ pub fn test_poll_channel_level() { let mut events = Events::with_capacity(1024); let (tx, rx) = channel::channel(); - poll.register(&rx, Token(123), Ready::readable(), PollOpt::level()) - .unwrap(); + poll.register(&rx, Token(123), Ready::readable(), PollOpt::level()).unwrap(); // Wait, but nothing should happen - let num = poll - .poll(&mut events, Some(Duration::from_millis(300))) - .unwrap(); + let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); assert_eq!(0, num); // Push the value @@ -208,9 +157,7 @@ pub fn test_poll_channel_level() { // Polling will contain the event for i in 0..5 { - let num = poll - .poll(&mut events, Some(Duration::from_millis(300))) - .unwrap(); + let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); assert!(1 == num, "actually got {} on iteration {}", num, i); let event = events.get(0).unwrap(); @@ -222,9 +169,7 @@ pub fn test_poll_channel_level() { assert_eq!("hello", rx.try_recv().unwrap()); // Wait, but nothing should happen - let num = poll - .poll(&mut events, Some(Duration::from_millis(300))) - .unwrap(); + let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); assert_eq!(0, num); } @@ -234,22 +179,17 @@ pub fn test_poll_channel_writable() { let mut events = Events::with_capacity(1024); let (tx, rx) = channel::channel(); - poll.register(&rx, Token(123), Ready::writable(), PollOpt::edge()) - .unwrap(); + poll.register(&rx, Token(123), Ready::writable(), PollOpt::edge()).unwrap(); // Wait, but nothing should happen - let num = poll - .poll(&mut events, Some(Duration::from_millis(300))) - .unwrap(); + let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); assert_eq!(0, num); // Push the value tx.send("hello").unwrap(); // Wait, but nothing should happen - let num = poll - .poll(&mut events, Some(Duration::from_millis(300))) - .unwrap(); + let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); assert_eq!(0, num); } @@ -259,8 +199,7 @@ pub fn test_dropping_receive_before_poll() { let mut events = Events::with_capacity(1024); let (tx, rx) = channel::channel(); - poll.register(&rx, Token(123), Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&rx, Token(123), Ready::readable(), PollOpt::edge()).unwrap(); // Push the value tx.send("hello").unwrap(); @@ -269,9 +208,7 @@ pub fn test_dropping_receive_before_poll() { drop(rx); // Wait, but nothing should happen - let num = poll - .poll(&mut events, Some(Duration::from_millis(300))) - .unwrap(); + let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); assert_eq!(0, num); } @@ -287,10 +224,8 @@ pub fn test_mixing_channel_with_socket() { let l = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); // Register the listener with `Poll` - poll.register(&l, Token(0), Ready::readable(), PollOpt::edge()) - .unwrap(); - poll.register(&rx, Token(1), Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&l, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&rx, Token(1), Ready::readable(), PollOpt::edge()).unwrap(); // Push a value onto the channel tx.send("hello").unwrap(); @@ -299,21 +234,15 @@ pub fn test_mixing_channel_with_socket() { let s1 = TcpStream::connect(&l.local_addr().unwrap()).unwrap(); // Register the socket - poll.register(&s1, Token(2), Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&s1, Token(2), Ready::readable(), PollOpt::edge()).unwrap(); // Sleep a bit to ensure it arrives at dest sleep_ms(250); - expect_events( - &poll, - &mut events, - 2, - vec![ - Event::new(Ready::empty(), Token(0)), - Event::new(Ready::empty(), Token(1)), - ], - ); + expect_events(&poll, &mut events, 2, vec![ + Event::new(Ready::empty(), Token(0)), + Event::new(Ready::empty(), Token(1)), + ]); } #[test] @@ -327,8 +256,7 @@ pub fn test_sending_from_other_thread_while_polling() { for _ in 0..ITERATIONS { let (tx, rx) = channel::channel(); - poll.register(&rx, Token(0), Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&rx, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); for _ in 0..THREADS { let tx = tx.clone(); diff --git a/test/test_register_deregister.rs b/test/test_register_deregister.rs index c3d11a398..a82698f91 100644 --- a/test/test_register_deregister.rs +++ b/test/test_register_deregister.rs @@ -1,9 +1,9 @@ -use bytes::SliceBuf; +use {expect_events, localhost, TryWrite}; +use mio::{Events, Poll, PollOpt, Ready, Token}; use mio::event::Event; use mio::net::{TcpListener, TcpStream}; -use mio::{Events, Poll, PollOpt, Ready, Token}; +use bytes::SliceBuf; use std::time::Duration; -use {expect_events, localhost, TryWrite}; const SERVER: Token = Token(0); const CLIENT: Token = Token(1); @@ -28,15 +28,13 @@ impl TestHandler { SERVER => { trace!("handle_read; token=SERVER"); let mut sock = self.server.accept().unwrap().0; - sock.try_write_buf(&mut SliceBuf::wrap("foobar".as_bytes())) - .unwrap(); + sock.try_write_buf(&mut SliceBuf::wrap("foobar".as_bytes())).unwrap(); } CLIENT => { trace!("handle_read; token=CLIENT"); assert!(self.state == 0, "unexpected state {}", self.state); self.state = 1; - poll.reregister(&self.client, CLIENT, Ready::writable(), PollOpt::level()) - .unwrap(); + poll.reregister(&self.client, CLIENT, Ready::writable(), PollOpt::level()).unwrap(); } _ => panic!("unexpected token"), } @@ -67,14 +65,12 @@ pub fn test_register_deregister() { let server = TcpListener::bind(&addr).unwrap(); info!("register server socket"); - poll.register(&server, SERVER, Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&server, SERVER, Ready::readable(), PollOpt::edge()).unwrap(); let client = TcpStream::connect(&addr).unwrap(); // Register client socket only as writable - poll.register(&client, CLIENT, Ready::readable(), PollOpt::level()) - .unwrap(); + poll.register(&client, CLIENT, Ready::readable(), PollOpt::level()).unwrap(); let mut handler = TestHandler::new(server, client); @@ -93,8 +89,7 @@ pub fn test_register_deregister() { } } - poll.poll(&mut events, Some(Duration::from_millis(100))) - .unwrap(); + poll.poll(&mut events, Some(Duration::from_millis(100))).unwrap(); assert_eq!(events.len(), 0); } @@ -106,36 +101,23 @@ pub fn test_register_empty_interest() { let sock = TcpListener::bind(&addr).unwrap(); - poll.register(&sock, Token(0), Ready::empty(), PollOpt::edge()) - .unwrap(); + poll.register(&sock, Token(0), Ready::empty(), PollOpt::edge()).unwrap(); let client = TcpStream::connect(&addr).unwrap(); // The connect is not guaranteed to have started until it is registered // https://docs.rs/mio/0.6.10/mio/struct.Poll.html#registering-handles - poll.register(&client, Token(1), Ready::empty(), PollOpt::edge()) - .unwrap(); + poll.register(&client, Token(1), Ready::empty(), PollOpt::edge()).unwrap(); // sock is registered with empty interest, we should not receive any event - poll.poll(&mut events, Some(Duration::from_millis(100))) - .unwrap(); - assert_eq!( - events.len(), - 0, - "Received unexpected event: {:?}", - events.get(0).unwrap() - ); + poll.poll(&mut events, Some(Duration::from_millis(100))).unwrap(); + assert_eq!(events.len(), 0, "Received unexpected event: {:?}", events.get(0).unwrap()); // now sock is reregistered with readable, we should receive the pending event - poll.reregister(&sock, Token(0), Ready::readable(), PollOpt::edge()) - .unwrap(); - expect_events( - &poll, - &mut events, - 2, - vec![Event::new(Ready::readable(), Token(0))], - ); - - poll.reregister(&sock, Token(0), Ready::empty(), PollOpt::edge()) - .unwrap(); + poll.reregister(&sock, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); + expect_events(&poll, &mut events, 2, vec![ + Event::new(Ready::readable(), Token(0)) + ]); + + poll.reregister(&sock, Token(0), Ready::empty(), PollOpt::edge()).unwrap(); } diff --git a/test/test_register_multiple_event_loops.rs b/test/test_register_multiple_event_loops.rs index 14182c6d5..9204afaf6 100644 --- a/test/test_register_multiple_event_loops.rs +++ b/test/test_register_multiple_event_loops.rs @@ -1,6 +1,6 @@ use localhost; -use mio::net::{TcpListener, TcpStream, UdpSocket}; use mio::*; +use mio::net::{TcpListener, TcpStream, UdpSocket}; use std::io::ErrorKind; #[test] @@ -9,65 +9,33 @@ fn test_tcp_register_multiple_event_loops() { let listener = TcpListener::bind(&addr).unwrap(); let poll1 = Poll::new().unwrap(); - poll1 - .register( - &listener, - Token(0), - Ready::readable() | Ready::writable(), - PollOpt::edge(), - ).unwrap(); + poll1.register(&listener, Token(0), Ready::readable() | Ready::writable(), PollOpt::edge()).unwrap(); let poll2 = Poll::new().unwrap(); // Try registering the same socket with the initial one - let res = poll2.register( - &listener, - Token(0), - Ready::readable() | Ready::writable(), - PollOpt::edge(), - ); + let res = poll2.register(&listener, Token(0), Ready::readable() | Ready::writable(), PollOpt::edge()); assert!(res.is_err()); assert_eq!(res.unwrap_err().kind(), ErrorKind::Other); // Try cloning the socket and registering it again let listener2 = listener.try_clone().unwrap(); - let res = poll2.register( - &listener2, - Token(0), - Ready::readable() | Ready::writable(), - PollOpt::edge(), - ); + let res = poll2.register(&listener2, Token(0), Ready::readable() | Ready::writable(), PollOpt::edge()); assert!(res.is_err()); assert_eq!(res.unwrap_err().kind(), ErrorKind::Other); // Try the stream let stream = TcpStream::connect(&addr).unwrap(); - poll1 - .register( - &stream, - Token(1), - Ready::readable() | Ready::writable(), - PollOpt::edge(), - ).unwrap(); + poll1.register(&stream, Token(1), Ready::readable() | Ready::writable(), PollOpt::edge()).unwrap(); - let res = poll2.register( - &stream, - Token(1), - Ready::readable() | Ready::writable(), - PollOpt::edge(), - ); + let res = poll2.register(&stream, Token(1), Ready::readable() | Ready::writable(), PollOpt::edge()); assert!(res.is_err()); assert_eq!(res.unwrap_err().kind(), ErrorKind::Other); // Try cloning the socket and registering it again let stream2 = stream.try_clone().unwrap(); - let res = poll2.register( - &stream2, - Token(1), - Ready::readable() | Ready::writable(), - PollOpt::edge(), - ); + let res = poll2.register(&stream2, Token(1), Ready::readable() | Ready::writable(), PollOpt::edge()); assert!(res.is_err()); assert_eq!(res.unwrap_err().kind(), ErrorKind::Other); } @@ -78,34 +46,18 @@ fn test_udp_register_multiple_event_loops() { let socket = UdpSocket::bind(&addr).unwrap(); let poll1 = Poll::new().unwrap(); - poll1 - .register( - &socket, - Token(0), - Ready::readable() | Ready::writable(), - PollOpt::edge(), - ).unwrap(); + poll1.register(&socket, Token(0), Ready::readable() | Ready::writable(), PollOpt::edge()).unwrap(); let poll2 = Poll::new().unwrap(); // Try registering the same socket with the initial one - let res = poll2.register( - &socket, - Token(0), - Ready::readable() | Ready::writable(), - PollOpt::edge(), - ); + let res = poll2.register(&socket, Token(0), Ready::readable() | Ready::writable(), PollOpt::edge()); assert!(res.is_err()); assert_eq!(res.unwrap_err().kind(), ErrorKind::Other); // Try cloning the socket and registering it again let socket2 = socket.try_clone().unwrap(); - let res = poll2.register( - &socket2, - Token(0), - Ready::readable() | Ready::writable(), - PollOpt::edge(), - ); + let res = poll2.register(&socket2, Token(0), Ready::readable() | Ready::writable(), PollOpt::edge()); assert!(res.is_err()); assert_eq!(res.unwrap_err().kind(), ErrorKind::Other); } diff --git a/test/test_reregister_without_poll.rs b/test/test_reregister_without_poll.rs index aeed33330..45d5aca49 100644 --- a/test/test_reregister_without_poll.rs +++ b/test/test_reregister_without_poll.rs @@ -1,6 +1,6 @@ -use mio::net::{TcpListener, TcpStream}; +use {sleep_ms}; use mio::*; -use sleep_ms; +use mio::net::{TcpListener, TcpStream}; use std::time::Duration; const MS: u64 = 1_000; @@ -14,27 +14,15 @@ pub fn test_reregister_different_without_poll() { let l = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); // Register the listener with `Poll` - poll.register( - &l, - Token(0), - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + poll.register(&l, Token(0), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); let s1 = TcpStream::connect(&l.local_addr().unwrap()).unwrap(); - poll.register(&s1, Token(2), Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&s1, Token(2), Ready::readable(), PollOpt::edge()).unwrap(); sleep_ms(MS); - poll.reregister( - &l, - Token(0), - Ready::writable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + poll.reregister(&l, Token(0), Ready::writable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); - poll.poll(&mut events, Some(Duration::from_millis(MS))) - .unwrap(); + poll.poll(&mut events, Some(Duration::from_millis(MS))).unwrap(); assert_eq!(events.len(), 0); } diff --git a/test/test_smoke.rs b/test/test_smoke.rs index 79eba01da..96f7d3c9e 100644 --- a/test/test_smoke.rs +++ b/test/test_smoke.rs @@ -1,15 +1,14 @@ extern crate mio; +use mio::{Events, Poll, Token, Ready, PollOpt}; use mio::net::TcpListener; -use mio::{Events, Poll, PollOpt, Ready, Token}; use std::time::Duration; #[test] fn run_once_with_nothing() { let mut events = Events::with_capacity(1024); let poll = Poll::new().unwrap(); - poll.poll(&mut events, Some(Duration::from_millis(100))) - .unwrap(); + poll.poll(&mut events, Some(Duration::from_millis(100))).unwrap(); } #[test] @@ -17,13 +16,8 @@ fn add_then_drop() { let mut events = Events::with_capacity(1024); let l = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); let poll = Poll::new().unwrap(); - poll.register( - &l, - Token(1), - Ready::readable() | Ready::writable(), - PollOpt::edge(), - ).unwrap(); + poll.register(&l, Token(1), Ready::readable() | Ready::writable(), PollOpt::edge()).unwrap(); drop(l); - poll.poll(&mut events, Some(Duration::from_millis(100))) - .unwrap(); + poll.poll(&mut events, Some(Duration::from_millis(100))).unwrap(); + } diff --git a/test/test_subprocess_pipe.rs b/test/test_subprocess_pipe.rs index 6dc4d3d9e..2bcf13248 100644 --- a/test/test_subprocess_pipe.rs +++ b/test/test_subprocess_pipe.rs @@ -1,45 +1,42 @@ -use mio::deprecated::unix::{PipeReader, PipeWriter}; -use mio::deprecated::{EventLoop, Handler}; +use {TryRead, TryWrite}; +use std::mem; use mio::*; use std::io; -use std::mem; -use std::process::{Child, Command, Stdio}; -use {TryRead, TryWrite}; +use mio::deprecated::{EventLoop, Handler}; +use mio::deprecated::unix::{PipeReader, PipeWriter}; +use std::process::{Command, Stdio, Child}; + struct SubprocessClient { stdin: Option, stdout: Option, stderr: Option, - stdin_token: Token, - stdout_token: Token, - stderr_token: Token, - output: Vec, - output_stderr: Vec, - input: Vec, - input_offset: usize, - buf: [u8; 65536], + stdin_token : Token, + stdout_token : Token, + stderr_token : Token, + output : Vec, + output_stderr : Vec, + input : Vec, + input_offset : usize, + buf : [u8; 65536], } + // Sends a message and expects to receive the same exact message, one at a time impl SubprocessClient { - fn new( - stdin: Option, - stdout: Option, - stderr: Option, - data: &[u8], - ) -> SubprocessClient { + fn new(stdin: Option, stdout : Option, stderr : Option, data : &[u8]) -> SubprocessClient { SubprocessClient { stdin: stdin, stdout: stdout, stderr: stderr, - stdin_token: Token(0), - stdout_token: Token(1), - stderr_token: Token(2), - output: Vec::::new(), - output_stderr: Vec::::new(), - buf: [0; 65536], - input: data.to_vec(), - input_offset: 0, + stdin_token : Token(0), + stdout_token : Token(1), + stderr_token : Token(2), + output : Vec::::new(), + output_stderr : Vec::::new(), + buf : [0; 65536], + input : data.to_vec(), + input_offset : 0, } } @@ -47,25 +44,26 @@ impl SubprocessClient { let mut eof = false; match self.stdout { None => unreachable!(), - Some(ref mut stdout) => match stdout.try_read(&mut self.buf[..]) { - Ok(None) => {} + Some (ref mut stdout) => match stdout.try_read(&mut self.buf[..]) { + Ok(None) => { + } Ok(Some(r)) => { if r == 0 { eof = true; } else { - self.output.extend(&self.buf[0..r]); + self.output.extend(&self.buf[0..r]); } } Err(e) => { return Err(e); } - }, + } }; if eof { drop(self.stdout.take()); match self.stderr { None => event_loop.shutdown(), - Some(_) => {} + Some(_) => {}, } } return Ok(()); @@ -76,7 +74,8 @@ impl SubprocessClient { match self.stderr { None => unreachable!(), Some(ref mut stderr) => match stderr.try_read(&mut self.buf[..]) { - Ok(None) => {} + Ok(None) => { + } Ok(Some(r)) => { if r == 0 { eof = true; @@ -87,14 +86,14 @@ impl SubprocessClient { Err(e) => { return Err(e); } - }, + } }; if eof { - drop(self.stderr.take()); - match self.stdout { - None => event_loop.shutdown(), - Some(_) => {} - } + drop(self.stderr.take()); + match self.stdout { + None => event_loop.shutdown(), + Some(_) => {}, + } } return Ok(()); } @@ -104,38 +103,41 @@ impl SubprocessClient { match self.stdin { None => unreachable!(), Some(ref mut stdin) => match stdin.try_write(&(&self.input)[self.input_offset..]) { - Ok(None) => {} + Ok(None) => { + }, Ok(Some(r)) => { if r == 0 { ok = false; } else { self.input_offset += r; } - } + }, Err(_) => { ok = false; - } - }, + }, + } } if self.input_offset == self.input.len() || !ok { drop(self.stdin.take()); match self.stderr { None => match self.stdout { - None => event_loop.shutdown(), - Some(_) => {} + None => event_loop.shutdown(), + Some(_) => {}, }, - Some(_) => {} + Some(_) => {}, } } return Ok(()); } + } impl Handler for SubprocessClient { type Timeout = usize; type Message = (); - fn ready(&mut self, event_loop: &mut EventLoop, token: Token, _: Ready) { + fn ready(&mut self, event_loop: &mut EventLoop, token: Token, + _: Ready) { if token == self.stderr_token { let _x = self.readable_stderr(event_loop); } else { @@ -147,14 +149,17 @@ impl Handler for SubprocessClient { } } -const TEST_DATA: [u8; 1024 * 4096] = [42; 1024 * 4096]; -pub fn subprocess_communicate(mut process: Child, input: &[u8]) -> (Vec, Vec) { + + + +const TEST_DATA : [u8; 1024 * 4096] = [42; 1024 * 4096]; +pub fn subprocess_communicate(mut process : Child, input : &[u8]) -> (Vec, Vec) { let mut event_loop = EventLoop::::new().unwrap(); - let stdin: Option; - let stdin_exists: bool; + let stdin : Option; + let stdin_exists : bool; match process.stdin { - None => stdin_exists = false, - Some(_) => stdin_exists = true, + None => stdin_exists = false, + Some(_) => stdin_exists = true, } if stdin_exists { match PipeWriter::from_stdin(process.stdin.take().unwrap()) { @@ -164,11 +169,11 @@ pub fn subprocess_communicate(mut process: Child, input: &[u8]) -> (Vec, Vec } else { stdin = None; } - let stdout_exists: bool; - let stdout: Option; + let stdout_exists : bool; + let stdout : Option; match process.stdout { - None => stdout_exists = false, - Some(_) => stdout_exists = true, + None => stdout_exists = false, + Some(_) => stdout_exists = true, } if stdout_exists { match PipeReader::from_stdout(process.stdout.take().unwrap()) { @@ -178,54 +183,42 @@ pub fn subprocess_communicate(mut process: Child, input: &[u8]) -> (Vec, Vec } else { stdout = None; } - let stderr_exists: bool; - let stderr: Option; + let stderr_exists : bool; + let stderr : Option; match process.stderr { - None => stderr_exists = false, - Some(_) => stderr_exists = true, + None => stderr_exists = false, + Some(_) => stderr_exists = true, } if stderr_exists { match PipeReader::from_stderr(process.stderr.take().unwrap()) { - Err(e) => panic!(e), - Ok(pipe) => stderr = Some(pipe), + Err(e) => panic!(e), + Ok(pipe) => stderr = Some(pipe), } } else { stderr = None } - let mut subprocess = SubprocessClient::new(stdin, stdout, stderr, input); + let mut subprocess = SubprocessClient::new(stdin, + stdout, + stderr, + input); match subprocess.stdout { - Some(ref sub_stdout) => event_loop - .register( - sub_stdout, - subprocess.stdout_token, - Ready::readable(), - PollOpt::level(), - ).unwrap(), - None => {} + Some(ref sub_stdout) => event_loop.register(sub_stdout, subprocess.stdout_token, Ready::readable(), + PollOpt::level()).unwrap(), + None => {}, } match subprocess.stderr { - Some(ref sub_stderr) => event_loop - .register( - sub_stderr, - subprocess.stderr_token, - Ready::readable(), - PollOpt::level(), - ).unwrap(), - None => {} + Some(ref sub_stderr) => event_loop.register(sub_stderr, subprocess.stderr_token, Ready::readable(), + PollOpt::level()).unwrap(), + None => {}, } // Connect to the server match subprocess.stdin { - Some(ref sub_stdin) => event_loop - .register( - sub_stdin, - subprocess.stdin_token, - Ready::writable(), - PollOpt::level(), - ).unwrap(), - None => {} + Some (ref sub_stdin) => event_loop.register(sub_stdin, subprocess.stdin_token, Ready::writable(), + PollOpt::level()).unwrap(), + None => {}, } // Start the event loop @@ -239,18 +232,18 @@ pub fn subprocess_communicate(mut process: Child, input: &[u8]) -> (Vec, Vec #[test] fn test_subprocess_pipe() { - let process = Command::new("/bin/cat") - .stdin(Stdio::piped()) - .stdout(Stdio::piped()) - .stderr(Stdio::piped()) - .spawn() - .unwrap(); - let (ret_stdout, ret_stderr) = subprocess_communicate(process, &TEST_DATA[..]); - assert_eq!(TEST_DATA.len(), ret_stdout.len()); - assert_eq!(0usize, ret_stderr.len()); - let mut i: usize = 0; - for item in TEST_DATA.iter() { - assert_eq!(*item, ret_stdout[i]); - i += 1; - } + let process = + Command::new("/bin/cat") + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn().unwrap(); + let (ret_stdout, ret_stderr) = subprocess_communicate(process, &TEST_DATA[..]); + assert_eq!(TEST_DATA.len(), ret_stdout.len()); + assert_eq!(0usize, ret_stderr.len()); + let mut i : usize = 0; + for item in TEST_DATA.iter() { + assert_eq!(*item, ret_stdout[i]); + i += 1; + } } diff --git a/test/test_tcp.rs b/test/test_tcp.rs index 729629579..2587c314f 100644 --- a/test/test_tcp.rs +++ b/test/test_tcp.rs @@ -1,6 +1,6 @@ use std::cmp; -use std::io; use std::io::prelude::*; +use std::io; use std::net; use std::sync::mpsc::channel; use std::thread; @@ -8,18 +8,14 @@ use std::time::Duration; use net2::{self, TcpStreamExt}; +use {TryRead, TryWrite}; +use mio::{Token, Ready, PollOpt, Poll, Events}; use iovec::IoVec; use mio::net::{TcpListener, TcpStream}; -use mio::{Events, Poll, PollOpt, Ready, Token}; -use {TryRead, TryWrite}; #[test] fn accept() { - struct H { - hit: bool, - listener: TcpListener, - shutdown: bool, - } + struct H { hit: bool, listener: TcpListener, shutdown: bool } let l = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); let addr = l.local_addr().unwrap(); @@ -30,16 +26,11 @@ fn accept() { let poll = Poll::new().unwrap(); - poll.register(&l, Token(1), Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&l, Token(1), Ready::readable(), PollOpt::edge()).unwrap(); let mut events = Events::with_capacity(128); - let mut h = H { - hit: false, - listener: l, - shutdown: false, - }; + let mut h = H { hit: false, listener: l, shutdown: false }; while !h.shutdown { poll.poll(&mut events, None).unwrap(); @@ -58,10 +49,7 @@ fn accept() { #[test] fn connect() { - struct H { - hit: u32, - shutdown: bool, - } + struct H { hit: u32, shutdown: bool } let l = net::TcpListener::bind("127.0.0.1:0").unwrap(); let addr = l.local_addr().unwrap(); @@ -78,19 +66,11 @@ fn connect() { let poll = Poll::new().unwrap(); let s = TcpStream::connect(&addr).unwrap(); - poll.register( - &s, - Token(1), - Ready::readable() | Ready::writable(), - PollOpt::edge(), - ).unwrap(); + poll.register(&s, Token(1), Ready::readable() | Ready::writable(), PollOpt::edge()).unwrap(); let mut events = Events::with_capacity(128); - let mut h = H { - hit: 0, - shutdown: false, - }; + let mut h = H { hit: 0, shutdown: false }; while !h.shutdown { poll.poll(&mut events, None).unwrap(); @@ -130,11 +110,7 @@ fn connect() { #[test] fn read() { const N: usize = 16 * 1024 * 1024; - struct H { - amt: usize, - socket: TcpStream, - shutdown: bool, - } + struct H { amt: usize, socket: TcpStream, shutdown: bool } let l = net::TcpListener::bind("127.0.0.1:0").unwrap(); let addr = l.local_addr().unwrap(); @@ -151,16 +127,11 @@ fn read() { let poll = Poll::new().unwrap(); let s = TcpStream::connect(&addr).unwrap(); - poll.register(&s, Token(1), Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&s, Token(1), Ready::readable(), PollOpt::edge()).unwrap(); let mut events = Events::with_capacity(128); - let mut h = H { - amt: 0, - socket: s, - shutdown: false, - }; + let mut h = H { amt: 0, socket: s, shutdown: false }; while !h.shutdown { poll.poll(&mut events, None).unwrap(); @@ -171,11 +142,11 @@ fn read() { if let Some(amt) = h.socket.try_read(&mut b).unwrap() { h.amt += amt; } else { - break; + break } if h.amt >= N { h.shutdown = true; - break; + break } } } @@ -186,11 +157,7 @@ fn read() { #[test] fn peek() { const N: usize = 16 * 1024 * 1024; - struct H { - amt: usize, - socket: TcpStream, - shutdown: bool, - } + struct H { amt: usize, socket: TcpStream, shutdown: bool } let l = net::TcpListener::bind("127.0.0.1:0").unwrap(); let addr = l.local_addr().unwrap(); @@ -207,16 +174,11 @@ fn peek() { let poll = Poll::new().unwrap(); let s = TcpStream::connect(&addr).unwrap(); - poll.register(&s, Token(1), Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&s, Token(1), Ready::readable(), PollOpt::edge()).unwrap(); let mut events = Events::with_capacity(128); - let mut h = H { - amt: 0, - socket: s, - shutdown: false, - }; + let mut h = H { amt: 0, socket: s, shutdown: false }; while !h.shutdown { poll.poll(&mut events, None).unwrap(); @@ -225,7 +187,9 @@ fn peek() { let mut b = [0; 1024]; match h.socket.peek(&mut b) { Ok(_) => (), - Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => continue, + Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => { + continue + }, Err(e) => panic!("unexpected error: {:?}", e), } @@ -233,11 +197,11 @@ fn peek() { if let Some(amt) = h.socket.try_read(&mut b).unwrap() { h.amt += amt; } else { - break; + break } if h.amt >= N { h.shutdown = true; - break; + break } } } @@ -266,15 +230,20 @@ fn read_bufs() { let s = TcpStream::connect(&addr).unwrap(); - poll.register(&s, Token(1), Ready::readable(), PollOpt::level()) - .unwrap(); + poll.register(&s, Token(1), Ready::readable(), PollOpt::level()).unwrap(); let b1 = &mut [0; 10][..]; let b2 = &mut [0; 383][..]; let b3 = &mut [0; 28][..]; let b4 = &mut [0; 8][..]; let b5 = &mut [0; 128][..]; - let mut b: [&mut IoVec; 5] = [b1.into(), b2.into(), b3.into(), b4.into(), b5.into()]; + let mut b: [&mut IoVec; 5] = [ + b1.into(), + b2.into(), + b3.into(), + b4.into(), + b5.into(), + ]; let mut so_far = 0; loop { @@ -289,7 +258,7 @@ fn read_bufs() { match s.read_bufs(&mut b) { Ok(0) => { assert_eq!(so_far, N); - break; + break } Ok(mut n) => { so_far += n; @@ -300,7 +269,7 @@ fn read_bufs() { } n = n.saturating_sub(buf.len()); if n == 0 { - break; + break } } assert_eq!(n, 0); @@ -315,11 +284,7 @@ fn read_bufs() { #[test] fn write() { const N: usize = 16 * 1024 * 1024; - struct H { - amt: usize, - socket: TcpStream, - shutdown: bool, - } + struct H { amt: usize, socket: TcpStream, shutdown: bool } let l = net::TcpListener::bind("127.0.0.1:0").unwrap(); let addr = l.local_addr().unwrap(); @@ -336,16 +301,11 @@ fn write() { let poll = Poll::new().unwrap(); let s = TcpStream::connect(&addr).unwrap(); - poll.register(&s, Token(1), Ready::writable(), PollOpt::edge()) - .unwrap(); + poll.register(&s, Token(1), Ready::writable(), PollOpt::edge()).unwrap(); let mut events = Events::with_capacity(128); - let mut h = H { - amt: 0, - socket: s, - shutdown: false, - }; + let mut h = H { amt: 0, socket: s, shutdown: false }; while !h.shutdown { poll.poll(&mut events, None).unwrap(); @@ -356,11 +316,11 @@ fn write() { if let Some(amt) = h.socket.try_write(&b).unwrap() { h.amt += amt; } else { - break; + break } if h.amt >= N { h.shutdown = true; - break; + break } } } @@ -394,15 +354,20 @@ fn write_bufs() { let poll = Poll::new().unwrap(); let mut events = Events::with_capacity(128); let s = TcpStream::connect(&addr).unwrap(); - poll.register(&s, Token(1), Ready::writable(), PollOpt::level()) - .unwrap(); + poll.register(&s, Token(1), Ready::writable(), PollOpt::level()).unwrap(); let b1 = &[1; 10][..]; let b2 = &[1; 383][..]; let b3 = &[1; 28][..]; let b4 = &[1; 8][..]; let b5 = &[1; 128][..]; - let b: [&IoVec; 5] = [b1.into(), b2.into(), b3.into(), b4.into(), b5.into()]; + let b: [&IoVec; 5] = [ + b1.into(), + b2.into(), + b3.into(), + b4.into(), + b5.into(), + ]; let mut so_far = 0; while so_far < N { @@ -419,38 +384,26 @@ fn write_bufs() { #[test] fn connect_then_close() { - struct H { - listener: TcpListener, - shutdown: bool, - } + struct H { listener: TcpListener, shutdown: bool } let poll = Poll::new().unwrap(); let l = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); let s = TcpStream::connect(&l.local_addr().unwrap()).unwrap(); - poll.register(&l, Token(1), Ready::readable(), PollOpt::edge()) - .unwrap(); - poll.register(&s, Token(2), Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&l, Token(1), Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&s, Token(2), Ready::readable(), PollOpt::edge()).unwrap(); let mut events = Events::with_capacity(128); - let mut h = H { - listener: l, - shutdown: false, - }; + let mut h = H { listener: l, shutdown: false }; while !h.shutdown { poll.poll(&mut events, None).unwrap(); for event in &events { if event.token() == Token(1) { let s = h.listener.accept().unwrap().0; - poll.register( - &s, - Token(3), - Ready::readable() | Ready::writable(), - PollOpt::edge(), - ).unwrap(); + poll.register(&s, Token(3), Ready::readable() | Ready::writable(), + PollOpt::edge()).unwrap(); drop(s); } else if event.token() == Token(2) { h.shutdown = true; @@ -464,14 +417,12 @@ fn listen_then_close() { let poll = Poll::new().unwrap(); let l = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); - poll.register(&l, Token(1), Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&l, Token(1), Ready::readable(), PollOpt::edge()).unwrap(); drop(l); let mut events = Events::with_capacity(128); - poll.poll(&mut events, Some(Duration::from_millis(100))) - .unwrap(); + poll.poll(&mut events, Some(Duration::from_millis(100))).unwrap(); for event in &events { if event.token() == Token(1) { @@ -480,9 +431,11 @@ fn listen_then_close() { } } -fn assert_send() {} +fn assert_send() { +} -fn assert_sync() {} +fn assert_sync() { +} #[test] fn test_tcp_sockets_are_send() { @@ -509,7 +462,7 @@ fn multiple_writes_immediate_success() { let mut s = l.accept().unwrap().0; let mut b = [0; 1024]; let mut amt = 0; - while amt < 1024 * N { + while amt < 1024*N { for byte in b.iter_mut() { *byte = 0; } @@ -523,8 +476,7 @@ fn multiple_writes_immediate_success() { let poll = Poll::new().unwrap(); let mut s = TcpStream::connect(&addr).unwrap(); - poll.register(&s, Token(1), Ready::writable(), PollOpt::level()) - .unwrap(); + poll.register(&s, Token(1), Ready::writable(), PollOpt::level()).unwrap(); let mut events = Events::with_capacity(16); // Wait for our TCP stream to connect @@ -532,7 +484,7 @@ fn multiple_writes_immediate_success() { poll.poll(&mut events, None).unwrap(); for event in events.iter() { if event.token() == Token(1) && event.readiness().is_writable() { - break 'outer; + break 'outer } } } @@ -555,7 +507,8 @@ fn connection_reset_by_peer() { let addr = l.local_addr().unwrap(); // Connect client - let client = net2::TcpBuilder::new_v4().unwrap().to_tcp_stream().unwrap(); + let client = net2::TcpBuilder::new_v4().unwrap() + .to_tcp_stream().unwrap(); client.set_linger(Some(Duration::from_millis(0))).unwrap(); client.connect(&addr).unwrap(); @@ -564,20 +517,15 @@ fn connection_reset_by_peer() { let client = TcpStream::from_stream(client).unwrap(); // Register server - poll.register(&l, Token(0), Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&l, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); // Register interest in the client - poll.register( - &client, - Token(1), - Ready::readable() | Ready::writable(), - PollOpt::edge(), - ).unwrap(); + poll.register(&client, Token(1), Ready::readable() | Ready::writable(), PollOpt::edge()).unwrap(); // Wait for listener to be ready let mut server; - 'outer: loop { + 'outer: + loop { poll.poll(&mut events, None).unwrap(); for event in &events { @@ -601,8 +549,8 @@ fn connection_reset_by_peer() { thread::sleep(Duration::from_millis(100)); // Register interest in the server socket - poll.register(&server, Token(3), Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&server, Token(3), Ready::readable(), PollOpt::edge()).unwrap(); + loop { poll.poll(&mut events, None).unwrap(); @@ -612,7 +560,8 @@ fn connection_reset_by_peer() { assert!(event.readiness().is_readable()); match server.read(&mut buf) { - Ok(0) | Err(_) => {} + Ok(0) | + Err(_) => {}, Ok(x) => panic!("expected empty buffer but read {} bytes", x), } @@ -620,6 +569,7 @@ fn connection_reset_by_peer() { } } } + } #[test] @@ -635,20 +585,20 @@ fn connect_error() { // Connection failed synchronously. This is not a bug, but it // unfortunately doesn't get us the code coverage we want. return; - } - Err(e) => panic!("TcpStream::connect unexpected error {:?}", e), + }, + Err(e) => panic!("TcpStream::connect unexpected error {:?}", e) }; - poll.register(&l, Token(0), Ready::writable(), PollOpt::edge()) - .unwrap(); + poll.register(&l, Token(0), Ready::writable(), PollOpt::edge()).unwrap(); - 'outer: loop { + 'outer: + loop { poll.poll(&mut events, None).unwrap(); for event in &events { if event.token() == Token(0) { assert!(event.readiness().is_writable()); - break 'outer; + break 'outer } } } @@ -671,19 +621,20 @@ fn write_error() { }); let mut s = TcpStream::connect(&addr).unwrap(); - poll.register( - &s, - Token(0), - Ready::readable() | Ready::writable(), - PollOpt::edge(), - ).unwrap(); - - let mut wait_writable = || 'outer: loop { - poll.poll(&mut events, None).unwrap(); - - for event in &events { - if event.token() == Token(0) && event.readiness().is_writable() { - break 'outer; + poll.register(&s, + Token(0), + Ready::readable() | Ready::writable(), + PollOpt::edge()).unwrap(); + + let mut wait_writable = || { + 'outer: + loop { + poll.poll(&mut events, None).unwrap(); + + for event in &events { + if event.token() == Token(0) && event.readiness().is_writable() { + break 'outer + } } } }; @@ -697,10 +648,12 @@ fn write_error() { loop { match s.write(&buf) { Ok(_) => {} - Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => wait_writable(), + Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => { + wait_writable() + } Err(e) => { println!("good error: {}", e); - break; + break } } } diff --git a/test/test_tcp_level.rs b/test/test_tcp_level.rs index aa56f0c7a..e52385c3d 100644 --- a/test/test_tcp_level.rs +++ b/test/test_tcp_level.rs @@ -1,9 +1,9 @@ +use {expect_events, sleep_ms, TryRead}; +use mio::{Events, Poll, PollOpt, Ready, Token}; use mio::event::Event; use mio::net::{TcpListener, TcpStream}; -use mio::{Events, Poll, PollOpt, Ready, Token}; use std::io::Write; use std::time::Duration; -use {expect_events, sleep_ms, TryRead}; const MS: u64 = 1_000; @@ -16,24 +16,20 @@ pub fn test_tcp_listener_level_triggered() { let l = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); // Register the listener with `Poll` - poll.register(&l, Token(0), Ready::readable(), PollOpt::level()) - .unwrap(); + poll.register(&l, Token(0), Ready::readable(), PollOpt::level()).unwrap(); let s1 = TcpStream::connect(&l.local_addr().unwrap()).unwrap(); - poll.register(&s1, Token(1), Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&s1, Token(1), Ready::readable(), PollOpt::edge()).unwrap(); while filter(&pevents, Token(0)).len() == 0 { - poll.poll(&mut pevents, Some(Duration::from_millis(MS))) - .unwrap(); + poll.poll(&mut pevents, Some(Duration::from_millis(MS))).unwrap(); } let events = filter(&pevents, Token(0)); assert_eq!(events.len(), 1); assert_eq!(events[0], Event::new(Ready::readable(), Token(0))); - poll.poll(&mut pevents, Some(Duration::from_millis(MS))) - .unwrap(); + poll.poll(&mut pevents, Some(Duration::from_millis(MS))).unwrap(); let events = filter(&pevents, Token(0)); assert_eq!(events.len(), 1); assert_eq!(events[0], Event::new(Ready::readable(), Token(0))); @@ -41,18 +37,15 @@ pub fn test_tcp_listener_level_triggered() { // Accept the connection then test that the events stop let _ = l.accept().unwrap(); - poll.poll(&mut pevents, Some(Duration::from_millis(MS))) - .unwrap(); + poll.poll(&mut pevents, Some(Duration::from_millis(MS))).unwrap(); let events = filter(&pevents, Token(0)); assert!(events.is_empty(), "actual={:?}", events); let s3 = TcpStream::connect(&l.local_addr().unwrap()).unwrap(); - poll.register(&s3, Token(2), Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&s3, Token(2), Ready::readable(), PollOpt::edge()).unwrap(); while filter(&pevents, Token(0)).len() == 0 { - poll.poll(&mut pevents, Some(Duration::from_millis(MS))) - .unwrap(); + poll.poll(&mut pevents, Some(Duration::from_millis(MS))).unwrap(); } let events = filter(&pevents, Token(0)); @@ -61,8 +54,7 @@ pub fn test_tcp_listener_level_triggered() { drop(l); - poll.poll(&mut pevents, Some(Duration::from_millis(MS))) - .unwrap(); + poll.poll(&mut pevents, Some(Duration::from_millis(MS))).unwrap(); let events = filter(&pevents, Token(0)); assert!(events.is_empty()); } @@ -77,29 +69,18 @@ pub fn test_tcp_stream_level_triggered() { let l = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); // Register the listener with `Poll` - poll.register(&l, Token(0), Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&l, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); let mut s1 = TcpStream::connect(&l.local_addr().unwrap()).unwrap(); - poll.register( - &s1, - Token(1), - Ready::readable() | Ready::writable(), - PollOpt::level(), - ).unwrap(); + poll.register(&s1, Token(1), Ready::readable() | Ready::writable(), PollOpt::level()).unwrap(); // Sleep a bit to ensure it arrives at dest sleep_ms(250); - expect_events( - &poll, - &mut pevents, - 2, - vec![ - Event::new(Ready::readable(), Token(0)), - Event::new(Ready::writable(), Token(1)), - ], - ); + expect_events(&poll, &mut pevents, 2, vec![ + Event::new(Ready::readable(), Token(0)), + Event::new(Ready::writable(), Token(1)), + ]); // Server side of socket let (mut s1_tx, _) = l.accept().unwrap(); @@ -107,16 +88,12 @@ pub fn test_tcp_stream_level_triggered() { // Sleep a bit to ensure it arrives at dest sleep_ms(250); - expect_events( - &poll, - &mut pevents, - 2, - vec![Event::new(Ready::writable(), Token(1))], - ); + expect_events(&poll, &mut pevents, 2, vec![ + Event::new(Ready::writable(), Token(1)) + ]); // Register the socket - poll.register(&s1_tx, Token(123), Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&s1_tx, Token(123), Ready::readable(), PollOpt::edge()).unwrap(); debug!("writing some data ----------"); @@ -130,44 +107,36 @@ pub fn test_tcp_stream_level_triggered() { debug!("looking at rx end ----------"); // Poll rx end - expect_events( - &poll, - &mut pevents, - 2, - vec![Event::new(Ready::readable(), Token(1))], - ); + expect_events(&poll, &mut pevents, 2, vec![ + Event::new(Ready::readable(), Token(1)) + ]); debug!("reading ----------"); // Reading the data should clear it let mut res = vec![]; - while s1.try_read_buf(&mut res).unwrap().is_some() {} + while s1.try_read_buf(&mut res).unwrap().is_some() { + } assert_eq!(res, b"hello world!"); debug!("checking just read ----------"); - expect_events( - &poll, - &mut pevents, - 1, - vec![Event::new(Ready::writable(), Token(1))], - ); + expect_events(&poll, &mut pevents, 1, vec![ + Event::new(Ready::writable(), Token(1))]); // Closing the socket clears all active level events drop(s1); debug!("checking everything is gone ----------"); - poll.poll(&mut pevents, Some(Duration::from_millis(MS))) - .unwrap(); + poll.poll(&mut pevents, Some(Duration::from_millis(MS))).unwrap(); let events = filter(&pevents, Token(1)); assert!(events.is_empty()); } fn filter(events: &Events, token: Token) -> Vec { - (0..events.len()) - .map(|i| events.get(i).unwrap()) - .filter(|e| e.token() == token) - .collect() + (0..events.len()).map(|i| events.get(i).unwrap()) + .filter(|e| e.token() == token) + .collect() } diff --git a/test/test_tick.rs b/test/test_tick.rs index aa3c61889..76587eb32 100644 --- a/test/test_tick.rs +++ b/test/test_tick.rs @@ -1,7 +1,7 @@ +use mio::*; use mio::deprecated::{EventLoop, Handler}; use mio::net::{TcpListener, TcpStream}; -use mio::*; -use sleep_ms; +use {sleep_ms}; struct TestHandler { tick: usize, @@ -10,7 +10,10 @@ struct TestHandler { impl TestHandler { fn new() -> TestHandler { - TestHandler { tick: 0, state: 0 } + TestHandler { + tick: 0, + state: 0, + } } } @@ -43,14 +46,10 @@ pub fn test_tick() { let mut event_loop = EventLoop::new().ok().expect("Couldn't make event loop"); let listener = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); - event_loop - .register(&listener, Token(0), Ready::readable(), PollOpt::level()) - .unwrap(); + event_loop.register(&listener, Token(0), Ready::readable(), PollOpt::level()).unwrap(); let client = TcpStream::connect(&listener.local_addr().unwrap()).unwrap(); - event_loop - .register(&client, Token(1), Ready::readable(), PollOpt::edge()) - .unwrap(); + event_loop.register(&client, Token(1), Ready::readable(), PollOpt::edge()).unwrap(); sleep_ms(250); diff --git a/test/test_timer.rs b/test/test_timer.rs index e16bda319..63d7fb53d 100644 --- a/test/test_timer.rs +++ b/test/test_timer.rs @@ -1,23 +1,21 @@ -use mio::deprecated::{EventLoop, Handler}; -use mio::timer::Timer; -use mio::*; use {sleep_ms, TryRead, TryWrite}; +use mio::*; +use mio::deprecated::{EventLoop, Handler}; +use mio::timer::{Timer}; +use mio::net::{TcpListener, TcpStream}; use bytes::{Buf, ByteBuf, SliceBuf}; use localhost; -use mio::net::{TcpListener, TcpStream}; use std::time::Duration; -use self::TestState::{AfterRead, Initial}; +use self::TestState::{Initial, AfterRead}; #[test] fn test_basic_timer_without_poll() { let mut timer = Timer::default(); // Set the timeout - timer - .set_timeout(Duration::from_millis(200), "hello") - .unwrap(); + timer.set_timeout(Duration::from_millis(200), "hello").unwrap(); // Nothing when polled immediately assert!(timer.poll().is_none()); @@ -37,11 +35,8 @@ fn test_basic_timer_with_poll_edge_set_timeout_after_register() { let mut events = Events::with_capacity(1024); let mut timer = Timer::default(); - poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()) - .unwrap(); - timer - .set_timeout(Duration::from_millis(200), "hello") - .unwrap(); + poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); + timer.set_timeout(Duration::from_millis(200), "hello").unwrap(); let elapsed = elapsed(|| { let num = poll.poll(&mut events, None).unwrap(); @@ -64,11 +59,8 @@ fn test_basic_timer_with_poll_edge_set_timeout_before_register() { let mut events = Events::with_capacity(1024); let mut timer = Timer::default(); - timer - .set_timeout(Duration::from_millis(200), "hello") - .unwrap(); - poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()) - .unwrap(); + timer.set_timeout(Duration::from_millis(200), "hello").unwrap(); + poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); let elapsed = elapsed(|| { let num = poll.poll(&mut events, None).unwrap(); @@ -91,15 +83,10 @@ fn test_setting_later_timeout_then_earlier_one() { let mut events = Events::with_capacity(1024); let mut timer = Timer::default(); - poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); - timer - .set_timeout(Duration::from_millis(600), "hello") - .unwrap(); - timer - .set_timeout(Duration::from_millis(200), "world") - .unwrap(); + timer.set_timeout(Duration::from_millis(600), "hello").unwrap(); + timer.set_timeout(Duration::from_millis(200), "world").unwrap(); let elapsed = elapsed(|| { let num = poll.poll(&mut events, None).unwrap(); @@ -132,17 +119,16 @@ fn test_timer_with_looping_wheel() { let poll = Poll::new().unwrap(); let mut events = Events::with_capacity(1024); - let mut timer = timer::Builder::default().num_slots(2).build(); + let mut timer = timer::Builder::default() + .num_slots(2) + .build(); - poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); - const TOKENS: &'static [&'static str] = &["hello", "world", "some", "thing"]; + const TOKENS: &'static [ &'static str ] = &[ "hello", "world", "some", "thing" ]; for (i, msg) in TOKENS.iter().enumerate() { - timer - .set_timeout(Duration::from_millis(500 * (i as u64 + 1)), msg) - .unwrap(); + timer.set_timeout(Duration::from_millis(500 * (i as u64 + 1)), msg).unwrap(); } for msg in TOKENS { @@ -154,14 +140,10 @@ fn test_timer_with_looping_wheel() { assert_eq!(Ready::readable(), events.get(0).unwrap().readiness()); }); - assert!( - is_about(500, elapsed), - "actual={:?}; msg={:?}", - elapsed, - msg - ); + assert!(is_about(500, elapsed), "actual={:?}; msg={:?}", elapsed, msg); assert_eq!(Some(msg), timer.poll()); assert_eq!(None, timer.poll()); + } } @@ -173,12 +155,9 @@ fn test_edge_without_polling() { let mut events = Events::with_capacity(1024); let mut timer = Timer::default(); - poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); - timer - .set_timeout(Duration::from_millis(400), "hello") - .unwrap(); + timer.set_timeout(Duration::from_millis(400), "hello").unwrap(); let ms = elapsed(|| { let num = poll.poll(&mut events, None).unwrap(); @@ -190,9 +169,7 @@ fn test_edge_without_polling() { assert!(is_about(400, ms), "actual={:?}", ms); let ms = elapsed(|| { - let num = poll - .poll(&mut events, Some(Duration::from_millis(300))) - .unwrap(); + let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); assert_eq!(num, 0); }); @@ -207,12 +184,9 @@ fn test_level_triggered() { let mut events = Events::with_capacity(1024); let mut timer = Timer::default(); - poll.register(&timer, Token(0), Ready::readable(), PollOpt::level()) - .unwrap(); + poll.register(&timer, Token(0), Ready::readable(), PollOpt::level()).unwrap(); - timer - .set_timeout(Duration::from_millis(400), "hello") - .unwrap(); + timer.set_timeout(Duration::from_millis(400), "hello").unwrap(); let ms = elapsed(|| { let num = poll.poll(&mut events, None).unwrap(); @@ -241,16 +215,9 @@ fn test_edge_oneshot_triggered() { let mut events = Events::with_capacity(1024); let mut timer = Timer::default(); - poll.register( - &timer, - Token(0), - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); - timer - .set_timeout(Duration::from_millis(200), "hello") - .unwrap(); + timer.set_timeout(Duration::from_millis(200), "hello").unwrap(); let ms = elapsed(|| { let num = poll.poll(&mut events, None).unwrap(); @@ -260,20 +227,13 @@ fn test_edge_oneshot_triggered() { assert!(is_about(200, ms), "actual={:?}", ms); let ms = elapsed(|| { - let num = poll - .poll(&mut events, Some(Duration::from_millis(300))) - .unwrap(); + let num = poll.poll(&mut events, Some(Duration::from_millis(300))).unwrap(); assert_eq!(num, 0); }); assert!(is_about(300, ms), "actual={:?}", ms); - poll.reregister( - &timer, - Token(0), - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + poll.reregister(&timer, Token(0), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); let ms = elapsed(|| { let num = poll.poll(&mut events, None).unwrap(); @@ -294,8 +254,7 @@ fn test_cancel_timeout() { timer.cancel_timeout(&timeout); let poll = Poll::new().unwrap(); - poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&timer, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); let mut events = Events::with_capacity(16); @@ -356,7 +315,7 @@ enum TestState { struct TestHandler { srv: TcpListener, cli: TcpStream, - state: TestState, + state: TestState } impl TestHandler { @@ -364,29 +323,22 @@ impl TestHandler { TestHandler { srv: srv, cli: cli, - state: Initial, + state: Initial } } - fn handle_read(&mut self, event_loop: &mut EventLoop, tok: Token, _events: Ready) { + fn handle_read(&mut self, event_loop: &mut EventLoop, + tok: Token, _events: Ready) { match tok { SERVER => { debug!("server connection ready for accept"); let conn = self.srv.accept().unwrap().0; - event_loop - .register( - &conn, - CONN, - Ready::readable() | Ready::writable(), - PollOpt::edge(), - ).unwrap(); - event_loop - .timeout(conn, Duration::from_millis(200)) - .unwrap(); - - event_loop - .reregister(&self.srv, SERVER, Ready::readable(), PollOpt::edge()) - .unwrap(); + event_loop.register(&conn, CONN, Ready::readable() | Ready::writable(), + PollOpt::edge()).unwrap(); + event_loop.timeout(conn, Duration::from_millis(200)).unwrap(); + + event_loop.reregister(&self.srv, SERVER, Ready::readable(), + PollOpt::edge()).unwrap(); } CLIENT => { debug!("client readable"); @@ -409,20 +361,17 @@ impl TestHandler { } } - event_loop - .reregister( - &self.cli, - CLIENT, - Ready::readable() | Ready::hup(), - PollOpt::edge(), - ).unwrap(); + event_loop.reregister(&self.cli, CLIENT, + Ready::readable() | Ready::hup(), + PollOpt::edge()).unwrap(); } CONN => {} _ => panic!("received unknown token {:?}", tok), } } - fn handle_write(&mut self, event_loop: &mut EventLoop, tok: Token, _: Ready) { + fn handle_write(&mut self, event_loop: &mut EventLoop, + tok: Token, _: Ready) { match tok { SERVER => panic!("received writable for token 0"), CLIENT => debug!("client connected"), @@ -430,9 +379,8 @@ impl TestHandler { _ => panic!("received unknown token {:?}", tok), } - event_loop - .reregister(&self.cli, CLIENT, Ready::readable(), PollOpt::edge()) - .unwrap(); + event_loop.reregister(&self.cli, CLIENT, Ready::readable(), + PollOpt::edge()).unwrap(); } } @@ -452,9 +400,7 @@ impl Handler for TestHandler { fn timeout(&mut self, _event_loop: &mut EventLoop, mut sock: TcpStream) { debug!("timeout handler : writing to socket"); - sock.try_write_buf(&mut SliceBuf::wrap(b"zomg")) - .unwrap() - .unwrap(); + sock.try_write_buf(&mut SliceBuf::wrap(b"zomg")).unwrap().unwrap(); } } @@ -471,24 +417,12 @@ pub fn test_old_timer() { info!("listening for connections"); - event_loop - .register( - &srv, - SERVER, - Ready::readable() | Ready::writable(), - PollOpt::edge(), - ).unwrap(); + event_loop.register(&srv, SERVER, Ready::readable() | Ready::writable(), PollOpt::edge()).unwrap(); let sock = TcpStream::connect(&addr).unwrap(); // Connect to the server - event_loop - .register( - &sock, - CLIENT, - Ready::readable() | Ready::writable(), - PollOpt::edge(), - ).unwrap(); + event_loop.register(&sock, CLIENT, Ready::readable() | Ready::writable(), PollOpt::edge()).unwrap(); // Init the handler let mut handler = TestHandler::new(srv, sock); diff --git a/test/test_udp_level.rs b/test/test_udp_level.rs index e8e1a87ed..7e19d54b3 100644 --- a/test/test_udp_level.rs +++ b/test/test_udp_level.rs @@ -1,6 +1,6 @@ +use mio::{Events, Poll, PollOpt, Ready, Token}; use mio::event::Event; use mio::net::UdpSocket; -use mio::{Events, Poll, PollOpt, Ready, Token}; use {expect_events, sleep_ms}; #[test] @@ -14,67 +14,39 @@ pub fn test_udp_level_triggered() { let tx = UdpSocket::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); let rx = UdpSocket::bind(&"127.0.0.1:0".parse().unwrap()).unwrap(); - poll.register( - &tx, - Token(0), - Ready::readable() | Ready::writable(), - PollOpt::level(), - ).unwrap(); - poll.register( - &rx, - Token(1), - Ready::readable() | Ready::writable(), - PollOpt::level(), - ).unwrap(); + poll.register(&tx, Token(0), Ready::readable() | Ready::writable(), PollOpt::level()).unwrap(); + poll.register(&rx, Token(1), Ready::readable() | Ready::writable(), PollOpt::level()).unwrap(); + for _ in 0..2 { - expect_events( - poll, - events, - 2, - vec![ - Event::new(Ready::writable(), Token(0)), - Event::new(Ready::writable(), Token(1)), - ], - ); + expect_events(poll, events, 2, vec![ + Event::new(Ready::writable(), Token(0)), + Event::new(Ready::writable(), Token(1)), + ]); } - tx.send_to(b"hello world!", &rx.local_addr().unwrap()) - .unwrap(); + tx.send_to(b"hello world!", &rx.local_addr().unwrap()).unwrap(); sleep_ms(250); for _ in 0..2 { - expect_events( - poll, - events, - 2, - vec![Event::new(Ready::readable() | Ready::writable(), Token(1))], - ); + expect_events(poll, events, 2, vec![ + Event::new(Ready::readable() | Ready::writable(), Token(1)) + ]); } let mut buf = [0; 200]; while rx.recv_from(&mut buf).is_ok() {} for _ in 0..2 { - expect_events( - poll, - events, - 4, - vec![Event::new(Ready::writable(), Token(1))], - ); + expect_events(poll, events, 4, vec![Event::new(Ready::writable(), Token(1))]); } - tx.send_to(b"hello world!", &rx.local_addr().unwrap()) - .unwrap(); + tx.send_to(b"hello world!", &rx.local_addr().unwrap()).unwrap(); sleep_ms(250); - expect_events( - poll, - events, - 10, - vec![Event::new(Ready::readable() | Ready::writable(), Token(1))], - ); + expect_events(poll, events, 10, + vec![Event::new(Ready::readable() | Ready::writable(), Token(1))]); drop(rx); } diff --git a/test/test_udp_socket.rs b/test/test_udp_socket.rs index d4504e2e9..dcb2e6cb9 100644 --- a/test/test_udp_socket.rs +++ b/test/test_udp_socket.rs @@ -1,10 +1,10 @@ -use bytes::{Buf, MutBuf, RingBuf, SliceBuf}; -use localhost; -use mio::net::UdpSocket; use mio::{Events, Poll, PollOpt, Ready, Token}; +use mio::net::UdpSocket; +use bytes::{Buf, RingBuf, SliceBuf, MutBuf}; use std::io::ErrorKind; use std::str; use std::time; +use localhost; const LISTENER: Token = Token(0); const SENDER: Token = Token(1); @@ -20,7 +20,7 @@ pub struct UdpHandlerSendRecv { } impl UdpHandlerSendRecv { - fn new(tx: UdpSocket, rx: UdpSocket, connected: bool, msg: &'static str) -> UdpHandlerSendRecv { + fn new(tx: UdpSocket, rx: UdpSocket, connected: bool, msg : &'static str) -> UdpHandlerSendRecv { UdpHandlerSendRecv { tx: tx, rx: rx, @@ -33,9 +33,11 @@ impl UdpHandlerSendRecv { } } -fn assert_send() {} +fn assert_send() { +} -fn assert_sync() {} +fn assert_sync() { +} #[cfg(test)] fn test_send_recv_udp(tx: UdpSocket, rx: UdpSocket, connected: bool) { @@ -47,18 +49,13 @@ fn test_send_recv_udp(tx: UdpSocket, rx: UdpSocket, connected: bool) { // ensure that the sockets are non-blocking let mut buf = [0; 128]; - assert_eq!( - ErrorKind::WouldBlock, - rx.recv_from(&mut buf).unwrap_err().kind() - ); + assert_eq!(ErrorKind::WouldBlock, rx.recv_from(&mut buf).unwrap_err().kind()); info!("Registering SENDER"); - poll.register(&tx, SENDER, Ready::writable(), PollOpt::edge()) - .unwrap(); + poll.register(&tx, SENDER, Ready::writable(), PollOpt::edge()).unwrap(); info!("Registering LISTENER"); - poll.register(&rx, LISTENER, Ready::readable(), PollOpt::edge()) - .unwrap(); + poll.register(&rx, LISTENER, Ready::readable(), PollOpt::edge()).unwrap(); let mut events = Events::with_capacity(1024); @@ -81,13 +78,11 @@ fn test_send_recv_udp(tx: UdpSocket, rx: UdpSocket, connected: bool) { } }; - unsafe { - MutBuf::advance(&mut handler.rx_buf, cnt); - } + unsafe { MutBuf::advance(&mut handler.rx_buf, cnt); } assert!(str::from_utf8(handler.rx_buf.bytes()).unwrap() == handler.msg); handler.shutdown = true; - } - _ => (), + }, + _ => () } } @@ -102,7 +97,7 @@ fn test_send_recv_udp(tx: UdpSocket, rx: UdpSocket, connected: bool) { }; handler.buf.advance(cnt); - } + }, _ => {} } } @@ -150,7 +145,7 @@ pub fn test_udp_socket_discard() { let tx_addr = tx.local_addr().unwrap(); let rx_addr = rx.local_addr().unwrap(); - + assert!(tx.connect(rx_addr).is_ok()); assert!(udp_outside.connect(rx_addr).is_ok()); assert!(rx.connect(tx_addr).is_ok()); @@ -160,21 +155,20 @@ pub fn test_udp_socket_discard() { let r = udp_outside.send("hello world".as_bytes()); assert!(r.is_ok() || r.unwrap_err().kind() == ErrorKind::WouldBlock); - poll.register(&rx, LISTENER, Ready::readable(), PollOpt::edge()) - .unwrap(); - poll.register(&tx, SENDER, Ready::writable(), PollOpt::edge()) - .unwrap(); + poll.register(&rx, LISTENER, Ready::readable(), PollOpt::edge()).unwrap(); + poll.register(&tx, SENDER, Ready::writable(), PollOpt::edge()).unwrap(); let mut events = Events::with_capacity(1024); - poll.poll(&mut events, Some(time::Duration::from_secs(5))) - .unwrap(); + poll.poll(&mut events, Some(time::Duration::from_secs(5))).unwrap(); for event in &events { if event.readiness().is_readable() { match event.token() { - LISTENER => assert!(false, "Expected to no receive a packet but got something"), - _ => (), + LISTENER => { + assert!(false, "Expected to no receive a packet but got something") + }, + _ => () } } } diff --git a/test/test_uds_shutdown.rs b/test/test_uds_shutdown.rs index 563ab4562..58d2431e8 100644 --- a/test/test_uds_shutdown.rs +++ b/test/test_uds_shutdown.rs @@ -1,12 +1,12 @@ -use bytes::{Buf, ByteBuf, MutByteBuf, SliceBuf}; -use mio::deprecated::unix::*; -use mio::deprecated::{EventLoop, Handler}; +use {TryRead, TryWrite}; use mio::*; +use mio::deprecated::{EventLoop, Handler}; +use mio::deprecated::unix::*; +use bytes::{Buf, ByteBuf, MutByteBuf, SliceBuf}; use slab::Slab; use std::io; use std::path::PathBuf; use tempdir::TempDir; -use {TryRead, TryWrite}; const SERVER: Token = Token(10_000_000); const CLIENT: Token = Token(10_000_001); @@ -16,7 +16,7 @@ struct EchoConn { buf: Option, mut_buf: Option, token: Option, - interest: Ready, + interest: Ready } impl EchoConn { @@ -26,7 +26,7 @@ impl EchoConn { buf: None, mut_buf: Some(ByteBuf::mut_with_capacity(2048)), token: None, - interest: Ready::hup(), + interest: Ready::hup() } } @@ -48,19 +48,15 @@ impl EchoConn { self.interest.insert(Ready::readable()); self.interest.remove(Ready::writable()); match self.sock.shutdown(Shutdown::Write) { - Err(e) => panic!(e), - _ => {} + Err(e) => panic!(e), + _ => {}, } } Err(e) => debug!("not implemented; client err={:?}", e), } - event_loop.reregister( - &self.sock, - self.token.unwrap(), - self.interest, - PollOpt::edge() | PollOpt::oneshot(), - ) + event_loop.reregister(&self.sock, self.token.unwrap(), self.interest, + PollOpt::edge() | PollOpt::oneshot()) } fn readable(&mut self, event_loop: &mut EventLoop) -> io::Result<()> { @@ -84,20 +80,17 @@ impl EchoConn { debug!("not implemented; client err={:?}", e); self.interest.remove(Ready::readable()); } + }; - event_loop.reregister( - &self.sock, - self.token.unwrap(), - self.interest, - PollOpt::edge(), - ) + event_loop.reregister(&self.sock, self.token.unwrap(), self.interest, + PollOpt::edge()) } } struct EchoServer { sock: UnixListener, - conns: Slab, + conns: Slab } impl EchoServer { @@ -105,29 +98,26 @@ impl EchoServer { debug!("server accepting socket"); let sock = self.sock.accept().unwrap(); - let conn = EchoConn::new(sock); + let conn = EchoConn::new(sock,); let tok = self.conns.insert(conn); // Register the connection self.conns[tok].token = Some(Token(tok)); - event_loop - .register( - &self.conns[tok].sock, - Token(tok), - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ).ok() - .expect("could not register socket with event loop"); + event_loop.register(&self.conns[tok].sock, Token(tok), Ready::readable(), + PollOpt::edge() | PollOpt::oneshot()) + .ok().expect("could not register socket with event loop"); Ok(()) } - fn conn_readable(&mut self, event_loop: &mut EventLoop, tok: Token) -> io::Result<()> { + fn conn_readable(&mut self, event_loop: &mut EventLoop, + tok: Token) -> io::Result<()> { debug!("server conn readable; tok={:?}", tok); self.conn(tok).readable(event_loop) } - fn conn_writable(&mut self, event_loop: &mut EventLoop, tok: Token) -> io::Result<()> { + fn conn_writable(&mut self, event_loop: &mut EventLoop, + tok: Token) -> io::Result<()> { debug!("server conn writable; tok={:?}", tok); self.conn(tok).writable(event_loop) } @@ -144,12 +134,13 @@ struct EchoClient { rx: SliceBuf<'static>, mut_buf: Option, token: Token, - interest: Ready, + interest: Ready } + // Sends a message and expects to receive the same exact message, one at a time impl EchoClient { - fn new(sock: UnixStream, tok: Token, mut msgs: Vec<&'static str>) -> EchoClient { + fn new(sock: UnixStream, tok: Token, mut msgs: Vec<&'static str>) -> EchoClient { let curr = msgs.remove(0); EchoClient { @@ -159,7 +150,7 @@ impl EchoClient { rx: SliceBuf::wrap(curr.as_bytes()), mut_buf: Some(ByteBuf::mut_with_capacity(2048)), token: tok, - interest: Ready::none(), + interest: Ready::none() } } @@ -176,24 +167,24 @@ impl EchoClient { Ok(Some(r)) => { if r == 0 { self.interest.remove(Ready::readable()); - event_loop.shutdown(); + event_loop.shutdown(); } else { - debug!("CLIENT : We read {} bytes!", r); + debug!("CLIENT : We read {} bytes!", r); - // prepare for reading - let mut buf = buf.flip(); + // prepare for reading + let mut buf = buf.flip(); - while buf.has_remaining() { - let actual = buf.read_byte().unwrap(); - let expect = self.rx.read_byte().unwrap(); + while buf.has_remaining() { + let actual = buf.read_byte().unwrap(); + let expect = self.rx.read_byte().unwrap(); - assert!(actual == expect, "actual={}; expect={}", actual, expect); - } + assert!(actual == expect, "actual={}; expect={}", actual, expect); + } - self.mut_buf = Some(buf.flip()); - if !self.rx.has_remaining() { - self.next_msg(event_loop).unwrap(); - } + self.mut_buf = Some(buf.flip()); + if !self.rx.has_remaining() { + self.next_msg(event_loop).unwrap(); + } } } Err(e) => { @@ -201,12 +192,8 @@ impl EchoClient { } }; - event_loop.reregister( - &self.sock, - self.token, - self.interest, - PollOpt::edge() | PollOpt::oneshot(), - ) + event_loop.reregister(&self.sock, self.token, self.interest, + PollOpt::edge() | PollOpt::oneshot()) } fn writable(&mut self, event_loop: &mut EventLoop) -> io::Result<()> { @@ -222,19 +209,16 @@ impl EchoClient { self.interest.insert(Ready::readable()); self.interest.remove(Ready::writable()); } - Err(e) => debug!("not implemented; client err={:?}", e), + Err(e) => debug!("not implemented; client err={:?}", e) } - event_loop.reregister( - &self.sock, - self.token, - self.interest, - PollOpt::edge() | PollOpt::oneshot(), - ) + event_loop.reregister(&self.sock, self.token, self.interest, + PollOpt::edge() | PollOpt::oneshot()) } fn next_msg(&mut self, event_loop: &mut EventLoop) -> io::Result<()> { if self.msgs.is_empty() { + return Ok(()); } @@ -245,12 +229,8 @@ impl EchoClient { self.rx = SliceBuf::wrap(curr.as_bytes()); self.interest.insert(Ready::writable()); - event_loop.reregister( - &self.sock, - self.token, - self.interest, - PollOpt::edge() | PollOpt::oneshot(), - ) + event_loop.reregister(&self.sock, self.token, self.interest, + PollOpt::edge() | PollOpt::oneshot()) } } @@ -264,9 +244,9 @@ impl Echo { Echo { server: EchoServer { sock: srv, - conns: Slab::with_capacity(128), + conns: Slab::with_capacity(128) }, - client: EchoClient::new(client, CLIENT, msgs), + client: EchoClient::new(client, CLIENT, msgs) } } } @@ -275,13 +255,14 @@ impl Handler for Echo { type Timeout = usize; type Message = (); - fn ready(&mut self, event_loop: &mut EventLoop, token: Token, events: Ready) { + fn ready(&mut self, event_loop: &mut EventLoop, token: Token, + events: Ready) { debug!("ready {:?} {:?}", token, events); if events.is_readable() { match token { SERVER => self.server.accept(event_loop).unwrap(), CLIENT => self.client.readable(event_loop).unwrap(), - i => self.server.conn_readable(event_loop, i).unwrap(), + i => self.server.conn_readable(event_loop, i).unwrap() } } @@ -289,7 +270,7 @@ impl Handler for Echo { match token { SERVER => panic!("received writable for token 0"), CLIENT => self.client.writable(event_loop).unwrap(), - _ => self.server.conn_writable(event_loop, token).unwrap(), + _ => self.server.conn_writable(event_loop, token).unwrap() }; } } @@ -305,27 +286,15 @@ pub fn test_echo_server() { let srv = UnixListener::bind(&addr).unwrap(); - event_loop - .register( - &srv, - SERVER, - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + event_loop.register(&srv, SERVER, Ready::readable(), + PollOpt::edge() | PollOpt::oneshot()).unwrap(); let sock = UnixStream::connect(&addr).unwrap(); // Connect to the server - event_loop - .register( - &sock, - CLIENT, - Ready::writable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + event_loop.register(&sock, CLIENT, Ready::writable(), + PollOpt::edge() | PollOpt::oneshot()).unwrap(); // Start the event loop - event_loop - .run(&mut Echo::new(srv, sock, vec!["foo", "bar"])) - .unwrap(); + event_loop.run(&mut Echo::new(srv, sock, vec!["foo", "bar"])).unwrap(); } diff --git a/test/test_unix_echo_server.rs b/test/test_unix_echo_server.rs index 0ef2bb9d7..6f3dd4b69 100644 --- a/test/test_unix_echo_server.rs +++ b/test/test_unix_echo_server.rs @@ -1,12 +1,12 @@ -use bytes::{Buf, ByteBuf, MutByteBuf, SliceBuf}; -use mio::deprecated::unix::*; -use mio::deprecated::{EventLoop, Handler}; +use {TryRead, TryWrite}; use mio::*; +use mio::deprecated::{EventLoop, Handler}; +use mio::deprecated::unix::*; +use bytes::{Buf, ByteBuf, MutByteBuf, SliceBuf}; use slab::Slab; -use std::io; use std::path::PathBuf; +use std::io; use tempdir::TempDir; -use {TryRead, TryWrite}; const SERVER: Token = Token(10_000_000); const CLIENT: Token = Token(10_000_001); @@ -50,17 +50,8 @@ impl EchoConn { Err(e) => debug!("not implemented; client err={:?}", e), } - assert!( - self.interest.is_readable() || self.interest.is_writable(), - "actual={:?}", - self.interest - ); - event_loop.reregister( - &self.sock, - self.token.unwrap(), - self.interest, - PollOpt::edge() | PollOpt::oneshot(), - ) + assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); + event_loop.reregister(&self.sock, self.token.unwrap(), self.interest, PollOpt::edge() | PollOpt::oneshot()) } fn readable(&mut self, event_loop: &mut EventLoop) -> io::Result<()> { @@ -84,25 +75,17 @@ impl EchoConn { debug!("not implemented; client err={:?}", e); self.interest.remove(Ready::readable()); } + }; - assert!( - self.interest.is_readable() || self.interest.is_writable(), - "actual={:?}", - self.interest - ); - event_loop.reregister( - &self.sock, - self.token.unwrap(), - self.interest, - PollOpt::edge() | PollOpt::oneshot(), - ) + assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); + event_loop.reregister(&self.sock, self.token.unwrap(), self.interest, PollOpt::edge() | PollOpt::oneshot()) } } struct EchoServer { sock: UnixListener, - conns: Slab, + conns: Slab } impl EchoServer { @@ -115,14 +98,8 @@ impl EchoServer { // Register the connection self.conns[tok].token = Some(Token(tok)); - event_loop - .register( - &self.conns[tok].sock, - Token(tok), - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ).ok() - .expect("could not register socket with event loop"); + event_loop.register(&self.conns[tok].sock, Token(tok), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()) + .ok().expect("could not register socket with event loop"); Ok(()) } @@ -152,9 +129,10 @@ struct EchoClient { interest: Ready, } + // Sends a message and expects to receive the same exact message, one at a time impl EchoClient { - fn new(sock: UnixStream, tok: Token, mut msgs: Vec<&'static str>) -> EchoClient { + fn new(sock: UnixStream, tok: Token, mut msgs: Vec<&'static str>) -> EchoClient { let curr = msgs.remove(0); EchoClient { @@ -184,11 +162,7 @@ impl EchoClient { // prepare for reading let mut buf = buf.flip(); - debug!( - "CLIENT : buf = {:?} -- rx = {:?}", - buf.bytes(), - self.rx.bytes() - ); + debug!("CLIENT : buf = {:?} -- rx = {:?}", buf.bytes(), self.rx.bytes()); while buf.has_remaining() { let actual = buf.read_byte().unwrap(); let expect = self.rx.read_byte().unwrap(); @@ -210,17 +184,8 @@ impl EchoClient { }; if !self.interest.is_none() { - assert!( - self.interest.is_readable() || self.interest.is_writable(), - "actual={:?}", - self.interest - ); - event_loop.reregister( - &self.sock, - self.token, - self.interest, - PollOpt::edge() | PollOpt::oneshot(), - )?; + assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); + event_loop.reregister(&self.sock, self.token, self.interest, PollOpt::edge() | PollOpt::oneshot())?; } Ok(()) @@ -239,20 +204,11 @@ impl EchoClient { self.interest.insert(Ready::readable()); self.interest.remove(Ready::writable()); } - Err(e) => debug!("not implemented; client err={:?}", e), + Err(e) => debug!("not implemented; client err={:?}", e) } - assert!( - self.interest.is_readable() || self.interest.is_writable(), - "actual={:?}", - self.interest - ); - event_loop.reregister( - &self.sock, - self.token, - self.interest, - PollOpt::edge() | PollOpt::oneshot(), - ) + assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); + event_loop.reregister(&self.sock, self.token, self.interest, PollOpt::edge() | PollOpt::oneshot()) } fn next_msg(&mut self, event_loop: &mut EventLoop) -> io::Result<()> { @@ -268,17 +224,8 @@ impl EchoClient { self.rx = SliceBuf::wrap(curr.as_bytes()); self.interest.insert(Ready::writable()); - assert!( - self.interest.is_readable() || self.interest.is_writable(), - "actual={:?}", - self.interest - ); - event_loop.reregister( - &self.sock, - self.token, - self.interest, - PollOpt::edge() | PollOpt::oneshot(), - ) + assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); + event_loop.reregister(&self.sock, self.token, self.interest, PollOpt::edge() | PollOpt::oneshot()) } } @@ -292,9 +239,9 @@ impl Echo { Echo { server: EchoServer { sock: srv, - conns: Slab::with_capacity(128), + conns: Slab::with_capacity(128) }, - client: EchoClient::new(client, CLIENT, msgs), + client: EchoClient::new(client, CLIENT, msgs) } } } @@ -308,7 +255,7 @@ impl Handler for Echo { match token { SERVER => self.server.accept(event_loop).unwrap(), CLIENT => self.client.readable(event_loop).unwrap(), - i => self.server.conn_readable(event_loop, i).unwrap(), + i => self.server.conn_readable(event_loop, i).unwrap() }; } @@ -316,7 +263,7 @@ impl Handler for Echo { match token { SERVER => panic!("received writable for token 0"), CLIENT => self.client.writable(event_loop).unwrap(), - _ => self.server.conn_writable(event_loop, token).unwrap(), + _ => self.server.conn_writable(event_loop, token).unwrap() }; } } @@ -333,27 +280,13 @@ pub fn test_unix_echo_server() { let srv = UnixListener::bind(&addr).unwrap(); info!("listen for connections"); - event_loop - .register( - &srv, - SERVER, - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + event_loop.register(&srv, SERVER, Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); let sock = UnixStream::connect(&addr).unwrap(); // Connect to the server - event_loop - .register( - &sock, - CLIENT, - Ready::writable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + event_loop.register(&sock, CLIENT, Ready::writable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); // Start the event loop - event_loop - .run(&mut Echo::new(srv, sock, vec!["foo", "bar"])) - .unwrap(); + event_loop.run(&mut Echo::new(srv, sock, vec!["foo", "bar"])).unwrap(); } diff --git a/test/test_unix_pass_fd.rs b/test/test_unix_pass_fd.rs index 438fbc26f..f43ec2273 100644 --- a/test/test_unix_pass_fd.rs +++ b/test/test_unix_pass_fd.rs @@ -1,13 +1,13 @@ -use bytes::{Buf, ByteBuf, SliceBuf}; -use mio::deprecated::unix::*; -use mio::deprecated::{EventLoop, Handler}; +use {TryRead, TryWrite}; use mio::*; +use mio::deprecated::{EventLoop, Handler}; +use mio::deprecated::unix::*; +use bytes::{Buf, ByteBuf, SliceBuf}; use slab::Slab; +use std::path::PathBuf; use std::io::{self, Read}; use std::os::unix::io::{AsRawFd, FromRawFd}; -use std::path::PathBuf; use tempdir::TempDir; -use {TryRead, TryWrite}; const SERVER: Token = Token(10_000_000); const CLIENT: Token = Token(10_000_001); @@ -48,17 +48,8 @@ impl EchoConn { Err(e) => debug!("not implemented; client err={:?}", e), } - assert!( - self.interest.is_readable() || self.interest.is_writable(), - "actual={:?}", - self.interest - ); - event_loop.reregister( - &self.sock, - self.token.unwrap(), - self.interest, - PollOpt::edge() | PollOpt::oneshot(), - ) + assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); + event_loop.reregister(&self.sock, self.token.unwrap(), self.interest, PollOpt::edge() | PollOpt::oneshot()) } fn readable(&mut self, event_loop: &mut EventLoop) -> io::Result<()> { @@ -77,6 +68,7 @@ impl EchoConn { debug!("not implemented; client err={:?}", e); self.interest.remove(Ready::readable()); } + }; // create fd to pass back. Assume that the write will work @@ -97,23 +89,14 @@ impl EchoConn { } self.pipe_fd = Some(rd); - assert!( - self.interest.is_readable() || self.interest.is_writable(), - "actual={:?}", - self.interest - ); - event_loop.reregister( - &self.sock, - self.token.unwrap(), - self.interest, - PollOpt::edge() | PollOpt::oneshot(), - ) + assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); + event_loop.reregister(&self.sock, self.token.unwrap(), self.interest, PollOpt::edge() | PollOpt::oneshot()) } } struct EchoServer { sock: UnixListener, - conns: Slab, + conns: Slab } impl EchoServer { @@ -126,14 +109,8 @@ impl EchoServer { // Register the connection self.conns[tok].token = Some(Token(tok)); - event_loop - .register( - &self.conns[tok].sock, - Token(tok), - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ).ok() - .expect("could not register socket with event loop"); + event_loop.register(&self.conns[tok].sock, Token(tok), Ready::readable(), PollOpt::edge() | PollOpt::oneshot()) + .ok().expect("could not register socket with event loop"); Ok(()) } @@ -162,9 +139,10 @@ struct EchoClient { interest: Ready, } + // Sends a message and expects to receive the same exact message, one at a time impl EchoClient { - fn new(sock: UnixStream, tok: Token, mut msgs: Vec<&'static str>) -> EchoClient { + fn new(sock: UnixStream, tok: Token, mut msgs: Vec<&'static str>) -> EchoClient { let curr = msgs.remove(0); EchoClient { @@ -221,17 +199,8 @@ impl EchoClient { } if !self.interest.is_none() { - assert!( - self.interest.is_readable() || self.interest.is_writable(), - "actual={:?}", - self.interest - ); - event_loop.reregister( - &self.sock, - self.token, - self.interest, - PollOpt::edge() | PollOpt::oneshot(), - )?; + assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); + event_loop.reregister(&self.sock, self.token, self.interest, PollOpt::edge() | PollOpt::oneshot())?; } Ok(()) @@ -250,20 +219,11 @@ impl EchoClient { self.interest.insert(Ready::readable()); self.interest.remove(Ready::writable()); } - Err(e) => debug!("not implemented; client err={:?}", e), + Err(e) => debug!("not implemented; client err={:?}", e) } - assert!( - self.interest.is_readable() || self.interest.is_writable(), - "actual={:?}", - self.interest - ); - event_loop.reregister( - &self.sock, - self.token, - self.interest, - PollOpt::edge() | PollOpt::oneshot(), - ) + assert!(self.interest.is_readable() || self.interest.is_writable(), "actual={:?}", self.interest); + event_loop.reregister(&self.sock, self.token, self.interest, PollOpt::edge() | PollOpt::oneshot()) } fn next_msg(&mut self, event_loop: &mut EventLoop) -> io::Result<()> { @@ -279,12 +239,7 @@ impl EchoClient { self.rx = SliceBuf::wrap(curr.as_bytes()); self.interest.insert(Ready::writable()); - event_loop.reregister( - &self.sock, - self.token, - self.interest, - PollOpt::edge() | PollOpt::oneshot(), - ) + event_loop.reregister(&self.sock, self.token, self.interest, PollOpt::edge() | PollOpt::oneshot()) } } @@ -298,9 +253,9 @@ impl Echo { Echo { server: EchoServer { sock: srv, - conns: Slab::with_capacity(128), + conns: Slab::with_capacity(128) }, - client: EchoClient::new(client, CLIENT, msgs), + client: EchoClient::new(client, CLIENT, msgs) } } } @@ -314,7 +269,7 @@ impl Handler for Echo { match token { SERVER => self.server.accept(event_loop).unwrap(), CLIENT => self.client.readable(event_loop).unwrap(), - i => self.server.conn_readable(event_loop, i).unwrap(), + i => self.server.conn_readable(event_loop, i).unwrap() }; } @@ -322,7 +277,7 @@ impl Handler for Echo { match token { SERVER => panic!("received writable for token 0"), CLIENT => self.client.writable(event_loop).unwrap(), - _ => self.server.conn_writable(event_loop, token).unwrap(), + _ => self.server.conn_writable(event_loop, token).unwrap() }; } } @@ -339,27 +294,13 @@ pub fn test_unix_pass_fd() { let srv = UnixListener::bind(&addr).unwrap(); info!("listen for connections"); - event_loop - .register( - &srv, - SERVER, - Ready::readable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + event_loop.register(&srv, SERVER, Ready::readable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); let sock = UnixStream::connect(&addr).unwrap(); // Connect to the server - event_loop - .register( - &sock, - CLIENT, - Ready::writable(), - PollOpt::edge() | PollOpt::oneshot(), - ).unwrap(); + event_loop.register(&sock, CLIENT, Ready::writable(), PollOpt::edge() | PollOpt::oneshot()).unwrap(); // Start the event loop - event_loop - .run(&mut Echo::new(srv, sock, vec!["foo", "bar"])) - .unwrap(); + event_loop.run(&mut Echo::new(srv, sock, vec!["foo", "bar"])).unwrap(); } diff --git a/test/test_write_then_drop.rs b/test/test_write_then_drop.rs index 64f3191d0..aa478eaf4 100644 --- a/test/test_write_then_drop.rs +++ b/test/test_write_then_drop.rs @@ -1,8 +1,8 @@ -use std::io::{Read, Write}; +use std::io::{Write, Read}; use mio::event::Evented; use mio::net::{TcpListener, TcpStream}; -use mio::{Events, Poll, PollOpt, Ready, Token}; +use mio::{Poll, Events, Ready, PollOpt, Token}; #[test] fn write_then_drop() { @@ -14,10 +14,14 @@ fn write_then_drop() { let poll = Poll::new().unwrap(); - a.register(&poll, Token(1), Ready::readable(), PollOpt::edge()) - .unwrap(); - s.register(&poll, Token(3), Ready::empty(), PollOpt::edge()) - .unwrap(); + a.register(&poll, + Token(1), + Ready::readable(), + PollOpt::edge()).unwrap(); + s.register(&poll, + Token(3), + Ready::empty(), + PollOpt::edge()).unwrap(); let mut events = Events::with_capacity(1024); while events.len() == 0 { @@ -28,8 +32,10 @@ fn write_then_drop() { let mut s2 = a.accept().unwrap().0; - s2.register(&poll, Token(2), Ready::writable(), PollOpt::edge()) - .unwrap(); + s2.register(&poll, + Token(2), + Ready::writable(), + PollOpt::edge()).unwrap(); let mut events = Events::with_capacity(1024); while events.len() == 0 { @@ -41,8 +47,10 @@ fn write_then_drop() { s2.write(&[1, 2, 3, 4]).unwrap(); drop(s2); - s.reregister(&poll, Token(3), Ready::readable(), PollOpt::edge()) - .unwrap(); + s.reregister(&poll, + Token(3), + Ready::readable(), + PollOpt::edge()).unwrap(); let mut events = Events::with_capacity(1024); while events.len() == 0 { poll.poll(&mut events, None).unwrap(); @@ -65,10 +73,14 @@ fn write_then_deregister() { let poll = Poll::new().unwrap(); - a.register(&poll, Token(1), Ready::readable(), PollOpt::edge()) - .unwrap(); - s.register(&poll, Token(3), Ready::empty(), PollOpt::edge()) - .unwrap(); + a.register(&poll, + Token(1), + Ready::readable(), + PollOpt::edge()).unwrap(); + s.register(&poll, + Token(3), + Ready::empty(), + PollOpt::edge()).unwrap(); let mut events = Events::with_capacity(1024); while events.len() == 0 { @@ -79,8 +91,10 @@ fn write_then_deregister() { let mut s2 = a.accept().unwrap().0; - s2.register(&poll, Token(2), Ready::writable(), PollOpt::edge()) - .unwrap(); + s2.register(&poll, + Token(2), + Ready::writable(), + PollOpt::edge()).unwrap(); let mut events = Events::with_capacity(1024); while events.len() == 0 { @@ -92,8 +106,10 @@ fn write_then_deregister() { s2.write(&[1, 2, 3, 4]).unwrap(); s2.deregister(&poll).unwrap(); - s.reregister(&poll, Token(3), Ready::readable(), PollOpt::edge()) - .unwrap(); + s.reregister(&poll, + Token(3), + Ready::readable(), + PollOpt::edge()).unwrap(); let mut events = Events::with_capacity(1024); while events.len() == 0 { poll.poll(&mut events, None).unwrap(); From 132bc80f0c475b34fc2715c6c52f0d255a78771d Mon Sep 17 00:00:00 2001 From: PerfectLaugh Date: Tue, 21 Aug 2018 08:11:52 +0800 Subject: [PATCH 4/6] delete incomplete test first --- test/mod.rs | 1 - ...st_drop_cancels_interest_and_shuts_down.rs | 62 ------------------- 2 files changed, 63 deletions(-) delete mode 100644 test/test_drop_cancels_interest_and_shuts_down.rs diff --git a/test/mod.rs b/test/mod.rs index d88038eae..75cda53f4 100644 --- a/test/mod.rs +++ b/test/mod.rs @@ -33,7 +33,6 @@ mod test_tcp_level; mod test_udp_level; mod test_udp_socket; mod test_write_then_drop; -mod test_drop_cancels_interest_and_shuts_down; #[cfg(feature = "with-deprecated")] mod test_notify; diff --git a/test/test_drop_cancels_interest_and_shuts_down.rs b/test/test_drop_cancels_interest_and_shuts_down.rs deleted file mode 100644 index e03fe2d14..000000000 --- a/test/test_drop_cancels_interest_and_shuts_down.rs +++ /dev/null @@ -1,62 +0,0 @@ -#[test] -fn drop_cancels_interest_and_shuts_down() { - use mio::net::TcpStream; - use mio::*; - use std::io; - use std::io::Read; - use std::net::TcpListener; - use std::thread; - use std::time::Duration; - - use env_logger; - let _ = env_logger::init(); - let l = TcpListener::bind("127.0.0.1:18000").unwrap(); - let addr = l.local_addr().unwrap(); - - let t = thread::spawn(move || { - let mut s = l.incoming().next().unwrap().unwrap(); - s.set_read_timeout(Some(Duration::from_secs(5))) - .expect("set_read_timeout"); - let r = s.read(&mut [0; 16]); - match r { - Ok(_) => (), - Err(e) => { - if e.kind() != io::ErrorKind::UnexpectedEof { - eprintln!("{}", e); - panic!(e); - } - } - } - }); - - let poll = Poll::new().unwrap(); - let mut s = TcpStream::connect(&addr).unwrap(); - - poll.register( - &s, - Token(1), - Ready::readable() | Ready::writable(), - PollOpt::edge(), - ).unwrap(); - let mut events = Events::with_capacity(16); - 'outer: loop { - poll.poll(&mut events, None).unwrap(); - for event in &events { - if event.token() == Token(1) { - // connected - break 'outer; - } - } - } - - let mut b = [0; 1024]; - match s.read(&mut b) { - Ok(_) => panic!("unexpected ok"), - Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => (), - Err(e) => panic!("unexpected error: {:?}", e), - } - - drop(poll); - drop(s); - t.join().unwrap(); -} From 67720d25f5608c3be67fce9c4cb78d8e9c596333 Mon Sep 17 00:00:00 2001 From: PerfectLaugh Date: Tue, 21 Aug 2018 08:56:02 +0800 Subject: [PATCH 5/6] add test --- src/sys/windows/from_raw_arc.rs | 5 +- src/sys/windows/selector.rs | 2 +- test/mod.rs | 1 + ...st_drop_cancels_interest_and_shuts_down.rs | 60 +++++++++++++++++++ 4 files changed, 64 insertions(+), 4 deletions(-) create mode 100644 test/test_drop_cancels_interest_and_shuts_down.rs diff --git a/src/sys/windows/from_raw_arc.rs b/src/sys/windows/from_raw_arc.rs index 61f0e49cd..2fbdfed21 100644 --- a/src/sys/windows/from_raw_arc.rs +++ b/src/sys/windows/from_raw_arc.rs @@ -97,11 +97,10 @@ pub struct FromRawArcStore { impl FromRawArcStore { pub fn new(ptr: *mut OVERLAPPED, deallocator: fn(*mut OVERLAPPED)) -> FromRawArcStore { - let store = FromRawArcStore { + FromRawArcStore { _ptr: unsafe { mem::transmute(ptr) }, deallocator: deallocator, - }; - store + } } } diff --git a/src/sys/windows/selector.rs b/src/sys/windows/selector.rs index d6a9cc826..385e27c69 100644 --- a/src/sys/windows/selector.rs +++ b/src/sys/windows/selector.rs @@ -103,7 +103,7 @@ impl Selector { match pos { Some(pos) => { let store = incompletes.remove(pos); - mem::forget(store); + mem::forget(store.1); }, None => { trace!("cannot find store, omiting..."); diff --git a/test/mod.rs b/test/mod.rs index 75cda53f4..d88038eae 100644 --- a/test/mod.rs +++ b/test/mod.rs @@ -33,6 +33,7 @@ mod test_tcp_level; mod test_udp_level; mod test_udp_socket; mod test_write_then_drop; +mod test_drop_cancels_interest_and_shuts_down; #[cfg(feature = "with-deprecated")] mod test_notify; diff --git a/test/test_drop_cancels_interest_and_shuts_down.rs b/test/test_drop_cancels_interest_and_shuts_down.rs new file mode 100644 index 000000000..dede12d8f --- /dev/null +++ b/test/test_drop_cancels_interest_and_shuts_down.rs @@ -0,0 +1,60 @@ +#[test] +fn drop_cancels_interest_and_shuts_down() { + use mio::net::TcpStream; + use mio::*; + use std::io; + use std::io::Read; + use std::net::TcpListener; + use std::thread; + use std::time::Duration; + + use env_logger; + let _ = env_logger::init(); + let l = TcpListener::bind("127.0.0.1:0").unwrap(); + let addr = l.local_addr().unwrap(); + + let t = thread::spawn(move || { + let mut s = l.incoming().next().unwrap().unwrap(); + s.set_read_timeout(Some(Duration::from_secs(5))) + .expect("set_read_timeout"); + let r = s.read(&mut [0; 16]); + match r { + Ok(_) => (), + Err(e) => { + if e.kind() != io::ErrorKind::UnexpectedEof { + panic!(e); + } + } + } + }); + + let poll = Poll::new().unwrap(); + let mut s = TcpStream::connect(&addr).unwrap(); + + poll.register( + &s, + Token(1), + Ready::readable() | Ready::writable(), + PollOpt::edge(), + ).unwrap(); + let mut events = Events::with_capacity(16); + 'outer: loop { + poll.poll(&mut events, None).unwrap(); + for event in &events { + if event.token() == Token(1) { + // connected + break 'outer; + } + } + } + + let mut b = [0; 1024]; + match s.read(&mut b) { + Ok(_) => panic!("unexpected ok"), + Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => (), + Err(e) => panic!("unexpected error: {:?}", e), + } + + drop(s); + t.join().unwrap(); +} From f3f1c9c8a040fd510831b24941effc7c2eb2d08a Mon Sep 17 00:00:00 2001 From: PerfectLaugh Date: Tue, 21 Aug 2018 09:15:18 +0800 Subject: [PATCH 6/6] fix missing omit continue --- src/sys/windows/selector.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/sys/windows/selector.rs b/src/sys/windows/selector.rs index 385e27c69..cbdf4589a 100644 --- a/src/sys/windows/selector.rs +++ b/src/sys/windows/selector.rs @@ -103,10 +103,11 @@ impl Selector { match pos { Some(pos) => { let store = incompletes.remove(pos); - mem::forget(store.1); + mem::forget(store); }, None => { trace!("cannot find store, omiting..."); + continue; } } }