Use tempfile instead of hardcode name

Author: spencerwooo

Cargo.lock

@@ -31,3 +31,4 @@ tokio = { version = "1.44", features = ["full"] }
 truncatable = "0.1"
 anyhow = "1.0"
 base64 = "0.22"
+tempfile = "3.18"

Cargo.toml

@@ -129,11 +129,10 @@ impl Config {
 /// * If config file does not exist, creates default config file to path and returns error.
 /// * If found, tries to parse the file and returns error if parse fails or fields found undefined.
 pub fn parse_config(path: &str) -> Result<Config> {
-    // Create `~/.config` directory if not exists
-    create_parent_dir(path)?;
-
     // Create mihoro default config if not exists
     let config_path = Path::new(path);
+    create_parent_dir(config_path)?;
+
     if !config_path.exists() {
         Config::new().write(config_path)?;
         bail!(

src/config.rs

@@ -8,12 +8,14 @@ use crate::utils::{
 
 use std::fs;
 use std::os::unix::prelude::PermissionsExt;
+use std::path::Path;
 
 use anyhow::{anyhow, Result};
 use colored::Colorize;
 use local_ip_address::local_ip;
 use reqwest::Client;
 use shellexpand::tilde;
+use tempfile::NamedTempFile;
 
 #[derive(Debug)]
 pub struct Mihoro {
@@ -31,7 +33,7 @@ pub struct Mihoro {
 impl Mihoro {
     pub fn new(config_path: &String) -> Result<Mihoro> {
         let config = parse_config(tilde(&config_path).as_ref())?;
-        return Ok(Mihoro {
+        Ok(Mihoro {
             prefix: String::from("mihoro:"),
             config: config.clone(),
             mihomo_target_binary_path: tilde(&config.mihomo_binary_path).to_string(),
@@ -43,7 +45,7 @@ impl Mihoro {
                 config.user_systemd_root
             ))
             .to_string(),
-        });
+        })
     }
 
     pub async fn setup(&self, client: Client, overwrite_binary: bool) -> Result<()> {
@@ -69,20 +71,15 @@ impl Mihoro {
                 );
             }
 
+            // Create a temporary file for downloading
+            let temp_file = NamedTempFile::new()?;
+            let temp_path = temp_file.path();
+
             // Download mihomo binary and set permission to executable
-            download_file(
-                &client,
-                &self.config.remote_mihomo_binary_url,
-                "mihomo-downloaded-binary.tar.gz",
-            )
-            .await?;
+            download_file(&client, &self.config.remote_mihomo_binary_url, temp_path).await?;
 
             // Try to extract the binary, handle "Text file busy" error if overwriting
-            match extract_gzip(
-                "mihomo-downloaded-binary.tar.gz",
-                &self.mihomo_target_binary_path,
-                &self.prefix,
-            ) {
+            match extract_gzip(temp_path, &self.mihomo_target_binary_path, &self.prefix) {
                 Ok(_) => {
                     // Set executable permission
                     let executable = fs::Permissions::from_mode(0o755);
@@ -103,7 +100,7 @@ impl Mihoro {
         download_file(
             &client,
             &self.config.remote_config_url,
-            &self.mihomo_target_config_path,
+            Path::new(&self.mihomo_target_config_path),
         )
         .await?;
 
@@ -133,7 +130,7 @@ impl Mihoro {
         download_file(
             &client,
             &self.config.remote_config_url,
-            &self.mihomo_target_config_path,
+            Path::new(&self.mihomo_target_config_path),
         )
         .await?;
 
@@ -160,20 +157,20 @@ impl Mihoro {
                 download_file(
                     &client,
                     &geox_url.geoip,
-                    format!("{}/geoip.dat", &self.mihomo_target_config_root).as_str(),
+                    &Path::new(&self.mihomo_target_config_root).join("geoip.dat"),
                 )
                 .await?;
                 download_file(
                     &client,
                     &geox_url.geosite,
-                    format!("{}/geosite.dat", &self.mihomo_target_config_root).as_str(),
+                    &Path::new(&self.mihomo_target_config_root).join("geosite.dat"),
                 )
                 .await?;
             } else {
                 download_file(
                     &client,
                     &geox_url.mmdb,
-                    format!("{}/country.mmdb", &self.mihomo_target_config_root).as_str(),
+                    &Path::new(&self.mihomo_target_config_root).join("country.mmdb"),
                 )
                 .await?;
             }
@@ -312,7 +309,7 @@ WantedBy=default.target",
     );
 
     // Create mihomo service directory if not exists
-    create_parent_dir(mihomo_service_path)?;
+    create_parent_dir(Path::new(mihomo_service_path))?;
 
     // Write mihomo.service contents to file
     fs::write(mihomo_service_path, service)?;

src/mihoro.rs

@@ -19,10 +19,14 @@ use truncatable::Truncatable;
 /// # Arguments
 ///
 /// * `path` - A string slice that holds the path for which the parent directory should be created.
-pub fn create_parent_dir(path: &str) -> Result<()> {
-    let parent_dir = Path::new(path)
-        .parent()
-        .with_context(|| format!("parent directory of `{}` invalid", path))?;
+pub fn create_parent_dir(path: &Path) -> Result<()> {
+    // let parent_dir = Path::new(path)
+    let parent_dir = path.parent().with_context(|| {
+        format!(
+            "parent directory of `{}` invalid",
+            path.to_string_lossy()
+        )
+    })?;
     if !parent_dir.exists() {
         fs::create_dir_all(parent_dir)?;
     }
@@ -40,7 +44,7 @@ pub fn create_parent_dir(path: &str) -> Result<()> {
 ///
 /// Note: Allow `clippy::unused_io_amount` because we are writing downloaded chunks on the fly.
 #[allow(clippy::unused_io_amount)]
-pub async fn download_file(client: &Client, url: &str, path: &str) -> Result<()> {
+pub async fn download_file(client: &Client, url: &str, path: &Path) -> Result<()> {
     // Create parent directory for download destination if not exists
     create_parent_dir(path)?;
 
@@ -97,7 +101,10 @@ pub async fn download_file(client: &Client, url: &str, path: &str) -> Result<()>
         }
     }
 
-    pb.finish_with_message(format!("Downloaded to {}", path.underline()));
+    pb.finish_with_message(format!(
+        "Downloaded to {}",
+        path.to_str().unwrap().underline()
+    ));
     Ok(())
 }
 
@@ -111,19 +118,19 @@ pub fn delete_file(path: &str, prefix: &str) -> Result<()> {
     Ok(())
 }
 
-pub fn extract_gzip(gzip_path: &str, filename: &str, prefix: &str) -> Result<()> {
+pub fn extract_gzip(from_path: &Path, to_path: &str, prefix: &str) -> Result<()> {
     // Create parent directory for extraction dest if not exists
-    create_parent_dir(filename)?;
+    create_parent_dir(Path::new(to_path))?;
 
     // Extract gzip file
-    let mut archive = GzDecoder::new(fs::File::open(gzip_path)?);
-    let mut file = fs::File::create(filename)?;
+    let mut archive = GzDecoder::new(File::open(from_path)?);
+    let mut file = File::create(to_path)?;
     io::copy(&mut archive, &mut file)?;
-    fs::remove_file(gzip_path)?;
+    // fs::remove_file(gzip_path)?;
     println!(
         "{} Extracted to {}",
         prefix.green(),
-        filename.underline().yellow()
+        to_path.underline().yellow()
     );
     Ok(())
 }