1use std::collections::BTreeMap;
2use std::path::{Path, PathBuf};
3
4use serde::{Deserialize, Serialize};
5use url::Url;
6use uuid::Uuid;
7
8use crate::checksum::Checksum;
9use crate::header::RequestOptions;
10use crate::link::Link;
11use crate::range::{ByteRange, completed_bytes, merge_ranges};
12use crate::resource::Resource;
13use crate::util::now_ms;
14
15pub type TaskId = Uuid;
17
18pub const TASK_SCHEMA_VERSION: u32 = 1;
20
21#[derive(Clone, Debug, Serialize, Deserialize)]
24#[non_exhaustive]
25pub struct Task {
26 pub schema_version: u32,
28 pub id: TaskId,
30 pub link: Link,
32 #[serde(default)]
34 pub resource: Option<Resource>,
35 #[serde(default)]
37 pub backend: Option<String>,
38 pub destination: PathBuf,
40 pub options: TaskOptions,
42 #[serde(default)]
44 pub priority: i32,
45 pub state: TaskState,
47 #[serde(default)]
49 pub files: Vec<FileItem>,
50 #[serde(default)]
52 pub resume: Option<TaskResume>,
53 #[serde(default)]
55 pub error: Option<String>,
56 pub created_at_ms: u64,
58 pub updated_at_ms: u64,
60}
61
62impl Task {
63 pub fn new(link: Link, destination: PathBuf, options: TaskOptions) -> Self {
66 let now = now_ms();
67 Self {
68 schema_version: TASK_SCHEMA_VERSION,
69 id: Uuid::now_v7(),
70 link,
71 resource: None,
72 backend: None,
73 destination,
74 priority: options.priority.unwrap_or(0),
75 options,
76 state: TaskState::Pending,
77 files: Vec::new(),
78 resume: None,
79 error: None,
80 created_at_ms: now,
81 updated_at_ms: now,
82 }
83 }
84
85 pub fn touch(&mut self) {
87 self.updated_at_ms = now_ms();
88 }
89
90 pub fn key(&self) -> String {
93 format!(
94 "{}|{}",
95 self.link.canonical(),
96 self.destination.to_string_lossy()
97 )
98 }
99
100 pub fn set_resource(&mut self, resource: Resource) {
103 self.files = resource
104 .files
105 .iter()
106 .map(|file| FileItem {
107 path: file.path.clone(),
108 url: Some(file.url.clone()),
109 size: file.size,
110 downloaded: 0,
111 state: FileState::Pending,
112 checksum: file.checksum.clone(),
113 selected: true,
114 })
115 .collect();
116 self.resource = Some(resource);
117 }
118
119 pub fn refresh_from_resume(&mut self) {
122 let Some(resume) = &self.resume else {
123 return;
124 };
125 for file in &mut self.files {
126 let Some(url) = &file.url else {
127 continue;
128 };
129 if let Some(entry) = resume.files.get(url.as_str()) {
130 file.downloaded = completed_bytes(&entry.completed);
131 if let Some(size) = entry.total_size {
132 file.size = Some(size);
133 }
134 file.path = entry.final_path.clone();
135 }
136 }
137 }
138
139 pub fn total_bytes(&self) -> Option<u64> {
142 self.files
143 .iter()
144 .try_fold(0u64, |sum, file| file.size.map(|size| sum + size))
145 }
146
147 pub fn downloaded_bytes(&self) -> u64 {
149 self.files.iter().map(|file| file.downloaded).sum()
150 }
151}
152
153#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
155#[serde(rename_all = "snake_case")]
156#[non_exhaustive]
157pub enum TaskState {
158 Pending,
160 Running,
162 Paused,
164 Completed,
166 Failed,
168 Cancelled,
170}
171
172impl TaskState {
173 pub fn is_active(&self) -> bool {
176 matches!(self, Self::Pending | Self::Running | Self::Paused)
177 }
178}
179
180#[derive(Clone, Debug, Default, Serialize, Deserialize)]
183pub struct TaskOptions {
184 #[serde(default)]
186 pub output: Option<PathBuf>,
187 #[serde(default)]
189 pub connections: Option<usize>,
190 #[serde(default)]
193 pub rate_limit: Option<u64>,
194 #[serde(default)]
196 pub file_jobs: Option<usize>,
197 #[serde(default)]
200 pub mirrors: Vec<Url>,
201 #[serde(default)]
203 pub priority: Option<i32>,
204 #[serde(default)]
206 pub resume: Option<bool>,
207 #[serde(default)]
209 pub verify: Option<VerifyMode>,
210 #[serde(default)]
212 pub checksum: Option<Checksum>,
213 #[serde(default)]
215 pub extract: Option<bool>,
216 #[serde(default)]
218 pub extract_dir: Option<PathBuf>,
219 #[serde(default)]
221 pub delete_archive: Option<bool>,
222 #[serde(default)]
224 pub cache: Option<bool>,
225 #[serde(default)]
227 pub content_cache: Option<bool>,
228 #[serde(default)]
230 pub request: RequestOptions,
231 #[serde(default)]
233 pub revision: Option<String>,
234 #[serde(default)]
236 pub include: Vec<String>,
237 #[serde(default)]
239 pub exclude: Vec<String>,
240 #[serde(default)]
242 pub overwrite: bool,
243 #[serde(default)]
246 pub rename_on_conflict: bool,
247 #[serde(default)]
249 pub force: bool,
250}
251
252#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
254#[serde(rename_all = "snake_case")]
255#[non_exhaustive]
256pub enum VerifyMode {
257 #[default]
259 Auto,
260 Require,
262 Disabled,
264}
265
266#[derive(Clone, Debug, Serialize, Deserialize)]
268#[non_exhaustive]
269pub struct FileItem {
270 pub path: String,
272 #[serde(default)]
274 pub url: Option<Url>,
275 #[serde(default)]
277 pub size: Option<u64>,
278 #[serde(default)]
280 pub downloaded: u64,
281 pub state: FileState,
283 #[serde(default)]
285 pub checksum: Option<Checksum>,
286 #[serde(default = "default_selected")]
288 pub selected: bool,
289}
290
291fn default_selected() -> bool {
292 true
293}
294
295#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
297#[serde(rename_all = "snake_case")]
298#[non_exhaustive]
299pub enum FileState {
300 Pending,
302 Downloading,
304 Completed,
306 Skipped,
308 Failed,
310}
311
312#[derive(Clone, Debug, Serialize, Deserialize)]
314#[non_exhaustive]
315pub struct TaskResume {
316 pub version: u32,
318 #[serde(default)]
320 pub files: BTreeMap<String, FileResume>,
321}
322
323impl Default for TaskResume {
324 fn default() -> Self {
325 Self {
326 version: 1,
327 files: BTreeMap::new(),
328 }
329 }
330}
331
332impl TaskResume {
333 pub fn file(&self, url: &str) -> Option<&FileResume> {
335 self.files.get(url)
336 }
337
338 pub fn upsert(&mut self, url: String, file: FileResume) {
340 self.files.insert(url, file);
341 }
342
343 pub fn downloaded(&self) -> u64 {
345 self.files
346 .values()
347 .map(|file| completed_bytes(&file.completed))
348 .sum()
349 }
350}
351
352#[derive(Clone, Debug, Serialize, Deserialize)]
354pub struct FileResume {
355 pub url: String,
357 pub final_path: String,
359 pub part_path: String,
361 #[serde(default)]
363 pub validator: Validator,
364 #[serde(default)]
366 pub total_size: Option<u64>,
367 pub segment_size: u64,
369 #[serde(default)]
371 pub completed: Vec<ByteRange>,
372 #[serde(default)]
374 pub checksum: Option<Checksum>,
375 #[serde(default)]
377 pub metadata: BTreeMap<String, String>,
378 pub updated_at_ms: u64,
380}
381
382impl FileResume {
383 pub fn completed_bytes(&self) -> u64 {
385 completed_bytes(&self.completed)
386 }
387
388 pub fn is_complete(&self) -> bool {
390 match self.total_size {
391 Some(total) => self.completed_bytes() >= total,
392 None => false,
393 }
394 }
395
396 pub fn normalize(&mut self) {
398 self.completed = merge_ranges(std::mem::take(&mut self.completed));
399 self.updated_at_ms = now_ms();
400 }
401}
402
403#[derive(Clone, Debug, Default, Serialize, Deserialize)]
406pub struct Validator {
407 #[serde(default)]
409 pub etag: Option<String>,
410 #[serde(default)]
412 pub last_modified: Option<String>,
413 #[serde(default)]
415 pub size: Option<u64>,
416}
417
418impl Validator {
419 pub fn is_empty(&self) -> bool {
421 self.etag.is_none() && self.last_modified.is_none() && self.size.is_none()
422 }
423
424 pub fn matches(&self, fresh: &Validator) -> bool {
428 if let Some(etag) = &self.etag
429 && !etag.starts_with("W/")
430 {
431 return fresh.etag.as_deref() == Some(etag.as_str());
432 }
433 if let Some(last_modified) = &self.last_modified {
434 return fresh.last_modified.as_deref() == Some(last_modified.as_str())
435 && (self.size.is_none() || self.size == fresh.size);
436 }
437 if let Some(size) = self.size {
438 return fresh.size == Some(size);
439 }
440 false
441 }
442}
443
444pub fn destination_file(destination: &Path, relative: &str) -> PathBuf {
447 destination.join(relative.replace('/', std::path::MAIN_SEPARATOR_STR))
448}
449
450pub fn part_path(final_path: &Path) -> PathBuf {
452 let mut value = final_path.as_os_str().to_os_string();
453 value.push(".shaul.part");
454 PathBuf::from(value)
455}