Programmatically Shutdown and Start Hyper Server

[Gowtham2003]

Hey everyone, I am building a simple file server application, I need to shutdown my server programmatically (for example via shutdown button from gui or cmd input)

Most of the resources available online are based on older versions

main.rs

use std::net::SocketAddr;
use std::sync::Arc;

use tokio::sync::Mutex;

use file_server::Store;

#[tokio::main]
pub async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    // parse the address to bind to from the command line argument or use the default address as a fallback if no argument is provided by the user
    let args: Vec<String> = std::env::args().collect();

    let addr: SocketAddr = match args.len() {
        2 => args[1].replace("localhost", "0.0.0.0").parse().unwrap(),
        _ => "0.0.0.0:3000".parse().unwrap()
    };
    let data_store = Arc::new(Mutex::new(Store::new()));
    data_store.clone().lock().await.add_file("/home/alpha/Downloads/Movie.mp4".to_string());
    data_store.clone().lock().await.add_file("/home/alpha/Downloads/ubuntu-22.04.3-desktop-amd64.iso".to_string());

    let server = file_server::Server::new(addr, data_store);

    server.run()
        .await
}

lib.rs

use std::net::SocketAddr;
use std::sync::Arc;

use hyper::server::conn::http1;
use hyper::service::service_fn;
use hyper_util::rt::TokioIo;
use tokio::net::TcpListener;
use tokio::sync::Mutex;

use crate::request_handlers::request_handler;
pub use crate::store::Store;

mod file_utils;
mod request_handlers;
mod utils;
mod store;

pub struct Server {
    pub addr: SocketAddr,
    pub store: Arc<Mutex<Store>>,
}


impl Server {
    pub fn new(addr: SocketAddr, store: Arc<Mutex<Store>>) -> Self {
        Self { addr, store }
    }
    pub async fn run(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {

        // Bind to the port and listen for incoming TCP connections
        let listener = TcpListener::bind(self.addr).await?;
        println!("Listening on http://{}", self.addr);
        loop {
            let (tcp, _) = listener.accept().await?;

            let io = TokioIo::new(tcp);
            let store = self.store.clone();
            // tokio::task::spawn(async move {
            let service = service_fn(move |req| {
                let store = Arc::clone(&store);
                async move {
                    request_handler(req, &store).await
                }
            });
                if let Err(err) =
                    http1::Builder::new() 
                        .serve_connection(io, service)
                        .await
                {
                    println!("Error serving connection: {:?}", err);
                }
            // });
        }
    }
}

Thanks in advance 🙏🏽