totebag 0.8.14

An API for extracting/archiving files and directories in multiple 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

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

use crate::Result;
use crate::extractor::{Entries, Entry, ToteExtractor};

/// CPIO format extractor implementation.
///
/// 
pub(super) struct Extractor {}

impl ToteExtractor for Extractor {
    fn list(&self, target: PathBuf) -> Result<Entries> {
        log::info!("listing CPIO archive: {target:?}");
        let mut file = std::fs::File::open(&target)
            .map(cpio::Archive::new)
            .map_err(crate::Error::IO)?;
        let mut entries: Vec<Entry> = vec![];
        loop {
            let entry = file.read_entry()
                .map_err(crate::Error::IO)?;
            match entry {
                Some(entry) => {
                    if entry.metadata.is_file() {
                        entries.push(create_new_entry(&entry.path, &entry.metadata));
                    }
                },
                None => break,
            }
        }
        Ok(Entries::new(target, entries))
    }

    fn perform(&self, target: PathBuf, base: PathBuf) -> Result<()> {
        log::info!("extracting CPIO archive: {target:?}");
        let mut file = std::fs::File::open(&target)
            .map(cpio::Archive::new)
            .map_err(crate::Error::IO)?;
        let mut errs = vec![];
        loop {
            let r = file.read_entry();
            match r {
                Ok(Some(entry)) => {
                    if !entry.metadata.is_file() {
                        continue;
                    }
                    match prepare_write(&entry, &base) {
                        Ok(dest_path) => write_to(entry, &dest_path, &mut errs),
                        Err(e) => errs.push(e),
                    }
                },
                Ok(None) => break,
                Err(e) => errs.push(crate::Error::IO(e)),
            }
        };
        crate::Error::error_or((), errs)
    }
}

fn prepare_write(entry: &cpio::Entry<std::fs::File>, base: &Path) -> Result<PathBuf>{
    let dest_path = base.join(&entry.path);
    log::info!("extracting {:?} ({} bytes) to {dest_path:?}", &entry.path, entry.metadata.size());
    if let Some(parent) = dest_path.parent() {
        std::fs::create_dir_all(parent)
            .map_err(crate::Error::IO)?;
    };
    Ok(dest_path)
}

fn write_to(mut entry: cpio::Entry<std::fs::File>, dest_path: &Path, errs: &mut Vec<crate::Error>) {
    match std::fs::File::create(dest_path) {
        Ok(mut dest_file) => if let Err(e) = std::io::copy(&mut entry.reader, &mut dest_file) {
            errs.push(crate::Error::IO(e));
        },
        Err(e) => {
            log::error!("failed to create file {dest_path:?}: {e}");
            errs.push(crate::Error::IO(e));
        }
    }
}

fn create_new_entry(path: &Path, entry: &cpio::Metadata) -> Entry {
    let timestamp = entry.mtime();
    let ndt = chrono::DateTime::from_timestamp(timestamp as i64, 0)
        .map(|d| d.naive_utc());
    Entry::builder()
        .name(path.to_string_lossy().to_string())
        .original_size(entry.size())
        .unix_mode(entry.mode())
        .date(ndt)
        .build()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_list_archives() {
        let file = PathBuf::from("../testdata/test.cpio");
        let extractor = Extractor {};
        match extractor.list(file) {
            Ok(r) => {
                let r = r.iter().map(|e| e.name.clone()).collect::<Vec<_>>();
                assert_eq!(r.len(), 16);
                assert_eq!(r.get(0), Some("./Cargo.toml".to_string()).as_ref());
                assert_eq!(r.get(1), Some("./LICENSE".to_string()).as_ref());
                assert_eq!(r.get(2), Some("./build.rs".to_string()).as_ref());
                assert_eq!(r.get(3), Some("./README.md".to_string()).as_ref());
            }
            Err(_) => assert!(false),
        }
    }

    #[test]
    fn test_extract_archive() {
        let archive_file = PathBuf::from("../testdata/test.cpio");
        let opts = crate::ExtractConfig::builder()
            .dest("results/cpio")
            .use_archive_name_dir(true)
            .overwrite(true)
            .build();
        match crate::extract(archive_file, &opts) {
            Ok(_) => {
                assert!(true);
                assert!(PathBuf::from("results/cpio/test/Cargo.toml").exists());
                std::fs::remove_dir_all(PathBuf::from("results/cpio")).unwrap();
            }
            Err(e) => {
                eprintln!("{:?}", e);
                assert!(false);
            }
        };
    }
}