fast-down-api 0.1.1

A convenient and easy-to-use FFI wrapper for fast-down
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
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

use super::super::{
    open_create, open_create_new,
    overwrite::{OverwriteOption, overwrite},
};
use crate::{
    Config, DownloadState, Event, PartialConfig, StateError, TerminationReason, Tx, tx_err,
};
use fast_down::UrlInfo;
use path_helper::IterStemExt;
use reqwest::Response;
use std::io;
use std::path::PathBuf;
use tokio::fs;
use tokio_util::sync::CancellationToken;
use url::Url;

#[derive(Clone, Copy)]
pub(super) enum Fallback {
    Fresh,
    ManifestFresh,
    Fail,
}

/// Data shared by every planned action.
pub(super) struct PlanCommon {
    pub(super) url: Url,
    pub(super) partial_config: PartialConfig,
    pub(super) config: Config,
    pub(super) info: UrlInfo,
    pub(super) resp: Response,
    pub(super) final_path: PathBuf,
    pub(super) cfg_path: PathBuf,
    pub(super) tmp_path: PathBuf,
    pub(super) tx: Tx,
    pub(super) token: CancellationToken,
}

impl PlanCommon {
    pub(super) async fn ensure_parent(&self) -> bool {
        if let Some(parent) = self.final_path.parent()
            && let Err(e) = fs::create_dir_all(parent).await
        {
            let _ = self.tx.send(Event::BuildPusherError(e));
            return false;
        }
        true
    }

    fn emit_resumed(&self, state: &DownloadState) {
        let _ = self.tx.send(Event::Resumed {
            config_path: self.cfg_path.clone(),
            progress: state.get_progress(),
            size: self.info.size,
        });
    }

    async fn run_overwrite(self, state: DownloadState) -> TerminationReason {
        overwrite(OverwriteOption {
            state,
            final_path: self.final_path,
            info: self.info,
            resp: self.resp,
            tx: self.tx,
            token: self.token,
        })
        .await
    }

    pub(super) async fn run_existing(
        self,
        state: DownloadState,
        emit_resumed: bool,
    ) -> TerminationReason {
        if !self.ensure_parent().await {
            return TerminationReason::Failed;
        }
        if emit_resumed {
            self.emit_resumed(&state);
        }
        self.run_overwrite(state).await
    }

    /// Atomically claim a fresh `.part`/`.fd` pair and start from byte zero.
    pub(super) async fn claim_and_run(mut self) -> TerminationReason {
        self.partial_config.downloaded_chunk = None;
        if !self.ensure_parent().await {
            return TerminationReason::Failed;
        }

        if self.config.overwrite {
            tx_err!(
                open_create().open(&self.tmp_path).await,
                self.tx,
                BuildPusherError,
                TerminationReason::Failed
            );
            let state =
                DownloadState::new(&self.url, &self.info, &self.partial_config, &self.cfg_path);
            return self.run_overwrite(state).await;
        }

        for base_path in self.final_path.iter_stem() {
            let tmp_path = base_path.with_added_extension("part");
            let cfg_path = base_path.with_added_extension("fd");
            match open_create_new().open(&tmp_path).await {
                Ok(_) => match open_create_new().open(&cfg_path).await {
                    Ok(_) => {
                        let state = DownloadState::new(
                            &self.url,
                            &self.info,
                            &self.partial_config,
                            &cfg_path,
                        );
                        return self.run_overwrite(state).await;
                    }
                    Err(e) if e.kind() == io::ErrorKind::AlreadyExists => {
                        let _ = fs::remove_file(&tmp_path).await;
                    }
                    Err(e) => {
                        let _ = fs::remove_file(&tmp_path).await;
                        let _ = self.tx.send(Event::StateSaveError(StateError::Save(e)));
                        return TerminationReason::Failed;
                    }
                },
                Err(e) if e.kind() == io::ErrorKind::AlreadyExists => {}
                Err(e) => {
                    let _ = self.tx.send(Event::BuildPusherError(e));
                    return TerminationReason::Failed;
                }
            }
        }
        unreachable!()
    }
}