tcp-std 0.1.0

Standard, blocking I/O handler for tcp-lib
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

use std::{
    io::{stderr, Read as _},
    net::{SocketAddr, TcpListener},
    thread::{self, JoinHandle},
};

use tcp_lib::write;
use tcp_std::Handler;
use tracing::{info, level_filters::LevelFilter};
use tracing_subscriber::{fmt, layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};

fn main() {
    info!("init logger and TCP server");
    init_logger();
    let (addr, server) = init_server();

    info!("init TCP I/O handler");
    let mut handler = Handler::try_from(addr).unwrap();

    info!("write bytes into TCP stream using Write flow");
    let mut flow = write::Flow::new(b"Lorem ipsum dolor sit amet.".to_vec());

    loop {
        match flow.next() {
            Err(write::Io::Write) => handler.write(&mut flow).unwrap(),
            Ok(_) => break,
        }
    }

    server.join().unwrap();
}

fn init_logger() {
    let layer = fmt::layer().with_writer(stderr);
    let filter = EnvFilter::builder()
        .with_default_directive(LevelFilter::DEBUG.into())
        .from_env_lossy();

    tracing_subscriber::registry()
        .with(layer)
        .with(filter)
        .init();
}

fn init_server() -> (SocketAddr, JoinHandle<()>) {
    let listener = TcpListener::bind("127.0.0.1:0").unwrap();
    let addr = listener.local_addr().unwrap();
    let host = addr.ip();
    let port = addr.port();

    info!(?host, port, "spawn TCP server");

    let handle = thread::spawn(move || {
        let (mut stream, _) = listener.accept().unwrap();
        let mut buf = [0; 512];
        let n = stream.read(&mut buf).unwrap();
        info!("written bytes: {:?}", String::from_utf8_lossy(&buf[..n]));
    });

    (addr, handle)
}