Early implementation of tokio-watchdog for further discussions.

Licence = Apache2.0/MIT, like in Rust.

API excerpt

```rust pub struct Watchdog(H); impl Watchdog { pub fn new(dur: Duration) -> Self; pub fn duration(&self) -> Duration; pub fn set_duration(&mut self, dur: Duration); pub fn handle(&self) -> Pet; }

impl Future for Watchdog { type Item = Rearm; type Error = tokio_timer::Error; }

pub struct Pet(H); impl Pet { pub fn pet(&self); pub fn getremainingtime(&self) -> Option; }

pub struct Rearm(H); impl Rearm { pub fn rearm(self) -> Watchdog; pub fn rearmwithduration(self, dur: Duration) -> Watchdog; } ```

Example

```rust extern crate tokio; extern crate tokio_watchdog;

use tokio::runtime; use tokio::prelude::{Future, Stream, future}; use tokio::timer::Interval;

use std::time::{Instant, Duration};

fn main() {

let mut r = runtime::Builder::new().build().unwrap();

let watch = tokio_watchdog::Watchdog::new(Duration::from_secs(1));

let p = watch.handle();

let task1 = watch.and_then(|_| {
    println!("BLAM!");
    ::std::process::exit(0);
    #[allow(unreachable_code)]
    future::ok(())
});



let intvl = Interval::new(Instant::now(), Duration::new(0, 100_000_000));
let lazy_time = Instant::now() + Duration::from_secs(2);
let task2 = intvl.for_each(move |i| {
    if i < lazy_time {
        println!("pet");
        p.pet();
    } else {
        println!("no pet");
    }
    future::ok(())
});

r.spawn(task1.map_err(|_|()));
r.spawn(task2.map_err(|_|()));

r.shutdown_on_idle().wait().unwrap();

} ```