ripcurl 0.2.0

Very persistent file transfers
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

//! Transfer destinations (where to write the file to)

use crate::protocol::file::{FileProtocol, WriteMode};
use crate::protocol::{DestinationProtocol, DestinationWriter, TransferError};
use crate::transfer::TransferConfig;
use url::Url;

/// A transfer destination.
pub enum Destination {
    /// A file accessible via a local filesystem mount.
    ///
    /// Scheme: `file://`.
    File(FileProtocol),
}

/// Resolve a destination URL to a [`Destination`] protocol handler.
///
/// # Errors
///
/// Returns [`TransferError::Permanent`] if the URL scheme is not supported.
/// Refer to the [`Destination`] enum for supported schemes.
pub fn resolve_destination(
    url: &Url,
    config: &TransferConfig,
) -> Result<Destination, TransferError> {
    let write_mode = if config.overwrite {
        WriteMode::Overwrite
    } else {
        WriteMode::CreateNew
    };

    match url.scheme() {
        "file" => Ok(Destination::File(FileProtocol::new(write_mode))),
        scheme => Err(TransferError::Permanent {
            reason: format!("unsupported destination protocol: {scheme}"),
        }),
    }
}

impl Destination {
    /// Creates a writer which can be used to persist bytes to the destination.
    ///
    /// # Errors
    ///
    /// Propagates errors from the underlying protocol
    /// (e.g. I/O failures or permission issues).
    pub async fn get_writer(&self, url: Url) -> Result<impl DestinationWriter, TransferError> {
        match self {
            Destination::File(proto) => {
                let writer = proto.get_writer(url).await?;
                Ok(writer)
            }
        }
    }
}