tokio-rs/tokio
1
0
Fork 0
mirror of https://github.com/tokio-rs/tokio.git synced 2026-09-07 00:00:08 +02:00
Code Issues Packages Projects Releases Wiki Activity

process: Run cargo fmt

Browse Source
This commit is contained in:
Ivan Petkov
2019-06-24 17:29:33 -07:00
parent 0ab25878bd
commit 27c15471c1
8 changed files with 151 additions and 155 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/unix/mod.rs
+35 -33
View File
@@ -28,20 +28,20 @@ extern crate tokio_signal;
mod orphan;
mod reap;
use futures::future::FlattenStream;
use futures::{Future, Poll};
use kill::Kill;
use self::mio::{Poll as MioPoll, PollOpt, Ready, Token};
use self::mio::unix::{EventedFd, UnixReady};
use self::mio::event::Evented;
use self::mio::unix::{EventedFd, UnixReady};
use self::mio::{Poll as MioPoll, PollOpt, Ready, Token};
use self::orphan::{AtomicOrphanQueue, OrphanQueue, Wait};
use self::reap::Reaper;
use self::tokio_signal::unix::Signal;
use super::SpawnedChild;
use futures::future::FlattenStream;
use futures::{Future, Poll};
use kill::Kill;
use std::fmt;
use std::io;
use std::os::unix::io::{AsRawFd, RawFd};
use std::process::{self, ExitStatus};
use super::SpawnedChild;
use tokio_io::IoFuture;
use tokio_reactor::{Handle, PollEvented};
@@ -153,7 +153,10 @@ impl<T: io::Write> io::Write for Fd<T> {
}
}
impl<T> AsRawFd for Fd<T> where T: AsRawFd {
impl<T> AsRawFd for Fd<T>
where
T: AsRawFd,
{
fn as_raw_fd(&self) -> RawFd {
self.0.as_raw_fd()
}
@@ -163,29 +166,28 @@ pub type ChildStdin = PollEvented<Fd<process::ChildStdin>>;
pub type ChildStdout = PollEvented<Fd<process::ChildStdout>>;
pub type ChildStderr = PollEvented<Fd<process::ChildStderr>>;
impl<T> Evented for Fd<T> where T: AsRawFd {
fn register(&self,
poll: &MioPoll,
token: Token,
interest: Ready,
opts: PollOpt)
-> io::Result<()> {
EventedFd(&self.as_raw_fd()).register(poll,
token,
interest | UnixReady::hup(),
opts)
impl<T> Evented for Fd<T>
where
T: AsRawFd,
{
fn register(
&self,
poll: &MioPoll,
token: Token,
interest: Ready,
opts: PollOpt,
) -> io::Result<()> {
EventedFd(&self.as_raw_fd()).register(poll, token, interest | UnixReady::hup(), opts)
}
fn reregister(&self,
poll: &MioPoll,
token: Token,
interest: Ready,
opts: PollOpt)
-> io::Result<()> {
EventedFd(&self.as_raw_fd()).reregister(poll,
token,
interest | UnixReady::hup(),
opts)
fn reregister(
&self,
poll: &MioPoll,
token: Token,
interest: Ready,
opts: PollOpt,
) -> io::Result<()> {
EventedFd(&self.as_raw_fd()).reregister(poll, token, interest | UnixReady::hup(), opts)
}
fn deregister(&self, poll: &MioPoll) -> io::Result<()> {
@@ -193,9 +195,9 @@ impl<T> Evented for Fd<T> where T: AsRawFd {
}
}
fn stdio<T>(option: Option<T>, handle: &Handle)
-> io::Result<Option<PollEvented<Fd<T>>>>
where T: AsRawFd
fn stdio<T>(option: Option<T>, handle: &Handle) -> io::Result<Option<PollEvented<Fd<T>>>>
where
T: AsRawFd,
{
let io = match option {
Some(io) => io,
@@ -207,11 +209,11 @@ fn stdio<T>(option: Option<T>, handle: &Handle)
let fd = io.as_raw_fd();
let r = libc::fcntl(fd, libc::F_GETFL);
if r == -1 {
return Err(io::Error::last_os_error())
return Err(io::Error::last_os_error());
}
let r = libc::fcntl(fd, libc::F_SETFL, r | libc::O_NONBLOCK);
if r == -1 {
return Err(io::Error::last_os_error())
return Err(io::Error::last_os_error());
}
}
let io = try!(PollEvented::new_with_handle(Fd(io), handle));
src/unix/orphan.rs
+3 -3
View File
@@ -70,7 +70,7 @@ impl<T: Wait> OrphanQueue<T> for AtomicOrphanQueue<T> {
let mut orphans = Vec::with_capacity(len);
while let Ok(mut orphan) = self.queue.pop() {
match orphan.try_wait() {
Ok(Some(_)) => {},
Ok(Some(_)) => {}
Err(e) => error!(
"leaking orphaned process {} due to try_wait() error: {}",
orphan.id(),
@@ -92,13 +92,13 @@ impl<T: Wait> OrphanQueue<T> for AtomicOrphanQueue<T> {
#[cfg(test)]
mod test {
use super::Wait;
use super::{AtomicOrphanQueue, OrphanQueue};
use std::cell::Cell;
use std::io;
use std::os::unix::process::ExitStatusExt;
use std::process::ExitStatus;
use std::rc::Rc;
use super::{AtomicOrphanQueue, OrphanQueue};
use super::Wait;
struct MockWait {
total_waits: Rc<Cell<usize>>,
src/unix/reap.rs
+33 -39
View File
@@ -1,16 +1,17 @@
use super::orphan::{OrphanQueue, Wait};
use futures::{Async, Future, Poll, Stream};
use kill::Kill;
use std::io;
use std::ops::Deref;
use std::process::ExitStatus;
use super::orphan::{OrphanQueue, Wait};
/// Orchestrates between registering interest for receiving signals when a
/// child process has exited, and attempting to poll for process completion.
#[derive(Debug)]
pub(crate) struct Reaper<W, Q, S>
where W: Wait,
Q: OrphanQueue<W>,
where
W: Wait,
Q: OrphanQueue<W>,
{
inner: Option<W>,
orphan_queue: Q,
@@ -18,8 +19,9 @@ pub(crate) struct Reaper<W, Q, S>
}
impl<W, Q, S> Deref for Reaper<W, Q, S>
where W: Wait,
Q: OrphanQueue<W>,
where
W: Wait,
Q: OrphanQueue<W>,
{
type Target = W;
@@ -29,8 +31,9 @@ impl<W, Q, S> Deref for Reaper<W, Q, S>
}
impl<W, Q, S> Reaper<W, Q, S>
where W: Wait,
Q: OrphanQueue<W>,
where
W: Wait,
Q: OrphanQueue<W>,
{
pub(crate) fn new(inner: W, orphan_queue: Q, signal: S) -> Self {
Self {
@@ -50,9 +53,10 @@ impl<W, Q, S> Reaper<W, Q, S>
}
impl<W, Q, S> Future for Reaper<W, Q, S>
where W: Wait,
Q: OrphanQueue<W>,
S: Stream<Error = io::Error>,
where
W: Wait,
Q: OrphanQueue<W>,
S: Stream<Error = io::Error>,
{
type Item = ExitStatus;
type Error = io::Error;
@@ -100,18 +104,19 @@ impl<W, Q, S> Future for Reaper<W, Q, S>
}
impl<W, Q, S> Kill for Reaper<W, Q, S>
where W: Kill + Wait,
Q: OrphanQueue<W>,
where
W: Kill + Wait,
Q: OrphanQueue<W>,
{
fn kill(&mut self) -> io::Result<()> {
self.inner_mut().kill()
}
}
impl<W, Q, S> Drop for Reaper<W, Q, S>
where W: Wait,
Q: OrphanQueue<W>,
where
W: Wait,
Q: OrphanQueue<W>,
{
fn drop(&mut self) {
if let Ok(Some(_)) = self.inner_mut().try_wait() {
@@ -125,11 +130,11 @@ impl<W, Q, S> Drop for Reaper<W, Q, S>
#[cfg(test)]
mod test {
use super::*;
use futures::{Async, Poll, Stream};
use std::cell::{Cell, RefCell};
use std::process::ExitStatus;
use std::os::unix::process::ExitStatusExt;
use super::*;
use std::process::ExitStatus;
#[derive(Debug)]
struct MockWait {
@@ -145,7 +150,7 @@ mod test {
total_kills: 0,
total_waits: 0,
num_wait_until_status,
status
status,
}
}
}
@@ -183,7 +188,7 @@ mod test {
fn new(values: Vec<Option<()>>) -> Self {
Self {
total_polls: 0,
values
values,
}
}
}
@@ -217,8 +222,7 @@ mod test {
impl<W: Wait> OrphanQueue<W> for MockQueue<W> {
fn push_orphan(&self, orphan: W) {
self.all_enqueued.borrow_mut()
.push(orphan);
self.all_enqueued.borrow_mut().push(orphan);
}
fn reap_orphans(&self) {
@@ -230,13 +234,11 @@ mod test {
fn reaper() {
let exit = ExitStatus::from_raw(0);
let mock = MockWait::new(exit, 3);
let mut grim = Reaper::new(mock, MockQueue::new(), MockStream::new(vec!(
None,
Some(()),
None,
None,
None,
)));
let mut grim = Reaper::new(
mock,
MockQueue::new(),
MockStream::new(vec![None, Some(()), None, None, None]),
);
// Not yet exited, interest registered
assert_eq!(Async::NotReady, grim.poll().expect("failed to wait"));
@@ -267,7 +269,7 @@ mod test {
let mut grim = Reaper::new(
MockWait::new(exit, 0),
MockQueue::new(),
MockStream::new(vec!(None))
MockStream::new(vec![None]),
);
grim.kill().unwrap();
@@ -284,11 +286,7 @@ mod test {
{
let queue = MockQueue::new();
let grim = Reaper::new(
&mut mock,
&queue,
MockStream::new(vec!())
);
let grim = Reaper::new(&mut mock, &queue, MockStream::new(vec![]));
drop(grim);
@@ -307,11 +305,7 @@ mod test {
{
let queue = MockQueue::<&mut MockWait>::new();
let grim = Reaper::new(
&mut mock,
&queue,
MockStream::new(vec!())
);
let grim = Reaper::new(&mut mock, &queue, MockStream::new(vec![]));
drop(grim);
assert_eq!(0, queue.total_reaps.get());