wip

Author: mxve

src/cdn.rs

@@ -22,7 +22,12 @@ impl File {
 
     /// Temporary (full) file path for downloading
     pub fn cache_path(&self) -> PathBuf {
-        format!("{}/{}", &global::CACHE_DIR, self.cache_name()).into()
+        format!(
+            "{}/{}",
+            utils::get_mutex(&global::CACHE_DIR).display(),
+            self.cache_name()
+        )
+        .into()
     }
 
     /// Human-readable file size
@@ -46,19 +51,18 @@ pub fn get_cdn_url() -> String {
     )
 }
 
-/// Get info from CDN
-pub async fn get_info() -> Result<Info, Box<dyn std::error::Error>> {
+/// Try each CDN host and set the first working one
+async fn find_working_host() -> Result<(), Box<dyn std::error::Error>> {
     for host in global::CDN_HOSTS {
         println!("Checking {}", host);
         utils::set_mutex(&global::CDN_HOST, host.to_owned());
 
         let url = format!("{}/info.json", get_cdn_url());
-
         match http::quick_request(&url).await {
             Ok(response) => match serde_json::from_str::<Info>(&response) {
-                Ok(info) => {
+                Ok(_) => {
                     println!("Successfully connected to {}", host);
-                    return Ok(info);
+                    return Ok(());
                 }
                 Err(e) => {
                     println!("Invalid JSON from {}: {}", host, e);
@@ -71,10 +75,30 @@ pub async fn get_info() -> Result<Info, Box<dyn std::error::Error>> {
             }
         }
     }
-
     Err("No CDN host is reachable or returned valid info".into())
 }
 
+/// Get info from CDN
+pub async fn get_info() -> Result<Info, Box<dyn std::error::Error>> {
+    async fn get_info_inner() -> Result<Info, Box<dyn std::error::Error>> {
+        if let Some(host) = utils::get_mutex_opt(&global::CDN_HOST) {
+            let url = format!("{}/info.json", get_cdn_url());
+            match http::quick_request(&url).await {
+                Ok(response) => match serde_json::from_str::<Info>(&response) {
+                    Ok(info) => return Ok(info),
+                    Err(e) => println!("Invalid JSON from {}: {}", host, e),
+                },
+                Err(e) => println!("Failed to get info from {}: {}", host, e),
+            }
+        }
+
+        find_working_host().await?;
+        Box::pin(get_info()).await
+    }
+
+    get_info_inner().await
+}
+
 /// Filter files by game
 pub fn filter_files(files: Vec<File>, game: crate::game::Game) -> Vec<File> {
     files

src/global.rs

@@ -10,18 +10,29 @@ pub const GITHUB_OWNER: &str = "mxve";
 /// The repository of the launcher
 pub const GITHUB_REPO: &str = "alterware-launcher";
 
+/// CDN hosts to iterate over
 pub const CDN_HOSTS: [&str; 2] = ["test.test", "cdn.getserve.rs"];
+
+/// CDN url procotol (http/https)
 pub static CDN_PROTOCOL: OnceCell<Mutex<String>> = OnceCell::new();
+
+/// CDN branch (sub dir)
 pub static CDN_BRANCH: OnceCell<Mutex<String>> = OnceCell::new();
+
+/// Chosen CDN host
 pub static CDN_HOST: OnceCell<Mutex<String>> = OnceCell::new();
 
+/// Game
 pub static GAME: OnceCell<Mutex<crate::game::Game>> = OnceCell::new();
+
+/// Game directory
 pub static GAME_DIR: OnceCell<Mutex<PathBuf>> = OnceCell::new();
+
+/// Game client
 pub static GAME_CLIENT: OnceCell<Mutex<Option<crate::game::Client>>> = OnceCell::new();
 
-// TODO: Make this configurable
 /// The path to the download cache
-pub const CACHE_DIR: &str = "awtmp";
+pub static CACHE_DIR: OnceCell<Mutex<PathBuf>> = OnceCell::new();
 
 /// User-agent for HTTP requests
 pub static USER_AGENT: Lazy<String> = Lazy::new(|| {

src/main.rs

@@ -60,6 +60,11 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         arg_path(&args, &["-p", "--path", "--game-path"])
             .unwrap_or(std::env::current_dir().unwrap()),
     );
+    utils::set_mutex(
+        &global::CACHE_DIR,
+        arg_path(&args, &["--cache"]).unwrap_or(utils::get_mutex(&global::GAME_DIR).join("awtmp")),
+    );
+    utils::set_mutex_opt(&global::CDN_HOST, arg_value(&args, &["--cdn"]));
 
     let client = args
         .iter()
@@ -68,30 +73,38 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     if let Some(client) = client {
         utils::set_mutex(&global::GAME_CLIENT, Some(client));
         utils::set_mutex(&global::GAME, client.game());
-    } else {
-        if let Some(game) = game::detect_game(&utils::get_mutex(&global::GAME_DIR)) {
-            utils::set_mutex(&global::GAME, game);
-            println!("Game: {:?}", game);
+    } else if let Some(game) = game::detect_game(&utils::get_mutex(&global::GAME_DIR)) {
+        utils::set_mutex(&global::GAME, game);
+        println!("Game: {:?}", game);
 
-            match game.clients().len() {
-                0 => {
-                    println!("No clients found for game");
-                    return Ok(());
-                }
-                1 => {
-                    utils::set_mutex(&global::GAME_CLIENT, Some(game.clients()[0]));
-                }
-                _ => {
-                    println!("Multiple clients found for game, please specify one");
-                    return Ok(());
-                }
+        match game.clients().len() {
+            0 => {
+                println!("No clients found for game");
+                return Ok(());
+            }
+            1 => {
+                utils::set_mutex(&global::GAME_CLIENT, Some(game.clients()[0]));
+            }
+            _ => {
+                println!("Multiple clients found for game, please specify one");
+                return Ok(());
             }
-        } else {
-            println!("No game detected");
-            return Ok(());
         }
+    } else {
+        println!("No game detected");
+        return Ok(());
     }
 
+    println!(
+        "Running with\nGame dir {}\nCache dir {}\nCDN host {}\nCDN protocol {}\nCDN branch {}\nGame {}",
+        utils::get_mutex(&global::GAME_DIR).display(),
+        utils::get_mutex(&global::CACHE_DIR).display(),
+        utils::get_mutex(&global::CDN_HOST),
+        utils::get_mutex(&global::CDN_PROTOCOL),
+        utils::get_mutex(&global::CDN_BRANCH),
+        utils::get_mutex(&global::GAME).name()
+    );
+
     let game = utils::get_mutex(&global::GAME);
     let clients = game.clients();
     println!("Clients: {:?}", clients);

src/utils.rs

@@ -11,10 +11,20 @@ pub fn set_mutex<T: Clone>(cell: &OnceCell<Mutex<T>>, value: T) {
     }
 }
 
+pub fn set_mutex_opt<T: Clone>(cell: &OnceCell<Mutex<T>>, value: Option<T>) {
+    if let Some(value) = value {
+        set_mutex(cell, value);
+    }
+}
+
 pub fn get_mutex<T: Clone>(cell: &OnceCell<Mutex<T>>) -> T {
     cell.get()
         .expect("Failed to get once cell value")
         .lock()
         .expect("Failed to lock mutex")
         .clone()
 }
+
+pub fn get_mutex_opt<T: Clone>(cell: &OnceCell<Mutex<T>>) -> Option<T> {
+    cell.get().map(|m| m.lock().unwrap().clone())
+}