support 2024

timzaak · timzaak · commit e99c613d1f86 · 2025-12-02T22:27:33.000+08:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -9,14 +9,14 @@ members = [
 
 [workspace.package]
 authors = ["timzaak <zsy.evan@gmail.com>"]
-edition = "2021"
+edition = "2024"
 version = "3.0.0"
 
 [workspace.dependencies]
 anyhow = { version = "1.0" }
 bytes = "1"
 chrono = { version = "0.4" }
-clap = { version = "4.5"}
+clap = { version = "4.5" }
 console = "0.16"
 dashmap = "6.1"
 delay_timer = "0.11.6"
@@ -32,15 +32,15 @@ md-5 = "0.10"
 percent-encoding = "2.1"
 regex = "1.10"
 reqwest = { version = "0.12", default-features = false }
-serde = { version = "1.0"}
+serde = { version = "1.0" }
 serde_json = "1.0"
 serde_repr = "0.1"
 tokio = { version = "1.0" }
 toml = { version = "0.9.8" }
 toml_edit = "0.23.7"
 tracing = "0.1.21"
 tracing-core = "0.1.32"
-tracing-subscriber = { version = "0.3"}
+tracing-subscriber = { version = "0.3" }
 walkdir = "2.5"
 salvo = "0.85.0"
 dunce = "1"
diff --git a/client/src/api.rs b/client/src/api.rs
@@ -5,7 +5,7 @@ use entity::request::{
     GetDomainOption, UpdateUploadingStatusOption,
 };
 use entity::storage::{CertInfo, DomainInfo, ShortMetaData, UploadDomainPosition};
-use reqwest::{header, multipart, StatusCode};
+use reqwest::{StatusCode, header, multipart};
 use std::borrow::Cow;
 use std::path::PathBuf;
 
@@ -207,8 +207,8 @@ impl API {
 }
 #[cfg(test)]
 mod test {
-    use crate::api::API;
     use crate::LOCAL_HOST;
+    use crate::api::API;
     use entity::request::UpdateUploadingStatusOption;
     use entity::storage::UploadingStatus;
 
diff --git a/client/src/config.rs b/client/src/config.rs
@@ -72,14 +72,18 @@ pub(crate) mod test {
     use std::env;
 
     pub(crate) fn init_env() {
-        env::set_var("SPA_SERVER_ADDRESS", "http://127.0.0.1:9000");
-        env::set_var("SPA_SERVER_AUTH_TOKEN", "token");
-        env::set_var("SPA_UPLOAD_PARALLEL", "4");
+        unsafe {
+            env::set_var("SPA_SERVER_ADDRESS", "http://127.0.0.1:9000");
+            env::set_var("SPA_SERVER_AUTH_TOKEN", "token");
+            env::set_var("SPA_UPLOAD_PARALLEL", "4");
+        }
     }
     fn remove_env() {
-        env::remove_var("SPA_SERVER_ADDRESS");
-        env::remove_var("SPA_SERVER_AUTH_TOKEN");
-        env::remove_var("SPA_UPLOAD_PARALLEL");
+        unsafe {
+            env::remove_var("SPA_SERVER_ADDRESS");
+            env::remove_var("SPA_SERVER_AUTH_TOKEN");
+            env::remove_var("SPA_UPLOAD_PARALLEL");
+        }
     }
 
     pub(crate) fn default_local_config() -> anyhow::Result<Config> {
diff --git a/client/src/lib.rs b/client/src/lib.rs
@@ -70,14 +70,16 @@ const LOCAL_HOST: &str = "local.fornetcode.com";
 
 #[cfg(test)]
 mod test {
-    use crate::{run_with_commands, CliCommand, LOCAL_HOST};
+    use crate::{CliCommand, LOCAL_HOST, run_with_commands};
     use clap::Parser;
     use std::env;
 
     fn init_config() {
-        env::set_var("SPA_SERVER_ADDRESS", "http://127.0.0.1:9000");
-        env::set_var("SPA_SERVER_AUTH_TOKEN", "token");
-        env::set_var("SPA_UPLOAD_PARALLEL", "4");
+        unsafe {
+            env::set_var("SPA_SERVER_ADDRESS", "http://127.0.0.1:9000");
+            env::set_var("SPA_SERVER_AUTH_TOKEN", "token");
+            env::set_var("SPA_UPLOAD_PARALLEL", "4");
+        }
     }
 
     #[ignore]
diff --git a/client/src/upload_files.rs b/client/src/upload_files.rs
@@ -1,10 +1,10 @@
-use crate::{success, API};
+use crate::{API, success};
 use anyhow::anyhow;
 use console::style;
 use entity::request::UpdateUploadingStatusOption;
 use entity::storage::{GetDomainPositionStatus, ShortMetaData, UploadingStatus};
-use futures::future::Either;
 use futures::StreamExt;
+use futures::future::Either;
 use if_chain::if_chain;
 use md5::{Digest, Md5};
 use std::borrow::Cow;
@@ -13,8 +13,8 @@ use std::fs;
 use std::fs::File;
 use std::io::Read;
 use std::path::{Path, PathBuf};
-use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::time::Duration;
 use tracing::warn;
 use walkdir::WalkDir;
@@ -32,7 +32,9 @@ pub async fn upload_files(
         return Err(anyhow!("{:?} is not a directory", path));
     }
     let version = get_upload_version(&api, &domain, version).await?;
-    println!("begin to fetch server file metadata with md5, you may need to wait if there are large number of files.");
+    println!(
+        "begin to fetch server file metadata with md5, you may need to wait if there are large number of files."
+    );
     let server_metadata = api.get_file_metadata(&domain, version).await?;
     if !server_metadata.is_empty() {
         println!(
@@ -122,15 +124,15 @@ pub async fn upload_files(
     let process_count = Arc::new(AtomicU64::new(1));
     let upload_result = futures::stream::iter(uploading_files.into_iter().map(|(key, path)| {
         let key: Cow<'static, str> = key.into();
-        let r = retry_upload(
+
+        retry_upload(
             api.as_ref(),
             domain.clone(),
             str_version.clone(),
             key,
             path,
             process_count.clone(),
-        );
-        r
+        )
     }))
     .buffer_unordered(parallel as usize)
     .map(|result| match result {
diff --git a/server/src/admin_server.rs b/server/src/admin_server.rs
@@ -1,4 +1,4 @@
-use crate::config::{get_host_path_from_domain, AdminConfig};
+use crate::config::{AdminConfig, get_host_path_from_domain};
 use crate::domain_storage::DomainStorage;
 use delay_timer::prelude::*;
 use salvo::prelude::*;
@@ -128,16 +128,16 @@ pub mod service {
         let option = req.parse_queries::<GetDomainOption>();
         match storage.get_domain_info() {
             Ok(domain_info) => {
-                if let Ok(option) = option {
-                    if let Some(domain) = option.domain {
-                        if let Some(data) = domain_info.iter().find(|x| x.domain == domain) {
-                            res.render(Json(&[data]));
-                        } else {
-                            let data: Vec<&DomainInfo> = Vec::new();
-                            res.render(Json(data));
-                        }
-                        return;
+                if let Ok(option) = option
+                    && let Some(domain) = option.domain
+                {
+                    if let Some(data) = domain_info.iter().find(|x| x.domain == domain) {
+                        res.render(Json(&[data]));
+                    } else {
+                        let data: Vec<&DomainInfo> = Vec::new();
+                        res.render(Json(data));
                     }
+                    return;
                 }
                 res.render(Json(domain_info));
             }
diff --git a/server/src/config.rs b/server/src/config.rs
@@ -1,4 +1,4 @@
-use anyhow::{bail, Context};
+use anyhow::{Context, bail};
 use duration_str::deserialize_duration;
 use headers::{HeaderValue, Origin};
 use serde::{Deserialize, Deserializer};
diff --git a/server/src/domain_storage.rs b/server/src/domain_storage.rs
@@ -1,6 +1,6 @@
 use crate::config::get_host_path_from_domain;
 use crate::file_cache::{CacheItem, FileCache};
-use anyhow::{anyhow, bail, Context};
+use anyhow::{Context, anyhow, bail};
 use dashmap::DashMap;
 use entity::storage::{
     DomainInfo, GetDomainPositionStatus, ShortMetaData, UploadDomainPosition, UploadingStatus,
@@ -103,16 +103,16 @@ impl DomainStorage {
                                 }
                                 let path_buf = sub_dir.join(version.to_string());
                                 match domain_version.get_mut(domain_dir_name) {
-                                    Some(mut domain_meta) => {
-                                        match domain_meta.value_mut() {
-                                            DomainMeta::MultipleWeb(ref mut map) => {
-                                                map.insert(sub_path.clone(), (path_buf, version));
-                                            }
-                                            DomainMeta::OneWeb(..) => {
-                                                panic!("init failure, {sub_dir:?} should be multiple web");
-                                            }
+                                    Some(mut domain_meta) => match domain_meta.value_mut() {
+                                        DomainMeta::MultipleWeb(map) => {
+                                            map.insert(sub_path.clone(), (path_buf, version));
                                         }
-                                    }
+                                        DomainMeta::OneWeb(..) => {
+                                            panic!(
+                                                "init failure, {sub_dir:?} should be multiple web"
+                                            );
+                                        }
+                                    },
                                     None => {
                                         let map = DashMap::new();
                                         map.insert(sub_path.clone(), (path_buf, version));
@@ -833,7 +833,9 @@ mod test {
     fn test_domain_storage_get_domain_info() {
         //TODO: fix config path
         let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../test/config.test.conf");
-        env::set_var("SPA_CONFIG", path.display().to_string());
+        unsafe {
+            env::set_var("SPA_CONFIG", path.display().to_string());
+        }
         let mut config = Config::load().unwrap();
         config.file_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
             .join("../tests/web/data")
diff --git a/server/src/file_cache.rs b/server/src/file_cache.rs
@@ -98,26 +98,25 @@ impl FileCache {
             .into_iter()
             .filter_map(|x| x.ok())
             .filter_map(|entry| {
-                if let Ok(metadata) = entry.metadata() {
-                    if metadata.is_file() {
-                        if let Ok(key) = entry.path().strip_prefix(&parent) {
-                            let key = key
-                                .components()
-                                .map(|c| c.as_os_str().to_string_lossy())
-                                .collect::<Vec<_>>()
-                                .join("/");
-                            let key = sub_path
-                                .map(|sub_path| format!("{sub_path}/{key}"))
-                                .unwrap_or(key);
-                            return Some((
-                                key,
-                                Arc::new(CacheItem {
-                                    data: entry.path().to_path_buf(),
-                                    version,
-                                }),
-                            ));
-                        }
-                    }
+                if let Ok(metadata) = entry.metadata()
+                    && metadata.is_file()
+                    && let Ok(key) = entry.path().strip_prefix(&parent)
+                {
+                    let key = key
+                        .components()
+                        .map(|c| c.as_os_str().to_string_lossy())
+                        .collect::<Vec<_>>()
+                        .join("/");
+                    let key = sub_path
+                        .map(|sub_path| format!("{sub_path}/{key}"))
+                        .unwrap_or(key);
+                    return Some((
+                        key,
+                        Arc::new(CacheItem {
+                            data: entry.path().to_path_buf(),
+                            version,
+                        }),
+                    ));
                 }
                 None
             })
diff --git a/server/src/service.rs b/server/src/service.rs
@@ -1,4 +1,4 @@
-use crate::config::{extract_origin, Config};
+use crate::config::{Config, extract_origin};
 use headers::HeaderValue;
 use hyper::StatusCode;
 use salvo::Response;
diff --git a/server/src/web_server.rs b/server/src/web_server.rs
@@ -99,23 +99,21 @@ async fn file_resp(req: &mut Request, depot: &mut Depot, res: &mut Response, _ct
                 if !original_path.is_empty() && original_path != "/" {
                     let ends_with_slash = original_path.ends_with('/');
 
-                    if !ends_with_slash {
-                        if let Ok(new_uri) =
+                    if !ends_with_slash
+                        && let Ok(new_uri) =
                             replace_uri_path(req.uri(), &format!("{original_path}/"))
-                        {
-                            res.body(ResBody::None);
-
-                            match Redirect::with_status_code(StatusCode::MOVED_PERMANENTLY, new_uri)
-                            {
-                                Ok(redirect) => {
-                                    res.render(redirect);
-                                }
-                                Err(e) => {
-                                    tracing::error!(error = ?e, "redirect failed");
-                                }
+                    {
+                        res.body(ResBody::None);
+
+                        match Redirect::with_status_code(StatusCode::MOVED_PERMANENTLY, new_uri) {
+                            Ok(redirect) => {
+                                res.render(redirect);
+                            }
+                            Err(e) => {
+                                tracing::error!(error = ?e, "redirect failed");
                             }
-                            return;
                         }
+                        return;
                     }
                 }
                 res.status_code(StatusCode::NOT_FOUND);
diff --git a/tests/src/main.rs b/tests/src/main.rs
@@ -1,30 +1,7 @@
 use anyhow::Result;
-use std::env;
-use std::path::PathBuf;
-use tracing::Level;
-use tracing_subscriber::EnvFilter;
 
-//This does not work because of file_dir config.
 #[tokio::main]
 async fn main() -> Result<()> {
-    env::set_var(
-        "SPA_CONFIG",
-        get_test_dir()
-            .join("server_config.toml")
-            .display()
-            .to_string(),
-    );
-
-    tracing_subscriber::fmt()
-        .with_env_filter(
-            EnvFilter::builder()
-                .with_default_directive(Level::DEBUG.into())
-                .from_env_lossy(),
-        )
-        .init();
-    spa_server::run_server().await
-}
-
-pub fn get_test_dir() -> PathBuf {
-    env::current_dir().unwrap().join("tests").join("data")
+    println!("Hello, world!");
+    Ok(())
 }
diff --git a/tests/tests/common.rs b/tests/tests/common.rs
@@ -52,10 +52,12 @@ fn get_tls_config() -> ClientConfig {
  */
 
 pub fn run_server_with_config(config_file_name: &str) -> JoinHandle<()> {
-    env::set_var(
-        "SPA_CONFIG",
-        get_test_dir().join(config_file_name).display().to_string(),
-    );
+    unsafe {
+        env::set_var(
+            "SPA_CONFIG",
+            get_test_dir().join(config_file_name).display().to_string(),
+        );
+    }
     /*
     let provider = TracerProvider::builder()
         .with_simple_exporter(SpanExporter::default())

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use anyhow::{bail, Context};`
	`1`	`+use anyhow::{Context, bail};`
`2`	`2`	`use duration_str::deserialize_duration;`
`3`	`3`	`use headers::{HeaderValue, Origin};`
`4`	`4`	`use serde::{Deserialize, Deserializer};`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use crate::config::{extract_origin, Config};`
	`1`	`+use crate::config::{Config, extract_origin};`
`2`	`2`	`use headers::HeaderValue;`
`3`	`3`	`use hyper::StatusCode;`
`4`	`4`	`use salvo::Response;`