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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
use actix_web::http::ContentEncoding;
use bytes::Bytes;
use libflate::gzip::Encoder;
use serde::Deserialize;
use std::io;
use std::path::PathBuf;
use strum_macros::{Display, EnumIter, EnumString};
use tar::Builder;
use crate::errors::{ContextualError, ContextualErrorKind};
/// Available compression methods
#[derive(Deserialize, Clone, EnumIter, EnumString, Display)]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum CompressionMethod {
/// TAR GZ
TarGz,
}
impl CompressionMethod {
pub fn extension(&self) -> String {
match &self {
CompressionMethod::TarGz => "tar.gz",
}
.to_string()
}
pub fn content_type(&self) -> String {
match &self {
CompressionMethod::TarGz => "application/gzip",
}
.to_string()
}
pub fn content_encoding(&self) -> ContentEncoding {
match &self {
CompressionMethod::TarGz => ContentEncoding::Gzip,
}
}
}
/// Creates an archive of a folder, using the algorithm the user chose from the web interface
/// This method returns the archive as a stream of bytes
pub fn create_archive(
method: &CompressionMethod,
dir: &PathBuf,
skip_symlinks: bool,
) -> Result<(String, Bytes), ContextualError> {
match method {
CompressionMethod::TarGz => tgz_compress(&dir, skip_symlinks),
}
}
/// Compresses a given folder in .tar.gz format, and returns the result as a stream of bytes
fn tgz_compress(dir: &PathBuf, skip_symlinks: bool) -> Result<(String, Bytes), ContextualError> {
let src_dir = dir.display().to_string();
if let Some(inner_folder) = dir.file_name() {
if let Some(directory) = inner_folder.to_str() {
let dst_filename = format!("{}.tar", directory);
let dst_tgz_filename = format!("{}.gz", dst_filename);
let mut tgz_data = Bytes::new();
let tar_data = tar(src_dir, directory.to_string(), skip_symlinks).map_err(|e| {
ContextualError::new(ContextualErrorKind::ArchiveCreationError(
"tarball".to_string(),
Box::new(e),
))
})?;
let gz_data = gzip(&tar_data).map_err(|e| {
ContextualError::new(ContextualErrorKind::ArchiveCreationError(
"GZIP archive".to_string(),
Box::new(e),
))
})?;
tgz_data.extend_from_slice(&gz_data);
Ok((dst_tgz_filename, tgz_data))
} else {
// https://doc.rust-lang.org/std/ffi/struct.OsStr.html#method.to_str
Err(ContextualError::new(ContextualErrorKind::InvalidPathError(
"Directory name contains invalid UTF-8 characters".to_string(),
)))
}
} else {
// https://doc.rust-lang.org/std/path/struct.Path.html#method.file_name
Err(ContextualError::new(ContextualErrorKind::InvalidPathError(
"Directory name terminates in \"..\"".to_string(),
)))
}
}
/// Creates a TAR archive of a folder, and returns it as a stream of bytes
fn tar(
src_dir: String,
inner_folder: String,
skip_symlinks: bool,
) -> Result<Vec<u8>, ContextualError> {
let mut tar_builder = Builder::new(Vec::new());
tar_builder.follow_symlinks(!skip_symlinks);
// Recursively adds the content of src_dir into the archive stream
tar_builder
.append_dir_all(inner_folder, &src_dir)
.map_err(|e| {
ContextualError::new(ContextualErrorKind::IOError(
format!(
"Failed to append the content of {} to the TAR archive",
&src_dir
),
e,
))
})?;
let tar_content = tar_builder.into_inner().map_err(|e| {
ContextualError::new(ContextualErrorKind::IOError(
"Failed to finish writing the TAR archive".to_string(),
e,
))
})?;
Ok(tar_content)
}
/// Compresses a stream of bytes using the GZIP algorithm, and returns the resulting stream
fn gzip(mut data: &[u8]) -> Result<Vec<u8>, ContextualError> {
let mut encoder = Encoder::new(Vec::new()).map_err(|e| {
ContextualError::new(ContextualErrorKind::IOError(
"Failed to create GZIP encoder".to_string(),
e,
))
})?;
io::copy(&mut data, &mut encoder).map_err(|e| {
ContextualError::new(ContextualErrorKind::IOError(
"Failed to write GZIP data".to_string(),
e,
))
})?;
let data = encoder.finish().into_result().map_err(|e| {
ContextualError::new(ContextualErrorKind::IOError(
"Failed to write GZIP trailer".to_string(),
e,
))
})?;
Ok(data)
}
|
