Function start

client/src/ping.rs:20–61

(port: u16)

}

pub async fn start(port: u16) -> Result<mpsc::Sender<()>> {
    // Create a channel for stop signal
    let (stop_tx, mut stop_rx) = mpsc::channel(1);

    let tcp_addr = format!("localhost:{}", port);

    // Spawn TCP ponger in a non-blocking task
    tokio::spawn(async move {
        debug!("Starting TCP ponger on {}", tcp_addr);
        match TcpListener::bind(&tcp_addr).await {
            Ok(acceptor) => {
                tokio::spawn(async move {
                    loop {
                        tokio::select! {
                            _ = stop_rx.recv() => {
                                debug!("TCP ponger received stop signal");
                                break;
                            }
                            accept_result = acceptor.accept() => {
                                match accept_result {
                                    Ok((client, addr)) => {
                                        debug!("TCP client connected from {}", addr);
                                        tokio::spawn(pong_tcp(client));
                                    }
                                    Err(e) => {
                                        error!("Failed to accept TCP connection: {}", e);
                                        break;
                                    }
                                }
                            }
                        }
                    }
                });
            }
            Err(e) => {
                error!("Failed to bind TCP ponger to {}: {}", tcp_addr, e);
            }
        }
    });

    Ok(stop_tx)
}

pub async fn publish(command_tx: mpsc::Sender<Message>) -> Result<()> {
    let port = find_free_tcp_port()