geam-cli 0.2.3

Standalone command implementation for Geam
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

use super::crates_io::sparse_index_path;
use super::discovery::{RegistryDiscoveryError, protocol};
use semver::Version;
use serde::Deserialize;

#[derive(Debug)]
pub(super) struct DownloadLocation(String);

impl DownloadLocation {
    pub(super) fn url(
        &self,
        crate_name: &str,
        version: &Version,
        checksum: &[u8; 32],
    ) -> Result<String, RegistryDiscoveryError> {
        let base = self.0.trim_end_matches('/');
        if !base.contains('{') {
            return Ok(format!("{base}/{crate_name}/{version}/download"));
        }
        let index_path = sparse_index_path(crate_name);
        let prefix = index_path.rsplit_once('/').map_or("", |(prefix, _)| prefix);
        let url = base
            .replace("{crate}", crate_name)
            .replace("{version}", &version.to_string())
            .replace("{prefix}", prefix)
            .replace("{lowerprefix}", &prefix.to_ascii_lowercase())
            .replace("{sha256-checksum}", &hex::encode(checksum));
        if url.contains('{') || url.contains('}') {
            return Err(RegistryDiscoveryError::Protocol {
                response: "configuration",
                reason: format!("download URL contains an unsupported marker: {url}"),
            });
        }
        Ok(url)
    }
}

pub(super) fn parse(source: &[u8]) -> Result<DownloadLocation, RegistryDiscoveryError> {
    let configuration = serde_json::from_slice::<RegistryConfiguration>(source)
        .map_err(|error| protocol("configuration", error))?;
    if !configuration.download.starts_with("https://") {
        return Err(RegistryDiscoveryError::Protocol {
            response: "configuration",
            reason: "download URL must use HTTPS".to_owned(),
        });
    }
    Ok(DownloadLocation(configuration.download))
}

#[derive(Deserialize)]
struct RegistryConfiguration {
    #[serde(rename = "dl")]
    download: String,
}

#[cfg(test)]
mod tests {
    use super::parse;
    use crate::provider::registry::RegistryDiscoveryError;
    use semver::Version;

    #[test]
    fn expands_legacy_and_supported_marker_download_locations() {
        let checksum = [0xab; 32];
        let legacy = parse(br#"{"dl":"https://downloads.example/"}"#)
            .expect("HTTPS legacy configuration should parse");
        assert_eq!(
            legacy
                .url("geam-images", &Version::new(1, 2, 3), &checksum)
                .expect("legacy URL should expand"),
            "https://downloads.example/geam-images/1.2.3/download",
        );

        let markers = parse(
            br#"{"dl":"https://downloads.example/{crate}/{version}/{prefix}/{lowerprefix}/{sha256-checksum}"}"#,
        )
        .expect("marker configuration should parse");
        assert_eq!(
            markers
                .url("geam-images", &Version::new(1, 2, 3), &checksum)
                .expect("supported markers should expand"),
            format!(
                "https://downloads.example/geam-images/1.2.3/ge/am/ge/am/{}",
                "ab".repeat(32),
            ),
        );
    }

    #[test]
    fn rejects_invalid_configuration_and_unsupported_markers() {
        for (source, expected, exact) in [
            (b"{".as_slice(), "EOF", false),
            (
                br#"{"dl":"http://example.test"}"#.as_slice(),
                "download URL must use HTTPS",
                true,
            ),
        ] {
            assert!(matches!(
                parse(source),
                Err(RegistryDiscoveryError::Protocol {
                    response: "configuration",
                    reason,
                }) if if exact {
                    reason == expected
                } else {
                    reason.contains(expected)
                }
            ));
        }

        let unsupported = parse(br#"{"dl":"https://downloads.example/{crate}/{unknown}"}"#)
            .expect("HTTPS configuration should parse");
        assert!(matches!(
            unsupported.url("geam-images", &Version::new(1, 0, 0), &[0; 32]),
            Err(RegistryDiscoveryError::Protocol {
                response: "configuration",
                ref reason,
            }) if reason.contains("unsupported marker")
        ));
    }
}