use tracing::debug;
use super::helpers::{parse_single_digest, parse_single_link, split_link_entries, split_top_level};
use super::types::{DEFAULT_PRI, MetalinkHttpDigest, MetalinkHttpLink, MetalinkHttpResult};
use crate::http::header_processor::HttpResponseHead;
pub struct MetalinkHttpParser;
impl MetalinkHttpParser {
pub fn parse_link_header(header_value: &str) -> Vec<MetalinkHttpLink> {
let entries = split_link_entries(header_value);
let mut links: Vec<MetalinkHttpLink> = entries
.iter()
.filter_map(|entry| parse_single_link(entry))
.filter(|link| link.is_relevant())
.collect();
links.sort_by_key(|l| l.sort_key());
links
}
pub fn parse_digest_header(header_value: &str) -> Vec<MetalinkHttpDigest> {
let mut digests = Vec::new();
for param in split_top_level(header_value, ',') {
let trimmed = param.trim();
if let Some(digest) = parse_single_digest(trimmed) {
digests.push(digest);
}
}
digests
}
pub fn parse_response(
response: &HttpResponseHead,
preferred_locations: &[String],
) -> MetalinkHttpResult {
let mut all_links = Vec::new();
for value in response.header_all("link") {
all_links.extend(Self::parse_link_header(value));
}
if !all_links.is_empty() && !preferred_locations.is_empty() {
let locs_lower: Vec<String> = preferred_locations
.iter()
.map(|l| l.to_lowercase())
.collect();
for link in &mut all_links {
if let Some(ref geo) = link.geo
&& locs_lower.iter().any(|l| l == geo)
{
let current_pri = link.pri.unwrap_or(DEFAULT_PRI);
link.pri = Some(current_pri.saturating_sub(DEFAULT_PRI));
}
}
all_links.sort_by_key(|l| l.sort_key());
}
let mut all_digests = Vec::new();
for digest_value in response.header_all("digest") {
all_digests.extend(Self::parse_digest_header(digest_value));
}
if !all_digests.is_empty() {
all_digests = deduplicate_digests(all_digests);
}
debug!(
links = all_links.len(),
digests = all_digests.len(),
"Metalink/HTTP parse result"
);
MetalinkHttpResult {
links: all_links,
digests: all_digests,
}
}
}
pub(crate) fn deduplicate_digests(digests: Vec<MetalinkHttpDigest>) -> Vec<MetalinkHttpDigest> {
if digests.is_empty() {
return digests;
}
let mut groups: std::collections::HashMap<String, Vec<MetalinkHttpDigest>> =
std::collections::HashMap::new();
for d in digests {
groups.entry(d.algorithm.clone()).or_default().push(d);
}
let mut result = Vec::new();
for (_, entries) in groups {
if entries.is_empty() {
continue;
}
let first_value = &entries[0].value;
let consistent = entries.iter().all(|e| e.value == *first_value);
if consistent {
result.push(entries.into_iter().next().expect(
"entries is non-empty: is_empty check above guarantees at least one element",
));
}
}
result
}