Bump subcrate versions (#524)

* tokio-current-thread 0.1.1
* tokio-executor 0.1.3
* tokio-fs 0.1.3
* tokio-reactor 0.1.3
* tokio-tcp 0.1.1
* tokio-timer 0.2.5

.travis.yml

@@ -15,7 +15,7 @@ matrix:
   # This represents the minimum Rust version supported by Tokio. Updating this
   # should be done in a dedicated PR and cannot be greater than two 0.x
   # releases prior to the current stable.
-  - rust: 1.21.0
+  - rust: 1.25.0
   - rust: stable
   - rust: beta
   - rust: nightly
@@ -34,6 +34,7 @@ script:
 
         export ASAN_OPTIONS="detect_odr_violation=0 detect_leaks=0"
         export TSAN_OPTIONS="suppressions=`pwd`/ci/tsan"
+        export RUST_BACKTRACE=1
 
         # === tokio-timer ====
 
@@ -45,15 +46,18 @@ script:
         RUSTFLAGS="-Z sanitizer=thread" \
         cargo test -p tokio-timer --test hammer --target x86_64-unknown-linux-gnu
 
-        # === tokio-threadpool ====
-
-        # Run address sanitizer
-        RUSTFLAGS="-Z sanitizer=address" \
-        cargo test -p tokio-threadpool --tests
-
-        # Run thread sanitizer
-        RUSTFLAGS="-Z sanitizer=thread" \
-        cargo test -p tokio-threadpool --tests
+        # TODO: Uncomment the sanitizer tests once the fence in steal issue is
+        #       resolved: https://github.com/tokio-rs/tokio/issues/329
+        #
+        # # === tokio-threadpool ====
+        #
+        # # Run address sanitizer
+        # RUSTFLAGS="-Z sanitizer=address" \
+        # cargo test -p tokio-threadpool --tests
+        #
+        # # Run thread sanitizer
+        # RUSTFLAGS="-Z sanitizer=thread" \
+        # cargo test -p tokio-threadpool --tests
     fi
   - |
     set -e

Cargo.toml

@@ -24,6 +24,7 @@ keywords = ["io", "async", "non-blocking", "futures"]
 members = [
   "./",
   "tokio-codec",
+  "tokio-current-thread",
   "tokio-executor",
   "tokio-fs",
   "tokio-io",
@@ -40,7 +41,7 @@ travis-ci = { repository = "tokio-rs/tokio" }
 appveyor = { repository = "carllerche/tokio", id = "s83yxhy9qeb58va7" }
 
 [dependencies]
-tokio-codec = { version = "0.1.0", path = "tokio-codec" }
+tokio-current-thread = { version = "0.1.0", path = "tokio-current-thread" }
 tokio-io = { version = "0.1.6", path = "tokio-io" }
 tokio-executor = { version = "0.1.2", path = "tokio-executor" }
 tokio-reactor = { version = "0.1.1", path = "tokio-reactor" }
@@ -56,6 +57,8 @@ futures = "0.1.20"
 mio = "0.6.14"
 
 [dev-dependencies]
+tokio-codec = { version = "0.1.0", path = "tokio-codec" }
+
 bytes = "0.4"
 env_logger = { version = "0.4", default-features = false }
 flate2 = { version = "1", features = ["tokio"] }

README.md

@@ -53,7 +53,7 @@ These components provide the runtime components necessary for building
 an asynchronous application.
 
 [net]: https://docs.rs/tokio/0.1/tokio/net/index.html
-[reactor]: https://docs.rs/tokio/0.1.1/tokio/reactor/index.html
+[reactor]: https://docs.rs/tokio/0.1/tokio/reactor/index.html
 [scheduler]: https://tokio-rs.github.io/tokio/tokio/runtime/index.html
 
 ## Example
@@ -111,6 +111,11 @@ have greater guarantees of stability.
 
 The crates included as part of Tokio are:
 
+* [`tokio-codec`]: Utilities for encoding and decoding protocol frames.
+
+* [`tokio-current-thread`]: Schedule the execution of futures on the current
+  thread.
+
 * [`tokio-executor`]: Task execution related traits and utilities.
 
 * [`tokio-fs`]: Filesystem (and standard in / out) APIs.
@@ -132,6 +137,8 @@ The crates included as part of Tokio are:
 * [`tokio-uds`]: Unix Domain Socket bindings for use with `tokio-io` and
   `tokio-reactor`.
 
+[`tokio-codec`]: tokio-codec
+[`tokio-current-thread`]: tokio-current-thread
 [`tokio-executor`]: tokio-executor
 [`tokio-fs`]: tokio-fs
 [`tokio-io`]: tokio-io

benches/tcp.rs

@@ -13,7 +13,6 @@ mod prelude {
     pub use futures::*;
     pub use tokio::reactor::Reactor;
     pub use tokio::net::{TcpListener, TcpStream};
-    pub use tokio::executor::current_thread;
     pub use tokio_io::io::read_to_end;
 
     pub use test::{self, Bencher};

ci/tsan

@@ -3,7 +3,7 @@
 # TSAN does not understand fences and `Arc::drop` is implemented using a fence.
 # This causes many false positives.
 race:Arc*drop
-race:arc*Weak*drop
+race:Weak*drop
 
 # `std` mpsc is not used in any Tokio code base. This race is triggered by some
 # rust runtime logic.
@@ -12,15 +12,14 @@ race:std*mpsc_queue
 # Probably more fences in std.
 race:__call_tls_dtors
 
-# The crossbeam deque uses fences.
-race:crossbeam_deque
+# The epoch-based GC uses fences.
+race:crossbeam_epoch
 
-# This is excluded as this race shows up due to using the stealing features of
-# the deque. Unfortunately, the implementation uses a fence, which makes tsan
-# unhappy.
-#
-# TODO: It would be nice to not have to filter this out.
-race:try_steal_task
+# Push and steal operations in crossbeam-deque may cause data races, but such
+# data races are safe. If a data race happens, the value read by `steal` is
+# forgotten and the steal operation is then retried.
+race:crossbeam_deque*push
+race:crossbeam_deque*steal
 
 # This filters out expected data race in the treiber stack implementations.
 # Treiber stacks are inherently racy. The pop operation will attempt to access

examples/chat.rs

@@ -290,7 +290,7 @@ impl Lines {
     fn poll_flush(&mut self) -> Poll<(), io::Error> {
         // As long as there is buffered data to write, try to write it.
         while !self.wr.is_empty() {
-            // Try to read some bytes from the socket
+            // Try to write some bytes to the socket
             let n = try_ready!(self.socket.poll_write(&self.wr));
 
             // As long as the wr is not empty, a successful write should

examples/manual-runtime.rs

@@ -10,6 +10,7 @@
 
 extern crate futures;
 extern crate tokio;
+extern crate tokio_current_thread;
 extern crate tokio_executor;
 extern crate tokio_reactor;
 extern crate tokio_timer;
@@ -18,11 +19,11 @@ use std::io::Error as IoError;
 use std::time::{Duration, Instant};
 
 use futures::{future, Future};
-use tokio::executor::current_thread::{self, CurrentThread};
+use tokio_current_thread::CurrentThread;
 use tokio_reactor::Reactor;
 use tokio_timer::timer::{self, Timer};
 
-/// Creates a „runtime“.
+/// Creates a "runtime".
 ///
 /// This is similar to running `tokio::runtime::current_thread::Runtime::new()`.
 fn run<F: Future<Item = (), Error = ()>>(f: F) -> Result<(), IoError> {
@@ -46,7 +47,7 @@ fn run<F: Future<Item = (), Error = ()>>(f: F) -> Result<(), IoError> {
             // executor when used. This is a trick, because we need two mutable references to the
             // executor (one to run the provided future, another to install as the default one). We
             // use the fake one here as the default one.
-            let mut default_executor = current_thread::TaskExecutor::current();
+            let mut default_executor = tokio_current_thread::TaskExecutor::current();
             tokio_executor::with_default(&mut default_executor, enter, |enter| {
                 let mut executor = executor.enter(enter);
                 // Run the provided future
@@ -61,7 +62,7 @@ fn run<F: Future<Item = (), Error = ()>>(f: F) -> Result<(), IoError> {
 
 fn main() {
     run(future::lazy(|| {
-        // Here comes the application logic. It can spawn further tasks by current_thread::spawn().
+        // Here comes the application logic. It can spawn further tasks by tokio_current_thread::spawn().
         // It also can use the default reactor and create timeouts.
 
         // Connect somewhere. And then do nothing with it. Yes, useless.
@@ -72,7 +73,7 @@ fn main() {
             .map_err(|e| println!("Failed to connect: {}", e));
         // We can spawn it without requiring Send. This would panic if we run it outside of the
         // `run` (or outside of anything else)
-        current_thread::spawn(connect);
+        tokio_current_thread::spawn(connect);
 
         // We can also create timeouts.
         let deadline = tokio::timer::Delay::new(Instant::now() + Duration::from_secs(5))

src/clock.rs

@@ -6,7 +6,7 @@
 //! tests or performing caching operations to reduce the number of syscalls.
 //!
 //! Note that, because the source of time is configurable, it is possible to
-//! observe non-monotonic behavior when calling [`now`] from different
+//! observe non-monotonic behavior when calling [`now`][n] from different
 //! executors.
 //!
 //! [n]: fn.now.html

src/executor/current_thread/mod.rs

@@ -1,3 +1,5 @@
+#![allow(deprecated)]
+
 //! Execute many tasks concurrently on the current thread.
 //!
 //! [`CurrentThread`] is an executor that keeps tasks on the same thread that
@@ -102,76 +104,24 @@
 //! [`CurrentThread`]: struct.CurrentThread.html
 //! [`Future::poll`]: https://docs.rs/futures/0.1/futures/future/trait.Future.html#tymethod.poll
 
-#![allow(deprecated)]
+pub use tokio_current_thread::{
+    BlockError,
+    CurrentThread,
+    Entered,
+    Handle,
+    RunError,
+    RunTimeoutError,
+    TaskExecutor,
+    Turn,
+    TurnError,
+    block_on_all,
+    spawn,
+};
 
-mod scheduler;
-use self::scheduler::Scheduler;
-
-use tokio_executor::{self, Enter, SpawnError};
-use tokio_executor::park::{Park, Unpark, ParkThread};
-
-use futures::{executor, Async, Future};
-use futures::future::{self, Executor, ExecuteError, ExecuteErrorKind};
-
-use std::fmt;
 use std::cell::Cell;
 use std::marker::PhantomData;
-use std::rc::Rc;
-use std::time::{Duration, Instant};
-use std::sync::mpsc;
 
-#[cfg(feature = "unstable-futures")]
-use futures2;
-
-/// Executes tasks on the current thread
-pub struct CurrentThread<P: Park = ParkThread> {
-    /// Execute futures and receive unpark notifications.
-    scheduler: Scheduler<P::Unpark>,
-
-    /// Current number of futures being executed
-    num_futures: usize,
-
-    /// Thread park handle
-    park: P,
-
-    /// Handle for spawning new futures from other threads
-    spawn_handle: Handle,
-
-    /// Receiver for futures spawned from other threads
-    spawn_receiver: mpsc::Receiver<Box<Future<Item = (), Error = ()> + Send + 'static>>,
-}
-
-/// Executes futures on the current thread.
-///
-/// All futures executed using this executor will be executed on the current
-/// thread. As such, `run` will wait for these futures to complete before
-/// returning.
-///
-/// For more details, see the [module level](index.html) documentation.
-#[derive(Debug, Clone)]
-pub struct TaskExecutor {
-    // Prevent the handle from moving across threads.
-    _p: ::std::marker::PhantomData<Rc<()>>,
-}
-
-/// Returned by the `turn` function.
-#[derive(Debug)]
-pub struct Turn {
-    polled: bool
-}
-
-impl Turn {
-    /// `true` if any futures were polled at all and `false` otherwise.
-    pub fn has_polled(&self) -> bool {
-        self.polled
-    }
-}
-
-/// A `CurrentThread` instance bound to a supplied execution context.
-pub struct Entered<'a, P: Park + 'a> {
-    executor: &'a mut CurrentThread<P>,
-    enter: &'a mut Enter,
-}
+use futures::future::{self};
 
 #[deprecated(since = "0.1.2", note = "use block_on_all instead")]
 #[doc(hidden)]
@@ -181,54 +131,17 @@ pub struct Context<'a> {
     _p: PhantomData<&'a ()>,
 }
 
-/// Error returned by the `run` function.
-#[derive(Debug)]
-pub struct RunError {
-    _p: (),
+impl<'a> Context<'a> {
+    /// Cancels *all* executing futures.
+    pub fn cancel_all_spawned(&self) {
+        self.cancel.set(true);
+    }
 }
 
-/// Error returned by the `run_timeout` function.
-#[derive(Debug)]
-pub struct RunTimeoutError {
-    timeout: bool,
-}
-
-/// Error returned by the `turn` function.
-#[derive(Debug)]
-pub struct TurnError {
-    _p: (),
-}
-
-/// Error returned by the `block_on` function.
-#[derive(Debug)]
-pub struct BlockError<T> {
-    inner: Option<T>,
-}
-
-/// This is mostly split out to make the borrow checker happy.
-struct Borrow<'a, U: 'a> {
-    scheduler: &'a mut Scheduler<U>,
-    num_futures: &'a mut usize,
-}
-
-trait SpawnLocal {
-    fn spawn_local(&mut self, future: Box<Future<Item = (), Error = ()>>);
-}
-
-struct CurrentRunner {
-    spawn: Cell<Option<*mut SpawnLocal>>,
-}
-
-/// Current thread's task runner. This is set in `TaskRunner::with`
-thread_local!(static CURRENT: CurrentRunner = CurrentRunner {
-    spawn: Cell::new(None),
-});
-
 #[deprecated(since = "0.1.2", note = "use block_on_all instead")]
 #[doc(hidden)]
-#[allow(deprecated)]
 pub fn run<F, R>(f: F) -> R
-where F: FnOnce(&mut Context) -> R
+    where F: FnOnce(&mut Context) -> R
 {
     let mut context = Context {
         cancel: Cell::new(false),
@@ -249,587 +162,9 @@ where F: FnOnce(&mut Context) -> R
     ret
 }
 
-/// Run the executor bootstrapping the execution with the provided future.
-///
-/// This creates a new [`CurrentThread`] executor, spawns the provided future,
-/// and blocks the current thread until the provided future and **all**
-/// subsequently spawned futures complete. In other words:
-///
-/// * If the provided bootstrap future does **not** spawn any additional tasks,
-///   `block_on_all` returns once `future` completes.
-/// * If the provided bootstrap future **does** spawn additional tasks, then
-///   `block_on_all` returns once **all** spawned futures complete.
-///
-/// See [module level][mod] documentation for more details.
-///
-/// [`CurrentThread`]: struct.CurrentThread.html
-/// [mod]: index.html
-pub fn block_on_all<F>(future: F) -> Result<F::Item, F::Error>
-where F: Future,
-{
-    let mut current_thread = CurrentThread::new();
-
-    let ret = current_thread.block_on(future);
-    current_thread.run().unwrap();
-
-    ret.map_err(|e| e.into_inner().expect("unexpected execution error"))
-}
-
-/// Executes a future on the current thread.
-///
-/// The provided future must complete or be canceled before `run` will return.
-///
-/// Unlike [`tokio::spawn`], this function will always spawn on a
-/// `CurrentThread` executor and is able to spawn futures that are not `Send`.
-///
-/// # Panics
-///
-/// This function can only be invoked from the context of a `run` call; any
-/// other use will result in a panic.
-///
-/// [`tokio::spawn`]: ../fn.spawn.html
-pub fn spawn<F>(future: F)
-where F: Future<Item = (), Error = ()> + 'static
-{
-    TaskExecutor::current()
-        .spawn_local(Box::new(future))
-        .unwrap();
-}
-
-// ===== impl CurrentThread =====
-
-impl CurrentThread<ParkThread> {
-    /// Create a new instance of `CurrentThread`.
-    pub fn new() -> Self {
-        CurrentThread::new_with_park(ParkThread::new())
-    }
-}
-
-impl<P: Park> CurrentThread<P> {
-    /// Create a new instance of `CurrentThread` backed by the given park
-    /// handle.
-    pub fn new_with_park(park: P) -> Self {
-        let unpark = park.unpark();
-
-        let (spawn_sender, spawn_receiver) = mpsc::channel();
-
-        let scheduler = Scheduler::new(unpark);
-        let notify = scheduler.notify();
-
-        CurrentThread {
-            scheduler: scheduler,
-            num_futures: 0,
-            park,
-            spawn_handle: Handle { sender: spawn_sender, notify: notify },
-            spawn_receiver: spawn_receiver,
-        }
-    }
-
-    /// Returns `true` if the executor is currently idle.
-    ///
-    /// An idle executor is defined by not currently having any spawned tasks.
-    pub fn is_idle(&self) -> bool {
-        self.num_futures == 0
-    }
-
-    /// Spawn the future on the executor.
-    ///
-    /// This internally queues the future to be executed once `run` is called.
-    pub fn spawn<F>(&mut self, future: F) -> &mut Self
-    where F: Future<Item = (), Error = ()> + 'static,
-    {
-        self.borrow().spawn_local(Box::new(future));
-        self
-    }
-
-    /// Synchronously waits for the provided `future` to complete.
-    ///
-    /// This function can be used to synchronously block the current thread
-    /// until the provided `future` has resolved either successfully or with an
-    /// error. The result of the future is then returned from this function
-    /// call.
-    ///
-    /// Note that this function will **also** execute any spawned futures on the
-    /// current thread, but will **not** block until these other spawned futures
-    /// have completed.
-    ///
-    /// The caller is responsible for ensuring that other spawned futures
-    /// complete execution.
-    pub fn block_on<F>(&mut self, future: F)
-        -> Result<F::Item, BlockError<F::Error>>
-    where F: Future
-    {
-        let mut enter = tokio_executor::enter().unwrap();
-        self.enter(&mut enter).block_on(future)
-    }
-
-    /// Run the executor to completion, blocking the thread until **all**
-    /// spawned futures have completed.
-    pub fn run(&mut self) -> Result<(), RunError> {
-        let mut enter = tokio_executor::enter().unwrap();
-        self.enter(&mut enter).run()
-    }
-
-    /// Run the executor to completion, blocking the thread until all
-    /// spawned futures have completed **or** `duration` time has elapsed.
-    pub fn run_timeout(&mut self, duration: Duration)
-        -> Result<(), RunTimeoutError>
-    {
-        let mut enter = tokio_executor::enter().unwrap();
-        self.enter(&mut enter).run_timeout(duration)
-    }
-
-    /// Perform a single iteration of the event loop.
-    ///
-    /// This function blocks the current thread even if the executor is idle.
-    pub fn turn(&mut self, duration: Option<Duration>)
-        -> Result<Turn, TurnError>
-    {
-        let mut enter = tokio_executor::enter().unwrap();
-        self.enter(&mut enter).turn(duration)
-    }
-
-    /// Bind `CurrentThread` instance with an execution context.
-    pub fn enter<'a>(&'a mut self, enter: &'a mut Enter) -> Entered<'a, P> {
-        Entered {
-            executor: self,
-            enter,
-        }
-    }
-
-    /// Returns a reference to the underlying `Park` instance.
-    pub fn get_park(&self) -> &P {
-        &self.park
-    }
-
-    /// Returns a mutable reference to the underlying `Park` instance.
-    pub fn get_park_mut(&mut self) -> &mut P {
-        &mut self.park
-    }
-
-    fn borrow(&mut self) -> Borrow<P::Unpark> {
-        Borrow {
-            scheduler: &mut self.scheduler,
-            num_futures: &mut self.num_futures,
-        }
-    }
-
-    /// Get a new handle to spawn futures on the executor
-    ///
-    /// Different to the executor itself, the handle can be sent to different
-    /// threads and can be used to spawn futures on the executor.
-    pub fn handle(&self) -> Handle {
-        self.spawn_handle.clone()
-    }
-}
-
-impl tokio_executor::Executor for CurrentThread {
-    fn spawn(&mut self, future: Box<Future<Item = (), Error = ()> + Send>)
-        -> Result<(), SpawnError>
-    {
-        self.borrow().spawn_local(future);
-        Ok(())
-    }
-
-    #[cfg(feature = "unstable-futures")]
-    fn spawn2(&mut self, _future: Box<futures2::Future<Item = (), Error = futures2::Never> + Send>)
-        -> Result<(), futures2::executor::SpawnError>
-    {
-        panic!("Futures 0.2 integration is not available for current_thread");
-    }
-}
-
-impl<P: Park> fmt::Debug for CurrentThread<P> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("CurrentThread")
-            .field("scheduler", &self.scheduler)
-            .field("num_futures", &self.num_futures)
-            .finish()
-    }
-}
-
-// ===== impl Entered =====
-
-impl<'a, P: Park> Entered<'a, P> {
-    /// Spawn the future on the executor.
-    ///
-    /// This internally queues the future to be executed once `run` is called.
-    pub fn spawn<F>(&mut self, future: F) -> &mut Self
-    where F: Future<Item = (), Error = ()> + 'static,
-    {
-        self.executor.borrow().spawn_local(Box::new(future));
-        self
-    }
-
-    /// Synchronously waits for the provided `future` to complete.
-    ///
-    /// This function can be used to synchronously block the current thread
-    /// until the provided `future` has resolved either successfully or with an
-    /// error. The result of the future is then returned from this function
-    /// call.
-    ///
-    /// Note that this function will **also** execute any spawned futures on the
-    /// current thread, but will **not** block until these other spawned futures
-    /// have completed.
-    ///
-    /// The caller is responsible for ensuring that other spawned futures
-    /// complete execution.
-    pub fn block_on<F>(&mut self, future: F)
-        -> Result<F::Item, BlockError<F::Error>>
-    where F: Future
-    {
-        let mut future = executor::spawn(future);
-        let notify = self.executor.scheduler.notify();
-
-        loop {
-            let res = self.executor.borrow().enter(self.enter, || {
-                future.poll_future_notify(&notify, 0)
-            });
-
-            match res {
-                Ok(Async::Ready(e)) => return Ok(e),
-                Err(e) => return Err(BlockError { inner: Some(e) }),
-                Ok(Async::NotReady) => {}
-            }
-
-            self.tick();
-
-            if let Err(_) = self.executor.park.park() {
-                return Err(BlockError { inner: None });
-            }
-        }
-    }
-
-    /// Run the executor to completion, blocking the thread until **all**
-    /// spawned futures have completed.
-    pub fn run(&mut self) -> Result<(), RunError> {
-        self.run_timeout2(None)
-            .map_err(|_| RunError { _p: () })
-    }
-
-    /// Run the executor to completion, blocking the thread until all
-    /// spawned futures have completed **or** `duration` time has elapsed.
-    pub fn run_timeout(&mut self, duration: Duration)
-        -> Result<(), RunTimeoutError>
-    {
-        self.run_timeout2(Some(duration))
-    }
-
-    /// Perform a single iteration of the event loop.
-    ///
-    /// This function blocks the current thread even if the executor is idle.
-    pub fn turn(&mut self, duration: Option<Duration>)
-        -> Result<Turn, TurnError>
-    {
-        let res = if self.executor.scheduler.has_pending_futures() {
-            self.executor.park.park_timeout(Duration::from_millis(0))
-        } else {
-            match duration {
-                Some(duration) => self.executor.park.park_timeout(duration),
-                None => self.executor.park.park(),
-            }
-        };
-
-        if res.is_err() {
-            return Err(TurnError { _p: () });
-        }
-
-        let polled = self.tick();
-
-        Ok(Turn { polled })
-    }
-
-    /// Returns a reference to the underlying `Park` instance.
-    pub fn get_park(&self) -> &P {
-        &self.executor.park
-    }
-
-    /// Returns a mutable reference to the underlying `Park` instance.
-    pub fn get_park_mut(&mut self) -> &mut P {
-        &mut self.executor.park
-    }
-
-    fn run_timeout2(&mut self, dur: Option<Duration>)
-        -> Result<(), RunTimeoutError>
-    {
-        if self.executor.is_idle() {
-            // Nothing to do
-            return Ok(());
-        }
-
-        let mut time = dur.map(|dur| (Instant::now() + dur, dur));
-
-        loop {
-            self.tick();
-
-            if self.executor.is_idle() {
-                return Ok(());
-            }
-
-            match time {
-                Some((until, rem)) => {
-                    if let Err(_) = self.executor.park.park_timeout(rem) {
-                        return Err(RunTimeoutError::new(false));
-                    }
-
-                    let now = Instant::now();
-
-                    if now >= until {
-                        return Err(RunTimeoutError::new(true));
-                    }
-
-                    time = Some((until, until - now));
-                }
-                None => {
-                    if let Err(_) = self.executor.park.park() {
-                        return Err(RunTimeoutError::new(false));
-                    }
-                }
-            }
-        }
-    }
-
-    /// Returns `true` if any futures were processed
-    fn tick(&mut self) -> bool {
-        // Spawn any futures that were spawned from other threads by manually
-        // looping over the receiver stream
-
-        // FIXME: Slightly ugly but needed to make the borrow checker happy
-        let (mut borrow, spawn_receiver) = (
-            Borrow {
-                scheduler: &mut self.executor.scheduler,
-                num_futures: &mut self.executor.num_futures,
-            },
-            &mut self.executor.spawn_receiver,
-        );
-
-        while let Ok(future) = spawn_receiver.try_recv() {
-            borrow.spawn_local(future);
-        }
-
-        // After any pending futures were scheduled, do the actual tick
-        borrow.scheduler.tick(
-            &mut *self.enter,
-            borrow.num_futures)
-    }
-}
-
-impl<'a, P: Park> fmt::Debug for Entered<'a, P> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("Entered")
-            .field("executor", &self.executor)
-            .field("enter", &self.enter)
-            .finish()
-    }
-}
-
-// ===== impl Handle =====
-
-/// Handle to spawn a future on the corresponding `CurrentThread` instance
-#[derive(Clone)]
-pub struct Handle {
-    sender: mpsc::Sender<Box<Future<Item = (), Error = ()> + Send + 'static>>,
-    notify: executor::NotifyHandle,
-}
-
-// Manual implementation because the Sender does not implement Debug
-impl fmt::Debug for Handle {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("Handle")
-            .finish()
-    }
-}
-
-impl Handle {
-    /// Spawn a future onto the `CurrentThread` instance corresponding to this handle
-    ///
-    /// # Panics
-    ///
-    /// This function panics if the spawn fails. Failure occurs if the `CurrentThread`
-    /// instance of the `Handle` does not exist anymore.
-    pub fn spawn<F>(&self, future: F) -> Result<(), SpawnError>
-    where F: Future<Item = (), Error = ()> + Send + 'static {
-        self.sender.send(Box::new(future))
-            .expect("CurrentThread does not exist anymore");
-        // use 0 for the id, CurrentThread does not make use of it
-        self.notify.notify(0);
-
-        Ok(())
-    }
-}
-
-// ===== impl TaskExecutor =====
-
 #[deprecated(since = "0.1.2", note = "use TaskExecutor::current instead")]
 #[doc(hidden)]
 pub fn task_executor() -> TaskExecutor {
-    TaskExecutor {
-        _p: ::std::marker::PhantomData,
-    }
+    TaskExecutor::current()
 }
 
-impl TaskExecutor {
-    /// Returns an executor that executes futures on the current thread.
-    ///
-    /// The user of `TaskExecutor` must ensure that when a future is submitted,
-    /// that it is done within the context of a call to `run`.
-    ///
-    /// For more details, see the [module level](index.html) documentation.
-    pub fn current() -> TaskExecutor {
-        TaskExecutor {
-            _p: ::std::marker::PhantomData,
-        }
-    }
-
-    /// Spawn a future onto the current `CurrentThread` instance.
-    pub fn spawn_local(&mut self, future: Box<Future<Item = (), Error = ()>>)
-        -> Result<(), SpawnError>
-    {
-        CURRENT.with(|current| {
-            match current.spawn.get() {
-                Some(spawn) => {
-                    unsafe { (*spawn).spawn_local(future) };
-                    Ok(())
-                }
-                None => {
-                    Err(SpawnError::shutdown())
-                }
-            }
-        })
-    }
-}
-
-impl tokio_executor::Executor for TaskExecutor {
-    fn spawn(&mut self, future: Box<Future<Item = (), Error = ()> + Send>)
-        -> Result<(), SpawnError>
-    {
-        self.spawn_local(future)
-    }
-
-    #[cfg(feature = "unstable-futures")]
-    fn spawn2(&mut self, _future: Box<futures2::Future<Item = (), Error = futures2::Never> + Send>)
-        -> Result<(), futures2::executor::SpawnError>
-    {
-        panic!("Futures 0.2 integration is not available for current_thread");
-    }
-
-    fn status(&self) -> Result<(), SpawnError> {
-        CURRENT.with(|current| {
-            if current.spawn.get().is_some() {
-                Ok(())
-            } else {
-                Err(SpawnError::shutdown())
-            }
-        })
-    }
-}
-
-impl<F> Executor<F> for TaskExecutor
-where F: Future<Item = (), Error = ()> + 'static
-{
-    fn execute(&self, future: F) -> Result<(), ExecuteError<F>> {
-        CURRENT.with(|current| {
-            match current.spawn.get() {
-                Some(spawn) => {
-                    unsafe { (*spawn).spawn_local(Box::new(future)) };
-                    Ok(())
-                }
-                None => {
-                    Err(ExecuteError::new(ExecuteErrorKind::Shutdown, future))
-                }
-            }
-        })
-    }
-}
-
-// ===== impl Context =====
-
-impl<'a> Context<'a> {
-    /// Cancels *all* executing futures.
-    pub fn cancel_all_spawned(&self) {
-        self.cancel.set(true);
-    }
-}
-
-// ===== impl Borrow =====
-
-impl<'a, U: Unpark> Borrow<'a, U> {
-    fn enter<F, R>(&mut self, _: &mut Enter, f: F) -> R
-    where F: FnOnce() -> R,
-    {
-        CURRENT.with(|current| {
-            current.set_spawn(self, || {
-                f()
-            })
-        })
-    }
-}
-
-impl<'a, U: Unpark> SpawnLocal for Borrow<'a, U> {
-    fn spawn_local(&mut self, future: Box<Future<Item = (), Error = ()>>) {
-        *self.num_futures += 1;
-        self.scheduler.schedule(future);
-    }
-}
-
-// ===== impl CurrentRunner =====
-
-impl CurrentRunner {
-    fn set_spawn<F, R>(&self, spawn: &mut SpawnLocal, f: F) -> R
-    where F: FnOnce() -> R
-    {
-        struct Reset<'a>(&'a CurrentRunner);
-
-        impl<'a> Drop for Reset<'a> {
-            fn drop(&mut self) {
-                self.0.spawn.set(None);
-            }
-        }
-
-        let _reset = Reset(self);
-
-        let spawn = unsafe { hide_lt(spawn as *mut SpawnLocal) };
-        self.spawn.set(Some(spawn));
-
-        f()
-    }
-}
-
-unsafe fn hide_lt<'a>(p: *mut (SpawnLocal + 'a)) -> *mut (SpawnLocal + 'static) {
-    use std::mem;
-    mem::transmute(p)
-}
-
-// ===== impl RunTimeoutError =====
-
-impl RunTimeoutError {
-    fn new(timeout: bool) -> Self {
-        RunTimeoutError { timeout }
-    }
-
-    /// Returns `true` if the error was caused by the operation timing out.
-    pub fn is_timeout(&self) -> bool {
-        self.timeout
-    }
-}
-
-impl From<tokio_executor::EnterError> for RunTimeoutError {
-    fn from(_: tokio_executor::EnterError) -> Self {
-        RunTimeoutError::new(false)
-    }
-}
-
-// ===== impl BlockError =====
-
-impl<T> BlockError<T> {
-    /// Returns the error yielded by the future being blocked on
-    pub fn into_inner(self) -> Option<T> {
-        self.inner
-    }
-}
-
-impl<T> From<tokio_executor::EnterError> for BlockError<T> {
-    fn from(_: tokio_executor::EnterError) -> Self {
-        BlockError { inner: None }
-    }
-}

src/executor/mod.rs

@@ -5,7 +5,7 @@
 //! the future must be submitted to an executor. A future that is submitted to
 //! an executor is called a "task".
 //!
-//! The executor executor is responsible for ensuring that [`Future::poll`] is
+//! The executor is responsible for ensuring that [`Future::poll`] is
 //! called whenever the task is [notified]. Notification happens when the
 //! internal state of a task transitions from "not ready" to ready. For
 //! example, a socket might have received data and a call to `read` will now be
@@ -13,16 +13,8 @@
 //!
 //! The specific strategy used to manage the tasks is left up to the
 //! executor. There are two main flavors of executors: single-threaded and
-//! multithreaded. This module provides both.
-//!
-//! * **[`current_thread`]**: A single-threaded executor that support spawning
-//! tasks that are not `Send`. It guarantees that tasks will be executed on
-//! the same thread from which they are spawned.
-//!
-//! * **[`thread_pool`]**: A multi-threaded executor that maintains a pool of
-//! threads. Tasks are spawned to one of the threads in the pool and executed.
-//! The pool employs a [work-stealing] strategy for optimizing how tasks get
-//! spread across the available threads.
+//! multithreaded. Tokio provides implementation for both of these in the
+//! [`runtime`] module.
 //!
 //! # `Executor` trait.
 //!
@@ -36,93 +28,26 @@
 //! executor. This value will often be set to the executor itself, but it is
 //! possible that the default executor might be set to a different executor.
 //!
-//! For example, the [`current_thread`] executor might set the default executor
-//! to a thread pool instead of itself, allowing futures to spawn new tasks onto
-//! the thread pool when those tasks are `Send`.
+//! For example, a single threaded executor might set the default executor to a
+//! thread pool instead of itself, allowing futures to spawn new tasks onto the
+//! thread pool when those tasks are `Send`.
 //!
 //! [`Future::poll`]: https://docs.rs/futures/0.1/futures/future/trait.Future.html#tymethod.poll
 //! [notified]: https://docs.rs/futures/0.1/futures/executor/trait.Notify.html#tymethod.notify
-//! [`current_thread`]: current_thread/index.html
-//! [`thread_pool`]: thread_pool/index.html
-//! [work-stealing]: https://en.wikipedia.org/wiki/Work_stealing
-//! [`tokio-executor`]: #
-//! [`Executor`]: #
-//! [`spawn`]: #
+//! [`runtime`]: ../runtime/index.html
+//! [`tokio-executor`]: https://docs.rs/tokio-executor/0.1
+//! [`Executor`]: trait.Executor.html
+//! [`spawn`]: fn.spawn.html
 
+#[deprecated(since = "0.1.8", note = "use tokio-current-thread crate instead")]
+#[doc(hidden)]
 pub mod current_thread;
 
+#[deprecated(since = "0.1.8", note = "use tokio-threadpool crate instead")]
+/// Re-exports of [`tokio-threadpool`], deprecated in favor of the crate.
+///
+/// [`tokio-threadpool`]: https://docs.rs/tokio-threadpool/0.1
 pub mod thread_pool {
-    //! Maintains a pool of threads across which the set of spawned tasks are
-    //! executed.
-    //!
-    //! [`ThreadPool`] is an executor that uses a thread pool for executing
-    //! tasks concurrently across multiple cores. It uses a thread pool that is
-    //! optimized for use cases that involve multiplexing large number of
-    //! independent tasks that perform short(ish) amounts of computation and are
-    //! mainly waiting on I/O, i.e. the Tokio use case.
-    //!
-    //! Usually, users of [`ThreadPool`] will not create pool instances.
-    //! Instead, they will create a [`Runtime`] instance, which comes with a
-    //! pre-configured thread pool.
-    //!
-    //! At the core, [`ThreadPool`] uses a work-stealing based scheduling
-    //! strategy. When spawning a task while *external* to the thread pool
-    //! (i.e., from a thread that is not part of the thread pool), the task is
-    //! randomly assigned to a worker thread. When spawning a task while
-    //! *internal* to the thread pool, the task is assigned to the current
-    //! worker.
-    //!
-    //! Each worker maintains its own queue and first focuses on processing all
-    //! tasks in its queue. When the worker's queue is empty, the worker will
-    //! attempt to *steal* tasks from other worker queues. This strategy helps
-    //! ensure that work is evenly distributed across threads while minimizing
-    //! synchronization between worker threads.
-    //!
-    //! # Usage
-    //!
-    //! Thread pool instances are created using [`ThreadPool::new`] or
-    //! [`Builder::new`]. The first option returns a thread pool with default
-    //! configuration values. The second option allows configuring the thread
-    //! pool before instantiating it.
-    //!
-    //! Once an instance is obtained, futures may be spawned onto it using the
-    //! [`spawn`] function.
-    //!
-    //! A handle to the thread pool is obtained using [`ThreadPool::sender`].
-    //! This handle is **only** able to spawn futures onto the thread pool. It
-    //! is unable to affect the lifecycle of the thread pool in any way. This
-    //! handle can be passed into functions or stored in structs as a way to
-    //! grant the capability of spawning futures.
-    //!
-    //! # Examples
-    //!
-    //! ```rust
-    //! # extern crate tokio;
-    //! # extern crate futures;
-    //! # use tokio::executor::thread_pool::ThreadPool;
-    //! use futures::future::{Future, lazy};
-    //!
-    //! # pub fn main() {
-    //! // Create a thread pool with default configuration values
-    //! let thread_pool = ThreadPool::new();
-    //!
-    //! thread_pool.spawn(lazy(|| {
-    //!     println!("called from a worker thread");
-    //!     Ok(())
-    //! }));
-    //!
-    //! // Gracefully shutdown the threadpool
-    //! thread_pool.shutdown().wait().unwrap();
-    //! # }
-    //! ```
-    //!
-    //! [`ThreadPool`]: struct.ThreadPool.html
-    //! [`ThreadPool::new`]: struct.ThreadPool.html#method.new
-    //! [`ThreadPool::sender`]: struct.ThreadPool.html#method.sender
-    //! [`spawn`]: struct.ThreadPool.html#method.spawn
-    //! [`Builder::new`]: struct.Builder.html#method.new
-    //! [`Runtime`]: ../../runtime/struct.Runtime.html
-
     pub use tokio_threadpool::{
         Builder,
         Sender,

src/fs.rs

@@ -7,7 +7,6 @@
 //! the context of the Tokio runtime as they require Tokio specific features to
 //! function.
 
-pub use tokio_fs::{
-    file,
-    File,
-};
+pub use tokio_fs::{create_dir, create_dir_all, file, hard_link, metadata, os, read_dir, read_link};
+pub use tokio_fs::{remove_dir, remove_file, rename, set_permissions, symlink_metadata, File};
+pub use tokio_fs::OpenOptions;

src/lib.rs

@@ -5,7 +5,7 @@
 //! provides a few major components:
 //!
 //! * A multi threaded, work-stealing based task [scheduler][runtime].
-//! * A [reactor][reactor] backed by the operating system's event queue (epoll, kqueue,
+//! * A [reactor] backed by the operating system's event queue (epoll, kqueue,
 //!   IOCP, etc...).
 //! * Asynchronous [TCP and UDP][net] sockets.
 //! * Asynchronous [filesystem][fs] operations.
@@ -17,7 +17,7 @@
 //! Guide level documentation is found on the [website].
 //!
 //! [website]: https://tokio.rs/docs/getting-started/hello-world/
-//! [futures]: http://docs.rs/futures
+//! [futures]: http://docs.rs/futures/0.1
 //!
 //! # Examples
 //!
@@ -70,6 +70,7 @@
 #[macro_use]
 extern crate futures;
 extern crate mio;
+extern crate tokio_current_thread;
 extern crate tokio_io;
 extern crate tokio_executor;
 extern crate tokio_fs;

src/reactor/mod.rs

@@ -81,7 +81,7 @@
 //! ## Implementation
 //!
 //! The reactor implementation uses [`mio`] to interface with the operating
-//! system's event queue. A call to [`Reactor::poll`] results in in a single
+//! system's event queue. A call to [`Reactor::poll`] results in a single
 //! call to [`Poll::poll`] which in turn results in a single call to the
 //! operating system's selector.
 //!
@@ -107,8 +107,8 @@
 //! There are a couple of ways to do this.
 //!
 //! If the custom I/O resource implements [`mio::Evented`] and implements
-//! [`std::Read`] and / or [`std::Write`], then [`PollEvented`] is the most
-//! suited.
+//! [`std::io::Read`] and / or [`std::io::Write`], then [`PollEvented`] is the
+//! most suited.
 //!
 //! Otherwise, [`Registration`] can be used directly. This provides the lowest
 //! level primitive needed for integrating with the reactor: a stream of

src/runtime/current_thread/mod.rs

@@ -62,9 +62,29 @@
 //! [rt]: struct.Runtime.html
 //! [concurrent-rt]: ../struct.Runtime.html
 //! [chan]: https://docs.rs/futures/0.1/futures/sync/mpsc/fn.channel.html
+//! [reactor]: ../../reactor/struct.Reactor.html
+//! [executor]: https://tokio.rs/docs/getting-started/runtime-model/#executors
+//! [timer]: ../../timer/index.html
 
 mod builder;
 mod runtime;
 
 pub use self::builder::Builder;
 pub use self::runtime::{Runtime, Handle};
+
+use futures::Future;
+
+/// Run the provided future to completion using a runtime running on the current thread.
+///
+/// This first creates a new [`Runtime`], and calls [`Runtime::block_on`] with the provided future,
+/// which blocks the current thread until the provided future completes. It then calls
+/// [`Runtime::run`] to wait for any other spawned futures to resolve.
+pub fn block_on_all<F>(future: F) -> Result<F::Item, F::Error>
+where
+    F: Future,
+{
+    let mut r = Runtime::new().expect("failed to start runtime on current thread");
+    let v = r.block_on(future)?;
+    r.run().expect("failed to resolve remaining futures");
+    Ok(v)
+}

src/runtime/current_thread/runtime.rs

@@ -1,5 +1,5 @@
-use executor::current_thread::{self, CurrentThread};
-use executor::current_thread::Handle as ExecutorHandle;
+use tokio_current_thread::{self as current_thread, CurrentThread};
+use tokio_current_thread::Handle as ExecutorHandle;
 use runtime::current_thread::Builder;
 
 use tokio_reactor::{self, Reactor};
@@ -9,6 +9,8 @@ use tokio_executor;
 
 use futures::Future;
 
+use std::fmt;
+use std::error::Error;
 use std::io;
 
 /// Single-threaded runtime provides a way to start reactor
@@ -48,6 +50,21 @@ pub struct RunError {
     inner: current_thread::RunError,
 }
 
+impl fmt::Display for RunError {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "{}", self.inner)
+    }
+}
+
+impl Error for RunError {
+    fn description(&self) -> &str {
+        self.inner.description()
+    }
+    fn cause(&self) -> Option<&Error> {
+        self.inner.cause()
+    }
+}
+
 impl Runtime {
     /// Returns a new runtime initialized with default configuration values.
     pub fn new() -> io::Result<Runtime> {

src/runtime/mod.rs

@@ -389,6 +389,31 @@ impl Runtime {
         rx.wait().unwrap()
     }
 
+    /// Run a future to completion on the Tokio runtime, then wait for all
+    /// background futures to complete too.
+    ///
+    /// This runs the given future on the runtime, blocking until it is
+    /// complete, waiting for background futures to complete, and yielding
+    /// its resolved result. Any tasks or timers which the future spawns
+    /// internally will be executed on the runtime and waited for completion.
+    ///
+    /// This method should not be called from an asynchrounous context.
+    ///
+    /// # Panics
+    ///
+    /// This function panics if the executor is at capacity, if the provided
+    /// future panics, or if called within an asynchronous execution context.
+    pub fn block_on_all<F, R, E>(mut self, future: F) -> Result<R, E>
+    where
+        F: Send + 'static + Future<Item = R, Error = E>,
+        R: Send + 'static,
+        E: Send + 'static,
+    {
+        let res = self.block_on(future);
+        self.shutdown_on_idle().wait().unwrap();
+        res
+    }
+
     /// Signals the runtime to shutdown once it becomes idle.
     ///
     /// Returns a future that completes once the shutdown operation has

src/timer.rs

@@ -76,6 +76,9 @@
 //! [runtime]: ../runtime/struct.Runtime.html
 //! [tokio-timer]: https://docs.rs/tokio-timer
 //! [ext]: ../util/trait.FutureExt.html#method.deadline
+//! [Deadline]: struct.Deadline.html
+//! [Delay]: struct.Delay.html
+//! [Interval]: struct.Interval.html
 
 pub use tokio_timer::{
     Deadline,

src/util/mod.rs

@@ -1,8 +1,9 @@
 //! Utilities for working with Tokio.
 //!
 //! This module contains utilities that are useful for working with Tokio.
-//! Currently, this only includes [`FutureExt`][FutureExt]. However, this will
-//! include over time.
+//! Currently, this only includes [`FutureExt`], but this may grow over time.
+//!
+//! [`FutureExt`]: trait.FutureExt.html
 
 mod future;
 

tests/reactor.rs

@@ -0,0 +1,89 @@
+extern crate futures;
+extern crate tokio_executor;
+extern crate tokio_reactor;
+extern crate tokio_tcp;
+
+use tokio_reactor::Reactor;
+use tokio_tcp::TcpListener;
+
+use futures::{Future, Stream};
+use futures::executor::{spawn, Notify, Spawn};
+
+use std::mem;
+use std::net::TcpStream;
+use std::sync::{Arc, Mutex};
+
+#[test]
+fn test_drop_on_notify() {
+    // When the reactor receives a kernel notification, it notifies the
+    // task that holds the associated socket. If this notification results in
+    // the task being dropped, the socket will also be dropped.
+    //
+    // Previously, there was a deadlock scenario where the reactor, while
+    // notifying, held a lock and the task being dropped attempted to acquire
+    // that same lock in order to clean up state.
+    //
+    // To simulate this case, we create a fake executor that does nothing when
+    // the task is notified. This simulates an executor in the process of
+    // shutting down. Then, when the task handle is dropped, the task itself is
+    // dropped.
+
+    struct MyNotify;
+
+    type Task = Mutex<Spawn<Box<Future<Item = (), Error = ()>>>>;
+
+    impl Notify for MyNotify {
+        fn notify(&self, _: usize) {
+            // Do nothing
+        }
+
+        fn clone_id(&self, id: usize) -> usize {
+            let ptr = id as *const Task;
+            let task = unsafe { Arc::from_raw(ptr) };
+
+            mem::forget(task.clone());
+            mem::forget(task);
+
+            id
+        }
+
+        fn drop_id(&self, id: usize) {
+            let ptr = id as *const Task;
+            let _ = unsafe { Arc::from_raw(ptr) };
+        }
+    }
+
+    let addr = "127.0.0.1:0".parse().unwrap();
+    let mut reactor = Reactor::new().unwrap();
+
+    // Create a listener
+    let listener = TcpListener::bind(&addr).unwrap();
+    let addr = listener.local_addr().unwrap();
+
+    // Define a task that just drains the listener
+    let task = Box::new({
+        listener.incoming()
+            .for_each(|_| Ok(()))
+            .map_err(|_| panic!())
+    }) as Box<Future<Item = (), Error = ()>>;
+
+    let task = Arc::new(Mutex::new(spawn(task)));
+    let notify = Arc::new(MyNotify);
+
+    let mut enter = tokio_executor::enter().unwrap();
+
+    tokio_reactor::with_default(&reactor.handle(), &mut enter, |_| {
+        let id = &*task as *const Task as usize;
+
+        task.lock().unwrap()
+            .poll_future_notify(&notify, id)
+            .unwrap();
+    });
+
+    drop(task);
+
+    // Establish a connection to the acceptor
+    let _s = TcpStream::connect(&addr).unwrap();
+
+    reactor.turn(None).unwrap();
+}

tests/runtime.rs

@@ -65,6 +65,74 @@ fn runtime_single_threaded() {
     runtime.run().unwrap();
 }
 
+#[test]
+fn runtime_single_threaded_block_on() {
+    let _ = env_logger::init();
+
+    tokio::runtime::current_thread::block_on_all(create_client_server_future()).unwrap();
+}
+
+#[test]
+fn runtime_single_threaded_block_on_all() {
+    let cnt = Arc::new(Mutex::new(0));
+    let c = cnt.clone();
+
+    let msg = tokio::runtime::current_thread::block_on_all(lazy(move || {
+        {
+            let mut x = c.lock().unwrap();
+            *x = 1 + *x;
+        }
+
+        // Spawn!
+        tokio::spawn(lazy(move || {
+            {
+                let mut x = c.lock().unwrap();
+                *x = 1 + *x;
+            }
+            Ok::<(), ()>(())
+        }));
+
+        Ok::<_, ()>("hello")
+    })).unwrap();
+
+    assert_eq!(2, *cnt.lock().unwrap());
+    assert_eq!(msg, "hello");
+}
+
+#[test]
+fn runtime_single_threaded_racy_spawn() {
+    let (trigger, exit) = futures::sync::oneshot::channel();
+    let (handle_tx, handle_rx) = ::std::sync::mpsc::channel();
+    let jh = ::std::thread::spawn(move || {
+        let mut rt = tokio::runtime::current_thread::Runtime::new().unwrap();
+        handle_tx.send(rt.handle()).unwrap();
+
+        // don't exit until we are told to
+        rt.block_on(exit.map_err(|_| ())).unwrap();
+
+        // run until all spawned futures (incl. the "exit" signal future) have completed.
+        rt.run().unwrap();
+    });
+
+    let (tx, rx) = futures::sync::oneshot::channel();
+
+    let handle = handle_rx.recv().unwrap();
+    handle
+        .spawn(futures::future::lazy(move || {
+            tx.send(()).unwrap();
+            Ok(())
+        }))
+        .unwrap();
+
+    // signal runtime thread to exit
+    trigger.send(()).unwrap();
+
+    // wait for runtime thread to exit
+    jh.join().unwrap();
+
+    assert_eq!(rx.wait().unwrap(), ());
+}
+
 #[test]
 fn runtime_multi_threaded() {
     let _ = env_logger::init();
@@ -173,3 +241,33 @@ fn spawn_many() {
     runtime.shutdown_on_idle().wait().unwrap();
     assert_eq!(ITER, *cnt.lock().unwrap());
 }
+
+#[test]
+fn spawn_from_block_on_all() {
+    let cnt = Arc::new(Mutex::new(0));
+    let c = cnt.clone();
+
+    let runtime = Runtime::new().unwrap();
+    let msg = runtime
+        .block_on_all(lazy(move || {
+            {
+                let mut x = c.lock().unwrap();
+                *x = 1 + *x;
+            }
+
+            // Spawn!
+            tokio::spawn(lazy(move || {
+                {
+                    let mut x = c.lock().unwrap();
+                    *x = 1 + *x;
+                }
+                Ok::<(), ()>(())
+            }));
+
+            Ok::<_, ()>("hello")
+        }))
+        .unwrap();
+
+    assert_eq!(2, *cnt.lock().unwrap());
+    assert_eq!(msg, "hello");
+}

tokio-codec/CHANGELOG.md

@@ -1,3 +1,3 @@
-# Unreleased
+# # 0.1.0 (June 13, 2018)
 
 * Initial release (#353)

tokio-codec/Cargo.toml

@@ -17,6 +17,6 @@ Utilities for encoding and decoding frames.
 categories = ["asynchronous"]
 
 [dependencies]
-tokio-io = { version = "0.1.6", path = "../tokio-io" }
+tokio-io = { version = "0.1.7", path = "../tokio-io" }
 bytes = "0.4.7"
 futures = "0.1.18"

tokio-codec/tests/framed_read.rs

@@ -6,7 +6,7 @@ extern crate futures;
 use tokio_io::AsyncRead;
 use tokio_codec::{FramedRead, Decoder};
 
-use bytes::{BytesMut, Buf, IntoBuf, BigEndian};
+use bytes::{BytesMut, Buf, IntoBuf};
 use futures::Stream;
 use futures::Async::{Ready, NotReady};
 
@@ -32,7 +32,7 @@ impl Decoder for U32Decoder {
             return Ok(None);
         }
 
-        let n = buf.split_to(4).into_buf().get_u32::<BigEndian>();
+        let n = buf.split_to(4).into_buf().get_u32_be();
         Ok(Some(n))
     }
 }

tokio-codec/tests/framed_write.rs

@@ -7,7 +7,7 @@ use tokio_io::AsyncWrite;
 use tokio_codec::{Encoder, FramedWrite};
 
 use futures::{Sink, Poll};
-use bytes::{BytesMut, BufMut, BigEndian};
+use bytes::{BytesMut, BufMut};
 
 use std::io::{self, Write};
 use std::collections::VecDeque;

tokio-current-thread/CHANGELOG.md

@@ -0,0 +1,8 @@
+# 0.1.1 (August 6, 2018)
+
+* Implement `std::Error` for misc error types (#501)
+* bugfix: Track tasks pending in spawn queue (#478)
+
+# 0.1.0 (June 13, 2018)
+
+* Extract `tokio::executor::current_thread` to a tokio-current-thread crate (#356)

tokio-current-thread/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "tokio-current-thread"
+
+# When releasing to crates.io:
+# - Update html_root_url.
+# - Update CHANGELOG.md.
+# - Create "v0.1.x" git tag.
+version = "0.1.1"
+documentation = "https://docs.rs/tokio-current-thread"
+repository = "https://github.com/tokio-rs/tokio"
+homepage = "https://github.com/tokio-rs/tokio"
+license = "MIT"
+authors = ["Carl Lerche <[email protected]>"]
+description = """
+Single threaded executor which manage many tasks concurrently on the current thread.
+"""
+keywords = ["futures", "tokio"]
+categories = ["concurrency", "asynchronous"]
+
+[dependencies]
+tokio-executor = { version = "0.1.2", path = "../tokio-executor" }
+futures = "0.1.19"

tokio-current-thread/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2018 Tokio Contributors
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

tokio-current-thread/README.md

@@ -0,0 +1,19 @@
+# tokio-current-thread
+
+Single threaded executor for Tokio.
+
+[Documentation](https://tokio-rs.github.io/tokio/tokio_current_thread/)
+
+## Overview
+
+This crate provides the single threaded executor which execute many tasks concurrently.
+
+## License
+
+This project is licensed under the [MIT license](LICENSE).
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in Tokio by you, shall be licensed as MIT, without any additional
+terms or conditions.

tokio-current-thread/src/lib.rs

@@ -0,0 +1,824 @@
+//! A single-threaded executor which executes tasks on the same thread from which
+//! they are spawned.
+//!
+//!
+//! The crate provides:
+//!
+//! * [`CurrentThread`] is the main type of this crate. It executes tasks on the current thread.
+//!   The easiest way to start a new [`CurrentThread`] executor is to call
+//!   [`block_on_all`] with an initial task to seed the executor.
+//!   All tasks that are being managed by a [`CurrentThread`] executor are able to
+//!   spawn additional tasks by calling [`spawn`].
+//!
+//!
+//! Application authors will not use this crate directly. Instead, they will use the
+//! `tokio` crate. Library authors should only depend on `tokio-current-thread` if they
+//! are building a custom task executor.
+//!
+//! For more details, see [executor module] documentation in the Tokio crate.
+//!
+//! [`CurrentThread`]: struct.CurrentThread.html
+//! [`spawn`]: fn.spawn.html
+//! [`block_on_all`]: fn.block_on_all.html
+//! [executor module]: https://docs.rs/tokio/0.1/tokio/executor/index.html
+
+#![doc(html_root_url = "https://docs.rs/tokio-current-thread/0.1.1")]
+#![deny(warnings, missing_docs, missing_debug_implementations)]
+
+extern crate futures;
+extern crate tokio_executor;
+
+mod scheduler;
+
+use self::scheduler::Scheduler;
+
+use tokio_executor::{Enter, SpawnError};
+use tokio_executor::park::{Park, Unpark, ParkThread};
+
+use futures::{executor, Async, Future};
+use futures::future::{Executor, ExecuteError, ExecuteErrorKind};
+
+use std::fmt;
+use std::cell::Cell;
+use std::error::Error;
+use std::rc::Rc;
+use std::sync::{atomic, mpsc, Arc};
+use std::time::{Duration, Instant};
+
+#[cfg(feature = "unstable-futures")]
+use futures2;
+
+/// Executes tasks on the current thread
+pub struct CurrentThread<P: Park = ParkThread> {
+    /// Execute futures and receive unpark notifications.
+    scheduler: Scheduler<P::Unpark>,
+
+    /// Current number of futures being executed.
+    ///
+    /// The LSB is used to indicate that the runtime is preparing to shut down.
+    /// Thus, to get the actual number of pending futures, `>>1`.
+    num_futures: Arc<atomic::AtomicUsize>,
+
+    /// Thread park handle
+    park: P,
+
+    /// Handle for spawning new futures from other threads
+    spawn_handle: Handle,
+
+    /// Receiver for futures spawned from other threads
+    spawn_receiver: mpsc::Receiver<Box<Future<Item = (), Error = ()> + Send + 'static>>,
+}
+
+/// Executes futures on the current thread.
+///
+/// All futures executed using this executor will be executed on the current
+/// thread. As such, `run` will wait for these futures to complete before
+/// returning.
+///
+/// For more details, see the [module level](index.html) documentation.
+#[derive(Debug, Clone)]
+pub struct TaskExecutor {
+    // Prevent the handle from moving across threads.
+    _p: ::std::marker::PhantomData<Rc<()>>,
+}
+
+/// Returned by the `turn` function.
+#[derive(Debug)]
+pub struct Turn {
+    polled: bool
+}
+
+impl Turn {
+    /// `true` if any futures were polled at all and `false` otherwise.
+    pub fn has_polled(&self) -> bool {
+        self.polled
+    }
+}
+
+/// A `CurrentThread` instance bound to a supplied execution context.
+pub struct Entered<'a, P: Park + 'a> {
+    executor: &'a mut CurrentThread<P>,
+    enter: &'a mut Enter,
+}
+
+/// Error returned by the `run` function.
+#[derive(Debug)]
+pub struct RunError {
+    _p: (),
+}
+
+impl fmt::Display for RunError {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "{}", self.description())
+    }
+}
+
+impl Error for RunError {
+    fn description(&self) -> &str {
+        "Run error"
+    }
+}
+
+/// Error returned by the `run_timeout` function.
+#[derive(Debug)]
+pub struct RunTimeoutError {
+    timeout: bool,
+}
+
+impl fmt::Display for RunTimeoutError {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "{}", self.description())
+    }
+}
+
+impl Error for RunTimeoutError {
+    fn description(&self) -> &str {
+        if self.timeout {
+            "Run timeout error (timeout)"
+        } else {
+            "Run timeout error (not timeout)"
+        }
+    }
+}
+
+/// Error returned by the `turn` function.
+#[derive(Debug)]
+pub struct TurnError {
+    _p: (),
+}
+
+impl fmt::Display for TurnError {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "{}", self.description())
+    }
+}
+
+impl Error for TurnError {
+    fn description(&self) -> &str {
+        "Turn error"
+    }
+}
+
+/// Error returned by the `block_on` function.
+#[derive(Debug)]
+pub struct BlockError<T> {
+    inner: Option<T>,
+}
+
+impl<T> fmt::Display for BlockError<T> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "Block error")
+    }
+}
+
+impl<T: fmt::Debug> Error for BlockError<T> {
+    fn description(&self) -> &str {
+        "Block error"
+    }
+}
+
+/// This is mostly split out to make the borrow checker happy.
+struct Borrow<'a, U: 'a> {
+    scheduler: &'a mut Scheduler<U>,
+    num_futures: &'a atomic::AtomicUsize,
+}
+
+trait SpawnLocal {
+    fn spawn_local(&mut self, future: Box<Future<Item = (), Error = ()>>, already_counted: bool);
+}
+
+struct CurrentRunner {
+    spawn: Cell<Option<*mut SpawnLocal>>,
+}
+
+/// Current thread's task runner. This is set in `TaskRunner::with`
+thread_local!(static CURRENT: CurrentRunner = CurrentRunner {
+    spawn: Cell::new(None),
+});
+
+/// Run the executor bootstrapping the execution with the provided future.
+///
+/// This creates a new [`CurrentThread`] executor, spawns the provided future,
+/// and blocks the current thread until the provided future and **all**
+/// subsequently spawned futures complete. In other words:
+///
+/// * If the provided bootstrap future does **not** spawn any additional tasks,
+///   `block_on_all` returns once `future` completes.
+/// * If the provided bootstrap future **does** spawn additional tasks, then
+///   `block_on_all` returns once **all** spawned futures complete.
+///
+/// See [module level][mod] documentation for more details.
+///
+/// [`CurrentThread`]: struct.CurrentThread.html
+/// [mod]: index.html
+pub fn block_on_all<F>(future: F) -> Result<F::Item, F::Error>
+where F: Future,
+{
+    let mut current_thread = CurrentThread::new();
+
+    let ret = current_thread.block_on(future);
+    current_thread.run().unwrap();
+
+    ret.map_err(|e| e.into_inner().expect("unexpected execution error"))
+}
+
+/// Executes a future on the current thread.
+///
+/// The provided future must complete or be canceled before `run` will return.
+///
+/// Unlike [`tokio::spawn`], this function will always spawn on a
+/// `CurrentThread` executor and is able to spawn futures that are not `Send`.
+///
+/// # Panics
+///
+/// This function can only be invoked from the context of a `run` call; any
+/// other use will result in a panic.
+///
+/// [`tokio::spawn`]: ../fn.spawn.html
+pub fn spawn<F>(future: F)
+where F: Future<Item = (), Error = ()> + 'static
+{
+    TaskExecutor::current()
+        .spawn_local(Box::new(future))
+        .unwrap();
+}
+
+// ===== impl CurrentThread =====
+
+impl CurrentThread<ParkThread> {
+    /// Create a new instance of `CurrentThread`.
+    pub fn new() -> Self {
+        CurrentThread::new_with_park(ParkThread::new())
+    }
+}
+
+impl<P: Park> CurrentThread<P> {
+    /// Create a new instance of `CurrentThread` backed by the given park
+    /// handle.
+    pub fn new_with_park(park: P) -> Self {
+        let unpark = park.unpark();
+
+        let (spawn_sender, spawn_receiver) = mpsc::channel();
+
+        let scheduler = Scheduler::new(unpark);
+        let notify = scheduler.notify();
+
+        let num_futures = Arc::new(atomic::AtomicUsize::new(0));
+
+        CurrentThread {
+            scheduler: scheduler,
+            num_futures: num_futures.clone(),
+            park,
+            spawn_handle: Handle {
+                sender: spawn_sender,
+                num_futures: num_futures,
+                notify: notify,
+                shut_down: Cell::new(false),
+            },
+            spawn_receiver: spawn_receiver,
+        }
+    }
+
+    /// Returns `true` if the executor is currently idle.
+    ///
+    /// An idle executor is defined by not currently having any spawned tasks.
+    ///
+    /// Note that this method is inherently racy -- if a future is spawned from a remote `Handle`,
+    /// this method may return `true` even though there are more futures to be executed.
+    pub fn is_idle(&self) -> bool {
+        self.num_futures.load(atomic::Ordering::SeqCst) <= 1
+    }
+
+    /// Spawn the future on the executor.
+    ///
+    /// This internally queues the future to be executed once `run` is called.
+    pub fn spawn<F>(&mut self, future: F) -> &mut Self
+    where F: Future<Item = (), Error = ()> + 'static,
+    {
+        self.borrow().spawn_local(Box::new(future), false);
+        self
+    }
+
+    /// Synchronously waits for the provided `future` to complete.
+    ///
+    /// This function can be used to synchronously block the current thread
+    /// until the provided `future` has resolved either successfully or with an
+    /// error. The result of the future is then returned from this function
+    /// call.
+    ///
+    /// Note that this function will **also** execute any spawned futures on the
+    /// current thread, but will **not** block until these other spawned futures
+    /// have completed.
+    ///
+    /// The caller is responsible for ensuring that other spawned futures
+    /// complete execution.
+    pub fn block_on<F>(&mut self, future: F)
+        -> Result<F::Item, BlockError<F::Error>>
+    where F: Future
+    {
+        let mut enter = tokio_executor::enter()
+            .expect("failed to start `current_thread::Runtime`");
+        self.enter(&mut enter).block_on(future)
+    }
+
+    /// Run the executor to completion, blocking the thread until **all**
+    /// spawned futures have completed.
+    pub fn run(&mut self) -> Result<(), RunError> {
+        let mut enter = tokio_executor::enter()
+            .expect("failed to start `current_thread::Runtime`");
+        self.enter(&mut enter).run()
+    }
+
+    /// Run the executor to completion, blocking the thread until all
+    /// spawned futures have completed **or** `duration` time has elapsed.
+    pub fn run_timeout(&mut self, duration: Duration)
+        -> Result<(), RunTimeoutError>
+    {
+        let mut enter = tokio_executor::enter()
+            .expect("failed to start `current_thread::Runtime`");
+        self.enter(&mut enter).run_timeout(duration)
+    }
+
+    /// Perform a single iteration of the event loop.
+    ///
+    /// This function blocks the current thread even if the executor is idle.
+    pub fn turn(&mut self, duration: Option<Duration>)
+        -> Result<Turn, TurnError>
+    {
+        let mut enter = tokio_executor::enter()
+            .expect("failed to start `current_thread::Runtime`");
+        self.enter(&mut enter).turn(duration)
+    }
+
+    /// Bind `CurrentThread` instance with an execution context.
+    pub fn enter<'a>(&'a mut self, enter: &'a mut Enter) -> Entered<'a, P> {
+        Entered {
+            executor: self,
+            enter,
+        }
+    }
+
+    /// Returns a reference to the underlying `Park` instance.
+    pub fn get_park(&self) -> &P {
+        &self.park
+    }
+
+    /// Returns a mutable reference to the underlying `Park` instance.
+    pub fn get_park_mut(&mut self) -> &mut P {
+        &mut self.park
+    }
+
+    fn borrow(&mut self) -> Borrow<P::Unpark> {
+        Borrow {
+            scheduler: &mut self.scheduler,
+            num_futures: &*self.num_futures,
+        }
+    }
+
+    /// Get a new handle to spawn futures on the executor
+    ///
+    /// Different to the executor itself, the handle can be sent to different
+    /// threads and can be used to spawn futures on the executor.
+    pub fn handle(&self) -> Handle {
+        self.spawn_handle.clone()
+    }
+}
+
+impl<P: Park> Drop for CurrentThread<P> {
+    fn drop(&mut self) {
+        // Signal to Handles that no more futures can be spawned by setting LSB.
+        //
+        // NOTE: this isn't technically necessary since the send on the mpsc will fail once the
+        // receiver is dropped, but it's useful to illustrate how clean shutdown will be
+        // implemented (e.g., by setting the LSB).
+        let pending = self.num_futures.fetch_add(1, atomic::Ordering::SeqCst);
+
+        // TODO: We currently ignore any pending futures at the time we shut down.
+        //
+        // The "proper" fix for this is to have an explicit shutdown phase (`shutdown_on_idle`)
+        // which sets LSB (as above) do make Handle::spawn stop working, and then runs until
+        // num_futures.load() == 1.
+        let _ = pending;
+    }
+}
+
+impl tokio_executor::Executor for CurrentThread {
+    fn spawn(
+        &mut self,
+        future: Box<Future<Item = (), Error = ()> + Send>,
+    ) -> Result<(), SpawnError> {
+        self.borrow().spawn_local(future, false);
+        Ok(())
+    }
+
+    #[cfg(feature = "unstable-futures")]
+    fn spawn2(&mut self, _future: Box<futures2::Future<Item = (), Error = futures2::Never> + Send>)
+        -> Result<(), futures2::executor::SpawnError>
+    {
+        panic!("Futures 0.2 integration is not available for current_thread");
+    }
+}
+
+impl<P: Park> fmt::Debug for CurrentThread<P> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("CurrentThread")
+            .field("scheduler", &self.scheduler)
+            .field("num_futures", &self.num_futures.load(atomic::Ordering::SeqCst))
+            .finish()
+    }
+}
+
+// ===== impl Entered =====
+
+impl<'a, P: Park> Entered<'a, P> {
+    /// Spawn the future on the executor.
+    ///
+    /// This internally queues the future to be executed once `run` is called.
+    pub fn spawn<F>(&mut self, future: F) -> &mut Self
+    where F: Future<Item = (), Error = ()> + 'static,
+    {
+        self.executor.borrow().spawn_local(Box::new(future), false);
+        self
+    }
+
+    /// Synchronously waits for the provided `future` to complete.
+    ///
+    /// This function can be used to synchronously block the current thread
+    /// until the provided `future` has resolved either successfully or with an
+    /// error. The result of the future is then returned from this function
+    /// call.
+    ///
+    /// Note that this function will **also** execute any spawned futures on the
+    /// current thread, but will **not** block until these other spawned futures
+    /// have completed.
+    ///
+    /// The caller is responsible for ensuring that other spawned futures
+    /// complete execution.
+    pub fn block_on<F>(&mut self, future: F)
+        -> Result<F::Item, BlockError<F::Error>>
+    where F: Future
+    {
+        let mut future = executor::spawn(future);
+        let notify = self.executor.scheduler.notify();
+
+        loop {
+            let res = self.executor.borrow().enter(self.enter, || {
+                future.poll_future_notify(&notify, 0)
+            });
+
+            match res {
+                Ok(Async::Ready(e)) => return Ok(e),
+                Err(e) => return Err(BlockError { inner: Some(e) }),
+                Ok(Async::NotReady) => {}
+            }
+
+            self.tick();
+
+            if let Err(_) = self.executor.park.park() {
+                return Err(BlockError { inner: None });
+            }
+        }
+    }
+
+    /// Run the executor to completion, blocking the thread until **all**
+    /// spawned futures have completed.
+    pub fn run(&mut self) -> Result<(), RunError> {
+        self.run_timeout2(None)
+            .map_err(|_| RunError { _p: () })
+    }
+
+    /// Run the executor to completion, blocking the thread until all
+    /// spawned futures have completed **or** `duration` time has elapsed.
+    pub fn run_timeout(&mut self, duration: Duration)
+        -> Result<(), RunTimeoutError>
+    {
+        self.run_timeout2(Some(duration))
+    }
+
+    /// Perform a single iteration of the event loop.
+    ///
+    /// This function blocks the current thread even if the executor is idle.
+    pub fn turn(&mut self, duration: Option<Duration>)
+        -> Result<Turn, TurnError>
+    {
+        let res = if self.executor.scheduler.has_pending_futures() {
+            self.executor.park.park_timeout(Duration::from_millis(0))
+        } else {
+            match duration {
+                Some(duration) => self.executor.park.park_timeout(duration),
+                None => self.executor.park.park(),
+            }
+        };
+
+        if res.is_err() {
+            return Err(TurnError { _p: () });
+        }
+
+        let polled = self.tick();
+
+        Ok(Turn { polled })
+    }
+
+    /// Returns a reference to the underlying `Park` instance.
+    pub fn get_park(&self) -> &P {
+        &self.executor.park
+    }
+
+    /// Returns a mutable reference to the underlying `Park` instance.
+    pub fn get_park_mut(&mut self) -> &mut P {
+        &mut self.executor.park
+    }
+
+    fn run_timeout2(&mut self, dur: Option<Duration>)
+        -> Result<(), RunTimeoutError>
+    {
+        if self.executor.is_idle() {
+            // Nothing to do
+            return Ok(());
+        }
+
+        let mut time = dur.map(|dur| (Instant::now() + dur, dur));
+
+        loop {
+            self.tick();
+
+            if self.executor.is_idle() {
+                return Ok(());
+            }
+
+            match time {
+                Some((until, rem)) => {
+                    if let Err(_) = self.executor.park.park_timeout(rem) {
+                        return Err(RunTimeoutError::new(false));
+                    }
+
+                    let now = Instant::now();
+
+                    if now >= until {
+                        return Err(RunTimeoutError::new(true));
+                    }
+
+                    time = Some((until, until - now));
+                }
+                None => {
+                    if let Err(_) = self.executor.park.park() {
+                        return Err(RunTimeoutError::new(false));
+                    }
+                }
+            }
+        }
+    }
+
+    /// Returns `true` if any futures were processed
+    fn tick(&mut self) -> bool {
+        // Spawn any futures that were spawned from other threads by manually
+        // looping over the receiver stream
+
+        // FIXME: Slightly ugly but needed to make the borrow checker happy
+        let (mut borrow, spawn_receiver) = (
+            Borrow {
+                scheduler: &mut self.executor.scheduler,
+                num_futures: &*self.executor.num_futures,
+            },
+            &mut self.executor.spawn_receiver,
+        );
+
+        while let Ok(future) = spawn_receiver.try_recv() {
+            borrow.spawn_local(future, true);
+        }
+
+        // After any pending futures were scheduled, do the actual tick
+        borrow.scheduler.tick(
+            &mut *self.enter,
+            borrow.num_futures)
+    }
+}
+
+impl<'a, P: Park> fmt::Debug for Entered<'a, P> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("Entered")
+            .field("executor", &self.executor)
+            .field("enter", &self.enter)
+            .finish()
+    }
+}
+
+// ===== impl Handle =====
+
+/// Handle to spawn a future on the corresponding `CurrentThread` instance
+#[derive(Clone)]
+pub struct Handle {
+    sender: mpsc::Sender<Box<Future<Item = (), Error = ()> + Send + 'static>>,
+    num_futures: Arc<atomic::AtomicUsize>,
+    shut_down: Cell<bool>,
+    notify: executor::NotifyHandle,
+}
+
+// Manual implementation because the Sender does not implement Debug
+impl fmt::Debug for Handle {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("Handle")
+            .field("shut_down", &self.shut_down.get())
+            .finish()
+    }
+}
+
+impl Handle {
+    /// Spawn a future onto the `CurrentThread` instance corresponding to this handle
+    ///
+    /// # Panics
+    ///
+    /// This function panics if the spawn fails. Failure occurs if the `CurrentThread`
+    /// instance of the `Handle` does not exist anymore.
+    pub fn spawn<F>(&self, future: F) -> Result<(), SpawnError>
+    where
+        F: Future<Item = (), Error = ()> + Send + 'static,
+    {
+        if self.shut_down.get() {
+            return Err(SpawnError::shutdown());
+        }
+
+        // NOTE: += 2 since LSB is the shutdown bit
+        let pending = self.num_futures.fetch_add(2, atomic::Ordering::SeqCst);
+        if pending % 2 == 1 {
+            // Bring the count back so we still know when the Runtime is idle.
+            self.num_futures.fetch_sub(2, atomic::Ordering::SeqCst);
+
+            // Once the Runtime is shutting down, we know it won't come back.
+            self.shut_down.set(true);
+
+            return Err(SpawnError::shutdown());
+        }
+
+        self.sender
+            .send(Box::new(future))
+            .expect("CurrentThread does not exist anymore");
+        // use 0 for the id, CurrentThread does not make use of it
+        self.notify.notify(0);
+
+        Ok(())
+    }
+}
+
+// ===== impl TaskExecutor =====
+
+impl TaskExecutor {
+    /// Returns an executor that executes futures on the current thread.
+    ///
+    /// The user of `TaskExecutor` must ensure that when a future is submitted,
+    /// that it is done within the context of a call to `run`.
+    ///
+    /// For more details, see the [module level](index.html) documentation.
+    pub fn current() -> TaskExecutor {
+        TaskExecutor {
+            _p: ::std::marker::PhantomData,
+        }
+    }
+
+    /// Spawn a future onto the current `CurrentThread` instance.
+    pub fn spawn_local(&mut self, future: Box<Future<Item = (), Error = ()>>)
+        -> Result<(), SpawnError>
+    {
+        CURRENT.with(|current| {
+            match current.spawn.get() {
+                Some(spawn) => {
+                    unsafe { (*spawn).spawn_local(future, false) };
+                    Ok(())
+                }
+                None => {
+                    Err(SpawnError::shutdown())
+                }
+            }
+        })
+    }
+}
+
+impl tokio_executor::Executor for TaskExecutor {
+    fn spawn(&mut self, future: Box<Future<Item = (), Error = ()> + Send>)
+        -> Result<(), SpawnError>
+    {
+        self.spawn_local(future)
+    }
+
+    #[cfg(feature = "unstable-futures")]
+    fn spawn2(&mut self, _future: Box<futures2::Future<Item = (), Error = futures2::Never> + Send>)
+        -> Result<(), futures2::executor::SpawnError>
+    {
+        panic!("Futures 0.2 integration is not available for current_thread");
+    }
+
+    fn status(&self) -> Result<(), SpawnError> {
+        CURRENT.with(|current| {
+            if current.spawn.get().is_some() {
+                Ok(())
+            } else {
+                Err(SpawnError::shutdown())
+            }
+        })
+    }
+}
+
+impl<F> Executor<F> for TaskExecutor
+where F: Future<Item = (), Error = ()> + 'static
+{
+    fn execute(&self, future: F) -> Result<(), ExecuteError<F>> {
+        CURRENT.with(|current| {
+            match current.spawn.get() {
+                Some(spawn) => {
+                    unsafe { (*spawn).spawn_local(Box::new(future), false) };
+                    Ok(())
+                }
+                None => {
+                    Err(ExecuteError::new(ExecuteErrorKind::Shutdown, future))
+                }
+            }
+        })
+    }
+}
+
+// ===== impl Borrow =====
+
+impl<'a, U: Unpark> Borrow<'a, U> {
+    fn enter<F, R>(&mut self, _: &mut Enter, f: F) -> R
+    where F: FnOnce() -> R,
+    {
+        CURRENT.with(|current| {
+            current.set_spawn(self, || {
+                f()
+            })
+        })
+    }
+}
+
+impl<'a, U: Unpark> SpawnLocal for Borrow<'a, U> {
+    fn spawn_local(&mut self, future: Box<Future<Item = (), Error = ()>>, already_counted: bool) {
+        if !already_counted {
+            // NOTE: we have a borrow of the Runtime, so we know that it isn't shut down.
+            // NOTE: += 2 since LSB is the shutdown bit
+            self.num_futures.fetch_add(2, atomic::Ordering::SeqCst);
+        }
+        self.scheduler.schedule(future);
+    }
+}
+
+// ===== impl CurrentRunner =====
+
+impl CurrentRunner {
+    fn set_spawn<F, R>(&self, spawn: &mut SpawnLocal, f: F) -> R
+    where F: FnOnce() -> R
+    {
+        struct Reset<'a>(&'a CurrentRunner);
+
+        impl<'a> Drop for Reset<'a> {
+            fn drop(&mut self) {
+                self.0.spawn.set(None);
+            }
+        }
+
+        let _reset = Reset(self);
+
+        let spawn = unsafe { hide_lt(spawn as *mut SpawnLocal) };
+        self.spawn.set(Some(spawn));
+
+        f()
+    }
+}
+
+unsafe fn hide_lt<'a>(p: *mut (SpawnLocal + 'a)) -> *mut (SpawnLocal + 'static) {
+    use std::mem;
+    mem::transmute(p)
+}
+
+// ===== impl RunTimeoutError =====
+
+impl RunTimeoutError {
+    fn new(timeout: bool) -> Self {
+        RunTimeoutError { timeout }
+    }
+
+    /// Returns `true` if the error was caused by the operation timing out.
+    pub fn is_timeout(&self) -> bool {
+        self.timeout
+    }
+}
+
+impl From<tokio_executor::EnterError> for RunTimeoutError {
+    fn from(_: tokio_executor::EnterError) -> Self {
+        RunTimeoutError::new(false)
+    }
+}
+
+// ===== impl BlockError =====
+
+impl<T> BlockError<T> {
+    /// Returns the error yielded by the future being blocked on
+    pub fn into_inner(self) -> Option<T> {
+        self.inner
+    }
+}
+
+impl<T> From<tokio_executor::EnterError> for BlockError<T> {
+    fn from(_: tokio_executor::EnterError) -> Self {
+        BlockError { inner: None }
+    }
+}

