flop 0.2.7

floppy-disk facades for common archive formats!
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
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
127
128
129
130
131
132
133
134
135
136

use std::sync::Arc;

use smoosh::CompressionType;
use tokio::io::AsyncReadExt;
use tracing::debug;

crate::util::archive_format!(Cpio, "a.cpio", cpio_open, cpio_close);

async fn cpio_open<P: Into<PathBuf>>(path: P) -> Result<CpioInternalMetadata> {
    let path = path.into();
    if !crate::util::exists_async(path.clone()).await {
        debug!("creating new cpio archive at {}...", path.display());
        tokio::fs::File::create(&path).await?;
        return Ok(CpioInternalMetadata {
            delegate: MemFloppyDisk::new(),
            compression: CompressionType::None,
            ordered_paths: IndexSet::new(),
        });
    }

    debug!("loading cpio archive from {}...", path.display());
    let out = MemFloppyDisk::new();
    let mut ordered_paths = IndexSet::new();
    let mut file = crate::util::async_file(path).await?;
    let mut buffer = vec![];
    let c = smoosh::recompress(&mut file, &mut buffer, smoosh::CompressionType::None).await?;
    debug!("loaded cpio archive!");

    debug!("reading cpio entries...");
    for file in cpio_reader::iter_files(&buffer) {
        debug!("reading next entry...");
        let file_path = if file.name().starts_with('/') {
            PathBuf::from(file.name())
        } else {
            PathBuf::from("/").join(file.name())
        };
        ordered_paths.insert(file_path.clone());

        if let Some(parent) = file_path.parent() {
            out.create_dir_all(parent).await?;
        }
        let mut mem_file = MemOpenOptions::new()
            .create(true)
            .write(true)
            .open(&out, &file_path)
            .await?;
        debug!("found cpio file: {}", file_path.display());
        let cpio_file_content = file.file().to_vec();
        let mut buf = vec![];
        smoosh::recompress(
            &mut cpio_file_content.as_slice(),
            &mut buf,
            CompressionType::None,
        )
        .await?;

        // TODO: random trailing null bytes show up and idk WHY ;-;
        let mut buf_slice = if buf[buf.len() - 1] == 0 {
            &buf[0..buf.len() - 1]
        } else {
            buf.as_slice()
        };
        tokio::io::copy(&mut buf_slice, &mut mem_file).await?;
        debug!("copied bytes!");
        mem_file
            .set_permissions(MemPermissions::from_mode(file.mode().bits()))
            .await?;
        debug!("set perms!");

        let uid = file.uid();
        let gid = file.gid();
        out.chown(&file_path, uid, gid).await?;
        debug!("loaded file!");
    }

    Ok(CpioInternalMetadata {
        delegate: out,
        compression: c,
        ordered_paths,
    })
}

async fn cpio_close(
    disk: &MemFloppyDisk,
    scope: &Path,
    compression: CompressionType,
    ordered_paths: &IndexSet<PathBuf>,
) -> Result<()> {
    let scope_clone = scope.to_path_buf();
    debug!("closing cpio archive at {}...", scope.display());
    let buffer = Arc::new(std::sync::Mutex::new(vec![]));

    debug!("found {} paths!", ordered_paths.len());
    for path in ordered_paths {
        let metadata = disk.metadata(path).await?;
        if metadata.is_file() {
            let writer = cpio::newc::Builder::new(&path.to_string_lossy());
            let mut handle = MemOpenOptions::new().read(true).open(disk, path).await?;

            let mut data = vec![];
            handle.read_to_end(&mut data).await?;

            let archive = buffer.clone();
            tokio::task::spawn_blocking(move || {
                let mut archive = archive.lock().unwrap();
                let mut writer = writer
                    .gid(metadata.gid().unwrap())
                    .uid(metadata.uid().unwrap())
                    .mode(metadata.permissions().mode())
                    .write(&mut *archive, metadata.len() as u32);

                std::io::copy(&mut data.as_slice(), &mut writer).unwrap();

                writer.finish().unwrap();
            })
            .await?;
            debug!("wrote file: {}", path.display());
        }
    }

    let mut file = tokio::fs::OpenOptions::new()
        .write(true)
        .truncate(true)
        .open(scope_clone)
        .await?;
    // TODO: Is there a better way to pull this data out?
    let buffer = tokio::task::spawn_blocking(move || {
        let data = buffer.lock().unwrap();
        data.clone()
    })
    .await?;
    smoosh::recompress(&mut buffer.as_slice(), &mut file, compression).await?;
    debug!("wrote cpio archive!");

    Ok(())
}