138 lines
3.8 KiB
Rust
138 lines
3.8 KiB
Rust
#![doc = include_str!("../README.md")]
|
|
use std::{
|
|
collections::HashMap,
|
|
fs,
|
|
io::{BufWriter, Write},
|
|
sync::Mutex,
|
|
};
|
|
#[cfg(feature = "parallel")]
|
|
use {
|
|
rayon::prelude::{IntoParallelRefIterator, ParallelIterator},
|
|
std::{ops::DerefMut, sync::mpsc::Sender},
|
|
};
|
|
|
|
mod checksum;
|
|
mod error;
|
|
mod file;
|
|
mod filetype;
|
|
pub(crate) mod nix;
|
|
mod node;
|
|
mod special;
|
|
mod stream;
|
|
|
|
pub use {
|
|
checksum::{Algorithm, Checksum},
|
|
error::Error,
|
|
file::File,
|
|
filetype::FileType,
|
|
node::Node,
|
|
special::Special,
|
|
stream::Stream,
|
|
};
|
|
|
|
#[cfg(feature = "parallel")]
|
|
pub use stream::Message as StreamMessage;
|
|
|
|
pub static MAGIC: [u8; 7] = [0x89, b'h', b'a', b'g', b'g', b'i', b's'];
|
|
|
|
/// Creates a haggis archive from a list of files
|
|
pub fn create_archive(path: &str, files: Vec<String>, algorithm: Algorithm) -> Result<(), Error> {
|
|
let fd = fs::OpenOptions::new()
|
|
.create(true)
|
|
.truncate(true)
|
|
.open(path)?;
|
|
let mut writer = BufWriter::new(fd);
|
|
stream_archive(&mut writer, files, algorithm)?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Streams a haggis archive over something which implements `Write`
|
|
pub fn stream_archive<W: Write>(
|
|
mut writer: W,
|
|
files: Vec<String>,
|
|
algorithm: Algorithm,
|
|
) -> Result<(), Error> {
|
|
writer.write_all(&MAGIC)?;
|
|
let len = u32::try_from(files.len())?;
|
|
writer.write_all(&len.to_le_bytes())?;
|
|
let links = Mutex::new(HashMap::new());
|
|
for f in &files {
|
|
let node = Node::from_path(f, algorithm, &links)?;
|
|
node.write(&mut writer)?;
|
|
}
|
|
writer.write_all(&[0; 8])?;
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(feature = "parallel")]
|
|
#[derive(Debug)]
|
|
pub enum Message {
|
|
NodeCreated(String),
|
|
NodeSaved { name: String, size: u64 },
|
|
Err(Error),
|
|
Eof,
|
|
}
|
|
|
|
/// Creates a Haggis archive from a list of files, processing each file in parallel
|
|
#[cfg(feature = "parallel")]
|
|
pub fn par_create_archive(
|
|
path: &str,
|
|
files: Vec<String>,
|
|
algorithm: Algorithm,
|
|
sender: &Sender<Message>,
|
|
) -> Result<(), Error> {
|
|
let fd = fs::File::create(path)?;
|
|
let writer = BufWriter::new(fd);
|
|
par_stream_archive(writer, files, algorithm, sender)?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Streams a Haggis archive from a list of files, processing each file in parallel
|
|
#[cfg(feature = "parallel")]
|
|
pub fn par_stream_archive<W: Write + Send>(
|
|
mut writer: W,
|
|
files: Vec<String>,
|
|
algorithm: Algorithm,
|
|
sender: &Sender<Message>,
|
|
) -> Result<(), Error> {
|
|
writer.write_all(&MAGIC)?;
|
|
let len = u32::try_from(files.len())?;
|
|
writer.write_all(&len.to_le_bytes())?;
|
|
let links = Mutex::new(HashMap::<u64, String>::new());
|
|
let writer = Mutex::new(writer);
|
|
let s = sender.clone();
|
|
files.par_iter().try_for_each_with(s, |s, f| {
|
|
let node = match Node::from_path(f, algorithm, &links) {
|
|
Ok(n) => n,
|
|
Err(e) => {
|
|
s.send(Message::Err(e)).map_err(|_| Error::SenderError)?;
|
|
return Ok(());
|
|
}
|
|
};
|
|
if let Ok(mut writer) = writer.lock() {
|
|
let mut writer = writer.deref_mut();
|
|
if let Err(e) = node.write(&mut writer) {
|
|
s.send(Message::Err(e)).map_err(|_| Error::SenderError)?;
|
|
}
|
|
match node.filetype {
|
|
FileType::Normal(n) => s
|
|
.send(Message::NodeSaved {
|
|
name: node.name.clone(),
|
|
size: n.len,
|
|
})
|
|
.map_err(|_| Error::SenderError)?,
|
|
_ => s
|
|
.send(Message::NodeCreated(node.name.clone()))
|
|
.map_err(|_| Error::SenderError)?,
|
|
}
|
|
Ok(())
|
|
} else {
|
|
Err(Error::MutexError)
|
|
}
|
|
})?;
|
|
let mut writer = writer.into_inner().map_err(|_| Error::MutexError)?;
|
|
writer.write_all(&[0; 8])?;
|
|
sender.send(Message::Eof).map_err(|_| Error::SenderError)?;
|
|
Ok(())
|
|
}
|