fix: remove graceful http connection shutdown (#773)

Author: bmuddha

magicblock-aperture/src/server/http/mod.rs

@@ -6,6 +6,7 @@ use hyper_util::{
     rt::{TokioExecutor, TokioIo},
     server::conn,
 };
+use log::info;
 use magicblock_core::link::DispatchEndpoints;
 use tokio::{
     net::{TcpListener, TcpStream},
@@ -74,7 +75,10 @@ impl HttpServer {
                 // Accept a new incoming connection.
                 Ok((stream, _)) = self.socket.accept() => self.handle(stream),
                 // Or, break the loop if the cancellation token is triggered.
-                _ = self.cancel.cancelled() => break,
+                _ = self.cancel.cancelled() => {
+                    info!("HTTP server shutdown signal has been received");
+                    break
+                }
             }
         }
 
@@ -84,6 +88,7 @@ impl HttpServer {
         drop(self.shutdown);
         // Wait for the shutdown signal, which fires when all connections are closed.
         let _ = self.shutdown_rx.await;
+        info!("HTTP server has shutdown");
     }
 
     /// Spawns a new task to handle a single incoming TCP connection.
@@ -104,23 +109,13 @@ impl HttpServer {
             let builder = conn::auto::Builder::new(TokioExecutor::new());
             let connection = builder.serve_connection(io, handler);
             tokio::pin!(connection);
-            let mut terminating = false;
-
             // This loop manages the connection's lifecycle.
-            loop {
-                tokio::select! {
-                    // Poll the connection itself. This branch
-                    // completes when the client disconnects.
-                    _ = &mut connection => {
-                        break;
-                    }
-                    // If the cancellation token is triggered, initiate a graceful shutdown
-                    // of the Hyper connection.
-                    _ = cancel.cancelled(), if !terminating => {
-                        connection.as_mut().graceful_shutdown();
-                        terminating = true;
-                    }
-                }
+            tokio::select! {
+                // Poll the connection itself. This branch
+                // completes when the client disconnects.
+                _ = connection => {},
+                // If the cancellation token is triggered, force terminate the connection
+                _ = cancel.cancelled() => {},
             }
             // Drop the shutdown handle for this connection, signaling
             // that one fewer outstanding connection is active.

magicblock-aperture/src/server/websocket/connection.rs

@@ -102,9 +102,13 @@ impl ConnectionHandler {
 
         loop {
             tokio::select! {
-                // Prioritize reading frames from the client.
+                // Prioritize fast system shutdown
                 biased;
 
+                // 0. We force shutdown the connection, without close frame
+                _ = self.cancel.cancelled() => break,
+
+
                 // 1. Handle an incoming frame from the client's WebSocket.
                 Ok(frame) = self.ws.read_frame() => {
                     // Record inbound client activity
@@ -163,10 +167,7 @@ impl ConnectionHandler {
                     }
                 }
 
-                // 4. Handle the global server shutdown signal.
-                _ = self.cancel.cancelled() => break,
-
-                // 5. Run cleanup logic for this connection (e.g., an expiring sub).
+                // 4. Run cleanup logic for this connection (e.g., an expiring sub).
                 _ = self.dispatcher.cleanup() => {}
 
                 else => {

magicblock-aperture/src/server/websocket/mod.rs

@@ -10,7 +10,7 @@ use hyper::{
     Request, Response,
 };
 use hyper_util::rt::TokioIo;
-use log::warn;
+use log::{info, warn};
 use tokio::{
     net::{TcpListener, TcpStream},
     sync::oneshot::Receiver,
@@ -94,13 +94,17 @@ impl WebsocketServer {
                     self.handle(stream);
                 },
                 // The server shutdown signal has been received.
-                _ = self.state.cancel.cancelled() => break,
+                _ = self.state.cancel.cancelled() => {
+                    info!("Websocket server shutdown signal has been received");
+                    break
+                }
             }
         }
         // Drop the main `ConnectionState` which holds the original `Shutdown` handle.
         drop(self.state);
         // Wait for all spawned connection tasks to finish.
         let _ = self.shutdown.await;
+        info!("Websocket server has shutdown");
     }
 
     /// Spawns a task to handle a new TCP stream as a potential WebSocket connection.