closable.rs

extern crate actix;
extern crate tokio_core;
extern crate futures;
use std::time::Duration;
use futures::Stream;
use tokio_core::reactor::Interval;
use actix::prelude::*;
use actix::{Actor, Context, StreamHandler, SpawnHandle, Arbiter};


struct ClosableActor {
    source: SpawnHandle,
}
impl Actor for ClosableActor {
    type Context = Context<Self>;
}


struct ClosablePacket;
impl<K> StreamHandler<ClosablePacket, K> for ClosableActor {
    fn handle(&mut self, _: ClosablePacket, ctx: &mut Context<Self>) {
        ctx.cancel_future(self.source);
    }
}


fn main() {
    let sys = actix::System::new("closable");
    let _: () = ClosableActor::create(|ctx| {
        ClosableActor {
            source: ctx.add_stream(
                Interval::new(
                    Duration::from_millis(1),
                    Arbiter::handle()
                ).unwrap().map(|_| ClosablePacket)
            ),
        }
    });
    std::process::exit(sys.run());
}