fix bugs

Author: timzaak

Cargo.lock

@@ -43,4 +43,5 @@ tracing-core = "0.1.32"
 tracing-subscriber = { version = "0.3"}
 walkdir = "2.5"
 warp = "0.4.2"
-salvo = "0.85.0"
+salvo = "0.85.0"
+dunce = "1"

Cargo.toml

@@ -48,4 +48,5 @@ md-5 = { workspace = true }
 # util
 anyhow = { workspace = true, features = ["backtrace"] }
 walkdir = { workspace = true }
-if_chain = { workspace = true }
+if_chain = { workspace = true }
+dunce = { workspace = true }

client/Cargo.toml

@@ -107,11 +107,6 @@ impl API {
         string_resp!(resp)
     }
 
-    pub async fn reload_spa_server(&self) -> anyhow::Result<()> {
-        let resp = self.async_client.post(self.url("reload")).send().await?;
-        handle!(resp)
-    }
-
     pub async fn remove_files(
         &self,
         domain: Option<String>,

client/src/api.rs

@@ -20,7 +20,6 @@ pub enum Commands {
         domain: String,
         version: Option<u32>,
     },
-    Reload,
     Delete {
         domain: Option<String>,
         max_reserve: Option<u32>,

client/src/commands.rs

@@ -51,10 +51,6 @@ async fn run_with_commands(commands: CliCommand) -> anyhow::Result<()> {
             let resp = api.release_domain_version(domain, version).await?;
             success(&resp);
         }
-        Commands::Reload => {
-            api.reload_spa_server().await?;
-            success("reload success!");
-        }
         Commands::Delete {
             domain,
             max_reserve,

client/src/lib.rs

@@ -31,11 +31,6 @@ pub async fn upload_files(
     if !path.is_dir() {
         return Err(anyhow!("{:?} is not a directory", path));
     }
-
-    let prefix_path = path
-        .to_str()
-        .ok_or_else(|| anyhow!("upload path can not parse"))?
-        .to_string();
     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.");
     let server_metadata = api.get_file_metadata(&domain, version).await?;
@@ -53,6 +48,7 @@ pub async fn upload_files(
         .collect::<HashMap<String, ShortMetaData>>();
 
     let mut byte_buffer = vec![0u8; 1024 * 1024];
+    let parent = path.clone();
     let uploading_files = WalkDir::new(path)
         .min_depth(1)
         .into_iter()
@@ -61,10 +57,11 @@ pub async fn upload_files(
                 if let Some(entity) = entity.ok();
                 if let Some(metadata) = entity.metadata().ok();
                 if metadata.is_file();
-                if let Some(path) = entity.path().to_str().map(|x|x.to_string());
+                if let Ok(key) = entity.path().strip_prefix(&parent);
                 then {
-                    let prefix = format!("{prefix_path}/");
-                    let key = path.replace(&prefix,"");
+                    let key = key.components().map(|c| c.as_os_str().to_string_lossy())
+                    .collect::<Vec<_>>()
+                    .join("/");
                     if server_metadata.get(&key).filter(|x|{
                         let md5 = md5_file(entity.path(), &mut byte_buffer);
                         x.length == metadata.len() &&

client/src/upload_files.rs

@@ -333,7 +333,7 @@ impl DomainStorage {
             let data = self.cache.cache_dir(host, path, version, &new_path)?;
             self.cache.update(host.to_string(), path, version, data);
             debug!(
-                "domain: {host} all keys:{:?}",
+                "domain: {host} sub_path: {path:?} all keys:{:?}",
                 self.cache.get_all_keys(host)
             );
             info!(

server/src/domain_storage.rs

@@ -90,36 +90,31 @@ impl FileCache {
         version: u32,
         path: &PathBuf,
     ) -> anyhow::Result<HashMap<String, Arc<CacheItem>>> {
-        let prefix = path
+        let _ = path
             .to_str()
             .map(|x| Ok(format!("{x}/")))
             .unwrap_or(Err(anyhow!("can not parse path")))?;
+        let parent = path.clone();
         let mut result: HashMap<String, Arc<CacheItem>> = WalkDir::new(path)
             .min_depth(1)
             .into_iter()
             .filter_map(|x| x.ok())
             .filter_map(|entry| {
                 if let Ok(metadata) = entry.metadata() {
                     if metadata.is_file() {
-                        let path = entry.path();
-                        let file = File::open(path).ok()?;
-                        let mut reader = BufReader::new(file);
-                        let mut bytes: Vec<u8> = vec![];
-                        reader.read_to_end(&mut bytes).ok()?;
-                        let entry_path = entry.into_path();
-                        return entry_path.clone().to_str().map(|x| {
-                            let key = x.replace(&prefix, "");
+                        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);
-                            (
-                                key,
-                                Arc::new(CacheItem {
-                                    data: entry_path,
-                                    version,
-                                }),
-                            )
-                        });
+                            return Some((key , Arc::new(CacheItem {
+                                data: entry.path().to_path_buf(),
+                                version,
+                            })))
+                        }
                     }
                 }
                 None

server/src/file_cache.rs

@@ -1,12 +1,14 @@
+use std::borrow::Cow;
 use crate::config::Config;
 use crate::domain_storage::DomainStorage;
 use crate::service::ServiceConfig;
 use salvo::fs::NamedFile;
 use salvo::http::header::LOCATION;
-use salvo::http::uri::{Authority, Uri};
+use salvo::http::uri::{Authority, PathAndQuery, Uri};
 use salvo::prelude::*;
 use std::str::FromStr;
 use std::sync::Arc;
+use salvo::http::{ParseError, ResBody};
 
 #[inline]
 pub(crate) fn decode_url_path_safely(path: &str) -> String {
@@ -60,11 +62,26 @@ fn alias_redirect(uri: &Uri, https: bool, host: &str, external_port: u16, res: &
     res.status_code(StatusCode::MOVED_PERMANENTLY);
 }
 
+fn replace_uri_path(original_uri: &Uri, new_path: &str) -> Result<Uri, ParseError> {
+    let mut uri_parts = original_uri.clone().into_parts();
+    uri_parts.authority = None;
+    uri_parts.scheme = None;
+    let path = match original_uri.query() {
+        Some(query) => Cow::from(format!("{new_path}?{query}")),
+        None => Cow::from(new_path),
+    };
+
+    uri_parts.path_and_query = Some(PathAndQuery::from_str(path.as_ref())?);
+    Ok(Uri::from_parts(uri_parts)?)
+}
+
+
 #[handler]
 async fn file_resp(req: &mut Request, depot: &mut Depot, res: &mut Response, _ctrl: &mut FlowCtrl) {
+
     let domain_storage = depot.obtain::<Arc<DomainStorage>>().unwrap();
     let service_config = depot.obtain::<Arc<ServiceConfig>>().unwrap();
-    let config = depot.obtain::<Arc<Config>>().unwrap();
+    // let config = depot.obtain::<Arc<Config>>().unwrap();
 
     let author_opt = get_authority(req);
     if let Some(author) = author_opt {
@@ -96,13 +113,37 @@ async fn file_resp(req: &mut Request, depot: &mut Depot, res: &mut Response, _ct
             &*decode_url_path_safely(req_path)
         };
         let rel_path = format_url_path_safely(rel_path);
+        tracing::debug!("hit {rel_path}");
         match domain_storage.get_file(host, &rel_path) {
             Some(item) => {
                 NamedFile::builder(&item.data)
                     .send(req.headers(), res)
                     .await;
             }
             None => {
+                // trailing slash
+                let original_path = req.uri().path();
+                if !original_path.is_empty() && original_path != "/" {
+                    let ends_with_slash = original_path.ends_with('/');
+
+                    if !ends_with_slash {
+                        if 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");
+                                }
+                            }
+                            return
+                        }
+
+                    }
+                }
+
                 res.status_code(StatusCode::NOT_FOUND);
             }
         }
@@ -122,13 +163,11 @@ pub async fn init_http_server(
         .await;
 
     // StaticDir::new();
-    let router = Router::with_hoop(trailing_slash::add_slash())
-        .hoop(
+    let router = Router::with_hoop(
             affix_state::inject(service_config.clone())
                 .inject(storage.clone())
                 .inject(conf.clone()),
-        )
-        .path("{*path}")
+        ).path("{*path}")
         .get(file_resp);
 
     Server::new(listener).serve(router).await;