Struct IncomingStream 

pub struct IncomingStream<'a, L>
where
    L: Listener,
{
    pub io: &'a TokioIo<L::Io>,
    pub remote_addr: L::Addr,
}

An incoming stream that bundles connection information.

This struct serves as the request type for the make_service Tower service, allowing it to access connection-level metadata when creating per-connection services.

Purpose

In Tower/Hyper’s model, make_service is called once per connection to create a service that handles all HTTP requests on that connection. IncomingStream provides the connection information needed to customize service creation based on:

• The remote address (for logging or access control)
• The underlying IO type (for protocol detection or configuration)

Design

This type holds a reference to the IO rather than ownership because:

• The actual IO is still needed by Hyper to serve the connection after make_service returns
• The make_service only needs to inspect connection metadata, not take ownership

Lifetime Safety

The lifetime 'a ensures the reference to IO remains valid only during the make_service.call() invocation. After the service is created, the IO is moved into a spawned task to handle the connection. This is safe because:

let io = TokioIo::new(stream);           // IO created
let service = make_service.call(
    IncomingStream { io: &io, .. }       // Borrowed during call
).await;                                  // Borrow ends
tokio::spawn(serve_connection(io, ..));  // IO moved to task

The borrow checker guarantees the reference doesn’t outlive the IO object.

Used with serve and crate::routing::IntoMakeServiceWithConnectInfo.

Fields

io: &'a TokioIo<L::Io>

Reference to the IO for this connection

remote_addr: L::Addr

Remote address of the client

Implementations

impl<L> IncomingStream<'_, L>

where L: Listener,

pub fn io(&self) -> &L::Io

Get a reference to the inner IO type.

pub fn remote_addr(&self) -> &L::Addr

Returns the remote address that this stream is bound to.

Trait Implementations

impl<'a, L> Connected<IncomingStream<'a, L>> for SocketAddr

where L: Listener<Addr = SocketAddr>,

fn connect_info(target: IncomingStream<'a, L>) -> Self

Create type holding information about the connection.

impl<'a, L> Debug for IncomingStream<'a, L>

where L: Listener + Debug, L::Io: Debug, L::Addr: Debug,

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

Formats the value using the given formatter.