Struct PostedRecv

pub struct PostedRecv<S>where
    S: RawTcpStream,
{ /* private fields */ }

Available on crate features std and tcp only.

Expand description

A raw TCP stream whose reads keep the data that arrives right before a reset.

See the module docs for why this is needed on Windows. Writes, socket addresses, socket options and extensions all go to the inner stream; only reading is taken over.

Dropping it never blocks. On Windows the socket is closed once the cancelled receives have completed, so that the close stays graceful instead of going out as a reset.

A socket stays attached to the internal completion port for its whole life, so a PostedRecv cannot be unwrapped again.

The AbortIo that a TcpStream publishes still works through the wrapper: called before the wrapper is dropped, it makes the deferred close go out as a reset.

Implementations§

§

impl<S> PostedRecv<S>
where S: RawTcpStream,

pub fn new(stream: S) -> PostedRecv<S>

Take over reading from stream, with the default PostedRecvConfig.

Wrap the stream right after it connected or was accepted: bytes read through stream before are not seen by the wrapper.

Never fails: if receives cannot be posted, reads pass through as if the stream was not wrapped. See PostedRecv::try_with_config to get the error instead.

pub fn with_config(stream: S, config: &PostedRecvConfig) -> PostedRecv<S>

Take over reading from stream with the given configuration.

Never fails, see PostedRecv::new.

pub fn try_with_config( stream: S, config: &PostedRecvConfig, ) -> Result<PostedRecv<S>, (Error, S)>

Take over reading from stream with the given configuration, or hand it back with the error.

§Errors

Fails on Windows if the completion thread cannot be started, or if the socket cannot be attached to its port, for instance because it already is attached to another one. A failed start is retried by the next call.

pub fn is_posted(&self) -> bool

Whether receives are posted for this stream. False off Windows, and when wrapping fell back to passing reads through.

pub fn get_ref(&self) -> &S

Borrow the inner stream.

Reading from it directly bypasses the posted receives and reorders the stream, and no overlapped I/O may be issued on its socket.

Trait Implementations§

§

impl<S> AsFd for PostedRecv<S>
where S: RawTcpStream + AsFd,

§

fn as_fd(&self) -> BorrowedFd<'_>

Borrows the file descriptor. Read more

§

impl<S> AsRawFd for PostedRecv<S>
where S: RawTcpStream + AsRawFd,

§

fn as_raw_fd(&self) -> i32

Extracts the raw file descriptor. Read more

§

impl<S> AsSocketRef for PostedRecv<S>
where S: RawTcpStream + AsSocketRef,

Available on target_family=unix or Windows only.

§

fn as_socket_ref(&self) -> SockRef<'_>

Return a non-owning reference to this socket.

§

impl<S> AsyncRead for PostedRecv<S>
where S: RawTcpStream,

§

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

Attempts to read from the AsyncRead into buf. Read more

§

impl<S> AsyncWrite for PostedRecv<S>
where S: RawTcpStream,

§

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

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

§

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

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

§

fn poll_flush( self: Pin<&mut PostedRecv<S>>, 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 PostedRecv<S>>, 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

§

impl<S> Debug for PostedRecv<S>
where S: RawTcpStream + Debug,

§

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

Formats the value using the given formatter. Read more

§

impl<S> ExtensionsRef for PostedRecv<S>
where S: RawTcpStream + ExtensionsRef,

§

fn extensions(&self) -> &Extensions

Get reference to the underlying Extensions store

§

impl<S> Socket for PostedRecv<S>
where S: RawTcpStream,

§

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<S> UnwindSafe for PostedRecv<S>
where S: UnwindSafe,

Blanket Implementations§

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( &mut self, cx: &mut Context<'_>, slot: &mut BufSlot, ) -> 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( &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( &mut self, cx: &mut Context<'_>, slot: &mut BufSlot, ) -> 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( &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<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> 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 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<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> 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.

§