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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

//! Transfer sources

use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
use url::Url;

use crate::protocol::{
    ReadOffset, SourceProtocol, SourceReader, TransferError, http::HttpSourceProtocol,
};
use crate::transfer::TransferConfig;

/// A transfer source.
pub enum Source {
    /// An HTTP(S) URL, accessible via a `GET` request.
    ///
    /// Schemes:
    /// - `http://`
    /// - `https://`
    Http(HttpSourceProtocol),
}

/// Resolve a source URL to a [`Source`] protocol handler.
///
/// # Errors
///
/// Returns [`TransferError::Permanent`] if the URL scheme is not supported.
/// Refer to the [`Source`] enum for supported variants.
pub fn resolve_source(url: &Url, config: &TransferConfig) -> Result<Source, TransferError> {
    match url.scheme() {
        "http" | "https" => {
            let headers = build_header_map(&config.custom_http_headers)?;
            Ok(Source::Http(HttpSourceProtocol::new(headers)?))
        }
        scheme => Err(TransferError::Permanent {
            reason: format!("unsupported source protocol: {scheme}"),
        }),
    }
}

/// Convert parsed header pairs into a [`HeaderMap`].
fn build_header_map(headers: &[(String, String)]) -> Result<HeaderMap, TransferError> {
    let mut map = HeaderMap::with_capacity(headers.len());
    for (name, value) in headers {
        let header_name =
            HeaderName::from_bytes(name.as_bytes()).map_err(|e| TransferError::Permanent {
                reason: format!("invalid header name \"{name}\": {e}"),
            })?;
        let header_value = HeaderValue::from_str(value).map_err(|e| TransferError::Permanent {
            reason: format!("invalid header value for \"{name}\": {e}"),
        })?;
        map.append(header_name, header_value);
    }
    Ok(map)
}

impl Source {
    /// Gets a reader from the source, starting at a given offset.
    ///
    /// # Errors
    ///
    /// Propagates connection and protocol errors from the underlying source
    /// (e.g. DNS failure, TLS errors, and HTTP error responses).
    pub async fn get_reader(
        &mut self,
        url: Url,
        start_byte_offset: u64,
    ) -> Result<(impl SourceReader, ReadOffset), TransferError> {
        match self {
            Source::Http(proto) => {
                let (reader, outcome) = proto.get_reader(url, start_byte_offset).await?;
                Ok((reader, outcome))
            }
        }
    }
}