Trying to link rust-websocket and tokio-core

websocket_server.rs

extern crate websocket;
extern crate tokio_core;
extern crate futures;

use websocket::{Server, Message, Sender, Receiver};
use websocket::message::Type;
use websocket::header::WebSocketProtocol;

use futures::Future;
use futures::stream::Stream;
use tokio_core::reactor::Core;

fn main() {
    let server = Server::bind("127.0.0.1:2794").unwrap();

    // Create the event loop that will drive this server
    let mut l = Core::new().unwrap();
    let handle = l.handle();

    let stream = futures::stream::iter(server);

    let done = stream.for_each(|connection| {
        // let request_got = connection.read_request(); // Get the request
        let request_future = futures::done::<_, std::io::Error>(connection.read_request());

        handle.spawn(request_future.then(|req_res| {
            let request = req_res.unwrap();

            let headers = request.headers.clone(); // Keep the headers so we can check them

            request.validate().unwrap(); // Validate the request

            let mut response = request.accept(); // Form a response

            if let Some(&WebSocketProtocol(ref protocols)) = headers.get() {
                if protocols.contains(&("rust-websocket".to_string())) {
                    // We have a protocol we want to use
                    response.headers.set(WebSocketProtocol(vec!["rust-websocket".to_string()]));
                }
            }

            let mut client = response.send().unwrap(); // Send the response

            let ip = client.get_mut_sender()
                .get_mut()
                .peer_addr()
                .unwrap();

            println!("Connection from {}", ip);

            let message: Message = Message::text("Hello".to_string());
            client.send_message(&message).unwrap();

            let (mut sender, mut receiver) = client.split();

            for message in receiver.incoming_messages() {
                let message: Message = message.unwrap();

                match message.opcode {
                    Type::Close => {
                        let message = Message::close();
                        sender.send_message(&message).unwrap();
                        println!("Client {} disconnected", ip);
                    }
                    Type::Ping => {
                        let message = Message::pong(message.payload);
                        sender.send_message(&message).unwrap();
                    }
                    _ => sender.send_message(&message).unwrap(),
                };
            }

            Ok(())
        }));

        Ok(())
    });

    l.run(done).unwrap();
}