从模块之间的通道接收消息

Question

我有四个模块。客户端正在发送消息，服务器正在接收消息。服务器收到消息后，会尝试将消息发送到 MPSC 通道。我将接收器放在我打算接收消息的另一个 .rs 文件中。

我在接收方没有收到任何消息。

也许服务器端的无限循环会造成问题，但有没有办法让这种通道通信正常工作？

client.rs

use std::io::prelude::*;
use std::os::unix::net::UnixDatagram;
use std::path::Path;
use std::sync::mpsc;

pub fn tcp_datagram_client() {
    pub static FILE_PATH: &'static str = "/tmp/datagram.sock";
    let socket = UnixDatagram::unbound().unwrap();
    match socket.connect(FILE_PATH) {
        Ok(socket) => socket,
        Err(e) => {
            println!("Couldn't connect: {:?}", e);
            return;
        }
    };
    println!("TCP client Connected to TCP Server {:?}", socket);
    loop {
        socket
            .send(b"Hello from client to server")
            .expect("recv function failed");
    }
}

fn main() {
    tcp_datagram_client();
}

server.rs

use std::os::unix::net::UnixDatagram;
use std::path::Path;
use std::str::from_utf8;
use std::sync::mpsc::Sender;

fn unlink_socket(path: impl AsRef<Path>) {
    let path = path.as_ref();
    if path.exists() {
        if let Err(e) = std::fs::remove_file(path) {
            eprintln!("Couldn't remove the file: {:?}", e);
        }
    }
}

static FILE_PATH: &'static str = "/tmp/datagram.sock";
pub fn tcp_datagram_server(tx: Sender<String>) {
    unlink_socket(FILE_PATH);
    let socket = match UnixDatagram::bind(FILE_PATH) {
        Ok(socket) => socket,
        Err(e) => {
            eprintln!("Couldn't bind: {:?}", e);
            return;
        }
    };
    let mut buf = vec![0; 1024];
    println!("Waiting for client to connect...");
    loop {
        let received_bytes = socket.recv(&mut buf).expect("recv function failed");
        println!("Received {:?}", received_bytes);
        let received_message = from_utf8(&buf).expect("utf-8 convert failed");
        tx.send(received_message.to_string());
    }
}

message_receiver.rs

use crate::server;
use std::sync::mpsc;

pub fn handle_messages() {
    let (tx, rx) = mpsc::channel();
    server::tcp_datagram_server(tx);
    let message_from_tcp_server = rx.recv().unwrap();
    println!("{:?}", message_from_tcp_server);
}

ma​​in.rs

mod server;
mod message_receiver;

fn main() {
    message_receiver::handle_messages();
}

TCP 客户端连接后：

TCP client Connected to TCP Server UnixDatagram { fd: 3, local: (unnamed), peer: "/tmp/datagram.sock" (pathname) }

我在频道接收端没有收到任何消息：

Waiting for client to connect...

Answer 1

可能服务器端的无限循环会造成问题

是的，从字面上看，您的服务器代码会执行无限的loop 来连续处理来自客户端的消息。所以对tcp_datagram_server 的调用永远不会返回。

但是有没有办法使这种渠道通信正常工作？

当然，您似乎只是缺少message_receiver 的第二个线程。将您的 tcp_datagram_server(tx) 包裹在 std::thread::spawn 中应该可以。您还可以添加loop 以继续处理请求以匹配tcp_datagram_server 中的请求：

pub fn handle_messages() {
    let (tx, rx) = mpsc::channel();
    std::thread::spawn(|| tcp_datagram_server(tx));
    loop {
        let message_from_tcp_server = rx.recv().unwrap();
        println!("{}", message_from_tcp_server);
    }
}