tokio-current-thread/src/scheduler.rs

@@ -10,7 +10,7 @@ use std::fmt::{self, Debug};
 use std::mem;
 use std::ptr;
 use std::sync::atomic::Ordering::{Relaxed, SeqCst, Acquire, Release, AcqRel};
-use std::sync::atomic::{AtomicPtr, AtomicBool, AtomicUsize};
+use std::sync::atomic::{AtomicBool, AtomicPtr, AtomicUsize};
 use std::sync::{Arc, Weak};
 use std::usize;
 use std::thread;
@@ -210,7 +210,7 @@ where U: Unpark,
     ///
     /// This function should be called whenever the caller is notified via a
     /// wakeup.
-    pub fn tick(&mut self, enter: &mut Enter, num_futures: &mut usize) -> bool
+    pub fn tick(&mut self, enter: &mut Enter, num_futures: &AtomicUsize) -> bool
     {
         let mut ret = false;
         let tick = self.inner.tick_num.fetch_add(1, SeqCst)
@@ -330,7 +330,8 @@ where U: Unpark,
                     };
 
                     if borrow.enter(enter, || scheduled.tick()) {
-                        *borrow.num_futures -= 1;
+                        // we have a borrow of the Runtime, so we know it's not shut down
+                        borrow.num_futures.fetch_sub(2, SeqCst);
                     }
                 }
 

