add /_version

timzaak · timzaak · commit 0340afcfc13e · 2024-05-29T01:20:05.000+08:00
diff --git a/server/src/service.rs b/server/src/service.rs
@@ -1,19 +1,18 @@
+use crate::cors::{cors_resp, resp_cors_request, Validated};
+use crate::DomainStorage;
+use futures_util::future::Either;
+use headers::HeaderMapExt;
+use hyper::header::LOCATION;
+use hyper::http::uri::{Authority, Scheme};
+use hyper::{Body, Request, Response, StatusCode};
 use std::collections::HashMap;
 use std::convert::Infallible;
 use std::str::FromStr;
 use std::sync::Arc;
-use futures_util::future::Either;
-use headers::{HeaderMapExt};
-use hyper::{Body, Request, Response, StatusCode};
-use hyper::header::LOCATION;
-use hyper::http::uri::{Authority, Scheme};
 use warp::fs::Conditionals;
-use crate::cors::{cors_resp, resp_cors_request, Validated};
-use crate::DomainStorage;
 
 use crate::static_file_filter::{cache_or_file_reply, get_cache_file};
 
-
 pub struct ServiceConfig {
     pub default: DomainServiceConfig,
     pub inner: HashMap<String, DomainServiceConfig>,
@@ -30,24 +29,35 @@ impl ServiceConfig {
     }
 }
 
-
-pub async fn create_service(req: Request<Body>, service_config: Arc<ServiceConfig>, domain_storage: Arc<DomainStorage>) -> Result<Response<Body>, Infallible> {
+pub async fn create_service(
+    req: Request<Body>,
+    service_config: Arc<ServiceConfig>,
+    domain_storage: Arc<DomainStorage>,
+) -> Result<Response<Body>, Infallible> {
     let from_uri = req.uri().authority().cloned();
 
     // trick, need more check
-    let authority_opt = from_uri.or_else(|| req.headers().get("host").map(|value|
-        value.to_str().ok().map(|x| Authority::from_str(x).ok()).flatten()
-    ).flatten());
+    let authority_opt = from_uri.or_else(|| {
+        req.headers()
+            .get("host")
+            .map(|value| {
+                value
+                    .to_str()
+                    .ok()
+                    .map(|x| Authority::from_str(x).ok())
+                    .flatten()
+            })
+            .flatten()
+    });
 
     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) {
-                Either::Left(x) => Some(x),
-                Either::Right(v) => return Ok(v)
-            };
+        let origin_opt = match resp_cors_request(req.method(), req.headers(), service_config.cors) {
+            Either::Left(x) => Some(x),
+            Either::Right(v) => return Ok(v),
+        };
 
         let scheme = req.uri().scheme();
         // redirect to https
@@ -58,8 +68,20 @@ pub async fn create_service(req: Request<Body>, service_config: Arc<ServiceConfi
             *resp.status_mut() = StatusCode::MOVED_PERMANENTLY;
             return Ok(resp);
         }
-        // static file
+        // get version
 
+        if req.uri().path() == "/_version" {
+            let version = domain_storage
+                .get_domain_info_by_domain(host)
+                .map(|info| info.current_version)
+                .flatten()
+                .unwrap_or(0)
+                .to_string();
+            let resp = Body::from(version);
+            let resp = Response::new(resp);
+            return Ok(resp);
+        }
+        // static file
         let mut resp = match get_cache_file(req.uri().path(), host, domain_storage).await {
             Ok(item) => {
                 let headers = req.headers();
@@ -69,14 +91,17 @@ pub async fn create_service(req: Request<Body>, service_config: Arc<ServiceConfi
                     if_range: headers.typed_get(),
                     range: headers.typed_get(),
                 };
-                let accept_encoding = headers.get("accept-encoding").map(|x| x.to_str().map(|x| x.to_string()).ok()).flatten();
+                let accept_encoding = headers
+                    .get("accept-encoding")
+                    .map(|x| x.to_str().map(|x| x.to_string()).ok())
+                    .flatten();
                 cache_or_file_reply(item, conditionals, accept_encoding).await
             }
-            Err(resp) => Ok(resp)
+            Err(resp) => Ok(resp),
         };
 
         if let Some(Validated::Simple(origin)) = origin_opt {
-            resp = resp.map(|r|cors_resp(r, origin));
+            resp = resp.map(|r| cors_resp(r, origin));
         }
         resp
     } else {
@@ -86,7 +111,6 @@ pub async fn create_service(req: Request<Body>, service_config: Arc<ServiceConfi
     }
 }
 
-
 pub fn not_found() -> Response<Body> {
     let mut resp = Response::default();
     *resp.status_mut() = StatusCode::NOT_FOUND;
@@ -97,4 +121,4 @@ pub fn resp(code: StatusCode, str: &'static str) -> Response<Body> {
     let mut resp = Response::new(Body::from(str));
     *resp.status_mut() = code;
     resp
-}
+}
