curl attemptcurl-attempt

2 files changed, 265 insertions, 23 deletions

diff --git a/src/launcher/download.rs b/src/launcher/download.rs
index 4294d33..5240d55 100644
--- a/src/launcher/download.rs
+++ b/src/launcher/download.rs
@@ -1,36 +1,278 @@
-use std::path::{Path, PathBuf};
-use sha1_smol::Digest;
+use std::cmp::min;
+use std::collections::VecDeque;
+use std::error::Error;
+use std::future::Future;
+use std::pin::{pin, Pin};
+use std::task::{Context, Poll};
+use curl::easy::{Easy2, Handler, WriteError};
+use curl::multi::{Easy2Handle, EasyHandle, Multi};
+use tokio::task::spawn_blocking;
+use crate::launcher::constants::USER_AGENT;
 
-pub trait Download {
-    fn get_url(&self) -> &str;
-    fn get_path(&self) -> &Path;
-    fn get_expect_digest(&self) -> Option<Digest>;
-    fn get_expect_size(&self) -> Option<usize>;
+trait Download {
+    async fn prepare(&mut self, easy: &EasyHandle) -> Result<bool, Box<dyn Error>>;
+    async fn handle_chunk(&mut self, data: &[u8]) -> Result<(), Box<dyn Error>>;
+    async fn finish(&mut self) -> Result<(), Box<dyn Error>>;
+}
+
+#[derive(Clone, Copy)]
+enum MultiDownloaderState {
+    Primed,
+    Running,
+    Complete
+}
+
+struct MultiDownloader<T>
+where
+    T: Download + Send + Unpin + 'static
+{
+    state: MultiDownloaderState,
+    nhandles: usize,
+    jobs: Option<VecDeque<T>>
+}
 
-    fn always_redownload(&self) -> bool;
+impl<T> MultiDownloader<T>
+where
+    T: Download + Send + Unpin + 'static
+{
+    // TODO: this interface is kind of weird (we have to take ownership of the jobs, but maybe this isn't the best way to do that)
+
+    pub fn new(jobs: Vec<T>, nhandles: usize) -> MultiDownloader<T> {
+        assert!(nhandles > 0);
+
+        MultiDownloader {
+            state: MultiDownloaderState::Primed,
+            nhandles,
+            jobs: Some(jobs.into())
+        }
+    }
 }
 
-pub type DownloadJob = dyn Download + Sync + Send;
+struct MultiDownloadResult {
 
-pub struct MultiDownloader<'j, 'js> {
-    jobs: &'js [&'j DownloadJob],
-    nhandles: usize
 }
 
-impl<'j, 'js> MultiDownloader<'j, 'js> {
-    pub fn new(jobs: &'js [&'j DownloadJob]) -> MultiDownloader<'j, 'js> {
-        Self::with_handles(jobs, 8)
+impl<T> Future for MultiDownloader<T>
+where
+    T: Download + Send + Unpin + 'static
+{
+    type Output = MultiDownloadResult;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let self_mut = self.get_mut();
+        match self_mut.state {
+            MultiDownloaderState::Primed => {
+                self_mut.state = MultiDownloaderState::Running;
+                let jobs = self_mut.jobs.take().unwrap();
+                let nhandles = self_mut.nhandles;
+
+                spawn_blocking(move || {
+                    // TODO
+                    MultiDownloadBlocking::new(jobs, nhandles).perform();
+                });
+
+                Poll::Pending
+            },
+            MultiDownloaderState::Running => {
+                Poll::Pending // TODO
+            },
+            MultiDownloaderState::Complete => panic!("multi download polled after completion")
+        }
     }
+}
+
+struct MultiHandler<T: Download> {
+    job: Option<T>
+}
 
-    pub fn with_handles(jobs: &'js [&'j DownloadJob], nhandles: usize) -> MultiDownloader<'j, 'js> {
+impl<T: Download> Handler for MultiHandler<T> {
+    fn write(&mut self, data: &[u8]) -> Result<usize, WriteError> {
+        todo!()
+    }
+}
+
+struct MultiDownloadBlocking<T: Download> {
+    multi: Multi,
+    easy_handles: Vec<Easy2Handle<MultiHandler<T>>>,
+    jobs: VecDeque<T>
+}
+
+impl<'a, T: Download> MultiDownloadBlocking<T> {
+    fn new(jobs: VecDeque<T>, nhandles: usize) -> MultiDownloadBlocking<T> {
         assert!(nhandles > 0);
-        
-        MultiDownloader {
-            jobs, nhandles
+
+        let nhandles = min(nhandles, jobs.len());
+
+        let multi = Multi::new();
+        let mut easy_handles = Vec::with_capacity(nhandles);
+
+        for n in 0..nhandles {
+            let mut easy = Easy2::new(MultiHandler { job: None });
+            easy.useragent(USER_AGENT).expect("setting user agent shouldn't fail");
+
+            let mut handle = multi.add2(easy).expect("adding easy handle cannot fail");
+            handle.set_token(n).expect("setting token cannot fail");
+            easy_handles.push(handle);
+        }
+
+        MultiDownloadBlocking {
+            multi,
+            easy_handles,
+            jobs
         }
     }
+    
+    fn prepare_job(&mut self, easy: &mut Easy2Handle<MultiHandler<T>>, job: T) {
+        let handler = easy.get_mut();
+
+        todo!()
+    }
 
-    fn do_it(&self) {
-        
+    fn perform(&mut self) -> MultiDownloadResult {
+        todo!()
     }
-}
\ No newline at end of file
+}
+
+// 
+// pub struct MultiDownloader<'j> {
+//     state: MultiDownloaderState,
+//     jobs: VecDeque<DownloadJob>,
+//     multi: Multi,
+//     handles: Vec<Easy2Handle<EasyHandler<'j>>>
+// }
+// 
+// pub struct EasyHandler<'j> {
+//     job: Option<&'j DownloadJob>
+// }
+// 
+// impl<'j> Handler for EasyHandler<'j> {
+//     fn write(&mut self, data: &[u8]) -> Result<usize, WriteError> {
+// 
+//     }
+// }
+// 
+// impl<'j, 'js, T> MultiDownloader<'j, 'js, T>
+// where
+//     T: Download + Sync + Send + ?Sized
+// {
+//     pub fn new(jobs: &'js [&'j T]) -> MultiDownloader<'j, 'js, T> {
+//         Self::with_handles(jobs, 8)
+//     }
+// 
+//     pub fn with_handles(jobs: &'js [&'j T], nhandles: usize) -> MultiDownloader<'j, 'js, T> {
+//         assert!(nhandles > 0);
+// 
+//         let mut handles = Vec::with_capacity(nhandles);
+//         let multi = Multi::new();
+// 
+//         for n in 0..nhandles {
+//             let mut easy = multi.add2(Easy2::new(EasyHandler { job: None })).expect("adding easy handle should not fail");
+//             easy.set_token(n).expect("setting token should not fail");
+// 
+//             handles.push(easy);
+//         }
+// 
+//         MultiDownloader {
+//             state: MultiDownloaderState::Primed,
+//             
+//             multi,
+//             handles
+//         }
+//     }
+// 
+//     fn next_job(&mut self) -> Option<&T> {
+//         let oj = self.jobs.get(self.job_idx).cloned();
+//         self.job_idx += 1;
+//         oj
+//     }
+// }
+// 
+// pub struct MultiDownloadResult {
+// 
+// }
+// 
+// impl<'j, 'js, T> Future for MultiDownloader<'j, 'js, T>
+// where
+//     T: Download + Sync + Send + ?Sized
+// {
+//     type Output = MultiDownloadResult;
+// 
+//     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+//         let self_mut = self.get_mut();
+//         match self_mut.state {
+//             MultiDownloaderState::Primed => {
+//                 self_mut.state = MultiDownloaderState::Running;
+// 
+//                 // TODO: assign download jobs to each
+// 
+//                 Poll::Pending
+//             },
+//             MultiDownloaderState::Running => {
+//                 todo!()
+//             },
+//             MultiDownloaderState::Complete => panic!("multi downloader polled after completion")
+//         }
+//     }
+// }
+
+// fn sample() {
+//     struct AbcdDownloader {
+//         file: Option<File>,
+//         path: PathBuf,
+//         url: String,
+//         expect_size: usize,
+//         expect_sha1: Digest
+//     }
+//
+//     impl Download for AbcdDownloader {
+//         async fn before_download(&mut self) -> Result<bool, Box<dyn Error>> {
+//             let mut file = match File::open(&self.path).await {
+//                 Ok(f) => f,
+//                 Err(e) => return match e.kind() {
+//                     ErrorKind::NotFound => {
+//                         // TODO: ensure parent dirs exist
+//
+//                         Ok(true)
+//                     },
+//                     _ => Err(e.into())
+//                 }
+//             };
+//
+//             let mut buf = [0u8; 4096];
+//             let mut sha1 = Sha1::new();
+//             let mut tally = 0usize;
+//
+//             loop {
+//                 let n = file.read(&mut buf[..]).await?;
+//                 if n == 0 {
+//                     file.seek(SeekFrom::Start(0)).await?;
+//                     break;
+//                 }
+//
+//                 sha1.update(&buf[..n]);
+//                 tally += n;
+//             }
+//
+//             Ok(tally != self.expect_size || sha1.digest() != self.expect_sha1)
+//         }
+//
+//         async fn handle_chunk(&mut self, data: &[u8]) -> Result<usize, WriteError> {
+//             self.file.unwrap().write_all(data).await
+//         }
+//
+//         async fn after_download(&mut self) -> Result<(), Box<dyn Error>> {
+//             todo!()
+//         }
+//     }
+//
+//     let mut jobs = Vec::new();
+//     jobs.push(AbcdDownloader {
+//         file: None,
+//         path: PathBuf::from("/home/bigfoot/test.words"),
+//         url: String::from("https://github.com/"),
+//         expect_size: 10,
+//         expect_sha1: Digest::default()
+//     });
+//
+//     let abcd = MultiDownloader::new(jobs.iter().map(|a| a).collect::<Vec<&AbcdDownloader>>().as_slice());
+// }
diff --git a/src/launcher/request.rs b/src/launcher/request.rs
index df89a8b..ab11b73 100644
--- a/src/launcher/request.rs
+++ b/src/launcher/request.rs
@@ -122,7 +122,7 @@ impl Future for EasyFetch {
                         response_code: easy.response_code().expect("querying response code should not fail"),
                         data: out_data,
                         easy
-                    })).expect("curl fetch reader hangup (this shouldn't happen)");
+                    })).ok(); // suppress this result since we don't really care if the caller hung up
                     waker.wake();
                 });