ocinoco 0.1.0

Build OCI image with no container
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use std::io::Result;
use std::path::{Path, PathBuf};

use rayon::iter::{ParallelBridge, ParallelIterator};

use crate::fs::{DirEntry, File, Source, Symlink};

#[cfg(unix)]
use std::os::unix::fs::MetadataExt;

pub(crate) struct OsSource {
    root_dir: PathBuf,
}

impl OsSource {
    pub(crate) fn new(root_dir: impl AsRef<Path>) -> Self {
        Self {
            root_dir: root_dir.as_ref().to_path_buf(),
        }
    }
}

impl Source for OsSource {
    fn read_dir(&self, path: &Path) -> Result<impl ParallelIterator<Item = DirEntry>> {
        let root_dir = self.root_dir.clone();

        Ok(std::fs::read_dir(self.resolve(path))?
            .par_bridge()
            .filter_map(move |entry| {
                let entry = entry.ok()?;
                let file_type = entry.file_type().ok()?;
                let path = entry.path().strip_prefix(&root_dir).ok()?.to_path_buf();

                if file_type.is_symlink() {
                    Some(DirEntry::Symlink(Symlink {
                        path,
                        target: entry.path().read_link().ok()?,
                        #[cfg(unix)]
                        mode: entry.metadata().ok()?.mode(),
                        #[cfg(not(unix))]
                        mode: 644,
                    }))
                } else if file_type.is_file() {
                    Some(DirEntry::File(File {
                        path,
                        #[cfg(unix)]
                        mode: entry.metadata().ok()?.mode(),
                        #[cfg(not(unix))]
                        mode: 644,
                    }))
                } else if file_type.is_dir() {
                    Some(DirEntry::Directory(path))
                } else {
                    None
                }
            }))
    }

    fn read(&self, path: &Path) -> Result<Vec<u8>> {
        std::fs::read(self.resolve(path))
    }
}

impl OsSource {
    fn resolve(&self, path: &Path) -> PathBuf {
        self.root_dir.join(path.strip_prefix("/").unwrap_or(path))
    }
}

#[cfg(test)]
mod tests {
    use std::fs;
    use std::time::{SystemTime, UNIX_EPOCH};

    use rayon::iter::ParallelIterator;

    use super::*;

    fn temp_root() -> PathBuf {
        let nanos = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_nanos();

        std::env::temp_dir().join(format!("ocinoco-os-source-{nanos}"))
    }

    #[test]
    fn reads_paths_under_root_dir_even_when_path_is_absolute() {
        let root = temp_root();
        fs::create_dir_all(root.join("nested")).unwrap();
        fs::write(root.join("nested/file.txt"), b"content").unwrap();
        fs::write(root.join("root.txt"), b"root").unwrap();

        let source = OsSource::new(&root);
        let mut entries = source.read_dir(Path::new("/")).unwrap().collect::<Vec<_>>();

        entries.sort_by_key(|entry| match entry {
            DirEntry::Directory(path) => path.clone(),
            DirEntry::File(file) => file.path.clone(),
            DirEntry::Symlink(symlink) => symlink.path.clone(),
        });

        assert!(entries.iter().any(|entry| {
            matches!(entry, DirEntry::Directory(path) if path == Path::new("nested"))
        }));
        assert!(entries.iter().any(|entry| {
            matches!(entry, DirEntry::File(file) if file.path == Path::new("root.txt"))
        }));
        assert_eq!(
            source.read(Path::new("/nested/file.txt")).unwrap(),
            b"content"
        );

        fs::remove_dir_all(root).unwrap();
    }

    #[test]
    fn resolves_relative_paths_under_root_dir() {
        let root = temp_root();
        let source = OsSource::new(&root);

        assert_eq!(source.resolve(Path::new("/a/b")), root.join("a/b"));
        assert_eq!(source.resolve(Path::new("a/b")), root.join("a/b"));
    }
}