Talk FastCGI from async Rust. Any runtime. Or none.

use fastcgi_client::{Client, Params, Request, io};
use std::{error::Error, path::PathBuf};
use tokio::net::TcpStream;

#[tokio::main(flavor = "current_thread")]
async fn main() -> Result<(), Box<dyn Error>> {
    let document_root = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("tests")
        .join("php");
    let script_filename = document_root.join("index.php");
    let script_name = "/index.php";

    // php-fpm default listening address.
    let stream = TcpStream::connect(("127.0.0.1", 9000)).await?;
    let client = Client::new_tokio(stream);

    // FastCGI params mirror the CGI values nginx would send.
    let params = Params::default()
        .request_method("GET")
        .document_root(document_root.to_string_lossy().into_owned())
        .script_name(script_name)
        .script_filename(script_filename.to_string_lossy().into_owned())
        .request_uri(script_name)
        .document_uri(script_name)
        .remote_addr("127.0.0.1")
        .remote_port(12345)
        .server_addr("127.0.0.1")
        .server_port(80)
        .server_name("localhost")
        .content_type("")
        .content_length(0);

    let output = client
        .execute_once(Request::new(params, io::empty()))
        .await?;

    println!(
        "stdout:\n{}",
        String::from_utf8_lossy(&output.stdout.unwrap_or_default())
    );

    if let Some(stderr) = output.stderr {
        eprintln!("stderr:\n{}", String::from_utf8_lossy(&stderr));
    }

    Ok(())
}

use fastcgi_client::{Client, Params, Request, io};
use smol::net::TcpStream;
use std::{error::Error, path::PathBuf};

fn main() -> Result<(), Box<dyn Error>> {
    smol::block_on(async {
        let document_root = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
            .join("tests")
            .join("php");
        let script_filename = document_root.join("index.php");
        let script_name = "/index.php";

        let stream = TcpStream::connect(("127.0.0.1", 9000)).await?;
        let mut client = Client::new_keep_alive(stream);

        let params = Params::default()
            .request_method("GET")
            .document_root(document_root.to_string_lossy().into_owned())
            .script_name(script_name)
            .script_filename(script_filename.to_string_lossy().into_owned())
            .request_uri(script_name)
            .document_uri(script_name)
            .content_type("")
            .content_length(0);

        // The connection is reused across every iteration.
        for request_number in 1..=3 {
            let output = client
                .execute(Request::new(params.clone(), io::empty()))
                .await?;

            println!(
                "response #{request_number}:\n{}",
                String::from_utf8_lossy(&output.stdout.unwrap_or_default())
            );
        }

        Ok(())
    })
}

use fastcgi_client::{Client, Params, Request, io};
use futures_executor::block_on;

// `MockStream` is an in-memory duplex stream that implements only the
// futures-io traits — see tests/client_no_runtime.rs for the full source.
fn main() {
    let mut stream = MockStream::new(response_bytes());

    let output = block_on(async {
        let client = Client::new(&mut stream);
        let request = Request::new(
            Params::default()
                .request_method("GET")
                .script_name("/index.php"),
            io::Cursor::new(b"hello=world".to_vec()),
        );
        client.execute_once(request).await.unwrap()
    });

    assert_eq!(output.stderr, None);
    println!(
        "{}",
        String::from_utf8_lossy(&output.stdout.unwrap_or_default())
    );
}

use fastcgi_client::{Client, Params, Request, StreamExt, io, response::Content};
use tokio::net::TcpStream;

#[tokio::main(flavor = "current_thread")]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let stream = TcpStream::connect(("127.0.0.1", 9000)).await?;
    let client = Client::new_tokio(stream);

    let mut stream = client
        .execute_once_stream(Request::new(params, io::empty()))
        .await?;

    let mut stdout_chunks = 0usize;

    while let Some(content) = stream.next().await {
        match content? {
            Content::Stdout(out) => {
                stdout_chunks += 1;
                println!("stdout chunk #{stdout_chunks}: {} bytes", out.len());
            }
            Content::Stderr(err) => {
                eprintln!("stderr: {} bytes", err.len());
            }
        }
    }

    Ok(())
}