Struct kvarn_fastcgi_client::client::Client

pub struct Client<S, M> { /* private fields */ }

Async client for handling communication between fastcgi server.

Implementations

impl<S: AsyncRead + AsyncWrite + Unpin + Send> Client<S, ShortConn>

pub fn new(stream: S) -> Self

Construct a Client Object with stream, such as tokio::net::TcpStream or tokio::net::UnixStream, under short connection mode.

pub async fn execute_once<I: AsyncRead + Unpin + Send>( self, request: Request<'_, I> ) -> ClientResult<Response>

Send request and receive response from fastcgi server, under short connection mode.

pub async fn execute_once_stream<'a, I: AsyncRead + Unpin + Send>( self, request: Request<'_, I> ) -> ClientResult<ResponseStream<S>>

Send request and receive response stream from fastcgi server, under short connection mode.

Examples

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

async fn stream() {
    let stream = TcpStream::connect(("127.0.0.1", 9000)).await.unwrap();
    let client = Client::new(stream);
    let mut stream = client
        .execute_once_stream(Request::new(Params::default(), &mut io::empty()))
        .await
        .unwrap();

    while let Some(content) = stream.next().await {
        let content = content.unwrap();

        match content {
            Content::Stdout(out) => todo!(),
            Content::Stderr(out) => todo!(),
        }
    }
}

impl<S: AsyncRead + AsyncWrite + Unpin + Send> Client<S, KeepAlive>

pub fn new_keep_alive(stream: S) -> Self

Construct a Client Object with stream, such as tokio::net::TcpStream or tokio::net::UnixStream, under keep alive connection mode.

pub async fn execute<I: AsyncRead + Unpin + Send>( &mut self, request: Request<'_, I> ) -> ClientResult<Response>

Send request and receive response from fastcgi server, under keep alive connection mode.

pub async fn execute_stream<I: AsyncRead + Unpin + Send>( &mut self, request: Request<'_, I> ) -> ClientResult<ResponseStream<&mut S>>

Send request and receive response stream from fastcgi server, under keep alive connection mode.

Examples

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

async fn stream() {
    let stream = TcpStream::connect(("127.0.0.1", 9000)).await.unwrap();
    let mut client = Client::new_keep_alive(stream);

    for _ in (0..3) {
        let mut stream = client
            .execute_stream(Request::new(Params::default(), &mut io::empty()))
            .await
            .unwrap();

        while let Some(content) = stream.next().await {
            let content = content.unwrap();

            match content {
                Content::Stdout(out) => todo!(),
                Content::Stderr(out) => todo!(),
            }
        }
    }
}