use super::{FetchError, FetchRequest, Fetched, Fetcher, HttpFetcher, ProgressFn, ProxyConfig};
use crate::types::Address;
use async_trait::async_trait;
pub const DEFAULT_I2P_PROXY: &str = "http://127.0.0.1:4444";
pub const DEFAULT_TOR_PROXY: &str = "socks5h://127.0.0.1:9050";
pub struct ProxyFetcher {
scheme: String,
name: String,
http: HttpFetcher,
schemes: Vec<String>,
}
impl ProxyFetcher {
pub fn new(scheme: impl Into<String>, proxy: impl Into<ProxyConfig>) -> Self {
let scheme = scheme.into();
Self {
name: format!("{scheme}-proxy"),
schemes: vec![scheme.clone()],
scheme,
http: HttpFetcher::new().with_proxy(proxy),
}
}
pub fn i2p() -> Self {
Self::new("i2p", DEFAULT_I2P_PROXY)
}
pub fn tor() -> Self {
Self::new("tor", DEFAULT_TOR_PROXY)
}
pub fn with_http_fetcher(mut self, http: HttpFetcher) -> Self {
self.http = http;
self
}
pub fn scheme(&self) -> &str {
&self.scheme
}
pub fn proxy(&self) -> Option<&ProxyConfig> {
self.http.proxy()
}
fn rewrite(&self, request: &FetchRequest) -> Result<FetchRequest, FetchError> {
let prefix = format!("{}://", self.scheme);
let rest = request
.address
.uri
.strip_prefix(&prefix)
.ok_or_else(|| {
FetchError::InvalidAddress(format!(
"not a {} address: `{}`",
self.scheme, request.address.uri
))
})?
.trim_start_matches('/');
if rest.is_empty() {
return Err(FetchError::InvalidAddress(format!(
"{} address has no host: `{}`",
self.scheme, request.address.uri
)));
}
Ok(FetchRequest {
address: Address::new("http", format!("http://{rest}")),
destination: request.destination.clone(),
expected_sha256: request.expected_sha256.clone(),
})
}
}
#[async_trait]
impl Fetcher for ProxyFetcher {
fn name(&self) -> &str {
&self.name
}
fn schemes(&self) -> &[String] {
&self.schemes
}
async fn fetch(&self, request: &FetchRequest) -> Result<Fetched, FetchError> {
let mut fetched = self.http.fetch(&self.rewrite(request)?).await?;
fetched.address = request.address.clone();
Ok(fetched)
}
async fn fetch_with_progress(
&self,
request: &FetchRequest,
progress: &ProgressFn<'_>,
) -> Result<Fetched, FetchError> {
let mut fetched = self
.http
.fetch_with_progress(&self.rewrite(request)?, progress)
.await?;
fetched.address = request.address.clone();
Ok(fetched)
}
}