Init commit

crates/backend/src/streaming.rs

@@ -0,0 +1,97 @@
+use std::fs::File;
+use std::io::{self, Read, Seek, SeekFrom};
+use std::path::Path;
+use std::sync::{Arc, Condvar, Mutex};
+
+#[derive(Default)]
+struct State {
+    available: u64,
+    complete: bool,
+}
+#[derive(Default)]
+struct Shared {
+    state: Mutex<State>,
+    changed: Condvar,
+}
+pub struct GrowingFileReader {
+    file: File,
+    pos: u64,
+    shared: Arc<Shared>,
+}
+pub struct GrowingFileWriter {
+    shared: Arc<Shared>,
+}
+
+pub fn growing_file(path: &Path) -> io::Result<(GrowingFileReader, GrowingFileWriter)> {
+    let shared = Arc::new(Shared::default());
+    Ok((
+        GrowingFileReader {
+            file: File::open(path)?,
+            pos: 0,
+            shared: Arc::clone(&shared),
+        },
+        GrowingFileWriter { shared },
+    ))
+}
+impl GrowingFileWriter {
+    pub fn add_available(&self, bytes: u64) {
+        let mut state = self
+            .shared
+            .state
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        state.available = state.available.saturating_add(bytes);
+        self.shared.changed.notify_all();
+    }
+    pub fn finish(&self) {
+        let mut state = self
+            .shared
+            .state
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        state.complete = true;
+        self.shared.changed.notify_all();
+    }
+}
+impl Drop for GrowingFileWriter {
+    fn drop(&mut self) {
+        self.finish();
+    }
+}
+impl Read for GrowingFileReader {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        loop {
+            let mut state = self
+                .shared
+                .state
+                .lock()
+                .unwrap_or_else(std::sync::PoisonError::into_inner);
+            while self.pos >= state.available && !state.complete {
+                state = self
+                    .shared
+                    .changed
+                    .wait(state)
+                    .unwrap_or_else(std::sync::PoisonError::into_inner);
+            }
+            if self.pos >= state.available {
+                return Ok(0);
+            }
+            let n = usize::try_from((state.available - self.pos).min(buf.len() as u64))
+                .unwrap_or(buf.len());
+            drop(state);
+            let read = self.file.read(&mut buf[..n])?;
+            self.pos += read as u64;
+            if read > 0 {
+                return Ok(read);
+            }
+        }
+    }
+}
+impl Seek for GrowingFileReader {
+    fn seek(&mut self, _: SeekFrom) -> io::Result<u64> {
+        Err(io::Error::new(
+            io::ErrorKind::Unsupported,
+            "federated stream is not seekable while downloading",
+        ))
+    }
+}