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

//! Filesystem semantics: `symlink_metadata`, `File::seek`, and
//! full-`st_mode` `Metadata::mode`.

#![cfg(unix)]

use std::io::SeekFrom;
use std::os::unix::fs::symlink;

/// `S_IFMT` / `S_IFREG` as octal literals (libc is not a dev-dependency).
const S_IFMT: u32 = 0o170000;
const S_IFREG: u32 = 0o100000;

fn temp_path(label: &str) -> std::path::PathBuf {
    std::env::temp_dir().join(format!("runite-{label}-{}", std::process::id()))
}

/// `metadata` follows symlinks; `symlink_metadata` reports the link itself.
#[runite::test]
async fn symlink_metadata_does_not_follow() {
    let dir = temp_path("symlink-meta");
    std::fs::create_dir_all(&dir).expect("mkdir");
    let target = dir.join("target.txt");
    let link = dir.join("link");
    std::fs::write(&target, b"data").expect("write target");
    let _ = std::fs::remove_file(&link);
    symlink(&target, &link).expect("symlink");

    let followed = runite::fs::metadata(&link).await.expect("metadata");
    assert!(followed.is_file(), "metadata should follow to the file");
    assert!(!followed.is_symlink());

    let link_meta = runite::fs::symlink_metadata(&link)
        .await
        .expect("symlink_metadata");
    assert!(
        link_meta.is_symlink(),
        "symlink_metadata should see the link"
    );
    assert!(!link_meta.is_file());

    std::fs::remove_dir_all(&dir).expect("cleanup");
}

/// `Metadata::mode` includes the file-type bits, not just permissions, and is
/// consistent across backends.
#[runite::test]
async fn mode_includes_file_type_bits() {
    let path = temp_path("mode");
    std::fs::write(&path, b"x").expect("write");
    let meta = runite::fs::metadata(&path).await.expect("metadata");
    assert_eq!(
        meta.mode() & S_IFMT,
        S_IFREG,
        "mode() should carry the regular-file type bits (full st_mode)"
    );
    std::fs::remove_file(&path).expect("cleanup");
}

/// `File::seek` repositions the shared kernel cursor for sequential reads.
#[runite::test]
async fn file_seek_repositions_cursor() {
    let path = temp_path("seek");
    std::fs::write(&path, b"0123456789").expect("write");

    let mut file = runite::fs::File::open(&path).await.expect("open");

    assert_eq!(file.seek(SeekFrom::Start(4)).await.expect("seek start"), 4);
    let mut buf = [0u8; 3];
    file.read_exact(&mut buf).await.expect("read after seek");
    assert_eq!(&buf, b"456");

    // The read advanced the cursor to 7.
    assert_eq!(
        file.seek(SeekFrom::Current(0)).await.expect("seek current"),
        7
    );
    assert_eq!(file.seek(SeekFrom::End(-2)).await.expect("seek end"), 8);

    std::fs::remove_file(&path).expect("cleanup");
}