Question

我正在编写一个名为BoltServer的简单websocket服务器，它基于Rust websocket crate（代码不完整，我刚开始）。我使用示例程序作为基础。但是，示例程序不是模块化的（具有很长的方法）。所以我试图把它们分解成结构和方法。我想为每个客户端生成两个线程。一个发送消息，另一个接收消息。所以在这里，我想捕获结构中线程使用的所有变量，然后在impl中调用run方法。

extern crate websocket;
extern crate time;
extern crate rustc_serialize;

pub mod ws {
    use std::thread;
    use std::sync::{Arc, Mutex};
    use std::sync::mpsc;
    use std::net::ToSocketAddrs;
    use websocket;
    use websocket::{Server, Message, Sender, Receiver};
    use websocket::server::Connection;
    use websocket::stream::WebSocketStream;
    use std::str::from_utf8;

    struct BoltUser {
        user_id: u32,
        my_tx: mpsc::Sender<String>,
    }

    struct Broadcaster {
        my_rx: mpsc::Receiver<String>,
    }
    impl Broadcaster {
        fn new(receiver: mpsc::Receiver<String>) -> Broadcaster {
            Broadcaster { my_rx: receiver }
        }
        fn run(self) {
            while let Ok(msg) = self.my_rx.recv() {
                println!("Broadcaster got message: {}", msg);
            }
        }
    }

    struct SocketReader {}
    impl SocketReader {
        fn run(self) {}
    }

    struct SocketWriter {
        my_rx: mpsc::Receiver<String>,
        sender: Sender,
    }
    impl SocketWriter {
        fn run(self) {
            while let Ok(message) = self.my_rx.recv() {
            }
        }
    }

    pub struct BoltServer {
        address: String,
        connected_users: Arc<Mutex<Vec<BoltUser>>>,
    }
    impl BoltServer {
        pub fn new(address: &str) -> BoltServer {
            BoltServer {
                address: address.to_string(),
                connected_users: Arc::new(Mutex::new(vec![])),
            }
        }
        fn handshake(&mut self,
                     connection: Connection<WebSocketStream, WebSocketStream>)
                     -> (SocketWriter, SocketReader) {
            let request = connection.read_request().unwrap();
            // println!("thread-> Accepting request...");
            let response = request.accept();
            let (mut sender, mut receiver) = response.send().unwrap().split();
            let (user_tx, user_rx) = mpsc::channel::<String>();//Create a channel for writer
            let socket_writer = SocketWriter {
                my_rx: user_rx,
                sender: sender,
            };
            let socket_reader = SocketReader {};
            (socket_writer, socket_reader)
        }
        pub fn start(&mut self) {
            println!("Starting");
            let (broadcaster_tx, broadcaster_rx) = mpsc::channel::<String>();
            let broadcaster = Broadcaster::new(broadcaster_rx);
            let handle = thread::Builder::new()
                .name("Broadcaster".to_string())
                .spawn(move || broadcaster.run());

            let server = Server::bind(&*self.address).unwrap();

            let mut user_id: u32 = 0;

            // Block and process connection request from a new client
            for connection in server {
                user_id = user_id + 1;//Create a new user id
                let (socket_writer, socket_reader) = self.handshake(connection);
                thread::Builder::new()
                    .name("Socket writer".to_string())
                    .spawn(move || socket_writer.run());
                thread::Builder::new()
                    .name("Socket reader".to_string())
                    .spawn(move || socket_reader.run());
            }

            handle.unwrap().join();
            println!("Finished");
        }
    }
}

以下代码概述了我想要实现的目标。

// Block and process connection request from a new client
for connection in server {
    user_id = user_id + 1;//Create a new user id
    let (socket_writer, socket_reader) = self.handshake(connection);
    thread::Builder::new().name("Socket writer".to_string()).spawn(move || {
        socket_writer.run()
    });
    thread::Builder::new().name("Socket reader".to_string()).spawn(move || {
        socket_reader.run()
    });
}

这里我陷入握手方式。我无法通过调用库中的SocketWriter方法来初始化split结构与我得到的发件人。我收到以下编译错误：

    error[E0038]: the trait `websocket::Sender` cannot be made into an object
  --> src/lib.rs:46:9
   |
46 |         sender:Sender,
   |         ^^^^^^^^^^^^^ the trait `websocket::Sender` cannot be made into an object
   |
   = note: method `send_dataframe` has generic type parameters
   = note: method `send_message` has generic type parameters

Answer 1

错误告诉您眼前的问题：

46 |         sender:Sender,
   |         ^^^^^^^^^^^^^ the trait `websocket::Sender` cannot be made into an object

首先，变量/字段不能具有普通特征类型（但&Trait是可能的），但websocket::Sender特征不是object safe;它具有无法动态工作的通用方法（即vtable方法必须具有固定类型）。

相反，你必须有一个具体的类型（你也可以使它成为一个通用的结构）。

正确的类型是不明显的，所以我想让编译器告诉我。所以首先尝试最简单的方法：

    sender: (),

编译器回复一些信息：

|                       ^^^^^^ expected (), found struct `websocket::client::Sender`

好的，我们将其插入：

    sender: websocket::client::Sender,

这给出了：

46 |         sender: websocket::client::Sender,
   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ expected 1 type arguments, found 0

好的，这是一种通用类型。接下来尝试：

    sender: websocket::client::Sender<()>,

最后它给了我们真实的类型：

74 |                sender:sender,
   |                       ^^^^^^ expected (), found enum `websocket::WebSocketStream`

最后我们可以完成SocketWriter：

struct SocketWriter {
    my_rx: mpsc::Receiver<String>,
    sender: websocket::client::Sender<websocket::WebSocketStream>,
}

由于您获得的connection是Result<>，因此存在以下编译错误，因此您需要检查错误（如果我更改为self.handshake(connection.unwrap())则会编译，但这显然不是最好的实践。

避免闭包 - 在结构中封装线程变量

1 个答案: