Crate fastcgi_client 

fastcgi-client-rs

Fastcgi client implemented for Rust with optional runtime support for tokio and smol.

Installation

Choose one or both runtime features explicitly:

Tokio:

cargo add fastcgi-client --features runtime-tokio
cargo add tokio --features full

Smol:

cargo add fastcgi-client --features runtime-smol
cargo add smol

Both runtimes:

cargo add fastcgi-client --features runtime-tokio,runtime-smol
cargo add tokio --features full
cargo add smol

Examples

Tokio short connection mode:

use fastcgi_client::{io, Client, Params, Request};
use std::env;
use tokio::net::TcpStream;

    let script_filename = env::current_dir()
        .unwrap()
        .join("tests")
        .join("php")
        .join("index.php");
    let script_filename = script_filename.to_str().unwrap();
    let script_name = "/index.php";

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

    // Fastcgi params, please reference to nginx-php-fpm config.
    let params = Params::default()
        .request_method("GET")
        .script_name(script_name)
        .script_filename(script_filename)
        .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("jmjoy-pc")
        .content_type("")
        .content_length(0);

    // Fetch fastcgi server(php-fpm) response.
    let output = client.execute_once(Request::new(params, io::empty())).await.unwrap();

    // "Content-type: text/html; charset=UTF-8\r\n\r\nhello"
    let stdout = String::from_utf8(output.stdout.unwrap()).unwrap();

    assert!(stdout.contains("Content-type: text/html; charset=UTF-8"));
    assert!(stdout.contains("hello"));
    assert_eq!(output.stderr, None);
}

Tokio keep alive mode:

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

    // Connect to php-fpm default listening address.
    let stream = TcpStream::connect(("127.0.0.1", 9000)).await.unwrap();
    let mut client = Client::new_keep_alive_tokio(stream);

    // Fastcgi params, please reference to nginx-php-fpm config.
    let params = Params::default();

    for _ in (0..3) {
        // Fetch fastcgi server(php-fpm) response.
        let output = client.execute(Request::new(params.clone(), io::empty())).await.unwrap();

        // "Content-type: text/html; charset=UTF-8\r\n\r\nhello"
        let stdout = String::from_utf8(output.stdout.unwrap()).unwrap();

        assert!(stdout.contains("Content-type: text/html; charset=UTF-8"));
        assert!(stdout.contains("hello"));
        assert_eq!(output.stderr, None);
    }
}

Smol short connection mode:

use fastcgi_client::{io, Client, Params, Request};
use std::env;
use smol::net::TcpStream;

    let script_filename = env::current_dir()
        .unwrap()
        .join("tests")
        .join("php")
        .join("index.php");
    let script_filename = script_filename.to_str().unwrap();
    let script_name = "/index.php";

    let stream = TcpStream::connect(("127.0.0.1", 9000)).await.unwrap();
    let client = Client::new_smol(stream);

    let params = Params::default()
        .request_method("GET")
        .script_name(script_name)
        .script_filename(script_filename)
        .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("jmjoy-pc")
        .content_type("")
        .content_length(0);

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

    let stdout = String::from_utf8(output.stdout.unwrap()).unwrap();

    assert!(stdout.contains("Content-type: text/html; charset=UTF-8"));
    assert!(stdout.contains("hello"));
    assert_eq!(output.stderr, None);
}

Smol keep alive mode:

use fastcgi_client::{io, Client, Params, Request};
use smol::net::TcpStream;

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

    let params = Params::default();

    for _ in (0..3) {
        let output = client.execute(Request::new(params.clone(), io::empty())).await.unwrap();

        let stdout = String::from_utf8(output.stdout.unwrap()).unwrap();

        assert!(stdout.contains("Content-type: text/html; charset=UTF-8"));
        assert!(stdout.contains("hello"));
        assert_eq!(output.stderr, None);
    }
}

Optional HTTP conversions

Enable the http feature if you want to convert between this crate’s FastCGI types and the http crate.

fastcgi-client = { version = "0.10", features = ["http", "runtime-tokio"] }

The conversion boundary is intentionally split in two:

• Request<'a, I> can convert into http::Request<I> without buffering the body.
• http::Request<I> can convert back into FastCGI metadata, but CGI-only params such as SCRIPT_FILENAME must be supplied explicitly through extra Params.
• Response can be parsed into http::Response<Vec<u8>>; stderr remains available only on the original FastCGI response.

License

Apache-2.0.

Re-exports

pub use crate::client::Client;

pub use crate::params::Params;

pub use crate::request::Request;

pub use crate::response::Response;

Modules

client

FastCGI client implementation for async communication with FastCGI servers.

conn

Connection mode definitions for FastCGI clients.

io

Runtime-neutral async I/O facade used by the FastCGI client.

params

FastCGI parameters builder and container.

request

FastCGI request structure and builders.

response

FastCGI response types and streaming support.

Enums

ClientError

Error types that can occur during FastCGI communication.

HttpConversionErrorhttp

Error types that can occur while converting between FastCGI and HTTP types.

Traits

StreamExt

Re Export StreamExt for .next support An extension trait for Streams that provides a variety of convenient combinator functions.

Type Aliases

ClientResult

Result type alias for FastCGI client operations.

HttpConversionResulthttp

Result type alias for HTTP/FastCGI conversion operations.