allow specifying http headers, proxy and user agent

Author: QaidVoid

Cargo.lock

@@ -26,7 +26,7 @@ flate2 = "1.1.1"
 futures = "0.3.31"
 indicatif = { version = "0.17.11", optional = true }
 regex = { version = "1.11.1", default-features = false, features = ["std", "unicode-case", "unicode-perl"] }
-reqwest = { version = "0.12.15", default-features = false, features = ["rustls-tls", "stream", "http2", "blocking", "json"] }
+reqwest = { version = "0.12.15", default-features = false, features = ["rustls-tls", "stream", "http2", "blocking", "json", "socks"] }
 serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.140"
 tar = "0.4.44"

Cargo.toml

@@ -76,4 +76,16 @@ pub struct Args {
     /// Quiet mode
     #[arg(required = false, long, short)]
     pub quiet: bool,
+
+    /// Set proxy
+    #[arg(required = false, long)]
+    pub proxy: Option<String>,
+
+    /// Set request headers
+    #[arg(required = false, long, short = 'H')]
+    pub header: Option<Vec<String>>,
+
+    /// Set user agent
+    #[arg(required = false, long, short = 'A')]
+    pub user_agent: Option<String>,
 }

src/bin/soar-dl/cli.rs

@@ -1,9 +1,10 @@
-use std::sync::Arc;
+use std::{error::Error, sync::Arc};
 
 use clap::Parser;
 use cli::Args;
 use download_manager::DownloadManager;
 use progress::create_progress_bar;
+use soar_dl::http_client::{configure_http_client, create_http_header_map};
 
 mod cli;
 mod download_manager;
@@ -19,6 +20,28 @@ async fn main() {
     let progress_bar = create_progress_bar();
     let progress_callback = Arc::new(move |state| progress::handle_progress(state, &progress_bar));
 
+    let proxy = args.proxy.clone();
+    let user_agent = args.user_agent.clone();
+    let header = args.header.clone();
+
+    if let Err(err) = configure_http_client(|config| {
+        config.proxy = proxy;
+
+        if let Some(user_agent) = user_agent {
+            config.user_agent = Some(user_agent);
+        }
+
+        if let Some(headers) = header {
+            config.headers = Some(create_http_header_map(headers));
+        }
+    }) {
+        error!("Error configuring HTTP client: {}", err);
+        if let Some(source) = err.source() {
+            error!("  Caused by: {}", source);
+        }
+        std::process::exit(1);
+    };
+
     let manager = DownloadManager::new(args, progress_callback);
     manager.execute().await;
 }

src/bin/soar-dl/main.rs

@@ -1,41 +1,98 @@
-use std::{sync::LazyLock, time::Duration};
+use std::{
+    str::FromStr,
+    sync::{Arc, LazyLock, RwLock},
+};
 
-use reqwest::{header::HeaderMap, Client};
+use reqwest::{
+    header::{HeaderMap, HeaderName, HeaderValue},
+    Client,
+};
 
-pub static SHARED_CLIENT: LazyLock<Client> = LazyLock::new(|| {
-    Client::builder()
-        .user_agent("pkgforge/soar")
-        .build()
-        .expect("failed to build default client")
+struct SharedClient {
+    client: Client,
+    config: ClientConfig,
+}
+
+static SHARED_CLIENT_STATE: LazyLock<Arc<RwLock<SharedClient>>> = LazyLock::new(|| {
+    let config = ClientConfig::default();
+    let client = config.build().expect("failed to build default client");
+
+    Arc::new(RwLock::new(SharedClient { client, config }))
 });
 
+pub static SHARED_CLIENT: LazyLock<Client> =
+    LazyLock::new(|| SHARED_CLIENT_STATE.read().unwrap().client.clone());
+
+#[derive(Clone, Debug)]
 pub struct ClientConfig {
     pub user_agent: Option<String>,
     pub headers: Option<HeaderMap>,
     pub proxy: Option<String>,
-    pub timeout: Option<Duration>,
+}
+
+impl Default for ClientConfig {
+    fn default() -> Self {
+        Self {
+            user_agent: Some("pkgforge/soar".to_string()),
+            headers: None,
+            proxy: None,
+        }
+    }
 }
 
 impl ClientConfig {
-    pub fn build(self) -> Result<Client, reqwest::Error> {
+    pub fn build(&self) -> Result<Client, reqwest::Error> {
         let mut builder = Client::builder();
 
-        if let Some(user_agent) = self.user_agent {
+        if let Some(user_agent) = &self.user_agent {
             builder = builder.user_agent(user_agent);
         }
 
-        if let Some(headers) = self.headers {
-            builder = builder.default_headers(headers);
-        }
-
-        if let Some(proxy_url) = self.proxy {
-            builder = builder.proxy(reqwest::Proxy::all(&proxy_url)?);
+        if let Some(headers) = &self.headers {
+            builder = builder.default_headers(headers.clone());
         }
 
-        if let Some(timeout) = self.timeout {
-            builder = builder.timeout(timeout);
+        if let Some(proxy_url) = &self.proxy {
+            builder = builder.proxy(reqwest::Proxy::all(proxy_url)?);
         }
 
         builder.build()
     }
 }
+
+pub fn create_http_header_map(headers: Vec<String>) -> HeaderMap {
+    let mut header_map = HeaderMap::new();
+
+    for header in headers {
+        let parts: Vec<&str> = header.splitn(2, ':').collect();
+        if parts.len() == 2 {
+            let key = parts[0].trim();
+            let value = parts[1].trim();
+
+            if let Ok(header_name) = HeaderName::from_str(key) {
+                if let Ok(header_value) = HeaderValue::from_str(value) {
+                    header_map.insert(header_name, header_value);
+                }
+            }
+        }
+    }
+
+    header_map
+}
+
+pub fn configure_http_client<F>(updater: F) -> Result<(), reqwest::Error>
+where
+    F: FnOnce(&mut ClientConfig),
+{
+    let mut state = SHARED_CLIENT_STATE.write().unwrap();
+    let mut new_config = state.config.clone();
+
+    updater(&mut new_config);
+
+    let new_client = new_config.build()?;
+
+    state.client = new_client;
+    state.config = new_config;
+
+    Ok(())
+}