Ignore "System Volume Information" folder when detecting empty disks

Author: zeld

src/disk.rs

@@ -1,95 +1,225 @@
-use std::env::current_dir;
-use std::fs;
+use std::path::Path;
+use std::vec::Vec;
 
-use sysinfo::{Disk, Disks};
+use futures::future::try_join_all;
 
-use console::Style;
-use indicatif::DecimalBytes;
+use anyhow::{Context, Error, Result, anyhow};
+
+use clap::{Arg, ArgAction, Command, crate_version};
 
 use log::debug;
 
-// Print disks list as a table
-pub fn print_disks() {
-    println!(
-        "{0: ^20} | {1: ^30} | {2: ^6} | {3: ^9} | {4: ^10} | {5: ^5} ",
-        "Name", "Location", "Type", "Removable", "Avail.", "Empty"
-    );
-    let red = Style::new().red();
-    let green = Style::new().green();
-    let disks = Disks::new_with_refreshed_list();
-    for disk in &disks {
-        let disk_removable = if disk.is_removable() {
-            green.apply_to("Yes")
-        } else {
-            red.apply_to("No")
-        };
-        let file_system_str = disk.file_system().to_string_lossy();
-        let file_system = if file_system_str.eq_ignore_ascii_case("vfat")
-            || file_system_str.eq_ignore_ascii_case("fat32")
-        {
-            green.apply_to(file_system_str)
-        } else {
-            red.apply_to(file_system_str)
-        };
-
-        let empty = if let Ok(files) = fs::read_dir(disk.mount_point()) {
-            if files.count() == 0 {
-                green.apply_to("Yes")
-            } else {
-                red.apply_to("No")
+use reqwest::Client;
+
+use indicatif::{DecimalBytes, MultiProgress};
+
+mod disk;
+mod download;
+mod interact;
+mod psa;
+
+#[tokio::main]
+async fn main() -> Result<(), Error> {
+    env_logger::init();
+
+    let mut map_info = "Sets the map to check for update. Supported maps:".to_string();
+    for map in psa::MAPS {
+        map_info = format!("{}\n - {}: {}", map_info, map.get_code(), map.get_name());
+    }
+
+    let matches = Command::new("PSA firmware update.")
+        .version(crate_version!())
+        .about("CLI alternative to Peugeot/Citroën/Opel/DS update applications for car infotainment system (NAC/RCC firmware and navigation maps), hopefully more robust. Supports for resume of downloads.")
+        .arg(Arg::new("VIN")
+            .help("Vehicle Identification Number (VIN) to check for update")
+            .required(false)
+            .index(1))
+        .arg(Arg::new("map")
+            .help(map_info)
+            .required(false)
+            .long("map")
+            .action(ArgAction::Set))
+        .arg(Arg::new("silent")
+            .help("Sets silent (non-interactive) mode")
+            .required(false)
+            .long("silent")
+            .action(ArgAction::SetTrue))
+        .arg(Arg::new("download")
+            .help("Automatically proceed with download of updates. Previous downloads will be resumed.")
+            .required(false)
+            .long("download")
+            .action(ArgAction::SetTrue))
+        .arg(Arg::new("extract")
+            .help("Location where to extract update files. Should be the root of an empty FAT32 USB drive.")
+            .required(false)
+            .long("extract")
+            .action(ArgAction::Set))
+        .arg(Arg::new("sequential-download")
+            .help("Forces sequential download of updates. By default updates are downloaded concurrently.")
+            .required(false)
+            .long("sequential-download")
+            .action(ArgAction::SetTrue))
+        .get_matches();
+
+    let interactive = !matches.get_flag("silent");
+    let vin = matches.get_one::<String>("VIN").map(|s| s.to_uppercase());
+    let vin_provided_as_arg = vin.is_some();
+    let map = matches.get_one::<String>("map").map(|s| s.as_str());
+    let download = matches.get_flag("download");
+    let sequential_download = matches.get_flag("sequential-download");
+    let extract_location = matches.get_one::<String>("extract").map(|s| s.as_str());
+
+    // Vin not provided on command line, asking interactively
+    let vin = if !vin_provided_as_arg && interactive {
+        interact::prompt("Please enter VIN").ok()
+    } else {
+        vin.map(|v| v.to_string())
+    };
+    if vin.is_none() {
+        return Err(anyhow!("No VIN provided"));
+    }
+    let vin = vin.unwrap();
+
+    let client = Client::builder()
+        // Dummy user agent to make cloudfront proxy happy when downloading firmware files
+        .user_agent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36")
+        .build()
+        .context("Failed to create HTTP client")?;
+    let device_info = psa::request_device_information(&client, &vin).await?;
+    let is_nac: bool = device_info
+        .devices
+        .map(|l| l.iter().any(|d| d.ecu_type.contains("NAC")))
+        == Some(true);
+
+    // Maps not provided on command line, asking interactively for NAC
+    let map = if map.is_none() && is_nac && interactive {
+        interact::select_map()?
+    } else {
+        map
+    };
+
+    let update_response = psa::request_available_updates(&client, &vin, map).await?;
+
+    if update_response.software.is_none() {
+        println!("No update found");
+        return Ok(());
+    }
+
+    let mut selected_updates: Vec<psa::SoftwareUpdate> = Vec::new();
+    let mut total_update_size = 0_u64;
+
+    let mut software_list: Vec<psa::Software> = update_response
+        .software
+        .expect("Expected at least a software in server response");
+
+    // For NAC, let's sort in reverse order of software type to display firmware (ovip) first, then map (map)
+    software_list.sort_by(|u1, u2| u2.software_type.cmp(&u1.software_type));
+
+    for software in software_list {
+        for update in &software.update {
+            // An empty update can be sent by the server when there is no available update
+            if !update.update_id.is_empty() {
+                psa::print(&software, update);
+                if download || (interactive && interact::confirm("Download update?")?) {
+                    selected_updates.push(update.clone());
+                    let update_size = match update.update_size.parse() {
+                        Ok(size) => size,
+                        Err(_) => {
+                            debug!("Failed to parse update size: {}", update.update_size);
+                            0
+                        }
+                    };
+                    total_update_size += update_size;
+                }
             }
-        } else {
-            red.apply_to("N/A")
-        };
-
-        println!(
-            "{0: <20} | {1: <30} | {2: <6} | {3: <9} | {4: >10} | {5: <5}",
-            disk.name().to_string_lossy(),
-            disk.mount_point().to_string_lossy(),
-            file_system,
-            disk_removable,
-            DecimalBytes(disk.available_space()).to_string(),
-            empty
-        );
+        }
     }
-}
 
-// Available disk space in current directory
-pub fn get_current_dir_available_space() -> Option<u64> {
-    let cwd_result = current_dir();
-    if cwd_result.is_err() {
-        debug!(
-            "Failed to retrieve information about current working directory: {}",
-            cwd_result.err().unwrap()
-        );
-        return None;
+    if selected_updates.is_empty() {
+        println!("No update selected for download");
+        return Ok(());
     }
-    let cwd = cwd_result.ok().unwrap();
-    let mut cwd_disk: Option<&Disk> = None;
-    // Lookup disk whose mount point is parent of cwd
-    // In case there are multiple candidates, pick up the "nearest" parent of cwd
-    let disks = Disks::new_with_refreshed_list();
-    for disk in &disks {
-        debug!("Disk {disk:?}");
-        if cwd.starts_with(disk.mount_point())
-            && (cwd_disk.is_none()
-                || disk
-                    .mount_point()
-                    .starts_with(cwd_disk.unwrap().mount_point()))
-        {
-            cwd_disk = Some(disk);
+
+    // Check available disk size
+    let disk_space = disk::get_current_dir_available_space();
+    if let Some(space) = disk_space
+        && space < total_update_size
+    {
+        interact::warn(&format!(
+            "Not enough space on disk to proceed with download. Available disk space in current directory: {}",
+            DecimalBytes(space)
+        ));
+        if interactive && !(interact::confirm("Continue anyway?")?) {
+            return Ok(());
         }
     }
-    if cwd_disk.is_none() {
-        debug!(
-            "Failed to retrieve disk information for current working directory: {}",
-            cwd.to_string_lossy()
-        );
-        return None;
+
+    let multi_progress = MultiProgress::new();
+
+    let downloaded_updates: Vec<psa::DownloadedUpdate> = if sequential_download {
+        // Download sequentially
+        let mut result: Vec<psa::DownloadedUpdate> = Vec::new();
+        for update in selected_updates {
+            result.push(psa::download_update(&client, &update, &multi_progress).await?);
+        }
+        result
+    } else {
+        // Download concurrently
+        let downloads = selected_updates
+            .iter()
+            .map(|update| psa::download_update(&client, update, &multi_progress));
+        try_join_all(downloads).await?
+    };
+
+    let mut extract_location = extract_location.map(str::to_string);
+    if interactive && extract_location.is_none() {
+        if !interact::confirm(
+            "To proceed to extraction of update(s), please insert an empty USB disk formatted as FAT32. Continue?",
+        )? {
+            return Ok(());
+        }
+
+        // Listing available disks for extraction
+        // TODO check destination available space.
+        disk::print_disks();
+        let location = interact::prompt(
+            "Location where to extract the update files (IMPORTANT: Should be the root of an EMPTY USB device formatted as FAT32)",
+        )?;
+        if !location.is_empty() {
+            extract_location = Some(location);
+        }
     }
-    debug!(
-        "Current working directory maps to disk {}",
-        cwd_disk.unwrap().name().to_string_lossy()
-    );
-    Some(cwd_disk.unwrap().available_space())
+
+    match extract_location {
+        Some(location) => {
+            let destination_path = Path::new(&location);
+            if !destination_path.is_dir() {
+                return Err(anyhow!(
+                    "Destination does not exist or is not a directory: {}",
+                    destination_path.to_string_lossy()
+                ));
+            }
+            for update in downloaded_updates {
+                psa::extract_update(&update, destination_path)
+                    .context("Failed to extract update")?;
+            }
+            println!(
+                "The update can be applied on the car infotainment system following vendor instructions."
+            );
+            if is_nac {
+                println!(
+                    "For example, for Peugeot NAC: https://web.archive.org/web/20220719220945/https://media-ct-ndp.peugeot.com/file/38/2/map-software-rcc-en.632382.pdf"
+                );
+            } else {
+                println!(
+                    "For example, for Peugeot RCC: https://web.archive.org/web/20230602131011/https://media-ct-ndp.peugeot.com/file/38/0/map-software-nac-en.632380.pdf"
+                );
+            }
+        }
+        None => {
+            println!("No location, skipping extraction");
+        }
+    }
+
+    Ok(())
 }