mirror of
https://github.com/tokio-rs/tokio.git
synced 2026-08-14 00:00:12 +02:00
Carl Lerche
db620b42ec
Currently, the timer uses a `Now` trait to abstract the source of time. This allows time to be mocked out. However, the current implementation has a number of limitations as represented by #288 and #296. The main issues are that `Now` requires `&mut self` which prevents a value from being easily used in a concurrent environment. Also, when wanting to write code that is abstract over the source of time, generics get out of hand. This patch provides an alternate solution. A new type, `Clock` is provided which defaults to `Instant::now` as the source of time, but allows configuring the actual source using a new iteration of the `Now` trait. This time, `Now` is `Send + Sync + 'static`. Internally, `Clock` stores the now value in an `Arc<Now>` value, which introduces dynamism and allows `Clock` values to be cloned and be `Sync`. Also, the current clock can be set for the current execution context using the `with_default` pattern. Because using the `Instant::now` will be the most common case by far, it is special cased in order to avoid the need to allocate an `Arc` and use dynamic dispatch.
70 lines
1.5 KiB
Rust
70 lines
1.5 KiB
Rust
extern crate futures;
|
|
extern crate tokio;
|
|
extern crate tokio_timer;
|
|
extern crate env_logger;
|
|
|
|
use tokio::prelude::*;
|
|
use tokio::runtime::{self, current_thread};
|
|
use tokio::timer::*;
|
|
use tokio_timer::clock::Clock;
|
|
|
|
use std::sync::mpsc;
|
|
use std::time::{Duration, Instant};
|
|
|
|
struct MockNow(Instant);
|
|
|
|
impl tokio_timer::clock::Now for MockNow {
|
|
fn now(&self) -> Instant {
|
|
self.0
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn clock_and_timer_concurrent() {
|
|
let _ = env_logger::init();
|
|
|
|
let when = Instant::now() + Duration::from_millis(5_000);
|
|
let clock = Clock::new_with_now(MockNow(when));
|
|
|
|
let mut rt = runtime::Builder::new()
|
|
.clock(clock)
|
|
.build()
|
|
.unwrap();
|
|
|
|
let (tx, rx) = mpsc::channel();
|
|
|
|
rt.spawn({
|
|
Delay::new(when)
|
|
.map_err(|e| panic!("unexpected error; err={:?}", e))
|
|
.and_then(move |_| {
|
|
assert!(Instant::now() < when);
|
|
tx.send(()).unwrap();
|
|
Ok(())
|
|
})
|
|
});
|
|
|
|
rx.recv().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn clock_and_timer_single_threaded() {
|
|
let _ = env_logger::init();
|
|
|
|
let when = Instant::now() + Duration::from_millis(5_000);
|
|
let clock = Clock::new_with_now(MockNow(when));
|
|
|
|
let mut rt = current_thread::Builder::new()
|
|
.clock(clock)
|
|
.build()
|
|
.unwrap();
|
|
|
|
rt.block_on({
|
|
Delay::new(when)
|
|
.map_err(|e| panic!("unexpected error; err={:?}", e))
|
|
.and_then(move |_| {
|
|
assert!(Instant::now() < when);
|
|
Ok(())
|
|
})
|
|
}).unwrap();
|
|
}
|