ipc_patterns.rs

use std::io::Result;
use std::thread;
use std::time::Duration;
use tempfile::tempdir;
/// IPC Usage Patterns Examples
///
/// This file demonstrates the practical differences between the two IPC
/// server patterns: static handler vs instance handler.
use pcap_parser::ipc::*;

#[tokio::main]
async fn main() -> Result<()> {
    println!("IPC Patterns Comparison");
    println!("==========================\n");

    // Example 1: Simple server with static handler
    simple_server_example().await?;

    // Example 2: Optimized server with instance handler
    optimized_server_example().await?;

    // Performance comparison
    performance_comparison().await?;

    Ok(())
}

/// Example 1: Simple IPC Server (Static Handler Pattern)
///
/// Use this pattern when:
/// - Building prototypes or simple tools
/// - Message frequency is low (< 100 messages/second)
/// - Simplicity is more important than performance
/// - You don't need to process message payloads
async fn simple_server_example() -> Result<()> {
    println!("Simple Server (Static Handler)");
    println!("Use case: Prototype, simple tool, low message frequency");

    let temp_dir = tempdir()?;
    let socket_path = temp_dir.path().join("simple.sock");

    // Server setup - properly handle one client connection
    let server_path = socket_path.clone();
    let client_path = socket_path.clone();

    let server_handle = thread::spawn(move || -> Result<()> {
        let mut server = ZeroCopyIpcServer::bind(&server_path)?;
        println!("Simple server started");

        // Accept exactly one connection for demo
        if let Ok(mut client_stream) = server.accept_one() {
            println!("Client connected to simple server");

            // Handle the client using static method
            if let Err(e) = ZeroCopyIpcServer::handle_client_static(&mut client_stream) {
                eprintln!("Client handling error: {}", e);
            }
        }

        Ok(())
    });

    // Give server time to start
    thread::sleep(Duration::from_millis(100));

    // Client interaction
    let client_handle = tokio::spawn(async move {
        match AsyncIpcClient::connect(&client_path).await {
            Ok(mut client) => match client.send_message(1, b"Hello simple server").await {
                Ok(response) => {
                    println!(
                        "Simple server response: {:?}",
                        String::from_utf8_lossy(&response)
                    );
                    println!("Simple server communication works");
                }
                Err(e) => println!("Client communication error: {}", e),
            },
            Err(e) => println!("Could not connect to simple server: {}", e),
        }
    });

    // Wait for both server and client
    let _ = client_handle.await;
    server_handle.join().unwrap()?;

    println!("  Memory usage: Creates new 64KB buffer per response");
    println!("  Payload handling: Ignores message content");

    Ok(())
}

/// Example 2: Optimized IPC Server (Instance Handler Pattern)
///
/// Use this pattern when:
/// - Building production systems
/// - High message frequency (> 1000 messages/second)
/// - Memory efficiency is important
/// - You need to process message payloads
/// - Performance is critical
async fn optimized_server_example() -> Result<()> {
    println!("Optimized Server (Instance Handler)");
    println!("Use case: Production system, high throughput, payload processing");

    let temp_dir = tempdir()?;
    let socket_path = temp_dir.path().join("optimized.sock");

    // Server setup - shows the optimized approach
    let server_path = socket_path.clone();
    let client_path = socket_path.clone();

    let server_handle = thread::spawn(move || -> Result<()> {
        let mut server = ZeroCopyIpcServer::bind(&server_path)?;
        println!("Optimized server created with reusable codec");

        // Accept exactly one connection for demo
        if let Ok(mut client_stream) = server.accept_one() {
            println!("Client connected to optimized server");

            // Handle the client using instance method (optimized)
            if let Err(e) = server.handle_client(&mut client_stream) {
                eprintln!("Client handling error: {}", e);
            }
        }

        Ok(())
    });

    // Give server time to start
    thread::sleep(Duration::from_millis(100));

    // Client interaction
    let client_handle = tokio::spawn(async move {
        match AsyncIpcClient::connect(&client_path).await {
            Ok(mut client) => match client.send_message(2, b"Data for processing").await {
                Ok(response) => {
                    println!(
                        "Optimized server response: {:?}",
                        String::from_utf8_lossy(&response)
                    );
                    println!("Optimized server communication works");
                }
                Err(e) => println!("Client communication error: {}", e),
            },
            Err(e) => println!("Could not connect to optimized server: {}", e),
        }
    });

    // Wait for both server and client
    let _ = client_handle.await;
    server_handle.join().unwrap()?;

    println!("  Memory usage: Reuses single 64KB buffer for all responses");
    println!("  Payload handling: Processes message content with process_message()");
    println!("  Complexity: Medium (requires mutable server reference)\n");

    Ok(())
}

