Line data Source code
1 : //! Implementation of append-only file data structure
2 : //! used to keep in-memory layers spilled on disk.
3 :
4 : use std::io;
5 : use std::sync::Arc;
6 : use std::sync::atomic::AtomicU64;
7 :
8 : use camino::Utf8PathBuf;
9 : use num_traits::Num;
10 : use pageserver_api::shard::TenantShardId;
11 : use tokio_epoll_uring::{BoundedBuf, Slice};
12 : use tracing::{error, info_span};
13 : use utils::id::TimelineId;
14 :
15 : use crate::assert_u64_eq_usize::{U64IsUsize, UsizeIsU64};
16 : use crate::config::PageServerConf;
17 : use crate::context::RequestContext;
18 : use crate::page_cache;
19 : use crate::tenant::storage_layer::inmemory_layer::vectored_dio_read::File;
20 : use crate::virtual_file::owned_buffers_io::io_buf_aligned::IoBufAlignedMut;
21 : use crate::virtual_file::owned_buffers_io::slice::SliceMutExt;
22 : use crate::virtual_file::owned_buffers_io::write::Buffer;
23 : use crate::virtual_file::{self, IoBufferMut, VirtualFile, owned_buffers_io};
24 :
25 : pub struct EphemeralFile {
26 : _tenant_shard_id: TenantShardId,
27 : _timeline_id: TimelineId,
28 : page_cache_file_id: page_cache::FileId,
29 : bytes_written: u64,
30 : buffered_writer: owned_buffers_io::write::BufferedWriter<IoBufferMut, VirtualFile>,
31 : /// Gate guard is held on as long as we need to do operations in the path (delete on drop)
32 : _gate_guard: utils::sync::gate::GateGuard,
33 : }
34 :
35 : const TAIL_SZ: usize = 64 * 1024;
36 :
37 : impl EphemeralFile {
38 2632 : pub async fn create(
39 2632 : conf: &PageServerConf,
40 2632 : tenant_shard_id: TenantShardId,
41 2632 : timeline_id: TimelineId,
42 2632 : gate: &utils::sync::gate::Gate,
43 2632 : ctx: &RequestContext,
44 2632 : ) -> anyhow::Result<EphemeralFile> {
45 : static NEXT_FILENAME: AtomicU64 = AtomicU64::new(1);
46 2632 : let filename_disambiguator =
47 2632 : NEXT_FILENAME.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
48 2632 :
49 2632 : let filename = conf
50 2632 : .timeline_path(&tenant_shard_id, &timeline_id)
51 2632 : .join(Utf8PathBuf::from(format!(
52 2632 : "ephemeral-{filename_disambiguator}"
53 2632 : )));
54 :
55 2632 : let file = Arc::new(
56 2632 : VirtualFile::open_with_options_v2(
57 2632 : &filename,
58 2632 : virtual_file::OpenOptions::new()
59 2632 : .read(true)
60 2632 : .write(true)
61 2632 : .create(true),
62 2632 : ctx,
63 2632 : )
64 2632 : .await?,
65 : );
66 :
67 2632 : let page_cache_file_id = page_cache::next_file_id(); // XXX get rid, we're not page-caching anymore
68 2632 :
69 2632 : Ok(EphemeralFile {
70 2632 : _tenant_shard_id: tenant_shard_id,
71 2632 : _timeline_id: timeline_id,
72 2632 : page_cache_file_id,
73 2632 : bytes_written: 0,
74 2632 : buffered_writer: owned_buffers_io::write::BufferedWriter::new(
75 2632 : file,
76 5264 : || IoBufferMut::with_capacity(TAIL_SZ),
77 2632 : gate.enter()?,
78 2632 : ctx,
79 2632 : info_span!(parent: None, "ephemeral_file_buffered_writer", tenant_id=%tenant_shard_id.tenant_id, shard_id=%tenant_shard_id.shard_slug(), timeline_id=%timeline_id, path = %filename),
80 : ),
81 2632 : _gate_guard: gate.enter()?,
82 : })
83 2632 : }
84 : }
85 :
86 : impl Drop for EphemeralFile {
87 2380 : fn drop(&mut self) {
88 2380 : // unlink the file
89 2380 : // we are clear to do this, because we have entered a gate
90 2380 : let path = self.buffered_writer.as_inner().path();
91 2380 : let res = std::fs::remove_file(path);
92 2380 : if let Err(e) = res {
93 4 : if e.kind() != std::io::ErrorKind::NotFound {
94 : // just never log the not found errors, we cannot do anything for them; on detach
95 : // the tenant directory is already gone.
96 : //
97 : // not found files might also be related to https://github.com/neondatabase/neon/issues/2442
98 0 : error!("could not remove ephemeral file '{path}': {e}");
99 4 : }
100 2376 : }
101 2380 : }
102 : }
103 :
104 : impl EphemeralFile {
105 19226220 : pub(crate) fn len(&self) -> u64 {
106 19226220 : self.bytes_written
107 19226220 : }
108 :
109 2616 : pub(crate) fn page_cache_file_id(&self) -> page_cache::FileId {
110 2616 : self.page_cache_file_id
111 2616 : }
112 :
113 1940 : pub(crate) async fn load_to_io_buf(
114 1940 : &self,
115 1940 : ctx: &RequestContext,
116 1940 : ) -> Result<IoBufferMut, io::Error> {
117 1940 : let size = self.len().into_usize();
118 1940 : let buf = IoBufferMut::with_capacity(size);
119 1940 : let (slice, nread) = self.read_exact_at_eof_ok(0, buf.slice_full(), ctx).await?;
120 1940 : assert_eq!(nread, size);
121 1940 : let buf = slice.into_inner();
122 1940 : assert_eq!(buf.len(), nread);
123 1940 : assert_eq!(buf.capacity(), size, "we shouldn't be reallocating");
124 1940 : Ok(buf)
125 1940 : }
126 :
127 : /// Returns the offset at which the first byte of the input was written, for use
128 : /// in constructing indices over the written value.
129 : ///
130 : /// Panics if the write is short because there's no way we can recover from that.
131 : /// TODO: make upstack handle this as an error.
132 9609764 : pub(crate) async fn write_raw(
133 9609764 : &mut self,
134 9609764 : srcbuf: &[u8],
135 9609764 : ctx: &RequestContext,
136 9609764 : ) -> std::io::Result<u64> {
137 9609764 : let (pos, control) = self.write_raw_controlled(srcbuf, ctx).await?;
138 9609764 : if let Some(control) = control {
139 11068 : control.release().await;
140 9598696 : }
141 9609764 : Ok(pos)
142 9609764 : }
143 :
144 9609768 : async fn write_raw_controlled(
145 9609768 : &mut self,
146 9609768 : srcbuf: &[u8],
147 9609768 : ctx: &RequestContext,
148 9609768 : ) -> std::io::Result<(u64, Option<owned_buffers_io::write::FlushControl>)> {
149 9609768 : let pos = self.bytes_written;
150 :
151 9609768 : let new_bytes_written = pos.checked_add(srcbuf.len().into_u64()).ok_or_else(|| {
152 0 : std::io::Error::other(format!(
153 0 : "write would grow EphemeralFile beyond u64::MAX: len={pos} writen={srcbuf_len}",
154 0 : srcbuf_len = srcbuf.len(),
155 0 : ))
156 9609768 : })?;
157 :
158 : // Write the payload
159 9609768 : let (nwritten, control) = self
160 9609768 : .buffered_writer
161 9609768 : .write_buffered_borrowed_controlled(srcbuf, ctx)
162 9609768 : .await?;
163 9609768 : assert_eq!(
164 9609768 : nwritten,
165 9609768 : srcbuf.len(),
166 0 : "buffered writer has no short writes"
167 : );
168 :
169 9609768 : self.bytes_written = new_bytes_written;
170 9609768 :
171 9609768 : Ok((pos, control))
172 9609768 : }
173 : }
174 :
175 : impl super::storage_layer::inmemory_layer::vectored_dio_read::File for EphemeralFile {
176 997696 : async fn read_exact_at_eof_ok<B: IoBufAlignedMut + Send>(
177 997696 : &self,
178 997696 : start: u64,
179 997696 : dst: tokio_epoll_uring::Slice<B>,
180 997696 : ctx: &RequestContext,
181 997696 : ) -> std::io::Result<(tokio_epoll_uring::Slice<B>, usize)> {
182 997696 : let submitted_offset = self.buffered_writer.bytes_submitted();
183 997696 :
184 997696 : let mutable = self.buffered_writer.inspect_mutable();
185 997696 : let mutable = &mutable[0..mutable.pending()];
186 997696 :
187 997696 : let maybe_flushed = self.buffered_writer.inspect_maybe_flushed();
188 997696 :
189 997696 : let dst_cap = dst.bytes_total().into_u64();
190 997696 : let end = {
191 : // saturating_add is correct here because the max file size is u64::MAX, so,
192 : // if start + dst.len() > u64::MAX, then we know it will be a short read
193 997696 : let mut end: u64 = start.saturating_add(dst_cap);
194 997696 : if end > self.bytes_written {
195 554384 : end = self.bytes_written;
196 554384 : }
197 997696 : end
198 : };
199 :
200 : // inclusive, exclusive
201 : #[derive(Debug)]
202 : struct Range<N>(N, N);
203 : impl<N: Num + Clone + Copy + PartialOrd + Ord> Range<N> {
204 6614137 : fn len(&self) -> N {
205 6614137 : if self.0 > self.1 {
206 3549569 : N::zero()
207 : } else {
208 3064568 : self.1 - self.0
209 : }
210 6614137 : }
211 : }
212 :
213 997696 : let (written_range, maybe_flushed_range) = {
214 997696 : if maybe_flushed.is_some() {
215 : // [ written ][ maybe_flushed ][ mutable ]
216 : // <- TAIL_SZ -><- TAIL_SZ ->
217 : // ^
218 : // `submitted_offset`
219 : // <++++++ on disk +++++++????????????????>
220 976910 : (
221 976910 : Range(
222 976910 : start,
223 976910 : std::cmp::min(end, submitted_offset.saturating_sub(TAIL_SZ as u64)),
224 976910 : ),
225 976910 : Range(
226 976910 : std::cmp::max(start, submitted_offset.saturating_sub(TAIL_SZ as u64)),
227 976910 : std::cmp::min(end, submitted_offset),
228 976910 : ),
229 976910 : )
230 : } else {
231 : // [ written ][ mutable ]
232 : // <- TAIL_SZ ->
233 : // ^
234 : // `submitted_offset`
235 : // <++++++ on disk +++++++++++++++++++++++>
236 20786 : (
237 20786 : Range(start, std::cmp::min(end, submitted_offset)),
238 20786 : // zero len
239 20786 : Range(submitted_offset, u64::MIN),
240 20786 : )
241 : }
242 : };
243 :
244 997696 : let mutable_range = Range(std::cmp::max(start, submitted_offset), end);
245 :
246 997696 : let dst = if written_range.len() > 0 {
247 20377 : let file: &VirtualFile = self.buffered_writer.as_inner();
248 20377 : let bounds = dst.bounds();
249 20377 : let slice = file
250 20377 : .read_exact_at(dst.slice(0..written_range.len().into_usize()), start, ctx)
251 20377 : .await?;
252 20377 : Slice::from_buf_bounds(Slice::into_inner(slice), bounds)
253 : } else {
254 977319 : dst
255 : };
256 :
257 997696 : let dst = if maybe_flushed_range.len() > 0 {
258 320952 : let offset_in_buffer = maybe_flushed_range
259 320952 : .0
260 320952 : .checked_sub(submitted_offset.saturating_sub(TAIL_SZ as u64))
261 320952 : .unwrap()
262 320952 : .into_usize();
263 320952 : // Checked previously the buffer is Some.
264 320952 : let maybe_flushed = maybe_flushed.unwrap();
265 320952 : let to_copy = &maybe_flushed
266 320952 : [offset_in_buffer..(offset_in_buffer + maybe_flushed_range.len().into_usize())];
267 320952 : let bounds = dst.bounds();
268 320952 : let mut view = dst.slice({
269 320952 : let start = written_range.len().into_usize();
270 320952 : let end = start
271 320952 : .checked_add(maybe_flushed_range.len().into_usize())
272 320952 : .unwrap();
273 320952 : start..end
274 320952 : });
275 320952 : view.as_mut_rust_slice_full_zeroed()
276 320952 : .copy_from_slice(to_copy);
277 320952 : Slice::from_buf_bounds(Slice::into_inner(view), bounds)
278 : } else {
279 676744 : dst
280 : };
281 :
282 997696 : let dst = if mutable_range.len() > 0 {
283 659454 : let offset_in_buffer = mutable_range
284 659454 : .0
285 659454 : .checked_sub(submitted_offset)
286 659454 : .unwrap()
287 659454 : .into_usize();
288 659454 : let to_copy =
289 659454 : &mutable[offset_in_buffer..(offset_in_buffer + mutable_range.len().into_usize())];
290 659454 : let bounds = dst.bounds();
291 659454 : let mut view = dst.slice({
292 659454 : let start =
293 659454 : written_range.len().into_usize() + maybe_flushed_range.len().into_usize();
294 659454 : let end = start.checked_add(mutable_range.len().into_usize()).unwrap();
295 659454 : start..end
296 659454 : });
297 659454 : view.as_mut_rust_slice_full_zeroed()
298 659454 : .copy_from_slice(to_copy);
299 659454 : Slice::from_buf_bounds(Slice::into_inner(view), bounds)
300 : } else {
301 338242 : dst
302 : };
303 :
304 : // TODO: in debug mode, randomize the remaining bytes in `dst` to catch bugs
305 :
306 997696 : Ok((dst, (end - start).into_usize()))
307 997696 : }
308 : }
309 :
310 : /// Does the given filename look like an ephemeral file?
311 0 : pub fn is_ephemeral_file(filename: &str) -> bool {
312 0 : if let Some(rest) = filename.strip_prefix("ephemeral-") {
313 0 : rest.parse::<u32>().is_ok()
314 : } else {
315 0 : false
316 : }
317 0 : }
318 :
319 : #[cfg(test)]
320 : mod tests {
321 : use std::fs;
322 : use std::str::FromStr;
323 :
324 : use rand::Rng;
325 :
326 : use super::*;
327 : use crate::context::DownloadBehavior;
328 : use crate::task_mgr::TaskKind;
329 :
330 16 : fn harness(
331 16 : test_name: &str,
332 16 : ) -> Result<
333 16 : (
334 16 : &'static PageServerConf,
335 16 : TenantShardId,
336 16 : TimelineId,
337 16 : RequestContext,
338 16 : ),
339 16 : io::Error,
340 16 : > {
341 16 : let repo_dir = PageServerConf::test_repo_dir(test_name);
342 16 : let _ = fs::remove_dir_all(&repo_dir);
343 16 : let conf = PageServerConf::dummy_conf(repo_dir);
344 16 : // Make a static copy of the config. This can never be free'd, but that's
345 16 : // OK in a test.
346 16 : let conf: &'static PageServerConf = Box::leak(Box::new(conf));
347 16 :
348 16 : let tenant_shard_id = TenantShardId::from_str("11000000000000000000000000000000").unwrap();
349 16 : let timeline_id = TimelineId::from_str("22000000000000000000000000000000").unwrap();
350 16 : fs::create_dir_all(conf.timeline_path(&tenant_shard_id, &timeline_id))?;
351 :
352 16 : let ctx =
353 16 : RequestContext::new(TaskKind::UnitTest, DownloadBehavior::Error).with_scope_unit_test();
354 16 :
355 16 : Ok((conf, tenant_shard_id, timeline_id, ctx))
356 16 : }
357 :
358 : #[tokio::test]
359 4 : async fn ephemeral_file_holds_gate_open() {
360 4 : const FOREVER: std::time::Duration = std::time::Duration::from_secs(5);
361 4 :
362 4 : let (conf, tenant_id, timeline_id, ctx) =
363 4 : harness("ephemeral_file_holds_gate_open").unwrap();
364 4 :
365 4 : let gate = utils::sync::gate::Gate::default();
366 4 :
367 4 : let file = EphemeralFile::create(conf, tenant_id, timeline_id, &gate, &ctx)
368 4 : .await
369 4 : .unwrap();
370 4 :
371 4 : let mut closing = tokio::task::spawn(async move {
372 4 : gate.close().await;
373 4 : });
374 4 :
375 4 : // gate is entered until the ephemeral file is dropped
376 4 : // do not start paused tokio-epoll-uring has a sleep loop
377 4 : tokio::time::pause();
378 4 : tokio::time::timeout(FOREVER, &mut closing)
379 4 : .await
380 4 : .expect_err("closing cannot complete before dropping");
381 4 :
382 4 : // this is a requirement of the reset_tenant functionality: we have to be able to restart a
383 4 : // tenant fast, and for that, we need all tenant_dir operations be guarded by entering a gate
384 4 : drop(file);
385 4 :
386 4 : tokio::time::timeout(FOREVER, &mut closing)
387 4 : .await
388 4 : .expect("closing completes right away")
389 4 : .expect("closing does not panic");
390 4 : }
391 :
392 : #[tokio::test]
393 4 : async fn test_ephemeral_file_basics() {
394 4 : let (conf, tenant_id, timeline_id, ctx) = harness("test_ephemeral_file_basics").unwrap();
395 4 :
396 4 : let gate = utils::sync::gate::Gate::default();
397 4 :
398 4 : let mut file = EphemeralFile::create(conf, tenant_id, timeline_id, &gate, &ctx)
399 4 : .await
400 4 : .unwrap();
401 4 :
402 4 : let mutable = file.buffered_writer.inspect_mutable();
403 4 : let cap = mutable.capacity();
404 4 : let align = mutable.align();
405 4 :
406 4 : let write_nbytes = cap * 2 + cap / 2;
407 4 :
408 4 : let content: Vec<u8> = rand::thread_rng()
409 4 : .sample_iter(rand::distributions::Standard)
410 4 : .take(write_nbytes)
411 4 : .collect();
412 4 :
413 4 : let mut value_offsets = Vec::new();
414 1280 : for range in (0..write_nbytes)
415 4 : .step_by(align)
416 1280 : .map(|start| start..(start + align).min(write_nbytes))
417 4 : {
418 1280 : let off = file.write_raw(&content[range], &ctx).await.unwrap();
419 1280 : value_offsets.push(off);
420 4 : }
421 4 :
422 4 : assert_eq!(file.len() as usize, write_nbytes);
423 1280 : for (i, range) in (0..write_nbytes)
424 4 : .step_by(align)
425 1280 : .map(|start| start..(start + align).min(write_nbytes))
426 4 : .enumerate()
427 4 : {
428 1280 : assert_eq!(value_offsets[i], range.start.into_u64());
429 1280 : let buf = IoBufferMut::with_capacity(range.len());
430 1280 : let (buf_slice, nread) = file
431 1280 : .read_exact_at_eof_ok(range.start.into_u64(), buf.slice_full(), &ctx)
432 1280 : .await
433 1280 : .unwrap();
434 1280 : let buf = buf_slice.into_inner();
435 1280 : assert_eq!(nread, range.len());
436 1280 : assert_eq!(&buf, &content[range]);
437 4 : }
438 4 :
439 4 : let file_contents = std::fs::read(file.buffered_writer.as_inner().path()).unwrap();
440 4 : assert!(file_contents == content[0..cap * 2]);
441 4 :
442 4 : let maybe_flushed_buffer_contents = file.buffered_writer.inspect_maybe_flushed().unwrap();
443 4 : assert_eq!(&maybe_flushed_buffer_contents[..], &content[cap..cap * 2]);
444 4 :
445 4 : let mutable_buffer_contents = file.buffered_writer.inspect_mutable();
446 4 : assert_eq!(mutable_buffer_contents, &content[cap * 2..write_nbytes]);
447 4 : }
448 :
449 : #[tokio::test]
450 4 : async fn test_flushes_do_happen() {
451 4 : let (conf, tenant_id, timeline_id, ctx) = harness("test_flushes_do_happen").unwrap();
452 4 :
453 4 : let gate = utils::sync::gate::Gate::default();
454 4 :
455 4 : let mut file = EphemeralFile::create(conf, tenant_id, timeline_id, &gate, &ctx)
456 4 : .await
457 4 : .unwrap();
458 4 :
459 4 : // mutable buffer and maybe_flushed buffer each has `cap` bytes.
460 4 : let cap = file.buffered_writer.inspect_mutable().capacity();
461 4 :
462 4 : let content: Vec<u8> = rand::thread_rng()
463 4 : .sample_iter(rand::distributions::Standard)
464 4 : .take(cap * 2 + cap / 2)
465 4 : .collect();
466 4 :
467 4 : file.write_raw(&content, &ctx).await.unwrap();
468 4 :
469 4 : // assert the state is as this test expects it to be
470 4 : assert_eq!(
471 4 : &file.load_to_io_buf(&ctx).await.unwrap(),
472 4 : &content[0..cap * 2 + cap / 2]
473 4 : );
474 4 : let md = file.buffered_writer.as_inner().path().metadata().unwrap();
475 4 : assert_eq!(
476 4 : md.len(),
477 4 : 2 * cap.into_u64(),
478 4 : "buffered writer requires one write to be flushed if we write 2.5x buffer capacity"
479 4 : );
480 4 : assert_eq!(
481 4 : &file.buffered_writer.inspect_maybe_flushed().unwrap()[0..cap],
482 4 : &content[cap..cap * 2]
483 4 : );
484 4 : assert_eq!(
485 4 : &file.buffered_writer.inspect_mutable()[0..cap / 2],
486 4 : &content[cap * 2..cap * 2 + cap / 2]
487 4 : );
488 4 : }
489 :
490 : #[tokio::test]
491 4 : async fn test_read_split_across_file_and_buffer() {
492 4 : // This test exercises the logic on the read path that splits the logical read
493 4 : // into a read from the flushed part (= the file) and a copy from the buffered writer's buffer.
494 4 : //
495 4 : // This test build on the assertions in test_flushes_do_happen
496 4 :
497 4 : let (conf, tenant_id, timeline_id, ctx) =
498 4 : harness("test_read_split_across_file_and_buffer").unwrap();
499 4 :
500 4 : let gate = utils::sync::gate::Gate::default();
501 4 :
502 4 : let mut file = EphemeralFile::create(conf, tenant_id, timeline_id, &gate, &ctx)
503 4 : .await
504 4 : .unwrap();
505 4 :
506 4 : let mutable = file.buffered_writer.inspect_mutable();
507 4 : let cap = mutable.capacity();
508 4 : let align = mutable.align();
509 4 : let content: Vec<u8> = rand::thread_rng()
510 4 : .sample_iter(rand::distributions::Standard)
511 4 : .take(cap * 2 + cap / 2)
512 4 : .collect();
513 4 :
514 4 : let (_, control) = file.write_raw_controlled(&content, &ctx).await.unwrap();
515 4 :
516 108 : let test_read = |start: usize, len: usize| {
517 108 : let file = &file;
518 108 : let ctx = &ctx;
519 108 : let content = &content;
520 108 : async move {
521 108 : let (buf, nread) = file
522 108 : .read_exact_at_eof_ok(
523 108 : start.into_u64(),
524 108 : IoBufferMut::with_capacity(len).slice_full(),
525 108 : ctx,
526 108 : )
527 108 : .await
528 108 : .unwrap();
529 108 : assert_eq!(nread, len);
530 108 : assert_eq!(&buf.into_inner(), &content[start..(start + len)]);
531 108 : }
532 108 : };
533 4 :
534 12 : let test_read_all_offset_combinations = || {
535 12 : async move {
536 12 : test_read(align, align).await;
537 4 : // border onto edge of file
538 12 : test_read(cap - align, align).await;
539 4 : // read across file and buffer
540 12 : test_read(cap - align, 2 * align).await;
541 4 : // stay from start of maybe flushed buffer
542 12 : test_read(cap, align).await;
543 4 : // completely within maybe flushed buffer
544 12 : test_read(cap + align, align).await;
545 4 : // border onto edge of maybe flushed buffer.
546 12 : test_read(cap * 2 - align, align).await;
547 4 : // read across maybe flushed and mutable buffer
548 12 : test_read(cap * 2 - align, 2 * align).await;
549 4 : // read across three segments
550 12 : test_read(cap - align, cap + 2 * align).await;
551 4 : // completely within mutable buffer
552 12 : test_read(cap * 2 + align, align).await;
553 12 : }
554 12 : };
555 4 :
556 4 : // completely within the file range
557 4 : assert!(align < cap, "test assumption");
558 4 : assert!(cap % align == 0);
559 4 :
560 4 : // test reads at different flush stages.
561 4 : let not_started = control.unwrap().into_not_started();
562 4 : test_read_all_offset_combinations().await;
563 4 : let in_progress = not_started.ready_to_flush();
564 4 : test_read_all_offset_combinations().await;
565 4 : in_progress.wait_until_flush_is_done().await;
566 4 : test_read_all_offset_combinations().await;
567 4 : }
568 : }
|
