Máy chủ TCP ví dụ được viết bằng Rust

Question

Tôi đang tìm một ví dụ về máy chủ TCP trong Rust.

Hoặc là 'thế giới hello' hoặc máy chủ echo sẽ tuyệt vời.

Answer 1

Dưới đây là một ví dụ rất đơn giản sử dụng std::net. Nó được phát triển chống lại chủ nhân hiện tại của Rust và cũng nên làm việc trên 1. *.

Hãy cẩn thận với ví dụ này; nó được đơn giản hóa; bạn có thể không muốn nó hoảng loạn nếu ràng buộc, nghe hoặc chấp nhận tạo ra một lỗi.

use std::io::Write; 
use std::net::TcpListener; 
use std::thread; 

fn main() { 
    let listener = TcpListener::bind("127.0.0.1:9123").unwrap(); 
    println!("listening started, ready to accept"); 
    for stream in listener.incoming() { 
     thread::spawn(|| { 
      let mut stream = stream.unwrap(); 
      stream.write(b"Hello World\r\n").unwrap(); 
     }); 
    } 
} 

Lưu ý mô hình liên quan đến việc chấp nhận; bạn phải tự mình thực hiện yêu cầu accept() (trong ví dụ này, chúng tôi đang sử dụng trình biến đổi incoming() chỉ gọi accept() mỗi lần) và do đó bạn sẽ có được thực sự kiểm soát những tác vụ có.

Do đó, tôi đã đặt mã xử lý luồng thực vào một chuỗi riêng biệt, nhưng không cần cho các yêu cầu rất ngắn (nó chỉ có nghĩa là bạn không thể xử lý yêu cầu thứ hai trong khi xử lý Đầu tiên); bạn cũng có thể xóa thread::spawn(|| { ... }) về hai dòng đó. Việc sử dụng các chủ đề bổ sung cũng đưa ra một mức độ cô lập nhất định; nếu thread thư giãn, máy chủ nói chung sẽ không chết (nhớ rằng, tuy nhiên, việc hết bộ nhớ hoặc có một sự hoảng sợ phá hoại trong khi thư giãn sẽ khiến toàn bộ máy chủ bị chết).

Answer 2

TCP đơn giản vang-server https://gist.github.com/seriyps/fd6d29442e16c44ba400

#![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(()) 
}