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

use std::io::Read;
use std::os::unix::prelude::{OsStrExt, OsStringExt};

use smoosh::CompressionType;
use tracing::debug;

crate::util::archive_format!(Ar, "a.ar", ar_open, ar_close);

async fn ar_open<P: Into<PathBuf>>(path: P) -> Result<ArInternalMetadata> {
    let path = path.into();
    if !crate::util::exists_async(path.clone()).await {
        debug!("creating empty ar {}!", path.display());
        let file = std::fs::File::create(path)?;
        debug!("created ar file!");
        let _archive = ar::Archive::new(&file);
        debug!("opened ar file!");
        return Ok(ArInternalMetadata {
            delegate: MemFloppyDisk::new(),
            compression: CompressionType::None,
            ordered_paths: IndexSet::new(),
        });
    } else {
        debug!("ar file exists!");
    }

    debug!("opening ar file {}", path.display());

    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?;

    let mut archive = ar::Archive::new(buffer.as_slice());
    let out = MemFloppyDisk::new();
    let mut ordered_paths = IndexSet::new();

    while let Some(entry) = archive.next_entry() {
        let mut entry = entry?;
        let header = entry.header();
        let path = PathBuf::from(OsString::from_vec(header.identifier().to_vec()));
        let path = if !path.starts_with("/") {
            PathBuf::from("/").join(path)
        } else {
            path
        };
        ordered_paths.insert(path.clone());
        debug!("processing archive path {}", path.display());

        if let Some(parent) = path.parent() {
            out.create_dir_all(parent).await?;
        }
        let mut handle = MemOpenOptions::new()
            .create(true)
            .write(true)
            .open(&out, &path)
            .await?;

        let mut data = vec![];
        entry.read_to_end(&mut data)?;
        tokio::io::copy(&mut data.as_slice(), &mut handle).await?;
        debug!("copied path!");
    }

    debug!("finished opening ar!");

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

async fn ar_close(
    disk: &MemFloppyDisk,
    scope: &Path,
    compression: CompressionType,
    ordered_paths: &IndexSet<PathBuf>,
) -> Result<()> {
    debug!("closing ar at {}", scope.display());
    let mut file = tokio::fs::OpenOptions::new()
        .write(true)
        .truncate(true) // TODO: Validate this is actually desired...
        .open(scope)
        .await?;
    let mut buffer = vec![];
    let mut archive = ar::Builder::new(&mut buffer);

    debug!("walking ar paths...");
    debug!("found {} paths!", ordered_paths.len());
    // We only need to write file paths into the ar.
    // Directories are implied by the file paths.
    for path in ordered_paths {
        debug!("processing archive path {}", path.display());
        let metadata = disk.metadata(path).await?;
        if metadata.is_file() {
            debug!("reading from memfs...");
            let mut handle = MemOpenOptions::new().read(true).open(disk, path).await?;

            let mut data = vec![];
            tokio::io::AsyncReadExt::read_to_end(&mut handle, &mut data).await?;
            debug!("read full file from memfs!");

            let mut header = ar::Header::new(
                path.strip_prefix("/")
                    .unwrap()
                    .as_os_str()
                    .as_bytes()
                    .to_vec(),
                data.len() as u64,
            );
            header.set_gid(metadata.gid()?);
            header.set_uid(metadata.uid()?);
            header.set_mode(metadata.permissions().mode());
            header.set_mtime(
                metadata
                    .modified()?
                    .duration_since(std::time::UNIX_EPOCH)
                    .unwrap()
                    .as_secs(),
            );
            debug!("created header!");

            // TODO: async safety
            archive.append(&header, &mut data.as_slice())?;
            debug!("appended to archive: {}", path.display());
        }
    }

    smoosh::recompress(&mut buffer.as_slice(), &mut file, compression).await?;
    debug!("finished closing ar!");

    Ok(())
}