use std::path::{Path, PathBuf};
use futures_util::StreamExt;
use tokio::fs::File;
use tokio::io::{AsyncWriteExt, BufWriter};
use crate::crypto::EncrawDecryptor;
use crate::error::{Error, Result};
use crate::transport::Transport;
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
pub enum Strategy {
#[default]
Failover,
Race,
}
pub struct Downloader<'a> {
transport: &'a Transport,
urls: Vec<String>,
key: Option<String>,
strategy: Strategy,
}
impl<'a> Downloader<'a> {
pub fn new(transport: &'a Transport, urls: impl IntoIterator<Item = String>) -> Self {
Self {
transport,
urls: urls.into_iter().collect(),
key: None,
strategy: Strategy::default(),
}
}
#[must_use]
pub fn encraw_key(mut self, key: impl Into<String>) -> Self {
self.key = Some(key.into());
self
}
#[must_use]
pub fn maybe_encraw_key(mut self, key: Option<impl Into<String>>) -> Self {
self.key = key.map(Into::into);
self
}
#[must_use]
pub fn strategy(mut self, strategy: Strategy) -> Self {
self.strategy = strategy;
self
}
pub async fn to_file(&self, path: impl AsRef<Path>) -> Result<u64> {
let path = path.as_ref();
self.ensure_urls()?;
let partial = partial_path(path);
if self.strategy == Strategy::Race && self.urls.len() > 1 {
if let Some(written) = self.race_to_file(&partial).await? {
commit(&partial, path).await?;
return Ok(written);
}
}
let mut last = None;
for url in &self.urls {
match self.stream_to_file(url, &partial).await {
Ok(written) => {
commit(&partial, path).await?;
return Ok(written);
},
Err(err) => {
remove_partial(&partial).await;
last = Some(err);
},
}
}
Err(last.unwrap_or(Error::IdMissing("download url")))
}
pub async fn to_bytes(&self) -> Result<Vec<u8>> {
self.ensure_urls()?;
if self.strategy == Strategy::Race && self.urls.len() > 1 {
if let Some(response) = self.race_open().await {
if let Ok(bytes) = collect(response).await {
return self.decrypted(bytes);
}
}
}
let mut last = None;
for url in &self.urls {
match self.transport.retrieve(url).await {
Ok(bytes) => return self.decrypted(bytes),
Err(err) => last = Some(err),
}
}
Err(last.unwrap_or(Error::IdMissing("download url")))
}
fn decrypted(&self, bytes: Vec<u8>) -> Result<Vec<u8>> {
match &self.key {
Some(key) => crate::crypto::decrypt_encraw(&bytes, key),
None => Ok(bytes),
}
}
fn ensure_urls(&self) -> Result<()> {
if self.urls.is_empty() {
return Err(Error::IdMissing("download url"));
}
Ok(())
}
async fn race_to_file(&self, path: &Path) -> Result<Option<u64>> {
let Some(response) = self.race_open().await else {
return Ok(None);
};
if let Ok(written) = self.pipe(response, path).await {
return Ok(Some(written));
}
remove_partial(path).await;
Ok(None)
}
async fn race_open(&self) -> Option<reqwest::Response> {
let mut opens = self
.urls
.iter()
.map(|url| {
let transport = self.transport;
Box::pin(async move { transport.open_stream(url).await })
})
.collect::<Vec<_>>();
loop {
if opens.is_empty() {
return None;
}
let (result, _index, rest) = futures_util::future::select_all(opens).await;
match result {
Ok(response) => return Some(response),
Err(_) => opens = rest,
}
}
}
async fn stream_to_file(&self, url: &str, path: &Path) -> Result<u64> {
let response = self.transport.open_stream(url).await?;
self.pipe(response, path).await
}
async fn pipe(&self, response: reqwest::Response, path: &Path) -> Result<u64> {
let mut decryptor = match &self.key {
Some(key) => Some(EncrawDecryptor::from_hex_key(key)?),
None => None,
};
let expected = response.content_length();
let mut file = BufWriter::new(File::create(path).await?);
let mut stream = response.bytes_stream();
let mut written = 0u64;
while let Some(chunk) = stream.next().await {
let mut chunk = chunk?.to_vec();
if let Some(decryptor) = &mut decryptor {
decryptor.apply(&mut chunk);
}
file.write_all(&chunk).await?;
written += chunk.len() as u64;
}
file.flush().await?;
if expected.is_some_and(|expected| written != expected) {
return Err(Error::InvalidResponse(format!(
"the download ended early: got {written} bytes of {}",
expected.unwrap_or_default()
)));
}
Ok(written)
}
}
async fn collect(response: reqwest::Response) -> Result<Vec<u8>> {
Ok(response.bytes().await?.to_vec())
}
async fn remove_partial(path: &Path) {
let _ = tokio::fs::remove_file(path).await;
}
fn partial_path(path: &Path) -> PathBuf {
let mut name = path.as_os_str().to_owned();
name.push(".part");
PathBuf::from(name)
}
async fn commit(partial: &Path, path: &Path) -> Result<()> {
match tokio::fs::rename(partial, path).await {
Ok(()) => Ok(()),
Err(err) => {
remove_partial(partial).await;
Err(Error::Io(err))
},
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn failover_is_the_default_strategy() {
assert_eq!(Strategy::default(), Strategy::Failover);
}
#[test]
fn the_partial_file_is_a_sibling_of_the_destination() {
let partial = partial_path(Path::new("/music/track.flac"));
assert_eq!(partial, PathBuf::from("/music/track.flac.part"));
assert_eq!(partial.parent(), Path::new("/music/track.flac").parent());
assert_eq!(partial_path(Path::new("bare")), PathBuf::from("bare.part"));
}
}