105 lines
3.1 KiB
Rust
105 lines
3.1 KiB
Rust
use joecalsend::{Config, JoecalService, Listeners, error, models::Device};
|
|
use log::{error, info};
|
|
use ratatui::DefaultTerminal;
|
|
use tokio::{sync::mpsc::unbounded_channel, task::JoinSet};
|
|
use tui_logger::{LevelFilter, init_logger, set_env_filter_from_env};
|
|
|
|
mod app;
|
|
use app::{App, CurrentScreen, Peer};
|
|
|
|
fn main() -> error::Result<()> {
|
|
let device = Device::default();
|
|
|
|
if std::env::var("RUST_LOG").is_err() {
|
|
unsafe {
|
|
std::env::set_var("RUST_LOG", "joecalsend");
|
|
}
|
|
}
|
|
init_logger(LevelFilter::Debug).map_err(|e| std::io::Error::other(format!("{e}")))?;
|
|
set_env_filter_from_env(None);
|
|
|
|
let config = Config::default();
|
|
|
|
let mut terminal = ratatui::init();
|
|
let result = start_and_run(&mut terminal, config, device);
|
|
ratatui::restore();
|
|
|
|
result
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn start_and_run(
|
|
terminal: &mut DefaultTerminal,
|
|
config: Config,
|
|
device: Device,
|
|
) -> error::Result<()> {
|
|
let (event_tx, event_listener) = unbounded_channel();
|
|
|
|
let service = JoecalService::new(device, config.clone(), event_tx)
|
|
.await
|
|
.expect("Could not create JoecalService");
|
|
|
|
let mut app = App::new(service, event_listener);
|
|
|
|
let mut handles = JoinSet::new();
|
|
app.service.start(&mut handles).await;
|
|
loop {
|
|
terminal.draw(|frame| app.draw(frame))?;
|
|
app.handle_events().await?;
|
|
|
|
if app.screen() == CurrentScreen::Stopping {
|
|
app.service.stop().await;
|
|
break;
|
|
}
|
|
|
|
let peers = app.service.peers.lock().await;
|
|
app.peers.clear();
|
|
peers.iter().for_each(|(fingerprint, (addr, device))| {
|
|
let alias = device.alias.clone();
|
|
let peer = Peer {
|
|
alias,
|
|
fingerprint: fingerprint.to_owned(),
|
|
addr: addr.to_owned(),
|
|
};
|
|
app.peers.push(peer);
|
|
});
|
|
|
|
let mut stale_rx_requests = Vec::with_capacity(app.receive_requests.len());
|
|
let now = chrono::Utc::now().timestamp_millis() as u64;
|
|
for (id, request) in app.receive_requests.iter() {
|
|
if request.tx.is_closed() || (now - id.timestamp()) > 60_000 {
|
|
stale_rx_requests.push(*id);
|
|
}
|
|
}
|
|
for id in stale_rx_requests {
|
|
app.receive_requests.remove(&id);
|
|
}
|
|
}
|
|
|
|
shutdown(&mut handles).await;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn shutdown(handles: &mut JoinSet<Listeners>) {
|
|
let mut alarm = tokio::time::interval(tokio::time::Duration::from_secs(5));
|
|
alarm.tick().await;
|
|
loop {
|
|
tokio::select! {
|
|
join_result = handles.join_next() => {
|
|
match join_result {
|
|
Some(handle) => match handle {
|
|
Ok(h) => info!("Stopped {h:?}"),
|
|
Err(e) => error!("Got error {e:?}"),
|
|
}
|
|
None => break,
|
|
}
|
|
}
|
|
_ = alarm.tick() => {
|
|
info!("Exit timeout reached, aborting all unjoined tasks");
|
|
handles.abort_all();
|
|
break;
|
|
},
|
|
}
|
|
}
|
|
}
|