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

use std::io::Cursor;
use std::os::unix::prelude::OsStringExt;

use async_zip::tokio::read::seek::ZipFileReader;
use async_zip::tokio::write::ZipFileWriter;
use async_zip::{ZipDateTime, ZipEntryBuilder, ZipString};
use chrono::DateTime;
use smoosh::CompressionType;
use tokio::io::AsyncReadExt;
use tracing::debug;

crate::util::archive_format!(Zip, "a.zip", zip_open, zip_close);

async fn zip_open<P: Into<PathBuf>>(path: P) -> Result<ZipInternalMetadata> {
    let path = path.into();
    if !crate::util::exists_async(path.clone()).await {
        let _archive = ZipFileWriter::with_tokio(tokio::fs::File::create(path).await?);
        return Ok(ZipInternalMetadata {
            delegate: MemFloppyDisk::new(),
            compression: CompressionType::None,
            ordered_paths: IndexSet::new(),
        });
    }

    debug!("opening zip 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 = ZipFileReader::with_tokio(Cursor::new(buffer))
        .await
        .map_err(fix_err)?;
    let out = MemFloppyDisk::new();
    let mut ordered_paths = IndexSet::new();

    let archive_file = archive.file();
    let entries = archive_file.entries();
    for idx in 0..entries.len() {
        let mut zip_entry = archive.reader_with_entry(idx).await.map_err(fix_err)?;
        let entry = zip_entry.entry();
        let path = PathBuf::from(OsString::from_vec(entry.filename().as_bytes().to_vec()));
        debug!("processing archive path {}", path.display());
        ordered_paths.insert(path.clone());

        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![];
        zip_entry
            .read_to_end_checked(&mut data)
            .await
            .map_err(fix_err)?;
        tokio::io::copy(&mut data.as_slice(), &mut handle).await?;
        debug!("copied path!");
    }

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

async fn zip_close(
    disk: &MemFloppyDisk,
    scope: &Path,
    compression: CompressionType,
    ordered_paths: &IndexSet<PathBuf>,
) -> Result<()> {
    debug!("closing zip at {}", scope.display());
    let mut file = tokio::fs::OpenOptions::new()
        .write(true)
        .truncate(true)
        .open(scope)
        .await?;

    let buffer = vec![];
    let mut writer = ZipFileWriter::with_tokio(buffer);

    for path in ordered_paths {
        let metadata = disk.metadata(path).await?;
        if metadata.is_file() {
            debug!("writing path {} to zip!", path.display());
            let mut handle = MemOpenOptions::new().read(true).open(disk, path).await?;

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

            // TODO: lol not utf8
            let entry = ZipEntryBuilder::new(
                ZipString::new(
                    path.to_string_lossy().to_string().as_bytes().to_vec(),
                    async_zip::StringEncoding::Utf8,
                ),
                async_zip::Compression::Stored,
            );

            let entry = entry
                .last_modification_date(ZipDateTime::from_chrono(&DateTime::from(
                    metadata.modified().unwrap(),
                )))
                .unix_permissions(metadata.permissions().mode() as u16);

            writer
                .write_entry_whole(entry, &data)
                .await
                .map_err(fix_err)?;

            debug!("wrote path!");
        }
    }

    let writer = writer.close().await.map_err(fix_err)?;
    smoosh::recompress(&mut writer.get_ref().as_slice(), &mut file, compression).await?;

    Ok(())
}

fn fix_err<E: std::error::Error + Send + Sync + 'static>(err: E) -> std::io::Error {
    std::io::Error::new(std::io::ErrorKind::Other, err)
}