use std::{
fmt,
path::Path,
sync::Arc,
};
#[derive(Clone, Copy, Debug)]
pub struct TransferDesc<'a> {
pub source: &'a str,
pub dest: &'a Path,
pub total: Option<u64>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TransferOutcome<'a> {
Complete,
Failed(&'a str),
}
pub trait TransferProgress: Send + Sync {
fn position(
&self,
bytes: u64,
);
fn finish(
&self,
outcome: TransferOutcome<'_>,
);
}
pub trait TransferObserver: Send + Sync + fmt::Debug {
fn begin(
&self,
desc: &TransferDesc<'_>,
) -> Box<dyn TransferProgress>;
}
pub type TransferObservers = Vec<Arc<dyn TransferObserver>>;
pub struct TransferProgressStack {
handles: Vec<Box<dyn TransferProgress>>,
}
impl TransferProgressStack {
pub fn begin(
observers: &[Arc<dyn TransferObserver>],
desc: &TransferDesc<'_>,
) -> Self {
Self {
handles: observers.iter().map(|o| o.begin(desc)).collect(),
}
}
pub fn len(&self) -> usize {
self.handles.len()
}
pub fn is_empty(&self) -> bool {
self.handles.is_empty()
}
}
impl fmt::Debug for TransferProgressStack {
fn fmt(
&self,
f: &mut fmt::Formatter<'_>,
) -> fmt::Result {
f.debug_struct("TransferProgressStack")
.field("handles", &self.handles.len())
.finish()
}
}
impl TransferProgress for TransferProgressStack {
fn position(
&self,
bytes: u64,
) {
for handle in &self.handles {
handle.position(bytes);
}
}
fn finish(
&self,
outcome: TransferOutcome<'_>,
) {
for handle in &self.handles {
handle.finish(outcome);
}
}
}
#[cfg(test)]
pub(crate) mod testing {
use std::{
path::PathBuf,
sync::{
Arc,
Mutex,
PoisonError,
},
};
use super::{
TransferDesc,
TransferObserver,
TransferOutcome,
TransferProgress,
};
pub(crate) const ABC_SHA256: &str =
"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad";
#[cfg(feature = "fetch")]
mod server {
use std::{
io::{
Read,
Write,
},
net::TcpListener,
thread,
};
pub(crate) fn serve_once(
name: &str,
body: &'static [u8],
) -> String {
serve(name, body, body.len(), 0, 1, 200)
}
pub(crate) fn serve_status(
name: &str,
status: u16,
) -> String {
serve(name, b"", 0, 0, 1, status)
}
pub(crate) fn serve_n(
name: &str,
body: &'static [u8],
n: usize,
) -> String {
serve(name, body, body.len(), 0, n, 200)
}
pub(crate) fn serve_flaky(
name: &str,
body: &'static [u8],
failures: usize,
) -> String {
serve(name, body, body.len(), failures, 1, 200)
}
pub(crate) fn refused_url(name: &str) -> String {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let addr = listener.local_addr().unwrap();
drop(listener);
format!("http://{addr}/{name}")
}
pub(crate) fn serve_once_declaring(
name: &str,
body: &'static [u8],
declared: usize,
) -> String {
serve(name, body, declared, 0, 1, 200)
}
fn serve(
name: &str,
body: &'static [u8],
declared: usize,
failures: usize,
n: usize,
status: u16,
) -> String {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let url = format!("http://{}/{name}", listener.local_addr().unwrap());
thread::spawn(move || {
for _ in 0..failures {
let (stream, _) = listener.accept().unwrap();
drop(stream);
}
for _ in 0..n {
let (mut stream, _) = listener.accept().unwrap();
let mut head = Vec::new();
let mut buf = [0u8; 4096];
loop {
let read = stream.read(&mut buf).unwrap();
if read == 0 {
break;
}
head.extend_from_slice(&buf[..read]);
if head.windows(4).any(|w| w == b"\r\n\r\n") {
break;
}
}
let reason = match status {
200 => "OK",
401 => "Unauthorized",
404 => "Not Found",
_ => "Status",
};
let response = format!(
"HTTP/1.1 {status} {reason}\r\nContent-Length: {declared}\r\nConnection: close\r\n\r\n"
);
stream.write_all(response.as_bytes()).unwrap();
stream.write_all(body).unwrap();
stream.flush().unwrap();
}
});
url
}
}
#[cfg(feature = "fetch")]
pub(crate) use server::*;
#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) enum CacheProgressEvent {
Begin {
source: String,
dest: PathBuf,
total: Option<u64>,
},
Position(u64),
Finish(Result<(), String>),
}
type Log = Arc<Mutex<Vec<CacheProgressEvent>>>;
#[derive(Debug, Default)]
pub(crate) struct RecordingObserver {
log: Log,
}
impl RecordingObserver {
pub(crate) fn events(&self) -> Vec<CacheProgressEvent> {
self.log
.lock()
.unwrap_or_else(PoisonError::into_inner)
.clone()
}
}
impl TransferObserver for RecordingObserver {
fn begin(
&self,
desc: &TransferDesc<'_>,
) -> Box<dyn TransferProgress> {
push(
&self.log,
CacheProgressEvent::Begin {
source: desc.source.to_string(),
dest: desc.dest.to_path_buf(),
total: desc.total,
},
);
Box::new(RecordingHandle(self.log.clone()))
}
}
struct RecordingHandle(Log);
impl TransferProgress for RecordingHandle {
fn position(
&self,
bytes: u64,
) {
push(&self.0, CacheProgressEvent::Position(bytes));
}
fn finish(
&self,
outcome: TransferOutcome<'_>,
) {
let outcome = match outcome {
TransferOutcome::Complete => Ok(()),
TransferOutcome::Failed(message) => Err(message.to_string()),
};
push(&self.0, CacheProgressEvent::Finish(outcome));
}
}
fn push(
log: &Log,
event: CacheProgressEvent,
) {
log.lock()
.unwrap_or_else(PoisonError::into_inner)
.push(event);
}
}
#[cfg(test)]
mod tests {
use std::{
path::Path,
sync::{
Arc,
Mutex,
},
};
use super::*;
use crate::data::cache::testing::{
CacheProgressEvent,
RecordingObserver,
};
#[test]
fn test_stack_fans_out_to_every_observer() {
let a = Arc::new(RecordingObserver::default());
let b = Arc::new(RecordingObserver::default());
let observers: Vec<Arc<dyn TransferObserver>> = vec![a.clone(), b.clone()];
let desc = TransferDesc {
source: "https://example.invalid/file.bin",
dest: Path::new("/cache/file.bin"),
total: Some(10),
};
let stack = TransferProgressStack::begin(&observers, &desc);
assert_eq!(stack.len(), 2);
assert!(!stack.is_empty());
assert_eq!(format!("{stack:?}"), "TransferProgressStack { handles: 2 }");
stack.position(3);
stack.position(10);
stack.finish(TransferOutcome::Complete);
let expected = vec![
CacheProgressEvent::Begin {
source: "https://example.invalid/file.bin".to_string(),
dest: Path::new("/cache/file.bin").to_path_buf(),
total: Some(10),
},
CacheProgressEvent::Position(3),
CacheProgressEvent::Position(10),
CacheProgressEvent::Finish(Ok(())),
];
assert_eq!(a.events(), expected);
assert_eq!(b.events(), expected);
}
#[test]
fn test_stack_keeps_registration_order() {
#[derive(Debug)]
struct Tagged {
tag: &'static str,
log: Arc<Mutex<Vec<String>>>,
}
struct TaggedHandle {
tag: &'static str,
log: Arc<Mutex<Vec<String>>>,
}
impl TransferObserver for Tagged {
fn begin(
&self,
_: &TransferDesc<'_>,
) -> Box<dyn TransferProgress> {
self.log.lock().unwrap().push(format!("{}:begin", self.tag));
Box::new(TaggedHandle {
tag: self.tag,
log: self.log.clone(),
})
}
}
impl TransferProgress for TaggedHandle {
fn position(
&self,
bytes: u64,
) {
self.log
.lock()
.unwrap()
.push(format!("{}:position {bytes}", self.tag));
}
fn finish(
&self,
outcome: TransferOutcome<'_>,
) {
self.log
.lock()
.unwrap()
.push(format!("{}:finish {outcome:?}", self.tag));
}
}
let log = Arc::new(Mutex::new(Vec::new()));
let observers: Vec<Arc<dyn TransferObserver>> = vec![
Arc::new(Tagged {
tag: "first",
log: log.clone(),
}),
Arc::new(Tagged {
tag: "second",
log: log.clone(),
}),
];
let desc = TransferDesc {
source: "src",
dest: Path::new("dest"),
total: None,
};
let stack = TransferProgressStack::begin(&observers, &desc);
stack.position(1);
stack.finish(TransferOutcome::Failed("boom"));
assert_eq!(
*log.lock().unwrap(),
vec![
"first:begin",
"second:begin",
"first:position 1",
"second:position 1",
"first:finish Failed(\"boom\")",
"second:finish Failed(\"boom\")",
]
);
}
#[test]
fn test_empty_stack_is_inert() {
let desc = TransferDesc {
source: "src",
dest: Path::new("dest"),
total: None,
};
let stack = TransferProgressStack::begin(&[], &desc);
assert!(stack.is_empty());
assert_eq!(stack.len(), 0);
stack.position(5);
stack.finish(TransferOutcome::Complete);
}
}