Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
bc9f847689 | ||
|
|
71cdf2d988 | ||
|
|
4fea3becf6 | ||
|
|
7781ff71d3 | ||
|
|
86e4761316 |
@@ -6,7 +6,7 @@
|
||||
//! firmware registry, so `scan`'s callers never have to think about it.
|
||||
|
||||
use std::io::Write;
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
|
||||
|
||||
use asic_rs::MinerFactory;
|
||||
use asic_rs::core::traits::miner::MinerAuth;
|
||||
@@ -31,9 +31,19 @@ pub fn save_credentials(user: &str, pass: &str) -> std::io::Result<()> {
|
||||
if let Some(dir) = p.parent() {
|
||||
std::fs::create_dir_all(dir)?;
|
||||
}
|
||||
let mut f = std::fs::File::create(&p)?;
|
||||
f.write_all(format!("{user}\n{pass}\n").as_bytes())?;
|
||||
// Open (and create) with mode 0600 up front so a freshly created file is
|
||||
// never world/group-readable, even for the instant before the write. For a
|
||||
// pre-existing file the create mode is ignored, so also tighten it to 0600
|
||||
// while it is still empty (post-truncate, pre-write) -- the plaintext is
|
||||
// never on disk under a looser mode.
|
||||
let mut f = std::fs::OpenOptions::new()
|
||||
.write(true)
|
||||
.create(true)
|
||||
.truncate(true)
|
||||
.mode(0o600)
|
||||
.open(&p)?;
|
||||
f.set_permissions(std::fs::Permissions::from_mode(0o600))?;
|
||||
f.write_all(format!("{user}\n{pass}\n").as_bytes())?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -84,7 +94,27 @@ mod tests {
|
||||
let meta = std::fs::metadata(config_path(CREDENTIALS_FILE)).unwrap();
|
||||
assert_eq!(meta.permissions().mode() & 0o777, 0o600, "credentials file must be 0600");
|
||||
|
||||
// configured_factory() must construct in both branches without panicking:
|
||||
// with saved credentials (fans auth across every firmware backend) ...
|
||||
let _ = configured_factory();
|
||||
|
||||
// A pre-existing, world-readable credentials file must be tightened to
|
||||
// 0600 by save_credentials (the create-mode is ignored for an existing
|
||||
// file, so the explicit set_permissions is what protects it).
|
||||
let path = config_path(CREDENTIALS_FILE);
|
||||
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o644)).unwrap();
|
||||
save_credentials("admin2", "s3cr3t").unwrap();
|
||||
let meta = std::fs::metadata(&path).unwrap();
|
||||
assert_eq!(
|
||||
meta.permissions().mode() & 0o777,
|
||||
0o600,
|
||||
"save over a pre-existing 0644 file must re-tighten to 0600"
|
||||
);
|
||||
assert_eq!(load_credentials(), Some(("admin2".to_string(), "s3cr3t".to_string())));
|
||||
|
||||
clear_credentials().unwrap();
|
||||
// ... and with no saved credentials (plain MinerFactory::new()).
|
||||
let _ = configured_factory();
|
||||
assert_eq!(load_credentials(), None, "cleared -> None");
|
||||
clear_credentials().unwrap(); // idempotent: clearing an already-clear store is not an error
|
||||
|
||||
|
||||
@@ -1,10 +1,9 @@
|
||||
//! Bench-fleet fixtures: the expected hardware output of the 9 boards on
|
||||
//! 10.255.1.0/24 (see ../../../HANDOFF.md section 7 and the parent project's
|
||||
//! [removed]), plus one synthetic unreachable IP rendered via
|
||||
//! `MinerRow::offline()` so the "offline" status/row shape is exercisable
|
||||
//! offline too (10 rows total). These are the reference values the workflow
|
||||
//! tests compare the application's actual output against, and the rows the
|
||||
//! offline `ALKANE_FAKE_SCAN` demo mode renders.
|
||||
//! [removed]). These are the reference values the workflow tests compare
|
||||
//! the application's actual output against, and the rows the offline
|
||||
//! `ALKANE_FAKE_SCAN` demo mode renders. Only miners that respond become rows,
|
||||
//! so there is no synthetic "offline" fixture.
|
||||
//!
|
||||
//! Hashrate/power/temp are representative per-model figures (the bench boards
|
||||
//! are not always energised); the point of the fixtures is a fixed, known input
|
||||
@@ -70,7 +69,7 @@ impl Board {
|
||||
is_mining: self.mining,
|
||||
slow,
|
||||
paused: self.paused,
|
||||
online: true,
|
||||
// offline defaults to false (online); these bench rows are reachable.
|
||||
mac: format!("AA:BB:CC:00:{:02X}:{last_octet:02X}", last_octet.wrapping_mul(3)),
|
||||
hostname: format!("miner-{last_octet}"),
|
||||
hashboards: boards,
|
||||
@@ -107,28 +106,50 @@ impl Board {
|
||||
tuning: self.mining,
|
||||
firmware_flash,
|
||||
},
|
||||
// Demo values for the round-8 columns (synthetic, so the columns
|
||||
// show variety offline).
|
||||
control_board: if self.model.contains("S17") {
|
||||
"Xilinx".to_string()
|
||||
} else if self.model.contains("S19j") || self.model.contains("S19k") {
|
||||
"AMLogic".to_string()
|
||||
} else if self.model.contains("S19") {
|
||||
"BeagleBone Black".to_string()
|
||||
} else if self.model.contains("S21") {
|
||||
"CVITek".to_string()
|
||||
} else {
|
||||
String::new()
|
||||
},
|
||||
pic_present: if self.model.contains("S21") {
|
||||
Some(false) // noPIC example
|
||||
} else if self.model.starts_with("Antminer") {
|
||||
Some(true)
|
||||
} else {
|
||||
None // WhatsMiner: unknown over the network
|
||||
},
|
||||
// Access: idle/view-only units (no worker) shown locked; the rest
|
||||
// unlocked. (Live rows infer this from control capabilities.)
|
||||
write_locked: Some(self.worker.is_empty()),
|
||||
errors: if self.model.contains("S21 Pro") {
|
||||
vec![
|
||||
"[Warning] hashrate 70% below expected".to_string(),
|
||||
"[Warning] chip temperature high (HashBoard 2)".to_string(),
|
||||
]
|
||||
} else {
|
||||
Vec::new()
|
||||
},
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The 9 bench boards plus one synthetic offline entry (10 rows total).
|
||||
/// One is idle/not-hashing (S17 stock, .112); one is paused (WardenOS dev,
|
||||
/// .115 - deliberately rebucketed from idle so the "paused" status/KPI
|
||||
/// bucket is exercisable offline); one is slow (S21 Pro aml stock at ~30%
|
||||
/// of expected); the other six hash normally; the last row is an
|
||||
/// unreachable IP rendered via `MinerRow::offline()` (blank fields,
|
||||
/// `online: false`).
|
||||
/// The 9 bench boards (9 rows total). One is idle/not-hashing (S17 stock,
|
||||
/// .112); one is paused (WardenOS dev, .115 - deliberately rebucketed from idle
|
||||
/// so the "paused" status/KPI bucket is exercisable offline); one is slow (S21
|
||||
/// Pro aml stock at ~30% of expected); the other six hash normally.
|
||||
///
|
||||
/// Derived totals (used by the workflow tests):
|
||||
/// total = 10, hashing = 6, slow = 1, not hashing = 1, paused = 1, offline = 1,
|
||||
/// total hashrate = 685.0 TH/s, total power = 21300 W (offline row is all zero).
|
||||
///
|
||||
/// Note: `compute_kpis` has no separate "offline" bucket - an offline row is
|
||||
/// `!is_mining && !paused && !slow`, so it folds into the "not hashing" KPI
|
||||
/// alongside the idle S17, giving `Kpis.not_hashing == 2`. The per-row
|
||||
/// `status()` text still distinguishes them ("not hashing" for .112 vs.
|
||||
/// "offline" for .199).
|
||||
/// total = 9, hashing = 6, slow = 1, not hashing = 1, paused = 1,
|
||||
/// total hashrate = 685.0 TH/s, total power = 21300 W.
|
||||
pub fn bench_fleet() -> Vec<MinerRow> {
|
||||
let boards = [
|
||||
Board { ip: "10.255.1.112", model: "Antminer S17", firmware: "Stock",
|
||||
@@ -161,8 +182,5 @@ pub fn bench_fleet() -> Vec<MinerRow> {
|
||||
hashrate: 0.0, expected: 0.0, power: 0.0, temp: 0.0, fan: 0.0,
|
||||
worker: "", mining: false, paused: true },
|
||||
];
|
||||
let mut rows: Vec<MinerRow> = boards.into_iter().map(Board::into_row).collect();
|
||||
// Synthetic offline board: unreachable IP, blank/zeroed fields, online: false.
|
||||
rows.push(MinerRow::offline("10.255.1.199".into()));
|
||||
rows
|
||||
boards.into_iter().map(Board::into_row).collect()
|
||||
}
|
||||
|
||||
+179
-77
@@ -68,6 +68,13 @@ pub fn format_fan_rpm(rpm: f64) -> String {
|
||||
}
|
||||
}
|
||||
|
||||
/// A hashrate reading (in TH/s) for the combined Hashrate column: mantissa + SI
|
||||
/// prefix only, no unit and no space (80.5 TH/s -> "80.5T", 102 TH/s -> "102T"),
|
||||
/// or `None` for an absent/non-positive reading.
|
||||
pub fn format_hashrate_ths(ths: f64) -> Option<String> {
|
||||
si_mantissa_and_prefix(ths * 1e12).map(|(num, prefix)| format!("{num}{prefix}"))
|
||||
}
|
||||
|
||||
/// The actual/expected ratio, or `None` when the expected value is unknown
|
||||
/// (<= 0.0) so a ratio-based color/warning never divides by zero or treats an
|
||||
/// unknown expectation as a 0% shortfall.
|
||||
@@ -75,19 +82,16 @@ pub fn actual_expected_ratio(actual: f64, expected: f64) -> Option<f64> {
|
||||
if expected > 0.0 { Some(actual / expected) } else { None }
|
||||
}
|
||||
|
||||
/// Render a combined "actual / expected" cell for a value shown against its
|
||||
/// model-expected counterpart (UI-SPEC combined columns: Hashrate,
|
||||
/// Hashboards, TotalChips): blank when neither is known, the bare actual
|
||||
/// when only it is known, "- / <expected>" when only the expected is known,
|
||||
/// and "<actual> / <expected>" when both are.
|
||||
/// Render the combined Hashrate cell "actual/expected" (no spaces around the
|
||||
/// slash, prefix-only unit): blank when neither is known, the bare actual when
|
||||
/// only it is known, "-/<expected>" when only the expected is known, and
|
||||
/// "<actual>/<expected>" when both are (e.g. "80.5T/95.0T").
|
||||
fn combined_si(actual_ths: f64, expected_ths: f64) -> String {
|
||||
let actual = (actual_ths > 0.0).then(|| format_si(actual_ths * 1e12, "H/s"));
|
||||
let expected = (expected_ths > 0.0).then(|| format_si(expected_ths * 1e12, "H/s"));
|
||||
match (actual, expected) {
|
||||
match (format_hashrate_ths(actual_ths), format_hashrate_ths(expected_ths)) {
|
||||
(None, None) => String::new(),
|
||||
(Some(a), None) => a,
|
||||
(None, Some(e)) => format!("- / {e}"),
|
||||
(Some(a), Some(e)) => format!("{a} / {e}"),
|
||||
(None, Some(e)) => format!("-/{e}"),
|
||||
(Some(a), Some(e)) => format!("{a}/{e}"),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -152,8 +156,9 @@ pub fn format_uptime(secs: u64) -> String {
|
||||
|
||||
/// Pack a dotted-quad IPv4 string into a u32 for numeric ordering, so
|
||||
/// "10.255.1.9" sorts before "10.255.1.10" (a plain string sort gets this
|
||||
/// wrong). Anything unparseable sorts first (0).
|
||||
fn ip_to_u32(s: &str) -> u32 {
|
||||
/// wrong). Anything unparseable sorts first (0). `pub(crate)` so the headless
|
||||
/// self-test can build the same numeric order it asserts the view against.
|
||||
pub(crate) fn ip_to_u32(s: &str) -> u32 {
|
||||
let mut parts = s.split('.');
|
||||
let mut acc = 0u32;
|
||||
for _ in 0..4 {
|
||||
@@ -207,6 +212,18 @@ impl MinerCaps {
|
||||
pub fn is_empty(self) -> bool {
|
||||
self == MinerCaps::default()
|
||||
}
|
||||
|
||||
/// Whether the miner exposes any writable control action at all. Used to
|
||||
/// infer the "Access" (locked/unlocked) column: no control -> view-only.
|
||||
pub fn any_control(self) -> bool {
|
||||
self.fault_light
|
||||
|| self.restart
|
||||
|| self.pause
|
||||
|| self.resume
|
||||
|| self.power_limit
|
||||
|| self.tuning
|
||||
|| self.firmware_flash
|
||||
}
|
||||
}
|
||||
|
||||
/// One miner's telemetry snapshot, flattened from asic-rs `MinerData` into the
|
||||
@@ -226,6 +243,19 @@ pub struct MinerRow {
|
||||
pub firmware: String,
|
||||
pub api_version: String,
|
||||
pub control_board: String,
|
||||
/// Whether the hashboards carry a PIC MCU. asic-rs does not report this over
|
||||
/// the network, so it is a best-effort inference (model-string heuristic):
|
||||
/// `None` = unknown, `Some(true)` = PIC, `Some(false)` = noPIC. True
|
||||
/// detection needs an on-board SSH/I2C probe (a separate feature).
|
||||
pub pic_present: Option<bool>,
|
||||
/// Whether this miner is locked to view-only (no command writes). Inferred
|
||||
/// from whether any control capability is available: `None` = unknown,
|
||||
/// `Some(true)` = locked, `Some(false)` = unlocked/writable.
|
||||
pub write_locked: Option<bool>,
|
||||
/// Structured error/event lines from the miner (severity + text), most
|
||||
/// severe first. Empty means none. The Error column shows a summary; the
|
||||
/// full list is the hover tooltip (added with the tooltip bridge support).
|
||||
pub errors: Vec<String>,
|
||||
// performance
|
||||
pub hashrate_ths: f64,
|
||||
pub expected_ths: f64,
|
||||
@@ -265,28 +295,14 @@ pub struct MinerRow {
|
||||
/// Not-mining because an operator paused it (distinct from simply idle);
|
||||
/// see `is_paused`.
|
||||
pub paused: bool,
|
||||
/// Whether this miner responded to the scan. `Default` gives `false`, so
|
||||
/// every constructor of a real (non-offline) row -- `scan::to_row`,
|
||||
/// fixtures -- MUST set this to `true` explicitly; only `MinerRow::offline`
|
||||
/// is meant to leave it `false`.
|
||||
pub online: bool,
|
||||
}
|
||||
|
||||
impl MinerRow {
|
||||
/// A miner that did not respond to this scan attempt: ip only, every
|
||||
/// other field blank/zero/false, `online: false` so `status()` reports
|
||||
/// "offline".
|
||||
pub fn offline(ip: String) -> MinerRow {
|
||||
let mut r = MinerRow::default();
|
||||
r.ip = ip;
|
||||
r.online = false;
|
||||
r
|
||||
}
|
||||
|
||||
/// The row's status label. Only miners that actually responded to a scan
|
||||
/// become rows, so there is no "offline" state: a responding miner that is
|
||||
/// not mining is "not hashing".
|
||||
pub fn status(&self) -> &'static str {
|
||||
if !self.online {
|
||||
"offline"
|
||||
} else if self.slow {
|
||||
if self.slow {
|
||||
"slow"
|
||||
} else if self.paused {
|
||||
"paused"
|
||||
@@ -318,6 +334,14 @@ pub fn is_paused(operating_state: &str, is_mining: bool) -> bool {
|
||||
!is_mining && operating_state.to_lowercase().contains("pause")
|
||||
}
|
||||
|
||||
/// The typed-confirmation gate for the irreversible firmware-flash action: the
|
||||
/// operator must type exactly "FLASH" (surrounding whitespace ignored, but not
|
||||
/// case-folded and not a prefix). Pure so the guard is unit-testable without a
|
||||
/// live dialog.
|
||||
pub fn flash_confirmed(input: &str) -> bool {
|
||||
input.trim() == "FLASH"
|
||||
}
|
||||
|
||||
/// Model columns. Ip is fixed (always shown first); the rest map 1:1 to a
|
||||
/// scannable metric and can be shown/hidden/reordered. Row selection replaces
|
||||
/// the old checkbox column.
|
||||
@@ -345,6 +369,9 @@ pub enum Column {
|
||||
Serial,
|
||||
ApiVersion,
|
||||
ControlBoard,
|
||||
Pic,
|
||||
Locked,
|
||||
Error,
|
||||
Uptime,
|
||||
Light,
|
||||
OperatingState,
|
||||
@@ -362,7 +389,7 @@ pub enum Column {
|
||||
|
||||
/// Every column, in registry order. Ip first, then the default-visible set
|
||||
/// (UI-SPEC order), then all remaining metrics.
|
||||
pub const ALL_COLUMNS: [Column; 35] = [
|
||||
pub const ALL_COLUMNS: [Column; 38] = [
|
||||
Column::Ip,
|
||||
Column::Hashrate,
|
||||
Column::Power,
|
||||
@@ -385,6 +412,9 @@ pub const ALL_COLUMNS: [Column; 35] = [
|
||||
Column::Serial,
|
||||
Column::ApiVersion,
|
||||
Column::ControlBoard,
|
||||
Column::Pic,
|
||||
Column::Locked,
|
||||
Column::Error,
|
||||
Column::Uptime,
|
||||
Column::Light,
|
||||
Column::OperatingState,
|
||||
@@ -437,8 +467,11 @@ impl Column {
|
||||
Column::Serial => "Serial",
|
||||
Column::ApiVersion => "API ver",
|
||||
Column::ControlBoard => "Control board",
|
||||
Column::Pic => "PIC",
|
||||
Column::Locked => "Access",
|
||||
Column::Error => "Errors",
|
||||
Column::Uptime => "Uptime",
|
||||
Column::Light => "Fault light",
|
||||
Column::Light => "Light",
|
||||
Column::OperatingState => "State",
|
||||
Column::BestShare => "Best share",
|
||||
Column::SessionBestShare => "Session best",
|
||||
@@ -470,6 +503,9 @@ impl Column {
|
||||
Column::Mac | Column::Hostname | Column::Serial => 150,
|
||||
Column::ApiVersion | Column::Light => 90,
|
||||
Column::ControlBoard => 130,
|
||||
Column::Pic => 70,
|
||||
Column::Locked => 90,
|
||||
Column::Error => 160,
|
||||
Column::Uptime => 100,
|
||||
Column::OperatingState => 100,
|
||||
Column::BestShare | Column::SessionBestShare => 110,
|
||||
@@ -608,6 +644,21 @@ impl Column {
|
||||
Column::Serial => r.serial.clone(),
|
||||
Column::ApiVersion => r.api_version.clone(),
|
||||
Column::ControlBoard => r.control_board.clone(),
|
||||
Column::Pic => match r.pic_present {
|
||||
Some(true) => "PIC".to_string(),
|
||||
Some(false) => "noPIC".to_string(),
|
||||
None => "?".to_string(),
|
||||
},
|
||||
Column::Locked => match r.write_locked {
|
||||
Some(true) => "locked".to_string(),
|
||||
Some(false) => "unlocked".to_string(),
|
||||
None => "?".to_string(),
|
||||
},
|
||||
Column::Error => match r.errors.len() {
|
||||
0 => String::new(),
|
||||
1 => r.errors[0].clone(),
|
||||
n => format!("{n} errors"),
|
||||
},
|
||||
Column::Status => r.status().to_string(),
|
||||
Column::Uptime => format_uptime(r.uptime_secs),
|
||||
Column::Light => match r.light_flashing {
|
||||
@@ -789,9 +840,9 @@ impl ViewState {
|
||||
}
|
||||
}
|
||||
|
||||
/// The KPIs (UI-SPEC header), derived from the filtered view. There is no
|
||||
/// separate "offline" bucket: an offline row is (by construction) neither
|
||||
/// slow, paused, nor mining, so it folds into `not_hashing`.
|
||||
/// The KPIs (UI-SPEC header), derived from the filtered view. Every row is a
|
||||
/// miner that responded to a scan; a responding non-mining miner counts as
|
||||
/// `not_hashing`.
|
||||
pub struct Kpis {
|
||||
pub total: usize,
|
||||
pub hashing: usize,
|
||||
@@ -814,14 +865,13 @@ pub fn compute_kpis(rows: &[MinerRow], view_idx: &[usize]) -> Kpis {
|
||||
};
|
||||
for &i in view_idx {
|
||||
let r = &rows[i];
|
||||
if r.slow {
|
||||
k.slow += 1;
|
||||
} else if r.paused {
|
||||
k.paused += 1;
|
||||
} else if r.is_mining {
|
||||
k.hashing += 1;
|
||||
} else {
|
||||
k.not_hashing += 1;
|
||||
// Bucket by the same precedence status() uses, so the KPI header can
|
||||
// never disagree with a row's own status text.
|
||||
match r.status() {
|
||||
"slow" => k.slow += 1,
|
||||
"paused" => k.paused += 1,
|
||||
"hashing" => k.hashing += 1,
|
||||
_ => k.not_hashing += 1,
|
||||
}
|
||||
k.total_hashrate_ths += r.hashrate_ths;
|
||||
k.total_power_w += r.power_w;
|
||||
@@ -846,12 +896,9 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn kpis_match_expected_hardware_output() {
|
||||
// Round-6 fixtures are being rebucketed concurrently (an idle board
|
||||
// moved into "paused", a new offline row added), so this does not
|
||||
// hardcode fixture counts: it independently recomputes each expected
|
||||
// KPI bucket and sum straight from the rows (via `status()`, a
|
||||
// separate code path from `compute_kpis`'s own if/else chain) and
|
||||
// cross-checks `compute_kpis`'s output against that.
|
||||
// This does not hardcode fixture counts: it independently recomputes
|
||||
// each expected KPI bucket and sum straight from the rows (via
|
||||
// `status()`) and cross-checks `compute_kpis`'s output against that.
|
||||
let (rows, _v, idx) = full_view();
|
||||
let k = compute_kpis(&rows, &idx);
|
||||
|
||||
@@ -864,8 +911,7 @@ mod tests {
|
||||
"slow" => exp_slow += 1,
|
||||
"paused" => exp_paused += 1,
|
||||
"hashing" => exp_hashing += 1,
|
||||
// offline folds into not_hashing for KPIs (no separate bucket).
|
||||
"not hashing" | "offline" => exp_not_hashing += 1,
|
||||
"not hashing" => exp_not_hashing += 1,
|
||||
other => panic!("unexpected status: {other}"),
|
||||
}
|
||||
}
|
||||
@@ -910,8 +956,8 @@ mod tests {
|
||||
assert_eq!(Column::Status.cell(s17), "not hashing");
|
||||
|
||||
let s21 = rows.iter().find(|r| r.ip == "10.255.1.149").unwrap();
|
||||
// Combined actual/expected cell: both known -> "<actual> / <expected>".
|
||||
assert_eq!(Column::Hashrate.cell(s21), "60.0 TH/s / 200 TH/s");
|
||||
// Combined hashrate cell: both known -> "<actual>/<expected>" (no spaces).
|
||||
assert_eq!(Column::Hashrate.cell(s21), "60.0T/200T");
|
||||
assert_eq!(Column::Power.cell(s21), "1.5 kW");
|
||||
assert_eq!(Column::Status.cell(s21), "slow");
|
||||
}
|
||||
@@ -1030,7 +1076,6 @@ mod tests {
|
||||
chip_temp_c: 55.0 + (i % 25) as f64,
|
||||
fan_rpms: vec![4000.0 + (i % 900) as f64],
|
||||
is_mining: i % 7 != 0,
|
||||
online: true,
|
||||
model: format!("Model-{}", i % 12),
|
||||
firmware: format!("fw-{}", i % 6),
|
||||
worker: format!("blueflare.{i}"),
|
||||
@@ -1141,6 +1186,39 @@ mod tests {
|
||||
assert_eq!(format_uptime(90_061), "1d 1h");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pic_locked_error_columns_render() {
|
||||
// PIC (best-effort): known -> PIC/noPIC, unknown -> "?".
|
||||
let pic = MinerRow { pic_present: Some(true), ..Default::default() };
|
||||
let nopic = MinerRow { pic_present: Some(false), ..Default::default() };
|
||||
let pic_unknown = MinerRow { pic_present: None, ..Default::default() };
|
||||
assert_eq!(Column::Pic.cell(&pic), "PIC");
|
||||
assert_eq!(Column::Pic.cell(&nopic), "noPIC");
|
||||
assert_eq!(Column::Pic.cell(&pic_unknown), "?");
|
||||
|
||||
// Access column.
|
||||
let locked = MinerRow { write_locked: Some(true), ..Default::default() };
|
||||
let unlocked = MinerRow { write_locked: Some(false), ..Default::default() };
|
||||
assert_eq!(Column::Locked.cell(&locked), "locked");
|
||||
assert_eq!(Column::Locked.cell(&unlocked), "unlocked");
|
||||
assert_eq!(Column::Locked.cell(&MinerRow::default()), "?");
|
||||
|
||||
// Error column: blank / single message / count.
|
||||
let none = MinerRow { errors: vec![], ..Default::default() };
|
||||
let one = MinerRow { errors: vec!["[Error] boom".into()], ..Default::default() };
|
||||
let many = MinerRow { errors: vec!["a".into(), "b".into(), "c".into()], ..Default::default() };
|
||||
assert_eq!(Column::Error.cell(&none), "");
|
||||
assert_eq!(Column::Error.cell(&one), "[Error] boom");
|
||||
assert_eq!(Column::Error.cell(&many), "3 errors");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn caps_any_control() {
|
||||
assert!(!MinerCaps::default().any_control(), "no caps -> view-only");
|
||||
assert!(MinerCaps { restart: true, ..Default::default() }.any_control());
|
||||
assert!(MinerCaps { firmware_flash: true, ..Default::default() }.any_control());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ip_column_sorts_numerically() {
|
||||
// A plain string sort puts "10.255.1.10" before "10.255.1.2"; the IP
|
||||
@@ -1198,9 +1276,9 @@ mod tests {
|
||||
#[test]
|
||||
fn passes_filters_ands_across_columns() {
|
||||
let rows = vec![
|
||||
MinerRow { ip: "10.0.0.1".into(), online: true, is_mining: true, model: "A".into(), ..Default::default() },
|
||||
MinerRow { ip: "10.0.0.2".into(), online: true, is_mining: true, model: "B".into(), ..Default::default() },
|
||||
MinerRow { ip: "10.0.0.3".into(), online: true, is_mining: false, model: "A".into(), ..Default::default() },
|
||||
MinerRow { ip: "10.0.0.1".into(), is_mining: true, model: "A".into(), ..Default::default() },
|
||||
MinerRow { ip: "10.0.0.2".into(), is_mining: true, model: "B".into(), ..Default::default() },
|
||||
MinerRow { ip: "10.0.0.3".into(), is_mining: false, model: "A".into(), ..Default::default() },
|
||||
];
|
||||
let mut view = ViewState::default();
|
||||
view.filters.insert(Column::Status, ColFilter::Values(HashSet::from(["hashing".to_string()])));
|
||||
@@ -1438,7 +1516,7 @@ mod tests {
|
||||
total_chips: Some(210),
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(Column::Hashrate.cell(&actual_only), "60.0 TH/s", "only actual -> bare actual");
|
||||
assert_eq!(Column::Hashrate.cell(&actual_only), "60.0T", "only actual -> bare actual");
|
||||
assert_eq!(Column::Hashboards.cell(&actual_only), "3");
|
||||
assert_eq!(Column::TotalChips.cell(&actual_only), "210");
|
||||
|
||||
@@ -1448,7 +1526,7 @@ mod tests {
|
||||
expected_chips: Some(228),
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(Column::Hashrate.cell(&expected_only), "- / 200 TH/s", "only expected -> '- / <expected>'");
|
||||
assert_eq!(Column::Hashrate.cell(&expected_only), "-/200T", "only expected -> '-/<expected>'");
|
||||
assert_eq!(Column::Hashboards.cell(&expected_only), "- / 3");
|
||||
assert_eq!(Column::TotalChips.cell(&expected_only), "- / 228");
|
||||
|
||||
@@ -1461,7 +1539,7 @@ mod tests {
|
||||
expected_chips: Some(228),
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(Column::Hashrate.cell(&both), "60.0 TH/s / 200 TH/s", "both known -> '<actual> / <expected>'");
|
||||
assert_eq!(Column::Hashrate.cell(&both), "60.0T/200T", "both known -> '<actual>/<expected>'");
|
||||
assert_eq!(Column::Hashboards.cell(&both), "3 / 3");
|
||||
assert_eq!(Column::TotalChips.cell(&both), "190 / 228");
|
||||
}
|
||||
@@ -1528,30 +1606,24 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn status_offline_and_paused() {
|
||||
let offline = MinerRow::offline("10.1.2.3".into());
|
||||
assert_eq!(offline.status(), "offline");
|
||||
assert!(!offline.online);
|
||||
assert_eq!(offline.ip, "10.1.2.3");
|
||||
assert_eq!(offline.hashrate_ths, 0.0, "offline row is otherwise blank");
|
||||
fn status_precedence() {
|
||||
// A plain default row is a reachable, non-mining miner.
|
||||
let default_row = MinerRow { ..Default::default() };
|
||||
assert_eq!(default_row.status(), "not hashing");
|
||||
|
||||
let paused = MinerRow { online: true, paused: true, ..Default::default() };
|
||||
let paused = MinerRow { paused: true, ..Default::default() };
|
||||
assert_eq!(paused.status(), "paused");
|
||||
|
||||
let hashing = MinerRow { online: true, is_mining: true, ..Default::default() };
|
||||
let hashing = MinerRow { is_mining: true, ..Default::default() };
|
||||
assert_eq!(hashing.status(), "hashing");
|
||||
|
||||
let not_hashing = MinerRow { online: true, ..Default::default() };
|
||||
assert_eq!(not_hashing.status(), "not hashing");
|
||||
|
||||
// offline outranks slow/paused/hashing in the precedence order.
|
||||
let offline_but_flagged =
|
||||
MinerRow { online: false, slow: true, paused: true, is_mining: true, ..Default::default() };
|
||||
assert_eq!(offline_but_flagged.status(), "offline");
|
||||
|
||||
// slow outranks paused (and hashing).
|
||||
let slow_and_paused = MinerRow { online: true, slow: true, paused: true, ..Default::default() };
|
||||
let slow_and_paused = MinerRow { slow: true, paused: true, is_mining: true, ..Default::default() };
|
||||
assert_eq!(slow_and_paused.status(), "slow");
|
||||
|
||||
// paused outranks hashing.
|
||||
let paused_but_mining = MinerRow { paused: true, is_mining: true, ..Default::default() };
|
||||
assert_eq!(paused_but_mining.status(), "paused");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -1562,4 +1634,34 @@ mod tests {
|
||||
assert!(!is_paused("Mining", false));
|
||||
assert!(!is_paused("", false));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn kpis_bucket_by_status_not_raw_flags() {
|
||||
// compute_kpis must bucket by status()'s precedence, so a row's KPI
|
||||
// bucket can never disagree with its status text.
|
||||
let rows = vec![
|
||||
MinerRow { slow: true, paused: true, is_mining: true, ..Default::default() }, // slow wins
|
||||
MinerRow { paused: true, is_mining: true, ..Default::default() }, // paused over hashing
|
||||
MinerRow { is_mining: true, ..Default::default() }, // hashing
|
||||
MinerRow { ..Default::default() }, // not hashing
|
||||
];
|
||||
let idx: Vec<usize> = (0..rows.len()).collect();
|
||||
let k = compute_kpis(&rows, &idx);
|
||||
assert_eq!(k.slow, 1);
|
||||
assert_eq!(k.paused, 1, "paused outranks the mining flag");
|
||||
assert_eq!(k.hashing, 1);
|
||||
assert_eq!(k.not_hashing, 1);
|
||||
assert_eq!(k.total, 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn flash_confirmed_requires_exact_word() {
|
||||
assert!(flash_confirmed("FLASH"));
|
||||
assert!(flash_confirmed(" FLASH "), "surrounding whitespace is trimmed");
|
||||
assert!(!flash_confirmed("flash"), "case-sensitive");
|
||||
assert!(!flash_confirmed("Flash"));
|
||||
assert!(!flash_confirmed("FLASHING"), "not a prefix match");
|
||||
assert!(!flash_confirmed("FLASH NOW"));
|
||||
assert!(!flash_confirmed(""));
|
||||
}
|
||||
}
|
||||
|
||||
+258
-26
@@ -120,6 +120,32 @@ pub fn parse_line(line: &str) -> Result<Vec<Ipv4Addr>, String> {
|
||||
}
|
||||
return Ok((0..count).map(|i| Ipv4Addr::from(base + i as u32)).collect());
|
||||
}
|
||||
// Per-octet ranges: each of the four octets may be a single number or an
|
||||
// inclusive `a-b` range, e.g. "10.1-9.1.1-255" scans the cartesian product
|
||||
// (the 9 /24s: 10.1.1.x .. 10.9.1.x). This also subsumes a plain single
|
||||
// address and a bare last-octet range like "10.253.1.3-234".
|
||||
let parts: Vec<&str> = line.split('.').collect();
|
||||
if parts.len() == 4 && parts.iter().all(|p| is_octet_spec(p)) {
|
||||
let r: Vec<(u8, u8)> =
|
||||
parts.iter().map(|p| parse_octet_spec(p)).collect::<Result<_, String>>()?;
|
||||
let count: u64 = r.iter().map(|(lo, hi)| (*hi as u64 - *lo as u64 + 1)).product();
|
||||
if count > MAX_ADDRS {
|
||||
return Err(format!("range too large (> {MAX_ADDRS} addresses): {line}"));
|
||||
}
|
||||
let mut out = Vec::with_capacity(count as usize);
|
||||
for a in r[0].0..=r[0].1 {
|
||||
for b in r[1].0..=r[1].1 {
|
||||
for c in r[2].0..=r[2].1 {
|
||||
for d in r[3].0..=r[3].1 {
|
||||
out.push(Ipv4Addr::new(a, b, c, d));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return Ok(out);
|
||||
}
|
||||
// Full A-B range across two dotted addresses (e.g. "10.0.0.1-10.7.255.254"),
|
||||
// which the per-octet form above cannot express.
|
||||
if let Some((start_s, end_s)) = line.split_once('-') {
|
||||
let start: Ipv4Addr = start_s
|
||||
.trim()
|
||||
@@ -148,6 +174,27 @@ pub fn parse_line(line: &str) -> Result<Vec<Ipv4Addr>, String> {
|
||||
Ok(vec![addr])
|
||||
}
|
||||
|
||||
/// Parse one octet spec: `"n"` -> `(n, n)`, or `"a-b"` -> `(a, b)` inclusive
|
||||
/// (rejecting `a > b`). Used by the per-octet range form in `parse_line`.
|
||||
fn parse_octet_spec(s: &str) -> Result<(u8, u8), String> {
|
||||
let s = s.trim();
|
||||
if let Some((lo, hi)) = s.split_once('-') {
|
||||
let lo: u8 = lo.trim().parse().map_err(|_| format!("bad octet range: {s}"))?;
|
||||
let hi: u8 = hi.trim().parse().map_err(|_| format!("bad octet range: {s}"))?;
|
||||
if lo > hi {
|
||||
return Err(format!("octet range start after end: {s}"));
|
||||
}
|
||||
Ok((lo, hi))
|
||||
} else {
|
||||
let n: u8 = s.parse().map_err(|_| format!("bad octet: {s}"))?;
|
||||
Ok((n, n))
|
||||
}
|
||||
}
|
||||
|
||||
fn is_octet_spec(s: &str) -> bool {
|
||||
parse_octet_spec(s).is_ok()
|
||||
}
|
||||
|
||||
fn prefix_mask(prefix: u8) -> u32 {
|
||||
if prefix == 0 {
|
||||
0
|
||||
@@ -258,13 +305,8 @@ pub fn start_scan(lines: Vec<String>) -> ScanHandle {
|
||||
let err_tx = tx.clone();
|
||||
let res = std::thread::Builder::new().name("fake-scan".into()).spawn(move || {
|
||||
let rows = crate::fixtures::bench_fleet();
|
||||
// A synthetic unreachable host, so the offline-recognition path
|
||||
// (a probed address with no miner behind it) is exercised even
|
||||
// when running fully offline against fixtures.
|
||||
let offline_ip = "10.255.1.254".to_string();
|
||||
let mut targets: HashSet<String> = rows.iter().map(|r| r.ip.clone()).collect();
|
||||
targets.insert(offline_ip.clone());
|
||||
let total = rows.len() + 1;
|
||||
let targets: HashSet<String> = rows.iter().map(|r| r.ip.clone()).collect();
|
||||
let total = rows.len();
|
||||
let _ = tx.send(ScanMsg::Started { total, targets });
|
||||
for (i, row) in rows.into_iter().enumerate() {
|
||||
if thread_cancel.load(Ordering::Relaxed) {
|
||||
@@ -275,13 +317,6 @@ pub fn start_scan(lines: Vec<String>) -> ScanHandle {
|
||||
}
|
||||
let _ = tx.send(ScanMsg::Progress { done: i + 1, total, ip: String::new() });
|
||||
}
|
||||
if thread_cancel.load(Ordering::Relaxed) {
|
||||
return;
|
||||
}
|
||||
if tx.send(ScanMsg::Row(MinerRow::offline(offline_ip))).is_err() {
|
||||
return;
|
||||
}
|
||||
let _ = tx.send(ScanMsg::Progress { done: total, total, ip: String::new() });
|
||||
let _ = tx.send(ScanMsg::Done("fixtures".into()));
|
||||
});
|
||||
if let Err(e) = res {
|
||||
@@ -338,15 +373,16 @@ pub fn start_scan(lines: Vec<String>) -> ScanHandle {
|
||||
return; // Stop / re-scan requested
|
||||
}
|
||||
done += 1;
|
||||
// Always report a row, even for an address that answered no
|
||||
// miner protocol: `MinerRow::offline` keeps it visible (and
|
||||
// distinct from a row the scan simply never reached).
|
||||
let row = match miner {
|
||||
Some(m) => to_row(&*m).await,
|
||||
None => MinerRow::offline(ip.to_string()),
|
||||
};
|
||||
if tx.send(ScanMsg::Row(row)).is_err() {
|
||||
return; // UI gone
|
||||
// Only surface a row for an address that actually has a miner
|
||||
// behind it. A non-responding address is not shown -- we never
|
||||
// fabricate a phantom "offline" row for an empty IP; a miner is
|
||||
// reported as "not hashing" only when it responds and we can see
|
||||
// it is not mining.
|
||||
if let Some(m) = miner {
|
||||
let row = to_row(&*m).await;
|
||||
if tx.send(ScanMsg::Row(row)).is_err() {
|
||||
return; // UI gone
|
||||
}
|
||||
}
|
||||
if done % step == 0 || done == total {
|
||||
let _ = tx.send(ScanMsg::Progress { done, total, ip: ip.to_string() });
|
||||
@@ -361,6 +397,34 @@ pub fn start_scan(lines: Vec<String>) -> ScanHandle {
|
||||
ScanHandle { rx, cancel }
|
||||
}
|
||||
|
||||
/// Flatten a miner's structured messages into display lines, most severe first
|
||||
/// ("[Error] text (component)"), for the Errors column + hover tooltip.
|
||||
fn summarize_messages(messages: &[asic_rs::core::data::message::MinerMessage]) -> Vec<String> {
|
||||
use asic_rs::core::data::message::MessageSeverity;
|
||||
let rank = |s: &MessageSeverity| match s {
|
||||
MessageSeverity::Error => 0u8,
|
||||
MessageSeverity::Warning => 1,
|
||||
MessageSeverity::Info => 2,
|
||||
};
|
||||
let mut ranked: Vec<(u8, String)> = messages
|
||||
.iter()
|
||||
.map(|m| {
|
||||
let sev = match m.severity {
|
||||
MessageSeverity::Error => "Error",
|
||||
MessageSeverity::Warning => "Warning",
|
||||
MessageSeverity::Info => "Info",
|
||||
};
|
||||
let line = match &m.component {
|
||||
Some(c) => format!("[{sev}] {} ({c})", m.message),
|
||||
None => format!("[{sev}] {}", m.message),
|
||||
};
|
||||
(rank(&m.severity), line)
|
||||
})
|
||||
.collect();
|
||||
ranked.sort_by_key(|(r, _)| *r);
|
||||
ranked.into_iter().map(|(_, s)| s).collect()
|
||||
}
|
||||
|
||||
async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
let data = miner.get_data().await;
|
||||
let hashrate_ths = data
|
||||
@@ -448,11 +512,22 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
tuning: miner.supports_set_tuning_percent(),
|
||||
firmware_flash: miner.supports_upgrade_firmware(),
|
||||
};
|
||||
// PIC vs noPIC is not reported over the network by asic-rs; best-effort
|
||||
// heuristic from the model string, else unknown (true detection needs an
|
||||
// on-board SSH/I2C probe -- a separate feature).
|
||||
let pic_present = if model.to_lowercase().contains("nopic") { Some(false) } else { None };
|
||||
// Access: locked/view-only when the miner exposes no writable control at
|
||||
// all, otherwise unlocked. Inferred from capabilities (asic-rs has no direct
|
||||
// lock-state field).
|
||||
let write_locked = Some(!caps.any_control());
|
||||
let errors = summarize_messages(&data.messages);
|
||||
MinerRow {
|
||||
ip: data.ip.to_string(),
|
||||
selected: false,
|
||||
online: true,
|
||||
caps,
|
||||
pic_present,
|
||||
write_locked,
|
||||
errors,
|
||||
model,
|
||||
mac: data.mac.map(|m| m.to_string()).unwrap_or_default(),
|
||||
hostname: data.hostname.clone().unwrap_or_default(),
|
||||
@@ -506,8 +581,8 @@ impl ConfigAction {
|
||||
/// Short label for status text and summaries.
|
||||
pub fn label(&self) -> String {
|
||||
match self {
|
||||
ConfigAction::FaultLight(true) => "fault light on".into(),
|
||||
ConfigAction::FaultLight(false) => "fault light off".into(),
|
||||
ConfigAction::FaultLight(true) => "flash lights on".into(),
|
||||
ConfigAction::FaultLight(false) => "flash lights off".into(),
|
||||
ConfigAction::Restart => "restart".into(),
|
||||
ConfigAction::Pause => "pause".into(),
|
||||
ConfigAction::Resume => "resume".into(),
|
||||
@@ -559,9 +634,13 @@ pub fn start_config_action(ips: Vec<String>, action: ConfigAction) -> ActionHand
|
||||
|
||||
if fake_scan_enabled() {
|
||||
let err_tx = tx.clone();
|
||||
let thread_cancel = cancel.clone();
|
||||
let res = std::thread::Builder::new().name("fake-action".into()).spawn(move || {
|
||||
let mut ok = 0usize;
|
||||
for ip in ips {
|
||||
if thread_cancel.load(Ordering::Relaxed) {
|
||||
break;
|
||||
}
|
||||
let _ = tx.send(ActionMsg::Result { ip, ok: true, detail: "simulated".into() });
|
||||
ok += 1;
|
||||
}
|
||||
@@ -655,10 +734,14 @@ pub fn start_refresh(ips: Vec<String>) -> RefreshHandle {
|
||||
|
||||
if fake_scan_enabled() {
|
||||
let err_tx = tx.clone();
|
||||
let thread_cancel = cancel.clone();
|
||||
let res = std::thread::Builder::new().name("fake-refresh".into()).spawn(move || {
|
||||
let fleet = crate::fixtures::bench_fleet();
|
||||
let mut ok = 0usize;
|
||||
for ip in ips {
|
||||
if thread_cancel.load(Ordering::Relaxed) {
|
||||
break;
|
||||
}
|
||||
match fleet.iter().find(|r| r.ip == ip) {
|
||||
Some(row) => {
|
||||
if tx.send(RefreshMsg::Row(row.clone())).is_err() {
|
||||
@@ -751,9 +834,13 @@ pub fn start_firmware_flash_action(ips: Vec<String>, image: FirmwareImage) -> Ac
|
||||
|
||||
if fake_scan_enabled() {
|
||||
let err_tx = tx.clone();
|
||||
let thread_cancel = cancel.clone();
|
||||
let res = std::thread::Builder::new().name("fake-firmware-flash".into()).spawn(move || {
|
||||
let mut ok = 0usize;
|
||||
for ip in ips {
|
||||
if thread_cancel.load(Ordering::Relaxed) {
|
||||
break;
|
||||
}
|
||||
let _ = tx.send(ActionMsg::Result { ip, ok: true, detail: "simulated".into() });
|
||||
ok += 1;
|
||||
}
|
||||
@@ -851,6 +938,31 @@ mod tests {
|
||||
assert_eq!(*ips.last().unwrap(), Ipv4Addr::new(10, 253, 1, 234));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_per_octet_ranges() {
|
||||
// The user's example: 9 /24s (octet2 1..9), each with .1.1-255.
|
||||
let ips = parse_line("10.1-9.1.1-255").unwrap();
|
||||
assert_eq!(ips.len(), 9 * 255, "9 /24 ranges of 255 addresses each");
|
||||
assert_eq!(ips[0], Ipv4Addr::new(10, 1, 1, 1), "ascending, first combo");
|
||||
assert_eq!(*ips.last().unwrap(), Ipv4Addr::new(10, 9, 1, 255));
|
||||
// Ordered by octet: the second address is .1.1.2, the 256th is .2.1.1.
|
||||
assert_eq!(ips[1], Ipv4Addr::new(10, 1, 1, 2));
|
||||
assert_eq!(ips[255], Ipv4Addr::new(10, 2, 1, 1));
|
||||
|
||||
// Ranges in more than one octet.
|
||||
let ips = parse_line("192.168.0-1.10-12").unwrap();
|
||||
assert_eq!(ips.len(), 2 * 3);
|
||||
assert_eq!(ips[0], Ipv4Addr::new(192, 168, 0, 10));
|
||||
assert_eq!(*ips.last().unwrap(), Ipv4Addr::new(192, 168, 1, 12));
|
||||
|
||||
// A single address still works through the per-octet path.
|
||||
assert_eq!(parse_line("10.0.0.5").unwrap(), vec![Ipv4Addr::new(10, 0, 0, 5)]);
|
||||
// Reversed octet range is an error.
|
||||
assert!(parse_line("10.9-1.1.1").is_err());
|
||||
// Out-of-range octet falls through and is reported.
|
||||
assert!(parse_line("10.1.1.999").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_cross_octet_range() {
|
||||
let ips = parse_line("10.253.1.250-10.253.2.5").unwrap();
|
||||
@@ -1052,4 +1164,124 @@ mod tests {
|
||||
println!("bench_targets_to_cidrs_large_range: {} addrs -> {sink} cidrs, {:?}/op", ips.len(), per);
|
||||
assert!(per.as_millis() < 200, "targets_to_cidrs regressed: {per:?}/op");
|
||||
}
|
||||
|
||||
/// Exercise the round-6 background actions through their fake-scan branch:
|
||||
/// offline-row emission (start_scan), per-IP refresh (start_refresh),
|
||||
/// firmware flash (start_firmware_flash_action), and that a cancelled run
|
||||
/// still terminates. ALKANE_FAKE_SCAN is process-global, but no other test
|
||||
/// calls these functions, so setting it here only affects this one
|
||||
/// (sequential) test; all fake-mode assertions live in a single #[test] so
|
||||
/// they never race each other over the env var.
|
||||
#[test]
|
||||
fn fake_mode_background_actions() {
|
||||
use std::sync::mpsc::RecvTimeoutError;
|
||||
use std::time::Duration;
|
||||
let deadline = Duration::from_secs(5);
|
||||
std::env::set_var(FAKE_SCAN_ENV, "1");
|
||||
|
||||
// start_scan (fake): streams exactly the bench-fleet fixtures, one Row
|
||||
// per fixture, and no fabricated rows for empty addresses.
|
||||
{
|
||||
let h = start_scan(vec!["10.255.1.0/30".into()]);
|
||||
let mut rows = Vec::new();
|
||||
let mut total = 0usize;
|
||||
loop {
|
||||
match h.rx.recv_timeout(deadline) {
|
||||
Ok(ScanMsg::Started { total: t, .. }) => total = t,
|
||||
Ok(ScanMsg::Row(r)) => rows.push(r),
|
||||
Ok(ScanMsg::Done(_)) => break,
|
||||
Ok(_) => {}
|
||||
Err(RecvTimeoutError::Timeout) => panic!("fake start_scan hung"),
|
||||
Err(RecvTimeoutError::Disconnected) => break,
|
||||
}
|
||||
}
|
||||
let fleet = crate::fixtures::bench_fleet();
|
||||
assert_eq!(rows.len(), fleet.len(), "one Row per fixture, no phantom offline rows");
|
||||
assert_eq!(total, fleet.len());
|
||||
assert!(rows.iter().all(|r| r.status() != "offline"), "no 'offline' status exists");
|
||||
}
|
||||
|
||||
// start_refresh: a known fixture IP re-reads as a Row, an unknown IP is
|
||||
// reported Failed{offline}, and the run ends with Done{ok:1,total:2}.
|
||||
{
|
||||
let known = "10.255.1.112".to_string(); // an S17 in bench_fleet
|
||||
let unknown = "10.0.0.250".to_string();
|
||||
let h = start_refresh(vec![known.clone(), unknown.clone()]);
|
||||
let (mut rows, mut failed, mut done) = (0usize, 0usize, None);
|
||||
loop {
|
||||
match h.rx.recv_timeout(deadline) {
|
||||
Ok(RefreshMsg::Started { .. }) => {}
|
||||
Ok(RefreshMsg::Row(r)) => {
|
||||
assert_eq!(r.ip, known);
|
||||
rows += 1;
|
||||
}
|
||||
Ok(RefreshMsg::Failed { ip, detail }) => {
|
||||
assert_eq!(ip, unknown);
|
||||
assert_eq!(detail, "offline");
|
||||
failed += 1;
|
||||
}
|
||||
Ok(RefreshMsg::Done { ok, total }) => {
|
||||
done = Some((ok, total));
|
||||
break;
|
||||
}
|
||||
Err(RecvTimeoutError::Timeout) => panic!("fake start_refresh hung"),
|
||||
Err(RecvTimeoutError::Disconnected) => break,
|
||||
}
|
||||
}
|
||||
assert_eq!(rows, 1);
|
||||
assert_eq!(failed, 1);
|
||||
assert_eq!(done, Some((1, 2)));
|
||||
}
|
||||
|
||||
// start_firmware_flash_action: fake mode reports one simulated success
|
||||
// per IP and a matching Done summary.
|
||||
{
|
||||
let image = FirmwareImage::new("fw.bin".to_string(), vec![0u8; 8]);
|
||||
let h = start_firmware_flash_action(
|
||||
vec!["10.255.1.166".into(), "10.255.1.149".into()],
|
||||
image,
|
||||
);
|
||||
let (mut results, mut done) = (0usize, None);
|
||||
loop {
|
||||
match h.rx.recv_timeout(deadline) {
|
||||
Ok(ActionMsg::Started { .. }) => {}
|
||||
Ok(ActionMsg::Result { ok, detail, .. }) => {
|
||||
assert!(ok);
|
||||
assert_eq!(detail, "simulated");
|
||||
results += 1;
|
||||
}
|
||||
Ok(ActionMsg::Done { ok, total }) => {
|
||||
done = Some((ok, total));
|
||||
break;
|
||||
}
|
||||
Err(RecvTimeoutError::Timeout) => panic!("fake flash hung"),
|
||||
Err(RecvTimeoutError::Disconnected) => break,
|
||||
}
|
||||
}
|
||||
assert_eq!(results, 2);
|
||||
assert_eq!(done, Some((2, 2)));
|
||||
}
|
||||
|
||||
// Cancellation contract: stopping a run still delivers a terminal Done
|
||||
// rather than hanging (the fake branches now honour the cancel flag).
|
||||
{
|
||||
let big: Vec<String> = (0..200).map(|i| format!("10.9.0.{}", i % 256)).collect();
|
||||
let h = start_refresh(big);
|
||||
h.stop();
|
||||
let mut saw_done = false;
|
||||
loop {
|
||||
match h.rx.recv_timeout(deadline) {
|
||||
Ok(RefreshMsg::Done { .. }) => {
|
||||
saw_done = true;
|
||||
break;
|
||||
}
|
||||
Ok(_) => {}
|
||||
Err(_) => break,
|
||||
}
|
||||
}
|
||||
assert!(saw_done, "a cancelled fake refresh must still emit Done, not hang");
|
||||
}
|
||||
|
||||
std::env::remove_var(FAKE_SCAN_ENV);
|
||||
}
|
||||
}
|
||||
|
||||
+435
-74
@@ -58,6 +58,12 @@ const ID_FLASH_CANCEL: i32 = 745;
|
||||
const ID_CREDS_SAVE: i32 = 746;
|
||||
const ID_CREDS_CLEAR: i32 = 747;
|
||||
const ID_CREDS_CANCEL: i32 = 748;
|
||||
// Column-header right-click menu (Excel-style).
|
||||
const ID_HDR_SORT_ASC: i32 = 760;
|
||||
const ID_HDR_SORT_DESC: i32 = 761;
|
||||
const ID_HDR_HIDE: i32 = 762;
|
||||
const ID_HDR_AUTOSIZE: i32 = 763;
|
||||
const ID_HDR_COLUMNS: i32 = 764;
|
||||
// Ticks (~seconds) to keep an action's result on the status bar before the
|
||||
// idle/countdown status takes over again.
|
||||
const ACTION_RESULT_TICKS: u8 = 8;
|
||||
@@ -82,6 +88,8 @@ struct Palette {
|
||||
amber: (u8, u8, u8),
|
||||
red: (u8, u8, u8),
|
||||
accent: (u8, u8, u8),
|
||||
/// Odd-row (zebra) background: a subtle tint of the window colour.
|
||||
zebra: (u8, u8, u8),
|
||||
}
|
||||
|
||||
fn luminance(c: (u8, u8, u8)) -> f32 {
|
||||
@@ -100,10 +108,11 @@ fn tint_toward(base: (u8, u8, u8), target: (u8, u8, u8), f: f64) -> (u8, u8, u8)
|
||||
}
|
||||
|
||||
/// Colour for a combined actual/expected ratio (Hashrate/Hashboards/
|
||||
/// TotalChips): red at 0, amber at 0.5, green at 1.0+, clamped and
|
||||
/// interpolated linearly between those stops.
|
||||
/// TotalChips): full red at 50% (or below), amber at 75%, green at 100%+,
|
||||
/// interpolated linearly -- calibrated so a miner running at half its expected
|
||||
/// output reads as clearly bad, and 100% reads green.
|
||||
fn ratio_color(pal: &Palette, ratio: f64) -> (u8, u8, u8) {
|
||||
let t = ratio.clamp(0.0, 1.0);
|
||||
let t = ((ratio - 0.5) / 0.5).clamp(0.0, 1.0);
|
||||
if t <= 0.5 {
|
||||
tint_toward(pal.red, pal.amber, t / 0.5)
|
||||
} else {
|
||||
@@ -111,6 +120,12 @@ fn ratio_color(pal: &Palette, ratio: f64) -> (u8, u8, u8) {
|
||||
}
|
||||
}
|
||||
|
||||
/// Colour for a chip-temperature reading: cool blue at/below 40 C fading to hot
|
||||
/// red at/above 90 C, so a hot miner reads red at a glance.
|
||||
fn temp_color(pal: &Palette, temp_c: f64) -> (u8, u8, u8) {
|
||||
tint_toward(pal.accent, pal.red, ((temp_c - 40.0) / 50.0).clamp(0.0, 1.0))
|
||||
}
|
||||
|
||||
/// Colour for one cooling-fan RPM: muted grey (stopped/unknown) fading to
|
||||
/// accent blue as the RPM approaches 6000 (comfortably above a healthy fan's
|
||||
/// typical ceiling, so a spinning fan reads as a clear, saturated blue).
|
||||
@@ -118,24 +133,46 @@ fn fan_color(pal: &Palette, rpm: f64) -> (u8, u8, u8) {
|
||||
tint_toward(pal.label, pal.accent, (rpm / 6000.0).clamp(0.0, 1.0))
|
||||
}
|
||||
|
||||
/// Build the segment-encoded cell text for a combined actual/expected column
|
||||
/// (Hashrate/Hashboards/TotalChips): when both halves are known (`plain`
|
||||
/// contains " / " and a ratio was computable), colour just the actual half by
|
||||
/// how it compares to expected and leave the separator + expected half in the
|
||||
/// default colour. Anything else (blank, actual-only, or no ratio) falls back
|
||||
/// to one plain, uncoloured segment so the encoding always round-trips to the
|
||||
/// same text `decode_segments_plain` would read back.
|
||||
fn encode_combined_cell(pal: &Palette, plain: &str, ratio: Option<f64>) -> String {
|
||||
match (plain.split_once(" / "), ratio) {
|
||||
(Some((actual, expected)), Some(ratio)) => encode_segments(&[
|
||||
(Some(ratio_color(pal, ratio)), actual.to_string()),
|
||||
(None, " / ".to_string()),
|
||||
(None, expected.to_string()),
|
||||
/// Build the segment-encoded cell for a combined actual/expected column
|
||||
/// (Hashrate/Hashboards/TotalChips) from its already-formatted parts: the
|
||||
/// actual half is coloured by `ratio` when both halves are known, the separator
|
||||
/// `sep` and the expected half stay the default text colour, and an unknown
|
||||
/// actual shows "-". Round-trips (via decode_segments_plain) to the same plain
|
||||
/// text the model's combined cell produces.
|
||||
fn encode_combined_cell(
|
||||
pal: &Palette,
|
||||
actual: Option<String>,
|
||||
expected: Option<String>,
|
||||
sep: &str,
|
||||
ratio: Option<f64>,
|
||||
) -> String {
|
||||
match (actual, expected) {
|
||||
(None, None) => encode_segments(&[(None, String::new())]),
|
||||
(Some(a), None) => encode_segments(&[(None, a)]),
|
||||
(a, Some(e)) => encode_segments(&[
|
||||
(ratio.map(|r| ratio_color(pal, r)), a.unwrap_or_else(|| "-".to_string())),
|
||||
(None, sep.to_string()),
|
||||
(None, e),
|
||||
]),
|
||||
_ => encode_segments(&[(None, plain.to_string())]),
|
||||
}
|
||||
}
|
||||
|
||||
/// Segment-encoded Chip-temp cell: the reading coloured on the blue-to-red
|
||||
/// temperature scale (blank cell stays blank).
|
||||
fn encode_temp_cell(pal: &Palette, plain: &str, temp_c: f64) -> String {
|
||||
if plain.is_empty() {
|
||||
encode_segments(&[(None, String::new())])
|
||||
} else {
|
||||
encode_segments(&[(Some(temp_color(pal, temp_c)), plain.to_string())])
|
||||
}
|
||||
}
|
||||
|
||||
/// Segment-encoded single-colour cell (Access/Errors): `plain` in `color`, or
|
||||
/// the default text colour when `color` is None.
|
||||
fn encode_flag_cell(plain: &str, color: Option<(u8, u8, u8)>) -> String {
|
||||
encode_segments(&[(color, plain.to_string())])
|
||||
}
|
||||
|
||||
/// Build the segment-encoded cell text for the Cooling column: each fan's RPM
|
||||
/// gets its own grey-to-blue colour by speed, and the "/" separators between
|
||||
/// them stay in the default text colour.
|
||||
@@ -199,7 +236,7 @@ fn kind_color(pal: &Palette, k: ColorKind) -> (u8, u8, u8) {
|
||||
/// what each status "looks like".
|
||||
fn status_kind_color(pal: &Palette, status: &str) -> (u8, u8, u8) {
|
||||
match status {
|
||||
"offline" | "not hashing" => pal.red,
|
||||
"not hashing" => pal.red,
|
||||
"paused" => pal.accent,
|
||||
"slow" => pal.amber,
|
||||
"hashing" => pal.green,
|
||||
@@ -207,14 +244,6 @@ fn status_kind_color(pal: &Palette, status: &str) -> (u8, u8, u8) {
|
||||
}
|
||||
}
|
||||
|
||||
/// A miner row's text colour, by status: green = hashing, amber = slow, blue =
|
||||
/// paused, red = offline/not hashing. This both conveys status and separates
|
||||
/// rows visually (GTK's native zebra/alt-row support is unreliable and fights
|
||||
/// selection).
|
||||
fn status_color(pal: &Palette, r: &MinerRow) -> (u8, u8, u8) {
|
||||
status_kind_color(pal, r.status())
|
||||
}
|
||||
|
||||
fn palette() -> Palette {
|
||||
let win = wx_rs::system_color(0); // window background
|
||||
let text = wx_rs::system_color(1); // window text
|
||||
@@ -229,6 +258,9 @@ fn palette() -> Palette {
|
||||
amber: if dark { (245, 190, 66) } else { (176, 120, 10) },
|
||||
red: if dark { (245, 110, 100) } else { (198, 55, 45) },
|
||||
accent: if dark { (108, 168, 250) } else { (40, 100, 170) },
|
||||
// Subtle zebra tint of the window: slightly lighter in dark mode, a
|
||||
// touch darker than the light window.
|
||||
zebra: if dark { nudge(win, 12) } else { nudge(win, -10) },
|
||||
}
|
||||
}
|
||||
|
||||
@@ -292,6 +324,15 @@ pub struct App {
|
||||
flash_confirm_dialog: Widget,
|
||||
flash_confirm_input: Widget,
|
||||
pending_flash: Option<(Vec<String>, FirmwareImage, String)>,
|
||||
// True while a firmware flash's ActionHandle is in flight. A flash is the
|
||||
// one irreversible, hardware-destroying action, so it takes an exclusive
|
||||
// lock: nothing else (scan / refresh / config action / another flash) may
|
||||
// start while it runs, and it will not start while anything else is running,
|
||||
// so no two network operations ever race the same miner mid-upload.
|
||||
flashing: bool,
|
||||
// The column a header right-click menu targets (remembered across the menu's
|
||||
// nested event loop until an item is chosen).
|
||||
header_menu_col: Option<Column>,
|
||||
// The "Set scan credentials..." dialog.
|
||||
creds_dialog: Widget,
|
||||
creds_user_input: Widget,
|
||||
@@ -337,6 +378,9 @@ pub fn build(frame: Widget) -> App {
|
||||
let vc = kind_color(&pal, kind);
|
||||
let card = Widget::panel(panel);
|
||||
card.set_bg(pal.card_bg.0, pal.card_bg.1, pal.card_bg.2);
|
||||
// Uniform size so every KPI box is identical regardless of its content
|
||||
// (wide enough for the largest value, e.g. "685 TH/s" / "21.3 kW").
|
||||
card.set_min_size(150, 62);
|
||||
let cs = Widget::box_sizer(true);
|
||||
let value = Widget::static_text(card, "0");
|
||||
value.set_font_size(19);
|
||||
@@ -347,10 +391,21 @@ pub fn build(frame: Widget) -> App {
|
||||
lbl.set_font_size(9);
|
||||
lbl.set_fg(pal.label.0, pal.label.1, pal.label.2);
|
||||
lbl.set_bg(pal.card_bg.0, pal.card_bg.1, pal.card_bg.2);
|
||||
cs.add(value, 0, sf::BORDER_LEFT | sf::BORDER_TOP | sf::BORDER_RIGHT, 12);
|
||||
cs.add(lbl, 0, sf::BORDER_LEFT | sf::BORDER_BOTTOM | sf::BORDER_RIGHT, 12);
|
||||
// Centre both texts horizontally: a stretch spacer on each side (no
|
||||
// ALIGN_CENTRE_HORIZONTAL flag exists in the bridge).
|
||||
let centre = |w: Widget| {
|
||||
let row = Widget::box_sizer(false);
|
||||
row.add_stretch(1);
|
||||
row.add(w, 0, sf::ALIGN_CENTRE_VERTICAL, 0);
|
||||
row.add_stretch(1);
|
||||
row
|
||||
};
|
||||
cs.add_stretch(1);
|
||||
cs.add_sizer(centre(value), 0, sf::EXPAND | sf::BORDER_LEFT | sf::BORDER_TOP | sf::BORDER_RIGHT, 8);
|
||||
cs.add_sizer(centre(lbl), 0, sf::EXPAND | sf::BORDER_LEFT | sf::BORDER_BOTTOM | sf::BORDER_RIGHT, 8);
|
||||
cs.add_stretch(1);
|
||||
cs.set_sizer_on(card);
|
||||
kpi_row.add(card, 1, sf::EXPAND | sf::BORDER_ALL, 4);
|
||||
kpi_row.add(card, 0, sf::BORDER_ALL, 4);
|
||||
kpi_cards.push((card, value, lbl, kind));
|
||||
(card, value)
|
||||
};
|
||||
@@ -462,6 +517,8 @@ pub fn build(frame: Widget) -> App {
|
||||
flash_confirm_dialog: frame,
|
||||
flash_confirm_input: frame,
|
||||
pending_flash: None,
|
||||
flashing: false,
|
||||
header_menu_col: None,
|
||||
creds_dialog: frame,
|
||||
creds_user_input: frame,
|
||||
creds_pass_input: frame,
|
||||
@@ -501,6 +558,9 @@ impl App {
|
||||
t.destroy();
|
||||
}
|
||||
let t = Widget::dvlc(self.table_parent);
|
||||
// Zebra striping (theme-aware) for row separation now that rows are no
|
||||
// longer tinted by status.
|
||||
t.dvlc_set_zebra(Some(self.pal.zebra));
|
||||
// Creation order == display order. IP is the fixed first column (not
|
||||
// reorderable); the rest are reorderable. The active sort column carries
|
||||
// an ASCII direction marker in its header ("^" asc, "v" desc) -- wx's
|
||||
@@ -514,7 +574,7 @@ impl App {
|
||||
Some((sc, false)) if sc == c => title.push_str(" v"),
|
||||
_ => {}
|
||||
}
|
||||
if matches!(c, Column::Hashrate | Column::Hashboards | Column::TotalChips | Column::Cooling) {
|
||||
if matches!(c, Column::Hashrate | Column::Hashboards | Column::TotalChips | Column::ChipTemp | Column::Cooling | Column::Locked | Column::Error | Column::Status) {
|
||||
// These columns show two-tone / multi-tone text (actual vs.
|
||||
// expected, or one colour per fan) via a custom renderer that
|
||||
// parses the segment-encoded cell value fill_rows writes.
|
||||
@@ -534,6 +594,9 @@ impl App {
|
||||
|
||||
pub fn fill_rows(&mut self) {
|
||||
let Some(t) = self.table else { return };
|
||||
// Hold the scroll position across the full clear+refill so the table
|
||||
// doesn't jump back to the top as new rows stream in during a scan.
|
||||
let top = t.dvlc_get_top_row();
|
||||
t.dvlc_clear();
|
||||
self.view_idx = self.view.view(&self.rows);
|
||||
let cols = self.view.display_columns();
|
||||
@@ -543,37 +606,77 @@ impl App {
|
||||
let refs: Vec<&str> = cells.iter().map(|s| s.as_str()).collect();
|
||||
t.dvlc_append_row(&refs);
|
||||
}
|
||||
// Colour each row's text by status (also separates rows visually).
|
||||
for (disp, &ri) in self.view_idx.iter().enumerate() {
|
||||
t.dvlc_set_row_color(disp, Some(status_color(&self.pal, &self.rows[ri])));
|
||||
}
|
||||
// Overwrite the combined actual/expected + cooling-fan cells with
|
||||
// segment-encoded coloured text (the custom renderer these columns use
|
||||
// parses it back out; see encode_combined_cell/encode_cooling_cell).
|
||||
// Rows are NOT tinted by status any more: every cell is the default text
|
||||
// colour except the conditionally-formatted columns below (the Status
|
||||
// column carries the status colour itself). Zebra striping + gridlines
|
||||
// (set at table build) separate rows instead.
|
||||
// Overwrite the conditionally-coloured cells with segment-encoded text
|
||||
// (the custom renderer these columns use parses it back out).
|
||||
for (disp, &ri) in self.view_idx.iter().enumerate() {
|
||||
let r = &self.rows[ri];
|
||||
for (ci, c) in cols.iter().enumerate() {
|
||||
let encoded = match c {
|
||||
// Combined columns are built from parts: the ratio is gated
|
||||
// on the ACTUAL being known, so an unknown actual renders as
|
||||
// "-/<expected>" in the default colour rather than a red 0%.
|
||||
Column::Hashrate => {
|
||||
let ratio = actual_expected_ratio(r.hashrate_ths, r.expected_ths);
|
||||
encode_combined_cell(&self.pal, &c.cell(r), ratio)
|
||||
let actual = format_hashrate_ths(r.hashrate_ths);
|
||||
let expected = format_hashrate_ths(r.expected_ths);
|
||||
let ratio = (r.hashrate_ths > 0.0)
|
||||
.then(|| actual_expected_ratio(r.hashrate_ths, r.expected_ths))
|
||||
.flatten();
|
||||
encode_combined_cell(&self.pal, actual, expected, "/", ratio)
|
||||
}
|
||||
Column::Hashboards => {
|
||||
let actual = r.hashboards.map(|v| v as f64).unwrap_or(0.0);
|
||||
let expected = r.expected_hashboards.map(|v| v as f64).unwrap_or(0.0);
|
||||
encode_combined_cell(&self.pal, &c.cell(r), actual_expected_ratio(actual, expected))
|
||||
let actual = r.hashboards.map(|v| v.to_string());
|
||||
let expected = r.expected_hashboards.map(|v| v.to_string());
|
||||
let ratio = r.hashboards.and_then(|a| {
|
||||
actual_expected_ratio(
|
||||
a as f64,
|
||||
r.expected_hashboards.map(|v| v as f64).unwrap_or(0.0),
|
||||
)
|
||||
});
|
||||
encode_combined_cell(&self.pal, actual, expected, " / ", ratio)
|
||||
}
|
||||
Column::TotalChips => {
|
||||
let actual = r.total_chips.map(|v| v as f64).unwrap_or(0.0);
|
||||
let expected = r.expected_chips.map(|v| v as f64).unwrap_or(0.0);
|
||||
encode_combined_cell(&self.pal, &c.cell(r), actual_expected_ratio(actual, expected))
|
||||
let actual = r.total_chips.map(|v| v.to_string());
|
||||
let expected = r.expected_chips.map(|v| v.to_string());
|
||||
let ratio = r.total_chips.and_then(|a| {
|
||||
actual_expected_ratio(
|
||||
a as f64,
|
||||
r.expected_chips.map(|v| v as f64).unwrap_or(0.0),
|
||||
)
|
||||
});
|
||||
encode_combined_cell(&self.pal, actual, expected, " / ", ratio)
|
||||
}
|
||||
Column::ChipTemp => encode_temp_cell(&self.pal, &c.cell(r), r.chip_temp_c),
|
||||
Column::Cooling => encode_cooling_cell(&self.pal, &r.fan_rpms),
|
||||
Column::Locked => {
|
||||
// green = unlocked/writable, red = locked/view-only.
|
||||
let color = match r.write_locked {
|
||||
Some(true) => Some(self.pal.red),
|
||||
Some(false) => Some(self.pal.green),
|
||||
None => None,
|
||||
};
|
||||
encode_flag_cell(&c.cell(r), color)
|
||||
}
|
||||
Column::Error => {
|
||||
let color = (!r.errors.is_empty()).then_some(self.pal.red);
|
||||
encode_flag_cell(&c.cell(r), color)
|
||||
}
|
||||
Column::Status => {
|
||||
// Status keeps its status colour on its own cell (the
|
||||
// row is no longer tinted wholesale).
|
||||
encode_flag_cell(&c.cell(r), Some(status_kind_color(&self.pal, r.status())))
|
||||
}
|
||||
_ => continue,
|
||||
};
|
||||
t.dvlc_set_cell(disp, ci, &encoded);
|
||||
}
|
||||
}
|
||||
if let Some(row) = top {
|
||||
t.dvlc_ensure_visible(row.min(self.view_idx.len().saturating_sub(1)));
|
||||
}
|
||||
// Re-apply the selection (a refresh clears the control's selection).
|
||||
let sel: Vec<usize> = self
|
||||
.view_idx
|
||||
@@ -612,6 +715,9 @@ impl App {
|
||||
caption.set_fg(self.pal.label.0, self.pal.label.1, self.pal.label.2);
|
||||
}
|
||||
self.highlight_kpi_filter();
|
||||
if let Some(t) = self.table {
|
||||
t.dvlc_set_zebra(Some(self.pal.zebra));
|
||||
}
|
||||
self.fill_rows(); // re-colour rows with the new palette
|
||||
self.table_parent.layout();
|
||||
}
|
||||
@@ -672,6 +778,13 @@ impl App {
|
||||
let menu = Widget::menu_new();
|
||||
let open = if n == 1 { "Open in browser".to_string() } else { format!("Open {n} miners in browser") };
|
||||
menu.menu_append(ID_CTX_OPEN, &open);
|
||||
// While a firmware flash holds the exclusive lock, offer only the
|
||||
// read-only "Open in browser" action; every network action is refused
|
||||
// anyway, so don't dangle them in the menu.
|
||||
if self.flashing {
|
||||
self.pending_popup = Some((t, menu));
|
||||
return;
|
||||
}
|
||||
menu.menu_append_separator();
|
||||
// Refresh is always offered for a non-empty selection, independent of
|
||||
// the capability intersection below.
|
||||
@@ -684,8 +797,8 @@ impl App {
|
||||
if !caps.is_empty() {
|
||||
let sfx = if n == 1 { String::new() } else { format!(" ({n})") };
|
||||
if caps.fault_light {
|
||||
menu.menu_append(ID_CTX_LIGHT_ON, &format!("Fault light on{sfx}"));
|
||||
menu.menu_append(ID_CTX_LIGHT_OFF, &format!("Fault light off{sfx}"));
|
||||
menu.menu_append(ID_CTX_LIGHT_ON, &format!("Flash lights on{sfx}"));
|
||||
menu.menu_append(ID_CTX_LIGHT_OFF, &format!("Flash lights off{sfx}"));
|
||||
}
|
||||
if caps.pause {
|
||||
menu.menu_append(ID_CTX_PAUSE, &format!("Pause mining{sfx}"));
|
||||
@@ -740,6 +853,10 @@ impl App {
|
||||
if ips.is_empty() {
|
||||
return;
|
||||
}
|
||||
if self.flashing {
|
||||
wx_rs::set_status_text("firmware flash in progress -- wait for it to finish");
|
||||
return;
|
||||
}
|
||||
if let Some(old) = self.action.take() {
|
||||
old.stop();
|
||||
}
|
||||
@@ -755,6 +872,10 @@ impl App {
|
||||
if ips.is_empty() {
|
||||
return;
|
||||
}
|
||||
if self.flashing {
|
||||
wx_rs::set_status_text("firmware flash in progress -- wait for it to finish");
|
||||
return;
|
||||
}
|
||||
if let Some(old) = self.refresh.take() {
|
||||
old.stop();
|
||||
}
|
||||
@@ -767,6 +888,9 @@ impl App {
|
||||
/// actions (power limit / tuning %) return a prompt dialog to show modally.
|
||||
fn on_menu_item(&mut self, id: i32) -> Option<Widget> {
|
||||
match id {
|
||||
ID_HDR_SORT_ASC | ID_HDR_SORT_DESC | ID_HDR_HIDE | ID_HDR_AUTOSIZE | ID_HDR_COLUMNS => {
|
||||
return self.on_header_menu(id)
|
||||
}
|
||||
ID_CTX_OPEN => {
|
||||
for ip in self.selected_ip_list() {
|
||||
wx_rs::launch_browser(&format!("http://{ip}"));
|
||||
@@ -774,13 +898,19 @@ impl App {
|
||||
}
|
||||
ID_CTX_REFRESH => self.start_refresh(self.selected_ip_list()),
|
||||
ID_CTX_FLASH => {
|
||||
let supporting: Vec<String> = self
|
||||
// A flash needs exclusive hardware access; don't even prompt if
|
||||
// any scan / refresh / action is running (re-checked at confirm).
|
||||
if self.flashing || self.scanning || self.action.is_some() || self.refresh.is_some() {
|
||||
wx_rs::set_status_text("busy (scan/action in progress) -- try again once it finishes");
|
||||
return None;
|
||||
}
|
||||
let targets: Vec<(String, String)> = self
|
||||
.selected_rows()
|
||||
.iter()
|
||||
.filter(|r| r.caps.firmware_flash)
|
||||
.map(|r| r.ip.clone())
|
||||
.map(|r| (r.ip.clone(), r.model.clone()))
|
||||
.collect();
|
||||
if supporting.is_empty() {
|
||||
if targets.is_empty() {
|
||||
return None;
|
||||
}
|
||||
// wxFileDialog runs its own nested modal loop; that's fine to
|
||||
@@ -791,11 +921,11 @@ impl App {
|
||||
return None;
|
||||
};
|
||||
match FirmwareImage::from_file(&path) {
|
||||
Ok(image) => return Some(self.build_flash_confirm_dialog(&path, supporting, image)),
|
||||
Ok(image) => return Some(self.build_flash_confirm_dialog(&path, targets, image)),
|
||||
Err(e) => wx_rs::set_status_text(&format!("failed to read firmware image: {e}")),
|
||||
}
|
||||
}
|
||||
// Fault light is harmless -> apply immediately.
|
||||
// Flashing the identify light is harmless -> apply immediately.
|
||||
ID_CTX_LIGHT_ON => self.start_action(self.selected_ip_list(), scan::ConfigAction::FaultLight(true)),
|
||||
ID_CTX_LIGHT_OFF => self.start_action(self.selected_ip_list(), scan::ConfigAction::FaultLight(false)),
|
||||
// Disruptive to running hardware -> confirm first.
|
||||
@@ -907,18 +1037,44 @@ impl App {
|
||||
/// operator must type FLASH exactly, on top of seeing the image's file
|
||||
/// name and how many of the selected miners actually support it. Built
|
||||
/// here, shown modally by `dispatch` outside the App borrow.
|
||||
fn build_flash_confirm_dialog(&mut self, path: &str, ips: Vec<String>, image: FirmwareImage) -> Widget {
|
||||
let n = ips.len();
|
||||
fn build_flash_confirm_dialog(
|
||||
&mut self,
|
||||
path: &str,
|
||||
targets: Vec<(String, String)>,
|
||||
image: FirmwareImage,
|
||||
) -> Widget {
|
||||
let n = targets.len();
|
||||
let name = std::path::Path::new(path)
|
||||
.file_name()
|
||||
.map(|s| s.to_string_lossy().into_owned())
|
||||
.unwrap_or_else(|| path.to_string());
|
||||
// List exactly which miners (IP + model) will receive the image, so the
|
||||
// typed confirmation is informed. Warn loudly if the batch spans more
|
||||
// than one model, since a single image is rarely valid for all of them.
|
||||
let mut models: Vec<&str> = targets.iter().map(|(_, m)| m.as_str()).collect();
|
||||
models.sort_unstable();
|
||||
models.dedup();
|
||||
let target_list = targets
|
||||
.iter()
|
||||
.map(|(ip, model)| format!(" {ip} ({model})"))
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n");
|
||||
let mixed_warn = if models.len() > 1 {
|
||||
format!(
|
||||
"\n\nWARNING: the selection spans {} different models ({}). One image is rarely valid for all of them and a wrong image can brick a miner.",
|
||||
models.len(),
|
||||
models.join(", ")
|
||||
)
|
||||
} else {
|
||||
String::new()
|
||||
};
|
||||
let ips: Vec<String> = targets.into_iter().map(|(ip, _)| ip).collect();
|
||||
self.pending_flash = Some((ips, image, name.clone()));
|
||||
let frame = Widget::main_frame();
|
||||
let dlg = Widget::dialog(frame, "Flash firmware");
|
||||
let root = Widget::box_sizer(true);
|
||||
let msg = format!(
|
||||
"Flash \"{name}\" to {n} selected miner(s)? This overwrites running firmware and cannot be undone.\n\nType FLASH to confirm:"
|
||||
"Flash \"{name}\" to these {n} miner(s)? This overwrites running firmware and cannot be undone.\n\n{target_list}{mixed_warn}\n\nType FLASH to confirm:"
|
||||
);
|
||||
root.add(Widget::static_text(dlg, &msg), 0, sf::BORDER_ALL, 12);
|
||||
let input = Widget::text_ctrl(dlg, false);
|
||||
@@ -941,16 +1097,22 @@ impl App {
|
||||
/// typed exactly "FLASH"; otherwise keep the dialog open (and the pending
|
||||
/// target captured) so they can correct it.
|
||||
fn apply_flash_confirm(&mut self) {
|
||||
if self.flash_confirm_input.get_value().trim() != "FLASH" {
|
||||
if !flash_confirmed(&self.flash_confirm_input.get_value()) {
|
||||
wx_rs::set_status_text("type FLASH exactly to confirm");
|
||||
return;
|
||||
}
|
||||
if let Some((ips, image, _name)) = self.pending_flash.take() {
|
||||
self.flash_confirm_dialog.close(1);
|
||||
if let Some(old) = self.action.take() {
|
||||
old.stop();
|
||||
// Authoritative exclusivity check: a scan/refresh/action may have
|
||||
// started while the dialog was open. A flash must never race another
|
||||
// network operation on the same miner, so refuse rather than run the
|
||||
// prior handle's `stop()` (which does not join the in-flight upload).
|
||||
if self.flashing || self.scanning || self.action.is_some() || self.refresh.is_some() {
|
||||
wx_rs::set_status_text("busy (scan/action started) -- flash cancelled, try again");
|
||||
return;
|
||||
}
|
||||
let msg = format!("flashing firmware to {} miner(s)...", ips.len());
|
||||
self.flashing = true;
|
||||
self.action = Some(scan::start_firmware_flash_action(ips, image));
|
||||
wx_rs::set_status_text(&msg);
|
||||
}
|
||||
@@ -963,12 +1125,18 @@ impl App {
|
||||
let frame = Widget::main_frame();
|
||||
let dlg = Widget::dialog(frame, "Set scan credentials");
|
||||
let root = Widget::box_sizer(true);
|
||||
let hint = Widget::static_text(
|
||||
dlg,
|
||||
"HTTP credentials for firmware auto-discovery on password-protected miners.",
|
||||
);
|
||||
root.add(hint, 0, sf::BORDER_ALL, 8);
|
||||
let (saved_user, saved_pass) = credentials::load_credentials().unwrap_or_default();
|
||||
// Never re-display the saved password in plaintext. Leave the field
|
||||
// blank; a blank password on Save keeps whatever is already stored (see
|
||||
// apply_creds_save), so opening this dialog to change only the username
|
||||
// does not require -- or reveal -- the password.
|
||||
let pass_hint = if saved_pass.is_empty() {
|
||||
"HTTP credentials for firmware auto-discovery on password-protected miners."
|
||||
} else {
|
||||
"HTTP credentials for firmware auto-discovery. A password is already saved; leave Password blank to keep it, or type a new one to replace it."
|
||||
};
|
||||
let hint = Widget::static_text(dlg, pass_hint);
|
||||
root.add(hint, 0, sf::BORDER_ALL, 8);
|
||||
let user_row = Widget::box_sizer(false);
|
||||
user_row.add(Widget::static_text(dlg, "Username:"), 0, sf::ALIGN_CENTRE_VERTICAL | sf::BORDER_ALL, 6);
|
||||
let user_input = Widget::text_ctrl(dlg, false);
|
||||
@@ -979,7 +1147,6 @@ impl App {
|
||||
let pass_row = Widget::box_sizer(false);
|
||||
pass_row.add(Widget::static_text(dlg, "Password:"), 0, sf::ALIGN_CENTRE_VERTICAL | sf::BORDER_ALL, 6);
|
||||
let pass_input = Widget::text_ctrl(dlg, false);
|
||||
pass_input.set_value(&saved_pass);
|
||||
pass_input.set_min_size(200, -1);
|
||||
pass_row.add(pass_input, 1, sf::ALIGN_CENTRE_VERTICAL | sf::BORDER_ALL, 6);
|
||||
root.add_sizer(pass_row, 0, sf::EXPAND | sf::BORDER_LEFT | sf::BORDER_RIGHT, 6);
|
||||
@@ -1000,7 +1167,14 @@ impl App {
|
||||
|
||||
fn apply_creds_save(&mut self) {
|
||||
let user = self.creds_user_input.get_value();
|
||||
let pass = self.creds_pass_input.get_value();
|
||||
let mut pass = self.creds_pass_input.get_value();
|
||||
// A blank password field means "keep the saved password" (the dialog no
|
||||
// longer pre-fills it in plaintext), so fall back to the stored value.
|
||||
if pass.is_empty() {
|
||||
if let Some((_, saved_pass)) = credentials::load_credentials() {
|
||||
pass = saved_pass;
|
||||
}
|
||||
}
|
||||
match credentials::save_credentials(&user, &pass) {
|
||||
Ok(()) => {
|
||||
self.creds_dialog.close(1);
|
||||
@@ -1061,6 +1235,9 @@ impl App {
|
||||
}
|
||||
if finished {
|
||||
self.action = None;
|
||||
// Release the firmware-flash exclusive lock (harmless no-op for a
|
||||
// plain config action, which never set it).
|
||||
self.flashing = false;
|
||||
// Keep the summary on the status bar for a few ticks so a fleet
|
||||
// action's outcome (incl. failures) isn't clobbered by the next tick.
|
||||
self.action_result = status.clone();
|
||||
@@ -1240,6 +1417,12 @@ impl App {
|
||||
/// the old scan to stop before replacing it prevents two scan threads (and
|
||||
/// two tokio runtimes) probing the network at once.
|
||||
fn begin_scan(&mut self, lines: Vec<String>) {
|
||||
// Never probe the network while a firmware flash is uploading: a stray
|
||||
// scan connection to a miner mid-write can interrupt/corrupt the flash.
|
||||
if self.flashing {
|
||||
wx_rs::set_status_text("firmware flash in progress -- scan deferred");
|
||||
return;
|
||||
}
|
||||
if let Some(old) = self.scan.take() {
|
||||
old.stop();
|
||||
}
|
||||
@@ -1302,6 +1485,58 @@ impl App {
|
||||
self.fill_rows();
|
||||
}
|
||||
|
||||
/// Right-click on a column header: Excel-style per-column menu (sort, hide,
|
||||
/// auto-size, and open the full column picker).
|
||||
fn header_context_menu(&mut self, creation_idx: usize) {
|
||||
let Some(t) = self.table else { return };
|
||||
let cols = self.view.display_columns();
|
||||
let Some(&col) = cols.get(creation_idx) else { return };
|
||||
self.header_menu_col = Some(col);
|
||||
let menu = Widget::menu_new();
|
||||
menu.menu_append(ID_HDR_SORT_ASC, &format!("Sort {} ascending", col.title()));
|
||||
menu.menu_append(ID_HDR_SORT_DESC, &format!("Sort {} descending", col.title()));
|
||||
menu.menu_append_separator();
|
||||
menu.menu_append(ID_HDR_AUTOSIZE, "Auto-size this column");
|
||||
// The fixed IP column can't be hidden.
|
||||
if !self.view.is_fixed(col) {
|
||||
menu.menu_append(ID_HDR_HIDE, &format!("Hide {}", col.title()));
|
||||
}
|
||||
menu.menu_append_separator();
|
||||
menu.menu_append(ID_HDR_COLUMNS, "Columns...");
|
||||
self.pending_popup = Some((t, menu));
|
||||
}
|
||||
|
||||
/// Apply a header-menu action to the remembered column.
|
||||
fn on_header_menu(&mut self, id: i32) -> Option<Widget> {
|
||||
let Some(col) = self.header_menu_col else { return None };
|
||||
match id {
|
||||
ID_HDR_SORT_ASC => {
|
||||
self.view.sort = Some((col, true));
|
||||
self.update_headers();
|
||||
self.fill_rows();
|
||||
}
|
||||
ID_HDR_SORT_DESC => {
|
||||
self.view.sort = Some((col, false));
|
||||
self.update_headers();
|
||||
self.fill_rows();
|
||||
}
|
||||
ID_HDR_HIDE if !self.view.is_fixed(col) => {
|
||||
self.view.visible.remove(&col);
|
||||
self.rebuild_table();
|
||||
}
|
||||
ID_HDR_AUTOSIZE => {
|
||||
if let (Some(t), Some(pos)) =
|
||||
(self.table, self.view.display_columns().iter().position(|c| *c == col))
|
||||
{
|
||||
t.dvlc_autosize_col(pos);
|
||||
}
|
||||
}
|
||||
ID_HDR_COLUMNS => return Some(self.build_columns_dialog()),
|
||||
_ => {}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Refresh each column header's ASCII sort marker ("^" asc, "v" desc) in
|
||||
/// place, without recreating the table.
|
||||
fn update_headers(&self) {
|
||||
@@ -1851,6 +2086,7 @@ impl App {
|
||||
}
|
||||
}
|
||||
WxEventKind::DvlcHeaderClick => self.header_click(ev.p1 as usize),
|
||||
WxEventKind::DvlcHeaderRightClick => self.header_context_menu(ev.p1 as usize),
|
||||
WxEventKind::DvlcSelectionChanged => self.on_selection_changed(),
|
||||
WxEventKind::DvlcActivated => self.activate_row(ev.p1 as usize),
|
||||
WxEventKind::DvlcReordered => self.column_reordered(),
|
||||
@@ -1884,10 +2120,10 @@ impl App {
|
||||
// 1. KPI values: independent, hand-computed from the fixtures. The
|
||||
// labels are static; the value widgets carry the numbers.
|
||||
let want_kpis = [
|
||||
(self.kpi_total, "Total", "10"),
|
||||
(self.kpi_total, "Total", "9"),
|
||||
(self.kpi_hashing, "Hashing", "6"),
|
||||
(self.kpi_slow, "Slow", "1"),
|
||||
(self.kpi_not, "Not hashing", "2"),
|
||||
(self.kpi_not, "Not hashing", "1"),
|
||||
(self.kpi_paused, "Paused", "1"),
|
||||
(self.kpi_hashrate, "Hashrate", "685 TH/s"),
|
||||
(self.kpi_power, "Est. power", "21.3 kW"),
|
||||
@@ -1905,8 +2141,8 @@ impl App {
|
||||
|
||||
// 2. Row count in the store matches the (unfiltered) fixture count.
|
||||
let want_rows = self.view_idx.len();
|
||||
check("table row count == 10",
|
||||
t.dvlc_row_count() == 10 && want_rows == 10,
|
||||
check("table row count == 9",
|
||||
t.dvlc_row_count() == 9 && want_rows == 9,
|
||||
format!("store={}, view={}", t.dvlc_row_count(), want_rows));
|
||||
|
||||
// 3. Every store cell equals what the model produced for that row/col
|
||||
@@ -1919,7 +2155,7 @@ impl App {
|
||||
for (j, c) in cols.iter().enumerate() {
|
||||
let want = c.cell(r);
|
||||
let raw = t.dvlc_get_cell(disp_row, j).unwrap_or_default();
|
||||
let got = if matches!(c, Column::Hashrate | Column::Hashboards | Column::TotalChips | Column::Cooling) {
|
||||
let got = if matches!(c, Column::Hashrate | Column::Hashboards | Column::TotalChips | Column::ChipTemp | Column::Cooling | Column::Locked | Column::Error | Column::Status) {
|
||||
decode_segments_plain(&raw)
|
||||
} else {
|
||||
raw
|
||||
@@ -1953,8 +2189,8 @@ impl App {
|
||||
if let (Some(row), Some(_)) = (find("10.255.1.149"), status_col) {
|
||||
check("S21 Pro (.149) is slow", cell(row, status_col) == "slow",
|
||||
format!("status=\"{}\"", cell(row, status_col)));
|
||||
check("S21 Pro (.149) hashrate == 60.0 TH/s / 200 TH/s",
|
||||
cell(row, hr_col) == "60.0 TH/s / 200 TH/s",
|
||||
check("S21 Pro (.149) hashrate == 60.0T/200T",
|
||||
cell(row, hr_col) == "60.0T/200T",
|
||||
format!("hashrate=\"{}\"", cell(row, hr_col)));
|
||||
} else {
|
||||
check("S21 Pro (.149) present", false, "row not found".into());
|
||||
@@ -1975,12 +2211,27 @@ impl App {
|
||||
}
|
||||
check("IP is the first column", ip_col == Some(0),
|
||||
format!("ip col index = {ip_col:?}"));
|
||||
// default view is IP-ascending
|
||||
// default view is IP-ascending -- compare against the model's own
|
||||
// numeric dotted-quad order (not a lexical string sort, which only
|
||||
// coincidentally matches while every fixture octet is the same width).
|
||||
let ips: Vec<String> = self.view_idx.iter().map(|&ri| self.rows[ri].ip.clone()).collect();
|
||||
let mut sorted = ips.clone();
|
||||
sorted.sort();
|
||||
sorted.sort_by_key(|ip| ip_to_u32(ip));
|
||||
check("default sort is IP ascending", ips == sorted, String::new());
|
||||
|
||||
// 5. KPI quick-filter: clicking a status card filters the table to that
|
||||
// status; clicking again clears it back to the full fleet.
|
||||
let full = self.view_idx.len();
|
||||
self.toggle_kpi_filter("slow");
|
||||
let slow_only = self.view_idx.iter().all(|&ri| self.rows[ri].status() == "slow");
|
||||
check("KPI filter 'slow' shows only slow rows",
|
||||
self.view_idx.len() == 1 && slow_only && self.active_kpi_filter == Some("slow"),
|
||||
format!("len={}, active={:?}", self.view_idx.len(), self.active_kpi_filter));
|
||||
self.toggle_kpi_filter("slow");
|
||||
check("KPI filter toggled off restores full fleet",
|
||||
self.view_idx.len() == full && self.active_kpi_filter.is_none(),
|
||||
format!("len={} (want {full}), active={:?}", self.view_idx.len(), self.active_kpi_filter));
|
||||
|
||||
ok
|
||||
}
|
||||
}
|
||||
@@ -2023,3 +2274,113 @@ pub fn dispatch(ev: WxEvent) {
|
||||
on.popup_menu(menu);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
//! Pure colour/encoding helpers exercised without any wx display: these are
|
||||
//! the visual contracts the headless self-test's `decode_segments_plain`
|
||||
//! cell comparison deliberately strips out, so they need their own coverage.
|
||||
use super::*;
|
||||
|
||||
/// A palette with unambiguous sentinel colours so equality checks are exact.
|
||||
fn test_pal() -> Palette {
|
||||
Palette {
|
||||
card_bg: (1, 1, 1),
|
||||
label: (10, 20, 30),
|
||||
neutral: (40, 40, 40),
|
||||
green: (0, 255, 0),
|
||||
amber: (255, 128, 0),
|
||||
red: (255, 0, 0),
|
||||
accent: (0, 0, 255),
|
||||
zebra: (245, 245, 245),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tint_toward_endpoints_and_midpoint() {
|
||||
let a = (10, 20, 30);
|
||||
let b = (200, 100, 250);
|
||||
assert_eq!(tint_toward(a, b, 0.0), a);
|
||||
assert_eq!(tint_toward(a, b, 1.0), b);
|
||||
assert_eq!(tint_toward(a, a, 0.37), a, "same endpoints -> unchanged at any fraction");
|
||||
assert_eq!(tint_toward((0, 0, 0), (255, 255, 255), 0.5), (128, 128, 128));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ratio_color_stops_and_clamping() {
|
||||
let p = test_pal();
|
||||
// Scale bottoms out at 50%: red at/below 0.5, amber at 0.75, green at 1.0+.
|
||||
assert_eq!(ratio_color(&p, 0.5), p.red, "50% -> full red");
|
||||
assert_eq!(ratio_color(&p, 0.25), p.red, "below 50% -> still full red");
|
||||
assert_eq!(ratio_color(&p, 0.75), p.amber, "75% -> amber");
|
||||
assert_eq!(ratio_color(&p, 1.0), p.green, "100% -> green");
|
||||
assert_eq!(ratio_color(&p, 9.0), p.green, "clamped above 1 (overperforming -> green)");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn temp_color_blue_to_red_scale() {
|
||||
let p = test_pal();
|
||||
assert_eq!(temp_color(&p, 40.0), p.accent, "cool -> blue");
|
||||
assert_eq!(temp_color(&p, 20.0), p.accent, "clamped below 40 C");
|
||||
assert_eq!(temp_color(&p, 90.0), p.red, "hot -> red");
|
||||
assert_eq!(temp_color(&p, 110.0), p.red, "clamped above 90 C");
|
||||
assert_eq!(temp_color(&p, 65.0), tint_toward(p.accent, p.red, 0.5), "midpoint blend");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fan_color_grey_to_blue_scale() {
|
||||
let p = test_pal();
|
||||
assert_eq!(fan_color(&p, 0.0), p.label, "stopped fan -> grey label colour");
|
||||
assert_eq!(fan_color(&p, 6000.0), p.accent, "at/above ceiling -> saturated accent blue");
|
||||
assert_eq!(fan_color(&p, 12000.0), p.accent, "clamped above the ceiling");
|
||||
assert_eq!(fan_color(&p, 3000.0), tint_toward(p.label, p.accent, 0.5), "halfway blend");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn combined_cell_unknown_actual_is_not_coloured_red() {
|
||||
let p = test_pal();
|
||||
// Unknown actual with a known expected shows "-" in the DEFAULT colour
|
||||
// (no ratio) -- not a red 0%. Hashrate uses a no-space "/" separator.
|
||||
let unknown = encode_combined_cell(&p, None, Some("200T".to_string()), "/", None);
|
||||
assert_eq!(
|
||||
unknown,
|
||||
encode_segments(&[(None, "-".to_string()), (None, "/".to_string()), (None, "200T".to_string())])
|
||||
);
|
||||
assert_eq!(decode_segments_plain(&unknown), "-/200T");
|
||||
|
||||
// A known ratio colours only the actual half; the slash + expected stay
|
||||
// the default colour, and it round-trips to the plain "actual/expected".
|
||||
let known =
|
||||
encode_combined_cell(&p, Some("60.0T".to_string()), Some("200T".to_string()), "/", Some(0.3));
|
||||
let expected = encode_segments(&[
|
||||
(Some(ratio_color(&p, 0.3)), "60.0T".to_string()),
|
||||
(None, "/".to_string()),
|
||||
(None, "200T".to_string()),
|
||||
]);
|
||||
assert_eq!(known, expected);
|
||||
assert_eq!(decode_segments_plain(&known), "60.0T/200T");
|
||||
|
||||
// Actual-only (no expected) is a single uncoloured segment.
|
||||
let actual_only = encode_combined_cell(&p, Some("95.0T".to_string()), None, "/", None);
|
||||
assert_eq!(decode_segments_plain(&actual_only), "95.0T");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cooling_cell_colours_each_fan_with_black_slashes() {
|
||||
let p = test_pal();
|
||||
assert_eq!(
|
||||
decode_segments_plain(&encode_cooling_cell(&p, &[4800.0, 4600.0])),
|
||||
"4.8k/4.6k",
|
||||
);
|
||||
// Slash segments carry no colour (they render in the default text colour).
|
||||
let encoded = encode_cooling_cell(&p, &[4800.0, 4600.0]);
|
||||
let expected = encode_segments(&[
|
||||
(Some(fan_color(&p, 4800.0)), format_fan_rpm(4800.0)),
|
||||
(None, "/".to_string()),
|
||||
(Some(fan_color(&p, 4600.0)), format_fan_rpm(4600.0)),
|
||||
]);
|
||||
assert_eq!(encoded, expected);
|
||||
// No fans -> a single empty segment that decodes to "".
|
||||
assert_eq!(decode_segments_plain(&encode_cooling_cell(&p, &[])), "");
|
||||
}
|
||||
}
|
||||
|
||||
+33
-1
@@ -10,7 +10,7 @@
|
||||
+pub use widgets::*;
|
||||
--- a/src/widgets.rs
|
||||
+++ b/src/widgets.rs
|
||||
@@ -0,0 +1,688 @@
|
||||
@@ -0,0 +1,720 @@
|
||||
+// widgets.rs — alkane-toolkit extension: Rust bindings for the widget bridge
|
||||
+// in cpp_src/widgets_bridge.cpp. Handles are opaque pointers owned by the
|
||||
+// wxWidgets object tree (parents own children; nothing to free in Rust).
|
||||
@@ -73,6 +73,7 @@
|
||||
+ pub fn wxbr_dvlc_set_cell(win: *mut c_void, row: usize, col: usize, value: *const c_char);
|
||||
+ pub fn wxbr_dvlc_get_cell(win: *mut c_void, row: usize, col: usize, buf: *mut c_char, cap: c_int) -> c_int;
|
||||
+ pub fn wxbr_dvlc_col_count(win: *mut c_void) -> c_int;
|
||||
+ pub fn wxbr_dvlc_autosize_col(win: *mut c_void, pos: c_int);
|
||||
+ pub fn wxbr_dvlc_set_col_title(win: *mut c_void, col: c_int, title: *const c_char);
|
||||
+ pub fn wxbr_dvlc_set_sort_indicator(win: *mut c_void, col: c_int, active: c_int, ascending: c_int);
|
||||
+ pub fn wxbr_dvlc_col_at_pos(win: *mut c_void, pos: c_int) -> c_int;
|
||||
@@ -82,6 +83,9 @@
|
||||
+ pub fn wxbr_dvlc_select_rows(win: *mut c_void, rows: *const c_int, n: c_int);
|
||||
+ pub fn wxbr_dvlc_set_alt_row_color(win: *mut c_void, r: c_int, g: c_int, b: c_int);
|
||||
+ pub fn wxbr_dvlc_set_row_color(win: *mut c_void, row: usize, r: c_int, g: c_int, b: c_int);
|
||||
+ pub fn wxbr_dvlc_set_zebra(win: *mut c_void, r: c_int, g: c_int, b: c_int);
|
||||
+ pub fn wxbr_dvlc_get_top_row(win: *mut c_void) -> c_int;
|
||||
+ pub fn wxbr_dvlc_ensure_visible(win: *mut c_void, row: usize);
|
||||
+ pub fn wxbr_apply_zebra_css(r: c_int, g: c_int, b: c_int);
|
||||
+ pub fn wxbr_rearrange_list(parent: *mut c_void, n: c_int, order: *const c_int, items: *const *const c_char) -> *mut c_void;
|
||||
+ pub fn wxbr_rearrange_get_order(win: *mut c_void, buf: *mut c_int, cap: c_int) -> c_int;
|
||||
@@ -146,6 +150,7 @@
|
||||
+ ChoiceChanged,
|
||||
+ SysColour,
|
||||
+ Deferred,
|
||||
+ DvlcHeaderRightClick,
|
||||
+}
|
||||
+
|
||||
+impl WxEventKind {
|
||||
@@ -164,6 +169,7 @@
|
||||
+ 12 => WxEventKind::ChoiceChanged,
|
||||
+ 13 => WxEventKind::SysColour,
|
||||
+ 14 => WxEventKind::Deferred,
|
||||
+ 15 => WxEventKind::DvlcHeaderRightClick,
|
||||
+ _ => return None,
|
||||
+ })
|
||||
+ }
|
||||
@@ -505,6 +511,11 @@
|
||||
+ unsafe { notsafe::wxbr_dvlc_col_count(self.0).max(0) as usize }
|
||||
+ }
|
||||
+
|
||||
+ /// Auto-size the column at display position `pos` to fit its content.
|
||||
+ pub fn dvlc_autosize_col(&self, pos: usize) {
|
||||
+ unsafe { notsafe::wxbr_dvlc_autosize_col(self.0, pos as c_int) }
|
||||
+ }
|
||||
+
|
||||
+ /// Model column index shown at display position `pos` (after drag reorder).
|
||||
+ pub fn dvlc_col_at_pos(&self, pos: usize) -> Option<usize> {
|
||||
+ let v = unsafe { notsafe::wxbr_dvlc_col_at_pos(self.0, pos as c_int) };
|
||||
@@ -548,6 +559,27 @@
|
||||
+ unsafe { notsafe::wxbr_dvlc_set_row_color(self.0, row, r, g, b) }
|
||||
+ }
|
||||
+
|
||||
+ /// Set the alternating-row (zebra) background colour applied to odd rows.
|
||||
+ /// Pass `None` to turn zebra striping off.
|
||||
+ pub fn dvlc_set_zebra(&self, color: Option<(u8, u8, u8)>) {
|
||||
+ let (r, g, b) = match color {
|
||||
+ Some((r, g, b)) => (r as c_int, g as c_int, b as c_int),
|
||||
+ None => (-1, -1, -1),
|
||||
+ };
|
||||
+ unsafe { notsafe::wxbr_dvlc_set_zebra(self.0, r, g, b) }
|
||||
+ }
|
||||
+
|
||||
+ /// The model-row index of the top (first visible) row, or `None` if empty.
|
||||
+ pub fn dvlc_get_top_row(&self) -> Option<usize> {
|
||||
+ let r = unsafe { notsafe::wxbr_dvlc_get_top_row(self.0) };
|
||||
+ (r >= 0).then_some(r as usize)
|
||||
+ }
|
||||
+
|
||||
+ /// Scroll so `row` is visible (used to restore scroll position after a refill).
|
||||
+ pub fn dvlc_ensure_visible(&self, row: usize) {
|
||||
+ unsafe { notsafe::wxbr_dvlc_ensure_visible(self.0, row) }
|
||||
+ }
|
||||
+
|
||||
+ // ---- rearrangeable check-list ----
|
||||
+
|
||||
+ /// Create a rearrangeable checklist. `order` uses wx encoding: a value `v`
|
||||
|
||||
+106
-9
@@ -1,6 +1,6 @@
|
||||
--- a/cpp_src/widgets_bridge.cpp
|
||||
+++ b/cpp_src/widgets_bridge.cpp
|
||||
@@ -0,0 +1,892 @@
|
||||
@@ -0,0 +1,989 @@
|
||||
+// widgets_bridge.cpp — alkane-toolkit extension to wx-rs
|
||||
+// Adds the widget/event surface the toolkit UI needs on top of the upstream
|
||||
+// render-callback bridge (which is kept untouched).
|
||||
@@ -34,11 +34,15 @@
|
||||
+#include <wx/filedlg.h>
|
||||
+#include <cstring>
|
||||
+#include <cstdio>
|
||||
+#include <map>
|
||||
+#include <vector>
|
||||
+
|
||||
+typedef void (*WxWidgetEventFn)(int kind, long p1, long p2);
|
||||
+static WxWidgetEventFn g_widget_event = nullptr;
|
||||
+
|
||||
+// Anchor row per data-view control for rubber-band (click-drag) range select.
|
||||
+static std::map<wxDataViewCtrl*, int> g_drag_anchor;
|
||||
+
|
||||
+// Event kinds (must match Rust WxEventKind in src/widgets.rs)
|
||||
+enum WxWidgetEventKind {
|
||||
+ WxEV_BUTTON_CLICKED = 1,
|
||||
@@ -54,23 +58,32 @@
|
||||
+ WxEV_CHOICE_CHANGED = 12,
|
||||
+ WxEV_SYS_COLOUR = 13,
|
||||
+ WxEV_DEFERRED = 14,
|
||||
+ WxEV_DVLC_HEADER_RIGHT_CLICK = 15,
|
||||
+};
|
||||
+
|
||||
+// A list store that carries an optional per-row foreground colour, surfaced to
|
||||
+// the native control via GetAttrByRow. This is how the miner table paints each
|
||||
+// row's text by status and separates rows on GTK (where SetAlternateRowColour
|
||||
+// and :nth-child CSS are unreliable and fight the selection highlight).
|
||||
+// A list store that carries an optional per-row foreground colour plus an
|
||||
+// alternating-row (zebra) background, surfaced to the native control via
|
||||
+// GetAttrByRow. The zebra background is set on odd rows only; because it is a
|
||||
+// BACKGROUND attr (not a foreground one), it does not affect the SegmentRenderer
|
||||
+// "no explicit colour -> default text colour" path, and the native selection
|
||||
+// highlight still paints over it for selected rows.
|
||||
+class AttrListStore : public wxDataViewListStore {
|
||||
+ public:
|
||||
+ std::vector<wxColour> row_fg;
|
||||
+ wxColour zebra; // odd-row background; unset (=off) unless the app sets it
|
||||
+ bool GetAttrByRow(unsigned int row, unsigned int col,
|
||||
+ wxDataViewItemAttr& attr) const override {
|
||||
+ (void)col;
|
||||
+ bool set = false;
|
||||
+ if (row < row_fg.size() && row_fg[row].IsOk()) {
|
||||
+ attr.SetColour(row_fg[row]);
|
||||
+ return true;
|
||||
+ set = true;
|
||||
+ }
|
||||
+ return false;
|
||||
+ if (zebra.IsOk() && (row % 2 == 1)) {
|
||||
+ attr.SetBackgroundColour(zebra);
|
||||
+ set = true;
|
||||
+ }
|
||||
+ return set;
|
||||
+ }
|
||||
+};
|
||||
+
|
||||
@@ -191,7 +204,11 @@
|
||||
+// subclass, so it accepts the same add/add_sizer/add_spacer/add_stretch and
|
||||
+// set_sizer_on calls as wxbr_box_sizer's result.
|
||||
+void* wxbr_wrap_sizer(int vertical) {
|
||||
+ return (void*)new wxWrapSizer(vertical ? wxVERTICAL : wxHORIZONTAL);
|
||||
+ // wxREMOVE_LEADING_SPACES only: drop the default wxEXTEND_LAST_ON_EACH_LINE so
|
||||
+ // the last item on a line is NOT stretched to fill the row (keeps fixed-size
|
||||
+ // items -- e.g. the uniform KPI cards -- the same size).
|
||||
+ return (void*)new wxWrapSizer(vertical ? wxVERTICAL : wxHORIZONTAL,
|
||||
+ wxREMOVE_LEADING_SPACES);
|
||||
+}
|
||||
+
|
||||
+// flag bits (must match Rust sizer_flags):
|
||||
@@ -442,7 +459,8 @@
|
||||
+ // status while the native selection highlight still shows through.
|
||||
+ wxDataViewCtrl* dv =
|
||||
+ new wxDataViewCtrl((wxWindow*)parent, wxID_ANY, wxDefaultPosition,
|
||||
+ wxSize(-1, -1), wxDV_ROW_LINES | wxDV_MULTIPLE);
|
||||
+ wxSize(-1, -1),
|
||||
+ wxDV_ROW_LINES | wxDV_VERT_RULES | wxDV_MULTIPLE);
|
||||
+ AttrListStore* store = new AttrListStore();
|
||||
+ dv->AssociateModel(store);
|
||||
+ store->DecRef(); // the control owns a reference now
|
||||
@@ -465,9 +483,57 @@
|
||||
+ dv->Bind(wxEVT_DATAVIEW_COLUMN_HEADER_CLICK, [](wxDataViewEvent& e) {
|
||||
+ if (g_widget_event) g_widget_event(WxEV_DVLC_HEADER_CLICK, (long)e.GetColumn(), 0);
|
||||
+ });
|
||||
+ // Right-click on a column header: Excel-style per-column menu (hide/sort/...).
|
||||
+ dv->Bind(wxEVT_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK, [](wxDataViewEvent& e) {
|
||||
+ if (g_widget_event) g_widget_event(WxEV_DVLC_HEADER_RIGHT_CLICK, (long)e.GetColumn(), 0);
|
||||
+ });
|
||||
+ dv->Bind(wxEVT_DATAVIEW_COLUMN_REORDERED, [](wxDataViewEvent&) {
|
||||
+ if (g_widget_event) g_widget_event(WxEV_DVLC_REORDERED, 0, 0);
|
||||
+ });
|
||||
+ // Rubber-band (click-drag) range selection: wxDataViewCtrl has none natively
|
||||
+ // (only ctrl/shift-click), so track it here. LEFT_DOWN records the anchor row
|
||||
+ // (and lets the native handler select it); dragging with the button down
|
||||
+ // extends the selection to the row under the cursor.
|
||||
+ dv->Bind(wxEVT_LEFT_DOWN, [](wxMouseEvent& e) {
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)e.GetEventObject();
|
||||
+ if (!dv) { e.Skip(); return; }
|
||||
+ // Leave modifier-clicks to the native ctrl/shift multi-select behaviour.
|
||||
+ if (e.ControlDown() || e.ShiftDown()) { g_drag_anchor.erase(dv); e.Skip(); return; }
|
||||
+ wxDataViewItem item;
|
||||
+ wxDataViewColumn* col = nullptr;
|
||||
+ dv->HitTest(e.GetPosition(), item, col);
|
||||
+ if (item.IsOk()) {
|
||||
+ g_drag_anchor[dv] =
|
||||
+ (int)((wxDataViewIndexListModel*)dv->GetModel())->GetRow(item);
|
||||
+ } else {
|
||||
+ g_drag_anchor.erase(dv);
|
||||
+ }
|
||||
+ e.Skip(); // let the native handler select the anchor row
|
||||
+ });
|
||||
+ dv->Bind(wxEVT_MOTION, [](wxMouseEvent& e) {
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)e.GetEventObject();
|
||||
+ if (!dv || !e.LeftIsDown()) { e.Skip(); return; }
|
||||
+ auto it = g_drag_anchor.find(dv);
|
||||
+ if (it == g_drag_anchor.end()) { e.Skip(); return; }
|
||||
+ wxDataViewItem item;
|
||||
+ wxDataViewColumn* col = nullptr;
|
||||
+ dv->HitTest(e.GetPosition(), item, col);
|
||||
+ if (!item.IsOk()) { e.Skip(); return; }
|
||||
+ wxDataViewIndexListModel* model = (wxDataViewIndexListModel*)dv->GetModel();
|
||||
+ int cur = (int)model->GetRow(item);
|
||||
+ int lo = it->second < cur ? it->second : cur;
|
||||
+ int hi = it->second < cur ? cur : it->second;
|
||||
+ dv->UnselectAll();
|
||||
+ for (int r = lo; r <= hi; ++r) dv->Select(model->GetItem((unsigned)r));
|
||||
+ // Selecting programmatically does not emit SELECTION_CHANGED, so notify.
|
||||
+ if (g_widget_event) g_widget_event(WxEV_DVLC_SELECTION_CHANGED, 0, 0);
|
||||
+ e.Skip();
|
||||
+ });
|
||||
+ dv->Bind(wxEVT_LEFT_UP, [](wxMouseEvent& e) {
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)e.GetEventObject();
|
||||
+ if (dv) g_drag_anchor.erase(dv);
|
||||
+ e.Skip();
|
||||
+ });
|
||||
+ // Row activation (double-click / Enter): report the row + column so the app
|
||||
+ // can, e.g., open the miner's IP in a browser.
|
||||
+ dv->Bind(wxEVT_DATAVIEW_ITEM_ACTIVATED, [](wxDataViewEvent& e) {
|
||||
@@ -549,6 +615,29 @@
|
||||
+ store->RowChanged(row);
|
||||
+}
|
||||
+
|
||||
+// Set (or clear, when r<0) the alternating-row (zebra) background colour. The
|
||||
+// app passes a theme-aware colour; odd rows get it (see AttrListStore).
|
||||
+void wxbr_dvlc_set_zebra(void* win, int r, int g, int b) {
|
||||
+ dvlc_store(win)->zebra = (r < 0) ? wxColour() : wxColour(r, g, b);
|
||||
+}
|
||||
+
|
||||
+// The model-row index of the first (top) visible row, or -1 if none. Used to
|
||||
+// hold the scroll position across a full clear+refill during a live scan.
|
||||
+int wxbr_dvlc_get_top_row(void* win) {
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
+ wxDataViewItem item = dv->GetTopItem();
|
||||
+ if (!item.IsOk()) return -1;
|
||||
+ return (int)((wxDataViewIndexListModel*)dv->GetModel())->GetRow(item);
|
||||
+}
|
||||
+
|
||||
+// Scroll so `row` is visible (used with wxbr_dvlc_get_top_row to restore the
|
||||
+// scroll position after a refill). Out-of-range rows are ignored.
|
||||
+void wxbr_dvlc_ensure_visible(void* win, unsigned row) {
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
+ wxDataViewItem item = ((wxDataViewIndexListModel*)dv->GetModel())->GetItem(row);
|
||||
+ if (item.IsOk()) dv->EnsureVisible(item);
|
||||
+}
|
||||
+
|
||||
+int wxbr_dvlc_row_count(void* win) {
|
||||
+ return (int)dvlc_store(win)->GetItemCount();
|
||||
+}
|
||||
@@ -579,6 +668,14 @@
|
||||
+ return (int)((wxDataViewCtrl*)win)->GetColumnCount();
|
||||
+}
|
||||
+
|
||||
+// Auto-size a column (by display position) to fit its content + header.
|
||||
+void wxbr_dvlc_autosize_col(void* win, int pos) {
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
+ if (pos < 0 || (unsigned)pos >= dv->GetColumnCount()) return;
|
||||
+ wxDataViewColumn* c = dv->GetColumn((unsigned)pos);
|
||||
+ if (c) c->SetWidth(wxCOL_WIDTH_AUTOSIZE);
|
||||
+}
|
||||
+
|
||||
+// Update a column's header text in place (creation index) without recreating
|
||||
+// the control -- used to refresh the ASCII sort marker on a sort click.
|
||||
+void wxbr_dvlc_set_col_title(void* win, int col, const char* title) {
|
||||
|
||||
+105
-8
@@ -31,11 +31,15 @@
|
||||
#include <wx/filedlg.h>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
|
||||
typedef void (*WxWidgetEventFn)(int kind, long p1, long p2);
|
||||
static WxWidgetEventFn g_widget_event = nullptr;
|
||||
|
||||
// Anchor row per data-view control for rubber-band (click-drag) range select.
|
||||
static std::map<wxDataViewCtrl*, int> g_drag_anchor;
|
||||
|
||||
// Event kinds (must match Rust WxEventKind in src/widgets.rs)
|
||||
enum WxWidgetEventKind {
|
||||
WxEV_BUTTON_CLICKED = 1,
|
||||
@@ -51,23 +55,32 @@ enum WxWidgetEventKind {
|
||||
WxEV_CHOICE_CHANGED = 12,
|
||||
WxEV_SYS_COLOUR = 13,
|
||||
WxEV_DEFERRED = 14,
|
||||
WxEV_DVLC_HEADER_RIGHT_CLICK = 15,
|
||||
};
|
||||
|
||||
// A list store that carries an optional per-row foreground colour, surfaced to
|
||||
// the native control via GetAttrByRow. This is how the miner table paints each
|
||||
// row's text by status and separates rows on GTK (where SetAlternateRowColour
|
||||
// and :nth-child CSS are unreliable and fight the selection highlight).
|
||||
// A list store that carries an optional per-row foreground colour plus an
|
||||
// alternating-row (zebra) background, surfaced to the native control via
|
||||
// GetAttrByRow. The zebra background is set on odd rows only; because it is a
|
||||
// BACKGROUND attr (not a foreground one), it does not affect the SegmentRenderer
|
||||
// "no explicit colour -> default text colour" path, and the native selection
|
||||
// highlight still paints over it for selected rows.
|
||||
class AttrListStore : public wxDataViewListStore {
|
||||
public:
|
||||
std::vector<wxColour> row_fg;
|
||||
wxColour zebra; // odd-row background; unset (=off) unless the app sets it
|
||||
bool GetAttrByRow(unsigned int row, unsigned int col,
|
||||
wxDataViewItemAttr& attr) const override {
|
||||
(void)col;
|
||||
bool set = false;
|
||||
if (row < row_fg.size() && row_fg[row].IsOk()) {
|
||||
attr.SetColour(row_fg[row]);
|
||||
return true;
|
||||
set = true;
|
||||
}
|
||||
return false;
|
||||
if (zebra.IsOk() && (row % 2 == 1)) {
|
||||
attr.SetBackgroundColour(zebra);
|
||||
set = true;
|
||||
}
|
||||
return set;
|
||||
}
|
||||
};
|
||||
|
||||
@@ -188,7 +201,11 @@ void* wxbr_box_sizer(int vertical) {
|
||||
// subclass, so it accepts the same add/add_sizer/add_spacer/add_stretch and
|
||||
// set_sizer_on calls as wxbr_box_sizer's result.
|
||||
void* wxbr_wrap_sizer(int vertical) {
|
||||
return (void*)new wxWrapSizer(vertical ? wxVERTICAL : wxHORIZONTAL);
|
||||
// wxREMOVE_LEADING_SPACES only: drop the default wxEXTEND_LAST_ON_EACH_LINE so
|
||||
// the last item on a line is NOT stretched to fill the row (keeps fixed-size
|
||||
// items -- e.g. the uniform KPI cards -- the same size).
|
||||
return (void*)new wxWrapSizer(vertical ? wxVERTICAL : wxHORIZONTAL,
|
||||
wxREMOVE_LEADING_SPACES);
|
||||
}
|
||||
|
||||
// flag bits (must match Rust sizer_flags):
|
||||
@@ -439,7 +456,8 @@ void* wxbr_dvlc(void* parent) {
|
||||
// status while the native selection highlight still shows through.
|
||||
wxDataViewCtrl* dv =
|
||||
new wxDataViewCtrl((wxWindow*)parent, wxID_ANY, wxDefaultPosition,
|
||||
wxSize(-1, -1), wxDV_ROW_LINES | wxDV_MULTIPLE);
|
||||
wxSize(-1, -1),
|
||||
wxDV_ROW_LINES | wxDV_VERT_RULES | wxDV_MULTIPLE);
|
||||
AttrListStore* store = new AttrListStore();
|
||||
dv->AssociateModel(store);
|
||||
store->DecRef(); // the control owns a reference now
|
||||
@@ -462,9 +480,57 @@ void* wxbr_dvlc(void* parent) {
|
||||
dv->Bind(wxEVT_DATAVIEW_COLUMN_HEADER_CLICK, [](wxDataViewEvent& e) {
|
||||
if (g_widget_event) g_widget_event(WxEV_DVLC_HEADER_CLICK, (long)e.GetColumn(), 0);
|
||||
});
|
||||
// Right-click on a column header: Excel-style per-column menu (hide/sort/...).
|
||||
dv->Bind(wxEVT_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK, [](wxDataViewEvent& e) {
|
||||
if (g_widget_event) g_widget_event(WxEV_DVLC_HEADER_RIGHT_CLICK, (long)e.GetColumn(), 0);
|
||||
});
|
||||
dv->Bind(wxEVT_DATAVIEW_COLUMN_REORDERED, [](wxDataViewEvent&) {
|
||||
if (g_widget_event) g_widget_event(WxEV_DVLC_REORDERED, 0, 0);
|
||||
});
|
||||
// Rubber-band (click-drag) range selection: wxDataViewCtrl has none natively
|
||||
// (only ctrl/shift-click), so track it here. LEFT_DOWN records the anchor row
|
||||
// (and lets the native handler select it); dragging with the button down
|
||||
// extends the selection to the row under the cursor.
|
||||
dv->Bind(wxEVT_LEFT_DOWN, [](wxMouseEvent& e) {
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)e.GetEventObject();
|
||||
if (!dv) { e.Skip(); return; }
|
||||
// Leave modifier-clicks to the native ctrl/shift multi-select behaviour.
|
||||
if (e.ControlDown() || e.ShiftDown()) { g_drag_anchor.erase(dv); e.Skip(); return; }
|
||||
wxDataViewItem item;
|
||||
wxDataViewColumn* col = nullptr;
|
||||
dv->HitTest(e.GetPosition(), item, col);
|
||||
if (item.IsOk()) {
|
||||
g_drag_anchor[dv] =
|
||||
(int)((wxDataViewIndexListModel*)dv->GetModel())->GetRow(item);
|
||||
} else {
|
||||
g_drag_anchor.erase(dv);
|
||||
}
|
||||
e.Skip(); // let the native handler select the anchor row
|
||||
});
|
||||
dv->Bind(wxEVT_MOTION, [](wxMouseEvent& e) {
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)e.GetEventObject();
|
||||
if (!dv || !e.LeftIsDown()) { e.Skip(); return; }
|
||||
auto it = g_drag_anchor.find(dv);
|
||||
if (it == g_drag_anchor.end()) { e.Skip(); return; }
|
||||
wxDataViewItem item;
|
||||
wxDataViewColumn* col = nullptr;
|
||||
dv->HitTest(e.GetPosition(), item, col);
|
||||
if (!item.IsOk()) { e.Skip(); return; }
|
||||
wxDataViewIndexListModel* model = (wxDataViewIndexListModel*)dv->GetModel();
|
||||
int cur = (int)model->GetRow(item);
|
||||
int lo = it->second < cur ? it->second : cur;
|
||||
int hi = it->second < cur ? cur : it->second;
|
||||
dv->UnselectAll();
|
||||
for (int r = lo; r <= hi; ++r) dv->Select(model->GetItem((unsigned)r));
|
||||
// Selecting programmatically does not emit SELECTION_CHANGED, so notify.
|
||||
if (g_widget_event) g_widget_event(WxEV_DVLC_SELECTION_CHANGED, 0, 0);
|
||||
e.Skip();
|
||||
});
|
||||
dv->Bind(wxEVT_LEFT_UP, [](wxMouseEvent& e) {
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)e.GetEventObject();
|
||||
if (dv) g_drag_anchor.erase(dv);
|
||||
e.Skip();
|
||||
});
|
||||
// Row activation (double-click / Enter): report the row + column so the app
|
||||
// can, e.g., open the miner's IP in a browser.
|
||||
dv->Bind(wxEVT_DATAVIEW_ITEM_ACTIVATED, [](wxDataViewEvent& e) {
|
||||
@@ -546,6 +612,29 @@ void wxbr_dvlc_set_row_color(void* win, unsigned row, int r, int g, int b) {
|
||||
store->RowChanged(row);
|
||||
}
|
||||
|
||||
// Set (or clear, when r<0) the alternating-row (zebra) background colour. The
|
||||
// app passes a theme-aware colour; odd rows get it (see AttrListStore).
|
||||
void wxbr_dvlc_set_zebra(void* win, int r, int g, int b) {
|
||||
dvlc_store(win)->zebra = (r < 0) ? wxColour() : wxColour(r, g, b);
|
||||
}
|
||||
|
||||
// The model-row index of the first (top) visible row, or -1 if none. Used to
|
||||
// hold the scroll position across a full clear+refill during a live scan.
|
||||
int wxbr_dvlc_get_top_row(void* win) {
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
wxDataViewItem item = dv->GetTopItem();
|
||||
if (!item.IsOk()) return -1;
|
||||
return (int)((wxDataViewIndexListModel*)dv->GetModel())->GetRow(item);
|
||||
}
|
||||
|
||||
// Scroll so `row` is visible (used with wxbr_dvlc_get_top_row to restore the
|
||||
// scroll position after a refill). Out-of-range rows are ignored.
|
||||
void wxbr_dvlc_ensure_visible(void* win, unsigned row) {
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
wxDataViewItem item = ((wxDataViewIndexListModel*)dv->GetModel())->GetItem(row);
|
||||
if (item.IsOk()) dv->EnsureVisible(item);
|
||||
}
|
||||
|
||||
int wxbr_dvlc_row_count(void* win) {
|
||||
return (int)dvlc_store(win)->GetItemCount();
|
||||
}
|
||||
@@ -576,6 +665,14 @@ int wxbr_dvlc_col_count(void* win) {
|
||||
return (int)((wxDataViewCtrl*)win)->GetColumnCount();
|
||||
}
|
||||
|
||||
// Auto-size a column (by display position) to fit its content + header.
|
||||
void wxbr_dvlc_autosize_col(void* win, int pos) {
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
if (pos < 0 || (unsigned)pos >= dv->GetColumnCount()) return;
|
||||
wxDataViewColumn* c = dv->GetColumn((unsigned)pos);
|
||||
if (c) c->SetWidth(wxCOL_WIDTH_AUTOSIZE);
|
||||
}
|
||||
|
||||
// Update a column's header text in place (creation index) without recreating
|
||||
// the control -- used to refresh the ASCII sort marker on a sort click.
|
||||
void wxbr_dvlc_set_col_title(void* win, int col, const char* title) {
|
||||
|
||||
@@ -60,6 +60,7 @@ mod notsafe {
|
||||
pub fn wxbr_dvlc_set_cell(win: *mut c_void, row: usize, col: usize, value: *const c_char);
|
||||
pub fn wxbr_dvlc_get_cell(win: *mut c_void, row: usize, col: usize, buf: *mut c_char, cap: c_int) -> c_int;
|
||||
pub fn wxbr_dvlc_col_count(win: *mut c_void) -> c_int;
|
||||
pub fn wxbr_dvlc_autosize_col(win: *mut c_void, pos: c_int);
|
||||
pub fn wxbr_dvlc_set_col_title(win: *mut c_void, col: c_int, title: *const c_char);
|
||||
pub fn wxbr_dvlc_set_sort_indicator(win: *mut c_void, col: c_int, active: c_int, ascending: c_int);
|
||||
pub fn wxbr_dvlc_col_at_pos(win: *mut c_void, pos: c_int) -> c_int;
|
||||
@@ -69,6 +70,9 @@ mod notsafe {
|
||||
pub fn wxbr_dvlc_select_rows(win: *mut c_void, rows: *const c_int, n: c_int);
|
||||
pub fn wxbr_dvlc_set_alt_row_color(win: *mut c_void, r: c_int, g: c_int, b: c_int);
|
||||
pub fn wxbr_dvlc_set_row_color(win: *mut c_void, row: usize, r: c_int, g: c_int, b: c_int);
|
||||
pub fn wxbr_dvlc_set_zebra(win: *mut c_void, r: c_int, g: c_int, b: c_int);
|
||||
pub fn wxbr_dvlc_get_top_row(win: *mut c_void) -> c_int;
|
||||
pub fn wxbr_dvlc_ensure_visible(win: *mut c_void, row: usize);
|
||||
pub fn wxbr_apply_zebra_css(r: c_int, g: c_int, b: c_int);
|
||||
pub fn wxbr_rearrange_list(parent: *mut c_void, n: c_int, order: *const c_int, items: *const *const c_char) -> *mut c_void;
|
||||
pub fn wxbr_rearrange_get_order(win: *mut c_void, buf: *mut c_int, cap: c_int) -> c_int;
|
||||
@@ -133,6 +137,7 @@ pub enum WxEventKind {
|
||||
ChoiceChanged,
|
||||
SysColour,
|
||||
Deferred,
|
||||
DvlcHeaderRightClick,
|
||||
}
|
||||
|
||||
impl WxEventKind {
|
||||
@@ -151,6 +156,7 @@ impl WxEventKind {
|
||||
12 => WxEventKind::ChoiceChanged,
|
||||
13 => WxEventKind::SysColour,
|
||||
14 => WxEventKind::Deferred,
|
||||
15 => WxEventKind::DvlcHeaderRightClick,
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
@@ -492,6 +498,11 @@ impl Widget {
|
||||
unsafe { notsafe::wxbr_dvlc_col_count(self.0).max(0) as usize }
|
||||
}
|
||||
|
||||
/// Auto-size the column at display position `pos` to fit its content.
|
||||
pub fn dvlc_autosize_col(&self, pos: usize) {
|
||||
unsafe { notsafe::wxbr_dvlc_autosize_col(self.0, pos as c_int) }
|
||||
}
|
||||
|
||||
/// Model column index shown at display position `pos` (after drag reorder).
|
||||
pub fn dvlc_col_at_pos(&self, pos: usize) -> Option<usize> {
|
||||
let v = unsafe { notsafe::wxbr_dvlc_col_at_pos(self.0, pos as c_int) };
|
||||
@@ -535,6 +546,27 @@ impl Widget {
|
||||
unsafe { notsafe::wxbr_dvlc_set_row_color(self.0, row, r, g, b) }
|
||||
}
|
||||
|
||||
/// Set the alternating-row (zebra) background colour applied to odd rows.
|
||||
/// Pass `None` to turn zebra striping off.
|
||||
pub fn dvlc_set_zebra(&self, color: Option<(u8, u8, u8)>) {
|
||||
let (r, g, b) = match color {
|
||||
Some((r, g, b)) => (r as c_int, g as c_int, b as c_int),
|
||||
None => (-1, -1, -1),
|
||||
};
|
||||
unsafe { notsafe::wxbr_dvlc_set_zebra(self.0, r, g, b) }
|
||||
}
|
||||
|
||||
/// The model-row index of the top (first visible) row, or `None` if empty.
|
||||
pub fn dvlc_get_top_row(&self) -> Option<usize> {
|
||||
let r = unsafe { notsafe::wxbr_dvlc_get_top_row(self.0) };
|
||||
(r >= 0).then_some(r as usize)
|
||||
}
|
||||
|
||||
/// Scroll so `row` is visible (used to restore scroll position after a refill).
|
||||
pub fn dvlc_ensure_visible(&self, row: usize) {
|
||||
unsafe { notsafe::wxbr_dvlc_ensure_visible(self.0, row) }
|
||||
}
|
||||
|
||||
// ---- rearrangeable check-list ----
|
||||
|
||||
/// Create a rearrangeable checklist. `order` uses wx encoding: a value `v`
|
||||
|
||||
Reference in New Issue
Block a user