Debian Codegraph @

third_party/rust/neqo-transport/src/connection/tests/priority.rs

raw
1 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
2 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
4 // option. This file may not be copied, modified, or distributed
5 // except according to those terms.
6
7 use std::{cell::RefCell, rc::Rc};
8
9 use neqo_common::{event::Provider as _, Datagram};
10 use test_fixture::now;
11
12 use super::{
13 super::{Connection, Error, Output},
14 connect, default_client, default_server, fill_cwnd, maybe_authenticate,
15 };
16 use crate::{
17 addr_valid::{AddressValidation, ValidateAddress},
18 send_stream::{RetransmissionPriority, TransmissionPriority},
19 ConnectionEvent, StreamId, StreamType,
20 };
21
22 const BLOCK_SIZE: usize = 4_096;
23
24 fn fill_stream(c: &mut Connection, id: StreamId) {
25 loop {
26 if c.stream_send(id, &[0x42; BLOCK_SIZE]).unwrap() < BLOCK_SIZE {
27 return;
28 }
29 }
30 }
31
32 /// A receive stream cannot be prioritized (yet).
33 #[test]
34 fn receive_stream() {
35 const MESSAGE: &[u8] = b"hello";
36 let mut client = default_client();
37 let mut server = default_server();
38 connect(&mut client, &mut server);
39
40 let id = client.stream_create(StreamType::UniDi).unwrap();
41 assert_eq!(MESSAGE.len(), client.stream_send(id, MESSAGE).unwrap());
42 let dgram = client.process_output(now()).dgram();
43
44 server.process_input(dgram.unwrap(), now());
45 assert_eq!(
46 server
47 .stream_priority(
48 id,
49 TransmissionPriority::default(),
50 RetransmissionPriority::default()
51 )
52 .unwrap_err(),
53 Error::InvalidStreamId,
54 "Priority doesn't apply to inbound unidirectional streams"
55 );
56
57 // But the stream does exist and can be read.
58 let mut buf = [0; 10];
59 let (len, end) = server.stream_recv(id, &mut buf).unwrap();
60 assert_eq!(MESSAGE, &buf[..len]);
61 assert!(!end);
62 }
63
64 /// Higher priority streams get sent ahead of lower ones, even when
65 /// the higher priority stream is written to later.
66 #[test]
67 fn relative() {
68 let mut client = default_client();
69 let mut server = default_server();
70 connect(&mut client, &mut server);
71
72 // id_normal is created first, but it is lower priority.
73 let id_normal = client.stream_create(StreamType::UniDi).unwrap();
74 fill_stream(&mut client, id_normal);
75 let high = client.stream_create(StreamType::UniDi).unwrap();
76 fill_stream(&mut client, high);
77 client
78 .stream_priority(
79 high,
80 TransmissionPriority::High,
81 RetransmissionPriority::default(),
82 )
83 .unwrap();
84
85 let dgram = client.process_output(now()).dgram();
86 server.process_input(dgram.unwrap(), now());
87
88 // The "id_normal" stream will get a `NewStream` event, but no data.
89 for e in server.events() {
90 if let ConnectionEvent::RecvStreamReadable { stream_id } = e {
91 assert_ne!(stream_id, id_normal);
92 }
93 }
94 }
95
96 /// Check that changing priority has effect on the next packet that is sent.
97 #[test]
98 fn reprioritize() {
99 let mut client = default_client();
100 let mut server = default_server();
101 connect(&mut client, &mut server);
102
103 // id_normal is created first, but it is lower priority.
104 let id_normal = client.stream_create(StreamType::UniDi).unwrap();
105 fill_stream(&mut client, id_normal);
106 let id_high = client.stream_create(StreamType::UniDi).unwrap();
107 fill_stream(&mut client, id_high);
108 client
109 .stream_priority(
110 id_high,
111 TransmissionPriority::High,
112 RetransmissionPriority::default(),
113 )
114 .unwrap();
115
116 let dgram = client.process_output(now()).dgram();
117 server.process_input(dgram.unwrap(), now());
118
119 // The "id_normal" stream will get a `NewStream` event, but no data.
120 for e in server.events() {
121 if let ConnectionEvent::RecvStreamReadable { stream_id } = e {
122 assert_ne!(stream_id, id_normal);
123 }
124 }
125
126 // When the high priority stream drops in priority, the streams are equal
127 // priority and so their stream ID determines what is sent.
128 client
129 .stream_priority(
130 id_high,
131 TransmissionPriority::Normal,
132 RetransmissionPriority::default(),
133 )
134 .unwrap();
135 let dgram = client.process_output(now()).dgram();
136 server.process_input(dgram.unwrap(), now());
137
138 for e in server.events() {
139 if let ConnectionEvent::RecvStreamReadable { stream_id } = e {
140 assert_ne!(stream_id, id_high);
141 }
142 }
143 }
144
145 /// Retransmission can be prioritized differently (usually higher).
146 #[test]
147 fn repairing_loss() {
148 let mut client = default_client();
149 let mut server = default_server();
150 connect(&mut client, &mut server);
151 let mut now = now();
152
153 // Send a few packets at low priority, lose one.
154 let id_low = client.stream_create(StreamType::UniDi).unwrap();
155 fill_stream(&mut client, id_low);
156 client
157 .stream_priority(
158 id_low,
159 TransmissionPriority::Low,
160 RetransmissionPriority::Higher,
161 )
162 .unwrap();
163
164 let _lost = client.process_output(now).dgram();
165 for _ in 0..5 {
166 match client.process_output(now) {
167 Output::Datagram(d) => server.process_input(d, now),
168 Output::Callback(delay) => now += delay,
169 Output::None => unreachable!(),
170 }
171 }
172
173 // Generate an ACK. The first packet is now considered lost.
174 let ack = server.process_output(now).dgram();
175 _ = server.events().count(); // Drain events.
176
177 let id_normal = client.stream_create(StreamType::UniDi).unwrap();
178 fill_stream(&mut client, id_normal);
179
180 let dgram = client.process(ack, now).dgram();
181 assert_eq!(client.stats().lost, 1); // Client should have noticed the loss.
182 server.process_input(dgram.unwrap(), now);
183
184 // Only the low priority stream has data as the retransmission of the data from
185 // the lost packet is now more important than new data from the high priority stream.
186 for e in server.events() {
187 println!("Event: {e:?}");
188 if let ConnectionEvent::RecvStreamReadable { stream_id } = e {
189 assert_eq!(stream_id, id_low);
190 }
191 }
192
193 // However, only the retransmission is prioritized.
194 // Though this might contain some retransmitted data, as other frames might push
195 // the retransmitted data into a second packet, it will also contain data from the
196 // normal priority stream.
197 let dgram = client.process_output(now).dgram();
198 server.process_input(dgram.unwrap(), now);
199 assert!(server.events().any(
200 |e| matches!(e, ConnectionEvent::RecvStreamReadable { stream_id } if stream_id == id_normal),
201 ));
202 }
203
204 fn connect_for_0rtt() -> (Connection, Connection) {
205 let mut client = default_client();
206 let mut server = default_server();
207
208 // Rather than connect, send stream data in 0.5-RTT.
209 // That allows this to test that critical streams preempt most frame types.
210 let dgram = client.process_output(now()).dgram();
211 let dgram2 = client.process_output(now()).dgram();
212 server.process_input(dgram.unwrap(), now());
213 let dgram = server.process(dgram2, now()).dgram();
214 client.process_input(dgram.unwrap(), now());
215 (client, server)
216 }
217
218 fn complete_handshake(client: &mut Connection, server: &mut Connection, dgram: Option<Datagram>) {
219 let dgram = client.process(dgram, now()).dgram();
220 maybe_authenticate(client);
221 let dgram = server.process(dgram, now()).dgram();
222 let dgram = client.process(dgram, now()).dgram();
223 server.process_input(dgram.unwrap(), now());
224 }
225
226 #[test]
227 fn critical() {
228 let (mut client, mut server) = connect_for_0rtt();
229
230 let id = server.stream_create(StreamType::UniDi).unwrap();
231 server
232 .stream_priority(
233 id,
234 TransmissionPriority::Critical,
235 RetransmissionPriority::default(),
236 )
237 .unwrap();
238
239 // Can't use fill_cwnd here because the server is blocked on the amplification
240 // limit, so it can't fill the congestion window.
241 while server.stream_create(StreamType::UniDi).is_ok() {}
242
243 fill_stream(&mut server, id);
244 let stats_before = server.stats().frame_tx;
245 let dgram = server.process_output(now()).dgram();
246 let stats_after = server.stats().frame_tx;
247 assert_eq!(stats_after.crypto, stats_before.crypto + 2);
248 assert_eq!(stats_after.streams_blocked, 0);
249 assert_eq!(stats_after.new_connection_id, 0);
250 assert_eq!(stats_after.new_token, 0);
251 assert_eq!(stats_after.handshake_done, 0);
252
253 // Complete the handshake.
254 complete_handshake(&mut client, &mut server, dgram);
255
256 // Critical beats everything but HANDSHAKE_DONE.
257 let stats_before = server.stats().frame_tx;
258 drop(fill_cwnd(&mut server, id, now()));
259 let stats_after = server.stats().frame_tx;
260 assert_eq!(stats_after.crypto, stats_before.crypto);
261 assert_eq!(stats_after.streams_blocked, 0);
262 assert_eq!(stats_after.new_connection_id, 0);
263 assert_eq!(stats_after.new_token, 0);
264 assert_eq!(stats_after.handshake_done, 1);
265 }
266
267 #[test]
268 fn important() {
269 let (mut client, mut server) = connect_for_0rtt();
270
271 let id = server.stream_create(StreamType::UniDi).unwrap();
272 server
273 .stream_priority(
274 id,
275 TransmissionPriority::Important,
276 RetransmissionPriority::default(),
277 )
278 .unwrap();
279 fill_stream(&mut server, id);
280
281 // Important beats everything but flow control.
282 // Make enough streams to get a STREAMS_BLOCKED frame out.
283 while server.stream_create(StreamType::UniDi).is_ok() {}
284
285 let stats_before = server.stats().frame_tx;
286 let dgram = server.process_output(now()).dgram();
287 let stats_after = server.stats().frame_tx;
288 assert_eq!(stats_after.crypto, stats_before.crypto + 2);
289 assert_eq!(stats_after.streams_blocked, 1);
290 assert_eq!(stats_after.new_connection_id, 0);
291 assert_eq!(stats_after.new_token, 0);
292 assert_eq!(stats_after.handshake_done, 0);
293 assert_eq!(stats_after.stream, stats_before.stream + 1);
294
295 // Complete the handshake.
296 complete_handshake(&mut client, &mut server, dgram);
297
298 // Important beats everything but flow control.
299 let stats_before = server.stats().frame_tx;
300 drop(fill_cwnd(&mut server, id, now()));
301 let stats_after = server.stats().frame_tx;
302 assert_eq!(stats_after.crypto, stats_before.crypto);
303 assert_eq!(stats_after.streams_blocked, 1);
304 assert_eq!(stats_after.new_connection_id, 0);
305 assert_eq!(stats_after.new_token, 0);
306 assert_eq!(stats_after.handshake_done, 1);
307 assert!(stats_after.stream > stats_before.stream);
308 }
309
310 #[test]
311 fn high_normal() {
312 let (mut client, mut server) = connect_for_0rtt();
313
314 let id = server.stream_create(StreamType::UniDi).unwrap();
315 server
316 .stream_priority(
317 id,
318 TransmissionPriority::High,
319 RetransmissionPriority::default(),
320 )
321 .unwrap();
322 fill_stream(&mut server, id);
323
324 // Important beats everything but flow control.
325 // Make enough streams to get a STREAMS_BLOCKED frame out.
326 while server.stream_create(StreamType::UniDi).is_ok() {}
327
328 let stats_before = server.stats().frame_tx;
329 let dgram = server.process_output(now()).dgram();
330 let stats_after = server.stats().frame_tx;
331 assert_eq!(stats_after.crypto, stats_before.crypto + 2);
332 assert_eq!(stats_after.streams_blocked, 1);
333 assert_eq!(stats_after.new_connection_id, 0);
334 assert_eq!(stats_after.new_token, 0);
335 assert_eq!(stats_after.handshake_done, 0);
336 assert_eq!(stats_after.stream, stats_before.stream + 1);
337
338 // Complete the handshake.
339 complete_handshake(&mut client, &mut server, dgram);
340
341 // High or Normal doesn't beat NEW_CONNECTION_ID,
342 // but they beat CRYPTO/NEW_TOKEN.
343 let stats_before = server.stats().frame_tx;
344 server.send_ticket(now(), &[]).unwrap();
345 drop(fill_cwnd(&mut server, id, now()));
346 let stats_after = server.stats().frame_tx;
347 assert_eq!(stats_after.crypto, stats_before.crypto);
348 assert_eq!(stats_after.streams_blocked, 1);
349 assert_ne!(stats_after.new_connection_id, 0); // Note: > 0
350 assert_eq!(stats_after.new_token, 0);
351 assert_eq!(stats_after.handshake_done, 1);
352 assert!(stats_after.stream > stats_before.stream);
353 }
354
355 #[test]
356 fn low() {
357 let mut client = default_client();
358 let mut server = default_server();
359 let now = now();
360 // Use address validation; note that we need to hold a strong reference
361 // as the server will only hold a weak reference.
362 let validation = Rc::new(RefCell::new(
363 AddressValidation::new(now, ValidateAddress::Never).unwrap(),
364 ));
365 server.set_validation(&validation);
366 connect(&mut client, &mut server);
367
368 let id = server.stream_create(StreamType::UniDi).unwrap();
369 server
370 .stream_priority(
371 id,
372 TransmissionPriority::Low,
373 RetransmissionPriority::default(),
374 )
375 .unwrap();
376 fill_stream(&mut server, id);
377
378 // Send a session ticket and make it big enough to require a whole packet.
379 // The resulting CRYPTO frame beats out the stream data.
380 let stats_before = server.stats().frame_tx;
381 server.send_ticket(now, &vec![0; server.plpmtu()]).unwrap();
382 drop(server.process_output(now));
383 let stats_after = server.stats().frame_tx;
384 assert_eq!(stats_after.crypto, stats_before.crypto + 1);
385 assert_eq!(stats_after.stream, stats_before.stream);
386
387 // The above can't test if NEW_TOKEN wins because once that fits in a packet,
388 // it is very hard to ensure that the STREAM frame won't also fit.
389 // However, we can ensure that the next packet doesn't consist of just STREAM.
390 let stats_before = server.stats().frame_tx;
391 drop(server.process_output(now));
392 let stats_after = server.stats().frame_tx;
393 assert_eq!(stats_after.crypto, stats_before.crypto + 1);
394 assert_eq!(stats_after.new_token, 1);
395 assert_eq!(stats_after.stream, stats_before.stream + 1);
396 }