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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
|
use crate::cfg::config::Config;
use std::fs::{File, create_dir_all};
use std::path::PathBuf;
use std::path::Path;
use flate2::read::GzDecoder;
use serde::{Deserialize, Serialize};
use tar::Archive;
use toml;
#[derive(Serialize, Debug, Deserialize)]
pub enum archs {
X86_64,
Aarch64,
X86,
}
#[derive(Serialize, Debug, Deserialize)]
pub struct Package {
name: String,
version: String,
arch: archs,
descr: Option<String>,
}
#[derive(Deserialize, Debug)]
struct Install {
path: String,
user: String,
group: String,
mode: String,
//. Cancels the previous fields and installs them using the shell script
custom_script: Option<String>,
}
impl Package {
/// Checks if the archive contains INSTALL, SETTS and BUILD files.
///
/// Checks if INSTALL file exists and is not empty. If it does not exist or is empty, returns an error.
///
/// Checks if SETTS and BUILD files exist and are not empty. If they do not exist or are empty, logs a warning.
///
/// # Errors
///
/// Returns an error if INSTALL file does not exist or is empty.
/// Returns an error if INSTALL file is empty.
fn loadmeta() -> Result<bool, std::io::Error> {
let config: Config = Config::parse().unwrap();
create_dir_all(&config.paths.cache_dir)?;
struct FileStates {
install: bool,
setts: bool,
build: bool,
}
// for file in ["INSTALL", "SETTS", "BUILD"] {
// let path = Path::new(&config.paths.cache_dir).join(file);
// }
let cache_dir = &config.paths.cache_dir;
let file_names = ["INSTALL", "SETTS", "BUILD"];
let paths: Vec<PathBuf> = file_names
.iter()
.map(|file_name| Path::new(cache_dir).join(file_name))
.collect();
let mut fstates: FileStates = FileStates { install: false, setts: false, build: false };
for (i, path) in paths.iter().enumerate() {
if path.exists() {
match i {
0 => fstates.install = true,
1 => fstates.setts = true,
2 => fstates.build = true,
_ => {}
}
}
}
if !fstates.install {
return Err(std::io::Error::new(
std::io::ErrorKind::NotFound,
"File INSTALL not found in arch"
));
}
/*
Example INSTALL format:
[package]
name = "my-package"
version = "1.0.0"
arch = "X86_64"
[install]
path = "/usr/bin/my-package"
user = "root"
group = "root"
mode = "755"
# Also [install] can be
# path = "/usr/bin/my-package"
# user = "root"
# group = "root"
# mode = "755"
# custom_script = "./install.sh" OR
# custom_script = """
# echo "Installing my-package"
# sudo apt-get install my-package
# """
*/
let inst_content = std::fs::read_to_string(paths[0..2].clone())?; // FIXME
let validate = toml::from_str::<Package>(&inst_content.to_string());
// TODO: Make the vector of file paths more explicit, and add this function as a whole.
Ok(true)
}
/// Checks if the archive contains INSTALL, SETTS and BUILD files.
///
/// Checks if INSTALL file exists and is not empty. If it does not exist or is empty, returns an error.
///
/// Checks if SETTS and BUILD files exist and are not empty. If they do not exist or are empty, logs a warning.
/// # Errors
/// * Returns an error if INSTALL file does not exist or is empty.
/// * Returns an error if INSTALL file is empty.
///
// TODO: Add meta-files validation here.
pub fn check(path_to_archive: String) -> Result<bool, std::io::Error> {
let config: Config = Config::parse().unwrap();
create_dir_all(&config.paths.cache_dir)?;
let file = File::open(&path_to_archive)?;
let gz = GzDecoder::new(file);
let mut archive = Archive::new(gz);
archive.unpack(&config.paths.cache_dir)?;
let install_path = Path::new(&config.paths.cache_dir).join("INSTALL");
let setts_path = Path::new(&config.paths.cache_dir).join("SETTS");
let build_path = Path::new(&config.paths.cache_dir).join("BUILD");
if !install_path.exists() {
return Err(std::io::Error::new(
std::io::ErrorKind::NotFound,
"INSTALL file not found in archive",
));
}
let install_content = std::fs::read_to_string(&install_path)?;
if install_content.trim().is_empty() {
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidData,
"INSTALL file is empty",
));
}
if !setts_path.exists() {
log::warn!("SETTS file not found in archive. Make sure you dont need this.");
} else {
let setts_content = std::fs::read_to_string(&setts_path)?;
if setts_content.trim().is_empty() {
log::warn!("SETTS file is empty. Make sure you dont need this.");
}
}
if !build_path.exists() {
log::warn!("BUILD file not found in archive. Make sure you dont need this.");
} else {
let build_content = std::fs::read_to_string(&build_path)?;
if build_content.trim().is_empty() {
log::warn!("BUILD file is empty. Make sure you dont need this.");
}
}
Ok(true)
}
pub fn build() -> Result<bool, std::io::Error> {
todo!();
}
pub fn install() -> Result<bool, std::io::Error> {
todo!();
}
pub fn gen_index() -> Result<bool, std::io::Error> {
todo!();
}
}
|
