wireframe 0.3.0

Simplify building servers and clients for custom binary protocols.
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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

//! Tests for [`WireframeServer`] configuration.
#![cfg(not(loom))]

use wireframe::server::WireframeServer;
use wireframe_testing::{TestResult, factory, unused_listener};

#[test]
fn default_worker_count_matches_cpu_count() -> TestResult {
    let server = WireframeServer::new(factory());
    let expected = std::thread::available_parallelism().map_or(1, std::num::NonZeroUsize::get);
    if server.worker_count() != expected {
        return Err(format!(
            "worker count mismatch: actual={}, expected={}",
            server.worker_count(),
            expected
        )
        .into());
    }
    Ok(())
}

#[test]
fn default_workers_at_least_one() -> TestResult {
    let server = WireframeServer::new(factory());
    if server.worker_count() < 1 {
        return Err(format!("worker count below 1: {}", server.worker_count()).into());
    }
    Ok(())
}

#[test]
fn workers_method_enforces_minimum() -> TestResult {
    let server = WireframeServer::new(factory()).workers(0);
    if server.worker_count() != 1 {
        return Err(format!(
            "worker count should clamp to 1, got {}",
            server.worker_count()
        )
        .into());
    }
    Ok(())
}

#[test]
fn workers_accepts_large_values() -> TestResult {
    let server = WireframeServer::new(factory()).workers(128);
    if server.worker_count() != 128 {
        return Err(format!(
            "worker count should be 128 after config, got {}",
            server.worker_count()
        )
        .into());
    }
    Ok(())
}

/// Ensure dropping the readiness receiver logs a warning and does not
/// prevent the server from accepting connections.
#[tokio::test]
async fn readiness_receiver_dropped() -> TestResult {
    use tokio::{
        net::TcpStream,
        sync::oneshot,
        time::{Duration, sleep},
    };

    let listener = unused_listener()?;
    let server = WireframeServer::new(factory())
        .workers(1)
        .bind_existing_listener(listener)
        .expect("failed to bind existing listener");

    let addr = server.local_addr().expect("local addr missing");
    // Create channel and immediately drop receiver to force send failure
    let (tx_ready, rx_ready) = oneshot::channel();
    drop(rx_ready);

    tokio::spawn(async move {
        server
            .ready_signal(tx_ready)
            .run_with_shutdown(tokio::time::sleep(Duration::from_millis(200)))
            .await
            .expect("server run failed");
    });

    // Wait briefly to ensure server attempted to send readiness signal
    sleep(Duration::from_millis(100)).await;

    // Server should still accept connections
    let _stream = TcpStream::connect(addr).await.expect("connect failed");
    Ok(())
}