add support for streaming response to stdout

QaidVoid · QaidVoid · commit 69ba8e1c7c48 · 2025-04-06T16:51:34.000+05:45
diff --git a/README.md b/README.md
@@ -43,6 +43,13 @@ soar-dl --github "pkgforge/soar" --gitlab "18817634" --output "final/"
 # Don't do this. The last download will replace the existing file
 # Only use file in output path if you're downloading single file.
 soar-dl --github "pkgforge/soar" --gitlab "18817634" --output "final"
+
+# Extract archives automatically (only `tar.gz`, `tar.xz`, `tar.zstd`, `tar.bz2`, and `zip` are supported)
+soar-dl "https://github.com/pkgforge/soar/releases/download/v0.5.14/soar-x86_64-linux.tar.gz" --extract
+
+# Stream response to stdout
+# If you like to pipe the response to other commands, also use quiet mode `-q` to silence other outputs
+soar-dl "https://github.com/pkgforge/soar/releases/download/v0.5.14/soar-x86_64-linux.tar.gz" -O-
 ```
 
 ## Command Line Options
@@ -65,6 +72,8 @@ Options:
   -c, --concurrency <CONCURRENCY>   GHCR concurrency
       --ghcr-api <GHCR_API>         GHCR API to use
       --exact-case                  Whether to use exact case matching for keywords
+      --extract                     Extract supported archive automatically
+  -q, --quiet                       Quiet mode
   -h, --help                        Print help
   -V, --version                     Print version
 ```
diff --git a/src/bin/soar-dl/cli.rs b/src/bin/soar-dl/cli.rs
@@ -64,4 +64,8 @@ pub struct Args {
     /// Extract supported archive automatically
     #[arg(required = false, long)]
     pub extract: bool,
+
+    /// Quiet mode
+    #[arg(required = false, long, short)]
+    pub quiet: bool,
 }
diff --git a/src/bin/soar-dl/download_manager.rs b/src/bin/soar-dl/download_manager.rs
@@ -15,7 +15,7 @@ use soar_dl::{
     },
 };
 
