Skip to main content

hopr_protocol_session/processing/
mod.rs

1//! This module contains the three main parts for frame processing.
2//! Each of them is represented using an adaptor
3//! extension to [`futures::Stream`] or [`futures::Sink`]
4//!
5//!
6//! 1. Segmenter
7//! 2. Reassembler
8//! 3. Sequencer
9//!
10//! Reassembler followed by a Sequencer is commonly called frame Reconstructor.
11
12mod reassembly;
13mod reorder;
14mod segmenter;
15mod sequencer;
16/// Types necessary for frame reconstruction and segmentation.
17pub(crate) mod types;
18
19pub(crate) use reassembly::ReassemblerExt;
20pub(crate) use reorder::SharedReorder;
21pub(crate) use segmenter::SegmenterExt;
22pub(crate) use sequencer::{SequencerConfig, SequencerExt};
23
24#[cfg(test)]
25mod tests {
26    use std::time::Duration;
27
28    use futures::{AsyncReadExt, AsyncWriteExt, SinkExt, StreamExt, TryStreamExt, pin_mut};
29    use futures_time::future::FutureExt;
30    use rand::prelude::*;
31
32    use super::*;
33    use crate::{
34        MAX_SESSION_MTU,
35        errors::SessionError,
36        protocol::{Frame, OrderedFrame},
37        utils::segment,
38    };
39
40    const RNG_SEED: [u8; 32] = hex_literal::hex!("d8a471f1c20490a3442b96fdde9d1807428096e1601b0cef0eea7e6d44a24c01");
41
42    #[tokio::test]
43    async fn framed_reconstructor_should_reconstruct_frames() -> anyhow::Result<()> {
44        let expected = (1u32..=10)
45            .map(|frame_id| Frame {
46                frame_id,
47                data: hopr_types::crypto_random::random_bytes::<100>().into(),
48                is_terminating: false,
49            })
50            .collect::<Vec<_>>();
51
52        let (reassm_tx, reassm_rx) = futures::channel::mpsc::unbounded();
53
54        let reassm_rx = reassm_rx
55            .reassembler(Duration::from_secs(5), 1024)
56            .filter_map(|maybe_frame| match maybe_frame {
57                Ok(frame) => futures::future::ready(Some(OrderedFrame(frame))),
58                Err(_) => futures::future::ready(None),
59            })
60            .sequencer(Duration::from_secs(5), 1024)
61            .and_then(|frame| futures::future::ok(frame.0));
62
63        let mut segments = expected
64            .iter()
65            .cloned()
66            .flat_map(|f| segment(f.data, 22, f.frame_id).unwrap())
67            .collect::<Vec<_>>();
68
69        let mut rng = StdRng::from_seed(RNG_SEED);
70        segments.shuffle(&mut rng);
71
72        hopr_utils::runtime::prelude::spawn(futures::stream::iter(segments).map(Ok).forward(reassm_tx)).await??;
73
74        let actual = reassm_rx
75            .try_collect::<Vec<_>>()
76            .timeout(futures_time::time::Duration::from_secs(5))
77            .await??;
78
79        assert_eq!(actual, expected);
80
81        Ok(())
82    }
83
84    #[test_log::test(tokio::test)]
85    async fn frame_reconstructor_should_discard_missing_segment() -> anyhow::Result<()> {
86        let expected = (1u32..=10)
87            .map(|frame_id| Frame {
88                frame_id,
89                data: hopr_types::crypto_random::random_bytes::<100>().into(),
90                is_terminating: false,
91            })
92            .collect::<Vec<_>>();
93
94        let (reassm_tx, reassm_rx) = futures::channel::mpsc::unbounded();
95
96        let reassm_rx = reassm_rx
97            .reassembler(Duration::from_secs(5), 1024)
98            .filter_map(|maybe_frame| match maybe_frame {
99                Ok(frame) => futures::future::ready(Some(OrderedFrame(frame))),
100                Err(_) => futures::future::ready(None),
101            })
102            .sequencer(Duration::from_secs(5), 1024)
103            .and_then(|frame| futures::future::ok(frame.0));
104
105        let mut segments = expected
106            .iter()
107            .cloned()
108            .flat_map(|f| segment(f.data, 22, f.frame_id).unwrap())
109            .filter(|s| s.frame_id != 4 || s.seq_idx != 1)
110            .collect::<Vec<_>>();
111
112        let mut rng = StdRng::from_seed(RNG_SEED);
113        segments.shuffle(&mut rng);
114
115        hopr_utils::runtime::prelude::spawn(futures::stream::iter(segments).map(Ok).forward(reassm_tx)).await??;
116
117        let actual = reassm_rx
118            .collect::<Vec<_>>()
119            .timeout(futures_time::time::Duration::from_secs(5))
120            .await?;
121
122        assert_eq!(actual.len(), expected.len());
123        for i in 0..expected.len() {
124            if i != 3 {
125                assert!(matches!(&actual[i], Ok(frame) if expected[i].eq(frame)));
126            } else {
127                assert!(matches!(actual[i], Err(SessionError::FrameDiscarded(4))))
128            }
129        }
130
131        Ok(())
132    }
133
134    #[test_log::test(tokio::test)]
135    async fn test_segmenter_reconstructor_should_work_together() -> anyhow::Result<()> {
136        const DATA_SIZE: usize = 9001;
137        const FRAME_SIZE: usize = MAX_SESSION_MTU;
138
139        const MTU: usize = 1000;
140
141        let (reassm_tx, reassm_rx) = futures::channel::mpsc::unbounded();
142
143        let data_out = reassm_rx
144            .reassembler(Duration::from_secs(1), 1024)
145            .filter_map(|maybe_frame| match maybe_frame {
146                Ok(frame) => futures::future::ready(Some(OrderedFrame(frame))),
147                Err(_) => futures::future::ready(None),
148            })
149            .sequencer(Duration::from_secs(1), 1024)
150            .and_then(|frame| futures::future::ok(frame.0));
151
152        let mut data_in = reassm_tx
153            .sink_map_err(|_| SessionError::InvalidSegment)
154            .segmenter::<MTU>(FRAME_SIZE);
155
156        let data_written = hopr_types::crypto_random::random_bytes::<DATA_SIZE>();
157
158        let data_read = tokio::task::spawn(async move {
159            let mut frame_count = 0;
160            let mut out = Vec::new();
161            let data_out = data_out
162                .inspect(|frame| {
163                    tracing::debug!("{:?}", frame);
164                    frame_count += 1;
165                })
166                .map_err(std::io::Error::other)
167                .into_async_read();
168
169            pin_mut!(data_out);
170            data_out.read_to_end(&mut out).await?;
171            Ok::<_, std::io::Error>((out, frame_count))
172        })
173        .timeout(futures_time::time::Duration::from_secs(5));
174
175        data_in.write_all(&data_written).await?;
176        data_in.flush().await?;
177        data_in.close().await?;
178
179        let (data_read, frame_count) = data_read.await???;
180
181        assert_eq!(&data_written, data_read.as_slice());
182        assert_eq!(DATA_SIZE / FRAME_SIZE + 1, frame_count);
183
184        Ok(())
185    }
186}