Struct PacketStream 

pub struct PacketStream<S: PacketSource + AsRawFd> { /* private fields */ }

Adapter implementing futures_core::Stream over an AsyncCapture.

Yields one Vec<OwnedPacket> per retired block — the standard “borrow-then-copy” idiom for Streams (the Stream::Item lifetime can’t outlive a single poll_next, so we copy data out of the ring before yielding).

For zero-copy access without copies, hold the underlying AsyncCapture directly and use AsyncCapture::try_recv_batch in a loop.

Cancel safety

Stream::poll_next is cancel-safe: dropping the future between polls abandons the in-flight readiness wait without losing data (the next poll will re-arm via tokio’s reactor).

Idiomatic consumption

netring re-exports only futures_core::Stream (the trait). To use the usual .next().await, .filter(), .take(), etc. combinators, add futures (or tokio_stream) to your Cargo.toml:

futures = "0.3"

then:

use futures::StreamExt;

let cap = netring::AsyncCapture::new(rx)?;
let mut stream = netring::PacketStream::new(cap);
while let Some(batch) = stream.next().await {
    for pkt in batch? { /* ... */ }
}

Hand-polling without StreamExt is also possible — see examples/async_stream.rs for that variant.

Examples

use futures_core::Stream;
use netring::CaptureBuilder;
use netring::async_adapters::tokio_adapter::{AsyncCapture, PacketStream};

let rx = CaptureBuilder::default().interface("lo").build()?;
let cap = AsyncCapture::new(rx)?;
let stream = PacketStream::new(cap);

// Pin and consume:
let mut stream = Box::pin(stream);
// .. then use Stream combinators or hand-poll. See StreamExt examples.

Implementations

impl<S: PacketSource + AsRawFd> PacketStream<S>

pub fn new(cap: AsyncCapture<S>) -> Self

Wrap an AsyncCapture as a Stream.

pub fn into_inner(self) -> AsyncCapture<S>

Unwrap into the underlying AsyncCapture.

Trait Implementations

impl<S: PacketSource + AsRawFd + Unpin> Stream for PacketStream<S>

type Item = Result<Vec<OwnedPacket>, Error>

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.