1 use tokio::signal::unix::{signal, SignalKind};

     2 use tokio::time;

     3 

     4 const ADV_INTERVAL: u64 = 3;

     5 const SKEW_INTERVAL: u64 = 1;

     6 

     7 async fn advert_handler() {

     8     println!("3 second timer fired");

     9 }

    10 

    11 async fn skew_handler() {

    12     println!("1 second timer fired");

    13 }

    14 

    15 async fn sighup_handler() {

    16     println!("got SIGHUP");

    17 }

    18 

    19 #[tokio::main(flavor = "current_thread")]

    20 async fn main() {

    21     let advert_handle = tokio::spawn(async move {

    22         let mut advert_interval = time::interval(time::Duration::from_secs(ADV_INTERVAL));

    23         loop {

    24             advert_interval.tick().await;

    25             advert_handler().await;

    26         }

    27     });

    28     let skew_handle = tokio::spawn(async move {

    29         let mut skew_interval = time::interval(time::Duration::from_secs(SKEW_INTERVAL));

    30         loop {

    31             skew_interval.tick().await;

    32             skew_handler().await;

    33         }

    34     });

    35     let sighup_handle = tokio::spawn(async move {

    36         let mut stream = signal(SignalKind::hangup()).expect("Should be a signal stream");

    37         loop {

    38             stream.recv().await;

    39             sighup_handler().await;

    40         }

    41     });

    42     let (_, _, _) = tokio::join!(advert_handle, skew_handle, sighup_handle);

    43 }