Struct kvarn_fastcgi_client::client::Client
source · pub struct Client<S, M> { /* private fields */ }
Expand description
Async client for handling communication between fastcgi server.
Implementations§
source§impl<S: AsyncRead + AsyncWrite + Unpin + Send> Client<S, ShortConn>
impl<S: AsyncRead + AsyncWrite + Unpin + Send> Client<S, ShortConn>
sourcepub fn new(stream: S) -> Self
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.
sourcepub async fn execute_once<I: AsyncRead + Unpin + Send>(
self,
request: Request<'_, I>
) -> ClientResult<Response>
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.
sourcepub async fn execute_once_stream<'a, I: AsyncRead + Unpin + Send>(
self,
request: Request<'_, I>
) -> ClientResult<ResponseStream<S>>
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!(),
}
}
}
source§impl<S: AsyncRead + AsyncWrite + Unpin + Send> Client<S, KeepAlive>
impl<S: AsyncRead + AsyncWrite + Unpin + Send> Client<S, KeepAlive>
sourcepub fn new_keep_alive(stream: S) -> Self
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.
sourcepub async fn execute<I: AsyncRead + Unpin + Send>(
&mut self,
request: Request<'_, I>
) -> ClientResult<Response>
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.
sourcepub async fn execute_stream<I: AsyncRead + Unpin + Send>(
&mut self,
request: Request<'_, I>
) -> ClientResult<ResponseStream<&mut S>>
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!(),
}
}
}
}
Auto Trait Implementations§
impl<S, M> RefUnwindSafe for Client<S, M>where
M: RefUnwindSafe,
S: RefUnwindSafe,
impl<S, M> Send for Client<S, M>
impl<S, M> Sync for Client<S, M>
impl<S, M> Unpin for Client<S, M>
impl<S, M> UnwindSafe for Client<S, M>where
M: UnwindSafe,
S: UnwindSafe,
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more