feat: disable downloader with console

uplink/src/collector/downloader.rs

@@ -72,7 +72,8 @@ use std::{io::Write, path::PathBuf};
 
 use crate::{base::bridge::BridgeTx, config::DownloaderConfig, Action, ActionResponse, Config};
 
-pub static STOP_DOWNLOAD: AtomicBool = AtomicBool::new(false);
+// Stops from downloading if true
+pub static DOWNLOADER_DISABLED: AtomicBool = AtomicBool::new(false);
 
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
@@ -256,7 +257,8 @@ impl FileDownloader {
             // Download and store to disk by streaming as chunks
             loop {
                 // Checks if downloader is disabled by user or not
-                if STOP_DOWNLOAD.load(Ordering::Acquire) {
+                if DOWNLOADER_DISABLED.load(Ordering::Acquire) {
+                    // async to ensure download can be cancelled during sleep
                     sleep(Duration::from_secs(1)).await;
                 }
                 let Some(item) = stream.next().await else { break };

uplink/src/console.rs

@@ -1,6 +1,8 @@
+use std::sync::atomic::Ordering;
+
 use axum::{extract::State, http::StatusCode, response::IntoResponse, routing::post, Router};
 use log::info;
-use uplink::base::CtrlTx;
+use uplink::{base::CtrlTx, collector::downloader::DOWNLOADER_DISABLED};
 
 use crate::ReloadHandle;
 
@@ -18,6 +20,8 @@ pub async fn start(port: u16, reload_handle: ReloadHandle, ctrl_tx: CtrlTx) {
     let app = Router::new()
         .route("/logs", post(reload_loglevel))
         .route("/shutdown", post(shutdown))
+        .route("/disable_downloader", post(disable_downloader))
+        .route("/enable_downloader", post(enable_downloader))
         .with_state(state);
 
     axum::Server::bind(&address.parse().unwrap()).serve(app.into_make_service()).await.unwrap();
@@ -38,3 +42,31 @@ async fn shutdown(State(state): State<StateHandle>) -> impl IntoResponse {
 
     StatusCode::OK
 }
+
+// Stops downloader from downloading even if it was already stopped
+async fn disable_downloader() -> impl IntoResponse {
+    info!("Downloader stopped");
+    // Shouldn't panic as always sets to true
+    if DOWNLOADER_DISABLED
+        .fetch_update(Ordering::Release, Ordering::Acquire, |_| Some(true))
+        .unwrap()
+    {
+        StatusCode::ACCEPTED
+    } else {
+        StatusCode::OK
+    }
+}
+
+// Start downloader back up even if it was already not stopped
+async fn enable_downloader() -> impl IntoResponse {
+    info!("Downloader started");
+    // Shouldn't panic as always sets to true
+    if DOWNLOADER_DISABLED
+        .fetch_update(Ordering::Release, Ordering::Acquire, |_| Some(false))
+        .unwrap()
+    {
+        StatusCode::OK
+    } else {
+        StatusCode::ACCEPTED
+    }
+}