mod counter;
mod serial;
use radbeeper::{analysis, broker, clock, entropy, history, log};
use analysis::{
bar_rows, bar_rows_to, level, spectrum_columns, Ladder, Level, Windows,
};
use std::collections::BTreeSet;
use std::io::{Read, Write};
use std::os::unix::process::CommandExt;
use std::path::{Path, PathBuf};
use std::process::{Child, Command};
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::{Duration, Instant};
const VERSION: &str = env!("CARGO_PKG_VERSION");
const BIG_ROWS: usize = 12;
const SERVICE_WAIT: f64 = 10.0;
const STRIP_KEEP: usize = 4096;
const RESCAN: f64 = log::DEFAULT_LOG_EVERY;
const WAIT_POLL: f64 = 0.5;
fn glyph(ch: char) -> Option<&'static [&'static str]> {
Some(match ch {
'0' => &["111111","111111","100001","100001","100001","100001","100001","100001","100001","100001","111111","111111"],
'1' => &["000110","001110","010110","000110","000110","000110","000110","000110","000110","000110","011111","011111"],
'2' => &["111111","111111","000001","000001","000001","111111","111111","100000","100000","100000","111111","111111"],
'3' => &["111111","111111","000001","000001","000001","111111","111111","000001","000001","000001","111111","111111"],
'4' => &["100001","100001","100001","100001","100001","111111","111111","000001","000001","000001","000001","000001"],
'5' => &["111111","111111","100000","100000","100000","111111","111111","000001","000001","000001","111111","111111"],
'6' => &["111111","111111","100000","100000","100000","111111","111111","100001","100001","100001","111111","111111"],
'7' => &["111111","111111","000001","000010","000010","000100","000100","001000","001000","010000","010000","010000"],
'8' => &["111111","111111","100001","100001","100001","111111","111111","100001","100001","100001","111111","111111"],
'9' => &["111111","111111","100001","100001","100001","111111","111111","000001","000001","000001","111111","111111"],
'.' => &["00","00","00","00","00","00","00","00","00","00","11","11"],
'-' => &["000000","000000","000000","000000","000000","111111","111111","000000","000000","000000","000000","000000"],
_ => return None,
})
}
fn digits_left(head: &str) -> usize {
head.chars().count() + 3
}
const MAX_READOUT: &str = "65535";
fn readout_width() -> usize {
big_number(MAX_READOUT)
.iter()
.map(|r| r.chars().count())
.max()
.unwrap_or(0)
}
fn nameplate() -> String {
format!("{} {}", env!("CARGO_PKG_NAME"), env!("CARGO_PKG_VERSION"))
}
fn nameplate_left(width: usize, busy_to: usize, plate: usize) -> Option<usize> {
let x = width.checked_sub(plate)?;
(x > busy_to + 1).then_some(x)
}
fn big_number(text: &str) -> Vec<String> {
let mut rows = vec![String::new(); BIG_ROWS];
for ch in text.chars() {
if let Some(g) = glyph(ch) {
for r in 0..BIG_ROWS {
for bit in g[r].chars() {
rows[r].push(if bit == '1' { '█' } else { ' ' });
}
rows[r].push(' ');
}
}
}
rows
}
struct Screen {
saved: libc::termios,
}
impl Screen {
fn enter() -> Screen {
let mut saved: libc::termios = unsafe { std::mem::zeroed() };
unsafe {
libc::tcgetattr(0, &mut saved);
let mut raw = saved;
raw.c_lflag &= !(libc::ICANON | libc::ECHO);
raw.c_cc[libc::VMIN] = 0;
raw.c_cc[libc::VTIME] = 0;
libc::tcsetattr(0, libc::TCSANOW, &raw);
}
print!("\x1b[?1049h\x1b[?25l");
let _ = std::io::stdout().flush();
Screen { saved }
}
fn size(&self) -> (usize, usize) {
let mut ws: libc::winsize = unsafe { std::mem::zeroed() };
if unsafe { libc::ioctl(1, libc::TIOCGWINSZ, &mut ws) } == 0 && ws.ws_col > 0 {
(ws.ws_row as usize, ws.ws_col as usize)
} else {
(24, 80)
}
}
fn quit_pressed(&self) -> bool {
let mut b = [0u8; 8];
match std::io::stdin().read(&mut b) {
Ok(n) if n > 0 => b[..n].iter().any(|&c| c == b'q' || c == b'Q' || c == 27),
_ => false,
}
}
}
impl Drop for Screen {
fn drop(&mut self) {
print!("\x1b[?25h\x1b[?1049l");
let _ = std::io::stdout().flush();
unsafe { libc::tcsetattr(0, libc::TCSANOW, &self.saved) };
}
}
const DIM: &str = "\x1b[2m";
const BOLD: &str = "\x1b[1m";
const OFF: &str = "\x1b[0m";
const GREEN: &str = "\x1b[32m";
const YELLOW: &str = "\x1b[33m";
const RED: &str = "\x1b[31m";
const CYAN: &str = "\x1b[36m";
fn colour_for(l: Level) -> &'static str {
match l {
Level::Calm => GREEN,
Level::Raised => YELLOW,
Level::High => RED,
}
}
fn at(row: usize, col: usize) -> String {
format!("\x1b[{};{}H", row + 1, col + 1)
}
const CPM_WINDOW: f64 = 30.0;
fn cpm_cmd(c: &counter::Counter, cpm_per_usvh: f64) -> i32 {
let mut w = Windows::new(&[CPM_WINDOW]);
eprintln!("counting for {}s...", CPM_WINDOW as i64);
c.heartbeat(true);
let start = Instant::now();
while w.average(CPM_WINDOW).is_none() {
let counts = match c.next_sample(Duration::from_millis(2500)) {
Some(v) => v as u32,
None => break,
};
w.add(start.elapsed().as_secs_f64(), counts);
}
c.heartbeat(false);
match w.average(CPM_WINDOW) {
Some(n) => {
println!("{:.1} CPM {:.3} uSv/h", n, n / cpm_per_usvh);
0
}
None => {
eprintln!("the counter stopped talking after {}s",
w.elapsed() as i64);
1
}
}
}
struct WatchLog {
dir: PathBuf,
every: f64,
backfill: Option<(usize, f64)>,
export_every: Option<f64>,
frames: bool,
}
fn export_pages(dir: &Path, cpm_per_usvh: f64) -> String {
match radbeeper::export::export(dir, &dir.join("index.html"), true, cpm_per_usvh,
radbeeper::export::DEFAULT_TITLE, None,
radbeeper::audit::DEFAULT_FRAME_BUDGET) {
Ok(r) => format!("exported {} rows {}", r.rows,
clock::format(clock::now(), "%H:%M")),
Err(e) => format!("NOT EXPORTED: {}", e),
}
}
fn table_lines(h: usize) -> usize {
if h < 26 {
0
} else if h < 36 {
h - 24
} else {
h - 30
}
}
fn draw_table(out: &mut String, top: usize, lines: usize, width: usize,
names: &[String], rows: &std::collections::VecDeque<Vec<String>>) {
if lines == 0 {
return;
}
let shown: Vec<&Vec<String>> = rows.iter().rev().take(lines - 1).rev().collect();
let src = names.iter().position(|n| n == "src");
let mut widths: Vec<usize> = names.iter().map(|n| n.len() + 1).collect();
for r in &shown {
for (i, cell) in r.iter().enumerate() {
if let Some(wd) = widths.get_mut(i) {
*wd = (*wd).max(cell.chars().count().max(1));
}
}
}
let mut fit = 0;
let mut used = 0;
for wd in &widths {
if used + wd > width.saturating_sub(1) {
break;
}
used += wd + 2;
fit += 1;
}
let mut head = String::new();
for (i, name) in names.iter().take(fit).enumerate() {
let label = if i == 0 { format!("#{}", name) } else { name.clone() };
head.push_str(&format!("{:<w$} ", label, w = widths[i]));
}
let head = head.trim_end().to_string();
out.push_str(&format!("{}{}{}{}", at(top, 0), DIM, head, OFF));
for (k, r) in shown.iter().enumerate() {
let flash = src.and_then(|i| r.get(i)).map(|v| v != log::SRC_LIVE).unwrap_or(false);
out.push_str(&at(top + 1 + k, 0));
if flash {
out.push_str(DIM);
}
for i in 0..fit {
let cell = r.get(i).map(String::as_str).unwrap_or("");
if cell.is_empty() {
out.push_str(&format!("{}{:<w$}{} ", DIM, "-", if flash { "" } else { OFF },
w = widths[i]));
} else {
out.push_str(&format!("{:<w$} ", cell, w = widths[i]));
}
}
out.push_str(OFF);
}
}
enum Tube {
Sample { who: usize, when: f64, counts: u32 },
Gone { who: usize },
}
struct Bank {
counters: Vec<Option<std::sync::Arc<counter::Counter>>>,
ids: Vec<broker::CounterId>,
tx: std::sync::mpsc::Sender<Tube>,
rx: std::sync::mpsc::Receiver<Tube>,
running: bool,
}
impl Bank {
fn open(found: Vec<counter::Counter>) -> Bank {
let (tx, rx) = std::sync::mpsc::channel();
let mut bank = Bank { counters: Vec::new(), ids: Vec::new(), tx, rx, running: false };
for c in found {
bank.adopt(c);
}
bank
}
fn adopt(&mut self, c: counter::Counter) -> usize {
let id = broker::CounterId {
path: c.path.clone(),
baud: c.baud,
version: c.version.clone(),
serial_no: c.serial_no.clone(),
};
let free = |k: usize| self.counters.get(k).map(|c| c.is_none()).unwrap_or(false);
let who = match self
.ids
.iter()
.position(|k| k.serial_no == id.serial_no)
.filter(|k| free(*k))
{
Some(i) => {
self.ids[i] = id;
self.counters[i] = Some(std::sync::Arc::new(c));
i
}
None => {
self.ids.push(id);
self.counters.push(Some(std::sync::Arc::new(c)));
self.ids.len() - 1
}
};
if self.running {
self.spawn(who);
}
who
}
fn spawn(&self, who: usize) {
let Some(c) = self.counters[who].clone() else { return };
let tx = self.tx.clone();
c.heartbeat(true);
std::thread::spawn(move || {
loop {
match c.next_sample(Duration::from_millis(2500)) {
Some(v) => {
if tx.send(Tube::Sample { who, when: clock::now(), counts: v as u32 })
.is_err()
{
return;
}
}
None => break,
}
}
let _ = tx.send(Tube::Gone { who });
});
}
fn identity(&self, spans: &[f64]) -> broker::Identity {
broker::Identity { counters: self.ids.clone(), spans: spans.to_vec() }
}
fn len(&self) -> usize {
self.ids.len()
}
fn live_paths(&self) -> Vec<String> {
self.counters
.iter()
.filter_map(|c| c.as_ref().map(|c| c.path.clone()))
.collect()
}
fn live(&self) -> Vec<std::sync::Arc<counter::Counter>> {
self.counters.iter().flatten().cloned().collect()
}
fn start(&mut self) {
if self.running {
return;
}
self.running = true;
for who in 0..self.counters.len() {
self.spawn(who);
}
}
fn next(&self, timeout: Duration) -> Option<Tube> {
self.rx.recv_timeout(timeout).ok()
}
fn retire(&mut self, who: usize) {
if let Some(slot) = self.counters.get_mut(who) {
*slot = None;
}
}
fn stop(&self) {
for c in self.counters.iter().flatten() {
c.heartbeat(false);
}
}
}
fn mean_cpm(w: &Windows, span: f64, tubes: usize) -> Option<f64> {
w.average(span).map(|v| v / tubes.max(1) as f64)
}
enum Feed {
Own {
bank: Bank,
srv: Option<broker::Server>,
},
Attached(broker::Client),
}
enum Tick {
Sample { who: usize, when: f64, counts: u32 },
Row { row: String },
Random { who: usize, hex: String, at: String, suspect: bool },
Live,
}
impl Feed {
fn open(dir: &Path, devices: &[String], baud: Option<u32>, spans: &[f64],
wait: Option<f64>) -> Result<Feed, counter::NotFound> {
if let Some(c) = broker::Client::attach(dir) {
if devices.iter().all(|d| c.identity().serves(d)) {
return Ok(Feed::Attached(c));
}
}
let one = devices.len() == 1;
let found = match (wait, one) {
(Some(limit), _) => vec![find_waiting(devices.first().map(|s| s.as_str()),
baud, limit)?],
_ => {
let (found, why) = counter::find_all(devices, baud);
match why {
Some(e) => return Err(e),
None => found,
}
}
};
let bank = Bank::open(found);
let srv = broker::Server::start(dir, &bank.identity(spans)).ok();
Ok(Feed::Own { bank, srv })
}
fn identity(&self) -> broker::Identity {
match self {
Feed::Own { bank, .. } => bank.identity(&[]),
Feed::Attached(c) => c.identity().clone(),
}
}
fn counters(&self) -> Vec<std::sync::Arc<counter::Counter>> {
match self {
Feed::Own { bank, .. } => bank.live(),
Feed::Attached(_) => Vec::new(),
}
}
fn owns_the_port(&self) -> bool {
matches!(self, Feed::Own { .. })
}
fn watchers(&self) -> usize {
match self {
Feed::Own { srv, .. } => srv.as_ref().map(|s| s.clients()).unwrap_or(0),
Feed::Attached(_) => 0,
}
}
fn start(&mut self) {
if let Feed::Own { bank, .. } = self {
bank.start();
}
}
fn width(&self) -> usize {
match self {
Feed::Own { bank, .. } => bank.len(),
Feed::Attached(c) => c.identity().len(),
}
}
fn stop(&mut self) {
if let Feed::Own { bank, .. } = self {
bank.stop();
}
}
fn next(&mut self, timeout: Duration) -> Option<Tick> {
match self {
Feed::Own { bank, srv } => {
if let Some(s) = srv.as_mut() {
s.accept_pending();
}
match bank.next(timeout)? {
Tube::Sample { who, when, counts } => {
if let Some(s) = srv.as_mut() {
s.publish_sample(who, when, counts);
}
Some(Tick::Sample { who, when, counts })
}
Tube::Gone { .. } => None,
}
}
Feed::Attached(c) => match c.next(timeout)? {
broker::Event::Sample { who, when, counts } => {
Some(Tick::Sample { who, when, counts })
}
broker::Event::Row { row, .. } => Some(Tick::Row { row }),
broker::Event::Random { who, hex, at, suspect } => {
Some(Tick::Random { who, hex, at, suspect })
}
broker::Event::Live => Some(Tick::Live),
broker::Event::Counter { .. } | broker::Event::Gone { .. } => {
Some(Tick::Live)
}
},
}
}
fn publish_row(&mut self, who: usize, row: &str) {
if let Feed::Own { srv: Some(s), .. } = self {
s.publish_row(who, row);
}
}
fn publish_random(&mut self, who: usize, hex: &str, at: &str, suspect: bool) {
if let Feed::Own { srv: Some(s), .. } = self {
s.publish_random(who, hex, at, suspect);
}
}
}
fn watch(feed: &mut Feed, spans: &[f64], cpm_per_usvh: f64,
duration: Option<f64>, logging: Option<WatchLog>) {
install_stop_handler();
let id = feed.identity();
let table_spans: Vec<f64> =
if id.spans.is_empty() { spans.to_vec() } else { id.spans.clone() };
let screen = Screen::enter();
let names = log::columns(&log::header(&table_spans));
let mut table: std::collections::VecDeque<Vec<String>> = std::collections::VecDeque::new();
let mut table_note = String::new();
let wants_table = logging.is_some();
let logging = logging.filter(|_| feed.owns_the_port());
let mut loggers: Vec<Logger> = Vec::new();
let mut merged_log: Option<MergedLogger> = None;
if let Some(wl) = logging.as_ref() {
let _ = std::fs::create_dir_all(&wl.dir);
for (k, c) in feed.counters().iter().enumerate() {
if let Some((bytes, max_gap)) = wl.backfill {
print!("\x1b[2J{}{}{} @ {} baud {} serial {}{}{}reading the counter's history \
to fill the log's gaps ({} KiB)...{}",
at(0, 0), DIM, c.path, c.baud, c.version, c.serial_no, OFF,
at(2, 0), bytes / 1024, at(3, 0));
let _ = std::io::stdout().flush();
let note = backfill_at_start(c, &wl.dir, spans, wl.every, bytes, max_gap, true)
.replace(" samples, ", " samples ")
.replace("backfill -- ", "backfill: ");
table_note = if k == 0 { note } else { format!("{} {}", table_note, note) };
}
let path = log::path(clock::now(), &wl.dir, Some(&c.serial_no));
for (_, cells) in
log::read_table(&path, &names).into_iter().rev().take(TABLE_KEEP).rev()
{
table.push_back(cells);
}
loggers.push(Logger::new(spans, wl.dir.clone(), &c.serial_no, wl.every));
}
let mut m = MergedLogger::new(spans, wl.dir.clone(), wl.every);
m.counters(
&feed.counters().iter().map(|c| c.serial_no.clone()).collect::<Vec<_>>(),
);
merged_log = Some(m);
if wl.export_every.is_some() {
let done = export_pages(&wl.dir, cpm_per_usvh);
table_note = if table_note.is_empty() { done } else { format!("{} {}", table_note, done) };
}
}
let mut exported = Instant::now();
let tubes = feed.width().max(1);
let mut each: Vec<Windows> = (0..tubes).map(|_| Windows::new(spans)).collect();
let mut w = Windows::new(spans);
let mut ladder = Ladder::new();
let mut pools: Vec<entropy::Entropy> =
(0..tubes).map(|_| new_pool()).collect();
let mut merged: std::collections::VecDeque<f64> = std::collections::VecDeque::new();
let mut dropped = 0usize;
let mut sec_bin: Option<i64> = None;
let mut sec_sum: u32 = 0;
let mut shown: Option<(String, String)> = None;
let mut suspect = false;
let mut replaying = !feed.owns_the_port();
if replaying {
table_note = match id.primary() {
Some(c) if tubes == 1 => format!("attached to the counter on {}", c.path),
_ => format!("attached to {} counters", tubes),
};
}
feed.start();
let watching = Instant::now();
let mut out = String::with_capacity(16384);
let mut rows: Vec<(usize, String)> = Vec::new();
loop {
let (who, when, counts) = match feed.next(Duration::from_millis(2500)) {
Some(Tick::Sample { who, when, counts }) => (who, when, counts),
Some(Tick::Row { row }) => {
table.push_back(row.split('\t').map(str::to_string).collect());
while table.len() > TABLE_KEEP {
table.pop_front();
}
continue;
}
Some(Tick::Random { who, hex, at, suspect: s }) => {
shown = Some((hex, at));
suspect = s;
if let Some(p) = pools.get_mut(who) {
p.reset();
}
continue;
}
Some(Tick::Live) => {
replaying = false;
continue;
}
None => break,
};
if stopping() {
break;
}
let who = who.min(tubes - 1);
w.add(when, counts);
each[who].add(when, counts);
if merged.len() >= STRIP_KEEP {
merged.pop_front();
dropped += 1;
}
merged.push_back(counts as f64);
let this = when.floor() as i64;
match sec_bin {
Some(b) if b == this => sec_sum += counts,
Some(_) => {
ladder.add(sec_sum);
sec_bin = Some(this);
sec_sum = counts;
}
None => {
sec_bin = Some(this);
sec_sum = counts;
}
}
if !replaying {
if let Some(p) = pools.get_mut(who) {
p.add_at(when, counts);
}
}
if replaying {
continue;
}
let spec = ladder.best();
if let Some(lg) = loggers.get_mut(who) {
let averages: Vec<Option<f64>> =
spans.iter().map(|s| each[who].average(*s)).collect();
match lg.add(clock::now(), counts, &averages) {
Ok(Some(line)) => {
table.push_back(line.split('\t').map(str::to_string).collect());
while table.len() > TABLE_KEEP {
table.pop_front();
}
rows.push((who, line));
}
Ok(None) => {}
Err(e) => table_note = format!("NOT LOGGING: {}", e),
}
}
if let Some(m) = merged_log.as_mut() {
if let Err(e) = m.add(who, when, counts, &w) {
table_note = format!("NOT LOGGING THE MERGE: {}", e);
}
}
for (k, line) in rows.drain(..) {
feed.publish_row(k, &line);
}
if let Some(wl) = logging.as_ref() {
if let Some(e) = wl.export_every {
if exported.elapsed().as_secs_f64() >= e {
exported = Instant::now();
table_note = export_pages(&wl.dir, cpm_per_usvh);
}
}
}
let (h, width) = screen.size();
let tl = if wants_table { table_lines(h) } else { 0 };
let hv = h - tl;
out.clear();
out.push_str("\x1b[2J");
let head = match (id.primary(), tubes) {
(Some(c), 1) => format!(
"{} @ {} baud {} serial {}",
c.path, c.baud, c.version, c.serial_no
),
(Some(c), n) => format!(
"{} and {} more {} {} tubes averaged",
c.path, n - 1, c.version, n
),
(None, _) => "no counter".to_string(),
};
out.push_str(&format!(
"{}{}{}{}",
at(0, 0), DIM, head, OFF
));
let mut row = 2usize;
for &span in spans {
match mean_cpm(&w, span, tubes) {
None => {
let left = (span - w.elapsed()).max(0.0).round() as i64;
out.push_str(&format!(
"{}{}{:>5}s filling, {}s to go{}",
at(row, 0), DIM, span as i64, left, OFF
));
}
Some(cpm) => {
out.push_str(&format!(
"{}{}{:>5}s{}{}{}{:>8.1} CPM{}{}{:>8.3} uSv/h",
at(row, 0), DIM, span as i64, OFF,
at(row, 7), colour_for(level(cpm)), cpm, OFF,
at(row, 23), cpm / cpm_per_usvh
));
}
}
row += 1;
}
row += 1;
out.push_str(&format!(
"{}{}now{} {} counts this second{}{}run{} {} counts in {}s",
at(row, 0), BOLD, OFF, counts,
at(row + 1, 0), DIM, OFF, w.total, w.elapsed().round() as i64
));
row += 3;
let headline = mean_cpm(&w, 30.0, tubes)
.or_else(|| mean_cpm(&w, *spans.last().unwrap(), tubes));
let digits = big_number(&match headline {
Some(v) => format!("{:.0}", v),
None => "--".to_string(),
});
let left = digits_left(&head);
let reserve = readout_width();
let readout = width >= left + reserve && h > BIG_ROWS;
if readout {
let tint = headline.map(|v| colour_for(level(v))).unwrap_or(DIM);
for (i, d) in digits.iter().enumerate() {
out.push_str(&format!("{}{}{}{}", at(i, left), tint, d, OFF));
}
}
let plate = nameplate();
let busy = if readout { left + reserve } else { head.chars().count() };
if let Some(x) = nameplate_left(width, busy, plate.chars().count()) {
out.push_str(&format!("{}{}{}{}", at(0, x), DIM, plate, OFF));
}
row += 2;
let counts_rows = if hv > row + 12 { 5 } else if hv > row + 8 { 3 } else { 1 };
let series: Vec<f64> = merged.iter().copied().collect();
let strip = if tubes > 1 {
analysis::tiers_interleaved(&series, dropped, width - 1, tubes)
} else {
analysis::tiers_with(&series, dropped, width - 1, spec.window, analysis::TIERS, 1.0)
};
let peak = strip
.iter()
.flat_map(|t| t.values.iter().flatten())
.cloned()
.fold(0.0f64, f64::max);
let every = logging.as_ref().map(|wl| wl.every.round().max(1.0) as i64);
let n = (dropped + series.len()) as i64;
let mut x0 = 0;
for (ti, tier) in strip.iter().enumerate() {
for (i, line) in bar_rows_to(&tier.values, counts_rows, peak).iter().enumerate() {
out.push_str(&at(row + i, x0));
let mut pen = "";
for (x, &g) in line.iter().enumerate() {
if g == ' ' {
out.push(' ');
continue;
}
let rate = tier.values[x].unwrap_or(0.0) * 60.0;
let want = colour_for(level(rate));
if want != pen {
out.push_str(want);
pen = want;
}
out.push(g);
}
out.push_str(OFF);
}
if row >= 1 && tier.columns > 2 {
let label = format!(
"{}{}s/bar \u{b7} {}",
if ti == 0 { "" } else { "F " },
analysis::bar_seconds(tier.seconds),
analysis::span_words(tier.columns as f64 * tier.seconds)
);
let label: String = label.chars().take(tier.columns - 1).collect();
let used = label.chars().count();
out.push_str(&format!("{}{}{}{}", at(row - 1, x0), DIM, label, OFF));
if let (Some(e), true) = (every, tier.seconds == 1.0) {
for j in used + 1..tier.columns {
let a = n - tier.columns as i64 + j as i64;
if a > 0 && a % e == 0 {
out.push_str(&format!("{}{}\u{a6}{}", at(row - 1, x0 + j), DIM, OFF));
}
}
}
}
x0 += tier.columns;
}
row += counts_rows + 1;
let mut footer = String::new();
let rel = spec.relative();
if rel.is_empty() {
footer = format!(
"spectrum accumulating, {}s to the first window of {}",
spec.wait(), spec.window
);
} else if hv > row + 4 {
let cols = spectrum_columns(&rel, width - 1);
let (top, where_) = spec.loudest();
let luck = spec.chance_max();
footer = if top < luck * 1.25 {
format!(
"spectrum flat -- arrivals look random, as decay should ({} windows)",
spec.runs
)
} else {
format!(
"spectrum peak at {:.0}s, {:.1}x the mean (chance gives {:.1}x), {:.1} sigma ({} windows)",
spec.period(where_), top, luck, spec.sigma(top), spec.runs
)
};
let bars = if hv > row + 9 { 5 } else if hv > row + 7 { 3 } else { 1 };
for (i, line) in bar_rows(&cols, cols.len(), bars).iter().enumerate() {
out.push_str(&at(row + i, 0));
let mut pen = "";
for (x, &g) in line.iter().enumerate() {
if g == ' ' {
out.push(' ');
continue;
}
let v = cols[x];
let want = if v >= luck * 2.0 { RED } else if v >= luck * 1.25 { YELLOW } else { CYAN };
if want != pen {
out.push_str(want);
pen = want;
}
out.push(g);
}
out.push_str(OFF);
}
row += bars;
let lo = format!("{}s", spec.window);
let gap = (width - 1).saturating_sub(lo.len() + 2);
out.push_str(&format!("{}{}{}{}2s{}", at(row, 0), DIM, lo, " ".repeat(gap), OFF));
}
if hv > row + 2 && width > 84 {
row += 1;
let ready = if feed.owns_the_port() {
pools.iter().position(|p| p.ready())
} else {
None
};
if let Some(k) = ready {
let (top, _) = spec.loudest();
suspect = top > 0.0 && top >= spec.chance_max() * 1.25;
let keep = logging.as_ref().map(|w| w.frames).unwrap_or(false);
let frame = keep.then(|| pools[k].frame(pools[k].seq, suspect));
let (text, record) = pools[k].draw();
let at_time = clock::format(clock::now(), "%H:%M:%S");
let serial = id.counters.get(k).map(|c| c.serial_no.as_str()).unwrap_or("");
if let Some(wl) = logging.as_ref() {
let _ = entropy::write_record(&wl.dir, &record, serial, suspect);
if let Some(f) = frame.as_ref() {
let _ = entropy::write_frame(&wl.dir, f, serial);
}
}
feed.publish_random(k, &text, &at_time, suspect);
shown = Some((text.clone(), at_time));
}
match &shown {
Some((text, at_time)) => {
out.push_str(&format!("{}{}random {}{}",
at(row, 0), CYAN,
entropy::group_hex(text), OFF));
if hv > row + 2 {
let note = format!(
"{} bits from decay at {} {}{}",
entropy::ENTROPY_BITS as i64, at_time,
entropy::pool_status(&pools[0], "next in "),
if suspect {
" -- SPECTRUM NOT FLAT, treat as suspect"
} else {
""
}
);
out.push_str(&format!("{}{}{}{}", at(row + 1, 9),
if suspect { YELLOW } else { DIM },
note, OFF));
}
}
None => out.push_str(&format!(
"{}{}random {}{}", at(row, 0), DIM,
entropy::pool_status(&pools[0], "next in "), OFF
)),
}
let clock_row = if tl > 0 {
h.saturating_sub(3 + tl).max(row + 2)
} else {
row + 2
};
if clock_row < hv.saturating_sub(2) {
out.push_str(&format!("{}{}clock{} {}", at(clock_row, 0), DIM, OFF,
clock::format(clock::now(), "%Y-%m-%d %H:%M:%S")));
match feed.watchers() {
0 => {}
1 => out.push_str(&format!("{}{}1 attached{}", at(clock_row, 24), DIM, OFF)),
n => out.push_str(&format!("{}{}{} attached{}", at(clock_row, 24), DIM, n, OFF)),
}
if !table_note.is_empty() && width > 40 + table_note.len() {
let tint = if table_note.starts_with("NOT") { YELLOW } else { DIM };
out.push_str(&format!("{}{}{}{}", at(clock_row, 32), tint, table_note, OFF));
}
}
}
if tl > 0 {
draw_table(&mut out, h - 2 - tl, tl, width, &names, &table);
}
if h >= 2 {
out.push_str(&format!("{}{}{}{}", at(h - 2, 0), DIM, footer, OFF));
out.push_str(&format!("{}{}q to quit{}", at(h - 1, 0), DIM, OFF));
}
print!("{}", out);
let _ = std::io::stdout().flush();
if screen.quit_pressed() {
break;
}
if let Some(d) = duration {
if watching.elapsed().as_secs_f64() >= d {
break;
}
}
}
for (k, lg) in loggers.iter_mut().enumerate() {
let averages: Vec<Option<f64>> = spans.iter().map(|s| each[k].average(*s)).collect();
lg.finish(&averages);
}
if let Some(m) = merged_log.as_mut() {
m.finish(&w);
}
if let Some(wl) = logging.as_ref() {
if wl.export_every.is_some() {
export_pages(&wl.dir, cpm_per_usvh);
}
}
feed.stop();
}
const TABLE_KEEP: usize = 200;
#[allow(clippy::too_many_arguments)]
fn service(spans: &[f64], every: f64, duration: Option<f64>,
devices: &[String], baud: Option<u32>,
logs: Option<std::path::PathBuf>,
backfill: Option<(usize, f64)>, frames: bool) -> i32 {
install_stop_handler();
let dir = logs.unwrap_or_else(log::state_dir);
let _ = std::fs::create_dir_all(&dir);
let started = clock::now();
let mut waiting = false;
let found = loop {
let (found, why) = counter::find_all(devices, baud);
match why {
None => break found,
Some(e) => {
if !e.busy {
let path = log::write_status(&dir, &format!("dormant: {}", e.reason));
println!("radbeeper: dormant -- {}", e.reason);
for line in e.detail.lines() {
println!(" {}", line);
}
println!(" status: {}", path.display());
println!(" it will look again at the next boot, or when you \
run: rc-service radbeeper start");
return 0;
}
if !waiting {
waiting = true;
log::write_status(&dir, &format!("waiting: {}", e.reason));
println!("radbeeper: waiting -- {}", e.reason);
println!(" Logging starts by itself when the port is free.");
}
let mut slept = 0.0;
while slept < SERVICE_WAIT {
if stopping() {
return 0;
}
if duration.map(|d| clock::now() - started >= d).unwrap_or(false) {
return 0;
}
std::thread::sleep(Duration::from_millis(500));
slept += 0.5;
}
}
}
};
if let Some((bytes, max_gap)) = backfill {
log::write_status(&dir, "backfilling from the counters' history");
for c in &found {
println!("radbeeper: {}",
backfill_at_start(c, &dir, spans, every, bytes, max_gap, false));
}
}
let tubes = found.len();
log::write_status(&dir, &format!(
"monitoring {} ({})",
found.iter().map(|c| c.path.as_str()).collect::<Vec<_>>().join(", "),
found.iter().map(|c| c.version.as_str()).collect::<Vec<_>>().join(", ")
));
let mut bank = Bank::open(found);
let id = bank.identity(spans);
let mut each: Vec<Windows> = (0..tubes).map(|_| Windows::new(spans)).collect();
let mut loggers: Vec<Logger> = id
.counters
.iter()
.map(|c| Logger::new(spans, dir.clone(), &c.serial_no, every))
.collect();
let mut all = Windows::new(spans);
let mut merged_log = MergedLogger::new(spans, dir.clone(), every);
merged_log.counters(
&id.counters.iter().map(|c| c.serial_no.clone()).collect::<Vec<_>>(),
);
let mut srv = match broker::Server::start(&dir, &id) {
Ok(s) => Some(s),
Err(e) => {
eprintln!("radbeeper: not serving the stream -- {}", e);
eprintln!(" the log is unaffected; a monitor will need the port itself");
None
}
};
let mut pools: Vec<entropy::Entropy> =
(0..tubes).map(|_| new_pool()).collect();
let mut ladder = Ladder::new();
let mut sec_bin: Option<i64> = None;
let mut sec_sum: u32 = 0;
if let Some(s) = srv.as_mut() {
let names = log::columns(&log::header(spans));
let mut seed: Vec<(usize, String)> = Vec::new();
for (k, c) in id.counters.iter().enumerate() {
let path = log::path(clock::now(), &dir, Some(&c.serial_no));
for (_, cells) in
log::read_table(&path, &names).into_iter().rev().take(TABLE_KEEP).rev()
{
seed.push((k, cells.join("\t")));
}
}
s.seed_rows(seed.into_iter());
}
let here = log::site_at(
id.counters.first().map(|c| c.serial_no.as_str()).unwrap_or(""),
clock::now(),
&loggers.first().map(|l| l.sites.clone()).unwrap_or_default(),
);
for c in &id.counters {
println!("radbeeper: monitoring {} -- {}", c.path, c.version);
println!("radbeeper: counter {} logging to {}", c.serial_no,
log::path(clock::now(), &dir, Some(&c.serial_no)).display());
}
if id.counters.len() > 1 {
println!("radbeeper: the room, merged, to {}",
log::path(clock::now(), &dir, Some(log::MERGED)).display());
}
println!("radbeeper: {} at {}", if tubes == 1 { "counter" } else { "counters" },
here.unwrap_or_else(|| "an unrecorded place".to_string()));
println!("radbeeper: a row every {}s", log::g(every));
if let Some(s) = srv.as_ref() {
println!("radbeeper: serving the stream on {}", s.socket().display());
println!("radbeeper: a monitor attaches to it -- the ports stay here");
}
bank.start();
let mut swept = clock::now();
loop {
if let Some(s) = srv.as_mut() {
s.accept_pending();
}
if stopping() {
break;
}
if duration.map(|d| clock::now() - started >= d).unwrap_or(false) {
break;
}
if clock::now() - swept >= RESCAN {
swept = clock::now();
let held = bank.live_paths();
let ports: Vec<String> = if devices.is_empty() {
counter::candidate_ports()
} else {
devices.to_vec()
};
for port in ports.into_iter().filter(|p| !held.contains(p)) {
let Some(c) = counter::open_at(&port, baud) else { continue };
let (path, version, serial) =
(c.path.clone(), c.version.clone(), c.serial_no.clone());
let who = bank.adopt(c);
if let Some((bytes, max_gap)) = backfill {
if let Some(k) = bank.counters.get(who).and_then(|c| c.clone()) {
println!("radbeeper: {}",
backfill_at_start(&k, &dir, spans, every, bytes, max_gap, false));
}
}
if who == each.len() {
each.push(Windows::new(spans));
pools.push(new_pool());
loggers.push(Logger::new(spans, dir.clone(), &serial, every));
} else {
each[who] = Windows::new(spans);
}
let id = bank.identity(spans);
merged_log.counters(
&id.counters.iter().map(|c| c.serial_no.clone()).collect::<Vec<_>>(),
);
if let (Some(s), Some(c)) = (srv.as_mut(), id.counters.get(who)) {
s.announce(who, c);
}
log::write_status(&dir, &format!("monitoring {} ({})", path, version));
println!("radbeeper: {} joined -- {} ({})", path, version, serial);
}
}
let (who, when, counts) = match bank.next(Duration::from_millis(2500)) {
Some(Tube::Sample { who, when, counts }) => (who, when, counts),
Some(Tube::Gone { who }) => {
bank.retire(who);
if let Some(s) = srv.as_mut() {
s.publish_gone(who);
}
let name = bank.ids.get(who).map(|c| c.path.clone()).unwrap_or_default();
println!("radbeeper: {} stopped answering -- waiting for it", name);
log::write_status(&dir, &format!("waiting: {} stopped answering", name));
continue;
}
None => continue,
};
each[who].add(when, counts);
all.add(when, counts);
if let Some(s) = srv.as_mut() {
s.publish_sample(who, when, counts);
}
let this = when.floor() as i64;
match sec_bin {
Some(b) if b == this => sec_sum += counts,
Some(_) => {
ladder.add(sec_sum);
sec_bin = Some(this);
sec_sum = counts;
}
None => {
sec_bin = Some(this);
sec_sum = counts;
}
}
pools[who].add_at(when, counts);
if pools[who].ready() {
let spec = ladder.best();
let (top, _) = spec.loudest();
let suspect = top > 0.0 && top >= spec.chance_max() * 1.25;
let frame = frames.then(|| pools[who].frame(pools[who].seq, suspect));
let (text, record) = pools[who].draw();
let at_time = clock::format(clock::now(), "%H:%M:%S");
let _ = entropy::write_record(&dir, &record, &id.counters[who].serial_no, suspect);
if let Some(f) = frame.as_ref() {
if let Err(e) = entropy::write_frame(&dir, f, &id.counters[who].serial_no) {
eprintln!("radbeeper: could not write the frame -- {}", e);
}
}
if let Some(s) = srv.as_mut() {
s.publish_random(who, &text, &at_time, suspect);
}
}
let averages: Vec<Option<f64>> =
spans.iter().map(|s| each[who].average(*s)).collect();
match loggers[who].add(when, counts, &averages) {
Ok(Some(line)) => {
if let Some(s) = srv.as_mut() {
s.publish_row(who, &line);
}
}
Ok(None) => {}
Err(e) => {
eprintln!("radbeeper: could not write the log -- {}", e);
break;
}
}
if let Err(e) = merged_log.add(who, when, counts, &all) {
eprintln!("radbeeper: could not write the merged log -- {}", e);
}
}
for (k, lg) in loggers.iter_mut().enumerate() {
let averages: Vec<Option<f64>> = spans.iter().map(|s| each[k].average(*s)).collect();
lg.finish(&averages);
}
merged_log.finish(&all);
bank.stop();
log::write_status(&dir, "stopped");
0
}
fn backfill_at_start(c: &counter::Counter, dir: &Path, spans: &[f64], every: f64,
bytes: usize, max_gap: f64, quiet: bool) -> String {
let offset = measure_clock_offset(c).unwrap_or(0.0);
let blob = read_history_tail(c, bytes, quiet);
if blob.is_empty() {
return "backfill skipped -- the counter returned no history".to_string();
}
let sites = log::read_sites(dir);
let r = history::backfill(&blob, spans, every, max_gap, offset, dir,
Some(c.serial_no.as_str()), &sites, None);
format!("backfill -- {} samples, {} rows, {} added, {} already logged",
r.samples, r.rows, r.added, r.clashed)
}
struct Logger {
dir: PathBuf,
serial: String,
every: f64,
out: log::Writer,
iv: log::Interval,
due: Option<f64>,
sites: Vec<(String, f64, String)>,
sites_mtime: Option<u64>,
}
impl Logger {
fn new(spans: &[f64], dir: PathBuf, serial: &str, every: f64) -> Logger {
let sites = log::read_sites(&dir);
let sites_mtime = mtime_of(&dir.join("sites.tsv"));
Logger {
out: log::Writer::new(spans, dir.clone(), Some(serial.to_string()), every),
iv: log::Interval::new(spans.len()),
dir,
serial: serial.to_string(),
every,
due: None,
sites,
sites_mtime,
}
}
fn add(&mut self, when: f64, counts: u32, averages: &[Option<f64>])
-> std::io::Result<Option<String>>
{
self.iv.add(counts, averages, 1.0);
let due = *self.due.get_or_insert(when + self.every);
if when < due {
return Ok(None);
}
let line = self.row(averages);
let wrote = self.out.write(clock::now(), &line)?;
self.iv.reset();
self.due = Some(when + self.every);
Ok(wrote.then_some(line))
}
fn finish(&mut self, averages: &[Option<f64>]) {
if self.iv.seconds > 0.0 {
let line = self.row(averages);
let _ = self.out.write(clock::now(), &line);
}
self.out.close();
}
fn row(&mut self, averages: &[Option<f64>]) -> String {
let now = clock::now();
let m = mtime_of(&self.dir.join("sites.tsv"));
if m != self.sites_mtime {
self.sites_mtime = m;
self.sites = log::read_sites(&self.dir);
}
let site = log::site_at(&self.serial, now, &self.sites).unwrap_or_default();
log::row(now, self.iv.cps(), self.iv.counts, self.iv.seconds,
averages, &self.iv.peaks, log::SRC_LIVE, &site)
}
}
struct MergedLogger {
dir: PathBuf,
spans: Vec<f64>,
every: f64,
out: log::Writer,
serials: Vec<String>,
counts: u64,
per_tube: Vec<u64>,
tube_seconds: f64,
wall: BTreeSet<i64>,
seen: BTreeSet<usize>,
peaks: Vec<Option<f64>>,
prev: Option<(usize, f64)>,
gap: (f64, u32),
due: Option<f64>,
sites: Vec<(String, f64, String)>,
sites_mtime: Option<u64>,
}
impl MergedLogger {
fn new(spans: &[f64], dir: PathBuf, every: f64) -> MergedLogger {
let sites = log::read_sites(&dir);
let sites_mtime = mtime_of(&dir.join("sites.tsv"));
MergedLogger {
out: log::Writer::merged(spans, dir.clone(), every),
spans: spans.to_vec(),
dir,
every,
serials: Vec::new(),
counts: 0,
per_tube: Vec::new(),
tube_seconds: 0.0,
wall: BTreeSet::new(),
seen: BTreeSet::new(),
peaks: vec![None; spans.len()],
prev: None,
gap: (0.0, 0),
due: None,
sites,
sites_mtime,
}
}
fn counters(&mut self, serials: &[String]) {
self.serials = serials.to_vec();
self.per_tube.resize(serials.len(), 0);
}
fn add(&mut self, who: usize, when: f64, counts: u32, all: &Windows)
-> std::io::Result<Option<String>>
{
if !self.worth_keeping() {
self.reset();
self.due = None;
return Ok(None);
}
self.seen.insert(who);
self.counts += counts as u64;
if self.per_tube.len() <= who {
self.per_tube.resize(who + 1, 0);
}
self.per_tube[who] += counts as u64;
self.tube_seconds += 1.0;
self.wall.insert(when.floor() as i64);
let tubes = self.tubes();
if let Some((prev, t)) = self.prev {
if prev != who && when > t {
self.gap.0 += when - t;
self.gap.1 += 1;
}
}
self.prev = Some((who, when));
for (i, span) in self.spans.iter().enumerate() {
if let Some(v) = mean_of(all, *span, tubes) {
let slot = &mut self.peaks[i];
if slot.is_none() || v > slot.unwrap() {
*slot = Some(v);
}
}
}
let due = *self.due.get_or_insert(when + self.every);
if when < due {
return Ok(None);
}
let line = self.row(all);
let wrote = self.out.write(clock::now(), &line)?;
self.reset();
self.due = Some(when + self.every);
Ok(wrote.then_some(line))
}
fn worth_keeping(&self) -> bool {
self.serials.len() > 1
}
fn finish(&mut self, all: &Windows) {
if self.worth_keeping() && !self.wall.is_empty() {
let line = self.row(all);
let _ = self.out.write(clock::now(), &line);
}
self.out.close();
}
fn reset(&mut self) {
self.counts = 0;
for c in self.per_tube.iter_mut() {
*c = 0;
}
self.tube_seconds = 0.0;
self.wall.clear();
self.seen.clear();
for p in self.peaks.iter_mut() {
*p = None;
}
self.gap = (0.0, 0);
}
fn tubes(&self) -> usize {
if self.seen.is_empty() {
self.serials.len().max(1)
} else {
self.seen.len()
}
}
fn row(&mut self, all: &Windows) -> String {
let now = clock::now();
let tubes = self.tubes();
let m = mtime_of(&self.dir.join("sites.tsv"));
if m != self.sites_mtime {
self.sites_mtime = m;
self.sites = log::read_sites(&self.dir);
}
let site = self
.serials
.first()
.and_then(|s| log::site_at(s, now, &self.sites))
.unwrap_or_default();
let averages: Vec<Option<f64>> =
self.spans.iter().map(|s| mean_of(all, *s, tubes)).collect();
let sigma = mean_of(all, HEADLINE_SPAN, tubes)
.and_then(|v| sigma_of(v, HEADLINE_SPAN, tubes));
let per_tube: Vec<(String, u64)> = self
.per_tube
.iter()
.enumerate()
.map(|(k, n)| {
let name = self
.serials
.get(k)
.cloned()
.unwrap_or_else(|| format!("tube{}", k));
(name, *n)
})
.collect();
log::merged_row(
now,
tubes,
(self.gap.1 > 0).then(|| self.gap.0 / self.gap.1 as f64),
self.counts,
self.wall.len() as f64,
self.tube_seconds,
&averages,
sigma,
&self.peaks,
&per_tube,
log::SRC_LIVE,
&site,
)
}
}
const HEADLINE_SPAN: f64 = 30.0;
fn mean_of(w: &Windows, span: f64, tubes: usize) -> Option<f64> {
w.average(span).map(|v| v / tubes.max(1) as f64)
}
fn sigma_of(cpm: f64, span: f64, tubes: usize) -> Option<f64> {
let n = cpm * span * tubes.max(1) as f64 / 60.0;
(n > 0.0).then(|| cpm / n.sqrt())
}
fn mtime_of(path: &std::path::Path) -> Option<u64> {
use std::os::unix::fs::MetadataExt;
std::fs::metadata(path).ok().map(|m| m.mtime() as u64)
}
static WANT_BITS: std::sync::OnceLock<f64> = std::sync::OnceLock::new();
fn new_pool() -> entropy::Entropy {
entropy::Entropy::new(*WANT_BITS.get().unwrap_or(&entropy::ENTROPY_BITS))
}
static STOP: AtomicBool = AtomicBool::new(false);
fn install_stop_handler() {
extern "C" fn handler(_sig: libc::c_int) {
STOP.store(true, Ordering::Relaxed);
}
let f: extern "C" fn(libc::c_int) = handler;
unsafe {
libc::signal(libc::SIGTERM, f as usize as libc::sighandler_t);
libc::signal(libc::SIGINT, f as usize as libc::sighandler_t);
}
}
fn stopping() -> bool {
STOP.load(Ordering::Relaxed)
}
enum Verdict {
Retry,
Give,
Expired(String),
}
fn wait_verdict(e: &counter::NotFound, waited: f64, limit: f64) -> Verdict {
if !e.busy {
return Verdict::Give;
}
if waited >= limit {
return Verdict::Expired(format!(
"Waited {}s for the port and it never came free.",
log::g(limit)));
}
Verdict::Retry
}
fn restore_stop_default() {
unsafe {
libc::signal(libc::SIGTERM, libc::SIG_DFL);
libc::signal(libc::SIGINT, libc::SIG_DFL);
}
}
fn find_waiting(device: Option<&str>, baud: Option<u32>, limit: f64)
-> Result<counter::Counter, counter::NotFound> {
install_stop_handler();
let started = clock::now();
let mut said = false;
loop {
let e = match counter::find(device, baud) {
Ok(c) => {
restore_stop_default();
if stopping() {
println!("radbeeper: stopped waiting.");
std::process::exit(1);
}
if said {
println!("radbeeper: the port came free.");
}
return Ok(c);
}
Err(e) => e,
};
match wait_verdict(&e, clock::now() - started, limit) {
Verdict::Give => {
restore_stop_default();
return Err(e);
}
Verdict::Expired(note) => {
restore_stop_default();
let mut e = e;
e.detail = format!("{}\n{}", e.detail, note);
return Err(e);
}
Verdict::Retry => {}
}
if !said {
said = true;
let how_long = if limit.is_finite() {
format!(" up to {}s", log::g(limit))
} else {
String::new()
};
println!("radbeeper: the port is busy -- waiting{} for it. \
Ctrl-C to stop.", how_long);
}
if stopping() {
println!("radbeeper: stopped waiting -- the port is still busy.");
std::process::exit(1);
}
std::thread::sleep(Duration::from_secs_f64(WAIT_POLL));
}
}
fn random(spans: &[f64], duration: Option<f64>, device: Option<&str>,
baud: Option<u32>, logs: Option<std::path::PathBuf>) -> i32 {
install_stop_handler();
let c = match counter::find(device, baud) {
Ok(c) => c,
Err(e) => {
eprintln!("{}: {}",
if e.busy { "port busy" } else { "no counter" }, e.reason);
return 1;
}
};
let want = entropy::ENTROPY_BITS;
let mut pool = entropy::Entropy::new(want);
let mut ladder = Ladder::new();
println!("radbeeper: collecting {} bits from {}", want as i64, c.path);
c.heartbeat(true);
let started = clock::now();
while !pool.ready() {
let counts = match c.next_sample(Duration::from_millis(2500)) {
Some(v) => v as u32,
None => break,
};
pool.add(counts);
ladder.add(counts);
if stopping() {
break;
}
if duration.map(|d| clock::now() - started >= d).unwrap_or(false) {
break;
}
}
c.heartbeat(false);
if !pool.ready() {
eprintln!("radbeeper: only {:.0} of {} bits -- {}",
pool.bits(), want as i64,
if duration.is_some() { "stopped early" } else { "interrupted" });
return 1;
}
let spec = ladder.best();
let (top, _) = spec.loudest();
let suspect = top > 0.0 && top >= spec.chance_max() * 1.25;
let modelled = pool.model_bits();
let seconds = pool.counts.len();
let rate = pool.rate();
let (text, record) = pool.draw();
println!();
println!("{}", entropy::group_hex(&text));
println!();
println!(" {} bits, min-entropy {:.0} measured, from {} seconds at {:.2} \
counts/s", want as i64, record.bits, seconds, rate);
println!(" {:.0} bits is what a Poisson model would have claimed for the \
same {} seconds", modelled, seconds);
println!(" spectrum {}", if suspect {
"NOT FLAT -- something periodic; treat as suspect"
} else {
"flat -- the source looks like decay"
});
let dir = logs.unwrap_or_else(log::state_dir);
match entropy::write_record(&dir, &record, &c.serial_no, suspect) {
Ok(p) => println!(" recorded in {}", p.display()),
Err(e) => println!(" not recorded: {}", e),
}
let _ = spans;
0
}
fn frames_report(path: &std::path::Path) -> i32 {
let frames = entropy::read_frames(path);
if frames.is_empty() {
eprintln!("radbeeper: no frames in {}", path.display());
return 1;
}
let bytes = std::fs::metadata(path).map(|m| m.len()).unwrap_or(0);
let mut bad = 0;
let mut samples = 0usize;
for f in &frames {
let counts = f.counts();
let ok = f.verifies();
if !ok {
bad += 1;
}
samples += counts.len();
let holes = f.samples.iter().skip(1).filter(|(g, _)| *g != 1).count();
println!(
" seq {:<4} {:<20} {:>5}s {:>5} samples peak {:>5} {:.3} bits/s {}{}",
f.seq,
clock::stamp(f.started as f64),
f.seconds(),
counts.len(),
counts.iter().copied().max().unwrap_or(0),
entropy::mcv_min_entropy(&counts),
if ok { "recomputes" } else { "DOES NOT RECOMPUTE" },
if holes == 0 {
String::new()
} else {
format!(" ({} gap{})", holes, if holes == 1 { "" } else { "s" })
}
);
if f.suspect {
println!(" spectrum was not flat when this was drawn -- suspect");
}
}
println!(
"radbeeper: {} of {} frames recompute from their own seconds",
frames.len() - bad,
frames.len()
);
println!(
"radbeeper: {} seconds of counts in {} bytes -- {:.2} bytes a second",
samples,
bytes,
if samples > 0 { bytes as f64 / samples as f64 } else { 0.0 }
);
if bad > 0 { 1 } else { 0 }
}
fn check_random(path: &std::path::Path) -> i32 {
let pools = entropy::read_emissions(path);
if pools.is_empty() {
eprintln!("radbeeper: no emissions in {}", path.display());
return 1;
}
let mut bad = 0;
for p in &pools {
let started = clock::parse_stamp(&p.time).unwrap_or(0.0);
let ok = entropy::check_record(p.seq, started, &p.counts, &p.hex);
if !ok {
bad += 1;
}
println!(" seq {:<4} {:<20} {:>4}s {:.3} bits/s {}",
p.seq, p.time, p.seconds,
entropy::mcv_min_entropy(&p.counts),
if ok { "recomputes" } else { "DOES NOT RECOMPUTE" });
}
println!("radbeeper: {} of {} emissions recompute from their own counts",
pools.len() - bad, pools.len());
if bad > 0 { 1 } else { 0 }
}
fn first_mark_time(c: &counter::Counter, address: usize, probe: usize)
-> Option<f64>
{
let chunk = c.read_history(address, probe);
history::raw(&chunk).find_map(|r| match r {
history::Raw::Mark { when, .. } => Some(when),
_ => None,
})
}
fn find_history_end(c: &counter::Counter, size: usize) -> (usize, bool) {
const PROBE: usize = 2048;
let tail = c.read_history(size.saturating_sub(PROBE), PROBE);
if !tail.iter().any(|b| *b != 0xFF) {
if !c.read_history(0, PROBE).iter().any(|b| *b != 0xFF) {
return (0, false);
}
let (mut lo, mut hi) = (0usize, size);
while hi - lo > PROBE {
let mid = (lo + hi) / 2;
if c.read_history(mid, PROBE).iter().any(|b| *b != 0xFF) {
lo = mid;
} else {
hi = mid;
}
}
let window = c.read_history(lo, PROBE * 2);
let last = window.iter().rposition(|b| *b != 0xFF);
return (last.map(|j| lo + j + 1).unwrap_or(lo), false);
}
let start = match first_mark_time(c, 0, PROBE) {
Some(t) => t,
None => return (size, true), };
let (mut lo, mut hi) = (0usize, size);
while hi - lo > PROBE {
let mid = (lo + hi) / 2;
match first_mark_time(c, mid, PROBE) {
Some(seen) if seen < start => hi = mid,
_ => lo = mid,
}
}
let window = c.read_history(lo, PROBE * 2);
for r in history::raw(&window) {
if let history::Raw::Mark { off, when } = r {
if when < start {
return (lo + off, true);
}
}
}
(lo + PROBE, true)
}
fn read_history_tail(c: &counter::Counter, want: usize, quiet: bool) -> Vec<u8> {
let size = c.flash_size();
if size == 0 {
return Vec::new();
}
let (end, wrapped) = find_history_end(c, size);
if end == 0 {
return Vec::new();
}
if !quiet {
println!("radbeeper: newest history at {} KiB of {} KiB{}; reading {} KiB",
end / 1024, size / 1024,
if wrapped { " (wrapped)" } else { "" },
want.min(size) / 1024);
}
if want <= end {
return c.read_history(end - want, want);
}
let head = c.read_history(0, end);
if !wrapped {
return head;
}
let over = (want - end).min(size - end);
let mut out = c.read_history(size - over, over);
out.extend_from_slice(&head);
out
}
fn measure_clock_offset(c: &counter::Counter) -> Option<f64> {
c.clock_ahead().map(|o| -o.ahead)
}
fn describe_offset(o: &counter::ClockOffset) -> String {
let within = if o.within < 0.1 {
format!("\u{b1}{:.2} s", o.within)
} else {
format!("\u{b1}{:.1} s", o.within)
};
if o.ahead.abs() <= o.within.max(0.05) {
return format!("matches this machine ({})", within);
}
let (n, way) = if o.ahead > 0.0 { (o.ahead, "ahead of") } else { (-o.ahead, "behind") };
let size = if n >= 10.0 { format!("{:.1} s", n) } else { format!("{:.2} s", n) };
format!("{} {} this machine ({})", size, way, within)
}
fn system_clock_synced() -> bool {
let mut t: libc::timex = unsafe { std::mem::zeroed() };
unsafe { libc::adjtimex(&mut t) != libc::TIME_ERROR }
}
fn clock_cmd(c: &counter::Counter, set: bool) -> i32 {
let before = match c.clock_ahead() {
Some(o) => o,
None => {
eprintln!("radbeeper: the counter did not answer <GETDATETIME>>");
return 1;
}
};
let synced = system_clock_synced();
println!("its clock {}", clock::format(before.theirs, "%Y-%m-%d %H:%M:%S"));
println!(" {}", describe_offset(&before));
println!("this machine {}", if synced {
"synchronised (the kernel says NTP is steering it)"
} else {
"NOT synchronised -- nothing is steering this clock"
});
if !set {
if before.ahead.abs() > 1.0 {
println!(" radbeeper clock --set corrects it from this machine");
}
return 0;
}
if !synced {
println!(" setting anyway: the counter will be as right as this machine is");
}
let mut lead = 0.0f64;
let mut after = None;
for _ in 0..2 {
let now = clock::now();
let target = now.floor() + 2.0;
let wait = target - lead - clock::now();
if wait > 0.0 {
std::thread::sleep(Duration::from_secs_f64(wait));
}
if !c.set_clock(target) {
eprintln!("radbeeper: the counter did not acknowledge <SETDATETIME>>");
return 1;
}
after = c.clock_ahead();
match after {
Some(o) if o.ahead.abs() > o.within.max(0.05) => {
lead = (lead - o.ahead).clamp(-0.9, 0.9);
}
_ => break,
}
}
let after = match after {
Some(o) => o,
None => {
eprintln!("radbeeper: set, but the counter did not answer the check");
return 1;
}
};
println!("set {}", clock::format(after.theirs, "%Y-%m-%d %H:%M:%S"));
println!(" {}", describe_offset(&after));
if before.ahead.abs() >= 1.0 {
println!();
println!(" history the counter recorded before now carries the old clock, {:.0} s",
before.ahead.abs());
println!(" {}. A backfill applies one offset to everything it reads, so rows",
if before.ahead > 0.0 { "ahead" } else { "behind" });
println!(" it rebuilds from before this moment will be out by that much.");
}
0
}
#[allow(clippy::too_many_arguments)]
fn backfill_cmd(spans: &[f64], every: f64, max_gap: f64, bytes: usize,
device: Option<&str>, baud: Option<u32>,
logs: Option<std::path::PathBuf>, image: Option<&std::path::Path>,
serial_arg: Option<&str>, one_file: Option<&str>)
-> i32
{
let dir = logs.unwrap_or_else(log::state_dir);
let _ = std::fs::create_dir_all(&dir);
let (blob, offset, serial) = match image {
Some(p) => match std::fs::read(p) {
Ok(b) => match serial_arg {
Some(sn) => (b, 0.0, sn.to_string()),
None => {
eprintln!("radbeeper: --serial is how a dumped image says \
which counter it came from");
return 1;
}
},
Err(e) => {
eprintln!("radbeeper: cannot read {} -- {}", p.display(), e);
return 1;
}
},
None => {
let c = match counter::find(device, baud) {
Ok(c) => c,
Err(e) => {
eprintln!("no counter: {}", e.reason);
return 1;
}
};
let off = measure_clock_offset(&c).unwrap_or(0.0);
let b = read_history_tail(&c, bytes, false);
(b, off, c.serial_no.clone())
}
};
if blob.is_empty() {
eprintln!("radbeeper: nothing to read");
return 1;
}
let sites = log::read_sites(&dir);
let serial_opt = if serial.is_empty() { None } else { Some(serial.as_str()) };
let r = history::backfill(&blob, spans, every, max_gap, offset, &dir,
serial_opt, &sites, one_file.map(std::path::Path::new));
if r.samples == 0 {
println!("radbeeper: no placeable samples in the history read");
return 0;
}
println!("radbeeper: {} samples, {} rows, {} added, {} already logged",
r.samples, r.rows, r.added, r.clashed);
if let (Some(a), Some(b)) = (r.first, r.last) {
println!(" {} .. {}", clock::stamp(a), clock::stamp(b));
}
println!(" clock offset {:+.0}s, {} hole{}", offset, r.holes,
if r.holes == 1 { "" } else { "s" });
for f in &r.files {
println!(" {}", f.display());
}
0
}
fn log_cmd(action: &str, bytes: Option<usize>, out_stem: Option<&str>,
device: Option<&str>, baud: Option<u32>) -> i32 {
let c = match counter::find(device, baud) {
Ok(c) => c,
Err(e) => {
eprintln!("no counter: {}", e.reason);
return 1;
}
};
if action == "info" {
println!("model {}", c.model());
println!("flash {} KiB", c.flash_size() / 1024);
println!("pull it radbeeper log pull -o FILE");
return 0;
}
let size = bytes.unwrap_or_else(|| c.flash_size());
let stem = match out_stem {
Some(s) => s.to_string(),
None => log::state_dir()
.join(format!("history-{}", clock::format(clock::now(), "%Y%m%d-%H%M%S")))
.display()
.to_string(),
};
println!("reading {} KiB of history from {}", size / 1024, c.path);
let got = c.read_history(0, size);
if got.is_empty() {
eprintln!("the counter returned nothing");
return 1;
}
let raw_path = format!("{}.bin", stem);
let csv_path = format!("{}.csv", stem);
if let Err(e) = std::fs::write(&raw_path, &got) {
eprintln!("radbeeper: cannot write {} -- {}", raw_path, e);
return 1;
}
println!("raw {} ({} KiB)", raw_path, got.len() / 1024);
let mut text = String::from("offset,time,interval_s,count,note\n");
let mut rows = 0usize;
for r in history::records(&got) {
text.push_str(&format!(
"{},{},{},{},{}\n",
r.off,
r.when.map(clock::stamp).unwrap_or_default(),
r.dt.map(|d| format!("{:.4}", d)).unwrap_or_default(),
r.count.map(|c| c.to_string()).unwrap_or_default(),
r.note.replace(',', " ")
));
rows += 1;
}
if let Err(e) = std::fs::write(&csv_path, text) {
eprintln!("radbeeper: cannot write {} -- {}", csv_path, e);
return 1;
}
println!("csv {} ({} rows)", csv_path, rows);
println!(" times are the COUNTER's clock; interval_s is the measured");
println!(" spacing of its samples. radbeeper backfill corrects both.");
if rows == 0 {
println!("nothing was recorded -- the counter's history may be empty.");
}
0
}
fn parse_spans(text: &str) -> Option<Vec<f64>> {
let mut out = Vec::new();
for part in text.split(',') {
let v: f64 = part.trim().parse().ok()?;
if v <= 0.0 {
return None;
}
out.push(v);
}
(!out.is_empty()).then_some(out)
}
fn parse_bytes(text: &str) -> Option<u64> {
let t = text.trim();
let (digits, scale) = match t.chars().last() {
Some('k') | Some('K') => (&t[..t.len() - 1], 1024u64),
Some('m') | Some('M') => (&t[..t.len() - 1], 1024 * 1024),
Some('g') | Some('G') => (&t[..t.len() - 1], 1024 * 1024 * 1024),
_ => (t, 1),
};
digits.trim().parse::<u64>().ok().map(|n| n.saturating_mul(scale))
}
fn usage() {
println!("radbeeper {} -- a GQ GMC counter on the desk (Rust build)", VERSION);
println!();
println!(" radbeeper probe find the counter and say what it is");
println!(" radbeeper cpm the counter's own CPM, once");
println!(" radbeeper clock [--set] its clock against this machine's, or correct it");
println!(" radbeeper watch the monitor, logging while it is open");
println!(" radbeeper service log every counter found, and serve the stream");
println!(" radbeeper random 256 bits of hex, out of decay timing");
println!(" radbeeper random --check F recompute every line in an emission log");
println!(" radbeeper random --frames F the raw seconds behind those lines");
println!(" radbeeper backfill fill the log's gaps from the counter's flash");
println!(" radbeeper log info|pull what history it holds, or download it");
println!(" radbeeper export index.html and random.html, from the logs");
println!(" radbeeper pages the landing page and lab reports, from the documents");
println!(" radbeeper hotplug sit in the session, open the monitor on plug-in");
println!();
println!(" -d, --device PATH serial port; repeat it for a second counter");
println!(" -b, --baud RATE baud (default: try 115200 then 57600)");
println!(" --spans 3,30,300,3000,30000 averaging windows, seconds");
println!(" --cpm-per-usvh N tube factor (default {})", counter::DEFAULT_CPM_PER_USVH);
println!(" --duration SECONDS stop after this long");
println!(" --wait [SECONDS] a busy port: wait for it, not give up");
println!(" --log-every SECONDS row spacing for service (default {})",
log::g(log::DEFAULT_LOG_EVERY));
println!(" --logs DIR where service, watch and backfill write, and export reads");
println!(" --no-log watch without writing anything");
println!(" --no-export watch without writing index.html (hourly, and on quit)");
println!(" --no-frames do not keep the raw seconds behind each random line");
println!(" --no-backfill skip reading the counter's history at start");
println!(" --image FILE backfill from a saved .bin, no counter");
println!(" --serial SERIAL which counter an image came from");
println!(" --bytes N how much flash to read");
println!(" --max-gap SECONDS a longer hole ends the averages");
println!(" --entropy-bits N bits a random line is worth (default 256)");
println!(" --poll SECONDS hotplug: how often /dev is read (default 4)");
println!(" --settle SECONDS hotplug: grace before a new node is opened (default 2)");
println!(" --tries N hotplug: attempts per plug event (default 3)");
println!(" --tui hotplug: a terminal, even where radbeeper-gui is installed");
println!(" -o, --output STEM where log pull writes .bin and .csv");
println!(" -o, --output FILE export: where the page goes (default index.html)");
println!(" --title TEXT export: the page's heading");
println!(" --random-output FILE export: the audit page (default random.html beside it)");
println!(" --frame-budget SIZE export: raw frame bytes carried in the page (default 2M, 0 for none)");
println!(" --no-random-page export: do not write the audit page");
println!();
println!("site and recompute are in the");
println!("Python program in the same repository. They are being ported; the");
println!("log format is here already, and tests/test_differential.py is what");
println!("says it is the same format and not a second dialect of it.");
}
fn main() {
let args: Vec<String> = std::env::args().skip(1).collect();
let mut command = String::new();
let mut devices: Vec<String> = Vec::new();
let mut baud: Option<u32> = None;
let mut spans = vec![3.0, 30.0, 300.0, 3000.0, 30000.0];
let mut cpm_per_usvh = counter::DEFAULT_CPM_PER_USVH;
let mut duration: Option<f64> = None;
let mut log_every = log::DEFAULT_LOG_EVERY;
let mut logs: Option<std::path::PathBuf> = None;
let mut check: Option<std::path::PathBuf> = None;
let mut image: Option<std::path::PathBuf> = None;
let mut bytes: Option<usize> = None;
let mut max_gap = 300.0f64;
let mut no_backfill = false;
let mut no_log = false;
let mut no_export = false;
let mut no_frames = false;
let mut frames_file: Option<std::path::PathBuf> = None;
let mut wait: Option<f64> = None;
let mut set_clock = false;
let mut output: Option<String> = None;
let mut poll: f64 = 4.0;
let mut settle: f64 = 2.0;
let mut tries: u32 = 3;
let mut tui = false;
let mut log_action = "info".to_string();
let mut serial: Option<String> = None;
let mut title = radbeeper::export::DEFAULT_TITLE.to_string();
let mut random_output: Option<PathBuf> = None;
let mut no_random_page = false;
let mut frame_budget = radbeeper::audit::DEFAULT_FRAME_BUDGET;
let mut i = 0;
while i < args.len() {
let a = args[i].as_str();
let next = |i: &mut usize| -> Option<String> {
*i += 1;
args.get(*i).cloned()
};
match a {
"-h" | "--help" => {
usage();
return;
}
"--version" => {
println!("radbeeper {}", VERSION);
return;
}
"-d" | "--device" => devices.extend(next(&mut i)),
"-b" | "--baud" => baud = next(&mut i).and_then(|v| v.parse().ok()),
"--spans" => {
spans = match next(&mut i).as_deref().and_then(parse_spans) {
Some(s) => s,
None => {
eprintln!("radbeeper: --spans wants whole seconds, comma separated");
std::process::exit(2);
}
}
}
"--cpm-per-usvh" => {
cpm_per_usvh = next(&mut i).and_then(|v| v.parse().ok()).unwrap_or(cpm_per_usvh)
}
"--duration" => duration = next(&mut i).and_then(|v| v.parse().ok()),
"--wait" => {
wait = Some(match args.get(i + 1).and_then(|v| v.parse::<f64>().ok()) {
Some(secs) => {
i += 1;
secs
}
None => f64::INFINITY,
});
}
"--logs" => logs = next(&mut i).map(std::path::PathBuf::from),
"--log-every" => {
log_every = next(&mut i).and_then(|v| v.parse().ok()).unwrap_or(log_every)
}
"--check" => check = next(&mut i).map(std::path::PathBuf::from),
"--frames" => frames_file = next(&mut i).map(std::path::PathBuf::from),
"--image" => image = next(&mut i).map(std::path::PathBuf::from),
"--serial" => serial = next(&mut i),
"--bytes" | "--backfill-bytes" => bytes = next(&mut i).and_then(|v| v.parse().ok()),
"--no-backfill" => no_backfill = true,
"--no-log" => no_log = true,
"--no-export" => no_export = true,
"--no-frames" => no_frames = true,
"--entropy-bits" => {
if let Some(v) = next(&mut i).and_then(|v| v.parse::<f64>().ok()) {
if v > 0.0 {
let _ = WANT_BITS.set(v);
}
}
}
"--set" => set_clock = true,
"--max-gap" => {
max_gap = next(&mut i).and_then(|v| v.parse().ok()).unwrap_or(max_gap)
}
"-o" | "--output" => output = next(&mut i),
"--poll" => poll = next(&mut i).and_then(|v| v.parse().ok()).unwrap_or(poll),
"--settle" => settle = next(&mut i).and_then(|v| v.parse().ok()).unwrap_or(settle),
"--tries" => tries = next(&mut i).and_then(|v| v.parse().ok()).unwrap_or(tries),
"--tui" => tui = true,
"--title" => title = next(&mut i).unwrap_or(title),
"--random-output" => random_output = next(&mut i).map(PathBuf::from),
"--no-random-page" => no_random_page = true,
"--frame-budget" => {
frame_budget = next(&mut i)
.and_then(|v| parse_bytes(&v))
.unwrap_or(frame_budget)
}
"info" | "pull" if command == "log" => log_action = a.to_string(),
"site" => {
eprintln!(
"radbeeper: `{}` is not in the Rust build -- it writes the log\n\
format, which the Python program owns. Use that one:\n\
\n https://github.com/vonglurt/radbeeper",
a
);
std::process::exit(2);
}
_ if a.starts_with('-') => {
eprintln!("radbeeper: unknown option {}", a);
std::process::exit(2);
}
_ => command = a.to_string(),
}
i += 1;
}
if command.is_empty() {
usage();
return;
}
if command == "backfill" {
std::process::exit(backfill_cmd(
&spans, log_every, max_gap, bytes.unwrap_or(64 * 1024),
devices.first().map(|s| s.as_str()), baud, logs, image.as_deref(),
serial.as_deref(), output.as_deref(),
));
}
if command == "export" {
std::process::exit(radbeeper::export::run(
&logs.unwrap_or_else(log::state_dir),
Path::new(output.as_deref().unwrap_or("index.html")),
!no_random_page, cpm_per_usvh, &title, random_output.as_deref(),
frame_budget,
));
}
if command == "log" {
std::process::exit(log_cmd(&log_action, bytes, output.as_deref(),
devices.first().map(|s| s.as_str()), baud));
}
if command == "random" {
if let Some(p) = frames_file {
std::process::exit(frames_report(&p));
}
if let Some(p) = check {
std::process::exit(check_random(&p));
}
std::process::exit(random(&spans, duration, devices.first().map(|s| s.as_str()), baud, logs));
}
if command == "pages" {
let root = output.as_deref().map(std::path::Path::new);
std::process::exit(radbeeper::site::run(root));
}
if command == "hotplug" {
let dir = logs.clone().unwrap_or_else(log::state_dir);
std::process::exit(hotplug(&dir, devices.first().map(|s| s.as_str()), baud, poll, settle, tries,
duration, tui));
}
if command == "service" {
let backfill = (!no_backfill).then(|| (bytes.unwrap_or(64 * 1024), max_gap));
std::process::exit(service(
&spans, log_every, duration, &devices, baud, logs, backfill,
!no_frames,
));
}
if command == "watch" {
let dir = logs.clone().unwrap_or_else(log::state_dir);
let logging = (!no_log).then(|| WatchLog {
dir: dir.clone(),
every: log_every,
backfill: (!no_backfill).then(|| (bytes.unwrap_or(64 * 1024), max_gap)),
export_every: (!no_export).then_some(3600.0),
frames: !no_frames,
});
let mut feed = match Feed::open(&dir, &devices, baud, &spans, wait) {
Ok(f) => f,
Err(e) => {
eprintln!("{}: {}", if e.busy { "port busy" } else { "no counter" }, e.reason);
for line in e.detail.lines() {
eprintln!(" {}", line);
}
std::process::exit(1);
}
};
watch(&mut feed, &spans, cpm_per_usvh, duration, logging);
return;
}
let found = match wait {
Some(limit) => find_waiting(devices.first().map(|s| s.as_str()), baud, limit),
None => counter::find(devices.first().map(|s| s.as_str()), baud),
};
let c = match found {
Ok(c) => c,
Err(e) => {
if e.busy && command == "probe" {
let dir = logs.clone().unwrap_or_else(log::state_dir);
if let Some(client) = broker::Client::attach(&dir)
.filter(|c| devices.iter().all(|d| c.identity().serves(d)))
{
let id = client.identity();
for (k, c) in id.counters.iter().enumerate() {
if k > 0 {
println!();
}
println!("counter {}", c.version);
println!("model {}", counter::model_of(&c.version));
println!("serial {}", c.serial_no);
println!("port {} @ {} baud", c.path, c.baud);
}
println!("held by the radbeeper serving {}",
broker::socket_path(&dir).display());
println!(" battery and clock need the port itself:");
println!(" doas rc-service radbeeper stop");
println!("reading radbeeper watch attaches to it -- no handover needed");
return;
}
}
eprintln!("{}: {}", if e.busy { "port busy" } else { "no counter" }, e.reason);
for line in e.detail.lines() {
eprintln!(" {}", line);
}
std::process::exit(1);
}
};
match command.as_str() {
"probe" => {
println!("counter {}", c.version);
println!("model {}", c.model());
println!("serial {}", c.serial_no);
println!("port {} @ {} baud", c.path, c.baud);
if let Some(v) = c.voltage() {
println!("battery {:.1} V", v);
}
if let Some(o) = c.clock_ahead() {
println!("its clock {} {}",
clock::format(o.theirs, "%Y-%m-%d %H:%M:%S"), describe_offset(&o));
if o.ahead.abs() > 1.0 {
println!(" radbeeper clock --set corrects it from this machine");
}
}
if let Some(n) = c.cpm() {
println!(
"reading {} CPM ({:.3} uSv/h at {:.1} CPM per uSv/h)",
n, n as f64 / cpm_per_usvh, cpm_per_usvh
);
}
}
"cpm" => std::process::exit(cpm_cmd(&c, cpm_per_usvh)),
"clock" => std::process::exit(clock_cmd(&c, set_clock)),
other => {
eprintln!("radbeeper: unknown command {}", other);
std::process::exit(2);
}
}
}
const TERMINALS: [(&str, &str); 5] = [
("foot", "-e"),
("alacritty", "-e"),
("urxvt", "-e"),
("xterm", "-e"),
("st", "-e"),
];
fn find_terminal() -> Option<(PathBuf, &'static str)> {
find_terminal_in(&std::env::var_os("PATH")?)
}
fn find_terminal_in(path: &std::ffi::OsStr) -> Option<(PathBuf, &'static str)> {
for (term, flag) in TERMINALS {
for dir in std::env::split_paths(path) {
let p = dir.join(term);
if p.is_file() && is_executable(&p) {
return Some((p, flag));
}
}
}
None
}
fn is_executable(p: &Path) -> bool {
use std::os::unix::fs::PermissionsExt;
std::fs::metadata(p).map(|m| m.permissions().mode() & 0o111 != 0).unwrap_or(false)
}
struct Watcher {
tries: u32,
max_tries: u32,
settle: f64,
due: f64,
}
impl Watcher {
fn new(max_tries: u32, settle: f64, anything_plugged_in: bool, now: f64) -> Watcher {
Watcher {
tries: if anything_plugged_in { max_tries } else { 0 },
max_tries,
settle,
due: now,
}
}
fn should_open(&mut self, now: f64, window_open: bool) -> bool {
if window_open {
self.tries = 0;
return false;
}
if self.tries > 0 && now >= self.due {
self.tries -= 1;
self.due = now + self.settle;
return true;
}
false
}
fn plugged(&mut self, now: f64) {
self.tries = self.max_tries;
self.due = now + self.settle;
}
}
fn worth_a_window(dir: &Path, device: Option<&str>, baud: Option<u32>) -> bool {
if broker::socket_path(dir).exists() {
return true;
}
match counter::find(device, baud) {
Ok(_) => true,
Err(e) => {
if !e.busy {
log::write_status(dir, &format!("dormant: {}", e.reason));
}
false
}
}
}
fn open_window(dir: &Path, device: Option<&str>, baud: Option<u32>, tui: bool) -> Option<Child> {
if !worth_a_window(dir, device, baud) {
return None;
}
if !tui {
if let Some(g) = find_gui() {
return spawn_window(Command::new(g));
}
}
let (term, flag) = match find_terminal() {
Some(t) => t,
None => {
eprintln!("no terminal emulator found; run: radbeeper watch");
return None;
}
};
let me = match std::env::current_exe() {
Ok(p) => p,
Err(e) => {
eprintln!("radbeeper: cannot find my own path: {}", e);
return None;
}
};
let mut cmd = Command::new(&term);
cmd.arg(flag).arg(&me);
if let Some(d) = device {
cmd.arg("--device").arg(d);
}
if let Some(b) = baud {
cmd.arg("--baud").arg(b.to_string());
}
cmd.arg("watch");
spawn_window(cmd)
}
fn spawn_window(mut cmd: Command) -> Option<Child> {
unsafe {
cmd.pre_exec(|| {
libc::setsid();
Ok(())
});
}
match cmd.spawn() {
Ok(child) => Some(child),
Err(e) => {
eprintln!("radbeeper: could not open a window: {}", e);
None
}
}
}
fn find_gui() -> Option<PathBuf> {
if let Ok(me) = std::env::current_exe() {
if let Some(dir) = me.parent() {
let beside = dir.join("radbeeper-gui");
if beside.is_file() && is_executable(&beside) {
return Some(beside);
}
}
}
let path = std::env::var_os("PATH")?;
std::env::split_paths(&path)
.map(|d| d.join("radbeeper-gui"))
.find(|p| p.is_file() && is_executable(p))
}
fn hotplug(
dir: &Path,
device: Option<&str>,
baud: Option<u32>,
poll: f64,
settle: f64,
tries: u32,
duration: Option<f64>,
tui: bool,
) -> i32 {
let mut seen: BTreeSet<String> = counter::candidate_ports().into_iter().collect();
let started = Instant::now();
let now = || started.elapsed().as_secs_f64();
let mut w = Watcher::new(tries, settle, !seen.is_empty(), now());
let mut child: Option<Child> = None;
loop {
if let Some(c) = child.as_mut() {
match c.try_wait() {
Ok(Some(_)) | Err(_) => child = None,
Ok(None) => {}
}
}
if w.should_open(now(), child.is_some()) {
child = open_window(dir, device, baud, tui);
}
if duration.map_or(false, |d| now() >= d) {
return 0;
}
std::thread::sleep(Duration::from_secs_f64(poll));
let ports: BTreeSet<String> = counter::candidate_ports().into_iter().collect();
if ports.difference(&seen).next().is_some() {
w.plugged(now());
}
seen = ports;
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_merge_begins_when_there_is_something_to_merge() {
let spans = [3.0, 30.0];
let dir = std::env::temp_dir()
.join(format!("radbeeper-mergedlog-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let path = log::path(clock::now(), &dir, Some(log::MERGED));
let mut lg = MergedLogger::new(&spans, dir.clone(), 2.0);
lg.counters(&["F48824B8207F7E".to_string()]);
let mut all = Windows::new(&spans);
for i in 0..20 {
let when = 1_700_000_000.0 + i as f64;
all.add(when, 2);
assert_eq!(lg.add(0, when, 2, &all).unwrap(), None);
}
lg.finish(&all);
assert!(!path.exists(), "one counter wrote a merged log");
lg.counters(&["F48824B8207F7E".to_string(), "F7F4CA7F05C2EA".to_string()]);
let mut wrote = None;
for i in 20..40 {
let when = 1_700_000_000.0 + i as f64;
for who in 0..2 {
all.add(when + who as f64 * 0.5, 2);
if let Some(line) = lg.add(who, when + who as f64 * 0.5, 2, &all).unwrap() {
wrote = Some(line);
}
}
}
let line = wrote.expect("two counters wrote a merged row");
assert!(path.exists(), "and it went to the merged log");
let names = log::columns(&log::merged_header(&spans));
let cells: Vec<&str> = line.split('\t').collect();
let at = |n: &str| cells[names.iter().position(|c| c == n).unwrap()];
assert_eq!(at("tubes"), "2");
assert!(at("per_tube").contains("F48824B8207F7E="), "{}", at("per_tube"));
assert!(at("per_tube").contains("F7F4CA7F05C2EA="), "{}", at("per_tube"));
assert!(!at("interleave").is_empty(), "no interleave was measured");
let _ = std::fs::remove_dir_all(&dir);
}
const HEAD: &str = "/dev/ttyUSB0 @ 115200 baud GMC-320Re 4.26 serial F48824B8207F7E";
#[test]
fn a_counter_already_there_at_login_opens_a_window() {
let mut w = Watcher::new(3, 2.0, true, 0.0);
assert!(w.should_open(0.0, false), "no waiting for a plug that already happened");
}
#[test]
fn an_empty_dev_opens_nothing_and_waits() {
let mut w = Watcher::new(3, 2.0, false, 0.0);
assert!(!w.should_open(0.0, false));
assert!(!w.should_open(100.0, false), "and goes on not opening one");
w.plugged(100.0);
assert!(!w.should_open(101.0, false), "the node gets its settling time");
assert!(w.should_open(102.0, false));
}
#[test]
fn a_plug_event_is_retried_and_then_written_off() {
let mut w = Watcher::new(3, 2.0, true, 0.0);
let mut opens = 0;
let mut t = 0.0;
while t < 60.0 {
if w.should_open(t, false) {
opens += 1;
}
t += 1.0;
}
assert_eq!(opens, 3, "three tries for one plug event, and no more");
}
#[test]
fn a_window_that_took_stops_the_retries() {
let mut w = Watcher::new(3, 2.0, true, 0.0);
assert!(w.should_open(0.0, false), "the first attempt");
assert!(!w.should_open(4.0, true));
assert!(!w.should_open(8.0, false), "closing the window is not a plug event");
assert!(!w.should_open(400.0, false));
}
#[test]
fn a_second_counter_is_a_second_event() {
let mut w = Watcher::new(3, 2.0, true, 0.0);
assert!(w.should_open(0.0, false));
assert!(!w.should_open(4.0, true), "the first window took");
w.plugged(10.0);
assert!(!w.should_open(11.0, false), "settling");
assert!(w.should_open(12.0, false), "and the new one gets its window");
}
#[test]
fn a_counter_being_served_is_worth_a_window_though_the_port_is_busy() {
let dir = std::env::temp_dir().join(format!("radbeeper-window-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let sock = broker::socket_path(&dir);
let _ = std::fs::remove_file(&sock);
assert!(!worth_a_window(&dir, Some("/dev/null-no-counter-here"), None));
std::os::unix::net::UnixListener::bind(&sock).unwrap();
assert!(worth_a_window(&dir, Some("/dev/null-no-counter-here"), None));
let _ = std::fs::remove_file(&sock);
}
#[test]
fn the_terminals_are_tried_best_first() {
assert_eq!(TERMINALS[0].0, "foot");
assert!(TERMINALS.iter().all(|(_, flag)| *flag == "-e"));
assert!(TERMINALS.iter().any(|(t, _)| *t == "xterm"), "an X11 session has one of these");
}
fn a_terminal_called(dir: &Path, name: &str, executable: bool) {
use std::os::unix::fs::PermissionsExt;
let p = dir.join(name);
std::fs::write(&p, b"#!/bin/sh\n").unwrap();
let mode = if executable { 0o755 } else { 0o644 };
std::fs::set_permissions(&p, std::fs::Permissions::from_mode(mode)).unwrap();
}
#[test]
fn the_terminal_search_prefers_the_desktops_over_the_directory_order() {
let root = std::env::temp_dir().join(format!("radbeeper-term-{}", std::process::id()));
let (first, second) = (root.join("first"), root.join("second"));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(&first).unwrap();
std::fs::create_dir_all(&second).unwrap();
a_terminal_called(&first, "xterm", true);
a_terminal_called(&second, "foot", true);
let path = std::env::join_paths([&first, &second]).unwrap();
let (found, flag) = find_terminal_in(&path).expect("one of them");
assert_eq!(found, second.join("foot"));
assert_eq!(flag, "-e");
let root2 = root.join("third");
std::fs::create_dir_all(&root2).unwrap();
a_terminal_called(&root2, "foot", false);
a_terminal_called(&root2, "st", true);
let path = std::env::join_paths([&root2]).unwrap();
assert_eq!(find_terminal_in(&path).unwrap().0, root2.join("st"));
let empty = root.join("empty");
std::fs::create_dir_all(&empty).unwrap();
let path = std::env::join_paths([&empty]).unwrap();
assert!(find_terminal_in(&path).is_none());
let _ = std::fs::remove_dir_all(&root);
}
#[test]
fn the_big_digits_start_clear_of_the_header() {
assert!(HEAD.chars().count() > 54, "the header outgrew the old constant");
assert!(digits_left(HEAD) > HEAD.chars().count());
}
#[test]
fn the_readout_has_room_for_everything_the_counter_can_say() {
let reserve = readout_width();
for v in [0u16, 7, 42, 999, 9999, u16::MAX] {
let drawn = big_number(&v.to_string())
.iter()
.map(|r| r.chars().count())
.max()
.unwrap_or(0);
assert!(drawn <= reserve, "{} needs {} of {}", v, drawn, reserve);
}
assert!(digits_left(HEAD) + reserve <= 160,
"the readout does not fit the terminal the shots are taken in");
}
#[test]
fn the_nameplate_names_the_program_and_its_version() {
let plate = nameplate();
assert!(plate.starts_with(env!("CARGO_PKG_NAME")));
assert!(plate.ends_with(env!("CARGO_PKG_VERSION")));
}
#[test]
fn the_nameplate_yields_the_corner_to_the_readout() {
let plate = nameplate().chars().count();
let left = digits_left(HEAD);
let busy = left + readout_width();
let x = nameplate_left(160, busy, plate).expect("no corner at 160");
assert_eq!(x + plate, 160, "not against the right edge");
assert!(x > busy, "drawn over the readout");
assert_eq!(nameplate_left(busy + plate, busy, plate), None);
assert_eq!(nameplate_left(40, busy, plate), None);
}
#[test]
fn a_shorter_header_lets_the_digits_come_left() {
assert!(digits_left("/dev/ttyUSB0 @ 57600 baud GMC-300 1.0 serial A1")
< digits_left(HEAD));
}
#[test]
fn every_character_the_readout_can_contain_has_a_glyph() {
for ch in "0123456789.-".chars() {
assert!(glyph(ch).is_some(), "no glyph for {:?}", ch);
}
assert!(glyph('x').is_none());
}
#[test]
fn a_big_number_is_twelve_rows_of_equal_width() {
let rows = big_number("40.5");
assert_eq!(rows.len(), BIG_ROWS);
let w = rows[0].chars().count();
assert!(w > 0);
for r in &rows {
assert_eq!(r.chars().count(), w, "ragged row: {:?}", r);
}
}
#[test]
fn a_number_with_no_reading_yet_still_draws() {
let rows = big_number("--");
assert_eq!(rows.len(), BIG_ROWS);
assert!(rows.iter().any(|r| r.contains('█')));
}
#[test]
fn an_unknown_character_is_skipped_rather_than_drawn_ragged() {
let rows = big_number("4x0");
let w = rows[0].chars().count();
assert!(rows.iter().all(|r| r.chars().count() == w));
}
#[test]
fn spans_are_a_comma_list_and_must_be_positive() {
assert_eq!(parse_spans("3,30,300,3000"),
Some(vec![3.0, 30.0, 300.0, 3000.0]));
assert_eq!(parse_spans(" 1 , 10 "), Some(vec![1.0, 10.0]));
assert_eq!(parse_spans("3,0"), None, "a zero-second window is not one");
assert_eq!(parse_spans("3,-1"), None);
assert_eq!(parse_spans("3,x"), None);
assert_eq!(parse_spans(""), None);
}
#[test]
fn a_cursor_move_is_one_based_on_the_wire_and_zero_based_here() {
assert_eq!(at(0, 0), "\x1b[1;1H");
assert_eq!(at(11, 53), "\x1b[12;54H");
}
#[test]
fn the_bands_colour_the_number_the_same_way_they_colour_the_bars() {
assert_ne!(colour_for(Level::Calm), colour_for(Level::Raised));
assert_ne!(colour_for(Level::Raised), colour_for(Level::High));
}
fn failure(busy: bool) -> counter::NotFound {
counter::NotFound {
reason: "r".into(),
detail: "d".into(),
busy,
}
}
#[test]
fn a_busy_port_is_waited_on() {
assert!(matches!(wait_verdict(&failure(true), 0.0, 30.0), Verdict::Retry));
assert!(matches!(wait_verdict(&failure(true), 29.9, 30.0), Verdict::Retry));
}
#[test]
fn a_missing_counter_is_not_waited_on_at_all() {
assert!(matches!(wait_verdict(&failure(false), 0.0, 30.0), Verdict::Give));
assert!(matches!(wait_verdict(&failure(false), 0.0, f64::INFINITY), Verdict::Give));
}
#[test]
fn the_limit_ends_the_wait_and_says_how_long_it_was() {
match wait_verdict(&failure(true), 30.0, 30.0) {
Verdict::Expired(note) => assert!(note.contains("30s"), "got {}", note),
_ => panic!("30s of a 30s wait is the end of it"),
}
}
#[test]
fn an_unbounded_wait_does_not_expire() {
assert!(matches!(wait_verdict(&failure(true), 3600.0, f64::INFINITY),
Verdict::Retry));
}
}