takanawa-http 0.3.1

Tokio and reqwest HTTP range downloader for Takanawa
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

use takanawa_core::{Result, TakanawaError};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ContentRange {
    pub start: u64,
    pub end: u64,
    pub total: u64,
}

pub fn parse_content_range(value: &str) -> Result<ContentRange> {
    let value = value.trim();
    let Some(rest) = value.strip_prefix("bytes ") else {
        return Err(TakanawaError::HttpProtocol(format!(
            "Content-Range does not use bytes unit: {value}"
        )));
    };
    if rest.starts_with("*/") {
        return Err(TakanawaError::HttpProtocol(format!(
            "unsatisfied Content-Range is not a byte range: {value}"
        )));
    }

    let (range, total) = rest
        .split_once('/')
        .ok_or_else(|| TakanawaError::HttpProtocol(format!("invalid Content-Range: {value}")))?;
    if total == "*" {
        return Err(TakanawaError::HttpProtocol(
            "Content-Range total length is unknown".to_owned(),
        ));
    }
    let total = total
        .parse::<u64>()
        .map_err(|err| TakanawaError::HttpProtocol(format!("invalid total length: {err}")))?;
    let (start, end) = range
        .split_once('-')
        .ok_or_else(|| TakanawaError::HttpProtocol(format!("invalid range: {value}")))?;
    let start = start
        .parse::<u64>()
        .map_err(|err| TakanawaError::HttpProtocol(format!("invalid range start: {err}")))?;
    let end = end
        .parse::<u64>()
        .map_err(|err| TakanawaError::HttpProtocol(format!("invalid range end: {err}")))?;
    if start > end || end >= total {
        return Err(TakanawaError::HttpProtocol(format!(
            "invalid Content-Range bounds: {value}"
        )));
    }

    Ok(ContentRange { start, end, total })
}

pub fn parse_unsatisfied_total(value: &str) -> Result<u64> {
    let value = value.trim();
    let Some(rest) = value.strip_prefix("bytes */") else {
        return Err(TakanawaError::HttpProtocol(format!(
            "invalid unsatisfied Content-Range: {value}"
        )));
    };
    rest.parse::<u64>()
        .map_err(|err| TakanawaError::HttpProtocol(format!("invalid unsatisfied total: {err}")))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn parses_content_range() {
        let parsed = parse_content_range("bytes 4-7/10").unwrap();

        assert_eq!(
            parsed,
            ContentRange {
                start: 4,
                end: 7,
                total: 10,
            }
        );
    }

    #[test]
    fn rejects_unknown_total() {
        assert!(parse_content_range("bytes 0-1/*").is_err());
    }

    #[test]
    fn parses_unsatisfied_total() {
        assert_eq!(parse_unsatisfied_total("bytes */0").unwrap(), 0);
    }
}