feat: v17.3.6

Author: eastspire

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hyperlane"
-version = "17.3.5"
+version = "17.3.6"
 readme = "README.md"
 edition = "2024"
 authors = ["root@ltpp.vip"]

src/server/impl.rs

@@ -438,7 +438,7 @@ impl Server {
     ///
     /// # Arguments
     ///
-    /// - `H: AsRef<str>` - The host address.
+    /// - `AsRef<str>` - The host address.
     /// - `u16` - The port number.
     ///
     /// # Returns
@@ -577,50 +577,79 @@ impl Server {
         };
     }
 
-    /// Creates and binds a `TcpListener` based on the server's configuration.
+    /// Configures socket options for a newly accepted `TcpStream`.
     ///
-    /// # Returns
+    /// This applies settings like `TCP_NODELAY`, and `IP_TTL` from the server's configuration.
     ///
-    /// - `Result<TcpListener, ServerError>` - A `Result` containing the bound `TcpListener` on success,
-    ///   or a `ServerError` on failure.
-    async fn create_tcp_listener(&self) -> Result<TcpListener, ServerError> {
-        Ok(TcpListener::bind(self.get_server_config().get_address()).await?)
+    /// # Arguments
+    ///
+    /// - `&TcpStream` - A reference to the `TcpStream` to configure.
+    async fn configure_stream(&self, stream: &TcpStream) {
+        let config: ServerConfig = self.get_server_config().clone();
+        if let Some(nodelay) = config.try_get_nodelay() {
+            let _ = stream.set_nodelay(*nodelay);
+        }
+        if let Some(ttl) = config.try_get_ttl() {
+            let _ = stream.set_ttl(*ttl);
+        }
     }
 
-    /// Enters a loop to accept incoming TCP connections and spawn handlers for them.
+    /// Executes trait-based request middleware in sequence.
     ///
     /// # Arguments
     ///
-    /// - `&TcpListener` - A reference to the `TcpListener` to accept connections from.
+    /// - `&mut Context` - The request context.
     ///
     /// # Returns
     ///
-    /// - `Result<(), ServerError>` - A `Result` which is typically `Ok(())` unless an unrecoverable
-    ///   error occurs.
-    async fn accept_connections(&self, tcp_listener: &TcpListener) -> Result<(), ServerError> {
-        while let Ok((stream, _)) = tcp_listener.accept().await {
-            self.configure_stream(&stream).await;
-            let stream: ArcRwLockStream = ArcRwLockStream::from_stream(stream);
-            self.spawn_connection_handler(stream).await;
+    /// - `bool` - `true` if the lifecycle was aborted, `false` otherwise.
+    pub(super) async fn handle_request_middleware(&self, ctx: &mut Context) -> bool {
+        for hook in self.get_request_middleware().iter() {
+            self.task_handler(ctx, hook, true).await;
+            if ctx.get_aborted() {
+                return true;
+            }
         }
-        Ok(())
+        false
     }
 
-    /// Configures socket options for a newly accepted `TcpStream`.
-    ///
-    /// This applies settings like `TCP_NODELAY`, and `IP_TTL` from the server's configuration.
+    /// Executes a trait-based route hook if one matches.
     ///
     /// # Arguments
     ///
-    /// - `&TcpStream` - A reference to the `TcpStream` to configure.
-    async fn configure_stream(&self, stream: &TcpStream) {
-        let config: ServerConfig = self.get_server_config().clone();
-        if let Some(nodelay) = config.try_get_nodelay() {
-            let _ = stream.set_nodelay(*nodelay);
+    /// - `&mut Context` - The request context.
+    /// - `&str` - The request path to match.
+    ///
+    /// # Returns
+    ///
+    /// - `bool` - `true` if the lifecycle was aborted, `false` otherwise.
+    pub(super) async fn handle_route_matcher(&self, ctx: &mut Context, path: &str) -> bool {
+        if let Some(hook) = self.get_route_matcher().try_resolve_route(ctx, path) {
+            self.task_handler(ctx, &hook, true).await;
+            if ctx.get_aborted() {
+                return true;
+            }
         }
-        if let Some(ttl) = config.try_get_ttl() {
-            let _ = stream.set_ttl(*ttl);
+        false
+    }
+
+    /// Executes trait-based response middleware in sequence.
+    ///
+    /// # Arguments
+    ///
+    /// - `&mut Context` - The request context.
+    ///
+    /// # Returns
+    ///
+    /// - `bool` - `true` if the lifecycle was aborted, `false` otherwise.
+    pub(super) async fn handle_response_middleware(&self, ctx: &mut Context) -> bool {
+        for hook in self.get_response_middleware().iter() {
+            self.task_handler(ctx, hook, true).await;
+            if ctx.get_aborted() {
+                return true;
+            }
         }
+        false
     }
 
     /// Spawns a new asynchronous task to handle a single client connection.
@@ -655,26 +684,6 @@ impl Server {
         ctx.set_aborted(true).set_closed(true);
     }
 
-    /// Handles a single client connection, determining whether it's an HTTP or WebSocket request.
-    ///
-    /// It reads the initial request from the stream and dispatches it to the appropriate hook.
-    ///
-    /// # Arguments
-    ///
-    /// - `ArcRwLockStream` - The stream for the client connection.
-    async fn handle_connection(&self, stream: ArcRwLockStream) {
-        match Request::http_from_stream(&stream, self.get_request_config()).await {
-            Ok(request) => {
-                let server_address: usize = self.into();
-                let hook: HandlerState = HandlerState::new(stream, server_address.into());
-                self.handle_http_requests(&hook, &request).await;
-            }
-            Err(error) => {
-                self.handle_request_error(&mut stream.into(), &error).await;
-            }
-        }
-    }
-
     /// The core request handling pipeline.
     ///
     /// This function orchestrates the execution of request middleware, the route hook,
@@ -732,62 +741,53 @@ impl Server {
         }
     }
 
-    /// Executes trait-based request middleware in sequence.
-    ///
-    /// # Arguments
+    /// Handles a single client connection, determining whether it's an HTTP or WebSocket request.
     ///
-    /// - `&mut Context` - The request context.
+    /// It reads the initial request from the stream and dispatches it to the appropriate hook.
     ///
-    /// # Returns
+    /// # Arguments
     ///
-    /// - `bool` - `true` if the lifecycle was aborted, `false` otherwise.
-    pub(super) async fn handle_request_middleware(&self, ctx: &mut Context) -> bool {
-        for hook in self.get_request_middleware().iter() {
-            self.task_handler(ctx, hook, true).await;
-            if ctx.get_aborted() {
-                return true;
+    /// - `ArcRwLockStream` - The stream for the client connection.
+    async fn handle_connection(&self, stream: ArcRwLockStream) {
+        match Request::http_from_stream(&stream, self.get_request_config()).await {
+            Ok(request) => {
+                let server_address: usize = self.into();
+                let hook: HandlerState = HandlerState::new(stream, server_address.into());
+                self.handle_http_requests(&hook, &request).await;
+            }
+            Err(error) => {
+                self.handle_request_error(&mut stream.into(), &error).await;
             }
         }
-        false
     }
 
-    /// Executes a trait-based route hook if one matches.
+    /// Enters a loop to accept incoming TCP connections and spawn handlers for them.
     ///
     /// # Arguments
     ///
-    /// - `&mut Context` - The request context.
-    /// - `&str` - The request path to match.
+    /// - `&TcpListener` - A reference to the `TcpListener` to accept connections from.
     ///
     /// # Returns
     ///
-    /// - `bool` - `true` if the lifecycle was aborted, `false` otherwise.
-    pub(super) async fn handle_route_matcher(&self, ctx: &mut Context, path: &str) -> bool {
-        if let Some(hook) = self.get_route_matcher().try_resolve_route(ctx, path) {
-            self.task_handler(ctx, &hook, true).await;
-            if ctx.get_aborted() {
-                return true;
-            }
+    /// - `Result<(), ServerError>` - A `Result` which is typically `Ok(())` unless an unrecoverable
+    ///   error occurs.
+    async fn accept_connections(&self, tcp_listener: &TcpListener) -> Result<(), ServerError> {
+        while let Ok((stream, _)) = tcp_listener.accept().await {
+            self.configure_stream(&stream).await;
+            let stream: ArcRwLockStream = ArcRwLockStream::from_stream(stream);
+            self.spawn_connection_handler(stream).await;
         }
-        false
+        Ok(())
     }
 
-    /// Executes trait-based response middleware in sequence.
-    ///
-    /// # Arguments
-    ///
-    /// - `&mut Context` - The request context.
+    /// Creates and binds a `TcpListener` based on the server's configuration.
     ///
     /// # Returns
     ///
-    /// - `bool` - `true` if the lifecycle was aborted, `false` otherwise.
-    pub(super) async fn handle_response_middleware(&self, ctx: &mut Context) -> bool {
-        for hook in self.get_response_middleware().iter() {
-            self.task_handler(ctx, hook, true).await;
-            if ctx.get_aborted() {
-                return true;
-            }
-        }
-        false
+    /// - `Result<TcpListener, ServerError>` - A `Result` containing the bound `TcpListener` on success,
+    ///   or a `ServerError` on failure.
+    async fn create_tcp_listener(&self) -> Result<TcpListener, ServerError> {
+        Ok(TcpListener::bind(self.get_server_config().get_address()).await?)
     }
 
     /// Starts the server, binds to the configured address, and begins listening for connections.