hopr_protocol_session/processing/
mod.rs1mod reassembly;
13mod reorder;
14mod segmenter;
15mod sequencer;
16pub(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}