rspc/examples/tcp.rs

use futures::{stream::FuturesUnordered, StreamExt};
use rspc_dev_utilities::test_data::{
    dur_to_str, make_test_data, TestData, TestDataClient, TestDataServer, TestEnum, DATASIZE,
};
use tokio::join;

use rspc::transport::serde::{TcpClient, TcpServer};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let data: TestData = make_test_data(DATASIZE);
    let mut server = TestDataServer::from(data);
    let t = TcpServer::new(&"127.0.0.1:6543").await.unwrap();
    let srv_thread = tokio::spawn(async move { server.listen(t).await });

    tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;

    let t = TcpClient::connect("127.0.0.1:6543").await.unwrap();
    let client = t.spawn().await;
    let client = TestDataClient::new(client);

    let start_time = std::time::Instant::now();

    let job1 = async {
        let now = std::time::Instant::now();
        assert_eq!(267914296, client.fib(42).await.unwrap());
        println!("fib1: {}", dur_to_str(now.elapsed()));
    };

    let job2 = async {
        let now = std::time::Instant::now();
        assert_eq!(4, client.calc().await.unwrap().unwrap_or(0));
        println!("calc: {}", dur_to_str(now.elapsed()));

        let cdat = make_test_data(DATASIZE);
        let now = std::time::Instant::now();
        assert_eq!(8, client.calc_add(cdat).await.unwrap().unwrap_or(0));
        println!("calc_add: {}", dur_to_str(now.elapsed()));

        let now = std::time::Instant::now();
        assert_eq!(267914296, client.fib(42).await.unwrap());
        println!("fib2: {}", dur_to_str(now.elapsed()));

        let now = std::time::Instant::now();
        assert_eq!(DATASIZE, client.len().await.unwrap());
        println!("len: {}", dur_to_str(now.elapsed()));

        let now = std::time::Instant::now();
        client.push((false, TestEnum::NoValue)).await.unwrap();
        println!("push: {}", dur_to_str(now.elapsed()));

        let now = std::time::Instant::now();
        assert_eq!(DATASIZE + 1, client.len().await.unwrap());
        println!("len: {}", dur_to_str(now.elapsed()));
    };

    join!(job1, job2);

    let now = std::time::Instant::now();
    {
        let set = FuturesUnordered::new();
        for _ in 0..128 {
            set.push(async {
                for _ in 0..100000 {
                    client.calc().await.unwrap();
                }
            });
        }
        let _: Vec<_> = set.collect().await;
    }
    println!("benchmark: {}", dur_to_str(now.elapsed()));

    println!("total: {}", dur_to_str(start_time.elapsed()));

    client.stop().await.unwrap();

    // todo : server stop
    srv_thread.await;

    Ok(())
}