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

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);
}

main.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

Maybe an infinite loop on the server side creates a problem

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

but is there a way to make this channel communication working?

当然，您似乎只是缺少 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);
    }
}

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

Receive message from channel between modules

rust

channels