Struct ClientConnection 

pub struct ClientConnection<IO> { /* private fields */ }

Available on crate features icap and std only.

A sequential ICAP client over an established byte stream.

Create a streaming request with ClientConnection::start. A connection is reusable only after the returned response body reaches its terminal chunk. Dropping a transaction early leaves it poisoned so a later request cannot accidentally reuse desynchronized framing.

Implementations

impl<IO> ClientConnection<IO>

where IO: Io + Unpin + ExtensionsRef,

pub async fn send_http( &mut self, request: ClientRequest, ) -> Result<ClientResponse<'_, IO>, Error>

Send a typed HTTP adaptation request with the default head parser.

The HTTP entity body remains streaming. While its next frame is pending, the connection monitors for an early ICAP response as required by the ICAP errata. Cancelling this operation leaves the connection non-reusable.

pub async fn send_http_with( &mut self, request: ClientRequest, parser: HeadParser, ) -> Result<ClientResponse<'_, IO>, Error>

Send a typed HTTP adaptation request with explicit parser bounds.

pub async fn send_http_owned( self, request: ClientRequest, ) -> Result<OwnedClientResponse<IO>, Error>

Consume this connection and send one owned HTTP adaptation request.

The returned response owns the connection, so it can be moved into a Rama HTTP body or across a service boundary without a task or channel.

pub async fn send_http_owned_with( self, request: ClientRequest, parser: HeadParser, ) -> Result<OwnedClientResponse<IO>, Error>

Consume this connection and send one owned HTTP adaptation request with explicit parser bounds.

impl<IO> ClientConnection<IO>

where IO: Io + Unpin + ExtensionsRef,

pub fn new(io: IO) -> ClientConnection<IO>

Wrap an established stream with default connection options.

Bare streams can use rama_core::ServiceInput to supply the Rama connection extension store required by this protocol wrapper.

pub fn with_options(io: IO, options: ConnectionOptions) -> ClientConnection<IO>

Wrap an established stream with explicit bounds and parser policy.

The connection retains the extension store supplied by io.

pub fn is_reusable(&self) -> bool

Return whether another transaction may safely start.

pub const fn options(&self) -> &ConnectionOptions

Return the connection bounds and parser policy.

pub fn into_inner(self) -> IO

Recover the underlying stream.

Any bytes read ahead by the ICAP decoder are discarded. Use into_parts to retain them.

pub fn into_parts(self) -> (IO, Bytes)

Recover the underlying stream and bytes read ahead by the decoder.

impl<IO> ClientConnection<IO>

where IO: Io + Unpin + ExtensionsRef,

pub async fn start( &mut self, request: Request, ) -> Result<ClientTransaction<'_, IO>, Error>

Start sending one ICAP request.

Trait Implementations

impl<IO> ExtensionsRef for ClientConnection<IO>

fn extensions(&self) -> &Extensions

Get reference to the underlying Extensions store