use crate::error::{Error, Result};
use crate::manifest::RetryConfig;
use chrono_machines::{BackoffStrategy, ExponentialBackoff};
use rand::rng;
use sha2::{Digest, Sha256};
use std::fs::{self, File};
use std::io::{BufReader, Read, Write};
use std::path::Path;
use std::thread;
use std::time::Duration;
pub const fn backoff_from_config(config: &RetryConfig) -> ExponentialBackoff {
ExponentialBackoff::new()
.base_delay_ms(config.base_delay_ms)
.max_delay_ms(config.max_delay_ms)
.multiplier(config.multiplier)
.max_attempts(config.max_attempts)
.jitter_factor(config.jitter_factor)
}
fn is_retryable(err: &ureq::Error) -> bool {
match err {
ureq::Error::StatusCode(408 | 429) => true,
ureq::Error::StatusCode(code) => !(400..500).contains(code),
_ => true,
}
}
fn retry_call<T>(
url: &str,
retry_config: &RetryConfig,
what: &str,
mut call: impl FnMut() -> std::result::Result<T, ureq::Error>,
) -> Result<T> {
let backoff = backoff_from_config(retry_config);
let mut rng = rng();
let mut attempt: u8 = 0;
loop {
attempt += 1;
match call() {
Ok(v) => return Ok(v),
Err(e) if !is_retryable(&e) => {
return Err(Error::DownloadFailed(format!(
"{what} failed for {url}: {e}"
)));
}
Err(e) => {
if let Some(delay_ms) = backoff.delay(attempt, &mut rng) {
eprintln!("{what} attempt {attempt} failed, retrying in {delay_ms}ms...");
thread::sleep(Duration::from_millis(delay_ms));
} else {
return Err(Error::DownloadFailed(format!(
"{what} failed for {url} after {attempt} attempts: {e}"
)));
}
}
}
}
}
pub fn download_file(
url: &str,
dest: &Path,
expected_sha256: Option<&str>,
retry_config: &RetryConfig,
) -> Result<()> {
if let Some(parent) = dest.parent() {
fs::create_dir_all(parent).map_err(|e| {
Error::DownloadFailed(format!(
"Failed to create directory {}: {}",
parent.display(),
e
))
})?;
}
eprintln!("Downloading: {url}");
let response = retry_call(url, retry_config, "Download", || ureq::get(url).call())?;
let content_length: Option<u64> = response
.headers()
.get("Content-Length")
.and_then(|v| v.to_str().ok())
.and_then(|s| s.parse().ok());
if let Some(len) = content_length {
#[allow(clippy::cast_precision_loss)]
let megabytes = len as f64 / 1_048_576.0;
eprintln!("Size: {len} bytes ({megabytes:.2} MB)");
}
let _ = std::fs::remove_file(dest);
let mut file = std::fs::OpenOptions::new()
.write(true)
.create_new(true)
.open(dest)
.map_err(|e| {
Error::DownloadFailed(format!("Failed to create file {}: {}", dest.display(), e))
})?;
let mut reader = response.into_body().into_reader();
let mut hasher = Sha256::new();
let mut buffer = vec![0u8; 65536]; let mut downloaded: u64 = 0;
let mut last_progress: u64 = 0;
loop {
let bytes_read = reader
.read(&mut buffer)
.map_err(|e| Error::DownloadFailed(format!("Read error during download: {e}")))?;
if bytes_read == 0 {
break;
}
file.write_all(&buffer[..bytes_read])
.map_err(|e| Error::DownloadFailed(format!("Write error during download: {e}")))?;
if expected_sha256.is_some() {
hasher.update(&buffer[..bytes_read]);
}
downloaded += bytes_read as u64;
if let Some(total) = content_length
&& let Some(progress) = (downloaded * 100).checked_div(total)
&& progress >= last_progress + 10
{
eprintln!("Progress: {progress}% ({downloaded} / {total} bytes)");
last_progress = progress;
}
}
eprintln!("Downloaded: {downloaded} bytes");
if let Some(expected) = expected_sha256 {
let actual = hex::encode(hasher.finalize());
if actual != expected {
let _ = fs::remove_file(dest);
return Err(Error::ChecksumMismatch {
file: dest.display().to_string(),
expected: expected.to_string(),
actual,
});
}
eprintln!("Checksum verified: OK");
}
Ok(())
}
pub fn sha256_file(path: &Path) -> Result<String> {
let file = File::open(path)
.map_err(|e| Error::DownloadFailed(format!("Failed to open file for checksum: {e}")))?;
let mut reader = BufReader::new(file);
let mut hasher = Sha256::new();
let mut buffer = vec![0u8; 65536];
loop {
let bytes_read = reader
.read(&mut buffer)
.map_err(|e| Error::DownloadFailed(format!("Read error computing checksum: {e}")))?;
if bytes_read == 0 {
break;
}
hasher.update(&buffer[..bytes_read]);
}
Ok(hex::encode(hasher.finalize()))
}
pub fn fetch_text(url: &str, retry_config: &RetryConfig) -> Result<String> {
let response = retry_call(url, retry_config, "Fetch", || ureq::get(url).call())?;
response
.into_body()
.read_to_string()
.map_err(|e| Error::DownloadFailed(format!("Failed to read response body: {e}")))
}
pub fn url_exists(url: &str, retry_config: &RetryConfig) -> bool {
retry_call(url, retry_config, "Probe", || ureq::head(url).call()).is_ok()
}
#[cfg(test)]
mod tests;