lightstream 0.4.4

Composable, zero-copy Arrow IPC and native data streaming for Rust with SIMD-aligned I/O, async support, and memory-mapping.
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

//! TCP Transport Example
//!
//! Demonstrates the Lightstream protocol over a TCP connection.
//! TCP is the simplest transport: bind, accept, connect.
//!
//! Run with:
//! ```sh
//! cargo run --example tcp_lightstream --features "protocol,tcp,msgpack"
//! ```

#[path = "../helpers/mod.rs"]
mod helpers;

use helpers::{recv_and_print_all, register_demo_types, send_demo_messages};
use lightstream::models::protocol::connection::TcpLightstreamConnection;
use tokio::net::TcpListener;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("TCP Transport Example");
    println!("=====================\n");

    let listener = TcpListener::bind("127.0.0.1:0").await?;
    let addr = listener.local_addr()?;
    println!("Listener bound to {}", addr);

    let server = tokio::spawn(async move {
        let (stream, peer) = listener.accept().await.unwrap();
        println!("Server accepted connection from {}", peer);

        let mut conn = TcpLightstreamConnection::from_tcp(stream);
        register_demo_types(&mut conn);
        recv_and_print_all(&mut conn).await;
        println!("Server connection closed.");
    });

    let client_stream = tokio::net::TcpStream::connect(addr).await?;
    println!("Client connected to {}", addr);

    let mut client = TcpLightstreamConnection::from_tcp(client_stream);
    register_demo_types(&mut client);
    send_demo_messages(&mut client, "tcp").await?;

    server.await?;
    println!("\nTCP transport example completed successfully!");
    Ok(())
}