From c344d4b9721bbe55c07a9b5c001938b893d67cbe Mon Sep 17 00:00:00 2001 From: Chris Frankland-Wright Date: Sun, 20 Jul 2025 17:37:02 +0100 Subject: [PATCH] ntp service implemented --- Cargo.toml | 3 +- src/ui.rs | 184 ++++++++++++++++++++++++++++++++++++----------------- 2 files changed, 126 insertions(+), 61 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index fc040de..8fec13a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,4 +10,5 @@ crossterm = "0.27" regex = "1.11" serde = { version = "1.0", features = ["derive"] } serde_json = "1.0" -notify = "5.1.0" \ No newline at end of file +notify = "5.1.0" +get_if_addrs = "0.5" \ No newline at end of file diff --git a/src/ui.rs b/src/ui.rs index c50b5ec..63cdab2 100644 --- a/src/ui.rs +++ b/src/ui.rs @@ -17,50 +17,83 @@ use crossterm::{ terminal::{self, Clear, ClearType, EnterAlternateScreen, LeaveAlternateScreen}, }; -use crate::sync_logic::LtcState; +use get_if_addrs::get_if_addrs; use std::collections::VecDeque; +use crate::sync_logic::LtcState; -/// Launch the TUI; reads `offset` live from the file-watcher and performs auto-sync if out of sync. +/// Check if the ntpd service is active +fn ntp_service_active() -> bool { + if let Ok(output) = Command::new("systemctl").args(&["is-active", "ntpd"]).output() { + output.status.success() && String::from_utf8_lossy(&output.stdout).trim() == "active" + } else { + false + } +} + +/// Toggle the ntpd service (start if `start` is true, stop otherwise) +fn ntp_service_toggle(start: bool) { + let action = if start { "start" } else { "stop" }; + let _ = Command::new("systemctl").args(&[action, "ntpd"]).status(); +} + +/// Launch the full-featured TUI; reads `offset` live and performs auto-sync if out of sync. pub fn start_ui( state: Arc>, serial_port: String, offset: Arc>, ) { let mut stdout = stdout(); + // Enter alternate screen and hide cursor execute!(stdout, EnterAlternateScreen, Hide).unwrap(); terminal::enable_raw_mode().unwrap(); // Recent log of messages (last 10) let mut logs: VecDeque = VecDeque::with_capacity(10); + // Tracks when we first detected out-of-sync let mut out_of_sync_since: Option = None; - // Delta display cache: update once per second + // For caching the timecode delta display once per second let mut last_delta_update = Instant::now() - Duration::from_secs(1); let mut cached_delta_ms: i64 = 0; let mut cached_delta_frames: i64 = 0; loop { - // 1️⃣ Read hardware offset + // 1️⃣ Read hardware offset from watcher let hw_offset_ms = *offset.lock().unwrap(); - // 2️⃣ Measure & record jitter and Timecode Δ when LOCKED; clear both on FREE + // 2️⃣ Check NTP service status and gather network interfaces + let ntp_active = ntp_service_active(); + let interfaces: Vec = get_if_addrs() + .unwrap_or_default() + .into_iter() + .filter(|ifa| !ifa.is_loopback()) + .map(|ifa| ifa.ip().to_string()) + .collect(); + + // 3️⃣ Measure & record jitter and Timecode Δ when LOCKED; clear on FREE { let mut st = state.lock().unwrap(); if let Some(frame) = st.latest.clone() { if frame.status == "LOCK" { - let measured = (Utc::now() - frame.timestamp).num_milliseconds() - hw_offset_ms; + // Jitter in ms + let now = Utc::now(); + let raw = (now - frame.timestamp).num_milliseconds(); + let measured = raw - hw_offset_ms; st.record_offset(measured); + + // Timecode delta: how far system clock differs from LTC let local = Local::now(); let sub_ms = ((frame.frames as f64 / frame.frame_rate) * 1000.0).round() as i64; let base_time = NaiveTime::from_hms_opt( frame.hours, frame.minutes, frame.seconds, - ) - .unwrap_or(local.time()); + ).unwrap_or(local.time()); let offset_dt = local.date_naive().and_time(base_time) + ChronoDuration::milliseconds(sub_ms); - let ltc_dt = Local.from_local_datetime(&offset_dt).single().unwrap_or(local); + let ltc_dt = Local.from_local_datetime(&offset_dt) + .single() + .unwrap_or(local); let delta_ms = local.signed_duration_since(ltc_dt).num_milliseconds(); st.record_clock_delta(delta_ms); } else { @@ -70,8 +103,8 @@ pub fn start_ui( } } - // 3️⃣ Compute averages and status - let (avg_ms, avg_frames, status, ratio, avg_delta) = { + // 4️⃣ Compute averages & statuses + let (avg_ms, avg_frames, status_str, lock_ratio, avg_delta) = { let st = state.lock().unwrap(); ( st.average_jitter(), @@ -82,12 +115,12 @@ pub fn start_ui( ) }; - // Update cached delta once per second + // 5️⃣ Update cached delta once per second if last_delta_update.elapsed() >= Duration::from_secs(1) { cached_delta_ms = avg_delta; - // compute frames from ms - if let Ok(st) = state.lock() { - if let Some(frame) = &st.latest { + // Recompute frames equivalent + if let Ok(st2) = state.lock() { + if let Some(frame) = &st2.latest { let ms_pf = 1000.0 / frame.frame_rate; cached_delta_frames = (cached_delta_ms as f64 / ms_pf).round() as i64; } @@ -95,12 +128,13 @@ pub fn start_ui( last_delta_update = Instant::now(); } - // Auto-sync: if OUT OF SYNC or Δ >10ms for 5s - if status == "OUT OF SYNC" || cached_delta_ms.abs() > 10 { + // 6️⃣ Auto-sync if "OUT OF SYNC" or Δ >10ms for 5s + if status_str == "OUT OF SYNC" || cached_delta_ms.abs() > 10 { if let Some(start) = out_of_sync_since { if start.elapsed() >= Duration::from_secs(5) { - if let Ok(stlock) = state.lock() { - if let Some(frame) = &stlock.latest { + // Perform sync to LTC + if let Ok(stl) = state.lock() { + if let Some(frame) = &stl.latest { let local_now = Local::now(); let sub_ms = ((frame.frames as f64 / frame.frame_rate) * 1000.0) .round() as i64; @@ -108,16 +142,23 @@ pub fn start_ui( frame.hours, frame.minutes, frame.seconds, - ) - .unwrap_or(local_now.time()); + ).unwrap_or(local_now.time()); let offset_dt = local_now.date_naive().and_time(base_time) + ChronoDuration::milliseconds(sub_ms); let ltc_dt = Local.from_local_datetime(&offset_dt) .single() .unwrap_or(local_now); let ts = format!("{:02}:{:02}:{:02}.{:03}", - ltc_dt.hour(), ltc_dt.minute(), ltc_dt.second(), ltc_dt.timestamp_subsec_millis()); - let res = Command::new("sudo").arg("date").arg("-s").arg(&ts).status(); + ltc_dt.hour(), + ltc_dt.minute(), + ltc_dt.second(), + ltc_dt.timestamp_subsec_millis() + ); + let res = Command::new("sudo") + .arg("date") + .arg("-s") + .arg(&ts) + .status(); let msg = if res.as_ref().map_or(false, |s| s.success()) { format!("🔄 Auto-synced to LTC: {}", ts) } else { @@ -138,44 +179,48 @@ pub fn start_ui( out_of_sync_since = None; } - // 4️⃣ Draw static UI + // 7️⃣ Draw static UI header queue!( stdout, MoveTo(0, 0), Clear(ClearType::All), MoveTo(2, 1), Print("NTP Timeturner v2 - Rust Port"), MoveTo(2, 2), Print(format!("Using Serial Port: {}", serial_port)), + MoveTo(2, 3), Print(format!("NTP Server : {}", if ntp_active { "ACTIVE" } else { "INACTIVE" })), + MoveTo(2, 4), Print(format!("Interfaces : {}", interfaces.join(", "))), ) .unwrap(); - // 5️⃣ Draw LTC & System Clock + // 8️⃣ Draw LTC and System Clock if let Ok(st) = state.lock() { if let Some(frame) = &st.latest { queue!( stdout, - MoveTo(2, 4), Print(format!("LTC Status : {}", frame.status)), - MoveTo(2, 5), Print(format!( - "LTC Timecode : {:02}:{:02}:{:02}:{:02}", + MoveTo(2, 6), Print(format!("LTC Status : {}", frame.status)), + MoveTo(2, 7), Print(format!( + "LTC Timecode : {:02}:{:02}:{:02}:{:02}", frame.hours, frame.minutes, frame.seconds, frame.frames )), - MoveTo(2, 6), Print(format!("Frame Rate : {:.2}fps", frame.frame_rate)), + MoveTo(2, 8), Print(format!("Frame Rate : {:.2}fps", frame.frame_rate)), ) .unwrap(); } else { queue!( stdout, - MoveTo(2, 4), Print("LTC Status : (waiting)"), - MoveTo(2, 5), Print("LTC Timecode : …"), - MoveTo(2, 6), Print("Frame Rate : …"), + MoveTo(2, 6), Print("LTC Status : (waiting)"), + MoveTo(2, 7), Print("LTC Timecode : …"), + MoveTo(2, 8), Print("Frame Rate : …"), ) .unwrap(); } let now_local = Local::now(); - let sys_str = format!("{:02}:{:02}:{:02}.{:03}", - now_local.hour(), now_local.minute(), now_local.second(), now_local.timestamp_subsec_millis()); - queue!(stdout, MoveTo(2, 7), Print(format!("System Clock : {}", sys_str))).unwrap(); + let sys_ts = format!("{:02}:{:02}:{:02}.{:03}", + now_local.hour(), now_local.minute(), now_local.second(), now_local.timestamp_subsec_millis() + ); + queue!(stdout, MoveTo(2, 9), Print(format!("System Clock : {}", sys_ts))).unwrap(); } - // 6️⃣ Overlay in new order + // 9️⃣ Overlay metrics in new order + // Timecode Δ line let dcol = if cached_delta_ms.abs() < 20 { Color::Green } else if cached_delta_ms.abs() < 100 { @@ -185,19 +230,27 @@ pub fn start_ui( }; queue!( stdout, - MoveTo(2, 8), SetForegroundColor(dcol), - Print(format!("Timecode Δ : {:+} ms ({:+} frames)", cached_delta_ms, cached_delta_frames)), + MoveTo(2, 11), SetForegroundColor(dcol), + Print(format!("Timecode Δ : {:+} ms ({:+} frames)", cached_delta_ms, cached_delta_frames)), ResetColor, ) .unwrap(); - let scol = if status == "IN SYNC" { Color::Green } else { Color::Red }; + // Sync Status line + let scol = if status_str == "IN SYNC" { + Color::Green + } else { + Color::Red + }; queue!( stdout, - MoveTo(2, 9), SetForegroundColor(scol), Print(format!("Sync Status : {}", status)), ResetColor, + MoveTo(2, 12), SetForegroundColor(scol), + Print(format!("Sync Status : {}", status_str)), + ResetColor, ) .unwrap(); + // Sync Jitter line let jstatus = if avg_ms.abs() < 10 { "GOOD" } else if avg_ms.abs() < 40 { @@ -214,40 +267,39 @@ pub fn start_ui( }; queue!( stdout, - MoveTo(2, 10), SetForegroundColor(jcol), Print(format!("Sync Jitter : {}", jstatus)), ResetColor, + MoveTo(2, 13), SetForegroundColor(jcol), + Print(format!("Sync Jitter : {}", jstatus)), + ResetColor, ) .unwrap(); - queue!( - stdout, - MoveTo(2, 11), Print(format!("Lock Ratio : {:.1}% LOCK", ratio)), + // Lock Ratio line + queue!(stdout, + MoveTo(2, 14), Print(format!("Lock Ratio : {:.1}% LOCK", lock_ratio)), ) .unwrap(); - // Footer - queue!( - stdout, - MoveTo(2, 13), Print("[S] Set system clock to LTC [Q] Quit"), + // 10️⃣ Footer and logs + queue!(stdout, + MoveTo(2, 16), Print("[S] Set system clock to LTC [Q] Quit"), ) .unwrap(); - - // 7️⃣ Recent logs for (i, log_msg) in logs.iter().enumerate() { - queue!(stdout, MoveTo(2, 15 + i as u16), Print(log_msg)).unwrap(); + queue!(stdout, MoveTo(2, 18 + i as u16), Print(log_msg)).unwrap(); } stdout.flush().unwrap(); - // 8️⃣ Handle manual sync/quit - if poll(Duration::from_millis(0)).unwrap() { + // 11️⃣ Handle manual sync and quit keys + if poll(Duration::from_millis(50)).unwrap() { if let Event::Key(evt) = read().unwrap() { - if let KeyCode::Char(c) = evt.code { - if c.eq_ignore_ascii_case(&'q') { + match evt.code { + KeyCode::Char(c) if c.eq_ignore_ascii_case(&'q') => { execute!(stdout, Show, LeaveAlternateScreen).unwrap(); terminal::disable_raw_mode().unwrap(); process::exit(0); } - if c.eq_ignore_ascii_case(&'s') { + KeyCode::Char(c) if c.eq_ignore_ascii_case(&'s') => { if let Ok(stlock) = state.lock() { if let Some(frame) = &stlock.latest { let local_now = Local::now(); @@ -264,19 +316,31 @@ pub fn start_ui( let ltc_dt = Local.from_local_datetime(&offset_dt) .single() .unwrap_or(local_now); - let ts = format!("{:02}:{:02}:{:02}.{:03}", - ltc_dt.hour(), ltc_dt.minute(), ltc_dt.second(), ltc_dt.timestamp_subsec_millis()); - let res = Command::new("sudo").arg("date").arg("-s").arg(&ts).status(); + let ts = format!( + "{:02}:{:02}:{:02}.{:03}", + ltc_dt.hour(), + ltc_dt.minute(), + ltc_dt.second(), + ltc_dt.timestamp_subsec_millis(), + ); + let res = Command::new("sudo") + .arg("date") + .arg("-s") + .arg(&ts) + .status(); let msg = if res.as_ref().map_or(false, |s| s.success()) { format!("✔ Synced exactly to LTC: {}", ts) } else { "❌ date cmd failed".into() }; - if logs.len() == 10 { logs.pop_front(); } + if logs.len() == 10 { + logs.pop_front(); + } logs.push_back(msg); } } } + _ => {} } } }