runite 0.1.0

An event-loop-per-thread async runtime built on io_uring (Linux), kqueue (macOS), and IOCP (Windows)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

//! # Async filesystem tour
//!
//! Reads metadata, file contents, and directory listings through the async
//! `runite::fs` API — `io_uring`-backed on Linux. A feature tour rather than an
//! application; see `command_center.rs` and friends for the model in action.
//!
//! Run it: `cargo run --example async_fs_showcase`

use runite::fs::{self, File};
use std::path::PathBuf;

fn preview(bytes: &[u8]) -> String {
    String::from_utf8_lossy(bytes).replace('\n', "\\n")
}

#[runite::main]
async fn main() {
    let manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    let cargo_toml = manifest_dir.join("Cargo.toml");
    let src_dir = manifest_dir.join("src");

    println!("manifest dir: {}", manifest_dir.display());

    let cargo_meta = fs::metadata(&cargo_toml)
        .await
        .expect("Cargo.toml metadata should load");
    println!(
        "Cargo.toml: {} bytes, file={}, empty={}",
        cargo_meta.len(),
        cargo_meta.is_file(),
        cargo_meta.is_empty()
    );

    let mut file = File::open(&cargo_toml)
        .await
        .expect("Cargo.toml should open for reading");
    let file_meta = file
        .metadata()
        .await
        .expect("opened file metadata should load");
    println!("opened file metadata size: {}", file_meta.len());

    let mut sequential = vec![0; 96];
    let sequential_read = file
        .read(&mut sequential)
        .await
        .expect("sequential read should succeed");
    sequential.truncate(sequential_read);
    println!(
        "sequential read ({sequential_read} bytes): {}",
        preview(&sequential)
    );

    let cloned = file.try_clone().await.expect("file clone should succeed");
    let mut positioned = [0u8; 48];
    let positioned_read = cloned
        .read_at(0, &mut positioned)
        .await
        .expect("positioned read should succeed");
    println!(
        "positioned read ({positioned_read} bytes): {}",
        preview(&positioned[..positioned_read])
    );

    let cargo_text = fs::read_to_string(&cargo_toml)
        .await
        .expect("read_to_string should succeed");
    println!("Cargo.toml line count: {}", cargo_text.lines().count());

    let mut dir = fs::read_dir(&src_dir)
        .await
        .expect("src directory should be readable");
    let mut entries = Vec::new();
    while let Some(entry) = dir
        .next_entry()
        .await
        .expect("read_dir stream should succeed")
    {
        let metadata = entry.metadata().await.expect("entry metadata should load");
        let kind = if metadata.is_dir() { "dir" } else { "file" };
        entries.push((entry.file_name().to_string_lossy().into_owned(), kind));
    }
    entries.sort_by(|left, right| left.0.cmp(&right.0));

    println!("src entries:");
    for (name, kind) in entries.iter().take(8) {
        println!("  - {name} ({kind})");
    }
}