smux_rust 0.2.1

//! 异步基本使用示例
//!
//! 这个示例展示了如何在异步环境中使用 smux_rust

use smux_rust::{client, server};
use tokio::net::{TcpListener, TcpStream};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 启动服务器
    let server_handle = tokio::spawn(async {
        server_example().await.unwrap();
    });

    // 等待服务器启动
    tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;

    // 运行客户端
    client_example().await?;

    // 等待服务器完成
    server_handle.await.unwrap();

    Ok(())
}

async fn server_example() -> Result<(), Box<dyn std::error::Error>> {
    let listener = TcpListener::bind("127.0.0.1:8080").await?;
    println!("服务器监听在 127.0.0.1:8080");

    loop {
        match listener.accept().await {
            Ok((tcp_conn, _)) => {
                println!("接受新连接");
                
                // 创建服务器会话
                let session = server(Box::new(tcp_conn), None).await?;
                
                // 接受流
                match session.accept_stream().await {
                    Ok(mut stream) => {
                        println!("接受新流: {}", stream.id());
                        
                        // 读取数据
                        let mut buf = [0u8; 1024];
                        match stream.read(&mut buf).await {
                            Ok(n) => {
                                println!("收到数据: {}", String::from_utf8_lossy(&buf[..n]));
                                
                                // 发送响应
                                stream.write_all(b"Hello from server!").await?;
                            }
                            Err(e) => {
                                eprintln!("读取错误: {}", e);
                            }
                        }
                        
                        // 关闭流
                        stream.close().await?;
                    }
                    Err(e) => {
                        eprintln!("接受流错误: {}", e);
                    }
                }
                
                // 关闭会话
                session.close().await?;
            }
            Err(e) => {
                eprintln!("连接错误: {}", e);
            }
        }
    }
}

async fn client_example() -> Result<(), Box<dyn std::error::Error>> {
    println!("客户端连接到 127.0.0.1:8080");
    
    // 建立 TCP 连接
    let tcp_conn = TcpStream::connect("127.0.0.1:8080").await?;
    
    // 创建客户端会话
    let session = client(Box::new(tcp_conn), None).await?;
    println!("客户端会话已创建");
    
    // 打开新流
    let mut stream = session.open_stream().await?;
    println!("打开流: {}", stream.id());
    
    // 发送数据
    let message = b"Hello from client!";
    stream.write_all(message).await?;
    println!("发送数据: {}", String::from_utf8_lossy(message));
    
    // 读取响应
    let mut buf = [0u8; 1024];
    match stream.read(&mut buf).await {
        Ok(n) => {
            println!("收到响应: {}", String::from_utf8_lossy(&buf[..n]));
        }
        Err(e) => {
            eprintln!("读取错误: {}", e);
        }
    }
    
    // 关闭流
    stream.close().await?;
    println!("流已关闭");
    
    // 关闭会话
    session.close().await?;
    println!("会话已关闭");
    
    Ok(())
}