fix: sub_domain '' => '/', like Github pages

timzaak · timzaak · commit 211cff001b7d · 2024-06-20T11:54:13.000+08:00
diff --git a/server/src/domain_storage.rs b/server/src/domain_storage.rs
@@ -407,7 +407,7 @@ impl DomainStorage {
             .filter_map(|version_entity| {
                 let version_entity = version_entity.ok()?;
                 let version = version_entity.file_name().to_str()?.parse::<u32>();
-                Some(version.ok()?)
+                version.ok()
             })
             .collect();
         if versions.is_empty() {
@@ -535,6 +535,21 @@ impl DomainStorage {
             Ok(Vec::new())
         }
     }
+    pub fn check_if_empty_index(&self, host:&str, path:&str) -> bool {
+        self.meta.get(host).map(|v| {
+            match v.value() {
+                DomainMeta::OneWeb{..} => path.is_empty(),
+                DomainMeta::MultipleWeb(map) => {
+                    if path.len() > 1 {
+                        map.contains_key(&path[1..])
+                    } else {
+                        map.contains_key(path)
+                    }
+                    
+                }
+            }
+        }).unwrap_or(false)
+    }
 
     pub fn save_file(
         &self,
diff --git a/server/src/file_cache.rs b/server/src/file_cache.rs
@@ -146,7 +146,7 @@ impl FileCache {
     ) -> anyhow::Result<HashMap<String, Arc<CacheItem>>> {
         let prefix = path
             .to_str()
-            .map(|x| Ok(format!("{}/", x.to_string())))
+            .map(|x| Ok(format!("{x}/")))
             .unwrap_or(Err(anyhow!("can not parse path")))?;
         tracing::info!("prepare to cache_dir: {}", &prefix);
         let conf = self.conf.get_domain_cache_config(domain);
@@ -233,7 +233,7 @@ impl FileCache {
                     .cloned();
                 if let Some(v) = index_opt {
                     result.insert(format!("{key_prefix}/"), v.clone());
-                    result.insert(key_prefix.to_string(), v);
+                    // result.insert(key_prefix.to_string(), v);
                 }
             }
             None => {
@@ -242,7 +242,7 @@ impl FileCache {
                     .or_else(|| result.get("index.htm"))
                     .cloned();
                 if let Some(v) = index_opt {
-                    result.insert("".to_string(), v.clone());
+                    // result.insert("".to_string(), v.clone());
                     result.insert("/".to_string(), v);
                 }
             }
diff --git a/server/src/service.rs b/server/src/service.rs
@@ -35,7 +35,8 @@ pub async fn create_service(
     domain_storage: Arc<DomainStorage>,
     is_https: bool,
 ) -> Result<Response<Body>, Infallible> {
-    let from_uri = req.uri().authority().cloned();
+    let uri = req.uri();
+    let from_uri = uri.authority().cloned();
     // trick, need more check
     let authority_opt = from_uri.or_else(|| {
         req.headers()
@@ -52,6 +53,7 @@ pub async fn create_service(
 
     if let Some(authority) = authority_opt {
         let host = authority.host();
+
         let service_config = service_config.get_domain_service_config(host);
         // cors
         let origin_opt = match resp_cors_request(req.method(), req.headers(), service_config.cors) {
@@ -67,15 +69,24 @@ pub async fn create_service(
                 } else {
                     format!(":{}", port)
                 };
-                let redirect_path = format!("https://{host}{port}{}", req.uri());
+                let redirect_path = format!("https://{host}{port}{}", uri);
                 resp.headers_mut()
                     .insert(LOCATION, redirect_path.parse().unwrap());
                 *resp.status_mut() = StatusCode::MOVED_PERMANENTLY;
                 return Ok(resp);
             }
         }
+        // path: "" => "/"
+        let path = uri.path();
+        if domain_storage.check_if_empty_index(host, path) {
+            let mut resp = Response::default();
+            resp.headers_mut()
+                .insert(LOCATION, format!("{path}/").parse().unwrap());
+            *resp.status_mut() = StatusCode::MOVED_PERMANENTLY;
+            return Ok(resp);
+        }
         // static file
-        let mut resp = match get_cache_file(req.uri().path(), host, domain_storage).await {
+        let mut resp = match get_cache_file(path, host, domain_storage).await {
             Ok(item) => {
                 let headers = req.headers();
                 let conditionals = Conditionals {
diff --git a/server/src/web_server.rs b/server/src/web_server.rs
@@ -72,8 +72,7 @@ impl Server {
                     http_redirect_to_https: domain
                         .https
                         .as_ref()
-                        .map(|x| x.http_redirect_to_https)
-                        .flatten()
+                        .and_then(|x| x.http_redirect_to_https)
                         .or(default_http_redirect_to_https),
                 };
 
diff --git a/tests/tests/common.rs b/tests/tests/common.rs
@@ -124,13 +124,20 @@ pub async fn assert_files(
             get_file_text(domain, version, file).unwrap()
         );
         if file.is_empty() {
-            println!("begin to check: {request_prefix}, version:{version}");
+            println!("begin to check: {request_prefix}/, version:{version}");
             let result = client.get(request_prefix).send().await.unwrap();
             assert_eq!(result.status(), StatusCode::OK);
             assert_eq!(
                 result.text().await.unwrap(),
                 get_file_text(domain, version, file).unwrap()
             );
+            println!("begin to check: {request_prefix}/, version:{version}");
+            let result = client.get(format!("{request_prefix}/")).send().await.unwrap();
+            assert_eq!(result.status(), StatusCode::OK);
+            assert_eq!(
+                result.text().await.unwrap(),
+                get_file_text(domain, version, file).unwrap()
+            );
         }
     }
 }
