web-dev-qa-db-fra.com

Exemple TCP serveur écrit en Rust

Je cherche un exemple de serveur TCP dans Rust.

Soit un "monde bonjour" soit un serveur d'écho serait formidable.

tcprust
37
fadedbee

Voici un exemple très simple utilisant std::net. Il a été développé contre le maître actuel de Rust et devrait également fonctionner sur 1. *.

Soyez prudent avec cet exemple; c'est simplifié; vous ne voudrez peut-être pas qu'il panique si la liaison, l'écoute ou l'acceptation produisent une erreur.

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

Notez le paradigme en ce qui concerne l'acceptation; vous devez lancer vous-même la demande accept() (dans cet exemple, nous utilisons l'itérateur incoming() qui appelle simplement accept() à chaque fois), et ainsi vous obtenez - réel contrôle des tâches qui existent.

En conséquence, j'ai mis le code de gestion de flux réel dans un thread séparé, mais il n'est pas nécessaire qu'il s'agisse de demandes très courtes (cela signifie simplement que vous ne seriez pas en mesure de traiter une deuxième demande lors de la gestion de la première); vous pouvez tout aussi bien supprimer la thread::spawn(|| { ... }) de ces deux lignes. L'utilisation de fils supplémentaires donne également un certain degré d'isolement; si le thread se déroule, le serveur dans son ensemble ne mourra pas (gardez à l'esprit, cependant, que le fait de manquer de mémoire ou d'avoir une panique destructrice pendant le déroulement entraînera la mort de tout le serveur).

45
Chris Morgan

Simple TCP echo-server https://Gist.github.com/seriyps/fd6d29442e16c44ba4

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