Merge pull request #79 from hubertshelley/fix/session_err

fix: session异常修复

Author: hubertshelley

silent/Cargo.toml

@@ -18,7 +18,7 @@ version.workspace = true
 default = ["server", "test", ]
 full = ["admin", "server", "multipart", "upgrade", "sse", "security", "static", "session", "cookie", "template", "test", "scheduler", "grpc"]
 admin = ["server", "sse", "template", "session"]
-server = ["tokio/net", "tokio/rt-multi-thread", "tokio/signal"]
+server = ["tokio/fs", "tokio/net", "tokio/rt-multi-thread", "tokio/signal"]
 upgrade = ["dep:tokio-tungstenite"]
 multipart = ["tokio/fs", "dep:multer", "dep:multimap", "dep:tempfile", "dep:textnonce"]
 sse = ["dep:pin-project", "dep:tokio-stream"]

silent/src/core/socket_addr.rs

@@ -1,17 +1,26 @@
-use std::fmt::{Display, Formatter};
+use std::fmt::{Debug, Display, Formatter};
 use std::str::FromStr;
 
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub enum SocketAddr {
     TcpSocketAddr(std::net::SocketAddr),
     UnixSocketAddr(std::os::unix::net::SocketAddr),
 }
 
+impl Debug for SocketAddr {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            SocketAddr::TcpSocketAddr(addr) => write!(f, "http://{}", addr),
+            SocketAddr::UnixSocketAddr(addr) => write!(f, "UnixSocketAddr({:?})", addr),
+        }
+    }
+}
+
 impl Display for SocketAddr {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
             #[allow(clippy::write_literal)]
-            SocketAddr::TcpSocketAddr(addr) => write!(f, "http{}//{:?}", ':', addr),
+            SocketAddr::TcpSocketAddr(addr) => write!(f, "{}", addr),
             SocketAddr::UnixSocketAddr(addr) => {
                 write!(f, "{:?}", addr.as_pathname())
             }
@@ -57,7 +66,7 @@ mod tests {
     fn test_socket_addr() {
         let addr = std::net::SocketAddr::from(([127, 0, 0, 1], 8080));
         let socket_addr = SocketAddr::from(addr);
-        assert_eq!(format!("{}", socket_addr), "http://127.0.0.1:8080");
+        assert_eq!(format!("{}", socket_addr), "127.0.0.1:8080");
 
         let _ = std::fs::remove_file("/tmp/sock");
         let addr = std::os::unix::net::SocketAddr::from_pathname("/tmp/sock").unwrap();

silent/src/route/root.rs

@@ -72,9 +72,6 @@ impl RootRoute {
     pub(crate) fn hook_first(&mut self, handler: impl MiddleWareHandler + 'static) {
         let handler = Arc::new(handler);
         self.middlewares.insert(0, handler.clone());
-        self.children
-            .iter_mut()
-            .for_each(|r| r.middleware_hook_first(handler.clone()));
     }
 
     pub(crate) fn set_configs(&mut self, configs: Option<Configs>) {

silent/src/session/middleware.rs

@@ -1,6 +1,4 @@
-use crate::{
-    CookieExt, Handler, MiddleWareHandler, Next, Request, Response, SilentError, StatusCode,
-};
+use crate::{CookieExt, Handler, MiddleWareHandler, Next, Request, Response};
 use async_session::{MemoryStore, Session, SessionStore};
 use async_trait::async_trait;
 use cookie::{Cookie, CookieJar};
@@ -41,25 +39,23 @@ where
         let cookie = cookies.get("silent-web-session");
         let session_store = self.session_store.read().await;
         let mut session_key_exists = false;
-        let cookie_value = if cookie.is_some() {
+        let mut cookie_value = if cookie.is_some() {
             session_key_exists = true;
             cookie.unwrap().value().to_string()
         } else {
             session_store.store_session(Session::new()).await?.unwrap()
         };
-        let session = session_store
-            .load_session(cookie_value.clone())
-            .await
-            .map_err(|e| {
-                SilentError::business_error(
-                    StatusCode::INTERNAL_SERVER_ERROR,
-                    format!("Failed to load session: {}", e),
-                )
-            })?
-            .ok_or(SilentError::business_error(
-                StatusCode::INTERNAL_SERVER_ERROR,
-                "Failed to load session",
-            ))?;
+        let session =
+            if let Ok(Some(session)) = session_store.load_session(cookie_value.clone()).await {
+                session
+            } else {
+                session_key_exists = false;
+                cookie_value = session_store.store_session(Session::new()).await?.unwrap();
+                session_store
+                    .load_session(cookie_value.clone())
+                    .await?
+                    .unwrap()
+            };
         req.extensions_mut().insert(session.clone());
         let session_copied = session.clone();
         if !session_key_exists {