async-fetcher 0.12.0

Asynchronous multi-connection multi-download resumable HTTP file fetching state machine
Documentation 
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

// Copyright 2021-2022 System76 <info@system76.com>
// SPDX-License-Identifier: MPL-2.0

use std::path::Path;
use std::sync::Arc;

/// Information about a source being fetched.
#[derive(Debug)]
pub struct Source {
    /// URLs whereby the file can be found.
    pub urls: Arc<[Box<str>]>,

    /// Where the file shall ultimately be fetched to.
    pub dest: Arc<Path>,

    /// Where partial files should be stored.
    pub part: Option<Arc<Path>>,
}

impl Source {
    pub fn builder(dest: Arc<Path>, url: Box<str>) -> SourceBuilder {
        SourceBuilder::new(dest, url)
    }

    pub fn new(urls: Arc<[Box<str>]>, dest: Arc<Path>) -> Self {
        Self {
            urls,
            dest,
            part: None,
        }
    }

    /// Sets the partial destination of a source.
    pub fn set_part(&mut self, part: Option<Arc<Path>>) {
        self.part = part;
    }
}

/// Constructs a `Source`.
pub struct SourceBuilder {
    urls: Vec<Box<str>>,
    dest: Arc<Path>,
    part: Option<Arc<Path>>,
}

impl SourceBuilder {
    pub fn new(dest: Arc<Path>, url: Box<str>) -> Self {
        SourceBuilder {
            dest,
            urls: vec![url],
            part: None,
        }
    }

    /// A mirror where the source can be located.
    pub fn append_url(mut self, url: Box<str>) -> Self {
        self.urls.push(url);
        self
    }

    /// A partial destination for a source.
    pub fn partial(mut self, part: Arc<Path>) -> Self {
        self.part = Some(part);
        self
    }

    pub fn build(self) -> Source {
        Source {
            urls: Arc::from(self.urls),
            dest: self.dest,
            part: self.part,
        }
    }
}