Question

我正在一个回显服务器上工作，该服务器从TCP接收数据并将一些逻辑应用于该数据。例如，如果客户端数据以hello的形式输入，我想以hello from server的形式进行响应。

我可以使用copy函数转发输入数据，但这对我而言没有用。

这是我正在处理的起始代码：

extern crate futures;
extern crate tokio_core;
extern crate tokio_io;

use futures::stream::Stream;
use futures::Future;
use std::net::SocketAddr;
use tokio_core::net::TcpListener;
use tokio_core::reactor::Core;
use tokio_io::io::copy;
use tokio_io::AsyncRead;

fn main() {
    let addr = "127.0.0.1:15000".parse::<SocketAddr>().unwrap();
    let mut core = Core::new().unwrap();
    let handle = core.handle();

    let socket = TcpListener::bind(&addr, &handle).unwrap();
    println!("Listening on: {}", addr);

    let done = socket.incoming().for_each(move |(socket, addr)| {
        let (reader, writer) = socket.split();
        let amt = copy(reader, writer);

        let msg = amt.then(move |result| {
            match result {
                Ok((amt, _, _)) => println!("wrote {} bytes to {}", amt, addr),
                Err(e) => println!("error on {}: {}", addr, e),
            }

            Ok(())
        });

        handle.spawn(msg);

        Ok(())
    });

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

我知道我需要添加一些逻辑来代替此复制功能，但是如何添加？

let amt = copy(reader, writer);

Answer 1

从某种意义上说，回显服务器是一种特殊的情况，即来自客户端的一个“请求”恰好跟着来自服务器的一个响应。这种用例的一个很好的例子是tokio的TinyDB example。

但是，应该考虑的一件事是，虽然UDP基于数据包，但是以与您发送数据包时相同的形式到达了另一端，而TCP则不是。 TCP是一种流协议-它有很强的保证力，即另一端接收到一个数据包，并且发送的数据按照发送时的顺序进行接收。但是，不能保证的是，一个调用“发送”一方面，“”会导致另一侧恰好一个“接收”调用，返回与发送的数据完全相同的数据块。当发送非常长的数据块（其中一个发送映射到多个接收）时，这尤其令人感兴趣。因此，您应该满足服务器在等待发送响应到客户端之前可以等待的分隔符。在Telnet中，该分隔符为“ \ r \ n”。这就是tokio的解码器/编码器基础结构发挥作用的地方。这种编解码器的示例实现是LinesCodec。如果你想拥有 Telnet，这正是您想要的。它将一次只给您一条消息，并允许您一次只发送一条这样的消息作为响应：

extern crate tokio;

use tokio::codec::Decoder;
use tokio::net::TcpListener;
use tokio::prelude::*;
use tokio::codec::LinesCodec;
use std::net::SocketAddr;

fn main() {
    let addr = "127.0.0.1:15000".parse::<SocketAddr>().unwrap();

    let socket = TcpListener::bind(&addr).unwrap();
    println!("Listening on: {}", addr);

    let done = socket.incoming()
        .map_err(|e| println!("failed to accept socket; error = {:?}", e))
        .for_each(move |socket| {
            // Fit the line-based codec on top of the socket. This will take on the task of
            // parsing incomming messages, as well as formatting outgoing ones (appending \r\n).
            let (lines_tx, lines_rx) = LinesCodec::new().framed(socket).split();

            // This takes every incomming message and allows to create one outgoing message for it,
            // essentially generating a stream of responses.
            let responses = lines_rx.map(|incomming_message| {
                // Implement whatever transform rules here
                if incomming_message == "hello" {
                    return String::from("hello from server");
                }
                return incomming_message;
            });

            // At this point `responses` is a stream of `Response` types which we
            // now want to write back out to the client. To do that we use
            // `Stream::fold` to perform a loop here, serializing each response and
            // then writing it out to the client.
            let writes = responses.fold(lines_tx, |writer, response| {
                //Return the future that handles to send the response to the socket
                writer.send(response)
            });

            // Run this request/response loop until the client closes the connection
            // Then return Ok(()), ignoring all eventual errors.
            tokio::spawn(
                writes.then(move |_| Ok(()))
            );

            return Ok(());
        });

    tokio::run(done);
}

如何使用基于Tokio的回显服务器异步检索数据并进行修改？

1 个答案: