server: Is it possible to get the path outside the callback? about tokio-tungstenite HOT 6 CLOSED

fn on_request(self, request: &Request) -> Result<Option<Vec<(String, String)>>>

extern crate futures;
extern crate tokio_core;
extern crate tokio_tungstenite;
extern crate tungstenite;

use std::cell::RefCell;
use std::collections::HashMap;
use std::env;
use std::io::{Error, ErrorKind};
use std::rc::Rc;

use futures::Future;
use futures::stream::Stream;
use tokio_core::net::TcpListener;
use tokio_core::reactor::Core;
use tokio_tungstenite::accept_hdr_async;
use tungstenite::handshake::server::{Callback, Request};
use tungstenite::protocol::Message;

struct TestCallback {
    path: String,
}

impl<'a> Callback for &'a mut TestCallback {
    fn on_request(
        self,
        _request: &Request,
    ) -> tungstenite::error::Result<Option<Vec<(String, String)>>> {
        Ok(None)
    }
}

fn main() {
    let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
    let addr = addr.parse().unwrap();

    // Create the event loop and TCP listener we'll accept connections on.
    let mut core = Core::new().unwrap();
    let handle = core.handle();
    let socket = TcpListener::bind(&addr, &handle).unwrap();
    println!("Listening on: {}", addr);

    // This is a single-threaded server, so we can just use Rc and RefCell to
    // store the map of all connections we know about.
    let connections = Rc::new(RefCell::new(HashMap::new()));

    let srv = socket.incoming().for_each(|(stream, addr)| {
        let connections_inner = connections.clone();
        let handle_inner = handle.clone();

        let test_callback = TestCallback {
            path: String::new(),
        };

        accept_hdr_async(stream, &mut test_callback)
            .and_then(move |ws_stream| {
                println!("New WebSocket connection: {}", addr);

                println!("test_callback: {:?}", test_callback.path);

                let (tx, rx) = futures::sync::mpsc::unbounded();
                connections_inner.borrow_mut().insert(addr, tx);

                let (sink, stream) = ws_stream.split();

                let connections = connections_inner.clone();
                let ws_reader = stream.for_each(move |message: Message| {
                    println!("Received a message from {}: {}", addr, message);

                    // For each open connection except the sender, send the
                    // string via the channel.
                    let mut conns = connections.borrow_mut();
                    let iter = conns
                        .iter_mut()
                        .filter(|&(&k, _)| k != addr)
                        .map(|(_, v)| v);
                    for tx in iter {
                        tx.unbounded_send(message.clone()).unwrap();
                    }
                    Ok(())
                });

                // Whenever we receive a string on the Receiver, we write it to
                // `WriteHalf<WebSocketStream>`.
                let ws_writer = rx.fold(sink, |mut sink, msg| {
                    use futures::Sink;
                    sink.start_send(msg).unwrap();
                    Ok(sink)
                });

                // Now that we've got futures representing each half of the socket, we
                // use the `select` combinator to wait for either half to be done to
                // tear down the other. Then we spawn off the result.
                let connection = ws_reader
                    .map(|_| ())
                    .map_err(|_| ())
                    .select(ws_writer.map(|_| ()).map_err(|_| ()));

                handle_inner.spawn(connection.then(move |_| {
                    connections_inner.borrow_mut().remove(&addr);
                    println!("Connection {} closed.", addr);
                    Ok(())
                }));

                Ok(())
            })
            .map_err(|e| {
                println!("Error during the websocket handshake occurred: {}", e);
                Error::new(ErrorKind::Other, e)
            })
    });

    // Execute server.
    core.run(srv).unwrap();
}