downloader: Fix exports and add prelude module

Author: cyberphantom52

crates/download-manager/src/download.rs

@@ -21,7 +21,7 @@ pub struct Download {
 }
 
 impl Download {
-    pub fn new(
+    pub(crate) fn new(
         id: DownloadID,
         progress: watch::Receiver<Progress>,
         events: broadcast::Receiver<DownloadEvent>,

crates/download-manager/src/download_manager.rs

@@ -4,20 +4,23 @@ mod error;
 mod events;
 mod request;
 mod scheduler;
+pub mod prelude {
+    pub use crate::{
+        context::DownloadID,
+        download::{Download, DownloadResult},
+        error::DownloadError,
+        events::{DownloadEvent, Progress},
+        request::Request,
+    };
+}
 
 use crate::{
     context::Context,
     request::RequestBuilder,
     scheduler::{Scheduler, SchedulerCmd},
 };
-pub use crate::{
-    context::DownloadID,
-    download::{Download, DownloadResult},
-    error::DownloadError,
-    events::{DownloadEvent, Progress},
-    request::Request,
-};
 use futures_core::Stream;
+use prelude::*;
 use reqwest::Url;
 use std::{
     path::Path,

crates/download-manager/src/events.rs

@@ -62,7 +62,7 @@ pub struct Progress {
 }
 
 impl Progress {
-    pub fn new(total_bytes: Option<u64>) -> Self {
+    pub(crate) fn new(total_bytes: Option<u64>) -> Self {
         let now = Instant::now();
         Progress {
             bytes_downloaded: 0,
@@ -79,17 +79,17 @@ impl Progress {
         }
     }
 
-    pub fn with_sample_interval(mut self, min_sample_interval: Duration) -> Self {
+    pub(crate) fn with_sample_interval(mut self, min_sample_interval: Duration) -> Self {
         self.min_sample_interval = min_sample_interval;
         self
     }
 
-    pub fn with_sample_bytes(mut self, min_sample_bytes: u64) -> Self {
+    pub(crate) fn with_sample_bytes(mut self, min_sample_bytes: u64) -> Self {
         self.min_sample_bytes = min_sample_bytes;
         self
     }
 
-    pub fn with_ema_alpha(mut self, ema_alpha: f64) -> Self {
+    pub(crate) fn with_ema_alpha(mut self, ema_alpha: f64) -> Self {
         self.ema_alpha = ema_alpha;
         self
     }
@@ -122,7 +122,7 @@ impl Progress {
         }
     }
 
-    pub fn update(&mut self, chunk_len: u64) -> bool {
+    pub(crate) fn update(&mut self, chunk_len: u64) -> bool {
         let now = Instant::now();
         self.bytes_downloaded += chunk_len;
         self.updated_at = now;
@@ -153,7 +153,7 @@ impl Progress {
         false
     }
 
-    pub fn force_update(&mut self) {
+    pub(crate) fn force_update(&mut self) {
         let now = Instant::now();
         let dt = now.duration_since(self.last_sample_at);
         let byte_delta = self.bytes_downloaded - self.last_sample_bytes;

crates/download-manager/src/scheduler.rs

@@ -36,7 +36,7 @@ static BACKOFF_STRATEGY: ExponentialBackoff = ExponentialBackoff {
     max_delay: Duration::from_secs(10),
 };
 
-pub enum SchedulerCmd {
+pub(crate) enum SchedulerCmd {
     Enqueue {
         request: Request,
         result_tx: oneshot::Sender<Result<DownloadResult, DownloadError>>,
@@ -46,14 +46,14 @@ pub enum SchedulerCmd {
     },
 }
 
-pub enum WorkerMsg {
+enum WorkerMsg {
     Finish {
         id: DownloadID,
         result: Result<DownloadResult, DownloadError>,
     },
 }
 
-pub struct Scheduler {
+pub(crate) struct Scheduler {
     ctx: Arc<Context>,
     tracker: TaskTracker,
 
@@ -85,7 +85,7 @@ impl Scheduler {
         }
     }
 
-    pub fn schedule(&mut self, job: Job) {
+    fn schedule(&mut self, job: Job) {
         let request = &job.request;
         let id = job.id();
         request.emit(DownloadEvent::Queued {
@@ -222,25 +222,25 @@ pub(crate) struct Job {
 }
 
 impl Job {
-    pub fn id(&self) -> DownloadID {
+    fn id(&self) -> DownloadID {
         self.request.id()
     }
 
-    pub fn send_result(self, result: Result<DownloadResult, DownloadError>) {
+    fn send_result(self, result: Result<DownloadResult, DownloadError>) {
         if let Some(result_tx) = self.result {
             let _ = result_tx.send(result);
         }
     }
 
-    pub fn fail(self, error: DownloadError) {
+    fn fail(self, error: DownloadError) {
         self.request.emit(DownloadEvent::Failed {
             id: self.id(),
             error: error.to_string(),
         });
         self.send_result(Err(error));
     }
 
-    pub fn finish(self, result: DownloadResult) {
+    fn finish(self, result: DownloadResult) {
         self.request.emit(DownloadEvent::Completed {
             id: self.id(),
             path: result.path.clone(),
@@ -249,23 +249,23 @@ impl Job {
         self.send_result(Ok(result))
     }
 
-    pub fn retry(&self, delay: Duration) {
+    fn retry(&self, delay: Duration) {
         self.request.emit(DownloadEvent::Retrying {
             id: self.id(),
             attempt: self.attempt,
             next_delay_ms: delay.as_millis() as u64,
         });
     }
 
-    pub fn cancel(self) {
+    fn cancel(self) {
         self.request.cancel_token.cancel();
         self.request
             .emit(DownloadEvent::Cancelled { id: self.id() });
         self.send_result(Err(DownloadError::Cancelled))
     }
 }
 
-pub async fn run(request: Arc<Request>, ctx: Arc<Context>, worker_tx: mpsc::Sender<WorkerMsg>) {
+async fn run(request: Arc<Request>, ctx: Arc<Context>, worker_tx: mpsc::Sender<WorkerMsg>) {
     let result = attempt_download(request.as_ref(), ctx.client.clone()).await;
 
     let _ = worker_tx