Use with_capacity as it's known by now.
use tokio::signal::unix;
use tokio::time;
const ADV_INTERVAL: u64 = 1;
#[derive(Debug)]
enum VRRPv2State {
Initialize,
Backup,
Master,
}
struct StateMachine {
state: VRRPv2State,
}
impl StateMachine {
fn new() -> Self {
StateMachine {
state: VRRPv2State::Initialize,
}
}
fn transit_to(&mut self, new_state: VRRPv2State) {
std::println!("vvrpd: {:?} -> {:?}", self.state, new_state);
self.state = new_state;
}
}
async fn advert_handler() {
println!("advert timer fired");
}
async fn sighup_handler() {
println!("got SIGHUP");
}
#[tokio::main(flavor = "current_thread")]
async fn main() {
let advert_timer_handle = tokio::spawn(async move {
let mut advert_interval = time::interval(time::Duration::from_secs(ADV_INTERVAL));
loop {
advert_interval.tick().await;
advert_handler().await;
}
});
let sighup_handle = tokio::spawn(async move {
let mut stream =
unix::signal(unix::SignalKind::hangup()).expect("Should be a signal stream");
loop {
stream.recv().await;
sighup_handler().await;
}
});
let mut sm = StateMachine::new();
sm.transit_to(VRRPv2State::Master);
sm.transit_to(VRRPv2State::Backup);
tokio::try_join!(advert_timer_handle, sighup_handle).expect("task(s) erred");
}