pingora_plain_l4.rs

use async_trait::async_trait;
use pingora_core::server::Server;
use pingora_core::services::listening::Service;
use pingora_core::upstreams::peer::HttpPeer; // Note: L4 usually doesn't need this
use tokio::net::TcpStream;
use pingora_core::Result;
use pingora_core::modules::Module;

// 1. Define the L4 Proxy Service
pub struct L4Proxy {
    backend_addr: String,
}

#[async_trait]
impl Service for L4Proxy {
    async fn handle_connection(&self, downstream_stream: tokio::net::TcpStream) {
        // 2. Connect to the backend
        let mut upstream_stream = match TcpStream::connect(&self.backend_addr).await {
            Ok(stream) => stream,
            Err(e) => {
                eprintln!("Failed to connect to backend: {}", e);
                return;
            }
        };

        // 3. Passthrough: Copy bytes between downstream and upstream
        let (mut client_reader, mut client_writer) = downstream_stream.into_split();
        let (mut server_reader, mut server_writer) = upstream_stream.into_split();

        let client_to_server = tokio::io::copy(&mut client_reader, &mut server_writer);
        let server_to_client = tokio::io::copy(&mut server_reader, &mut client_writer);

        // Run both directions concurrently
        let _ = tokio::try_join!(client_to_server, server_to_client);
    }
}

fn main() {
    let mut my_server = Server::new(None).unwrap();
    my_server.bootstrap();

    // 4. Configure the service to listen
    let mut l4_service = L4Proxy {
        backend_addr: "127.0.0.1:8080".to_string(),
    };
    
    // Example: listen on 0.0.0.0:6188
    // l4_service.add_tcp("0.0.0.0:6188"); 

    // Note: The above Service trait implementation needs to be 
    // wrapped in a running service in a real Pingora application.
    
    // my_server.add_service(l4_service);
    // my_server.run_forever();
}