rama::net::client::pool

Struct LeasedConnection

pub struct LeasedConnection<C, ID>where
    C: ExtensionsRef,
{ /* private fields */ }

Available on crate feature net only.

Expand description

LeasedConnection is a connection that is temporarily leased from a pool

It will be returned to the pool once dropped if the user didn’t take ownership of the connection C with LeasedConnection::into_connection(). LeasedConnections are considered active pool connections until dropped or ownership is taken of the internal connection.

Implementations§

§

impl<C, ID> LeasedConnection<C, ID>
where C: ExtensionsRef, ID: ConnID,

pub fn rekey(&mut self, reuse: ConnectionReuse)

File this connection under new reuse requirements once it returns to the pool, such as an identity it authenticated after it was established.

Also publishes reuse on the connection. Pools otherwise keep the requirements the connection was added with.

§

impl<C, ID> LeasedConnection<C, ID>
where C: ExtensionsRef,

pub fn into_connection(self) -> C

Trait Implementations§

§

impl<C, ID> AsMut<C> for LeasedConnection<C, ID>
where C: ExtensionsRef,

§

fn as_mut(&mut self) -> &mut C

Converts this type into a mutable reference of the (usually inferred) input type.

§

impl<C, ID> AsRef<C> for LeasedConnection<C, ID>
where C: ExtensionsRef,

§

fn as_ref(&self) -> &C

Converts this type into a shared reference of the (usually inferred) input type.

§

impl<C, ID> AsyncRead for LeasedConnection<C, ID>
where C: AsyncRead + Unpin + ExtensionsRef, ID: Unpin,

§