/// Example 3: Performance Comparison
///
/// shows the memory allocation differences between the patterns
async fn performance_comparison() -> Result<()> {
    println!("Performance Comparison");

    // Simulate codec usage patterns
    println!("\nSimulating 1000 message responses...");

    // Pattern 1: Static handler approach (inefficient)
    println!("\nStatic Handler Pattern:");
    let start_time = std::time::Instant::now();
    let mut total_allocations = 0;

    for i in 0..1000 {
        // Each response creates a new codec (64KB allocation)
        let mut codec = IpcCodec::new();
        let header = IpcHeader {
            msg_type: 1000 + i,
            payload_len: 8,
            seq_num: i as u64,
            timestamp: 1640995200000000,
        };
        let _response = codec.encode(&header, b"response");
        total_allocations += 64 * 1024; // 64KB per codec
    }
    let static_duration = start_time.elapsed();

    println!("  Time: {:?}", static_duration);
    println!(
        "  Memory allocated: ~{}MB",
        total_allocations / (1024 * 1024)
    );
    println!("  Allocations: 1000 separate 64KB buffers");

    // Pattern 2: Instance handler approach (efficient)
    println!("\nInstance Handler Pattern:");
    let start_time = std::time::Instant::now();
    let mut codec = IpcCodec::new(); // Single codec instance
    let single_allocation = 64 * 1024; // Only one 64KB allocation

    for i in 0..1000 {
        // Each response reuses the same codec buffer
        let header = IpcHeader {
            msg_type: 1000 + i,
            payload_len: 8,
            seq_num: i as u64,
            timestamp: 1640995200000000,
        };
        let _response = codec.encode(&header, b"ACK_OK  ");
        // Buffer is reused via encode_buf.clear() - no new allocations!
    }
    let instance_duration = start_time.elapsed();

    println!("  Time: {:?}", instance_duration);
    println!("  Memory allocated: ~{}KB", single_allocation / 1024);
    println!("  Allocations: 1 reusable 64KB buffer");

    // Performance summary
    let memory_savings =
        ((total_allocations - single_allocation) as f64 / total_allocations as f64) * 100.0;
    let speed_improvement = static_duration.as_nanos() as f64 / instance_duration.as_nanos() as f64;

    println!("\nPerformance Impact:");
    println!("  Memory savings: {:.1}%", memory_savings);
    println!("  Speed improvement: {:.1}x faster", speed_improvement);

    Ok(())
}

/// Helper fn showing how to extend the server patterns
#[allow(dead_code)]
async fn custom_server_implementation() -> Result<()> {
    let temp_dir = tempdir()?;
    let socket_path = temp_dir.path().join("custom.sock");

    let _server = ZeroCopyIpcServer::bind(&socket_path)?;

    // Custom connection handling loop
    // (In real code, this would run indefinitely)
    /*
    loop {
        for stream in server.listener.incoming() {
            match stream {
                Ok(mut client) => {
                    // Use the optimized handler with payload processing
                    if let Err(e) = server.handle_client(&mut client) {
                        eprintln!("Client handling error: {}", e);
                    }
                }
                Err(e) => {
                    eprintln!("Accept error: {}", e);
                    break;
                }
            }
        }
    }
    */

    println!("Custom server implementation ready");
    Ok(())
}