jay-compositor 1.15.0

The Jay compositor
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

use crate::utils::fx_hash::FHashMap;
use flate2::Compression;
use flate2::GzBuilder;
use jay_algorithms::jar::JarError;
use jay_algorithms::jar::JarEvent;
use jay_algorithms::jar::JarReader;
use jay_algorithms::tar::TarWriter;
use std::io;
use std::io::BufWriter;
use thiserror::Error;
use uapi::OwnedFd;

#[derive(Debug, Error)]
pub enum JarToTarError {
    #[error("Could not create event reader")]
    OpenJar(#[source] JarError),
    #[error("Could not read event")]
    ReadJar(#[source] JarError),
    #[error("Could not write tar")]
    WriteTar(#[source] io::Error),
    #[error("Jar refers to an unknown link")]
    MissingLink,
}

pub fn jar_to_tar(root: &str, src: &OwnedFd, dst: &OwnedFd) -> Result<(), JarToTarError> {
    let mut reader = JarReader::new(src).map_err(JarToTarError::OpenJar)?;
    let filename = format!("{root}.tar");
    let writer = BufWriter::with_capacity(1 << 17, dst.borrow());
    let writer = GzBuilder::new()
        .filename(filename)
        .write(writer, Compression::default());
    let mut buf_writer = BufWriter::new(writer);
    let mut tar_writer = TarWriter::new(&mut buf_writer);
    let mut lens = vec![];
    let mut path = vec![];
    let mut paths = FHashMap::default();
    loop {
        let ev = reader.next().map_err(JarToTarError::ReadJar)?;
        let Some(ev) = ev else {
            break;
        };
        let len = path.len();
        let res = match ev {
            JarEvent::Dir(p) => {
                lens.push(len);
                path.extend_from_slice(p);
                path.push(b'/');
                tar_writer.add_dir(&path)
            }
            JarEvent::DirUp => {
                let len = lens.pop().unwrap();
                path.truncate(len);
                Ok(())
            }
            JarEvent::Reg(p, unique, c) => {
                path.extend_from_slice(p);
                if let Some(unique) = unique {
                    paths.insert(unique, path.clone());
                }
                let res = tar_writer.add_reg(&path, c);
                path.truncate(len);
                res
            }
            JarEvent::Lnk(p, l) => {
                path.extend_from_slice(p);
                let res = tar_writer.add_lnk(&path, l);
                path.truncate(len);
                res
            }
            JarEvent::Hrd(p, unique) => {
                let l = paths.get(&unique).ok_or(JarToTarError::MissingLink)?;
                path.extend_from_slice(p);
                let res = tar_writer.add_hrd(&path, l);
                path.truncate(len);
                res
            }
        };
        res.map_err(JarToTarError::WriteTar)?;
    }
    tar_writer.finish().map_err(JarToTarError::WriteTar)?;
    buf_writer
        .into_inner()
        .map_err(|e| e.into_error())
        .map_err(JarToTarError::WriteTar)?
        .finish()
        .map_err(JarToTarError::WriteTar)?
        .into_inner()
        .map_err(|e| e.into_error())
        .map_err(JarToTarError::WriteTar)?;
    Ok(())
}