Best way to restart server

[smiera]

Hi,

Im looking for best way for restart server using SIGHUP.
Here is my result

use std::net::SocketAddr;

use axum::Router;
use axum::routing::get;
use tokio::signal::unix::{signal, SignalKind};
use tokio::sync::oneshot;

#[derive(Debug)]
enum SignalAction {
    Shutdown,
    Restart,
}

#[tokio::main]
async fn main() {
    // register SIGHUP signal receiver
    let mut restart_signal = signal(SignalKind::hangup()).unwrap();
    loop {
        // create channel for sending axum server shutdown message from 'restart_signal'
        let (sender, receiver) = oneshot::channel();
        let mut server_task = tokio::spawn(run_server(receiver));
        //
        let action = tokio::select! {
            _= &mut server_task => {
                // 'ctrl_c' or 'SIGTERM' signal was received
                println!("server shutdown");
                SignalAction::Shutdown
            },
            _ = restart_signal.recv() => {
                // 'SIGHUP' signal was received
                sender.send(()).ok();
                println!("restart server");
                SignalAction::Restart
            },
        };
        //
        if !server_task.is_finished() {
            server_task.await.ok();
        }
        println!("loop action: {:?}", action);
        //
        if matches!(action, SignalAction::Shutdown) {
            break;
        }
    }
}

async fn run_server(receiver: oneshot::Receiver<()>) {
    let app = Router::new()
        .route("/", get(|| async { "Hello world" }));
    //
    let addr: SocketAddr = "127.0.0.1:3000".parse().expect("Can't parse address");
    let server = axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .with_graceful_shutdown(shutdown_signal(receiver));

    println!("listening on {}", addr);
    server.await.unwrap();
    println!("STOP server");
}

async fn shutdown_signal(sighup: oneshot::Receiver<()>) {
    let ctrl_c = async {
        tokio::signal::ctrl_c()
            .await
            .expect("failed to install Ctrl+C handler");
    };

    let sigterm = async {
        signal(SignalKind::terminate())
            .expect("failed to install SIGTERM handler")
            .recv()
            .await;
    };

    tokio::select! {
        _ = ctrl_c => {
            println!("[ctrl_c] signal received");
        },
        _ = sigterm => {
            println!("[sigterm] signal received");
        },
        _ = sighup => {
            println!("[restart] signal received");
        },
    }

    println!("shutdown_signal");
}

Am I doing everything right? Or maybe exists better way?