tokio-current-thread/tests/current_thread.rs

@@ -1,10 +1,10 @@
 #![cfg(not(feature = "unstable-futures"))]
 
-extern crate tokio;
+extern crate tokio_current_thread;
 extern crate tokio_executor;
 extern crate futures;
 
-use tokio::executor::current_thread::{self, block_on_all, CurrentThread};
+use tokio_current_thread::{block_on_all, CurrentThread};
 
 use std::any::Any;
 use std::cell::{Cell, RefCell};
@@ -22,11 +22,11 @@ fn spawn_from_block_on_all() {
     let cnt = Rc::new(Cell::new(0));
     let c = cnt.clone();
 
-    let msg = current_thread::block_on_all(lazy(move || {
+    let msg = tokio_current_thread::block_on_all(lazy(move || {
         c.set(1 + c.get());
 
         // Spawn!
-        current_thread::spawn(lazy(move || {
+        tokio_current_thread::spawn(lazy(move || {
             c.set(1 + c.get());
             Ok::<(), ()>(())
         }));
@@ -63,17 +63,17 @@ fn spawn_many() {
     const ITER: usize = 200;
 
     let cnt = Rc::new(Cell::new(0));
-    let mut current_thread = CurrentThread::new();
+    let mut tokio_current_thread = CurrentThread::new();
 
     for _ in 0..ITER {
         let cnt = cnt.clone();
-        current_thread.spawn(lazy(move || {
+        tokio_current_thread.spawn(lazy(move || {
             cnt.set(1 + cnt.get());
             Ok::<(), ()>(())
         }));
     }
 
-    current_thread.run().unwrap();
+    tokio_current_thread.run().unwrap();
 
     assert_eq!(cnt.get(), ITER);
 }
@@ -95,12 +95,12 @@ fn does_not_set_global_executor_by_default() {
 fn spawn_from_block_on_future() {
     let cnt = Rc::new(Cell::new(0));
 
-    let mut current_thread = CurrentThread::new();
+    let mut tokio_current_thread = CurrentThread::new();
 
-    current_thread.block_on(lazy(|| {
+    tokio_current_thread.block_on(lazy(|| {
         let cnt = cnt.clone();
 
-        current_thread::spawn(lazy(move || {
+        tokio_current_thread::spawn(lazy(move || {
             cnt.set(1 + cnt.get());
             Ok(())
         }));
@@ -108,7 +108,7 @@ fn spawn_from_block_on_future() {
         Ok::<_, ()>(())
     })).unwrap();
 
-    current_thread.run().unwrap();
+    tokio_current_thread.run().unwrap();
 
     assert_eq!(1, cnt.get());
 }
@@ -128,10 +128,10 @@ impl Future for Never {
 fn outstanding_tasks_are_dropped_when_executor_is_dropped() {
     let mut rc = Rc::new(());
 
-    let mut current_thread = CurrentThread::new();
-    current_thread.spawn(Never(rc.clone()));
+    let mut tokio_current_thread = CurrentThread::new();
+    tokio_current_thread.spawn(Never(rc.clone()));
 
-    drop(current_thread);
+    drop(tokio_current_thread);
 
     // Ensure the daemon is dropped
     assert!(Rc::get_mut(&mut rc).is_some());
@@ -140,14 +140,14 @@ fn outstanding_tasks_are_dropped_when_executor_is_dropped() {
 
     let mut rc = Rc::new(());
 
-    let mut current_thread = CurrentThread::new();
+    let mut tokio_current_thread = CurrentThread::new();
 
-    current_thread.block_on(lazy(|| {
-        current_thread::spawn(Never(rc.clone()));
+    tokio_current_thread.block_on(lazy(|| {
+        tokio_current_thread::spawn(Never(rc.clone()));
         Ok::<_, ()>(())
     })).unwrap();
 
-    drop(current_thread);
+    drop(tokio_current_thread);
 
     // Ensure the daemon is dropped
     assert!(Rc::get_mut(&mut rc).is_some());
@@ -169,7 +169,7 @@ fn nesting_run() {
 #[should_panic]
 fn run_in_future() {
     block_on_all(lazy(|| {
-        current_thread::spawn(lazy(|| {
+        tokio_current_thread::spawn(lazy(|| {
             block_on_all(lazy(|| {
                 ok()
             })).unwrap();
@@ -246,12 +246,12 @@ fn tasks_are_scheduled_fairly() {
     }
 
     block_on_all(lazy(|| {
-        current_thread::spawn(Spin {
+        tokio_current_thread::spawn(Spin {
             state: state.clone(),
             idx: 0,
         });
 
-        current_thread::spawn(Spin {
+        tokio_current_thread::spawn(Spin {
             state: state,
             idx: 1,
         });
@@ -265,21 +265,21 @@ fn spawn_and_turn() {
     let cnt = Rc::new(Cell::new(0));
     let c = cnt.clone();
 
-    let mut current_thread = CurrentThread::new();
+    let mut tokio_current_thread = CurrentThread::new();
 
     // Spawn a basic task to get the executor to turn
-    current_thread.spawn(lazy(move || {
+    tokio_current_thread.spawn(lazy(move || {
         Ok(())
     }));
 
     // Turn once...
-    current_thread.turn(None).unwrap();
+    tokio_current_thread.turn(None).unwrap();
 
-    current_thread.spawn(lazy(move || {
+    tokio_current_thread.spawn(lazy(move || {
         c.set(1 + c.get());
 
         // Spawn!
-        current_thread::spawn(lazy(move || {
+        tokio_current_thread::spawn(lazy(move || {
             c.set(1 + c.get());
             Ok::<(), ()>(())
         }));
@@ -288,21 +288,21 @@ fn spawn_and_turn() {
     }));
 
     // This does not run the newly spawned thread
-    current_thread.turn(None).unwrap();
+    tokio_current_thread.turn(None).unwrap();
     assert_eq!(1, cnt.get());
 
     // This runs the newly spawned thread
-    current_thread.turn(None).unwrap();
+    tokio_current_thread.turn(None).unwrap();
     assert_eq!(2, cnt.get());
 }
 
 #[test]
 fn spawn_in_drop() {
-    let mut current_thread = CurrentThread::new();
+    let mut tokio_current_thread = CurrentThread::new();
 
     let (tx, rx) = oneshot::channel();
 
-    current_thread.spawn({
+    tokio_current_thread.spawn({
         struct OnDrop<F: FnOnce()>(Option<F>);
 
         impl<F: FnOnce()> Drop for OnDrop<F> {
@@ -326,7 +326,7 @@ fn spawn_in_drop() {
 
         MyFuture {
             _data: Box::new(OnDrop(Some(move || {
-                current_thread::spawn(lazy(move || {
+                tokio_current_thread::spawn(lazy(move || {
                     tx.send(()).unwrap();
                     Ok(())
                 }));
@@ -334,8 +334,8 @@ fn spawn_in_drop() {
         }
     });
 
-    current_thread.block_on(rx).unwrap();
-    current_thread.run().unwrap();
+    tokio_current_thread.block_on(rx).unwrap();
+    tokio_current_thread.run().unwrap();
 }
 
 #[test]
@@ -352,11 +352,11 @@ fn hammer_turn() {
         // Add some jitter
         for _ in 0..THREADS {
             let th = thread::spawn(|| {
-                let mut current_thread = CurrentThread::new();
+                let mut tokio_current_thread = CurrentThread::new();
 
                 let (tx, rx) = mpsc::unbounded();
 
-                current_thread.spawn({
+                tokio_current_thread.spawn({
                     let cnt = Rc::new(Cell::new(0));
                     let c = cnt.clone();
 
@@ -378,8 +378,8 @@ fn hammer_turn() {
                     }
                 });
 
-                while !current_thread.is_idle() {
-                    current_thread.turn(None).unwrap();
+                while !tokio_current_thread.is_idle() {
+                    tokio_current_thread.turn(None).unwrap();
                 }
             });
 
@@ -394,20 +394,20 @@ fn hammer_turn() {
 
 #[test]
 fn turn_has_polled() {
-    let mut current_thread = CurrentThread::new();
+    let mut tokio_current_thread = CurrentThread::new();
 
     // Spawn oneshot receiver
     let (sender, receiver) = oneshot::channel::<()>();
-    current_thread.spawn(receiver.then(|_| Ok(())));
+    tokio_current_thread.spawn(receiver.then(|_| Ok(())));
 
     // Turn once...
-    let res = current_thread.turn(Some(Duration::from_millis(0))).unwrap();
+    let res = tokio_current_thread.turn(Some(Duration::from_millis(0))).unwrap();
 
     // Should've polled the receiver once, but considered it not ready
     assert!(res.has_polled());
 
     // Turn another time
-    let res = current_thread.turn(Some(Duration::from_millis(0))).unwrap();
+    let res = tokio_current_thread.turn(Some(Duration::from_millis(0))).unwrap();
 
     // Should've polled nothing, the receiver is not ready yet
     assert!(!res.has_polled());
@@ -416,14 +416,14 @@ fn turn_has_polled() {
     sender.send(()).unwrap();
 
     // Turn another time
-    let res = current_thread.turn(Some(Duration::from_millis(0))).unwrap();
+    let res = tokio_current_thread.turn(Some(Duration::from_millis(0))).unwrap();
 
     // Should've polled the receiver, it's ready now
     assert!(res.has_polled());
 
     // Now the executor should be empty
-    assert!(current_thread.is_idle());
-    let res = current_thread.turn(Some(Duration::from_millis(0))).unwrap();
+    assert!(tokio_current_thread.is_idle());
+    let res = tokio_current_thread.turn(Some(Duration::from_millis(0))).unwrap();
 
     // So should've polled nothing
     assert!(!res.has_polled());
@@ -478,14 +478,14 @@ fn turn_fair() {
         send_now: send_now.clone(),
     };
 
-    let mut current_thread = CurrentThread::new_with_park(my_park);
+    let mut tokio_current_thread = CurrentThread::new_with_park(my_park);
 
     let receiver_1_done = Rc::new(Cell::new(false));
     let receiver_1_done_clone = receiver_1_done.clone();
 
     // Once an item is received on the oneshot channel, it will immediately
     // immediately make the second oneshot channel ready
-    current_thread.spawn(receiver
+    tokio_current_thread.spawn(receiver
         .map_err(|_| unreachable!())
         .and_then(move |_| {
             sender_2.send(()).unwrap();
@@ -498,7 +498,7 @@ fn turn_fair() {
     let receiver_2_done = Rc::new(Cell::new(false));
     let receiver_2_done_clone = receiver_2_done.clone();
 
-    current_thread.spawn(receiver_2
+    tokio_current_thread.spawn(receiver_2
         .map_err(|_| unreachable!())
         .and_then(move |_| {
             receiver_2_done_clone.set(true);
@@ -511,7 +511,7 @@ fn turn_fair() {
     let receiver_3_done = Rc::new(Cell::new(false));
     let receiver_3_done_clone = receiver_3_done.clone();
 
-    current_thread.spawn(receiver_3
+    tokio_current_thread.spawn(receiver_3
         .map_err(|_| unreachable!())
         .and_then(move |_| {
             receiver_3_done_clone.set(true);
@@ -520,11 +520,11 @@ fn turn_fair() {
     );
 
     // First turn should've polled both and considered them not ready
-    let res = current_thread.turn(Some(Duration::from_millis(0))).unwrap();
+    let res = tokio_current_thread.turn(Some(Duration::from_millis(0))).unwrap();
     assert!(res.has_polled());
 
     // Next turn should've polled nothing
-    let res = current_thread.turn(Some(Duration::from_millis(0))).unwrap();
+    let res = tokio_current_thread.turn(Some(Duration::from_millis(0))).unwrap();
     assert!(!res.has_polled());
 
     assert!(!receiver_1_done.get());
@@ -537,7 +537,7 @@ fn turn_fair() {
 
     // Now the first receiver should be done, the second receiver should be ready
     // to be polled again and the socket not yet
-    let res = current_thread.turn(None).unwrap();
+    let res = tokio_current_thread.turn(None).unwrap();
     assert!(res.has_polled());
 
     assert!(receiver_1_done.get());
@@ -551,7 +551,7 @@ fn turn_fair() {
     // and read the packet from it. If it didn't do both here, we would handle
     // futures that are woken up from the reactor and directly unfairly and would
     // favour the ones that are woken up directly.
-    let res = current_thread.turn(None).unwrap();
+    let res = tokio_current_thread.turn(None).unwrap();
     assert!(res.has_polled());
 
     assert!(receiver_1_done.get());
@@ -562,8 +562,8 @@ fn turn_fair() {
     send_now.set(false);
 
     // Now we should be idle and turning should not poll anything
-    assert!(current_thread.is_idle());
-    let res = current_thread.turn(None).unwrap();
+    assert!(tokio_current_thread.is_idle());
+    let res = tokio_current_thread.turn(None).unwrap();
     assert!(!res.has_polled());
 }
 

tokio-executor/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 0.1.3 (August 6, 2018)
+
+* Implement `Executor` for `Box<E: Executor>` (#420).
+* Improve `EnterError` debug message (#410).
+* Implement `status`, `Send`, and `Sync` for `DefaultExecutor` (#463, #472).
+* Fix race in `ParkThread` (#507).
+* Handle recursive calls into `DefaultExecutor` (#473).
+
 # 0.1.2 (March 30, 2018)
 
 * Implement `Unpark` for `Box<Unpark>`.

tokio-executor/Cargo.toml

@@ -5,7 +5,7 @@ name = "tokio-executor"
 # - Update html_root_url.
 # - Update CHANGELOG.md.
 # - Create "v0.1.x" git tag.
-version = "0.1.2"
+version = "0.1.3"
 documentation = "https://docs.rs/tokio-executor"
 repository = "https://github.com/tokio-rs/tokio"
 homepage = "https://github.com/tokio-rs/tokio"

tokio-executor/src/enter.rs

@@ -20,11 +20,18 @@ pub struct Enter {
 
 /// An error returned by `enter` if an execution scope has already been
 /// entered.
-#[derive(Debug)]
 pub struct EnterError {
     _a: (),
 }
 
+impl fmt::Debug for EnterError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("EnterError")
+            .field("reason", &"attempted to run an executor while another executor is already running")
+            .finish()
+    }
+}
+
 /// Marks the current thread as being within the dynamic extent of an
 /// executor.
 ///

tokio-executor/src/global.rs

@@ -3,8 +3,6 @@ use super::{Executor, Enter, SpawnError};
 use futures::Future;
 
 use std::cell::Cell;
-use std::marker::PhantomData;
-use std::rc::Rc;
 
 #[cfg(feature = "unstable-futures")]
 use futures2;
@@ -21,8 +19,7 @@ use futures2;
 /// variable and is set using `tokio_executor::with_default`
 #[derive(Debug, Clone)]
 pub struct DefaultExecutor {
-    // Prevent the handle from moving across threads.
-    _p: PhantomData<Rc<()>>,
+    _dummy: (),
 }
 
 impl DefaultExecutor {
@@ -34,15 +31,44 @@ impl DefaultExecutor {
     /// the default **at the time `spawn` is called**. This enables
     /// `DefaultExecutor::current()` to be called before an execution context is
     /// setup, then passed **into** an execution context before it is used.
+    ///
+    /// This is also true for sending the handle across threads, so calling
+    /// `DefaultExecutor::current()` on thread A and then sending the result to
+    /// thread B will _not_ reference the default executor that was set on thread A.
     pub fn current() -> DefaultExecutor {
         DefaultExecutor {
-            _p: PhantomData,
+            _dummy: (),
         }
     }
+
+    #[inline]
+    fn with_current<F: FnOnce(&mut Executor) -> R, R>(f: F) -> Option<R> {
+        EXECUTOR.with(|current_executor| {
+            match current_executor.replace(State::Active) {
+                State::Ready(executor_ptr) => {
+                    let executor = unsafe { &mut *executor_ptr };
+                    let result = f(executor);
+                    current_executor.set(State::Ready(executor_ptr));
+                    Some(result)
+                },
+                State::Empty | State::Active => None,
+            }
+        })
+    }
 }
 
+#[derive(Clone, Copy)]
+enum State {
+    // default executor not defined
+    Empty,
+    // default executor is defined and ready to be used
+    Ready(*mut Executor),
+    // default executor is currently active (used to detect recursive calls)
+    Active
+} 
+
 /// Thread-local tracking the current executor
-thread_local!(static EXECUTOR: Cell<Option<*mut Executor>> = Cell::new(None));
+thread_local!(static EXECUTOR: Cell<State> = Cell::new(State::Empty));
 
 // ===== impl DefaultExecutor =====
 
@@ -50,34 +76,21 @@ impl super::Executor for DefaultExecutor {
     fn spawn(&mut self, future: Box<Future<Item = (), Error = ()> + Send>)
         -> Result<(), SpawnError>
     {
-        EXECUTOR.with(|current_executor| {
-            match current_executor.get() {
-                Some(executor) => {
-                    let executor = unsafe { &mut *executor };
-                    executor.spawn(future)
-                }
-                None => {
-                    Err(SpawnError::shutdown())
-                }
-            }
-        })
+        DefaultExecutor::with_current(|executor| executor.spawn(future))
+            .unwrap_or_else(|| Err(SpawnError::shutdown()))
     }
 
     #[cfg(feature = "unstable-futures")]
     fn spawn2(&mut self, future: Box<futures2::Future<Item = (), Error = futures2::Never> + Send>)
              -> Result<(), futures2::executor::SpawnError>
     {
-        EXECUTOR.with(|current_executor| {
-            match current_executor.get() {
-                Some(executor) => {
-                    let executor = unsafe { &mut *executor };
-                    executor.spawn2(future)
-                }
-                None => {
-                    Err(futures2::executor::SpawnError::shutdown())
-                }
-            }
-        })
+        DefaultExecutor::with_current(|executor| executor.spawn2(future))
+            .unwrap_or_else(|| Err(futures2::executor::SpawnError::shutdown()))
+    }
+
+    fn status(&self) -> Result<(), SpawnError> {
+        DefaultExecutor::with_current(|executor| executor.status())
+            .unwrap_or_else(|| Err(SpawnError::shutdown()))
     }
 }
 
@@ -148,15 +161,19 @@ where T: Executor,
       F: FnOnce(&mut Enter) -> R
 {
     EXECUTOR.with(|cell| {
-        assert!(cell.get().is_none(), "default executor already set for execution context");
+        match cell.get() {
+            State::Ready(_) | State::Active =>
+                panic!("default executor already set for execution context"),
+            _ => {}
+        }
 
         // Ensure that the executor is removed from the thread-local context
         // when leaving the scope. This handles cases that involve panicking.
-        struct Reset<'a>(&'a Cell<Option<*mut Executor>>);
+        struct Reset<'a>(&'a Cell<State>);
 
         impl<'a> Drop for Reset<'a> {
             fn drop(&mut self) {
-                self.0.set(None);
+                self.0.set(State::Empty);
             }
         }
 
@@ -171,7 +188,7 @@ where T: Executor,
         // cells require.
         let executor = unsafe { hide_lt(executor as &mut _ as *mut _) };
 
-        cell.set(Some(executor));
+        cell.set(State::Ready(executor));
 
         f(enter)
     })
@@ -181,3 +198,27 @@ unsafe fn hide_lt<'a>(p: *mut (Executor + 'a)) -> *mut (Executor + 'static) {
     use std::mem;
     mem::transmute(p)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{Executor, DefaultExecutor, with_default};
+
+    #[test]
+    fn default_executor_is_send_and_sync() {
+        fn assert_send_sync<T: Send + Sync>() {}
+
+        assert_send_sync::<DefaultExecutor>();
+    }
+
+    #[test]
+    fn nested_default_executor_status() {
+        let mut enter = super::super::enter().unwrap();
+        let mut executor = DefaultExecutor::current();
+
+        let result = with_default(&mut executor, &mut enter, |_| {
+            DefaultExecutor::current().status()
+        });
+
+        assert!(result.err().unwrap().is_shutdown())
+    }
+}

tokio-executor/src/lib.rs

@@ -6,9 +6,10 @@
 //! an executor is called a "task".
 //!
 //! The executor is responsible for ensuring that [`Future::poll`] is called
-//! whenever the task is [notified]. Notification happens when the internal
-//! state of a task transitions from "not ready" to ready. For example, a socket
-//! might have received data and a call to `read` will now be able to succeed.
+//! whenever the task is notified. Notification happens when the internal
+//! state of a task transitions from *not ready* to *ready*. For example, a
+//! socket might have received data and a call to `read` will now be able to
+//! succeed.
 //!
 //! This crate provides traits and utilities that are necessary for building an
 //! executor, including:
@@ -29,9 +30,10 @@
 //! [`enter`]: fn.enter.html
 //! [`DefaultExecutor`]: struct.DefaultExecutor.html
 //! [`Park`]: park/index.html
+//! [`Future::poll`]: https://docs.rs/futures/0.1/futures/future/trait.Future.html#tymethod.poll
 
 #![deny(missing_docs, missing_debug_implementations, warnings)]
-#![doc(html_root_url = "https://docs.rs/tokio-executor/0.1.2")]
+#![doc(html_root_url = "https://docs.rs/tokio-executor/0.1.3")]
 
 extern crate futures;
 
@@ -182,6 +184,25 @@ pub trait Executor {
     }
 }
 
+impl<E: Executor + ?Sized> Executor for Box<E> {
+    fn spawn(&mut self, future: Box<Future<Item = (), Error = ()> + Send>)
+        -> Result<(), SpawnError>
+    {
+        (**self).spawn(future)
+    }
+
+    #[cfg(feature = "unstable-futures")]
+    fn spawn2(&mut self, future: Box<futures2::Future<Item = (), Error = futures2::Never> + Send>)
+        -> Result<(), futures2::executor::SpawnError>
+    {
+        (**self).spawn2(future)
+    }
+
+    fn status(&self) -> Result<(), SpawnError> {
+        (**self).status()
+    }
+}
+
 /// Errors returned by `Executor::spawn`.
 ///
 /// Spawn errors should represent relatively rare scenarios. Currently, the two

tokio-executor/src/park.rs

@@ -42,7 +42,7 @@
 //! [`park_timeout`]: trait.Park.html#tymethod.park_timeout
 //! [`unpark`]: trait.Unpark.html#tymethod.unpark
 //! [up]: trait.Unpark.html
-//! [mio]: https://docs.rs/mio/0.6.13/mio/struct.Poll.html
+//! [mio]: https://docs.rs/mio/0.6/mio/struct.Poll.html
 
 use std::marker::PhantomData;
 use std::rc::Rc;
@@ -288,10 +288,12 @@ impl Inner {
         // The other half is sleeping, this requires a lock
         let _m = self.mutex.lock().unwrap();
 
-        // Transition from SLEEP -> NOTIFY
-        match self.state.compare_and_swap(SLEEP, NOTIFY, Ordering::SeqCst) {
+        // Transition to NOTIFY
+        match self.state.swap(NOTIFY, Ordering::SeqCst) {
             SLEEP => {}
-            _ => return,
+            NOTIFY => return,
+            IDLE => return,
+            _ => unreachable!(),
         }
 
         // Wakeup the sleeper

tokio-fs/CHANGELOG.md

@@ -1,5 +1,16 @@
-# Unreleased
+# 0.1.3 (August 6, 2018)
 
+* Add async equivalents to most of `std::fs` (#494).
+
+# 0.1.2 (July 11, 2018)
+
+* Add `metadata` and `File::metadata` ([#433](https://github.com/tokio-rs/tokio/pull/433), [#385](https://github.com/tokio-rs/tokio/pull/385))
+* Add `File::seek` ([#434](https://github.com/tokio-rs/tokio/pull/434))
+
+# 0.1.1 (June 13, 2018)
+
+* Add `OpenOptions` ([#390](https://github.com/tokio-rs/tokio/pull/390))
+* Add `into_std` to `File` ([#403](https://github.com/tokio-rs/tokio/pull/403))
 * Use `tokio-codec` in examples
 
 # 0.1.0 (May 2, 2018)

tokio-fs/Cargo.toml

@@ -5,7 +5,7 @@ name = "tokio-fs"
 # - Update html_root_url.
 # - Update CHANGELOG.md.
 # - Create "v0.1.x" git tag.
-version = "0.1.0"
+version = "0.1.3"
 authors = ["Carl Lerche <[email protected]>"]
 license = "MIT"
 readme = "README.md"
@@ -28,3 +28,4 @@ rand = "0.4.2"
 tempdir = "0.3.7"
 tokio-io = { version = "0.1.6", path = "../tokio-io" }
 tokio-codec = { version = "0.1.0", path = "../tokio-codec" }
+tokio = { version = "0.1.7", path = ".." }

tokio-fs/src/create_dir.rs

@@ -0,0 +1,46 @@
+use std::fs;
+use std::io;
+use std::path::Path;
+
+use futures::{Future, Poll};
+
+/// Creates a new, empty directory at the provided path
+///
+/// This is an async version of [`std::fs::create_dir`][std]
+///
+/// [std]: https://doc.rust-lang.org/std/fs/fn.create_dir.html
+pub fn create_dir<P: AsRef<Path>>(path: P) -> CreateDirFuture<P> {
+    CreateDirFuture::new(path)
+}
+
+/// Future returned by `create_dir`.
+#[derive(Debug)]
+pub struct CreateDirFuture<P>
+where
+    P: AsRef<Path>
+{
+    path: P,
+}
+
+impl<P> CreateDirFuture<P>
+where
+    P: AsRef<Path>
+{
+    fn new(path: P) -> CreateDirFuture<P> {
+        CreateDirFuture {
+            path: path,
+        }
+    }
+}
+
+impl<P> Future for CreateDirFuture<P>
+where
+    P: AsRef<Path>
+{
+    type Item = ();
+    type Error = io::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        ::blocking_io(|| fs::create_dir(&self.path) )
+    }
+}

tokio-fs/src/create_dir_all.rs

@@ -0,0 +1,47 @@
+use std::fs;
+use std::io;
+use std::path::Path;
+
+use futures::{Future, Poll};
+
+/// Recursively create a directory and all of its parent components if they
+/// are missing.
+///
+/// This is an async version of [`std::fs::create_dir_all`][std]
+///
+/// [std]: https://doc.rust-lang.org/std/fs/fn.create_dir_all.html
+pub fn create_dir_all<P: AsRef<Path>>(path: P) -> CreateDirAllFuture<P> {
+    CreateDirAllFuture::new(path)
+}
+
+/// Future returned by `create_dir_all`.
+#[derive(Debug)]
+pub struct CreateDirAllFuture<P>
+where
+    P: AsRef<Path>
+{
+    path: P,
+}
+
+impl<P> CreateDirAllFuture<P>
+where
+    P: AsRef<Path>
+{
+    fn new(path: P) -> CreateDirAllFuture<P> {
+        CreateDirAllFuture {
+            path: path,
+        }
+    }
+}
+
+impl<P> Future for CreateDirAllFuture<P>
+where
+    P: AsRef<Path>
+{
+    type Item = ();
+    type Error = io::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        ::blocking_io(|| fs::create_dir_all(&self.path) )
+    }
+}

tokio-fs/src/file/metadata.rs

@@ -0,0 +1,39 @@
+use super::File;
+
+use futures::{Future, Poll};
+
+use std::fs::File as StdFile;
+use std::fs::Metadata;
+use std::io;
+
+const POLL_AFTER_RESOLVE: &str = "Cannot poll MetadataFuture after it resolves";
+
+/// Future returned by `File::metadata` and resolves to a `(Metadata, File)` instance.
+#[derive(Debug)]
+pub struct MetadataFuture {
+    file: Option<File>,
+}
+
+impl MetadataFuture {
+    pub(crate) fn new(file: File) -> Self {
+        MetadataFuture { file: Some(file) }
+    }
+
+    fn std(&mut self) -> &mut StdFile {
+        self.file.as_mut().expect(POLL_AFTER_RESOLVE).std()
+    }
+}
+
+impl Future for MetadataFuture {
+    type Item = (File, Metadata);
+    type Error = io::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        let metadata = try_ready!(::blocking_io(|| {
+            StdFile::metadata(self.std())
+        }));
+
+        let file = self.file.take().expect(POLL_AFTER_RESOLVE);
+        Ok((file, metadata).into())
+    }
+}

tokio-fs/src/file/mod.rs

@@ -3,10 +3,16 @@
 //! [`File`]: file/struct.File.html
 
 mod create;
+mod metadata;
 mod open;
+mod open_options;
+mod seek;
 
 pub use self::create::CreateFuture;
+pub use self::metadata::MetadataFuture;
 pub use self::open::OpenFuture;
+pub use self::open_options::OpenOptions;
+pub use self::seek::SeekFuture;
 
 use tokio_io::{AsyncRead, AsyncWrite};
 
@@ -36,16 +42,20 @@ pub struct File {
 impl File {
     /// Attempts to open a file in read-only mode.
     ///
+    /// See [`OpenOptions`] for more details.
+    ///
+    /// [`OpenOptions`]: struct.OpenOptions.html
+    ///
     /// # Errors
     ///
     /// `OpenFuture` results in an error if called from outside of the Tokio
     /// runtime or if the underlying [`open`] call results in an error.
     ///
-    /// [`open`]: https://doc.rust-lang.org/std/fs/struct.OpenOptions.html#method.open
+    /// [`open`]: https://doc.rust-lang.org/std/fs/struct.File.html#method.open
     pub fn open<P>(path: P) -> OpenFuture<P>
     where P: AsRef<Path> + Send + 'static,
     {
-        OpenFuture::new(path)
+        OpenOptions::new().read(true).open(path)
     }
 
     /// Opens a file in write-only mode.
@@ -53,6 +63,12 @@ impl File {
     /// This function will create a file if it does not exist, and will truncate
     /// it if it does.
     ///
+    /// See [`OpenOptions`] for more details.
+    ///
+    /// [`OpenOptions`]: struct.OpenOptions.html
+    ///
+    /// # Errors
+    ///
     /// `CreateFuture` results in an error if called from outside of the Tokio
     /// runtime or if the underlying [`create`] call results in an error.
     ///
@@ -86,6 +102,16 @@ impl File {
         ::blocking_io(|| self.std().seek(pos))
     }
 
+    /// Seek to an offset, in bytes, in a stream.
+    ///
+    /// Similar to `poll_seek`, but returning a `Future`.
+    ///
+    /// This method consumes the `File` and returns it back when the future
+    /// completes.
+    pub fn seek(self, pos: io::SeekFrom) -> SeekFuture {
+        SeekFuture::new(self, pos)
+    }
+
     /// Attempts to sync all OS-internal metadata to disk.
     ///
     /// This function will attempt to ensure that all in-core data reaches the
@@ -121,6 +147,11 @@ impl File {
         ::blocking_io(|| self.std().set_len(size))
     }
 
+    /// Queries metadata about the underlying file.
+    pub fn metadata(self) -> MetadataFuture {
+        MetadataFuture::new(self)
+    }
+
     /// Queries metadata about the underlying file.
     pub fn poll_metadata(&mut self) -> Poll<Metadata, io::Error> {
         ::blocking_io(|| self.std().metadata())
@@ -155,6 +186,17 @@ impl File {
         ::blocking_io(|| self.std().set_permissions(perm))
     }
 
+    /// Destructures the `tokio_fs::File` into a [`std::fs::File`][std].
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if `shutdown` has been called.
+    ///
+    /// [std]: https://doc.rust-lang.org/std/fs/struct.File.html
+    pub fn into_std(mut self) -> StdFile {
+        self.std.take().expect("`File` instance already shutdown")
+    }
+
     fn std(&mut self) -> &mut StdFile {
         self.std.as_mut().expect("`File` instance already shutdown")
     }

tokio-fs/src/file/open.rs

@@ -2,21 +2,22 @@ use super::File;
 
 use futures::{Future, Poll};
 
-use std::fs::File as StdFile;
+use std::fs::OpenOptions as StdOpenOptions;
 use std::io;
 use std::path::Path;
 
 /// Future returned by `File::open` and resolves to a `File` instance.
 #[derive(Debug)]
 pub struct OpenFuture<P> {
+    options: StdOpenOptions,
     path: P,
 }
 
 impl<P> OpenFuture<P>
 where P: AsRef<Path> + Send + 'static,
 {
-    pub(crate) fn new(path: P) -> Self {
-        OpenFuture { path }
+    pub(crate) fn new(options: StdOpenOptions, path: P) -> Self {
+        OpenFuture { options, path }
     }
 }
 
@@ -28,7 +29,7 @@ where P: AsRef<Path> + Send + 'static,
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
         let std = try_ready!(::blocking_io(|| {
-            StdFile::open(&self.path)
+            self.options.open(&self.path)
         }));
 
         let file = File::from_std(std);

tokio-fs/src/file/open_options.rs

@@ -0,0 +1,103 @@
+use super::OpenFuture;
+
+use std::convert::From;
+use std::fs::OpenOptions as StdOpenOptions;
+use std::path::Path;
+
+/// Options and flags which can be used to configure how a file is opened.
+///
+/// This is a specialized version of [`std::fs::OpenOptions`] for usage from
+/// the Tokio runtime.
+///
+/// `From<std::fs::OpenOptions>` is implemented for more advanced configuration
+/// than the methods provided here.
+///
+/// [`std::fs::OpenOptions`]: https://doc.rust-lang.org/std/fs/struct.OpenOptions.html
+#[derive(Clone, Debug)]
+pub struct OpenOptions(StdOpenOptions);
+
+impl OpenOptions {
+    /// Creates a blank new set of options ready for configuration.
+    ///
+    /// All options are initially set to `false`.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// use tokio::fs::OpenOptions;
+    ///
+    /// let mut options = OpenOptions::new();
+    /// let future = options.read(true).open("foo.txt");
+    /// ```
+    pub fn new() -> OpenOptions {
+        OpenOptions(StdOpenOptions::new())
+    }
+
+    /// See the underlying [`read`] call for details.
+    ///
+    /// [`read`]: https://doc.rust-lang.org/std/fs/struct.OpenOptions.html#method.read
+    pub fn read(&mut self, read: bool) -> &mut OpenOptions {
+        self.0.read(read);
+        self
+    }
+
+    /// See the underlying [`write`] call for details.
+    ///
+    /// [`write`]: https://doc.rust-lang.org/std/fs/struct.OpenOptions.html#method.write
+    pub fn write(&mut self, write: bool) -> &mut OpenOptions {
+        self.0.write(write);
+        self
+    }
+
+    /// See the underlying [`append`] call for details.
+    ///
+    /// [`append`]: https://doc.rust-lang.org/std/fs/struct.OpenOptions.html#method.append
+    pub fn append(&mut self, append: bool) -> &mut OpenOptions {
+        self.0.append(append);
+        self
+    }
+
+    /// See the underlying [`truncate`] call for details.
+    ///
+    /// [`truncate`]: https://doc.rust-lang.org/std/fs/struct.OpenOptions.html#method.truncate
+    pub fn truncate(&mut self, truncate: bool) -> &mut OpenOptions {
+        self.0.truncate(truncate);
+        self
+    }
+
+    /// See the underlying [`create`] call for details.
+    ///
+    /// [`create`]: https://doc.rust-lang.org/std/fs/struct.OpenOptions.html#method.create
+    pub fn create(&mut self, create: bool) -> &mut OpenOptions {
+        self.0.create(create);
+        self
+    }
+
+    /// See the underlying [`create_new`] call for details.
+    ///
+    /// [`create_new`]: https://doc.rust-lang.org/std/fs/struct.OpenOptions.html#method.create_new
+    pub fn create_new(&mut self, create_new: bool) -> &mut OpenOptions {
+        self.0.create_new(create_new);
+        self
+    }
+
+    /// Opens a file at `path` with the options specified by `self`.
+    ///
+    /// # Errors
+    ///
+    /// `OpenOptionsFuture` results in an error if called from outside of the
+    /// Tokio runtime or if the underlying [`open`] call results in an error.
+    ///
+    /// [`open`]: https://doc.rust-lang.org/std/fs/struct.OpenOptions.html#method.open
+    pub fn open<P>(&self, path: P) -> OpenFuture<P>
+    where P: AsRef<Path> + Send + 'static
+    {
+        OpenFuture::new(self.0.clone(), path)
+    }
+}
+
+impl From<StdOpenOptions> for OpenOptions {
+    fn from(options: StdOpenOptions) -> OpenOptions {
+        OpenOptions(options)
+    }
+}

tokio-fs/src/file/seek.rs

@@ -0,0 +1,37 @@
+use super::File;
+
+use futures::{Future, Poll};
+
+use std::io;
+
+/// Future returned by `File::seek`.
+#[derive(Debug)]
+pub struct SeekFuture {
+    inner: Option<File>,
+    pos: io::SeekFrom,
+}
+
+impl SeekFuture {
+    pub(crate) fn new(file: File, pos: io::SeekFrom) -> Self {
+        Self {
+            pos,
+            inner: Some(file),
+        }
+    }
+}
+
+impl Future for SeekFuture {
+    type Item = (File, u64);
+    type Error = io::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        let pos = try_ready!(
+            self.inner
+                .as_mut()
+                .expect("Cannot poll `SeekFuture` after it resolves")
+                .poll_seek(self.pos)
+        );
+        let inner = self.inner.take().unwrap();
+        Ok((inner, pos).into())
+    }
+}

tokio-fs/src/hard_link.rs

@@ -0,0 +1,54 @@
+use std::fs;
+use std::io;
+use std::path::Path;
+
+use futures::{Future, Poll};
+
+/// Creates a new hard link on the filesystem.
+///
+/// The `dst` path will be a link pointing to the `src` path. Note that systems
+/// often require these two paths to both be located on the same filesystem.
+///
+/// This is an async version of [`std::fs::hard_link`][std]
+///
+/// [std]: https://doc.rust-lang.org/std/fs/fn.hard_link.html
+pub fn hard_link<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q) -> HardLinkFuture<P, Q> {
+    HardLinkFuture::new(src, dst)
+}
+
+/// Future returned by `hard_link`.
+#[derive(Debug)]
+pub struct HardLinkFuture<P, Q>
+where
+    P: AsRef<Path>,
+    Q: AsRef<Path>
+{
+    src: P,
+    dst: Q,
+}
+
+impl<P, Q> HardLinkFuture<P, Q>
+where
+    P: AsRef<Path>,
+    Q: AsRef<Path>
+{
+    fn new(src: P, dst: Q) -> HardLinkFuture<P, Q> {
+        HardLinkFuture {
+            src: src,
+            dst: dst,
+        }
+    }
+}
+
+impl<P, Q> Future for HardLinkFuture<P, Q>
+where
+    P: AsRef<Path>,
+    Q: AsRef<Path>
+{
+    type Item = ();
+    type Error = io::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        ::blocking_io(|| fs::hard_link(&self.src, &self.dst) )
+    }
+}

tokio-fs/src/lib.rs

@@ -1,31 +1,71 @@
-//! Asynchronous filesystem manipulation operations (and stdin, stdout, stderr).
+//! Asynchronous file and standard stream adaptation.
 //!
-//! This module contains basic methods and types for manipulating the contents
-//! of the local filesystem from within the context of the Tokio runtime.
+//! This module contains utility methods and adapter types for input/output to
+//! files or standard streams (`Stdin`, `Stdout`, `Stderr`), and
+//! filesystem manipulation, for use within (and only within) a Tokio runtime.
 //!
-//! Tasks running on the Tokio runtime are expected to be asynchronous, i.e.,
-//! they will not block the thread of execution. Filesystem operations do not
-//! satisfy this requirement. In order to perform filesystem operations
-//! asynchronously, this library uses the [`blocking`][blocking] annotation
-//! to signal to the runtime that a blocking operation is being performed. This
-//! allows the runtime to compensate.
+//! Tasks run by *worker* threads should not block, as this could delay
+//! servicing reactor events. Portable filesystem operations are blocking,
+//! however. This module offers adapters which use a [`blocking`] annotation
+//! to inform the runtime that a blocking operation is required. When
+//! necessary, this allows the runtime to convert the current thread from a
+//! *worker* to a *backup* thread, where blocking is acceptable.
 //!
-//! [blocking]: https://docs.rs/tokio-threadpool/0.1/tokio_threadpool/fn.blocking.html
+//! ## Usage
+//!
+//! Where possible, users should prefer the provided asynchronous-specific
+//! traits such as [`AsyncRead`], or methods returning a `Future` or `Poll`
+//! type. Adaptions also extend to traits like `std::io::Read` where methods
+//! return `std::io::Result`.  Be warned that these adapted methods may return
+//! `std::io::ErrorKind::WouldBlock` if a *worker* thread can not be converted
+//! to a *backup* thread immediately. See [tokio-threadpool] for more details
+//! of the threading model and [`blocking`].
+//!
+//! [`blocking`]: https://docs.rs/tokio-threadpool/0.1/tokio_threadpool/fn.blocking.html
+//! [`AsyncRead`]: https://docs.rs/tokio-io/0.1/tokio_io/trait.AsyncRead.html
+//! [tokio-threadpool]: https://docs.rs/tokio-threadpool/0.1/tokio_threadpool
+
+#![deny(missing_docs, missing_debug_implementations, warnings)]
+#![doc(html_root_url = "https://docs.rs/tokio-fs/0.1.3")]
 
 #[macro_use]
 extern crate futures;
 extern crate tokio_io;
 extern crate tokio_threadpool;
 
+mod create_dir;
+mod create_dir_all;
 pub mod file;
+mod hard_link;
+mod metadata;
+pub mod os;
+mod read_dir;
+mod read_link;
+mod remove_dir;
+mod remove_file;
+mod rename;
+mod set_permissions;
 mod stdin;
 mod stdout;
 mod stderr;
+mod symlink_metadata;
 
+pub use create_dir::{create_dir, CreateDirFuture};
+pub use create_dir_all::{create_dir_all, CreateDirAllFuture};
 pub use file::File;
+pub use file::OpenOptions;
+pub use hard_link::{hard_link, HardLinkFuture};
+pub use metadata::{metadata, MetadataFuture};
+pub use read_dir::{read_dir, ReadDirFuture, ReadDir, DirEntry};
+pub use read_link::{read_link, ReadLinkFuture};
+pub use remove_dir::{remove_dir, RemoveDirFuture};
+pub use remove_file::{remove_file, RemoveFileFuture};
+pub use rename::{rename, RenameFuture};
+pub use set_permissions::{set_permissions, SetPermissionsFuture};
 pub use stdin::{stdin, Stdin};
 pub use stdout::{stdout, Stdout};
 pub use stderr::{stderr, Stderr};
+pub use symlink_metadata::{symlink_metadata, SymlinkMetadataFuture};
 
 use futures::Poll;
 use futures::Async::*;

tokio-fs/src/metadata.rs

@@ -0,0 +1,45 @@
+use super::blocking_io;
+
+use futures::{Future, Poll};
+
+use std::fs::{self, Metadata};
+use std::io;
+use std::path::Path;
+
+/// Queries the file system metadata for a path.
+pub fn metadata<P>(path: P) -> MetadataFuture<P>
+where
+    P: AsRef<Path> + Send + 'static,
+{
+    MetadataFuture::new(path)
+}
+
+/// Future returned by `metadata`.
+#[derive(Debug)]
+pub struct MetadataFuture<P>
+where
+    P: AsRef<Path> + Send + 'static,
+{
+    path: P,
+}
+
+impl<P> MetadataFuture<P>
+where
+    P: AsRef<Path> + Send + 'static,
+{
+    pub(crate) fn new(path: P) -> Self {
+        Self { path }
+    }
+}
+
+impl<P> Future for MetadataFuture<P>
+where
+    P: AsRef<Path> + Send + 'static,
+{
+    type Item = Metadata;
+    type Error = io::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        blocking_io(|| fs::metadata(&self.path))
+    }
+}

tokio-fs/src/os/mod.rs

@@ -0,0 +1,6 @@
+//! OS-specific functionality.
+
+#[cfg(unix)]
+pub mod unix;
+#[cfg(windows)]
+pub mod windows;

tokio-fs/src/os/unix.rs

@@ -0,0 +1,55 @@
+//! Unix-specific extensions to primitives in the `tokio_fs` module.
+
+use std::io;
+use std::path::Path;
+use std::os::unix::fs;
+
+use futures::{Future, Poll};
+
+/// Creates a new symbolic link on the filesystem.
+///
+/// The `dst` path will be a symbolic link pointing to the `src` path.
+///
+/// This is an async version of [`std::os::unix::fs::symlink`][std]
+///
+/// [std]: https://doc.rust-lang.org/std/os/unix/fs/fn.symlink.html
+pub fn symlink<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q) -> SymlinkFuture<P, Q> {
+    SymlinkFuture::new(src, dst)
+}
+
+/// Future returned by `symlink`.
+#[derive(Debug)]
+pub struct SymlinkFuture<P, Q>
+where
+    P: AsRef<Path>,
+    Q: AsRef<Path>
+{
+    src: P,
+    dst: Q,
+}
+
+impl<P, Q> SymlinkFuture<P, Q>
+where
+    P: AsRef<Path>,
+    Q: AsRef<Path>
+{
+    fn new(src: P, dst: Q) -> SymlinkFuture<P, Q> {
+        SymlinkFuture {
+            src: src,
+            dst: dst,
+        }
+    }
+}
+
+impl<P, Q> Future for SymlinkFuture<P, Q>
+where
+    P: AsRef<Path>,
+    Q: AsRef<Path>
+{
+    type Item = ();
+    type Error = io::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        ::blocking_io(|| fs::symlink(&self.src, &self.dst) )
+    }
+}

tokio-fs/src/os/windows/mod.rs

@@ -0,0 +1,7 @@
+//! Windows-specific extensions for the primitives in the `tokio_fs` module.
+
+mod symlink_dir;
+mod symlink_file;
+
+pub use self::symlink_dir::{symlink_dir, SymlinkDirFuture};
+pub use self::symlink_file::{symlink_file, SymlinkFileFuture};

tokio-fs/src/os/windows/symlink_dir.rs

@@ -0,0 +1,54 @@
+use std::io;
+use std::path::Path;
+use std::os::windows::fs;
+
+use futures::{Future, Poll};
+
+/// Creates a new directory symlink on the filesystem.
+///
+/// The `dst` path will be a directory symbolic link pointing to the `src`
+/// path.
+///
+/// This is an async version of [`std::os::windows::fs::symlink_dir`][std]
+///
+/// [std]: https://doc.rust-lang.org/std/os/windows/fs/fn.symlink_dir.html
+pub fn symlink_dir<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q) -> SymlinkDirFuture<P, Q> {
+    SymlinkDirFuture::new(src, dst)
+}
+
+/// Future returned by `symlink_dir`.
+#[derive(Debug)]
+pub struct SymlinkDirFuture<P, Q>
+where
+    P: AsRef<Path>,
+    Q: AsRef<Path>
+{
+    src: P,
+    dst: Q,
+}
+
+impl<P, Q> SymlinkDirFuture<P, Q>
+where
+    P: AsRef<Path>,
+    Q: AsRef<Path>
+{
+    fn new(src: P, dst: Q) -> SymlinkDirFuture<P, Q> {
+        SymlinkDirFuture {
+            src: src,
+            dst: dst,
+        }
+    }
+}
+
+impl<P, Q> Future for SymlinkDirFuture<P, Q>
+where
+    P: AsRef<Path>,
+    Q: AsRef<Path>
+{
+    type Item = ();
+    type Error = io::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        ::blocking_io(|| fs::symlink_dir(&self.src, &self.dst) )
+    }
+}

tokio-fs/src/os/windows/symlink_file.rs

@@ -0,0 +1,54 @@
+use std::io;
+use std::path::Path;
+use std::os::windows::fs;
+
+use futures::{Future, Poll};
+
+/// Creates a new file symbolic link on the filesystem.
+///
+/// The `dst` path will be a file symbolic link pointing to the `src`
+/// path.
+///
+/// This is an async version of [`std::os::windows::fs::symlink_file`][std]
+///
+/// [std]: https://doc.rust-lang.org/std/os/windows/fs/fn.symlink_file.html
+pub fn symlink_file<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q) -> SymlinkFileFuture<P, Q> {
+    SymlinkFileFuture::new(src, dst)
+}
+
+/// Future returned by `symlink_file`.
+#[derive(Debug)]
+pub struct SymlinkFileFuture<P, Q>
+where
+    P: AsRef<Path>,
+    Q: AsRef<Path>
+{
+    src: P,
+    dst: Q,
+}
+
+impl<P, Q> SymlinkFileFuture<P, Q>
+where
+    P: AsRef<Path>,
+    Q: AsRef<Path>
+{
+    fn new(src: P, dst: Q) -> SymlinkFileFuture<P, Q> {
+        SymlinkFileFuture {
+            src: src,
+            dst: dst,
+        }
+    }
+}
+
+impl<P, Q> Future for SymlinkFileFuture<P, Q>
+where
+    P: AsRef<Path>,
+    Q: AsRef<Path>
+{
+    type Item = ();
+    type Error = io::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        ::blocking_io(|| fs::symlink_file(&self.src, &self.dst) )
+    }
+}

tokio-fs/src/read_dir.rs

@@ -0,0 +1,247 @@
+use std::ffi::OsString;
+use std::fs::{self, DirEntry as StdDirEntry, ReadDir as StdReadDir, FileType, Metadata};
+use std::io;
+#[cfg(unix)]
+use std::os::unix::fs::DirEntryExt;
+use std::path::{Path, PathBuf};
+
+use futures::{Future, Poll, Stream};
+
+/// Returns a stream over the entries within a directory.
+///
+/// This is an async version of [`std::fs::read_dir`][std]
+///
+/// [std]: https://doc.rust-lang.org/std/fs/fn.read_dir.html
+pub fn read_dir<P>(path: P) -> ReadDirFuture<P>
+where
+    P: AsRef<Path> + Send + 'static,
+{
+    ReadDirFuture::new(path)
+}
+
+/// Future returned by `read_dir`.
+#[derive(Debug)]
+pub struct ReadDirFuture<P>
+where
+    P: AsRef<Path> + Send + 'static,
+{
+    path: P,
+}
+
+impl<P> ReadDirFuture<P>
+where
+    P: AsRef<Path> + Send + 'static
+{
+    fn new(path: P) -> ReadDirFuture<P> {
+        ReadDirFuture {
+            path: path,
+        }
+    }
+}
+
+impl<P> Future for ReadDirFuture<P>
+where
+    P: AsRef<Path> + Send + 'static,
+{
+    type Item = ReadDir;
+    type Error = io::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, io::Error> {
+        ::blocking_io(|| Ok(ReadDir(fs::read_dir(&self.path)?)))
+    }
+}
+
+/// Stream of the entries in a directory.
+///
+/// This stream is returned from the [`read_dir`] function of this module and
+/// will yield instances of [`DirEntry`]. Through a [`DirEntry`]
+/// information like the entry's path and possibly other metadata can be
+/// learned.
+///
+/// # Errors
+///
+/// This [`Stream`] will return an [`Err`] if there's some sort of intermittent
+/// IO error during iteration.
+///
+/// [`read_dir`]: fn.read_dir.html
+/// [`DirEntry`]: struct.DirEntry.html
+/// [`Stream`]: ../futures/stream/trait.Stream.html
+/// [`Err`]: https://doc.rust-lang.org/std/result/enum.Result.html#variant.Err
+#[derive(Debug)]
+pub struct ReadDir(StdReadDir);
+
+impl Stream for ReadDir {
+    type Item = DirEntry;
+    type Error = io::Error;
+
+    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
+        ::blocking_io(|| {
+            match self.0.next() {
+                Some(Err(err)) => Err(err),
+                Some(Ok(item)) => Ok(Some(DirEntry(item))),
+                None => Ok(None)
+            }
+        })
+    }
+}
+
+/// Entries returned by the [`ReadDir`] stream.
+///
+/// [`ReadDir`]: struct.ReadDir.html
+///
+/// This is a specialized version of [`std::fs::DirEntry`][std] for usage from the
+/// Tokio runtime.
+///
+/// An instance of `DirEntry` represents an entry inside of a directory on the
+/// filesystem. Each entry can be inspected via methods to learn about the full
+/// path or possibly other metadata through per-platform extension traits.
+///
+/// [std]: https://doc.rust-lang.org/std/fs/struct.DirEntry.html
+#[derive(Debug)]
+pub struct DirEntry(StdDirEntry);
+
+impl DirEntry {
+    /// Destructures the `tokio_fs::DirEntry` into a [`std::fs::DirEntry`][std].
+    ///
+    /// [std]: https://doc.rust-lang.org/std/fs/struct.DirEntry.html
+    pub fn into_std(self) -> StdDirEntry {
+        self.0
+    }
+
+    /// Returns the full path to the file that this entry represents.
+    ///
+    /// The full path is created by joining the original path to `read_dir`
+    /// with the filename of this entry.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # extern crate futures;
+    /// # extern crate tokio;
+    /// # extern crate tokio_fs;
+    /// use futures::{Future, Stream};
+    ///
+    /// fn main() {
+    ///     let fut = tokio_fs::read_dir(".").flatten_stream().for_each(|dir| {
+    ///         println!("{:?}", dir.path());
+    ///         Ok(())
+    ///     }).map_err(|err| { eprintln!("Error: {:?}", err); () });
+    ///     tokio::run(fut);
+    /// }
+    /// ```
+    ///
+    /// This prints output like:
+    ///
+    /// ```text
+    /// "./whatever.txt"
+    /// "./foo.html"
+    /// "./hello_world.rs"
+    /// ```
+    ///
+    /// The exact text, of course, depends on what files you have in `.`.
+    pub fn path(&self) -> PathBuf {
+        self.0.path()
+    }
+
+    /// Returns the bare file name of this directory entry without any other
+    /// leading path component.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # extern crate futures;
+    /// # extern crate tokio;
+    /// # extern crate tokio_fs;
+    /// use futures::{Future, Stream};
+    ///
+    /// fn main() {
+    ///     let fut = tokio_fs::read_dir(".").flatten_stream().for_each(|dir| {
+    ///         // Here, `dir` is a `DirEntry`.
+    ///         println!("{:?}", dir.file_name());
+    ///         Ok(())
+    ///     }).map_err(|err| { eprintln!("Error: {:?}", err); () });
+    ///     tokio::run(fut);
+    /// }
+    /// ```
+    pub fn file_name(&self) -> OsString {
+        self.0.file_name()
+    }
+
+    /// Return the metadata for the file that this entry points at.
+    ///
+    /// This function will not traverse symlinks if this entry points at a
+    /// symlink.
+    ///
+    /// # Platform-specific behavior
+    ///
+    /// On Windows this function is cheap to call (no extra system calls
+    /// needed), but on Unix platforms this function is the equivalent of
+    /// calling `symlink_metadata` on the path.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # extern crate futures;
+    /// # extern crate tokio;
+    /// # extern crate tokio_fs;
+    /// use futures::{Future, Stream};
+    /// use futures::future::poll_fn;
+    ///
+    /// fn main() {
+    ///     let fut = tokio_fs::read_dir(".").flatten_stream().for_each(|dir| {
+    ///         // Here, `dir` is a `DirEntry`.
+    ///         let path = dir.path();
+    ///         poll_fn(move || dir.poll_metadata()).map(move |metadata| {
+    ///             println!("{:?}: {:?}", path, metadata.permissions());
+    ///         })
+    ///     }).map_err(|err| { eprintln!("Error: {:?}", err); () });
+    ///     tokio::run(fut);
+    /// }
+    /// ```
+    pub fn poll_metadata(&self) -> Poll<Metadata, io::Error> {
+        ::blocking_io(|| self.0.metadata())
+    }
+
+    /// Return the file type for the file that this entry points at.
+    ///
+    /// This function will not traverse symlinks if this entry points at a
+    /// symlink.
+    ///
+    /// # Platform-specific behavior
+    ///
+    /// On Windows and most Unix platforms this function is free (no extra
+    /// system calls needed), but some Unix platforms may require the equivalent
+    /// call to `symlink_metadata` to learn about the target file type.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # extern crate futures;
+    /// # extern crate tokio;
+    /// # extern crate tokio_fs;
+    /// use futures::{Future, Stream};
+    /// use futures::future::poll_fn;
+    ///
+    /// fn main() {
+    ///     let fut = tokio_fs::read_dir(".").flatten_stream().for_each(|dir| {
+    ///         // Here, `dir` is a `DirEntry`.
+    ///         let path = dir.path();
+    ///         poll_fn(move || dir.poll_file_type()).map(move |file_type| {
+    ///             // Now let's show our entry's file type!
+    ///             println!("{:?}: {:?}", path, file_type);
+    ///         })
+    ///     }).map_err(|err| { eprintln!("Error: {:?}", err); () });
+    ///     tokio::run(fut);
+    /// }
+    /// ```
+    pub fn poll_file_type(&self) -> Poll<FileType, io::Error> {
+        ::blocking_io(|| self.0.file_type())
+    }
+}
+
+#[cfg(unix)]
+impl DirEntryExt for DirEntry {
+    fn ino(&self) -> u64 {
+        self.0.ino()
+    }
+}

tokio-fs/src/read_link.rs

@@ -0,0 +1,46 @@
+use std::fs;
+use std::io;
+use std::path::{Path, PathBuf};
+
+use futures::{Future, Poll};
+
+/// Reads a symbolic link, returning the file that the link points to.
+///
+/// This is an async version of [`std::fs::read_link`][std]
+///
+/// [std]: https://doc.rust-lang.org/std/fs/fn.read_link.html
+pub fn read_link<P: AsRef<Path>>(path: P) -> ReadLinkFuture<P> {
+    ReadLinkFuture::new(path)
+}
+
+/// Future returned by `read_link`.
+#[derive(Debug)]
+pub struct ReadLinkFuture<P>
+where
+    P: AsRef<Path>
+{
+    path: P,
+}
+
+impl<P> ReadLinkFuture<P>
+where
+    P: AsRef<Path>
+{
+    fn new(path: P) -> ReadLinkFuture<P> {
+        ReadLinkFuture {
+            path: path,
+        }
+    }
+}
+
+impl<P> Future for ReadLinkFuture<P>
+where
+    P: AsRef<Path>
+{
+    type Item = PathBuf;
+    type Error = io::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        ::blocking_io(|| fs::read_link(&self.path) )
+    }
+}

tokio-fs/src/remove_dir.rs

@@ -0,0 +1,46 @@
+use std::fs;
+use std::io;
+use std::path::Path;
+
+use futures::{Future, Poll};
+
+/// Removes an existing, empty directory.
+///
+/// This is an async version of [`std::fs::remove_dir`][std]
+///
+/// [std]: https://doc.rust-lang.org/std/fs/fn.remove_dir.html
+pub fn remove_dir<P: AsRef<Path>>(path: P) -> RemoveDirFuture<P> {
+    RemoveDirFuture::new(path)
+}
+
+/// Future returned by `remove_dir`.
+#[derive(Debug)]
+pub struct RemoveDirFuture<P>
+where
+    P: AsRef<Path>
+{
+    path: P,
+}
+
+impl<P> RemoveDirFuture<P>
+where
+    P: AsRef<Path>
+{
+    fn new(path: P) -> RemoveDirFuture<P> {
+        RemoveDirFuture {
+            path: path,
+        }
+    }
+}
+
+impl<P> Future for RemoveDirFuture<P>
+where
+    P: AsRef<Path>
+{
+    type Item = ();
+    type Error = io::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        ::blocking_io(|| fs::remove_dir(&self.path) )
+    }
+}

tokio-fs/src/remove_file.rs

@@ -0,0 +1,50 @@
+use std::fs;
+use std::io;
+use std::path::Path;
+
+use futures::{Future, Poll};
+
+/// Removes a file from the filesystem.
+///
+/// Note that there is no
+/// guarantee that the file is immediately deleted (e.g. depending on
+/// platform, other open file descriptors may prevent immediate removal).
+///
+/// This is an async version of [`std::fs::remove_file`][std]
+///
+/// [std]: https://doc.rust-lang.org/std/fs/fn.remove_file.html
+pub fn remove_file<P: AsRef<Path>>(path: P) -> RemoveFileFuture<P> {
+    RemoveFileFuture::new(path)
+}
+
+/// Future returned by `remove_file`.
+#[derive(Debug)]
+pub struct RemoveFileFuture<P>
+where
+    P: AsRef<Path>
+{
+    path: P,
+}
+
+impl<P> RemoveFileFuture<P>
+where
+    P: AsRef<Path>
+{
+    fn new(path: P) -> RemoveFileFuture<P> {
+        RemoveFileFuture {
+            path: path,
+        }
+    }
+}
+
+impl<P> Future for RemoveFileFuture<P>
+where
+    P: AsRef<Path>
+{
+    type Item = ();
+    type Error = io::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        ::blocking_io(|| fs::remove_file(&self.path) )
+    }
+}

tokio-fs/src/rename.rs

@@ -0,0 +1,54 @@
+use std::fs;
+use std::io;
+use std::path::Path;
+
+use futures::{Future, Poll};
+
+/// Rename a file or directory to a new name, replacing the original file if
+/// `to` already exists.
+///
+/// This will not work if the new name is on a different mount point.
+///
+/// This is an async version of [`std::fs::rename`][std]
+///
+/// [std]: https://doc.rust-lang.org/std/fs/fn.rename.html
+pub fn rename<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> RenameFuture<P, Q> {
+    RenameFuture::new(from, to)
+}
+
+/// Future returned by `rename`.
+#[derive(Debug)]
+pub struct RenameFuture<P, Q>
+where
+    P: AsRef<Path>,
+    Q: AsRef<Path>
+{
+    from: P,
+    to: Q,
+}
+
+impl<P, Q> RenameFuture<P, Q>
+where
+    P: AsRef<Path>,
+    Q: AsRef<Path>
+{
+    fn new(from: P, to: Q) -> RenameFuture<P, Q> {
+        RenameFuture {
+            from: from,
+            to: to,
+        }
+    }
+}
+
+impl<P, Q> Future for RenameFuture<P, Q>
+where
+    P: AsRef<Path>,
+    Q: AsRef<Path>
+{
+    type Item = ();
+    type Error = io::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        ::blocking_io(|| fs::rename(&self.from, &self.to) )
+    }
+}

tokio-fs/src/set_permissions.rs

@@ -0,0 +1,48 @@
+use std::fs;
+use std::io;
+use std::path::Path;
+
+use futures::{Future, Poll};
+
+/// Changes the permissions found on a file or a directory.
+///
+/// This is an async version of [`std::fs::set_permissions`][std]
+///
+/// [std]: https://doc.rust-lang.org/std/fs/fn.set_permissions.html
+pub fn set_permissions<P: AsRef<Path>>(path: P, perm: fs::Permissions) -> SetPermissionsFuture<P> {
+    SetPermissionsFuture::new(path, perm)
+}
+
+/// Future returned by `set_permissions`.
+#[derive(Debug)]
+pub struct SetPermissionsFuture<P>
+where
+    P: AsRef<Path>
+{
+    path: P,
+    perm: fs::Permissions,
+}
+
+impl<P> SetPermissionsFuture<P>
+where
+    P: AsRef<Path>
+{
+    fn new(path: P, perm: fs::Permissions) -> SetPermissionsFuture<P> {
+        SetPermissionsFuture {
+            path: path,
+            perm: perm,
+        }
+    }
+}
+
+impl<P> Future for SetPermissionsFuture<P>
+where
+    P: AsRef<Path>
+{
+    type Item = ();
+    type Error = io::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        ::blocking_io(|| fs::set_permissions(&self.path, self.perm.clone()) )
+    }
+}

tokio-fs/src/symlink_metadata.rs

@@ -0,0 +1,49 @@
+use super::blocking_io;
+
+use futures::{Future, Poll};
+
+use std::fs::{self, Metadata};
+use std::io;
+use std::path::Path;
+
+/// Queries the file system metadata for a path.
+///
+/// This is an async version of [`std::fs::symlink_metadata`][std]
+///
+/// [std]: https://doc.rust-lang.org/std/fs/fn.symlink_metadata.html
+pub fn symlink_metadata<P>(path: P) -> SymlinkMetadataFuture<P>
+where
+    P: AsRef<Path> + Send + 'static,
+{
+    SymlinkMetadataFuture::new(path)
+}
+
+/// Future returned by `symlink_metadata`.
+#[derive(Debug)]
+pub struct SymlinkMetadataFuture<P>
+where
+    P: AsRef<Path> + Send + 'static,
+{
+    path: P,
+}
+
+impl<P> SymlinkMetadataFuture<P>
+where
+    P: AsRef<Path> + Send + 'static,
+{
+    pub(crate) fn new(path: P) -> Self {
+        Self { path }
+    }
+}
+
+impl<P> Future for SymlinkMetadataFuture<P>
+where
+    P: AsRef<Path> + Send + 'static,
+{
+    type Item = Metadata;
+    type Error = io::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        blocking_io(|| fs::symlink_metadata(&self.path))
+    }
+}

tokio-fs/tests/file.rs

@@ -16,7 +16,7 @@ use rand::{thread_rng, Rng};
 use tempdir::TempDir;
 
 use std::fs::File as StdFile;
-use std::io::Read;
+use std::io::{Read, SeekFrom};
 
 #[test]
 fn read_write() {
@@ -41,7 +41,9 @@ fn read_write() {
         let contents = contents.clone();
 
         File::create(file_path)
-            .and_then(move |file| io::write_all(file, contents))
+            .and_then(|file| file.metadata())
+            .inspect(|&(_, ref metadata)| assert!(metadata.is_file()))
+            .and_then(move |(file, _)| io::write_all(file, contents))
             .and_then(|(mut file, _)| {
                 poll_fn(move || file.poll_sync_all())
             })
@@ -61,13 +63,84 @@ fn read_write() {
 
     assert_eq!(dst, contents);
 
+    let (tx, rx) = oneshot::channel();
+
     pool.spawn({
         File::open(file_path)
             .and_then(|file| io::read_to_end(file, vec![]))
             .then(move |res| {
                 let (_, buf) = res.unwrap();
                 assert_eq!(buf, contents);
+                tx.send(()).unwrap();
                 Ok(())
             })
     });
+
+    rx.wait().unwrap();
+}
+
+#[test]
+fn metadata() {
+    let dir = TempDir::new("tokio-fs-tests").unwrap();
+    let file_path = dir.path().join("metadata.txt");
+
+    let pool = Builder::new().pool_size(1).build();
+
+    let (tx, rx) = oneshot::channel();
+
+    pool.spawn({
+        let file_path = file_path.clone();
+        let file_path2 = file_path.clone();
+        let file_path3 = file_path.clone();
+
+        tokio_fs::metadata(file_path)
+            .then(|r| {
+                let _ = r.err().unwrap();
+                Ok(())
+            })
+            .and_then(|_| File::create(file_path2))
+            .and_then(|_| tokio_fs::metadata(file_path3))
+            .then(|r| {
+                assert!(r.unwrap().is_file());
+                tx.send(())
+            })
+    });
+
+    rx.wait().unwrap();
+}
+
+#[test]
+fn seek() {
+    let dir = TempDir::new("tokio-fs-tests").unwrap();
+    let file_path = dir.path().join("seek.txt");
+
+    let pool = Builder::new().pool_size(1).build();
+
+    let (tx, rx) = oneshot::channel();
+
+    pool.spawn(
+        OpenOptions::new()
+            .create(true)
+            .read(true)
+            .write(true)
+            .open(file_path)
+            .and_then(|file| io::write_all(file, "Hello, world!"))
+            .and_then(|(file, _)| file.seek(SeekFrom::End(-6)))
+            .and_then(|(file, _)| io::read_exact(file, vec![0; 5]))
+            .and_then(|(file, buf)| {
+                assert_eq!(buf, b"world");
+                file.seek(SeekFrom::Start(0))
+            })
+            .and_then(|(file, _)| io::read_exact(file, vec![0; 5]))
+            .and_then(|(_, buf)| {
+                assert_eq!(buf, b"Hello");
+                Ok(())
+            })
+            .then(|r| {
+                let _ = r.unwrap();
+                tx.send(())
+            }),
+    );
+
+    rx.wait().unwrap();
 }

tokio-io/CHANGELOG.md

@@ -1,4 +1,4 @@
-# Unreleased
+# 0.1.7 (June 13, 2018)
 
 * Move `codec::{Encode, Decode, Framed*}` into `tokio-codec` (#353)
 

tokio-io/Cargo.toml

@@ -5,7 +5,7 @@ name = "tokio-io"
 # - Update html_root_url.
 # - Update CHANGELOG.md.
 # - Create "v0.1.x" git tag.
-version = "0.1.6"
+version = "0.1.7"
 authors = ["Carl Lerche <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/tokio-rs/tokio"

tokio-io/src/codec/mod.rs

@@ -104,7 +104,7 @@ pub mod length_delimited {
     //! [`FramedRead`] adapts an [`AsyncRead`] into a `Stream` of [`BytesMut`],
     //! such that each yielded [`BytesMut`] value contains the contents of an
     //! entire frame. There are many configuration parameters enabling
-    //! [`FrameRead`] to handle a wide range of protocols. Here are some
+    //! [`FramedRead`] to handle a wide range of protocols. Here are some
     //! examples that will cover the various options at a high level.
     //!
     //! ## Example 1
@@ -370,7 +370,7 @@ pub mod length_delimited {
     //! [`AsyncRead`]: ../../trait.AsyncRead.html
     //! [`AsyncWrite`]: ../../trait.AsyncWrite.html
     //! [`Encoder`]: ../trait.Encoder.html
-    //! [`BytesMut`]: https://docs.rs/bytes/~0.4/bytes/struct.BytesMut.html
+    //! [`BytesMut`]: https://docs.rs/bytes/0.4/bytes/struct.BytesMut.html
 
     pub use ::length_delimited::*;
 }

tokio-io/src/io/read_to_end.rs

@@ -29,9 +29,8 @@ enum State<A> {
 /// object `A` into the buffer provided.
 ///
 /// In the case of an error the buffer and the object will be discarded, with
-/// the error yielded. In the case of success the object will be destroyed and
-/// the buffer will be returned, with all data read from the stream appended to
-/// the buffer.
+/// the error yielded. In the case of success both the object and the buffer
+/// will be returned, with all data read from the stream appended to the buffer.
 pub fn read_to_end<A>(a: A, buf: Vec<u8>) -> ReadToEnd<A>
     where A: AsyncRead,
 {

tokio-io/src/lib.rs

@@ -7,7 +7,7 @@
 //! [low level details]: https://tokio.rs/docs/going-deeper-tokio/core-low-level/
 
 #![deny(missing_docs, missing_debug_implementations, warnings)]
-#![doc(html_root_url = "https://docs.rs/tokio-io/0.1.6")]
+#![doc(html_root_url = "https://docs.rs/tokio-io/0.1.7")]
 
 #[macro_use]
 extern crate log;

tokio-reactor/CHANGELOG.md

@@ -1,3 +1,12 @@
+# 0.1.3 (August 6, 2018)
+
+* Misc small fixes (#508)
+
+# 0.1.2 (June 13, 2018)
+
+* Fix deadlock that can happen when shutting down (#409)
+* Handle::default() lazily binds to reactor (#350)
+
 # 0.1.1 (March 22, 2018)
 
 * Fix threading bugs (#227)

tokio-reactor/Cargo.toml

@@ -5,7 +5,7 @@ name = "tokio-reactor"
 # - Update html_root_url.
 # - Update CHANGELOG.md.
 # - Create "v0.1.x" git tag.
-version = "0.1.1"
+version = "0.1.3"
 authors = ["Carl Lerche <[email protected]>"]
 license = "MIT"
 readme = "README.md"

tokio-reactor/src/atomic_task.rs

@@ -84,7 +84,7 @@ pub(crate) struct AtomicTask {
 // `NOTIFYING` is made. On success, the caller obtains a lock on the task cell.
 //
 // If the lock is obtained, then the thread takes ownership of the current value
-// in teh task cell, and calls `notify` on it. The state is then transitioned
+// in the task cell, and calls `notify` on it. The state is then transitioned
 // back to `WAITING`. This transition must succeed as, at this point, the state
 // cannot be transitioned by another thread.
 //
@@ -237,10 +237,9 @@ impl AtomicTask {
         }
     }
 
-    /// Notifies the task that last called `register`.
-    ///
-    /// If `register` has not been called yet, then this does nothing.
-    pub fn notify(&self) {
+    /// Attempts to take the `Task` value out of the `AtomicTask` with the
+    /// intention that the caller will notify the task.
+    pub fn take_to_notify(&self) -> Option<Task> {
         // AcqRel ordering is used in order to acquire the value of the `task`
         // cell as well as to establish a `release` ordering with whatever
         // memory the `AtomicTask` is associated with.
@@ -252,9 +251,7 @@ impl AtomicTask {
                 // Release the lock
                 self.state.fetch_and(!NOTIFYING, Release);
 
-                if let Some(task) = task {
-                    task.notify();
-                }
+                task
             }
             state => {
                 // There is a concurrent thread currently updating the
@@ -268,9 +265,20 @@ impl AtomicTask {
                     state == REGISTERING ||
                     state == REGISTERING | NOTIFYING ||
                     state == NOTIFYING);
+
+                None
             }
         }
     }
+
+    /// Notifies the task that last called `register`.
+    ///
+    /// If `register` has not been called yet, then this does nothing.
+    pub fn notify(&self) {
+        if let Some(task) = self.take_to_notify() {
+            task.notify();
+        }
+    }
 }
 
 impl Default for AtomicTask {

tokio-reactor/src/lib.rs

@@ -27,7 +27,7 @@
 //! [`PollEvented`]: struct.PollEvented.html
 //! [reactor module]: https://docs.rs/tokio/0.1/tokio/reactor/index.html
 
-#![doc(html_root_url = "https://docs.rs/tokio-reactor/0.1.1")]
+#![doc(html_root_url = "https://docs.rs/tokio-reactor/0.1.3")]
 #![deny(missing_docs, warnings, missing_debug_implementations)]
 
 #[macro_use]
@@ -49,7 +49,7 @@ mod registration;
 
 // ===== Public re-exports =====
 
-pub use self::background::Background;
+pub use self::background::{Background, Shutdown};
 pub use self::registration::Registration;
 pub use self::poll_evented::PollEvented;
 
@@ -61,7 +61,7 @@ use tokio_executor::Enter;
 use tokio_executor::park::{Park, Unpark};
 
 use std::{fmt, usize};
-use std::io::{self, ErrorKind};
+use std::io;
 use std::mem;
 use std::cell::RefCell;
 use std::sync::atomic::Ordering::{Relaxed, SeqCst};
@@ -353,7 +353,6 @@ impl Reactor {
         // happened.
         match self.inner.io.poll(&mut self.events, max_wait) {
             Ok(_) => {}
-            Err(ref e) if e.kind() == ErrorKind::Interrupted => return Ok(()),
             Err(e) => return Err(e),
         }
 
@@ -392,9 +391,19 @@ impl Reactor {
         let aba_guard = token.0 & !MAX_SOURCES;
         let token = token.0 & MAX_SOURCES;
 
-        let io_dispatch = self.inner.io_dispatch.read().unwrap();
+        let mut rd = None;
+        let mut wr = None;
+
+        // Create a scope to ensure that notifying the tasks stays out of the
+        // lock's critical section.
+        {
+            let io_dispatch = self.inner.io_dispatch.read().unwrap();
+
+            let io = match io_dispatch.get(token) {
+                Some(io) => io,
+                None => return,
+            };
 
-        if let Some(io) = io_dispatch.get(token) {
             if aba_guard != io.aba_guard {
                 return;
             }
@@ -402,13 +411,21 @@ impl Reactor {
             io.readiness.fetch_or(ready.as_usize(), Relaxed);
 
             if ready.is_writable() || platform::is_hup(&ready) {
-                io.writer.notify();
+                wr = io.writer.take_to_notify();
             }
 
             if !(ready & (!mio::Ready::writable())).is_empty() {
-                io.reader.notify();
+                rd = io.reader.take_to_notify();
             }
         }
+
+        if let Some(task) = rd {
+            task.notify();
+        }
+
+        if let Some(task) = wr {
+            task.notify();
+        }
     }
 }
 

tokio-reactor/src/poll_evented.rs

@@ -52,7 +52,7 @@ use std::sync::atomic::Ordering::Relaxed;
 ///
 /// This allows the caller to implement additional functions. For example,
 /// [`TcpListener`] implements poll_accept by using [`poll_read_ready`] and
-/// [`clear_write_ready`].
+/// [`clear_read_ready`].
 ///
 /// ```rust,ignore
 /// pub fn poll_accept(&mut self) -> Poll<(net::TcpStream, SocketAddr), io::Error> {
@@ -84,6 +84,10 @@ use std::sync::atomic::Ordering::Relaxed;
 /// [`mio::Evented`]: https://docs.rs/mio/0.6/mio/trait.Evented.html
 /// [`Registration`]: struct.Registration.html
 /// [`TcpListener`]: ../net/struct.TcpListener.html
+/// [`clear_read_ready`]: #method.clear_read_ready
+/// [`clear_read_ready`]: #method.clear_read_ready
+/// [`poll_read_ready`]: #method.poll_read_ready
+/// [`poll_write_ready`]: #method.poll_write_ready
 pub struct PollEvented<E: Evented> {
     io: Option<E>,
     inner: Inner,
@@ -338,7 +342,7 @@ where E: Evented
     /// cannot be cleared as it is a final state.
     ///
     /// After calling this function, `poll_write_ready(Ready::writable())` will
-    /// return `NotReady` until a new read readiness event has been received.
+    /// return `NotReady` until a new write readiness event has been received.
     ///
     /// # Panics
     ///

tokio-tcp/CHANGELOG.md

@@ -1,3 +1,7 @@
-# 0.1.0 (unreleased)
+# 0.1.1 (August 6, 2018)
+
+* Add `TcpStream::try_clone` (#448)
+
+# 0.1.0 (March 23, 2018)
 
 * Initial release

tokio-tcp/Cargo.toml

@@ -5,7 +5,7 @@ name = "tokio-tcp"
 # - Update html_root_url.
 # - Update CHANGELOG.md.
 # - Create "v0.1.x" git tag.
-version = "0.1.0"
+version = "0.1.1"
 authors = ["Carl Lerche <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/tokio-rs/tokio"

tokio-tcp/src/lib.rs

@@ -19,7 +19,7 @@
 //! [incoming_method]: struct.TcpListener.html#method.incoming
 //! [`Incoming`]: struct.Incoming.html
 
-#![doc(html_root_url = "https://docs.rs/tokio-tcp/0.1.0")]
+#![doc(html_root_url = "https://docs.rs/tokio-tcp/0.1.1")]
 #![deny(missing_docs, warnings, missing_debug_implementations)]
 
 extern crate bytes;

tokio-tcp/src/stream.rs

@@ -374,6 +374,17 @@ impl TcpStream {
     pub fn set_linger(&self, dur: Option<Duration>) -> io::Result<()> {
         self.io.get_ref().set_linger(dur)
     }
+
+    /// Creates a new independently owned handle to the underlying socket.
+    ///
+    /// The returned `TcpStream` is a reference to the same stream that this
+    /// object references. Both handles will read and write the same stream of
+    /// data, and options set on one stream will be propagated to the other
+    /// stream.
+    pub fn try_clone(&self) -> io::Result<TcpStream> {
+        let io = self.io.get_ref().try_clone()?;
+        Ok(TcpStream::new(io))
+    }
 }
 
 // ===== impl Read / Write =====

tokio-threadpool/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 0.1.5 (July 3, 2018)
+
+* Fix race condition bug when threads are woken up (#459).
+* Improve `BlockingError` message (#451).
+
 # 0.1.4 (June 6, 2018)
 
 * Fix bug that can occur with multiple pools in a process (#375).

tokio-threadpool/Cargo.toml

@@ -4,7 +4,7 @@ name = "tokio-threadpool"
 # - Update html_root_url.
 # - Update CHANGELOG.md.
 # - Create "v0.1.x" git tag.
-version = "0.1.4"
+version = "0.1.5"
 documentation = "https://docs.rs/tokio-threadpool"
 repository = "https://github.com/tokio-rs/tokio"
 homepage = "https://github.com/tokio-rs/tokio"
@@ -19,9 +19,10 @@ categories = ["concurrency", "asynchronous"]
 [dependencies]
 tokio-executor = { version = "0.1.2", path = "../tokio-executor" }
 futures = "0.1.19"
-crossbeam-deque = "0.3"
+crossbeam-deque = "0.5.0"
+crossbeam-utils = "0.4.1"
 num_cpus = "1.2"
-rand = "0.4"
+rand = "0.5"
 log = "0.4"
 
 [dev-dependencies]

tokio-threadpool/src/blocking.rs

@@ -6,7 +6,6 @@ use std::error::Error;
 use std::fmt;
 
 /// Error raised by `blocking`.
-#[derive(Debug)]
 pub struct BlockingError {
     _p: (),
 }
@@ -156,6 +155,14 @@ impl fmt::Display for BlockingError {
     }
 }
 
+impl fmt::Debug for BlockingError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("BlockingError")
+            .field("reason", &self.description())
+            .finish()
+    }
+}
+
 impl Error for BlockingError {
     fn description(&self) -> &str {
         "`blocking` annotation used from outside the context of a thread pool"

tokio-threadpool/src/builder.rs

@@ -41,7 +41,6 @@ use futures2;
 /// use std::time::Duration;
 ///
 /// # pub fn main() {
-/// // Create a thread pool with default configuration values
 /// let thread_pool = Builder::new()
 ///     .pool_size(4)
 ///     .keep_alive(Some(Duration::from_secs(30)))
@@ -86,7 +85,6 @@ impl Builder {
     /// use std::time::Duration;
     ///
     /// # pub fn main() {
-    /// // Create a thread pool with default configuration values
     /// let thread_pool = Builder::new()
     ///     .pool_size(4)
     ///     .keep_alive(Some(Duration::from_secs(30)))
@@ -131,7 +129,6 @@ impl Builder {
     /// # use tokio_threadpool::Builder;
     ///
     /// # pub fn main() {
-    /// // Create a thread pool with default configuration values
     /// let thread_pool = Builder::new()
     ///     .pool_size(4)
     ///     .build();
@@ -164,7 +161,6 @@ impl Builder {
     /// # use tokio_threadpool::Builder;
     ///
     /// # pub fn main() {
-    /// // Create a thread pool with default configuration values
     /// let thread_pool = Builder::new()
     ///     .max_blocking(200)
     ///     .build();
@@ -196,7 +192,6 @@ impl Builder {
     /// use std::time::Duration;
     ///
     /// # pub fn main() {
-    /// // Create a thread pool with default configuration values
     /// let thread_pool = Builder::new()
     ///     .keep_alive(Some(Duration::from_secs(30)))
     ///     .build();
@@ -224,7 +219,6 @@ impl Builder {
     /// # use tokio_threadpool::Builder;
     ///
     /// # pub fn main() {
-    /// // Create a thread pool with default configuration values
     /// let thread_pool = Builder::new()
     ///     .name_prefix("my-pool-")
     ///     .build();
@@ -251,7 +245,6 @@ impl Builder {
     /// # use tokio_threadpool::Builder;
     ///
     /// # pub fn main() {
-    /// // Create a thread pool with default configuration values
     /// let thread_pool = Builder::new()
     ///     .stack_size(32 * 1024)
     ///     .build();
@@ -265,7 +258,7 @@ impl Builder {
     /// Execute function `f` on each worker thread.
     ///
     /// This function is provided a handle to the worker and is expected to call
-    /// `Worker::run`, otherwise the worker thread will shutdown without doing
+    /// [`Worker::run`], otherwise the worker thread will shutdown without doing
     /// any work.
     ///
     /// # Examples
@@ -276,7 +269,6 @@ impl Builder {
     /// # use tokio_threadpool::Builder;
     ///
     /// # pub fn main() {
-    /// // Create a thread pool with default configuration values
     /// let thread_pool = Builder::new()
     ///     .around_worker(|worker, _| {
     ///         println!("worker is starting up");
@@ -286,6 +278,8 @@ impl Builder {
     ///     .build();
     /// # }
     /// ```
+    ///
+    /// [`Worker::run`]: struct.Worker.html#method.run
     pub fn around_worker<F>(&mut self, f: F) -> &mut Self
         where F: Fn(&Worker, &mut Enter) + Send + Sync + 'static
     {
@@ -306,7 +300,6 @@ impl Builder {
     /// # use tokio_threadpool::Builder;
     ///
     /// # pub fn main() {
-    /// // Create a thread pool with default configuration values
     /// let thread_pool = Builder::new()
     ///     .after_start(|| {
     ///         println!("thread started");
@@ -333,7 +326,6 @@ impl Builder {
     /// # use tokio_threadpool::Builder;
     ///
     /// # pub fn main() {
-    /// // Create a thread pool with default configuration values
     /// let thread_pool = Builder::new()
     ///     .before_stop(|| {
     ///         println!("thread stopping");
@@ -362,7 +354,6 @@ impl Builder {
     /// # fn decorate<F>(f: F) -> F { f }
     ///
     /// # pub fn main() {
-    /// // Create a thread pool with default configuration values
     /// let thread_pool = Builder::new()
     ///     .custom_park(|_| {
     ///         use tokio_threadpool::park::DefaultPark;
@@ -402,7 +393,6 @@ impl Builder {
     /// # use tokio_threadpool::Builder;
     ///
     /// # pub fn main() {
-    /// // Create a thread pool with default configuration values
     /// let thread_pool = Builder::new()
     ///     .build();
     /// # }

tokio-threadpool/src/lib.rs

@@ -1,11 +1,86 @@
-//! A work-stealing based thread pool for executing futures.
-
-#![doc(html_root_url = "https://docs.rs/tokio-threadpool/0.1.4")]
+#![doc(html_root_url = "https://docs.rs/tokio-threadpool/0.1.5")]
 #![deny(warnings, missing_docs, missing_debug_implementations)]
 
+//! A work-stealing based thread pool for executing futures.
+//!
+//! The Tokio thread pool supports scheduling futures and processing them on
+//! multiple CPU cores. It is optimized for the primary Tokio use case of many
+//! independent tasks with limited computation and with most tasks waiting on
+//! I/O. Usually, users will not create a `ThreadPool` instance directly, but
+//! will use one via a [`runtime`].
+//!
+//! The `TheadPool` structure manages two sets of threads:
+//!
+//! * Worker threads.
+//! * Backup threads.
+//!
+//! Worker threads are used to schedule futures using a work-stealing strategy.
+//! Backup threads, on the other hand, are intended only to support the
+//! `blocking` API. Threads will transition between the two sets.
+//!
+//! The advantage of the work-stealing strategy is minimal cross-thread
+//! coordination. The thread pool attempts to make as much progress as possible
+//! without communicating across threads.
+//!
+//! ## Worker overview
+//!
+//! Each worker has two queues: a deque and a mpsc channel. The deque is the
+//! primary queue for tasks that are scheduled to run on the worker thread. Tasks
+//! can only be pushed onto the deque by the worker, but other workers may
+//! "steal" from that deque. The mpsc channel is used to submit futures while
+//! external to the pool.
+//!
+//! As long as the thread pool has not been shutdown, a worker will run in a
+//! loop. Each loop, it consumes all tasks on its mpsc channel and pushes it onto
+//! the deque. It then pops tasks off of the deque and executes them.
+//!
+//! If a worker has no work, i.e., both queues are empty. It attempts to steal.
+//! To do this, it randomly scans other workers' deques and tries to pop a task.
+//! If it finds no work to steal, the thread goes to sleep.
+//!
+//! When the worker detects that the pool has been shut down, it exits the loop,
+//! cleans up its state, and shuts the thread down.
+//!
+//! ## Thread pool initialization
+//!
+//! Note, users normally will use the threadpool created by a [`runtime`].
+//!
+//! By default, no threads are spawned on creation. Instead, when new futures are
+//! spawned, the pool first checks if there are enough active worker threads. If
+//! not, a new worker thread is spawned.
+//!
+//! ## Spawning futures
+//!
+//! The spawning behavior depends on whether a future was spawned from within a
+//! worker or thread or if it was spawned from an external handle.
+//!
+//! When spawning a future while external to the thread pool, the current
+//! strategy is to randomly pick a worker to submit the task to. The task is then
+//! pushed onto that worker's mpsc channel.
+//!
+//! When spawning a future while on a worker thread, the task is pushed onto the
+//! back of the current worker's deque.
+//!
+//! ## Blocking annotation strategy
+//!
+//! The [`blocking`] function is used to annotate a section of code that
+//! performs a blocking operation, either by issuing a blocking syscall or
+//! performing any long running CPU-bound computation.
+//!
+//! The strategy for handling blocking closures is to hand off the worker to a
+//! new thread. This implies handing off the `deque` and `mpsc`. Once this is
+//! done, the new thread continues to process the work queue and the original
+//! thread is able to block. Once it finishes processing the blocking future, the
+//! thread has no additional work and is inserted into the backup pool. This
+//! makes it available to other workers that encounter a [`blocking`] call.
+//!
+//! [`blocking`]: fn.blocking.html
+//! [`runtime`]: https://docs.rs/tokio/0.1/tokio/runtime/
+
 extern crate tokio_executor;
 
 extern crate crossbeam_deque as deque;
+extern crate crossbeam_utils;
 #[macro_use]
 extern crate futures;
 extern crate num_cpus;
@@ -17,6 +92,56 @@ extern crate log;
 #[cfg(feature = "unstable-futures")]
 extern crate futures2;
 
+// ## Crate layout
+//
+// The primary type, `Pool`, holds the majority of a thread pool's state,
+// including the state for each worker. Each worker's state is maintained in an
+// instance of `worker::Entry`.
+//
+// `Worker` contains the logic that runs on each worker thread. It holds an
+// `Arc` to `Pool` and is able to access its state from `Pool`.
+//
+// `Task` is a harness around an individual future. It manages polling and
+// scheduling that future.
+//
+// ## Sleeping workers
+//
+// Sleeping workers are tracked using a [treiber stack]. This results in the
+// thread that most recently went to sleep getting woken up first. When the pool
+// is not under load, this helps threads shutdown faster.
+//
+// Sleeping is done by using `tokio_executor::Park` implementations. This allows
+// the user of the thread pool to customize the work that is performed to sleep.
+// This is how injecting timers and other functionality into the thread pool is
+// done.
+//
+// ## Notifying workers
+//
+// When there is work to be done, workers must be notified. However, notifying a
+// worker requires cross thread coordination. Ideally, a worker would only be
+// notified when it is sleeping, but there is no way to know if a worker is
+// sleeping without cross thread communication.
+//
+// The two cases when a worker might need to be notified are:
+//
+// 1. A task is externally submitted to a worker via the mpsc channel.
+// 2. A worker has a back log of work and needs other workers to steal from it.
+//
+// In the first case, the worker will always be notified. However, it could be
+// possible to avoid the notification if the mpsc channel has two or greater
+// number of tasks *after* the task is submitted. In this case, we are able to
+// assume that the worker has previously been notified.
+//
+// The second case is trickier. Currently, whenever a worker spawns a new future
+// (pushing it onto its deque) and when it pops a future from its mpsc, it tries
+// to notify a sleeping worker to wake up and start stealing. This is a lot of
+// notification and it **might** be possible to reduce it.
+//
+// Also, whenever a worker is woken up via a signal and it does find work, it,
+// in turn, will try to wake up a new worker.
+//
+// [treiber stack]: https://en.wikipedia.org/wiki/Treiber_Stack
+
 pub mod park;
 
 mod blocking;
@@ -39,4 +164,4 @@ pub use builder::Builder;
 pub use sender::Sender;
 pub use shutdown::Shutdown;
 pub use thread_pool::ThreadPool;
-pub use worker::Worker;
+pub use worker::{Worker, WorkerId};

tokio-threadpool/src/park/default_park.rs

@@ -133,8 +133,8 @@ impl Inner {
             None => self.condvar.wait(m).unwrap(),
         };
 
-        // Transition back to idle. If the state has transitions dto `NOTIFY`,
-        // this will consume that notification
+        // Transition back to idle. If the state has transitioned to `NOTIFY`,
+        // this will consume that notification.
         self.state.store(IDLE, SeqCst);
 
         // Explicitly drop the mutex guard. There is no real point in doing it
@@ -155,10 +155,12 @@ impl Inner {
         // The other half is sleeping, this requires a lock
         let _m = self.mutex.lock().unwrap();
 
-        // Transition from SLEEP -> NOTIFY
-        match self.state.compare_and_swap(SLEEP, NOTIFY, SeqCst) {
+        // Transition to NOTIFY
+        match self.state.swap(NOTIFY, SeqCst) {
             SLEEP => {}
-            _ => return,
+            NOTIFY => return,
+            IDLE => return,
+            _ => unreachable!(),
         }
 
         // Wakeup the sleeper

tokio-threadpool/src/pool/backup.rs

@@ -5,6 +5,7 @@ use std::cell::UnsafeCell;
 use std::fmt;
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering::{self, Acquire, AcqRel, Relaxed};
+use std::time::{Duration, Instant};
 
 /// State associated with a thread in the thread pool.
 ///
@@ -155,7 +156,8 @@ impl Backup {
     }
 
     /// Wait for a worker handoff
-    pub fn wait_for_handoff(&self, sleep: bool) -> Handoff {
+    pub fn wait_for_handoff(&self, timeout: Option<Duration>) -> Handoff {
+        let sleep_until = timeout.map(|dur| Instant::now() + dur);
         let mut state: State = self.state.load(Acquire).into();
 
         // Run in a loop since there can be spurious wakeups
@@ -169,36 +171,40 @@ impl Backup {
                     (*self.handoff.get()).take()
                         .expect("no worker handoff")
                 };
-
                 return Handoff::Worker(worker_id);
             }
 
-            if sleep {
-                // TODO: Park with a timeout
-                self.park.park_sync(None);
-
-                // Reload the state
-                state = self.state.load(Acquire).into();
-                debug_assert!(state.is_running());
-            } else {
-                debug_assert!(state.is_running());
-
-                // Transition out of running
-                let mut next = state;
-                next.unset_running();
-
-                let actual = self.state.compare_and_swap(
-                    state.into(),
-                    next.into(),
-                    AcqRel).into();
-
-                if actual == state {
-                    debug_assert!(!next.is_running());
-
-                    return Handoff::Idle;
+            match sleep_until {
+                None => {
+                    self.park.park_sync(None);
+                    state = self.state.load(Acquire).into();
                 }
+                Some(when) => {
+                    let now = Instant::now();
 
-                state = actual;
+                    if now < when {
+                        self.park.park_sync(Some(when - now));
+                        state = self.state.load(Acquire).into();
+                    } else {
+                        debug_assert!(state.is_running());
+
+                        // Transition out of running
+                        let mut next = state;
+                        next.unset_running();
+
+                        let actual = self.state.compare_and_swap(
+                            state.into(),
+                            next.into(),
+                            AcqRel).into();
+
+                        if actual == state {
+                            debug_assert!(!next.is_running());
+                            return Handoff::Idle;
+                        }
+
+                        state = actual;
+                    }
+                }
             }
         }
     }

tokio-threadpool/src/pool/mod.rs

@@ -21,22 +21,30 @@ use worker::{self, Worker, WorkerId};
 use futures::Poll;
 use futures::task::AtomicTask;
 
-use std::cell::UnsafeCell;
-use std::sync::atomic::Ordering::{Acquire, AcqRel, Relaxed};
+use std::cell::Cell;
+use std::num::Wrapping;
+use std::sync::atomic::Ordering::{Acquire, AcqRel};
 use std::sync::atomic::AtomicUsize;
 use std::sync::Arc;
 use std::thread;
 
-use rand::{Rng, SeedableRng, XorShiftRng};
+use crossbeam_utils::cache_padded::CachePadded;
+use rand;
 
-// TODO: Rename this
 #[derive(Debug)]
 pub(crate) struct Pool {
-    // ThreadPool state
-    pub state: AtomicUsize,
+    // Tracks the state of the thread pool (running, shutting down, ...).
+    //
+    // While workers check this field as a hint to detect shutdown, it is
+    // **not** used as a primary point of coordination for workers. The sleep
+    // stack is used as the primary point of coordination for workers.
+    //
+    // The value of this atomic is deserialized into a `pool::State` instance.
+    // See comments for that type.
+    pub state: CachePadded<AtomicUsize>,
 
     // Stack tracking sleeping workers.
-    sleep_stack: worker::Stack,
+    sleep_stack: CachePadded<worker::Stack>,
 
     // Number of workers that haven't reached the final state of shutdown
     //
@@ -44,9 +52,6 @@ pub(crate) struct Pool {
     // shutdown process has completed.
     pub num_workers: AtomicUsize,
 
-    // Used to generate a thread local RNG seed
-    pub next_thread_id: AtomicUsize,
-
     // Worker state
     //
     // A worker is a thread that is processing the work queue and polling
@@ -103,10 +108,9 @@ impl Pool {
         let blocking = Blocking::new(max_blocking);
 
         let ret = Pool {
-            state: AtomicUsize::new(State::new().into()),
-            sleep_stack: worker::Stack::new(),
+            state: CachePadded::new(AtomicUsize::new(State::new().into())),
+            sleep_stack: CachePadded::new(worker::Stack::new()),
             num_workers: AtomicUsize::new(0),
-            next_thread_id: AtomicUsize::new(0),
             workers,
             backup,
             backup_stack,
@@ -413,6 +417,8 @@ impl Pool {
                     break;
                 }
 
+                debug_assert!(!inner.backup[backup_id.0].is_pushed());
+
                 // Push the thread back onto the backup stack. This makes it
                 // available for future handoffs.
                 //
@@ -433,20 +439,14 @@ impl Pool {
 
                 // Wait for a handoff
                 let handoff = inner.backup[backup_id.0]
-                    .wait_for_handoff(true);
+                    .wait_for_handoff(inner.config.keep_alive);
 
                 match handoff {
                     Handoff::Worker(id) => {
                         debug_assert!(inner.backup[backup_id.0].is_running());
                         worker_id = id;
                     }
-                    Handoff::Idle => {
-                        // Worker is idle
-                        break;
-                    }
-                    Handoff::Terminated => {
-                        // TODO: When wait_for_handoff supports blocking with a
-                        // timeout, this will have to be smarter
+                    Handoff::Idle | Handoff::Terminated => {
                         break;
                     }
                 }
@@ -512,39 +512,25 @@ impl Pool {
 
     /// Generates a random number
     ///
-    /// Uses a thread-local seeded XorShift.
+    /// Uses a thread-local random number generator based on XorShift.
     pub fn rand_usize(&self) -> usize {
-        // Use a thread-local random number generator. If the thread does not
-        // have one yet, then seed a new one
-        thread_local!(static THREAD_RNG_KEY: UnsafeCell<Option<XorShiftRng>> = UnsafeCell::new(None));
-
-        THREAD_RNG_KEY.with(|t| {
-            #[cfg(target_pointer_width = "32")]
-            fn new_rng(thread_id: usize) -> XorShiftRng {
-                XorShiftRng::from_seed([
-                    thread_id as u32,
-                    0x00000000,
-                    0xa8a7d469,
-                    0x97830e05])
+        thread_local! {
+            static RNG: Cell<Wrapping<u32>> = {
+                // The initial seed must be non-zero.
+                let init = rand::random::<u32>() | 1;
+                Cell::new(Wrapping(init))
             }
+        }
 
-            #[cfg(target_pointer_width = "64")]
-            fn new_rng(thread_id: usize) -> XorShiftRng {
-                XorShiftRng::from_seed([
-                    thread_id as u32,
-                    (thread_id >> 32) as u32,
-                    0xa8a7d469,
-                    0x97830e05])
-            }
-
-            let thread_id = self.next_thread_id.fetch_add(1, Relaxed);
-            let rng = unsafe { &mut *t.get() };
-
-            if rng.is_none() {
-                *rng = Some(new_rng(thread_id));
-            }
-
-            rng.as_mut().unwrap().next_u32() as usize
+        RNG.with(|rng| {
+            // This is the 32-bit variant of Xorshift.
+            // https://en.wikipedia.org/wiki/Xorshift
+            let mut x = rng.get();
+            x ^= x << 13;
+            x ^= x >> 17;
+            x ^= x << 5;
+            rng.set(x);
+            x.0 as usize
         })
     }
 }

tokio-threadpool/src/task/queue.rs

@@ -6,12 +6,14 @@ use std::sync::Arc;
 use std::sync::atomic::AtomicPtr;
 use std::sync::atomic::Ordering::{Acquire, Release, AcqRel, Relaxed};
 
+use crossbeam_utils::cache_padded::CachePadded;
+
 #[derive(Debug)]
 pub(crate) struct Queue {
     /// Queue head.
     ///
     /// This is a strong reference to `Task` (i.e, `Arc<Task>`)
-    head: AtomicPtr<Task>,
+    head: CachePadded<AtomicPtr<Task>>,
 
     /// Tail pointer. This is `Arc<Task>` unless it points to `stub`.
     tail: UnsafeCell<*mut Task>,
@@ -37,7 +39,7 @@ impl Queue {
         let ptr = &*stub as *const _ as *mut _;
 
         Queue {
-            head: AtomicPtr::new(ptr),
+            head: CachePadded::new(AtomicPtr::new(ptr)),
             tail: UnsafeCell::new(ptr),
             stub: stub,
         }

tokio-threadpool/src/worker/entry.rs

@@ -8,6 +8,7 @@ use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::atomic::Ordering::{Acquire, AcqRel, Relaxed};
 
+use crossbeam_utils::cache_padded::CachePadded;
 use deque;
 
 // TODO: None of the fields should be public
@@ -16,16 +17,19 @@ use deque;
 // operations are thread-safe vs. which ones require ownership of the worker.
 pub(crate) struct WorkerEntry {
     // Worker state. This is mutated when notifying the worker.
-    pub state: AtomicUsize,
+    //
+    // The `usize` value is deserialized to a `worker::State` instance. See
+    // comments on that type.
+    pub state: CachePadded<AtomicUsize>,
 
     // Next entry in the parked Trieber stack
     next_sleeper: UnsafeCell<usize>,
 
     // Worker half of deque
-    deque: deque::Deque<Arc<Task>>,
+    worker: deque::Worker<Arc<Task>>,
 
     // Stealer half of deque
-    steal: deque::Stealer<Arc<Task>>,
+    stealer: deque::Stealer<Arc<Task>>,
 
     // Thread parker
     pub park: UnsafeCell<BoxPark>,
@@ -39,14 +43,13 @@ pub(crate) struct WorkerEntry {
 
 impl WorkerEntry {
     pub fn new(park: BoxPark, unpark: BoxUnpark) -> Self {
-        let w = deque::Deque::new();
-        let s = w.stealer();
+        let (w, s) = deque::fifo();
 
         WorkerEntry {
-            state: AtomicUsize::new(State::default().into()),
+            state: CachePadded::new(AtomicUsize::new(State::default().into())),
             next_sleeper: UnsafeCell::new(0),
-            deque: w,
-            steal: s,
+            worker: w,
+            stealer: s,
             inbound: Queue::new(),
             park: UnsafeCell::new(park),
             unpark,
@@ -185,23 +188,23 @@ impl WorkerEntry {
     ///
     /// This **must** only be called by the thread that owns the worker entry.
     /// This function is not `Sync`.
-    pub fn pop_task(&self) -> deque::Steal<Arc<Task>> {
-        self.deque.steal()
+    pub fn pop_task(&self) -> Option<Arc<Task>> {
+        self.worker.pop()
     }
 
     /// Steal a task
     ///
     /// This is called by *other* workers to steal a task for processing. This
     /// function is `Sync`.
-    pub fn steal_task(&self) -> deque::Steal<Arc<Task>> {
-        self.steal.steal()
+    pub fn steal_task(&self) -> Option<Arc<Task>> {
+        self.stealer.steal()
     }
 
     /// Drain (and drop) all tasks that are queued for work.
     ///
     /// This is called when the pool is shutting down.
     pub fn drain_tasks(&self) {
-        while let Some(_) = self.deque.pop() {
+        while let Some(_) = self.worker.pop() {
         }
     }
 
@@ -212,7 +215,7 @@ impl WorkerEntry {
 
     #[inline]
     pub fn push_internal(&self, task: Arc<Task>) {
-        self.deque.push(task);
+        self.worker.push(task);
     }
 
     #[inline]
@@ -236,8 +239,8 @@ impl fmt::Debug for WorkerEntry {
         fmt.debug_struct("WorkerEntry")
             .field("state", &self.state.load(Relaxed))
             .field("next_sleeper", &"UnsafeCell<usize>")
-            .field("deque", &self.deque)
-            .field("steal", &self.steal)
+            .field("worker", &self.worker)
+            .field("stealer", &self.stealer)
             .field("park", &"UnsafeCell<BoxPark>")
             .field("unpark", &"BoxUnpark")
             .field("inbound", &self.inbound)

tokio-threadpool/src/worker/mod.rs

@@ -25,12 +25,17 @@ use std::marker::PhantomData;
 use std::rc::Rc;
 use std::sync::atomic::Ordering::{AcqRel, Acquire};
 use std::sync::Arc;
+use std::thread;
 use std::time::{Duration, Instant};
 
 /// Thread worker
 ///
-/// This is passed to the `around_worker` callback set on `Builder`. This
-/// callback is only expected to call `run` on it.
+/// This is passed to the [`around_worker`] callback set on [`Builder`]. This
+/// callback is only expected to call [`run`] on it.
+///
+/// [`Builder`]: struct.Builder.html
+/// [`around_worker`]: struct.Builder.html#method.around_worker
+/// [`run`]: struct.Worker.html#method.run
 #[derive(Debug)]
 pub struct Worker {
     // Shared scheduler data
@@ -70,7 +75,7 @@ struct CurrentTask {
     can_block: Cell<CanBlock>,
 }
 
-/// Identifiers a thread pool worker.
+/// Identifies a thread pool worker.
 ///
 /// This identifier is unique scoped by the thread pool. It is possible that
 /// different thread pool instances share worker identifier values.
@@ -212,6 +217,7 @@ impl Worker {
     ///
     /// This function blocks until the worker is shutting down.
     pub fn run(&self) {
+        const MAX_SPINS: usize = 60;
         const LIGHT_SLEEP_INTERVAL: usize = 32;
 
         // Get the notifier.
@@ -250,19 +256,24 @@ impl Worker {
             }
 
             if !consistent {
+                thread::yield_now();
                 spin_cnt = 0;
                 continue;
             }
 
-            // Starting to get sleeeeepy
-            if spin_cnt < 61 {
-                spin_cnt += 1;
-            } else {
-                tick = 0;
+            spin_cnt += 1;
 
-                if !self.sleep() {
-                    return;
-                }
+            if spin_cnt < MAX_SPINS {
+                thread::yield_now();
+                continue;
+            }
+
+            tick = 0;
+            spin_cnt = 0;
+
+            // Starting to get sleeeeepy
+            if !self.sleep() {
+                return;
             }
 
             // If there still isn't any work to do, shutdown the worker?
@@ -336,8 +347,29 @@ impl Worker {
             state = actual;
         }
 
-        // If this is the first iteration of the worker loop, then the state can
-        // be signaled.
+        // `first` is set to true the first time this function is called after
+        // the thread has started.
+        //
+        // This check is to handle the scenario where a worker gets signaled
+        // while it is already happily running. The `is_signaled` state is
+        // intended to wake up a worker that has been previously sleeping in
+        // effect increasing the number of active workers. If this is the first
+        // time `check_run_state` is called, then being in a signalled state is
+        // normal and the thread was started to handle it.  However, if this is
+        // **not** the first time the fn was called, then the number of active
+        // workers has not been increased by the signal, so `signal_work` has to
+        // be called again to try to wake up another worker.
+        //
+        // For example, if the thread pool is configured to allow 4 workers.
+        // Worker 1 is processing tasks from its `deque`. Worker 2 receives its
+        // first task. Worker 2 will pick a random worker to signal. It does
+        // this by popping off the sleep stack, but there is no guarantee that
+        // workers on the sleep stack are actually sleeping. It is possible that
+        // Worker 1 gets signaled.
+        //
+        // Without this check, in the above case, no additional workers will get
+        // started, which results in the thread pool permanently being at 2
+        // workers even though it should reach 4.
         if !first && state.is_signaled() {
             trace!("Worker::check_run_state; delegate signal");
             // This worker is not ready to be signaled, so delegate the signal
@@ -352,16 +384,13 @@ impl Worker {
     ///
     /// Returns `true` if work was found.
     fn try_run_owned_task(&self, notify: &Arc<Notifier>, sender: &mut Sender) -> bool {
-        use deque::Steal::*;
-
         // Poll the internal queue for a task to run
         match self.entry().pop_task() {
-            Data(task) => {
+            Some(task) => {
                 self.run_task(task, notify, sender);
                 true
             }
-            Empty => false,
-            Retry => true,
+            None => false,
         }
     }
 
@@ -369,36 +398,29 @@ impl Worker {
     ///
     /// Returns `true` if work was found
     fn try_steal_task(&self, notify: &Arc<Notifier>, sender: &mut Sender) -> bool {
-        use deque::Steal::*;
-
         debug_assert!(!self.is_blocking.get());
 
         let len = self.inner.workers.len();
         let mut idx = self.inner.rand_usize() % len;
-        let mut found_work = false;
         let start = idx;
 
         loop {
             if idx < len {
-                match self.inner.workers[idx].steal_task() {
-                    Data(task) => {
-                        trace!("stole task");
+                if let Some(task) = self.inner.workers[idx].steal_task() {
+                    trace!("stole task");
 
-                        self.run_task(task, notify, sender);
+                    self.run_task(task, notify, sender);
 
-                        trace!("try_steal_task -- signal_work; self={}; from={}",
-                               self.id.0, idx);
+                    trace!("try_steal_task -- signal_work; self={}; from={}",
+                           self.id.0, idx);
 
-                        // Signal other workers that work is available
-                        //
-                        // TODO: Should this be called here or before
-                        // `run_task`?
-                        self.inner.signal_work(&self.inner);
+                    // Signal other workers that work is available
+                    //
+                    // TODO: Should this be called here or before
+                    // `run_task`?
+                    self.inner.signal_work(&self.inner);
 
-                        return true;
-                    }
-                    Empty => {}
-                    Retry => found_work = true,
+                    return true;
                 }
 
                 idx += 1;
@@ -411,7 +433,7 @@ impl Worker {
             }
         }
 
-        found_work
+        false
     }
 
     fn run_task(&self, task: Arc<Task>, notify: &Arc<Notifier>, sender: &mut Sender) {
@@ -537,6 +559,9 @@ impl Worker {
             match task {
                 Empty => {
                     if found_work {
+                        // TODO: Why is this called on every iteration? Would it
+                        // not be better to only signal when work was found
+                        // after waking up?
                         trace!("found work while draining; signal_work");
                         self.inner.signal_work(&self.inner);
                     }

tokio-timer/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 0.2.5 (August 6, 2018)
+
+* Add `Interval::interval` shortcut (#492).
+
 # 0.2.4 (June 6, 2018)
 
 * Add `sleep` function for easy interval delays (#347).

tokio-timer/Cargo.toml

@@ -4,7 +4,7 @@ name = "tokio-timer"
 # - Update html_root_url.
 # - Update CHANGELOG.md.
 # - Create "v0.2.x" git tag.
-version = "0.2.4"
+version = "0.2.5"
 authors = ["Carl Lerche <[email protected]>"]
 license = "MIT"
 readme = "README.md"

tokio-timer/src/clock/clock.rs

@@ -26,7 +26,7 @@ thread_local!(static CLOCK: Cell<Option<*const Clock>> = Cell::new(None));
 /// execution context. By default, this is `Instant::now()`.
 ///
 /// Note that, because the source of time is configurable, it is possible to
-/// observe non-monotonic behavior when calling [`now`] from different
+/// observe non-monotonic behavior when calling `now` from different
 /// executors.
 ///
 /// See [module](index.html) level documentation for more details.

tokio-timer/src/clock/mod.rs

@@ -7,7 +7,7 @@
 //! The [`now`][n] function returns the current `Instant`. By default, it delegates
 //! to [`Instant::now`][std].
 //!
-//! The source of time used by [`now`] can be configured by implementing the
+//! The source of time used by [`now`][n] can be configured by implementing the
 //! [`Now`] trait and passing an instance to [`with_default`].
 //!
 //! [n]: fn.now.html

tokio-timer/src/interval.rs

@@ -1,5 +1,7 @@
 use Delay;
 
+use clock;
+
 use futures::{Future, Stream, Poll};
 
 use std::time::{Instant, Duration};
@@ -18,6 +20,8 @@ impl Interval {
     /// Create a new `Interval` that starts at `at` and yields every `duration`
     /// interval after that.
     ///
+    /// Note that when it starts, it produces item too.
+    ///
     /// The `duration` argument must be a non-zero duration.
     ///
     /// # Panics
@@ -29,6 +33,19 @@ impl Interval {
         Interval::new_with_delay(Delay::new(at), duration)
     }
 
+    /// Creates new `Interval` that yields with interval of `duration`.
+    ///
+    /// The function is shortcut for `Interval::new(Instant::now() + duration, duration)`.
+    ///
+    /// The `duration` argument must be a non-zero duration.
+    ///
+    /// # Panics
+    ///
+    /// This function panics if `duration` is zero.
+    pub fn new_interval(duration: Duration) -> Interval {
+        Interval::new(clock::now() + duration, duration)
+    }
+
     pub(crate) fn new_with_delay(delay: Delay, duration: Duration) -> Interval {
         Interval {
             delay,

tokio-timer/src/lib.rs

@@ -18,7 +18,7 @@
 //! [`Interval`]: struct.Interval.html
 //! [`Timer`]: timer/struct.Timer.html
 
-#![doc(html_root_url = "https://docs.rs/tokio-timer/0.2.4")]
+#![doc(html_root_url = "https://docs.rs/tokio-timer/0.2.5")]
 #![deny(missing_docs, warnings, missing_debug_implementations)]
 
 extern crate tokio_executor;

tokio-timer/src/timer/handle.rs

@@ -33,6 +33,7 @@ thread_local!(static CURRENT_TIMER: RefCell<Option<Handle>> = RefCell::new(None)
 /// This function panics if there already is a default timer set.
 ///
 /// [`Delay`]: ../struct.Delay.html
+/// [`Delay::new`]: ../struct.Delay.html#method.new
 pub fn with_default<F, R>(handle: &Handle, enter: &mut Enter, f: F) -> R
 where F: FnOnce(&mut Enter) -> R
 {

tokio-timer/src/timer/mod.rs

@@ -26,6 +26,7 @@
 //! [`Delay`]: ../struct.Delay.html
 //! [`Now`]: trait.Now.html
 //! [`Now::now`]: trait.Now.html#method.now
+//! [`SystemNow`]: struct.SystemNow.html
 
 // This allows the usage of the old `Now` trait.
 #![allow(deprecated)]

tokio-udp/CHANGELOG.md

@@ -1,3 +1,7 @@
-# 0.1.0 (unreleased)
+# 0.1.1 (June 13, 2018)
+
+* Switch to tokio-codec (#360)
+
+# 0.1.0 (Mar 23, 2018)
 
 * Initial release

tokio-udp/Cargo.toml

@@ -5,7 +5,7 @@ name = "tokio-udp"
 # - Update html_root_url.
 # - Update CHANGELOG.md.
 # - Create "v0.1.x" git tag.
-version = "0.1.0"
+version = "0.1.1"
 authors = ["Carl Lerche <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/tokio-rs/tokio"
@@ -18,7 +18,7 @@ categories = ["asynchronous"]
 
 [dependencies]
 tokio-codec = { version = "0.1.0", path = "../tokio-codec" }
-tokio-io = { version = "0.1.6", path = "../tokio-io" }
+tokio-io = { version = "0.1.7", path = "../tokio-io" }
 tokio-reactor = { version = "0.1.1", path = "../tokio-reactor" }
 bytes = "0.4"
 mio = "0.6.14"

tokio-udp/src/lib.rs

@@ -16,7 +16,7 @@
 //! [`UdpFramed`]: struct.UdpFramed.html
 //! [`framed`]: struct.UdpSocket.html#method.framed
 
-#![doc(html_root_url = "https://docs.rs/tokio-tcp/0.1.0")]
+#![doc(html_root_url = "https://docs.rs/tokio-tcp/0.1.1")]
 #![deny(missing_docs, warnings, missing_debug_implementations)]
 
 extern crate bytes;

tokio-uds/src/datagram.rs

@@ -104,6 +104,7 @@ impl UnixDatagram {
         let r = self.io.get_ref().recv_from(buf);
         if is_wouldblock(&r) {
             self.io.clear_read_ready(Ready::readable())?;
+            return Ok(Async::NotReady);
         }
         r.map(Async::Ready)
     }
@@ -118,6 +119,7 @@ impl UnixDatagram {
         let r = self.io.get_ref().recv(buf);
         if is_wouldblock(&r) {
             self.io.clear_read_ready(Ready::readable())?;
+            return Ok(Async::NotReady);
         }
         r.map(Async::Ready)
     }

tokio-uds/src/lib.rs

@@ -30,5 +30,5 @@ pub use incoming::Incoming;
 pub use listener::UnixListener;
 pub use recv_dgram::RecvDgram;
 pub use send_dgram::SendDgram;
-pub use stream::UnixStream;
+pub use stream::{UnixStream, ConnectFuture};
 pub use ucred::UCred;