-use crate::cli::Args;
+use crate::{cli::Args, error, info};
 
 pub struct DownloadManager {
     args: Args,
@@ -86,7 +86,7 @@ impl DownloadManager {
 
         let selected_asset = self.select_asset(&assets)?;
 
-        println!("Downloading asset from {}", selected_asset.download_url());
+        info!("Downloading asset from {}", selected_asset.download_url());
         handler.download(&selected_asset, options.clone()).await?;
         Ok(())
     }
@@ -98,12 +98,12 @@ impl DownloadManager {
 
         let handler = ReleaseHandler::<Github>::new();
         for project in &self.args.github {
-            println!("Fetching releases from GitHub: {}", project);
+            info!("Fetching releases from GitHub: {}", project);
             if let Err(e) = self
                 .handle_platform_download::<Github, GithubRelease, GithubAsset>(&handler, project)
                 .await
             {
-                eprintln!("{}", e);
+                error!("{}", e);
             }
         }
         Ok(())
@@ -116,12 +116,12 @@ impl DownloadManager {
 
         let handler = ReleaseHandler::<Gitlab>::new();
         for project in &self.args.gitlab {
-            println!("Fetching releases from GitLab: {}", project);
+            info!("Fetching releases from GitLab: {}", project);
             if let Err(e) = self
                 .handle_platform_download::<Gitlab, GitlabRelease, GitlabAsset>(&handler, project)
                 .await
             {
-                eprintln!("{}", e);
+                error!("{}", e);
             }
         }
         Ok(())
@@ -144,7 +144,7 @@ impl DownloadManager {
         let mut retries = 0;
         loop {
             if retries > 5 {
-                eprintln!("Max retries exhausted. Aborting.");
+                error!("Max retries exhausted. Aborting.");
                 break;
             }
             match downloader.download_oci().await {
@@ -157,7 +157,7 @@ impl DownloadManager {
                     | DownloadError::ChunkError,
                 ) => thread::sleep(Duration::from_secs(5)),
                 Err(err) => {
-                    eprintln!("{}", err);
+                    error!("{}", err);
                     break;
                 }
             };
@@ -173,7 +173,7 @@ impl DownloadManager {
         }
 
         for reference in &self.args.ghcr {
-            println!("Downloading using OCI reference: {}", reference);
+            info!("Downloading using OCI reference: {}", reference);
 
             self.handle_oci_download(reference).await?;
         }
@@ -185,7 +185,7 @@ impl DownloadManager {
         for link in &self.args.links {
             match PlatformUrl::parse(link) {
                 Ok(PlatformUrl::DirectUrl(url)) => {
-                    println!("Downloading using direct link: {}", url);
+                    info!("Downloading using direct link: {}", url);
 
                     let options = DownloadOptions {
                         url: link.clone(),
@@ -196,39 +196,39 @@ impl DownloadManager {
                     let _ = downloader
                         .download(options)
                         .await
-                        .map_err(|e| eprintln!("{}", e));
+                        .map_err(|e| error!("{}", e));
                 }
                 Ok(PlatformUrl::Github(project)) => {
-                    println!("Detected GitHub URL, processing as GitHub release");
+                    info!("Detected GitHub URL, processing as GitHub release");
                     let handler = ReleaseHandler::<Github>::new();
                     if let Err(e) = self
                         .handle_platform_download::<Github, GithubRelease, GithubAsset>(
                             &handler, &project,
                         )
                         .await
                     {
-                        eprintln!("{}", e);
+                        error!("{}", e);
                     }
                 }
                 Ok(PlatformUrl::Gitlab(project)) => {
-                    println!("Detected GitLab URL, processing as GitLab release");
+                    info!("Detected GitLab URL, processing as GitLab release");
                     let handler = ReleaseHandler::<Gitlab>::new();
                     if let Err(e) = self
                         .handle_platform_download::<Gitlab, GitlabRelease, GitlabAsset>(
                             &handler, &project,
                         )
                         .await
                     {
-                        eprintln!("{}", e);
+                        error!("{}", e);
                     }
                 }
                 Ok(PlatformUrl::Oci(url)) => {
-                    println!("Downloading using OCI reference: {}", url);
+                    info!("Downloading using OCI reference: {}", url);
                     if let Err(e) = self.handle_oci_download(&url).await {
-                        eprintln!("{}", e);
+                        error!("{}", e);
                     };
                 }
-                Err(err) => eprintln!("Error parsing URL '{}' : {}", link, err),
+                Err(err) => error!("Error parsing URL '{}' : {}", link, err),
             };
         }
         Ok(())
@@ -243,13 +243,13 @@ impl DownloadManager {
             return Ok(assets[0].clone());
         }
 
-        println!("\nAvailable assets:");
+        info!("\nAvailable assets:");
         for (i, asset) in assets.iter().enumerate() {
             let size = asset
                 .size()
                 .map(|s| format!(" ({})", HumanBytes(s)))
                 .unwrap_or_default();
-            println!("{}. {}{}", i + 1, asset.name(), size);
+            info!("{}. {}{}", i + 1, asset.name(), size);
         }
 
         loop {
@@ -261,7 +261,7 @@ impl DownloadManager {
 
             match input.trim().parse::<usize>() {
                 Ok(n) if n > 0 && n <= assets.len() => return Ok(assets[n - 1].clone()),
-                _ => println!("Invalid selection, please try again."),
+                _ => error!("Invalid selection, please try again."),
             }
         }
     }
diff --git a/src/bin/soar-dl/log.rs b/src/bin/soar-dl/log.rs
@@ -0,0 +1,29 @@
+use std::sync::atomic::{AtomicBool, Ordering};
+
+static QUIET_MODE: AtomicBool = AtomicBool::new(false);
+
+pub fn init(quiet: bool) {
+    QUIET_MODE.store(quiet, Ordering::SeqCst);
+}
+
+pub fn is_quiet() -> bool {
+    QUIET_MODE.load(Ordering::SeqCst)
+}
+
+#[macro_export]
+macro_rules! info {
+    ($($arg:tt)*) => {
+        if !$crate::log::is_quiet() {
+            println!("{}", format!($($arg)*));
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! error {
+    ($($arg:tt)*) => {
+        if !$crate::log::is_quiet() {
+            eprintln!("{}", format!($($arg)*));
+        }
+    };
+}
diff --git a/src/bin/soar-dl/main.rs b/src/bin/soar-dl/main.rs
@@ -7,11 +7,15 @@ use progress::create_progress_bar;
 
 mod cli;
 mod download_manager;
+mod log;
 mod progress;
 
 #[tokio::main]
 async fn main() {
     let args = Args::parse();
+
+    log::init(args.quiet);
+
     let progress_bar = create_progress_bar();
     let progress_callback = Arc::new(move |state| progress::handle_progress(state, &progress_bar));
 
diff --git a/src/downloader.rs b/src/downloader.rs
@@ -1,6 +1,7 @@
 use std::{
     collections::{HashMap, HashSet},
     fs::Permissions,
+    io::Write,
     os::unix::fs::PermissionsExt,
     path::{Path, PathBuf},
     sync::{Arc, Mutex},
@@ -83,6 +84,19 @@ impl Downloader {
 
         let content_length = response.content_length().unwrap_or(0);
 
+        if options.output_path.as_deref() == Some("-") {
+            let stdout = std::io::stdout();
+            let mut stdout_lock = stdout.lock();
+            let mut stream = response.bytes_stream();
+
+            while let Some(chunk) = stream.next().await {
+                let chunk = chunk.unwrap();
+                stdout_lock.write_all(&chunk).unwrap();
+                stdout_lock.flush().unwrap();
+            }
+            return Ok("-".to_string());
+        }
+
         let filename = options
             .output_path
             .or_else(|| {

Original file line number	Diff line number	Diff line change
`@@ -64,4 +64,8 @@ pub struct Args {`
`64`	`64`	`/// Extract supported archive automatically`
`65`	`65`	`#[arg(required = false, long)]`
`66`	`66`	`pub extract: bool,`
	`67`	`+`
	`68`	`+ /// Quiet mode`
	`69`	`+ #[arg(required = false, long, short)]`
	`70`	`+ pub quiet: bool,`
`67`	`71`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ use soar_dl::{`
`15`	`15`	`},`
`16`	`16`	`};`
`17`	`17`
`18`		`-use crate::cli::Args;`
	`18`	`+use crate::{cli::Args, error, info};`
`19`	`19`
`20`	`20`	`pub struct DownloadManager {`
`21`	`21`	`args: Args,`
`@@ -86,7 +86,7 @@ impl DownloadManager {`
`86`	`86`
`87`	`87`	`let selected_asset = self.select_asset(&assets)?;`
`88`	`88`
`89`		`- println!("Downloading asset from {}", selected_asset.download_url());`
	`89`	`+ info!("Downloading asset from {}", selected_asset.download_url());`
`90`	`90`	`handler.download(&selected_asset, options.clone()).await?;`
`91`	`91`	`Ok(())`
`92`	`92`	`}`
`@@ -98,12 +98,12 @@ impl DownloadManager {`
`98`	`98`
`99`	`99`	`let handler = ReleaseHandler::<Github>::new();`
`100`	`100`	`for project in &self.args.github {`
`101`		`- println!("Fetching releases from GitHub: {}", project);`
	`101`	`+ info!("Fetching releases from GitHub: {}", project);`
`102`	`102`	`if let Err(e) = self`
`103`	`103`	`.handle_platform_download::<Github, GithubRelease, GithubAsset>(&handler, project)`
`104`	`104`	`.await`
`105`	`105`	`{`
`106`		`- eprintln!("{}", e);`
	`106`	`+ error!("{}", e);`
`107`	`107`	`}`
`108`	`108`	`}`
`109`	`109`	`Ok(())`
`@@ -116,12 +116,12 @@ impl DownloadManager {`
`116`	`116`
`117`	`117`	`let handler = ReleaseHandler::<Gitlab>::new();`
`118`	`118`	`for project in &self.args.gitlab {`
`119`		`- println!("Fetching releases from GitLab: {}", project);`
	`119`	`+ info!("Fetching releases from GitLab: {}", project);`
`120`	`120`	`if let Err(e) = self`
`121`	`121`	`.handle_platform_download::<Gitlab, GitlabRelease, GitlabAsset>(&handler, project)`
`122`	`122`	`.await`
`123`	`123`	`{`
`124`		`- eprintln!("{}", e);`
	`124`	`+ error!("{}", e);`
`125`	`125`	`}`
`126`	`126`	`}`
`127`	`127`	`Ok(())`
`@@ -144,7 +144,7 @@ impl DownloadManager {`
`144`	`144`	`let mut retries = 0;`
`145`	`145`	`loop {`
`146`	`146`	`if retries > 5 {`
`147`		`- eprintln!("Max retries exhausted. Aborting.");`
	`147`	`+ error!("Max retries exhausted. Aborting.");`
`148`	`148`	`break;`
`149`	`149`	`}`
`150`	`150`	`match downloader.download_oci().await {`
`@@ -157,7 +157,7 @@ impl DownloadManager {`
`157`	`157`	`\| DownloadError::ChunkError,`
`158`	`158`	`) => thread::sleep(Duration::from_secs(5)),`
`159`	`159`	`Err(err) => {`
`160`		`- eprintln!("{}", err);`
	`160`	`+ error!("{}", err);`
`161`	`161`	`break;`
`162`	`162`	`}`
`163`	`163`	`};`
`@@ -173,7 +173,7 @@ impl DownloadManager {`
`173`	`173`	`}`
`174`	`174`
`175`	`175`	`for reference in &self.args.ghcr {`
`176`		`- println!("Downloading using OCI reference: {}", reference);`
	`176`	`+ info!("Downloading using OCI reference: {}", reference);`
`177`	`177`
`178`	`178`	`self.handle_oci_download(reference).await?;`
`179`	`179`	`}`
`@@ -185,7 +185,7 @@ impl DownloadManager {`
`185`	`185`	`for link in &self.args.links {`
`186`	`186`	`match PlatformUrl::parse(link) {`
`187`	`187`	`Ok(PlatformUrl::DirectUrl(url)) => {`
`188`		`- println!("Downloading using direct link: {}", url);`
	`188`	`+ info!("Downloading using direct link: {}", url);`
`189`	`189`
`190`	`190`	`let options = DownloadOptions {`
`191`	`191`	`url: link.clone(),`
`@@ -196,39 +196,39 @@ impl DownloadManager {`
`196`	`196`	`let _ = downloader`
`197`	`197`	`.download(options)`
`198`	`198`	`.await`
`199`		`- .map_err(\|e\| eprintln!("{}", e));`
	`199`	`+ .map_err(\|e\| error!("{}", e));`
`200`	`200`	`}`
`201`	`201`	`Ok(PlatformUrl::Github(project)) => {`
`202`		`- println!("Detected GitHub URL, processing as GitHub release");`
	`202`	`+ info!("Detected GitHub URL, processing as GitHub release");`
`203`	`203`	`let handler = ReleaseHandler::<Github>::new();`
`204`	`204`	`if let Err(e) = self`
`205`	`205`	`.handle_platform_download::<Github, GithubRelease, GithubAsset>(`
`206`	`206`	`&handler, &project,`
`207`	`207`	`)`
`208`	`208`	`.await`
`209`	`209`	`{`
`210`		`- eprintln!("{}", e);`
	`210`	`+ error!("{}", e);`
`211`	`211`	`}`
`212`	`212`	`}`
`213`	`213`	`Ok(PlatformUrl::Gitlab(project)) => {`
`214`		`- println!("Detected GitLab URL, processing as GitLab release");`
	`214`	`+ info!("Detected GitLab URL, processing as GitLab release");`
`215`	`215`	`let handler = ReleaseHandler::<Gitlab>::new();`
`216`	`216`	`if let Err(e) = self`
`217`	`217`	`.handle_platform_download::<Gitlab, GitlabRelease, GitlabAsset>(`
`218`	`218`	`&handler, &project,`
`219`	`219`	`)`
`220`	`220`	`.await`
`221`	`221`	`{`
`222`		`- eprintln!("{}", e);`
	`222`	`+ error!("{}", e);`
`223`	`223`	`}`
`224`	`224`	`}`
`225`	`225`	`Ok(PlatformUrl::Oci(url)) => {`
`226`		`- println!("Downloading using OCI reference: {}", url);`
	`226`	`+ info!("Downloading using OCI reference: {}", url);`
`227`	`227`	`if let Err(e) = self.handle_oci_download(&url).await {`
`228`		`- eprintln!("{}", e);`
	`228`	`+ error!("{}", e);`
`229`	`229`	`};`
`230`	`230`	`}`
`231`		`- Err(err) => eprintln!("Error parsing URL '{}' : {}", link, err),`
	`231`	`+ Err(err) => error!("Error parsing URL '{}' : {}", link, err),`
`232`	`232`	`};`
`233`	`233`	`}`
`234`	`234`	`Ok(())`
`@@ -243,13 +243,13 @@ impl DownloadManager {`
`243`	`243`	`return Ok(assets[0].clone());`
`244`	`244`	`}`
`245`	`245`
`246`		`- println!("\nAvailable assets:");`
	`246`	`+ info!("\nAvailable assets:");`
`247`	`247`	`for (i, asset) in assets.iter().enumerate() {`
`248`	`248`	`let size = asset`
`249`	`249`	`.size()`
`250`	`250`	`.map(\|s\| format!(" ({})", HumanBytes(s)))`
`251`	`251`	`.unwrap_or_default();`
`252`		`- println!("{}. {}{}", i + 1, asset.name(), size);`
	`252`	`+ info!("{}. {}{}", i + 1, asset.name(), size);`
`253`	`253`	`}`
`254`	`254`
`255`	`255`	`loop {`
`@@ -261,7 +261,7 @@ impl DownloadManager {`
`261`	`261`
`262`	`262`	`match input.trim().parse::<usize>() {`
`263`	`263`	`Ok(n) if n > 0 && n <= assets.len() => return Ok(assets[n - 1].clone()),`
`264`		`- _ => println!("Invalid selection, please try again."),`
	`264`	`+ _ => error!("Invalid selection, please try again."),`
`265`	`265`	`}`
`266`	`266`	`}`
`267`	`267`	`}`