use super::{FetchError, FetchRequest, Fetched, Fetcher, HttpFetcher, ProgressFn};
use crate::types::Address;
use async_trait::async_trait;
use std::sync::atomic::{AtomicU64, Ordering};
pub struct GatewayFetcher {
scheme: String,
prefix: String,
gateways: Vec<String>,
http: HttpFetcher,
schemes: Vec<String>,
}
impl GatewayFetcher {
pub fn new<I, S>(scheme: impl Into<String>, prefix: impl Into<String>, gateways: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
let scheme = scheme.into();
let gateways = gateways
.into_iter()
.map(Into::into)
.map(|gateway: String| gateway.trim_end_matches('/').to_owned())
.collect();
Self {
schemes: vec![scheme.clone()],
scheme,
prefix: normalize_prefix(prefix.into()),
gateways,
http: HttpFetcher::new(),
}
}
pub fn with_http_fetcher(mut self, http: HttpFetcher) -> Self {
self.http = http;
self
}
pub fn scheme(&self) -> &str {
&self.scheme
}
pub fn prefix(&self) -> &str {
&self.prefix
}
pub fn gateway(&self) -> &str {
self.gateways.first().map(String::as_str).unwrap_or("")
}
pub fn gateways(&self) -> &[String] {
&self.gateways
}
pub fn resolve(&self, uri: &str) -> Result<String, FetchError> {
Self::resolve_with(&self.scheme, &self.prefix, self.gateway(), uri)
}
fn resolve_with(
scheme: &str,
prefix: &str,
gateway: &str,
uri: &str,
) -> Result<String, FetchError> {
let marker = format!("{scheme}://");
let rest = uri
.strip_prefix(&marker)
.ok_or_else(|| FetchError::InvalidAddress(format!("not a {scheme} URI: `{uri}`")))?;
let rest = rest.trim_start_matches('/');
if rest.is_empty() {
return Err(FetchError::InvalidAddress(format!(
"{scheme} URI has nothing after the scheme: `{uri}`"
)));
}
Ok(format!("{gateway}{prefix}{rest}"))
}
fn rewrite(
scheme: &str,
prefix: &str,
gateway: &str,
request: &FetchRequest,
) -> Result<FetchRequest, FetchError> {
let resolved = Self::resolve_with(scheme, prefix, gateway, &request.address.uri)?;
let scheme = if resolved.starts_with("http://") {
"http"
} else {
"https"
};
Ok(FetchRequest {
address: Address::new(scheme, resolved),
destination: request.destination.clone(),
expected_sha256: request.expected_sha256.clone(),
})
}
}
fn normalize_prefix(prefix: String) -> String {
let trimmed = prefix.trim().trim_matches('/');
if trimmed.is_empty() {
"/".to_owned()
} else {
format!("/{trimmed}/")
}
}
#[async_trait]
impl Fetcher for GatewayFetcher {
fn name(&self) -> &str {
"gateway"
}
fn schemes(&self) -> &[String] {
&self.schemes
}
async fn fetch(&self, request: &FetchRequest) -> Result<Fetched, FetchError> {
self.fetch_with_progress(request, &|_: u64| {}).await
}
async fn fetch_with_progress(
&self,
request: &FetchRequest,
progress: &ProgressFn<'_>,
) -> Result<Fetched, FetchError> {
if self.gateways.is_empty() {
return Err(FetchError::InvalidAddress(format!(
"no {} gateway configured",
self.scheme
)));
}
let high_water = AtomicU64::new(0);
let mut errors = Vec::new();
for gateway in &self.gateways {
let rewritten = Self::rewrite(&self.scheme, &self.prefix, gateway, request)?;
let monotonic = |bytes: u64| {
let previous = high_water.fetch_max(bytes, Ordering::Relaxed);
if bytes > previous {
progress(bytes);
}
};
match self.http.fetch_with_progress(&rewritten, &monotonic).await {
Ok(fetched) => return Ok(fetched),
Err(error) => errors.push(error),
}
}
let count = errors.len();
Err(FetchError::AllFailed { count, errors })
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn resolves_with_a_root_prefix() {
let fetcher = GatewayFetcher::new("freenet", "/", ["http://127.0.0.1:8888"]);
assert_eq!(
fetcher.resolve("freenet://CHK@abc").expect("resolve"),
"http://127.0.0.1:8888/CHK@abc"
);
assert_eq!(
fetcher
.resolve("freenet:///USK@abc/site/1/x")
.expect("resolve"),
"http://127.0.0.1:8888/USK@abc/site/1/x"
);
}
#[test]
fn resolves_with_a_path_prefix_like_ipfs() {
let fetcher = GatewayFetcher::new("ipfs", "ipfs", ["https://ipfs.io/"]);
assert_eq!(fetcher.prefix(), "/ipfs/");
assert_eq!(
fetcher
.resolve("ipfs://bafyabc/docs/x.pdf?name=x")
.expect("resolve"),
"https://ipfs.io/ipfs/bafyabc/docs/x.pdf?name=x"
);
assert_eq!(fetcher.gateway(), "https://ipfs.io");
}
#[test]
fn keeps_gateways_in_preference_order() {
let fetcher = GatewayFetcher::new(
"freenet",
"/",
["http://127.0.0.1:8888/", "https://fproxy.example"],
);
assert_eq!(
fetcher.gateways(),
["http://127.0.0.1:8888", "https://fproxy.example"]
);
}
#[test]
fn rejects_a_foreign_scheme_and_an_empty_address() {
let fetcher = GatewayFetcher::new("freenet", "/", ["http://127.0.0.1:8888"]);
assert!(fetcher.resolve("ipfs://bafyabc").is_err());
assert!(fetcher.resolve("freenet://").is_err());
}
#[tokio::test]
async fn empty_gateway_list_is_an_error() {
let fetcher = GatewayFetcher::new("freenet", "/", Vec::<String>::new());
let request = FetchRequest {
address: Address::new("freenet", "freenet://CHK@abc"),
destination: std::path::PathBuf::from("out"),
expected_sha256: None,
};
let error = fetcher.fetch(&request).await.expect_err("no gateway");
assert!(
matches!(error, FetchError::InvalidAddress(_)),
"got {error:?}"
);
}
}