Struct FrameReassembler

pub struct FrameReassembler { /* private fields */ }

Represents a frame reassembler.

The FrameReassembler behaves as a [Sink] for Segment. Upon creation, also [Stream] for reassembled Frames is created. The corresponding stream is closed either when the reassembler is dropped or [futures::SinkExt::close] is called.

As new segments are pushed into the reassembler, the frames get reassembled, and once they are completed, they are automatically pushed out into the outgoing frame stream.

The reassembler can also have a max_age of frames that are under construction. The evict method then can be called to remove the incomplete frames over max_age. The timestamps are measured with millisecond precision.

Note that the reassembler is also evicted when dropped.

futures::executor::block_on(async {
use hopr_network_types::session::{Frame, FrameReassembler};
use futures::{pin_mut, StreamExt, TryStreamExt};

let bytes = b"deadbeefcafe00112233";

// Build Frame and segment it
let frame = Frame { frame_id: 1, data: bytes.as_ref().into() };
let segments = frame.segment(2).unwrap();
assert_eq!(bytes.len() / 2, segments.len());

// Create FrameReassembler and feed the segments to it
let (fragmented, reassembled) = FrameReassembler::new(Duration::from_secs(10));

for segment in segments {
    fragmented.push_segment(segment).unwrap();
}

drop(fragmented);
pin_mut!(reassembled);

assert!(matches!(reassembled.try_next().await, Ok(Some(frame))));

Implementations

impl FrameReassembler

pub fn new(max_age: Duration) -> (Self, impl Stream<Item = Result<Frame>>)

Creates a new frame reassembler and a corresponding stream for reassembled Frames. An optional max_age of segments can be specified, which allows the evict method to remove stale incomplete segments.

pub fn push_segment(&self, segment: Segment) -> Result<()>

Pushes a new Segment for reassembly. This function also pushes out the reassembled frame if this segment completed it. Pushing a segment belonging to a frame ID that has been already previously completed or evicted will fail.

pub fn incomplete_frames(&self) -> BinaryHeap<FrameInfo>

Returns information about the incomplete frames. The returned collection is ordered by frame IDs.

pub fn evict(&self) -> Result<usize>

According to the max_age set during construction, evicts leading incomplete frames that are expired at the time this method was called. Returns that total number of frames that were evicted.

pub fn close(&self)

Closes the reassembler. Any subsequent calls to FrameReassembler::push_segment will fail.

Trait Implementations

impl Debug for FrameReassembler

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

Formats the value using the given formatter.

impl Drop for FrameReassembler

fn drop(&mut self)

Executes the destructor for this type.

impl Extend<Segment> for FrameReassembler

fn extend<T: IntoIterator<Item = Segment>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl Sink<Segment> for FrameReassembler

type Error = NetworkTypeError

The type of value produced by the sink when an error occurs.

fn poll_ready( self: Pin<&mut Self>, _: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, item: Segment) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush( self: Pin<&mut Self>, _: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Self>, _: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.