fn poll_read( self: Pin<&mut LeasedConnection<C, ID>>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<(), Error>>

Attempts to read from the AsyncRead into buf. Read more

§

impl<C, ID> AsyncWrite for LeasedConnection<C, ID>
where C: AsyncWrite + Unpin + ExtensionsRef, ID: Unpin,

§

fn poll_write( self: Pin<&mut LeasedConnection<C, ID>>, cx: &mut Context<'_>, buf: &[u8], ) -> Poll<Result<usize, Error>>

Attempt to write bytes from buf into the object. Read more

§

fn poll_flush( self: Pin<&mut LeasedConnection<C, ID>>, cx: &mut Context<'_>, ) -> Poll<Result<(), Error>>

Attempts to flush the object, ensuring that any buffered data reach their destination. Read more

§

fn poll_shutdown( self: Pin<&mut LeasedConnection<C, ID>>, cx: &mut Context<'_>, ) -> Poll<Result<(), Error>>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down. Read more

§

fn is_write_vectored(&self) -> bool

Determines if this writer has an efficient poll_write_vectored implementation. Read more

§

fn poll_write_vectored( self: Pin<&mut LeasedConnection<C, ID>>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize, Error>>

Like poll_write, except that it writes from a slice of buffers. Read more

§

impl<C, ID> Debug for LeasedConnection<C, ID>
where C: Debug + ExtensionsRef, ID: Debug,

§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more

§

impl<C, ID> Deref for LeasedConnection<C, ID>
where C: ExtensionsRef,

§

type Target = C

The resulting type after dereferencing.

§

fn deref(&self) -> &<LeasedConnection<C, ID> as Deref>::Target

Dereferences the value.

§

impl<C, ID> DerefMut for LeasedConnection<C, ID>
where C: ExtensionsRef,

§

fn deref_mut(&mut self) -> &mut <LeasedConnection<C, ID> as Deref>::Target

Mutably dereferences the value.

§

impl<C, ID> Drop for LeasedConnection<C, ID>
where C: ExtensionsRef,

§

fn drop(&mut self)

Executes the destructor for this type. Read more

Source §

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned. Read more

§

impl<C, ID> ExtensionsRef for LeasedConnection<C, ID>
where C: ExtensionsRef,

§

fn extensions(&self) -> &Extensions

Get reference to the underlying Extensions store

§

impl<Input, C, ID> Service<Input> for LeasedConnection<C, ID>
where ID: Send + Sync + Debug + 'static, C: Service<Input> + ExtensionsRef, Input: ExtensionsMut + Send + 'static,

§

type Output = <C as Service<Input>>::Output

The type of the output returned by the service.

§

type Error = <C as Service<Input>>::Error

The type of error returned by the service.

§

async fn serve( &self, input: Input, ) -> Result<<LeasedConnection<C, ID> as Service<Input>>::Output, <LeasedConnection<C, ID> as Service<Input>>::Error>

Serve an output or an error for the given input

§

fn boxed(self) -> BoxService<Input, Self::Output, Self::Error>

Box this service to allow for dynamic dispatch.

§

impl<C, ID> Socket for LeasedConnection<C, ID>
where ID: Send + Sync + 'static, C: Socket + ExtensionsRef,

§

fn local_addr(&self) -> Result<SocketAddress, Error>

Try to get the local address of the socket.

§

fn peer_addr(&self) -> Result<SocketAddress, Error>

Try to get the remote address of the socket.

Auto Trait Implementations§

§

impl<C, ID> Send for LeasedConnection<C, ID>
where ManuallyDrop<PooledConnection<C, ID>>: Send, ConnReturner<C, ID>: Send,

§

impl<C, ID> Sync for LeasedConnection<C, ID>
where ManuallyDrop<PooledConnection<C, ID>>: Sync, ConnReturner<C, ID>: Sync,

§

impl<C, ID> Unpin for LeasedConnection<C, ID>
where ManuallyDrop<PooledConnection<C, ID>>: Unpin, ConnReturner<C, ID>: Unpin,

§

impl<C, ID> UnsafeUnpin for LeasedConnection<C, ID>
where ManuallyDrop<PooledConnection<C, ID>>: UnsafeUnpin, ConnReturner<C, ID>: UnsafeUnpin,

Blanket Implementations§

§

impl<T, A, P> Access<T> for P
where A: Access<T> + ?Sized, P: Deref<Target = A>,

§

type Guard = <A as Access<T>>::Guard

A guard object containing the value and keeping it alive. Read more

§

fn load(&self) -> <P as Access<T>>::Guard

The loading method. Read more

Source §

impl<T> Any for T
where T: 'static + ?Sized,

Source §

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

§

impl<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

§

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

§

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

§

fn implicit( self, class: Class, constructed: bool, tag: u32, ) -> TaggedParser<'a, Implicit, Self, E>

§

impl<R> AsyncReadExt for R
where R: AsyncRead + ?Sized,

§

fn chain<R>(self, next: R) -> Chain<Self, R>
where Self: Sized, R: AsyncRead,

Creates a new AsyncRead instance that chains this stream with next. Read more

§

fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> Read<'a, Self>
where Self: Unpin,

Pulls some bytes from this source into the specified buffer, returning how many bytes were read. Read more

§

fn read_buf<'a, B>(&'a mut self, buf: &'a mut B) -> ReadBuf<'a, Self, B>
where Self: Unpin, B: BufMut + ?Sized,

Pulls some bytes from this source into the specified buffer, advancing the buffer’s internal cursor. Read more

§

fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExact<'a, Self>
where Self: Unpin,

Reads the exact number of bytes required to fill buf. Read more

§

fn read_u8(&mut self) -> ReadU8<&mut Self>
where Self: Unpin,

Reads an unsigned 8 bit integer from the underlying reader. Read more

§

fn read_i8(&mut self) -> ReadI8<&mut Self>
where Self: Unpin,

Reads a signed 8 bit integer from the underlying reader. Read more

§

fn read_u16(&mut self) -> ReadU16<&mut Self>
where Self: Unpin,

Reads an unsigned 16-bit integer in big-endian order from the underlying reader. Read more

§

fn read_i16(&mut self) -> ReadI16<&mut Self>
where Self: Unpin,

Reads a signed 16-bit integer in big-endian order from the underlying reader. Read more

§

fn read_u32(&mut self) -> ReadU32<&mut Self>
where Self: Unpin,

Reads an unsigned 32-bit integer in big-endian order from the underlying reader. Read more

§

fn read_i32(&mut self) -> ReadI32<&mut Self>
where Self: Unpin,

Reads a signed 32-bit integer in big-endian order from the underlying reader. Read more

§

fn read_u64(&mut self) -> ReadU64<&mut Self>
where Self: Unpin,

Reads an unsigned 64-bit integer in big-endian order from the underlying reader. Read more

§

fn read_i64(&mut self) -> ReadI64<&mut Self>
where Self: Unpin,

Reads an signed 64-bit integer in big-endian order from the underlying reader. Read more

§

fn read_u128(&mut self) -> ReadU128<&mut Self>
where Self: Unpin,

Reads an unsigned 128-bit integer in big-endian order from the underlying reader. Read more

§

fn read_i128(&mut self) -> ReadI128<&mut Self>
where Self: Unpin,

Reads an signed 128-bit integer in big-endian order from the underlying reader. Read more

§

fn read_f32(&mut self) -> ReadF32<&mut Self>
where Self: Unpin,

Reads an 32-bit floating point type in big-endian order from the underlying reader. Read more

§

fn read_f64(&mut self) -> ReadF64<&mut Self>
where Self: Unpin,

Reads an 64-bit floating point type in big-endian order from the underlying reader. Read more

§

fn read_u16_le(&mut self) -> ReadU16Le<&mut Self>
where Self: Unpin,

Reads an unsigned 16-bit integer in little-endian order from the underlying reader. Read more

§

fn read_i16_le(&mut self) -> ReadI16Le<&mut Self>
where Self: Unpin,

Reads a signed 16-bit integer in little-endian order from the underlying reader. Read more

§

fn read_u32_le(&mut self) -> ReadU32Le<&mut Self>
where Self: Unpin,

Reads an unsigned 32-bit integer in little-endian order from the underlying reader. Read more

§

fn read_i32_le(&mut self) -> ReadI32Le<&mut Self>
where Self: Unpin,

Reads a signed 32-bit integer in little-endian order from the underlying reader. Read more

§

fn read_u64_le(&mut self) -> ReadU64Le<&mut Self>
where Self: Unpin,

Reads an unsigned 64-bit integer in little-endian order from the underlying reader. Read more

§

fn read_i64_le(&mut self) -> ReadI64Le<&mut Self>
where Self: Unpin,

Reads an signed 64-bit integer in little-endian order from the underlying reader. Read more

§

fn read_u128_le(&mut self) -> ReadU128Le<&mut Self>
where Self: Unpin,

Reads an unsigned 128-bit integer in little-endian order from the underlying reader. Read more

§

fn read_i128_le(&mut self) -> ReadI128Le<&mut Self>
where Self: Unpin,

Reads an signed 128-bit integer in little-endian order from the underlying reader. Read more

§

fn read_f32_le(&mut self) -> ReadF32Le<&mut Self>
where Self: Unpin,

Reads an 32-bit floating point type in little-endian order from the underlying reader. Read more

§

fn read_f64_le(&mut self) -> ReadF64Le<&mut Self>
where Self: Unpin,

Reads an 64-bit floating point type in little-endian order from the underlying reader. Read more

§

fn read_to_end<'a>(&'a mut self, buf: &'a mut Vec<u8>) -> ReadToEnd<'a, Self>
where Self: Unpin,

Reads all bytes until EOF in this source, placing them into buf. Read more

§

fn read_to_string<'a>( &'a mut self, dst: &'a mut String, ) -> ReadToString<'a, Self>
where Self: Unpin,

Reads all bytes until EOF in this source, appending them to buf. Read more

§

fn take(self, limit: u64) -> Take<Self>
where Self: Sized,

Creates an adaptor which reads at most limit bytes from it. Read more

§

impl<T> AsyncReadOwned for T
where T: AsyncRead + Unpin + Send + ?Sized,

§

fn poll_read_owned<B>( &mut self, cx: &mut Context<'_>, slot: &mut BufSlot<B>, ) -> Poll<Result<usize, Error>>
where B: IoBufMut,

The primitive. Poll a read into the owned buffer in slot, returning the bytes read (0 = EOF). The buffer is moved through the read op: Read more

§

fn read_owned<B>( &mut self, buf: B, ) -> impl Future<Output = (Result<usize, Error>, B)> + Send
where B: IoBufMut, Self: Send,

Derived async convenience over poll_read_owned: move buf in, drive to completion, hand it back filled. Not a second impl: every owned reader gets it for free, relays and read_exact_into use it. Read more

§

impl<W> AsyncWriteExt for W
where W: AsyncWrite + ?Sized,

§

fn write<'a>(&'a mut self, src: &'a [u8]) -> Write<'a, Self>
where Self: Unpin,

Writes a buffer into this writer, returning how many bytes were written. Read more

§

fn write_vectored<'a, 'b>( &'a mut self, bufs: &'a [IoSlice<'b>], ) -> WriteVectored<'a, 'b, Self>
where Self: Unpin,

Like write, except that it writes from a slice of buffers. Read more

§

fn write_buf<'a, B>(&'a mut self, src: &'a mut B) -> WriteBuf<'a, Self, B>
where Self: Sized + Unpin, B: Buf,

Writes a buffer into this writer, advancing the buffer’s internal cursor. Read more

§

fn write_all_buf<'a, B>( &'a mut self, src: &'a mut B, ) -> WriteAllBuf<'a, Self, B>
where Self: Sized + Unpin, B: Buf,

Attempts to write an entire buffer into this writer. Read more

§

fn write_all<'a>(&'a mut self, src: &'a [u8]) -> WriteAll<'a, Self>
where Self: Unpin,

Attempts to write an entire buffer into this writer. Read more

§

fn write_u8(&mut self, n: u8) -> WriteU8<&mut Self>
where Self: Unpin,

Writes an unsigned 8-bit integer to the underlying writer. Read more

§

fn write_i8(&mut self, n: i8) -> WriteI8<&mut Self>
where Self: Unpin,

Writes a signed 8-bit integer to the underlying writer. Read more

§

fn write_u16(&mut self, n: u16) -> WriteU16<&mut Self>
where Self: Unpin,

Writes an unsigned 16-bit integer in big-endian order to the underlying writer. Read more

§

fn write_i16(&mut self, n: i16) -> WriteI16<&mut Self>
where Self: Unpin,

Writes a signed 16-bit integer in big-endian order to the underlying writer. Read more

§

fn write_u32(&mut self, n: u32) -> WriteU32<&mut Self>
where Self: Unpin,

Writes an unsigned 32-bit integer in big-endian order to the underlying writer. Read more

§

fn write_i32(&mut self, n: i32) -> WriteI32<&mut Self>
where Self: Unpin,

Writes a signed 32-bit integer in big-endian order to the underlying writer. Read more

§

fn write_u64(&mut self, n: u64) -> WriteU64<&mut Self>
where Self: Unpin,

Writes an unsigned 64-bit integer in big-endian order to the underlying writer. Read more

§

fn write_i64(&mut self, n: i64) -> WriteI64<&mut Self>
where Self: Unpin,

Writes an signed 64-bit integer in big-endian order to the underlying writer. Read more

§

fn write_u128(&mut self, n: u128) -> WriteU128<&mut Self>
where Self: Unpin,

Writes an unsigned 128-bit integer in big-endian order to the underlying writer. Read more

§

fn write_i128(&mut self, n: i128) -> WriteI128<&mut Self>
where Self: Unpin,

Writes an signed 128-bit integer in big-endian order to the underlying writer. Read more

§

fn write_f32(&mut self, n: f32) -> WriteF32<&mut Self>
where Self: Unpin,

Writes an 32-bit floating point type in big-endian order to the underlying writer. Read more

§

fn write_f64(&mut self, n: f64) -> WriteF64<&mut Self>
where Self: Unpin,

Writes an 64-bit floating point type in big-endian order to the underlying writer. Read more

§

fn write_u16_le(&mut self, n: u16) -> WriteU16Le<&mut Self>
where Self: Unpin,

Writes an unsigned 16-bit integer in little-endian order to the underlying writer. Read more

§

fn write_i16_le(&mut self, n: i16) -> WriteI16Le<&mut Self>
where Self: Unpin,

Writes a signed 16-bit integer in little-endian order to the underlying writer. Read more

§

fn write_u32_le(&mut self, n: u32) -> WriteU32Le<&mut Self>
where Self: Unpin,

Writes an unsigned 32-bit integer in little-endian order to the underlying writer. Read more

§

fn write_i32_le(&mut self, n: i32) -> WriteI32Le<&mut Self>
where Self: Unpin,

Writes a signed 32-bit integer in little-endian order to the underlying writer. Read more

§

fn write_u64_le(&mut self, n: u64) -> WriteU64Le<&mut Self>
where Self: Unpin,

Writes an unsigned 64-bit integer in little-endian order to the underlying writer. Read more

§

fn write_i64_le(&mut self, n: i64) -> WriteI64Le<&mut Self>
where Self: Unpin,

Writes an signed 64-bit integer in little-endian order to the underlying writer. Read more

§

fn write_u128_le(&mut self, n: u128) -> WriteU128Le<&mut Self>
where Self: Unpin,

Writes an unsigned 128-bit integer in little-endian order to the underlying writer. Read more

§

fn write_i128_le(&mut self, n: i128) -> WriteI128Le<&mut Self>
where Self: Unpin,

Writes an signed 128-bit integer in little-endian order to the underlying writer. Read more

§

fn write_f32_le(&mut self, n: f32) -> WriteF32Le<&mut Self>
where Self: Unpin,

Writes an 32-bit floating point type in little-endian order to the underlying writer. Read more

§

fn write_f64_le(&mut self, n: f64) -> WriteF64Le<&mut Self>
where Self: Unpin,

Writes an 64-bit floating point type in little-endian order to the underlying writer. Read more

§

fn flush(&mut self) -> Flush<'_, Self>
where Self: Unpin,

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination. Read more

§

fn shutdown(&mut self) -> Shutdown<'_, Self>
where Self: Unpin,

Shuts down the output stream, ensuring that the value can be dropped cleanly. Read more

§

impl<T> AsyncWriteOwned for T
where T: AsyncWrite + Unpin + Send + ?Sized,

§

fn poll_write_owned<B>( &mut self, cx: &mut Context<'_>, slot: &mut BufSlot<B>, ) -> Poll<Result<usize, Error>>
where B: IoBuf,

The primitive. Poll a write of the initialized bytes [0, buf_len) of the buffer in slot, returning the bytes written. The buffer is moved through the write op (readiness: borrowed-then-restored; completion / SEND_ZC: moved into the op, slot left InFlight, returned on the NOTIF) and left back in slot on Ready. The caller advances its own cursor by the returned count.

§

fn poll_flush_owned(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Error>>

Poll a flush of any buffered data to the underlying sink.

§

fn poll_shutdown_owned( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), Error>>

Poll a shutdown of the write side of this connection.

§

fn is_write_vectored_owned(&self) -> bool

Hint whether vectored writes are efficient on this writer (mirrors [tokio::io::AsyncWrite::is_write_vectored]), lets a frame encoder pick a chain threshold. Defaults to false, the blanket-over-tokio impl and thin adapters forward the underlying writer’s answer.

§

fn write_owned<B>( &mut self, buf: B, ) -> impl Future<Output = (Result<usize, Error>, B)> + Send
where B: IoBuf, Self: Send,

Derived async convenience over poll_write_owned: move buf in, issue one write, hand it back with the bytes written. Not a second impl: every owned writer gets it for free. Read more

§

fn flush_owned(&mut self) -> impl Future<Output = Result<(), Error>> + Send
where Self: Send,

Derived async flush over poll_flush_owned.

§

fn shutdown_owned(&mut self) -> impl Future<Output = Result<(), Error>> + Send
where Self: Send,

Derived async shutdown over poll_shutdown_owned.

Source §

impl<T> Borrow<T> for T
where T: ?Sized,

Source §

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

Source §

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source §

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

§

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

§

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

§

impl<S, Input, Connection> ConnectorService<Input> for S
where S: Service<Input, Output = EstablishedClientConnection<Connection, Input>>, <S as Service<Input>>::Error: Into<ConnectionError>, Connection: Send + ExtensionsRef,

§

type Connection = Connection

Connection returned by the ConnectorService

§

fn connect( &self, input: Input, ) -> impl Future<Output = Result<EstablishedClientConnection<<S as ConnectorService<Input>>::Connection, Input>, ConnectionError>> + Send

Establish a connection, which often involves some kind of handshake, or connection revival. Read more

Source §

impl<T> CryptoRng for T
where T: DerefMut, <T as Deref>::Target: CryptoRng,

§

impl<R> CryptoRng for R
where R: TryCryptoRng<Error = !> + ?Sized,

§

impl<T, A> DynAccess<T> for A
where A: Access<T>, <A as Access<T>>::Guard: 'static,

§

fn load(&self) -> DynGuard<T>

The equivalent of [Access::load].

§

impl<T> Formattable for T
where T: Deref, <T as Deref>::Target: Formattable,

§

impl<T> ForwardedClientExt for T
where T: ExtensionsRef + ?Sized,

§

fn forwarded_client(&self) -> Option<&ForwardedElement>

The element describing the client.

§

fn forwarded_client_ip(&self) -> Option<IpAddr>

The client’s IP, from its for node.

§

fn forwarded_client_socket_addr(&self) -> Option<SocketAddress>

The client’s IP and port, from its for node.

§

fn forwarded_client_host(&self) -> Option<&ForwardedAuthority>

The host the client asked for.

§

fn forwarded_client_proto(&self) -> Option<ForwardedProtocol>

The protocol the client used.

§

fn forwarded_client_version(&self) -> Option<ForwardedVersion>

The HTTP version the client used.

Source §

impl<T> From<T> for T

Source §

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> FutureExt for T

§

fn with_context(self, otel_cx: Context) -> WithContext<Self> ⓘ

Attaches the provided Context to this type, returning a WithContext wrapper. Read more

§

fn with_current_context(self) -> WithContext<Self> ⓘ

Attaches the current Context to this type, returning a WithContext wrapper. Read more

§

impl<T, ReqBody, ResBody> GrpcService<ReqBody> for T
where T: Service<Request<ReqBody>, Output = Response<ResBody>>, <T as Service<Request<ReqBody>>>::Error: Into<Box<dyn Error + Sync + Send>>, ResBody: Body, <ResBody as Body>::Error: Into<Box<dyn Error + Sync + Send>>,

§

type ResponseBody = ResBody

Responses body given by the service.

§

type Error = <T as Service<Request<ReqBody>>>::Error

Errors produced by the service.

§

fn serve( &self, request: Request<ReqBody>, ) -> impl Future<Output = Result<Response<<T as GrpcService<ReqBody>>::ResponseBody>, <T as GrpcService<ReqBody>>::Error>> + Send

Process the request and return the response asynchronously. Read more

§

impl<S, Body> HttpClientExt for S
where S: Service<Request, Output = Response<Body>>, <S as Service<Request>>::Error: Into<Box<dyn Error + Sync + Send>>,

§

type ExecuteResponse = Response<Body>

The response type returned by the execute method.

§

type ExecuteError = <S as Service<Request>>::Error

The error type returned by the execute method.

§

fn get( &self, url: impl IntoUrl, ) -> RequestBuilder<'_, S, <S as HttpClientExt>::ExecuteResponse>

Convenience method to make a GET request to a URL. Read more

§

fn post( &self, url: impl IntoUrl, ) -> RequestBuilder<'_, S, <S as HttpClientExt>::ExecuteResponse>

Convenience method to make a POST request to a URL. Read more

§

fn put( &self, url: impl IntoUrl, ) -> RequestBuilder<'_, S, <S as HttpClientExt>::ExecuteResponse>

Convenience method to make a PUT request to a URL. Read more

§

fn patch( &self, url: impl IntoUrl, ) -> RequestBuilder<'_, S, <S as HttpClientExt>::ExecuteResponse>

Convenience method to make a PATCH request to a URL. Read more

§

fn delete( &self, url: impl IntoUrl, ) -> RequestBuilder<'_, S, <S as HttpClientExt>::ExecuteResponse>

Convenience method to make a DELETE request to a URL. Read more

§

fn head( &self, url: impl IntoUrl, ) -> RequestBuilder<'_, S, <S as HttpClientExt>::ExecuteResponse>

Convenience method to make a HEAD request to a URL. Read more

§

fn connect( &self, url: impl IntoUrl, ) -> RequestBuilder<'_, S, <S as HttpClientExt>::ExecuteResponse>

Convenience method to make a CONNECT request to a URL. Read more

§

fn query( &self, url: impl IntoUrl, ) -> RequestBuilder<'_, S, <S as HttpClientExt>::ExecuteResponse>

Convenience method to make a QUERY request to a URL. Read more

§

fn request( &self, method: Method, url: impl IntoUrl, ) -> RequestBuilder<'_, S, <S as HttpClientExt>::ExecuteResponse>

Start building a Request with the Method and Url. Read more

§

fn build_from_request<RequestBody>( &self, request: Request<RequestBody>, ) -> RequestBuilder<'_, S, <S as HttpClientExt>::ExecuteResponse>
where RequestBody: Into<Body>,

Start building a Request, using the given Request. Read more

§

fn execute( &self, request: Request, ) -> impl Future<Output = Result<<S as HttpClientExt>::ExecuteResponse, <S as HttpClientExt>::ExecuteError>>

Executes a Request. Read more

§

impl<S, Body> HttpClientWebSocketExt<Body> for S
where S: Service<Request, Output = Response<Body>>, <S as Service<Request>>::Error: Into<Box<dyn Error + Sync + Send>>,

§

fn websocket( &self, url: impl IntoUrl, ) -> WebSocketRequestBuilder<WithService<'_, S, Body>>

Create a new WebSocketRequestBuilder] to be used to establish a WebSocket connection over http/1.1.

§

fn websocket_h2( &self, url: impl IntoUrl, ) -> WebSocketRequestBuilder<WithService<'_, S, Body>>

Create a new WebSocketRequestBuilder to be used to establish a WebSocket connection over h2.

§

fn websocket_h3( &self, url: impl IntoUrl, ) -> WebSocketRequestBuilder<WithService<'_, S, Body>>

Create a new WebSocketRequestBuilder to be used to establish a WebSocket connection over h3.

§

fn websocket_with_request<RequestBody>( &self, req: Request<RequestBody>, ) -> WebSocketRequestBuilder<WithService<'_, S, Body>>
where RequestBody: Into<Body>,

Create a new WebSocketRequestBuilder starting from the given request. Read more

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

§

fn in_current_span(self) -> Instrumented<Self> ⓘ

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

Source §

impl<T, U> Into<U> for T
where U: From<T>,

Source §

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source §

impl<T> IntoEither for T

Source §

fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Source §

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

§

impl<S> IntoEndpointService<(S,)> for S
where S: Service<Request>,

§

type Service = S

§

fn into_endpoint_service(self) -> <S as IntoEndpointService<(S,)>>::Service

convert the type into a rama_core::Service.

§

impl<S, State> IntoEndpointServiceWithState<(S,), State> for S
where S: Service<Request>,

§

type Service = S

§

fn into_endpoint_service_with_state( self, _state: State, ) -> <S as IntoEndpointServiceWithState<(S,), State>>::Service

convert the type into a rama_core::Service with state.

§

impl<IO> IntoHttpTransport for IO
where IO: Io + Unpin + ExtensionsRef,

§

type Stream = IO

§

fn supports_http_version(version: Version) -> bool

Whether this transport type can carry the requested HTTP version. Read more

§

fn into_http_transport(self) -> HttpTransport<<IO as IntoHttpTransport>::Stream>

§

impl<T> IntoRequest<T> for T

§

fn into_request(self) -> Request<T>

Wrap the input message T in a rama_grpc::Request

§

impl<T> Io for T
where T: AsyncRead + AsyncWrite + Send + 'static,

§

impl<L> LayerExt<L> for L

§

fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>
where L: Layer<S>,

Applies the layer to a service and wraps it in Layered.

§

impl<T> Parsable for T
where T: Deref, <T as Deref>::Target: Parsable,

§

impl<T> PeekIoProvider for T
where T: Io,

§

type PeekIo = T

The type that can be peeked.

§

type Mapped<PeekedIo: Io> = PeekedIo

The mapped Self type produced as a result of mapping the PeekIo type.

§

fn peek_io_mut(&mut self) -> &mut <T as PeekIoProvider>::PeekIo

Retrieve a mutable reference to the Peekable type.

§

fn map_peek_io<PeekedIo, F>( self, map: F, ) -> <T as PeekIoProvider>::Mapped<PeekedIo>
where PeekedIo: Io, F: FnOnce(<T as PeekIoProvider>::PeekIo) -> PeekedIo,

Once peeking is finished one can reproduce self by mapping the Peeked Io type and produce a new type, usually with the peeked data in-memory as prefix.

§