net-io 0.6.0

Network IO substrate for Rust: TCP, UDP and local-socket listeners, connection lifecycle, limits, graceful drain, PROXY protocol, and a TLS seam. Protocol-free and dependency-free.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

//! A line echo written as a sans-IO session: net-io reads and writes, the session
//! only decides what to send.
//!
//! ```text
//! cargo run --example echo_sessions -- 127.0.0.1:7002
//! ```
//!
//! Each complete line comes back upper-cased. A line longer than the input
//! buffer closes the connection (`CloseReason::Limit`).

use std::time::Duration;

use net_io::{
    AllowAll, CloseReason, ConnectionInfo, Input, Limits, ListenerSpec, NetError, Phase,
    ServerBuilder, Session, SessionContext, Step,
};

struct Upper;

impl Session for Upper {
    fn on_data(&mut self, cx: &mut SessionContext<'_>, input: &mut Input) -> Step {
        let Some(end) = input.bytes().iter().position(|&b| b == b'\n') else {
            // Part of a line: keep reading under the read timeout and minimum rate.
            cx.set_phase(Phase::Receiving);
            return Step::Read;
        };
        let line = input.bytes()[..=end].to_ascii_uppercase();
        if cx.output().push(&line).is_err() {
            // Output full: flush first; net-io calls on_data again with the same input.
            return Step::Write;
        }
        input.consume(end + 1);
        // The exchange is over: wait for the next line under the idle timeout.
        cx.set_phase(Phase::Idle);
        Step::Write
    }

    fn on_close(&mut self, info: &ConnectionInfo, reason: CloseReason) {
        println!("{} from {} closed: {}", info.id, info.peer, reason.as_str());
    }
}

fn main() -> Result<(), NetError> {
    let addr = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "127.0.0.1:7002".to_string());
    let limits = Limits::builder()
        .idle_timeout(Duration::from_secs(30))
        .read_timeout(Duration::from_secs(10))
        .build()?;
    let server = ServerBuilder::new()
        .listener(ListenerSpec::tcp(addr.as_str()).name("echo"))
        .workers(16)
        .limits(limits)
        .sessions(|_: &ConnectionInfo| Upper)
        .gate(AllowAll)
        .build()?;
    server.open_door()?;
    for l in server.listeners() {
        println!("echo (sessions) listening on {}", l.local);
    }
    let report = server.wait_for_stop();
    println!("stopped: {report:?}");
    Ok(())
}