用Rust编写的TCP服务器示例

我正在寻找Rust中TCP服务器的示例

---

“hello world”或echo服务器都很好。

下面是一个使用

std:：net

的非常简单的示例。它是针对当前的锈迹大师开发的，应该也适用于1.*上

注意这个例子；简化了；如果绑定、侦听或接受产生错误，您可能不希望它惊慌失措

使用std:：io:：Write；
使用std:：net:：TcpListener；
使用std：：线程；
fn main（）{
让listener=TcpListener:：bind（“127.0.0.1:9123”）.unwrap（）；
println！（“已开始侦听，准备接受”）；
对于listener.incoming（）中的流{
线程：：spawn（| |{
让mut stream=stream.unwrap（）；
stream.write（b“Hello World\r\n”）.unwrap（）；
});
}
}

注意关于接受的范例；您必须自己启动

accept（）

请求（在本例中，我们使用的是

incoming（）

迭代器，每次只调用

accept（）

），这样您就可以真正控制有哪些任务

因此，我将实际的流处理代码放在一个单独的线程中，但它不必用于非常短的请求（这只意味着在处理第一个请求时，您将无法处理第二个请求）；您也可以删除关于这两行的

thread:：spawn（| |{…}）

。额外线程的使用也提供了一定程度的隔离；如果线程展开，服务器作为一个整体不会死亡（但是请记住，在展开时内存不足或析构函数死机将导致整个服务器死亡）。

简单TCP echo服务器

#！[专题（阶段）]
#[阶段（插件、链接）]外部板条箱日志；
外部板条箱绿色；
外部板条箱；
使用std：：io；
使用std：：os；
使用std:：io:：{Listener，Acceptor，TcpStream}；
//这是绿色线程。如果删除，将为每个客户端生成1个OS线程。
#[开始]
fn开始（argc:int，argv:*常数*常数u8）->int{
绿色：：开始（argc、argv、rustuv：：事件\u循环，主）
}
fn main（）{
让host=“127.0.0.1”；
设端口=8080；
让sock=io:：TcpListener:：bind（主机，端口）.unwrap（）；
让mut acceptor=sock.listen（）；
对于acceptor.incoming（）中的流{
匹配流{
Err（e）=>warn！（“接受Err{}”，e），
Ok（流）=>{
繁殖（proc（）{
调试！（“{}”，句柄_客户端（流））；
})
}
}
}
}
fn handle_客户端（多数据流：io:：TcpStream）->io:：IoResult{
信息！（“新客户端{}”，stream.peer_name（））；
设mut buf=[0u8，…4096]；
环路{
让get=try！（stream.read（buf））；
如果get==0{
//可能吗？还是会引发IoError？
打破
}
试试！（stream.write（buf.slice（0，got））；
}
好（（））
}

@rags:你应该回答that@rags当前位置实际上，我决定为Rust 0.7进行修复，并亲自发布。如果您愿意，请随意回答，我将删除我的副本。你的要点也需要更新。请看，这段代码不再编译了，你能更新它吗？（我会的，但我不知道如何生成任务）@JeroenBollen:updated。它在master上也不再编译了。我估计TcpListener已经迁移到std:：net了，但看起来生成和流写入的过程也发生了变化well@wump：已更新。这不再有效-请参阅我的评论了解原因。

#![feature(phase)]
#[phase(plugin, link)] extern crate log;
extern crate green;
extern crate rustuv;

use std::io;
use std::os;
use std::io::{Listener,Acceptor,TcpStream};

// This is for green threads. If removed, will spawn 1 OS thread per client.
#[start]
fn start(argc: int, argv: *const *const u8) -> int {
    green::start(argc, argv, rustuv::event_loop, main)
}


fn main() {
    let host = "127.0.0.1";
    let port = 8080;

    let sock = io::TcpListener::bind(host, port).unwrap();
    let mut acceptor = sock.listen();
    for stream in acceptor.incoming() {
        match stream {
            Err(e) => warn!("Accept err {}", e),
            Ok(stream) => {
                spawn(proc() {
                    debug!("{}", handle_client(stream));
                })
            }
        }
    }
}

fn handle_client(mut stream: io::TcpStream) -> io::IoResult<()> {
    info!("New client {}", stream.peer_name());
    let mut buf = [0u8, ..4096];
    loop {
        let got = try!(stream.read(buf));
        if got == 0 {
            // Is it possible? Or IoError will be raised anyway?
            break
        }
        try!(stream.write(buf.slice(0, got)));
    }
    Ok(())
}