Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
e593548746 | ||
|
|
2fd433c3b0 | ||
|
|
5399f9fc49 | ||
|
|
6b4961d7bc | ||
|
|
fc7c665166 | ||
|
|
ae437c0d24 | ||
|
|
b343746718 | ||
|
|
aa75031112 | ||
|
|
8eb9a2caad | ||
|
|
9e2b453eb5 | ||
|
|
3530d67a5c | ||
|
|
3ac4e104a0 | ||
|
|
3c99934513 | ||
|
|
9b5d811b1e | ||
|
|
77399bdd06 | ||
|
|
408b7d12b4 | ||
|
|
50cd463bee | ||
|
|
d73299166e | ||
|
|
a81fef3c7d | ||
|
|
365732b5d4 | ||
|
|
98603077e3 | ||
|
|
bc9f847689 | ||
|
|
71cdf2d988 | ||
|
|
4fea3becf6 | ||
|
|
7781ff71d3 |
Generated
+2
@@ -81,6 +81,8 @@ dependencies = [
|
||||
"asic-rs",
|
||||
"futures-util",
|
||||
"measurements",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"tokio",
|
||||
"wx-rs",
|
||||
]
|
||||
|
||||
@@ -17,3 +17,5 @@ asic-rs = "0.8.1"
|
||||
measurements = "0.11"
|
||||
tokio = { version = "1", features = ["rt"] }
|
||||
futures-util = "0.3"
|
||||
serde = { version = "1", features = ["derive"] }
|
||||
serde_json = "1"
|
||||
|
||||
@@ -0,0 +1,115 @@
|
||||
//! Real access / lock-state detection: whether this miner accepts privileged
|
||||
//! (credentialed) command writes, or is view-only.
|
||||
//!
|
||||
//! asic-rs has no lock-state signal (a wrong-password miner just silently
|
||||
//! returns fewer fields, because the collector drops the 401). We build the real
|
||||
//! check ON TOP of asic-rs: a NON-mutating, digest-authenticated GET to a
|
||||
//! privileged endpoint. On Antminer every `/cgi-bin/*.cgi` requires digest auth,
|
||||
//! so the HTTP status is decisive -- 200 means our credentials authenticate
|
||||
//! (we can write -> unlocked), 401/403 means they are rejected (view-only ->
|
||||
//! locked). We probe `get_miner_conf.cgi`, which is read-only (never the
|
||||
//! mutating `set_miner_conf.cgi`).
|
||||
//!
|
||||
//! We shell out to `curl --digest` (already present, supports digest auth)
|
||||
//! rather than add an HTTP+digest crate, so the offline/vendored build is
|
||||
//! unaffected. `Some(true)` = locked, `Some(false)` = unlocked, `None` =
|
||||
//! indeterminate (unreachable, or an endpoint/vendor this probe doesn't cover).
|
||||
|
||||
use std::process::Command;
|
||||
use std::time::Duration;
|
||||
|
||||
/// Classify a miner's access state from an HTTP status code string (curl's
|
||||
/// `%{http_code}` output). Conservative: anything other than a clear
|
||||
/// authenticated/unauthorized answer is `None`.
|
||||
pub fn classify_http_code(code: &str) -> Option<bool> {
|
||||
match code.trim() {
|
||||
"200" | "204" => Some(false), // authenticated -> unlocked/writable
|
||||
"401" | "403" => Some(true), // rejected -> locked/view-only
|
||||
_ => None, // 000 (no connect), 404, 5xx, ... -> unknown
|
||||
}
|
||||
}
|
||||
|
||||
/// The privileged, read-only endpoint we probe per firmware family. Antminer
|
||||
/// stock/aftermarket all gate `get_miner_conf.cgi` behind digest auth.
|
||||
fn endpoint(_firmware: &str) -> &'static str {
|
||||
"/cgi-bin/get_miner_conf.cgi"
|
||||
}
|
||||
|
||||
/// Probe one miner's access state over its web API with the given credentials.
|
||||
/// Returns `Ok(Some(true/false))` on a decisive lock/unlock answer, `Ok(None)`
|
||||
/// if reachable-but-indeterminate or a vendor this probe doesn't cover, or
|
||||
/// `Err` only on a failure to run curl at all.
|
||||
pub fn probe_access(ip: &str, firmware: &str, user: &str, pass: &str) -> Result<Option<bool>, String> {
|
||||
let url = format!("http://{ip}{}", endpoint(firmware));
|
||||
let userpass = format!("{user}:{pass}");
|
||||
let mut cmd = Command::new("curl");
|
||||
cmd.args([
|
||||
"-s",
|
||||
"-o",
|
||||
"/dev/null",
|
||||
"-w",
|
||||
"%{http_code}",
|
||||
"--digest",
|
||||
"-u",
|
||||
&userpass,
|
||||
"--connect-timeout",
|
||||
"5",
|
||||
"--max-time",
|
||||
"9",
|
||||
&url,
|
||||
]);
|
||||
let out = wait_with_timeout(cmd, Duration::from_secs(12))?;
|
||||
// curl prints the status code to stdout regardless of exit status (000 on a
|
||||
// connection failure), so classify the code rather than the exit status.
|
||||
let code = String::from_utf8_lossy(&out.stdout);
|
||||
Ok(classify_http_code(&code))
|
||||
}
|
||||
|
||||
/// Run a command with a wall-clock timeout (curl can hang past --max-time on a
|
||||
/// black-holed host).
|
||||
fn wait_with_timeout(mut cmd: Command, timeout: Duration) -> Result<std::process::Output, String> {
|
||||
use std::io::Read;
|
||||
cmd.stdout(std::process::Stdio::piped()).stderr(std::process::Stdio::piped());
|
||||
let mut child = cmd.spawn().map_err(|e| format!("spawn curl: {e}"))?;
|
||||
let start = std::time::Instant::now();
|
||||
loop {
|
||||
match child.try_wait().map_err(|e| e.to_string())? {
|
||||
Some(status) => {
|
||||
let mut stdout = Vec::new();
|
||||
let mut stderr = Vec::new();
|
||||
if let Some(mut o) = child.stdout.take() {
|
||||
let _ = o.read_to_end(&mut stdout);
|
||||
}
|
||||
if let Some(mut e) = child.stderr.take() {
|
||||
let _ = e.read_to_end(&mut stderr);
|
||||
}
|
||||
return Ok(std::process::Output { status, stdout, stderr });
|
||||
}
|
||||
None => {
|
||||
if start.elapsed() >= timeout {
|
||||
let _ = child.kill();
|
||||
return Err("curl timed out".into());
|
||||
}
|
||||
std::thread::sleep(Duration::from_millis(100));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn classify_codes() {
|
||||
assert_eq!(classify_http_code("200"), Some(false), "authenticated -> unlocked");
|
||||
assert_eq!(classify_http_code("204"), Some(false));
|
||||
assert_eq!(classify_http_code("401"), Some(true), "unauthorized -> locked");
|
||||
assert_eq!(classify_http_code("403"), Some(true));
|
||||
assert_eq!(classify_http_code("000"), None, "no connection -> unknown");
|
||||
assert_eq!(classify_http_code("404"), None, "endpoint absent -> unknown");
|
||||
assert_eq!(classify_http_code("500"), None);
|
||||
assert_eq!(classify_http_code(" 200 "), Some(false), "whitespace tolerated");
|
||||
assert_eq!(classify_http_code(""), None);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
//! miner_probe -- a read-only (by default) asic-rs diagnostic for live-hardware
|
||||
//! verification of the round-9 power-limit work. It reuses the same MinerFactory
|
||||
//! + saved-credential setup the GUI uses (see crate::credentials), but as a
|
||||
//! standalone CLI so hardware checks don't go through the wx event loop.
|
||||
//!
|
||||
//! Usage:
|
||||
//! miner_probe scan <cidr> [<cidr>...]
|
||||
//! Scan the given subnets and print, per responder (TSV):
|
||||
//! ip make firmware model_id control_board watts supports_power_limit supports_tuning
|
||||
//!
|
||||
//! Mutation modes (setpl) are intentionally NOT included here: asic-rs exposes
|
||||
//! no read-back of a miner's configured power limit, so an exact
|
||||
//! restore-to-prior-state cannot be guaranteed from this tool alone.
|
||||
|
||||
use asic_rs::MinerFactory;
|
||||
use asic_rs::core::traits::miner::MinerAuth;
|
||||
use futures_util::StreamExt;
|
||||
|
||||
fn load_creds() -> Option<(String, String)> {
|
||||
let home = std::env::var("HOME").ok()?;
|
||||
let p = std::path::PathBuf::from(home)
|
||||
.join(".config/alkane-toolkit/scan-credentials.txt");
|
||||
let s = std::fs::read_to_string(p).ok()?;
|
||||
let mut l = s.lines();
|
||||
let u = l.next()?.to_string();
|
||||
let pw = l.next().unwrap_or("").to_string();
|
||||
Some((u, pw))
|
||||
}
|
||||
|
||||
fn factory() -> MinerFactory {
|
||||
let mut f = MinerFactory::new();
|
||||
if let Some((u, pw)) = load_creds() {
|
||||
for fw in asic_rs::factory::default_firmware_registry() {
|
||||
f = f.with_firmware_discovery_auth(fw.as_ref(), MinerAuth::new(u.clone(), pw.clone()));
|
||||
}
|
||||
eprintln!("(using saved scan credentials for discovery auth)");
|
||||
} else {
|
||||
eprintln!("(no saved credentials -- backends use their default auth)");
|
||||
}
|
||||
f
|
||||
}
|
||||
|
||||
async fn scan(cidrs: &[String]) {
|
||||
let mut f = factory();
|
||||
for c in cidrs {
|
||||
f = match f.with_subnet(c) {
|
||||
Ok(f) => f,
|
||||
Err(e) => {
|
||||
eprintln!("bad subnet {c}: {e}");
|
||||
return;
|
||||
}
|
||||
};
|
||||
}
|
||||
println!("ip\tmake\tfirmware\tmodel_id\tcontrol_board\twatts\tsupports_power_limit\tsupports_tuning");
|
||||
let mut stream = f.scan_stream_with_ip();
|
||||
let mut found = 0usize;
|
||||
while let Some((ip, miner)) = stream.next().await {
|
||||
if let Some(m) = miner {
|
||||
let data = m.get_data().await;
|
||||
let watts = data.wattage.as_ref().map(|p| p.as_watts()).unwrap_or(0.0);
|
||||
let cb = data
|
||||
.control_board_version
|
||||
.as_ref()
|
||||
.map(|c| c.to_string())
|
||||
.unwrap_or_default();
|
||||
println!(
|
||||
"{ip}\t{}\t{}\t{}\t{}\t{watts:.0}\t{}\t{}",
|
||||
data.device_info.make,
|
||||
data.device_info.firmware,
|
||||
data.device_info.model,
|
||||
cb,
|
||||
m.supports_set_power_limit(),
|
||||
m.supports_set_tuning_percent(),
|
||||
);
|
||||
found += 1;
|
||||
}
|
||||
}
|
||||
eprintln!("scan complete: {found} miner(s) responded");
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let args: Vec<String> = std::env::args().collect();
|
||||
let rt = match tokio::runtime::Builder::new_current_thread().enable_all().build() {
|
||||
Ok(rt) => rt,
|
||||
Err(e) => {
|
||||
eprintln!("tokio runtime: {e}");
|
||||
std::process::exit(2);
|
||||
}
|
||||
};
|
||||
match args.get(1).map(String::as_str) {
|
||||
Some("scan") if args.len() >= 3 => rt.block_on(scan(&args[2..])),
|
||||
_ => {
|
||||
eprintln!("usage: miner_probe scan <cidr> [<cidr>...]");
|
||||
std::process::exit(2);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -14,20 +14,24 @@ use asic_rs::core::traits::miner::MinerAuth;
|
||||
use crate::scan::config_path;
|
||||
|
||||
pub const CREDENTIALS_FILE: &str = "scan-credentials.txt";
|
||||
/// SSH login for the control board (used by the PIC probe; distinct from the
|
||||
/// web/API scan credentials above -- miners' SSH root login is usually not the
|
||||
/// same account as the web digest-auth login).
|
||||
pub const SSH_CREDENTIALS_FILE: &str = "ssh-credentials.txt";
|
||||
|
||||
/// Load the saved miner username/password, if any were saved.
|
||||
pub fn load_credentials() -> Option<(String, String)> {
|
||||
let s = std::fs::read_to_string(config_path(CREDENTIALS_FILE)).ok()?;
|
||||
/// Load a saved username/password pair from `file`, if present.
|
||||
fn load_creds_file(file: &str) -> Option<(String, String)> {
|
||||
let s = std::fs::read_to_string(config_path(file)).ok()?;
|
||||
let mut lines = s.lines();
|
||||
let user = lines.next()?.to_string();
|
||||
let pass = lines.next().unwrap_or("").to_string();
|
||||
Some((user, pass))
|
||||
}
|
||||
|
||||
/// Save the miner username/password, restricting the file to owner
|
||||
/// read/write (credentials are plaintext on disk, so the mode matters).
|
||||
pub fn save_credentials(user: &str, pass: &str) -> std::io::Result<()> {
|
||||
let p = config_path(CREDENTIALS_FILE);
|
||||
/// Save a username/password pair to `file`, restricting it to owner read/write
|
||||
/// (credentials are plaintext on disk, so the mode matters).
|
||||
fn save_creds_file(file: &str, user: &str, pass: &str) -> std::io::Result<()> {
|
||||
let p = config_path(file);
|
||||
if let Some(dir) = p.parent() {
|
||||
std::fs::create_dir_all(dir)?;
|
||||
}
|
||||
@@ -47,15 +51,42 @@ pub fn save_credentials(user: &str, pass: &str) -> std::io::Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Remove the saved credentials, if any. Not an error if none were saved.
|
||||
pub fn clear_credentials() -> std::io::Result<()> {
|
||||
match std::fs::remove_file(config_path(CREDENTIALS_FILE)) {
|
||||
fn clear_creds_file(file: &str) -> std::io::Result<()> {
|
||||
match std::fs::remove_file(config_path(file)) {
|
||||
Ok(()) => Ok(()),
|
||||
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()),
|
||||
Err(e) => Err(e),
|
||||
}
|
||||
}
|
||||
|
||||
/// Load the saved miner web/API username/password, if any were saved.
|
||||
pub fn load_credentials() -> Option<(String, String)> {
|
||||
load_creds_file(CREDENTIALS_FILE)
|
||||
}
|
||||
|
||||
/// Save the miner web/API username/password (0600).
|
||||
pub fn save_credentials(user: &str, pass: &str) -> std::io::Result<()> {
|
||||
save_creds_file(CREDENTIALS_FILE, user, pass)
|
||||
}
|
||||
|
||||
/// Load the saved SSH username/password for the PIC probe, if any.
|
||||
pub fn load_ssh_credentials() -> Option<(String, String)> {
|
||||
load_creds_file(SSH_CREDENTIALS_FILE)
|
||||
}
|
||||
|
||||
/// Save the SSH username/password for the PIC probe (0600).
|
||||
pub fn save_ssh_credentials(user: &str, pass: &str) -> std::io::Result<()> {
|
||||
save_creds_file(SSH_CREDENTIALS_FILE, user, pass)
|
||||
}
|
||||
|
||||
/// Remove the saved web/API credentials, if any. Not an error if none were saved.
|
||||
pub fn clear_credentials() -> std::io::Result<()> {
|
||||
match clear_creds_file(CREDENTIALS_FILE) {
|
||||
Ok(()) => Ok(()),
|
||||
Err(e) => Err(e),
|
||||
}
|
||||
}
|
||||
|
||||
/// Build a `MinerFactory` with the saved credentials (if any) applied as
|
||||
/// discovery auth for every firmware backend, so scans, refreshes, config
|
||||
/// actions, and firmware flashes all authenticate against a non-default
|
||||
|
||||
@@ -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
|
||||
@@ -15,10 +14,16 @@
|
||||
use crate::model::{is_slow, MinerRow};
|
||||
|
||||
/// One fixture board, pre-transform. `expected` of 0.0 means "band unknown".
|
||||
/// `make`/`model_id`/`board` mirror what asic-rs actually reports (compact
|
||||
/// identifiers + a bare control-board name) so the fixtures exercise the real
|
||||
/// crate::naming transform, not pre-cleaned strings.
|
||||
struct Board {
|
||||
ip: &'static str,
|
||||
model: &'static str,
|
||||
make: &'static str,
|
||||
model_id: &'static str,
|
||||
board: &'static str,
|
||||
firmware: &'static str,
|
||||
fw_version: &'static str,
|
||||
hashrate: f64,
|
||||
expected: f64,
|
||||
power: f64,
|
||||
@@ -48,23 +53,67 @@ impl Board {
|
||||
} else {
|
||||
vec![]
|
||||
};
|
||||
// Three per-hashboard chip temps around the average (so the offline demo
|
||||
// shows the "77 / 64 / 74" per-board Chip-temp cell).
|
||||
let board_temps = if self.mining && self.temp > 0.0 {
|
||||
vec![self.temp + 2.0, self.temp - 3.0, self.temp + 1.0]
|
||||
} else {
|
||||
vec![]
|
||||
};
|
||||
// Air-cooled WhatsMiners report an ambient reading (asic-rs surfaces it in
|
||||
// its fluid_temperature field); the scan routes it to env_temp for
|
||||
// air-cooled models, so the demo mirrors that (round 11 #17).
|
||||
let env_temp_c = if self.mining && self.make.eq_ignore_ascii_case("whatsminer") {
|
||||
27.0
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
// Per-hashboard health dots for the Boards column (round 11 #10): mining
|
||||
// units show three green dots, except two demo cases -- the slow S21 Pro
|
||||
// has one faulted (red) board, and one VNish S19 has a board that wasn't
|
||||
// detected (grey) -- so the offline demo exercises all three states.
|
||||
use crate::model::BoardHealth::{Fault, Missing, Ok};
|
||||
let board_status = if self.mining {
|
||||
match self.ip {
|
||||
"10.255.1.149" => vec![Ok, Fault, Ok],
|
||||
"10.255.1.166" => vec![Ok, Ok, Missing],
|
||||
_ => vec![Ok, Ok, Ok],
|
||||
}
|
||||
} else {
|
||||
vec![]
|
||||
};
|
||||
// Firmware-flash capability is modeled on the real Bitmain/Antminer
|
||||
// upgrade path (S17/S19/S21 family); WhatsMiner boards in this fleet
|
||||
// don't advertise it, so both true and false show up and the
|
||||
// firmware menu item is testable.
|
||||
let firmware_flash = self.model == "Antminer S17"
|
||||
|| self.model.starts_with("Antminer S19")
|
||||
|| self.model.starts_with("Antminer S21");
|
||||
let firmware_flash = self.make.eq_ignore_ascii_case("antminer")
|
||||
&& (self.model_id == "S17"
|
||||
|| self.model_id.starts_with("S19")
|
||||
|| self.model_id.starts_with("S21"));
|
||||
// Derive the display identity through the same path the live scan uses.
|
||||
let brand = crate::naming::brand(self.make);
|
||||
let model = crate::naming::clean_model(self.make, self.model_id);
|
||||
let submodel = crate::naming::submodel(self.make, self.model_id);
|
||||
let control_board = crate::naming::control_board_code(self.make, self.board, &model);
|
||||
let cpu = crate::naming::control_board_cpu(self.make, self.board, &model);
|
||||
let board_code = crate::naming::control_board_board(self.make, self.board, &model);
|
||||
MinerRow {
|
||||
ip: self.ip.to_string(),
|
||||
selected: false,
|
||||
model: self.model.to_string(),
|
||||
model,
|
||||
brand,
|
||||
submodel,
|
||||
firmware: self.firmware.to_string(),
|
||||
fw_version: self.fw_version.to_string(),
|
||||
cpu,
|
||||
board_code,
|
||||
hashrate_ths: self.hashrate,
|
||||
expected_ths: self.expected,
|
||||
efficiency,
|
||||
power_w: self.power,
|
||||
chip_temp_c: self.temp,
|
||||
board_temps,
|
||||
env_temp_c,
|
||||
fan_rpms,
|
||||
worker: self.worker.to_string(),
|
||||
is_mining: self.mining,
|
||||
@@ -75,10 +124,13 @@ impl Board {
|
||||
hostname: format!("miner-{last_octet}"),
|
||||
hashboards: boards,
|
||||
expected_hashboards: Some(3),
|
||||
board_status,
|
||||
total_chips: chips,
|
||||
psu_fan_rpm: if self.mining { self.fan * 0.9 } else { 0.0 },
|
||||
uptime_secs: if self.mining { 3600 * 24 * 2 + 3600 * 5 } else { 0 },
|
||||
light_flashing: Some(false),
|
||||
// One unit is "being located" so the Light column's yellow dot is
|
||||
// demonstrable offline (round 11 #10).
|
||||
light_flashing: Some(self.ip == "10.255.1.167"),
|
||||
pool_url: if self.worker.is_empty() { String::new() } else { "stratum+tcp://pool.blueflare:3333".to_string() },
|
||||
pools: if self.worker.is_empty() {
|
||||
Vec::new()
|
||||
@@ -107,62 +159,76 @@ impl Board {
|
||||
tuning: self.mining,
|
||||
firmware_flash,
|
||||
},
|
||||
// Demo values for the round-8/9 columns (synthetic, so the columns
|
||||
// show variety offline). control_board is derived above via naming.
|
||||
algorithm: "SHA256".to_string(),
|
||||
control_board,
|
||||
pic_present: if self.model_id.contains("S21") {
|
||||
Some(false) // noPIC example
|
||||
} else if self.make.eq_ignore_ascii_case("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()),
|
||||
// Concise, prefix-free lines (matching summarize_messages output):
|
||||
// the Errors column shows the count, these are the hover tooltip.
|
||||
errors: if self.model_id == "S21Pro" {
|
||||
vec![
|
||||
"hashrate 70% below expected".to_string(),
|
||||
"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,
|
||||
/// `offline: true`).
|
||||
/// 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",
|
||||
// firmware families span the palette (Stock/VNish/Braiins/LuxOS/ePIC/
|
||||
// Hive/BixBit/Alkane) so the offline demo shows the Firmware colouring.
|
||||
Board { ip: "10.255.1.112", make: "Antminer", model_id: "S17", board: "Xilinx", firmware: "Stock", fw_version: "",
|
||||
hashrate: 0.0, expected: 0.0, power: 0.0, temp: 0.0, fan: 0.0,
|
||||
worker: "", mining: false, paused: false },
|
||||
Board { ip: "10.255.1.166", model: "Antminer S19", firmware: "[removed] 1.2",
|
||||
Board { ip: "10.255.1.166", make: "Antminer", model_id: "S19", board: "BeagleBoneBlack", firmware: "VNish", fw_version: "1.2.8",
|
||||
hashrate: 95.0, expected: 96.0, power: 3250.0, temp: 65.0, fan: 4200.0,
|
||||
worker: "blueflare.s19", mining: true, paused: false },
|
||||
Board { ip: "10.255.1.152", model: "Antminer S19j Pro", firmware: "[removed] 1.2",
|
||||
Board { ip: "10.255.1.152", make: "Antminer", model_id: "S19jPro", board: "AMLogic", firmware: "Braiins", fw_version: "25.05.1",
|
||||
hashrate: 100.0, expected: 104.0, power: 3100.0, temp: 62.0, fan: 3900.0,
|
||||
worker: "blueflare.s19jpro", mining: true, paused: false },
|
||||
Board { ip: "10.255.1.167", model: "Antminer S19k Pro", firmware: "[removed] 1.2",
|
||||
Board { ip: "10.255.1.167", make: "Antminer", model_id: "S19KPro", board: "AMLogic", firmware: "LuxOS", fw_version: "2024.9.0",
|
||||
hashrate: 120.0, expected: 128.0, power: 3300.0, temp: 68.0, fan: 4500.0,
|
||||
worker: "blueflare.s19kpro", mining: true, paused: false },
|
||||
Board { ip: "10.255.1.149", model: "Antminer S21 Pro", firmware: "Stock",
|
||||
Board { ip: "10.255.1.149", make: "Antminer", model_id: "S21Pro", board: "CVITek", firmware: "ePIC", fw_version: "1.0.3",
|
||||
hashrate: 60.0, expected: 200.0, power: 1500.0, temp: 55.0, fan: 3000.0,
|
||||
worker: "blueflare.s21pro", mining: true, paused: false }, // slow: 60/200 = 30%
|
||||
Board { ip: "10.255.1.126", model: "WhatsMiner M30S", firmware: "WMOS H3",
|
||||
Board { ip: "10.255.1.126", make: "Whatsminer", model_id: "M30SVE40", board: "H3", firmware: "Stock", fw_version: "H3.0.1",
|
||||
hashrate: 92.0, expected: 96.0, power: 3400.0, temp: 70.0, fan: 4800.0,
|
||||
worker: "blueflare.h3", mining: true, paused: false },
|
||||
Board { ip: "10.255.1.131", model: "WhatsMiner M30S+", firmware: "WMOS H616",
|
||||
Board { ip: "10.255.1.131", make: "Whatsminer", model_id: "M30SPlusVE40", board: "H616", firmware: "Hive", fw_version: "1.0",
|
||||
hashrate: 100.0, expected: 100.0, power: 3450.0, temp: 71.0, fan: 4900.0,
|
||||
worker: "blueflare.h616", mining: true, paused: false },
|
||||
Board { ip: "10.255.1.148", model: "WhatsMiner M50", firmware: "WMOS CB4",
|
||||
Board { ip: "10.255.1.148", make: "Whatsminer", model_id: "M50VH50", board: "H6", firmware: "BixBit", fw_version: "2.1",
|
||||
hashrate: 118.0, expected: 122.0, power: 3300.0, temp: 66.0, fan: 4600.0,
|
||||
worker: "blueflare.m50", mining: true, paused: false },
|
||||
// Rebucketed from idle/not-hashing to paused so the "paused"
|
||||
// status/KPI bucket is exercisable in the fake-scan/offline demo.
|
||||
Board { ip: "10.255.1.115", model: "Antminer S19", firmware: "WardenOS dev",
|
||||
Board { ip: "10.255.1.115", make: "Antminer", model_id: "S19", board: "BeagleBoneBlack", firmware: "Alkane", fw_version: "0.1",
|
||||
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, offline: true.
|
||||
rows.push(MinerRow::offline("10.255.1.199".into()));
|
||||
rows
|
||||
boards.into_iter().map(Board::into_row).collect()
|
||||
}
|
||||
|
||||
@@ -1,9 +1,13 @@
|
||||
//! alkane-toolkit — primary view (docs/UI-SPEC.md).
|
||||
//! Pure-Rust wxWidgets app on the vendored, patched wx-rs.
|
||||
|
||||
mod access_probe;
|
||||
mod credentials;
|
||||
mod fixtures;
|
||||
mod model;
|
||||
mod naming;
|
||||
mod pic_probe;
|
||||
mod presets;
|
||||
mod scan;
|
||||
mod ui;
|
||||
|
||||
|
||||
+322
-107
@@ -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}"),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -130,6 +134,16 @@ pub fn decode_segments_plain(s: &str) -> String {
|
||||
.collect::<String>()
|
||||
}
|
||||
|
||||
/// Split a full pool worker "account.worker" into (account, worker). Mining
|
||||
/// pools name a worker "<account>.<rig>"; split on the first '.'. With no '.',
|
||||
/// the whole string is the account and the worker name is empty.
|
||||
fn split_worker(full: &str) -> (&str, &str) {
|
||||
match full.split_once('.') {
|
||||
Some((account, worker)) => (account, worker),
|
||||
None => (full, ""),
|
||||
}
|
||||
}
|
||||
|
||||
/// Compact human duration (e.g. "3d 4h", "5h 12m", "42m", "18s").
|
||||
pub fn format_uptime(secs: u64) -> String {
|
||||
if secs == 0 {
|
||||
@@ -208,6 +222,28 @@ 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
|
||||
}
|
||||
}
|
||||
|
||||
/// Per-hashboard health for the Boards column's status dots (round 11 #10):
|
||||
/// green = present and hashing, red = present but idle/faulty, grey = expected
|
||||
/// but not detected at all.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum BoardHealth {
|
||||
Ok,
|
||||
Fault,
|
||||
Missing,
|
||||
}
|
||||
|
||||
/// One miner's telemetry snapshot, flattened from asic-rs `MinerData` into the
|
||||
@@ -221,12 +257,40 @@ pub struct MinerRow {
|
||||
pub caps: MinerCaps,
|
||||
// identity
|
||||
pub model: String,
|
||||
/// Manufacturer brand ("Antminer", "WhatsMiner", ...), its own column so the
|
||||
/// Model column can carry just the cleaned model name.
|
||||
pub brand: String,
|
||||
/// Model sub-variant: WhatsMiner's version block ("VE40"); blank for Antminer
|
||||
/// (its hashboard type is not reported over the network by asic-rs).
|
||||
pub submodel: String,
|
||||
pub mac: String,
|
||||
pub hostname: String,
|
||||
pub serial: String,
|
||||
/// Firmware family only ("Stock", "VNish", "Braiins", ...); the Firmware
|
||||
/// column colours by this. The version string lives in `fw_version`.
|
||||
pub firmware: String,
|
||||
pub fw_version: String,
|
||||
pub api_version: String,
|
||||
/// Combined "CPU (code)" control-board label (e.g. "AML (C76)"); `cpu` and
|
||||
/// `board_code` hold the split halves for their own columns.
|
||||
pub control_board: String,
|
||||
pub cpu: String,
|
||||
pub board_code: String,
|
||||
/// Mining algorithm (e.g. "SHA256", "Scrypt", "Equihash"), from asic-rs.
|
||||
pub algorithm: 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,
|
||||
@@ -235,8 +299,20 @@ pub struct MinerRow {
|
||||
pub power_w: f64,
|
||||
pub tuning_percent: Option<u8>,
|
||||
// thermal / cooling
|
||||
/// Average chip temperature (used for sorting/colour banding of the
|
||||
/// combined Chip-temp cell).
|
||||
pub chip_temp_c: f64,
|
||||
/// Per-hashboard chip temperature (hottest chip per board), shown in the
|
||||
/// Chip-temp column as "77 / 64 / 74". Empty falls back to the average.
|
||||
pub board_temps: Vec<f64>,
|
||||
/// Coolant/immersion-fluid temperature (liquid-cooled miners only).
|
||||
pub fluid_temp_c: f64,
|
||||
/// Environment/ambient air temperature. asic-rs reports air-cooled miners'
|
||||
/// ambient reading in its `fluid_temperature` field (see the WhatsMiner
|
||||
/// backends' "Env Temp"/"environment-temperature" key); the scan routes it
|
||||
/// here for air-cooled models so it isn't mislabelled as a fluid temp
|
||||
/// (round 11 #17).
|
||||
pub env_temp_c: f64,
|
||||
pub outlet_temp_c: f64,
|
||||
/// Individual cooling-fan RPMs (empty if unknown). PSU fan is tracked
|
||||
/// separately below since it is not part of the cooling-fan set.
|
||||
@@ -249,6 +325,10 @@ pub struct MinerRow {
|
||||
pub expected_chips: Option<u32>,
|
||||
pub hashboards: Option<u32>,
|
||||
pub expected_hashboards: Option<u32>,
|
||||
/// Per-hashboard health for the Boards status dots (round 11 #10), one entry
|
||||
/// per expected board, ordered by position (index 0 = board 1). Empty = no
|
||||
/// per-board data (the cell renders blank).
|
||||
pub board_status: Vec<BoardHealth>,
|
||||
// pool: active-pool convenience fields, plus the (url, worker) of each
|
||||
// configured pool (miners usually allow up to 3 redundant pools).
|
||||
pub worker: String,
|
||||
@@ -266,30 +346,14 @@ pub struct MinerRow {
|
||||
/// Not-mining because an operator paused it (distinct from simply idle);
|
||||
/// see `is_paused`.
|
||||
pub paused: bool,
|
||||
/// Whether this miner FAILED to respond to the scan. Stored as `offline`
|
||||
/// (not `online`) so `Default` gives `false` -- i.e. a plain
|
||||
/// `MinerRow { ..Default::default() }` is a reachable row, and only
|
||||
/// `MinerRow::offline` deliberately marks a row unreachable. This removes
|
||||
/// the old footgun where a struct-update literal that forgot `online: true`
|
||||
/// silently read back as offline.
|
||||
pub offline: bool,
|
||||
}
|
||||
|
||||
impl MinerRow {
|
||||
/// A miner that did not respond to this scan attempt: ip only, every
|
||||
/// other field blank/zero/false, `offline: true` so `status()` reports
|
||||
/// "offline".
|
||||
pub fn offline(ip: String) -> MinerRow {
|
||||
let mut r = MinerRow::default();
|
||||
r.ip = ip;
|
||||
r.offline = true;
|
||||
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.offline {
|
||||
"offline"
|
||||
} else if self.slow {
|
||||
if self.slow {
|
||||
"slow"
|
||||
} else if self.paused {
|
||||
"paused"
|
||||
@@ -332,19 +396,29 @@ pub fn flash_confirmed(input: &str) -> bool {
|
||||
/// 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.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
|
||||
pub enum Column {
|
||||
Ip,
|
||||
Hashrate,
|
||||
/// Sort-only pseudo-column (round 11 #16): the actual/expected hashrate
|
||||
/// ratio. Deliberately NOT in `ALL_COLUMNS`, so it never appears in the
|
||||
/// column picker or the display order; it exists only as a `sort` target the
|
||||
/// Hashrate header cycles into.
|
||||
HashrateRel,
|
||||
Power,
|
||||
ChipTemp,
|
||||
Cooling,
|
||||
Firmware,
|
||||
FwVersion,
|
||||
Worker,
|
||||
PoolAccount,
|
||||
Model,
|
||||
Brand,
|
||||
Submodel,
|
||||
Status,
|
||||
Efficiency,
|
||||
FluidTemp,
|
||||
EnvTemp,
|
||||
OutletTemp,
|
||||
PsuFan,
|
||||
FanCount,
|
||||
@@ -355,7 +429,12 @@ pub enum Column {
|
||||
Hostname,
|
||||
Serial,
|
||||
ApiVersion,
|
||||
ControlBoard,
|
||||
Cpu,
|
||||
BoardCode,
|
||||
Algorithm,
|
||||
Pic,
|
||||
Locked,
|
||||
Error,
|
||||
Uptime,
|
||||
Light,
|
||||
OperatingState,
|
||||
@@ -373,18 +452,23 @@ 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; 45] = [
|
||||
Column::Ip,
|
||||
Column::Hashrate,
|
||||
Column::Power,
|
||||
Column::ChipTemp,
|
||||
Column::Cooling,
|
||||
Column::Firmware,
|
||||
Column::FwVersion,
|
||||
Column::Worker,
|
||||
Column::PoolAccount,
|
||||
Column::Model,
|
||||
Column::Brand,
|
||||
Column::Submodel,
|
||||
Column::Status,
|
||||
Column::Efficiency,
|
||||
Column::FluidTemp,
|
||||
Column::EnvTemp,
|
||||
Column::OutletTemp,
|
||||
Column::PsuFan,
|
||||
Column::FanCount,
|
||||
@@ -395,7 +479,12 @@ pub const ALL_COLUMNS: [Column; 35] = [
|
||||
Column::Hostname,
|
||||
Column::Serial,
|
||||
Column::ApiVersion,
|
||||
Column::ControlBoard,
|
||||
Column::Cpu,
|
||||
Column::BoardCode,
|
||||
Column::Algorithm,
|
||||
Column::Pic,
|
||||
Column::Locked,
|
||||
Column::Error,
|
||||
Column::Uptime,
|
||||
Column::Light,
|
||||
Column::OperatingState,
|
||||
@@ -411,16 +500,19 @@ pub const ALL_COLUMNS: [Column; 35] = [
|
||||
Column::Pool3Worker,
|
||||
];
|
||||
|
||||
/// The columns shown by default (UI-SPEC), after the fixed IP column.
|
||||
pub const DEFAULT_VISIBLE: [Column; 8] = [
|
||||
/// The columns shown by default (UI-SPEC), after the fixed IP column, in display
|
||||
/// order: model, errors, hashrate, power, chip temp, firmware, CPU, boards
|
||||
/// (hashboard health), access.
|
||||
pub const DEFAULT_VISIBLE: [Column; 9] = [
|
||||
Column::Model,
|
||||
Column::Error,
|
||||
Column::Hashrate,
|
||||
Column::Power,
|
||||
Column::ChipTemp,
|
||||
Column::Cooling,
|
||||
Column::Firmware,
|
||||
Column::Worker,
|
||||
Column::Model,
|
||||
Column::Status,
|
||||
Column::Cpu,
|
||||
Column::Hashboards,
|
||||
Column::Locked,
|
||||
];
|
||||
|
||||
impl Column {
|
||||
@@ -428,15 +520,21 @@ impl Column {
|
||||
match self {
|
||||
Column::Ip => "IP",
|
||||
Column::Hashrate => "Hashrate",
|
||||
Column::HashrateRel => "Rel. hashrate",
|
||||
Column::Power => "Power",
|
||||
Column::ChipTemp => "Chip temp",
|
||||
Column::Cooling => "Fan (RPM)",
|
||||
Column::Firmware => "Firmware",
|
||||
Column::Worker => "Pool worker",
|
||||
Column::FwVersion => "FW Version",
|
||||
Column::Worker => "Worker",
|
||||
Column::PoolAccount => "Pool account",
|
||||
Column::Model => "Model",
|
||||
Column::Brand => "Brand",
|
||||
Column::Submodel => "Submodel",
|
||||
Column::Status => "Status",
|
||||
Column::Efficiency => "Efficiency (J/TH)",
|
||||
Column::FluidTemp => "Fluid temp",
|
||||
Column::EnvTemp => "Env temp",
|
||||
Column::OutletTemp => "Outlet temp",
|
||||
Column::PsuFan => "PSU fan (RPM)",
|
||||
Column::FanCount => "Fans",
|
||||
@@ -447,9 +545,14 @@ impl Column {
|
||||
Column::Hostname => "Hostname",
|
||||
Column::Serial => "Serial",
|
||||
Column::ApiVersion => "API ver",
|
||||
Column::ControlBoard => "Control board",
|
||||
Column::Cpu => "CPU",
|
||||
Column::BoardCode => "Board",
|
||||
Column::Algorithm => "Algorithm",
|
||||
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",
|
||||
@@ -468,19 +571,29 @@ impl Column {
|
||||
match self {
|
||||
Column::Ip => 130,
|
||||
Column::Hashrate => 110,
|
||||
Column::HashrateRel => 110,
|
||||
Column::Power => 90,
|
||||
Column::ChipTemp | Column::FluidTemp | Column::OutletTemp => 95,
|
||||
Column::ChipTemp | Column::FluidTemp | Column::EnvTemp | Column::OutletTemp => 95,
|
||||
Column::Cooling | Column::PsuFan => 100,
|
||||
Column::Firmware => 160,
|
||||
Column::Worker => 150,
|
||||
Column::Firmware => 110,
|
||||
Column::FwVersion => 130,
|
||||
Column::Worker => 130,
|
||||
Column::PoolAccount => 120,
|
||||
Column::Model => 150,
|
||||
Column::Brand => 100,
|
||||
Column::Submodel => 100,
|
||||
Column::Status => 95,
|
||||
Column::Efficiency => 120,
|
||||
Column::FanCount | Column::TotalChips | Column::Hashboards => 70,
|
||||
Column::ExpectedFans | Column::TuningPercent => 90,
|
||||
Column::Mac | Column::Hostname | Column::Serial => 150,
|
||||
Column::ApiVersion | Column::Light => 90,
|
||||
Column::ControlBoard => 130,
|
||||
Column::Cpu => 70,
|
||||
Column::BoardCode => 70,
|
||||
Column::Algorithm => 100,
|
||||
Column::Pic => 70,
|
||||
Column::Locked => 90,
|
||||
Column::Error => 160,
|
||||
Column::Uptime => 100,
|
||||
Column::OperatingState => 100,
|
||||
Column::BestShare | Column::SessionBestShare => 110,
|
||||
@@ -496,10 +609,12 @@ impl Column {
|
||||
matches!(
|
||||
self,
|
||||
Column::Hashrate
|
||||
| Column::HashrateRel
|
||||
| Column::Power
|
||||
| Column::Efficiency
|
||||
| Column::ChipTemp
|
||||
| Column::FluidTemp
|
||||
| Column::EnvTemp
|
||||
| Column::OutletTemp
|
||||
| Column::Cooling
|
||||
| Column::PsuFan
|
||||
@@ -547,10 +662,16 @@ impl Column {
|
||||
let none = f64::NEG_INFINITY;
|
||||
match self {
|
||||
Column::Hashrate => SortKey::Num(r.hashrate_ths),
|
||||
// Relative hashrate = actual/expected; unknown expectation sorts to
|
||||
// the bottom (round 11 #16).
|
||||
Column::HashrateRel => {
|
||||
SortKey::Num(actual_expected_ratio(r.hashrate_ths, r.expected_ths).unwrap_or(none))
|
||||
}
|
||||
Column::Power => SortKey::Num(r.power_w),
|
||||
Column::Efficiency => SortKey::Num(if r.efficiency > 0.0 { r.efficiency } else { none }),
|
||||
Column::ChipTemp => SortKey::Num(r.chip_temp_c),
|
||||
Column::FluidTemp => SortKey::Num(r.fluid_temp_c),
|
||||
Column::EnvTemp => SortKey::Num(r.env_temp_c),
|
||||
Column::OutletTemp => SortKey::Num(r.outlet_temp_c),
|
||||
Column::Cooling => SortKey::Num(if r.fan_rpms.is_empty() {
|
||||
none
|
||||
@@ -591,6 +712,11 @@ impl Column {
|
||||
match self {
|
||||
Column::Ip => r.ip.clone(),
|
||||
Column::Hashrate => combined_si(r.hashrate_ths, r.expected_ths),
|
||||
// Never displayed as its own column; rendered as a percentage only for
|
||||
// completeness (e.g. a debug/self-test read of the cell).
|
||||
Column::HashrateRel => actual_expected_ratio(r.hashrate_ths, r.expected_ths)
|
||||
.map(|ratio| format!("{:.0}%", ratio * 100.0))
|
||||
.unwrap_or_default(),
|
||||
Column::Power => {
|
||||
if r.power_w > 0.0 {
|
||||
format_si(r.power_w, "W")
|
||||
@@ -599,8 +725,17 @@ impl Column {
|
||||
}
|
||||
}
|
||||
Column::Efficiency => num(r.efficiency, 1, ""),
|
||||
Column::ChipTemp => num(r.chip_temp_c, 1, " C"),
|
||||
// Per-hashboard chip temps as integers ("77 / 64 / 74"); fall back to
|
||||
// the average (integer) when per-board readings aren't available.
|
||||
Column::ChipTemp => {
|
||||
if r.board_temps.is_empty() {
|
||||
if r.chip_temp_c > 0.0 { format!("{:.0}", r.chip_temp_c) } else { String::new() }
|
||||
} else {
|
||||
r.board_temps.iter().map(|&t| format!("{t:.0}")).collect::<Vec<_>>().join(" / ")
|
||||
}
|
||||
}
|
||||
Column::FluidTemp => num(r.fluid_temp_c, 1, " C"),
|
||||
Column::EnvTemp => num(r.env_temp_c, 1, " C"),
|
||||
Column::OutletTemp => num(r.outlet_temp_c, 1, " C"),
|
||||
Column::Cooling => {
|
||||
r.fan_rpms.iter().map(|&v| format_fan_rpm(v)).collect::<Vec<_>>().join("/")
|
||||
@@ -611,14 +746,36 @@ impl Column {
|
||||
Column::TotalChips => combined_count(r.total_chips, r.expected_chips),
|
||||
Column::Hashboards => combined_count(r.hashboards, r.expected_hashboards),
|
||||
Column::Firmware => r.firmware.clone(),
|
||||
Column::Worker => r.worker.clone(),
|
||||
Column::FwVersion => r.fw_version.clone(),
|
||||
Column::Worker => split_worker(&r.worker).1.to_string(),
|
||||
Column::PoolAccount => split_worker(&r.worker).0.to_string(),
|
||||
Column::PoolUrl => r.pool_url.clone(),
|
||||
Column::Model => r.model.clone(),
|
||||
Column::Brand => r.brand.clone(),
|
||||
Column::Submodel => r.submodel.clone(),
|
||||
Column::Mac => r.mac.clone(),
|
||||
Column::Hostname => r.hostname.clone(),
|
||||
Column::Serial => r.serial.clone(),
|
||||
Column::ApiVersion => r.api_version.clone(),
|
||||
Column::ControlBoard => r.control_board.clone(),
|
||||
Column::Cpu => r.cpu.clone(),
|
||||
Column::BoardCode => r.board_code.clone(),
|
||||
Column::Algorithm => r.algorithm.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(),
|
||||
},
|
||||
// Just the count (blank when none); the full list is the hover
|
||||
// tooltip (see fill_rows). No "errors" word, even for a single one.
|
||||
Column::Error => match r.errors.len() {
|
||||
0 => String::new(),
|
||||
n => n.to_string(),
|
||||
},
|
||||
Column::Status => r.status().to_string(),
|
||||
Column::Uptime => format_uptime(r.uptime_secs),
|
||||
Column::Light => match r.light_flashing {
|
||||
@@ -648,7 +805,7 @@ pub enum SortKey {
|
||||
}
|
||||
|
||||
/// Text-column filter operators (Excel-style text filters).
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
|
||||
pub enum TextOp {
|
||||
Contains,
|
||||
NotContains,
|
||||
@@ -658,7 +815,7 @@ pub enum TextOp {
|
||||
}
|
||||
|
||||
/// Numeric-column filter operators (Excel-style number filters).
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
|
||||
pub enum NumOp {
|
||||
Between,
|
||||
Eq,
|
||||
@@ -671,7 +828,7 @@ pub enum NumOp {
|
||||
|
||||
/// One column's active filter. Text columns can filter by a value checklist
|
||||
/// ("is any of") or a text predicate; numeric columns by a numeric predicate.
|
||||
#[derive(Debug, Clone)]
|
||||
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
||||
pub enum ColFilter {
|
||||
Values(HashSet<String>),
|
||||
Text { op: TextOp, needle: String },
|
||||
@@ -712,6 +869,7 @@ impl ColFilter {
|
||||
}
|
||||
|
||||
/// Display state: order, visibility, sort, filter.
|
||||
#[derive(Clone)]
|
||||
pub struct ViewState {
|
||||
/// Model column order as displayed (Ip is always the first visible column).
|
||||
pub order: Vec<Column>,
|
||||
@@ -723,9 +881,17 @@ pub struct ViewState {
|
||||
|
||||
impl Default for ViewState {
|
||||
fn default() -> Self {
|
||||
// Registry order for `order`; Ip + DEFAULT_VISIBLE are shown. Default
|
||||
// sort is by IP ascending.
|
||||
let order: Vec<Column> = ALL_COLUMNS.to_vec();
|
||||
// Display order = Ip, then DEFAULT_VISIBLE in its own order, then every
|
||||
// remaining metric (so the initial columns match the UI-SPEC order rather
|
||||
// than the ALL_COLUMNS registry order). Default sort is by IP ascending.
|
||||
let mut order: Vec<Column> = Vec::with_capacity(ALL_COLUMNS.len());
|
||||
order.push(Column::Ip);
|
||||
order.extend(DEFAULT_VISIBLE);
|
||||
for c in ALL_COLUMNS {
|
||||
if !order.contains(&c) {
|
||||
order.push(c);
|
||||
}
|
||||
}
|
||||
let mut visible: HashSet<Column> = DEFAULT_VISIBLE.iter().copied().collect();
|
||||
visible.insert(Column::Ip);
|
||||
ViewState { order, visible, sort: Some((Column::Ip, true)), filters: HashMap::new() }
|
||||
@@ -742,6 +908,16 @@ impl ViewState {
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Every column available to filter on, independent of visibility: a filter
|
||||
/// matches a row by that column's cell text whether or not the column is
|
||||
/// shown, so (e.g.) Algorithm can be filtered without first un-hiding it.
|
||||
/// Ip first, then the registry order.
|
||||
pub fn filter_columns(&self) -> Vec<Column> {
|
||||
let mut v = vec![Column::Ip];
|
||||
v.extend(self.order.iter().copied().filter(|c| *c != Column::Ip));
|
||||
v
|
||||
}
|
||||
|
||||
pub fn is_fixed(&self, c: Column) -> bool {
|
||||
c == Column::Ip
|
||||
}
|
||||
@@ -800,9 +976,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,
|
||||
@@ -811,6 +987,11 @@ pub struct Kpis {
|
||||
pub paused: usize,
|
||||
pub total_hashrate_ths: f64,
|
||||
pub total_power_w: f64,
|
||||
/// Per-algorithm hashrate totals (algorithm name, total TH/s), only for
|
||||
/// algorithms actually producing hashrate, ordered by total descending then
|
||||
/// name. The hashrate KPI card cycles through these when more than one
|
||||
/// algorithm is running in the fleet.
|
||||
pub hashrate_by_algo: Vec<(String, f64)>,
|
||||
}
|
||||
|
||||
pub fn compute_kpis(rows: &[MinerRow], view_idx: &[usize]) -> Kpis {
|
||||
@@ -822,12 +1003,15 @@ pub fn compute_kpis(rows: &[MinerRow], view_idx: &[usize]) -> Kpis {
|
||||
paused: 0,
|
||||
total_hashrate_ths: 0.0,
|
||||
total_power_w: 0.0,
|
||||
hashrate_by_algo: Vec::new(),
|
||||
};
|
||||
// Accumulate per-algorithm totals in an insertion-ordered list (fleets have
|
||||
// a handful of algorithms at most, so a linear scan is cheaper than a map).
|
||||
let mut by_algo: Vec<(String, f64)> = Vec::new();
|
||||
for &i in view_idx {
|
||||
let r = &rows[i];
|
||||
// Bucket by the same precedence status() uses, so the KPI header can
|
||||
// never disagree with a row's own status text. There is no separate
|
||||
// "offline" KPI, so offline folds into not_hashing (the `_` arm).
|
||||
// never disagree with a row's own status text.
|
||||
match r.status() {
|
||||
"slow" => k.slow += 1,
|
||||
"paused" => k.paused += 1,
|
||||
@@ -836,7 +1020,19 @@ pub fn compute_kpis(rows: &[MinerRow], view_idx: &[usize]) -> Kpis {
|
||||
}
|
||||
k.total_hashrate_ths += r.hashrate_ths;
|
||||
k.total_power_w += r.power_w;
|
||||
if r.hashrate_ths > 0.0 {
|
||||
// Fall back to "SHA256" when a miner didn't report its algorithm, so
|
||||
// a producing miner is never dropped from the per-algorithm cycle.
|
||||
let algo = if r.algorithm.is_empty() { "SHA256" } else { r.algorithm.as_str() };
|
||||
match by_algo.iter_mut().find(|(a, _)| a == algo) {
|
||||
Some((_, t)) => *t += r.hashrate_ths,
|
||||
None => by_algo.push((algo.to_string(), r.hashrate_ths)),
|
||||
}
|
||||
}
|
||||
}
|
||||
// Stable order: largest total first, ties broken alphabetically.
|
||||
by_algo.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal).then(a.0.cmp(&b.0)));
|
||||
k.hashrate_by_algo = by_algo;
|
||||
k
|
||||
}
|
||||
|
||||
@@ -857,12 +1053,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);
|
||||
|
||||
@@ -875,8 +1068,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}"),
|
||||
}
|
||||
}
|
||||
@@ -921,8 +1113,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");
|
||||
}
|
||||
@@ -1004,9 +1196,12 @@ mod tests {
|
||||
fn reorder_with_hidden_column_keeps_all_columns() {
|
||||
let mut view = ViewState::default();
|
||||
view.visible.remove(&Column::Power);
|
||||
// display now: Ip(0), Hashrate(1), ChipTemp(2), ... - swap Hashrate/ChipTemp
|
||||
// Swap Hashrate and ChipTemp in the visible display order (order-agnostic:
|
||||
// find them by identity rather than by a fixed index).
|
||||
let mut vis = view.display_columns();
|
||||
vis.swap(1, 2);
|
||||
let hr0 = vis.iter().position(|c| *c == Column::Hashrate).unwrap();
|
||||
let ct0 = vis.iter().position(|c| *c == Column::ChipTemp).unwrap();
|
||||
vis.swap(hr0, ct0);
|
||||
view.apply_visible_reorder(&vis);
|
||||
assert!(view.order.contains(&Column::Power), "hidden column dropped!");
|
||||
assert_eq!(view.order.len(), ALL_COLUMNS.len());
|
||||
@@ -1151,6 +1346,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 shows only the count (blank when none), even for one.
|
||||
let none = MinerRow { errors: vec![], ..Default::default() };
|
||||
let one = MinerRow { errors: vec!["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), "1");
|
||||
assert_eq!(Column::Error.cell(&many), "3");
|
||||
}
|
||||
|
||||
#[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
|
||||
@@ -1448,7 +1676,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");
|
||||
|
||||
@@ -1458,7 +1686,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");
|
||||
|
||||
@@ -1471,7 +1699,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");
|
||||
}
|
||||
@@ -1538,18 +1766,10 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn status_offline_and_paused() {
|
||||
let offline = MinerRow::offline("10.1.2.3".into());
|
||||
assert_eq!(offline.status(), "offline");
|
||||
assert!(offline.offline);
|
||||
assert_eq!(offline.ip, "10.1.2.3");
|
||||
assert_eq!(offline.hashrate_ths, 0.0, "offline row is otherwise blank");
|
||||
|
||||
// A plain default row is online (offline: false), so a struct-update
|
||||
// literal that forgets to say so is reachable, not silently offline.
|
||||
let default_is_online = MinerRow { ..Default::default() };
|
||||
assert!(!default_is_online.offline, "Default row must be online");
|
||||
assert_eq!(default_is_online.status(), "not hashing");
|
||||
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 { paused: true, ..Default::default() };
|
||||
assert_eq!(paused.status(), "paused");
|
||||
@@ -1557,17 +1777,13 @@ mod tests {
|
||||
let hashing = MinerRow { is_mining: true, ..Default::default() };
|
||||
assert_eq!(hashing.status(), "hashing");
|
||||
|
||||
let not_hashing = MinerRow { ..Default::default() };
|
||||
assert_eq!(not_hashing.status(), "not hashing");
|
||||
|
||||
// offline outranks slow/paused/hashing in the precedence order.
|
||||
let offline_but_flagged =
|
||||
MinerRow { offline: true, 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 { 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]
|
||||
@@ -1581,21 +1797,20 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn kpis_bucket_by_status_not_raw_flags() {
|
||||
// An offline row that also carries stale slow/paused/mining flags must
|
||||
// count as not_hashing (matching status() == "offline"), never as slow
|
||||
// or paused -- i.e. compute_kpis and status() can't diverge.
|
||||
// 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 { offline: true, slow: true, paused: true, is_mining: true, ..Default::default() },
|
||||
MinerRow { slow: true, ..Default::default() },
|
||||
MinerRow { paused: true, ..Default::default() },
|
||||
MinerRow { is_mining: true, ..Default::default() },
|
||||
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, "only the genuinely-slow row");
|
||||
assert_eq!(k.paused, 1, "only the genuinely-paused row");
|
||||
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, "the offline-but-flagged row folds here, not into slow");
|
||||
assert_eq!(k.not_hashing, 1);
|
||||
assert_eq!(k.total, 4);
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,413 @@
|
||||
//! Display-layer device-naming cleanup (round-9 item #11).
|
||||
//!
|
||||
//! asic-rs hands us compact Rust-identifier model strings and bare control-board
|
||||
//! names, not human-facing labels:
|
||||
//! - `device_info.make` = "Antminer" / "Whatsminer" (note the casing)
|
||||
//! - `device_info.model` = the model enum's variant identifier verbatim, e.g.
|
||||
//! "S19KPro", "S19jPro", "M30SPlusVE40", "M30SPlusPlusVE40" -- no spaces,
|
||||
//! "+" rendered "Plus", "++" rendered "PlusPlus", the WhatsMiner version
|
||||
//! block ("VE40") baked in.
|
||||
//! - `control_board_version` = a bare board name ("Xilinx", "CVITek",
|
||||
//! "AMLogic", "BeagleBoneBlack"; WhatsMiner "H3"/"H6"/"H6OS"/"H616").
|
||||
//!
|
||||
//! This module turns those into the Brand / Model / Submodel / control-board
|
||||
//! short code the table shows. It is a pure string transform -- no asic-rs edit
|
||||
//! -- so it stays a build-on-top layer over the vendored crate.
|
||||
//!
|
||||
//! Known limitations (asic-rs does not expose the data):
|
||||
//! - Antminer has no hashboard-type/submodel over the network, so Submodel is
|
||||
//! blank for Antminer (only WhatsMiner's version block is recoverable).
|
||||
//! - asic-rs reports only "AMLogic" (not the 120mm C76 vs 140mm CBE board) and
|
||||
//! only "Xilinx" (not C49 vs C55); we disambiguate by model family as a
|
||||
//! best-effort heuristic documented at `control_board_code`.
|
||||
|
||||
/// Human brand from asic-rs `device_info.make`.
|
||||
pub fn brand(make: &str) -> String {
|
||||
match make.trim().to_ascii_lowercase().as_str() {
|
||||
"antminer" => "Antminer".to_string(),
|
||||
"whatsminer" => "WhatsMiner".to_string(),
|
||||
"" => String::new(),
|
||||
other => {
|
||||
// Title-case an unknown make so the Brand column still reads well.
|
||||
let mut c = other.chars();
|
||||
match c.next() {
|
||||
Some(f) => f.to_ascii_uppercase().to_string() + c.as_str(),
|
||||
None => String::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn is_whatsminer(make: &str) -> bool {
|
||||
make.trim().eq_ignore_ascii_case("whatsminer")
|
||||
}
|
||||
|
||||
fn is_antminer(make: &str) -> bool {
|
||||
make.trim().eq_ignore_ascii_case("antminer")
|
||||
}
|
||||
|
||||
/// Split asic-rs's firmware family string into the family shown in the Firmware
|
||||
/// column and an optional vendor prefix that moves into the FW Version column
|
||||
/// (round 11 #6). asic-rs reports stock firmware as "AntMiner Stock" /
|
||||
/// "WhatsMiner Stock"; the Firmware column should read just "Stock" (so it
|
||||
/// colours as the neutral/default family), and the vendor word belongs with the
|
||||
/// version. Aftermarket families ("VNish", "Braiins", ...) carry no vendor
|
||||
/// prefix and pass through unchanged.
|
||||
pub fn firmware_family(raw: &str) -> (String, Option<String>) {
|
||||
let trimmed = raw.trim();
|
||||
// Vendor prefixes asic-rs prepends on stock-firmware family strings, matched
|
||||
// case-insensitively.
|
||||
for vendor in ["AntMiner", "WhatsMiner"] {
|
||||
if trimmed.len() > vendor.len() && trimmed[..vendor.len()].eq_ignore_ascii_case(vendor) {
|
||||
let rest = trimmed[vendor.len()..].trim();
|
||||
if !rest.is_empty() {
|
||||
return (rest.to_string(), Some(vendor.to_string()));
|
||||
}
|
||||
}
|
||||
}
|
||||
(trimmed.to_string(), None)
|
||||
}
|
||||
|
||||
/// Whether a miner is liquid-cooled (hydro / water / immersion) rather than
|
||||
/// air-cooled, inferred from the model name (round 11 #17). asic-rs exposes no
|
||||
/// cooling-type field, so this is a best-effort model-string heuristic: it
|
||||
/// decides whether a reported "fluid" temperature is a real coolant reading or
|
||||
/// (for air-cooled units) the ambient/environment temperature.
|
||||
pub fn is_liquid_cooled(model: &str) -> bool {
|
||||
let m = model.to_ascii_lowercase();
|
||||
m.contains("hydro") || m.contains("immers") || m.contains("water")
|
||||
}
|
||||
|
||||
/// The human model name for the Model column: brand dropped (it has its own
|
||||
/// column), family-letter suffix lowercased, word suffixes spaced, "+"/"++" for
|
||||
/// Plus/PlusPlus, and (WhatsMiner) the trailing version block moved to Submodel.
|
||||
pub fn clean_model(make: &str, model_id: &str) -> String {
|
||||
let id = model_id.trim();
|
||||
if id.is_empty() {
|
||||
return String::new();
|
||||
}
|
||||
if is_whatsminer(make) {
|
||||
clean_whatsminer(id).0
|
||||
} else if is_antminer(make) {
|
||||
clean_antminer(id)
|
||||
} else {
|
||||
id.to_string()
|
||||
}
|
||||
}
|
||||
|
||||
/// The Submodel column value. WhatsMiner: the version block ("VE40"). Antminer:
|
||||
/// empty -- the hashboard type is not reported over the network by asic-rs.
|
||||
pub fn submodel(make: &str, model_id: &str) -> String {
|
||||
if is_whatsminer(make) {
|
||||
clean_whatsminer(model_id.trim()).1
|
||||
} else {
|
||||
String::new()
|
||||
}
|
||||
}
|
||||
|
||||
/// Split a WhatsMiner identifier into (clean model, version submodel). The
|
||||
/// version block is the trailing run beginning at the first 'V' (WhatsMiner
|
||||
/// tiers never contain a 'V', so the first 'V' always starts the version). The
|
||||
/// prefix's Plus/PlusPlus become +/++.
|
||||
fn clean_whatsminer(id: &str) -> (String, String) {
|
||||
let (prefix, version) = match id.find('V') {
|
||||
Some(i) => (&id[..i], id[i..].to_string()),
|
||||
None => (id, String::new()),
|
||||
};
|
||||
let model = prefix.replace("PlusPlus", "++").replace("Plus", "+");
|
||||
(model, version)
|
||||
}
|
||||
|
||||
/// Known Antminer word-suffixes, longest-first so "PlusPlus" wins over "Plus"
|
||||
/// and "NoPIC" is matched whole. Each maps to its spaced display form.
|
||||
const ANT_SUFFIXES: &[(&str, &str)] = &[
|
||||
("PlusPlus", "++"),
|
||||
("Plus", "+"),
|
||||
("NoPIC", " NoPIC"),
|
||||
("Hydro", " Hydro"),
|
||||
("Pro", " Pro"),
|
||||
("XP", " XP"),
|
||||
];
|
||||
|
||||
/// Clean an Antminer identifier, e.g. "S19KPro" -> "S19k Pro", "S21eXPHydro" ->
|
||||
/// "S21e XP Hydro", "L3PlusPlus" -> "L3++". Unknown/odd inputs pass through.
|
||||
fn clean_antminer(id: &str) -> String {
|
||||
// asic-rs "Unknown" models pass the raw vendor string through with the brand
|
||||
// still in it (e.g. "ANTMINER S19 (88)", a NoPIC S19); drop a redundant
|
||||
// leading brand word so the Model column never repeats the Brand column.
|
||||
let id = if id.len() >= 9 && id[..9].eq_ignore_ascii_case("ANTMINER ") {
|
||||
id[9..].trim_start()
|
||||
} else {
|
||||
id
|
||||
};
|
||||
let bytes = id.as_bytes();
|
||||
// Base = leading letters then digits ("S19", "KS5", "L3", "Z15"). Without a
|
||||
// letter+digit base (e.g. an Unknown passthrough), return the id unchanged.
|
||||
let mut i = 0;
|
||||
while i < bytes.len() && bytes[i].is_ascii_alphabetic() {
|
||||
i += 1;
|
||||
}
|
||||
let letters_end = i;
|
||||
while i < bytes.len() && bytes[i].is_ascii_digit() {
|
||||
i += 1;
|
||||
}
|
||||
if letters_end == 0 || i == letters_end {
|
||||
return id.to_string();
|
||||
}
|
||||
let mut out = String::from(&id[..i]);
|
||||
let mut rest = &id[i..];
|
||||
|
||||
// An optional single family letter directly after the digits (j/i/a/e/K/L),
|
||||
// recognised as "not the start of a known suffix". Lowercase it, keep it
|
||||
// attached to the base (no space): "S19K" -> "S19k".
|
||||
if let Some(first) = rest.chars().next() {
|
||||
let starts_suffix = ANT_SUFFIXES.iter().any(|(s, _)| rest.starts_with(s));
|
||||
if first.is_ascii_alphabetic() && !starts_suffix {
|
||||
out.push(first.to_ascii_lowercase());
|
||||
rest = &rest[first.len_utf8()..];
|
||||
}
|
||||
}
|
||||
|
||||
// Remaining suffix words, matched greedily against the known set.
|
||||
while !rest.is_empty() {
|
||||
match ANT_SUFFIXES.iter().find(|(s, _)| rest.starts_with(s)) {
|
||||
Some((s, disp)) => {
|
||||
out.push_str(disp);
|
||||
rest = &rest[s.len()..];
|
||||
}
|
||||
None => {
|
||||
// Unknown trailing token: emit it space-separated and stop.
|
||||
out.push(' ');
|
||||
out.push_str(rest.trim_start());
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Normalise a raw control-board name for matching: drop spaces/punctuation and
|
||||
/// uppercase, so "BeagleBone Black", "BeagleBoneBlack" and "BBB" all collapse.
|
||||
fn compact_upper(s: &str) -> String {
|
||||
s.chars().filter(|c| c.is_ascii_alphanumeric()).flat_map(|c| c.to_uppercase()).collect()
|
||||
}
|
||||
|
||||
/// The control-board short code for the Control-board column, e.g.
|
||||
/// "BeagleBoneBlack" -> "BBB (C77)", "Xilinx" on an S17 -> "XIL (C49)".
|
||||
///
|
||||
/// asic-rs reports only the board FAMILY ("AMLogic"/"Xilinx"), never the exact
|
||||
/// Bitmain board number, so where a family spans two boards we disambiguate by
|
||||
/// model era/class (best-effort, since the network data can't distinguish them):
|
||||
/// - Xilinx: S17/T17-era -> C49, otherwise (S19-era) -> C55.
|
||||
/// - AMLogic: XP-class / S19k (140mm fans) -> CBE, otherwise (120mm) -> C76.
|
||||
/// `clean_model` is the already-cleaned model name (used for the era/class test).
|
||||
pub fn control_board_code(make: &str, board_name: &str, clean_model: &str) -> String {
|
||||
let (cpu, code) = control_board_split(make, board_name, clean_model);
|
||||
if code.is_empty() {
|
||||
cpu
|
||||
} else {
|
||||
format!("{cpu} ({code})")
|
||||
}
|
||||
}
|
||||
|
||||
/// The control-board CPU family short code alone ("AML", "CVI", "BBB", "XIL",
|
||||
/// WhatsMiner "H3"/"H6"/"H6os"/"H616", or the raw name if unrecognised).
|
||||
pub fn control_board_cpu(make: &str, board_name: &str, clean_model: &str) -> String {
|
||||
control_board_split(make, board_name, clean_model).0
|
||||
}
|
||||
|
||||
/// The Bitmain board code alone ("C77"/"C88"/"C49"/"C55"/"C76"/"CBE";
|
||||
/// WhatsMiner "CB2"/"CB4"/"CB6"), or "" when unknown.
|
||||
pub fn control_board_board(make: &str, board_name: &str, clean_model: &str) -> String {
|
||||
control_board_split(make, board_name, clean_model).1
|
||||
}
|
||||
|
||||
/// Split a raw control-board name into (CPU family short code, Bitmain board
|
||||
/// code). asic-rs reports only the board FAMILY ("AMLogic"/"Xilinx"), never the
|
||||
/// exact board number, so where a family spans two boards we disambiguate by
|
||||
/// model era/class (best-effort):
|
||||
/// - Xilinx: S17/T17-era -> C49, otherwise (S19-era) -> C55.
|
||||
/// - AMLogic: XP-class / S19k / S21 (140mm fans) -> CBE, otherwise 120mm C76.
|
||||
fn control_board_split(make: &str, board_name: &str, clean_model: &str) -> (String, String) {
|
||||
let raw = board_name.trim();
|
||||
if raw.is_empty() {
|
||||
return (String::new(), String::new());
|
||||
}
|
||||
// asic-rs renders an unrecognised board as "Unknown: <raw>"; surface it in
|
||||
// the CPU part with no code.
|
||||
if raw.starts_with("Unknown") {
|
||||
return (raw.to_string(), String::new());
|
||||
}
|
||||
let key = compact_upper(raw);
|
||||
let pair = |cpu: &str, code: &str| (cpu.to_string(), code.to_string());
|
||||
|
||||
if is_whatsminer(make) {
|
||||
return match key.as_str() {
|
||||
"H3" => pair("H3", "CB2"),
|
||||
"H6" => pair("H6", "CB4"),
|
||||
"H6OS" => pair("H6os", "CB4"),
|
||||
"H616" => pair("H616", "CB6"),
|
||||
_ => (raw.to_string(), String::new()),
|
||||
};
|
||||
}
|
||||
|
||||
// Antminer (and any make that reports these families).
|
||||
match key.as_str() {
|
||||
"BEAGLEBONEBLACK" | "BBB" | "BB" | "BEAGLEBONE" => pair("BBB", "C77"),
|
||||
"CVITEK" | "CVI" => pair("CVI", "C88"),
|
||||
"XILINX" | "XIL" => {
|
||||
if is_s17_era(clean_model) {
|
||||
pair("XIL", "C49")
|
||||
} else {
|
||||
pair("XIL", "C55")
|
||||
}
|
||||
}
|
||||
"AMLOGIC" | "AML" => {
|
||||
if is_aml_140mm(clean_model) {
|
||||
pair("AML", "CBE")
|
||||
} else {
|
||||
pair("AML", "C76")
|
||||
}
|
||||
}
|
||||
_ => (raw.to_string(), String::new()),
|
||||
}
|
||||
}
|
||||
|
||||
/// S17/T17-era models use the Xilinx C49 control board.
|
||||
fn is_s17_era(clean_model: &str) -> bool {
|
||||
let m = clean_model.trim_start();
|
||||
m.starts_with("S17") || m.starts_with("T17")
|
||||
}
|
||||
|
||||
/// Best-effort: the 140mm-fan AMLogic board (CBE) is used on the XP-class, the
|
||||
/// S19k Pro, and the S21 Pro; everything else AMLogic is the 120mm C76. asic-rs
|
||||
/// cannot tell these apart, so this is a model-family heuristic, not a read.
|
||||
fn is_aml_140mm(clean_model: &str) -> bool {
|
||||
let m = clean_model.trim_start();
|
||||
m.contains("XP") || m.starts_with("S19k") || m.starts_with("S21")
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn brand_normalises_case() {
|
||||
assert_eq!(brand("Antminer"), "Antminer");
|
||||
assert_eq!(brand("Whatsminer"), "WhatsMiner");
|
||||
assert_eq!(brand("whatsminer"), "WhatsMiner");
|
||||
assert_eq!(brand(""), "");
|
||||
assert_eq!(brand("avalonminer"), "Avalonminer");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn antminer_model_cleanup() {
|
||||
// The headline example from the spec.
|
||||
assert_eq!(clean_model("Antminer", "S19KPro"), "S19k Pro");
|
||||
assert_eq!(clean_model("Antminer", "S19jPro"), "S19j Pro");
|
||||
assert_eq!(clean_model("Antminer", "S21Pro"), "S21 Pro");
|
||||
assert_eq!(clean_model("Antminer", "S19"), "S19");
|
||||
assert_eq!(clean_model("Antminer", "S19XP"), "S19 XP");
|
||||
assert_eq!(clean_model("Antminer", "S19jXP"), "S19j XP");
|
||||
assert_eq!(clean_model("Antminer", "S19Plus"), "S19+");
|
||||
assert_eq!(clean_model("Antminer", "S19ProPlus"), "S19 Pro+");
|
||||
assert_eq!(clean_model("Antminer", "S19jProPlus"), "S19j Pro+");
|
||||
assert_eq!(clean_model("Antminer", "S19ProPlusHydro"), "S19 Pro+ Hydro");
|
||||
assert_eq!(clean_model("Antminer", "S19jNoPIC"), "S19j NoPIC");
|
||||
assert_eq!(clean_model("Antminer", "S21PlusPlus"), "S21++");
|
||||
assert_eq!(clean_model("Antminer", "S21eXPHydro"), "S21e XP Hydro");
|
||||
assert_eq!(clean_model("Antminer", "L3PlusPlus"), "L3++");
|
||||
assert_eq!(clean_model("Antminer", "KS5Pro"), "KS5 Pro");
|
||||
assert_eq!(clean_model("Antminer", "Z15Pro"), "Z15 Pro");
|
||||
assert_eq!(clean_model("Antminer", "S9i"), "S9i");
|
||||
assert_eq!(clean_model("Antminer", "S17e"), "S17e");
|
||||
assert_eq!(clean_model("Antminer", "S19a"), "S19a");
|
||||
assert_eq!(clean_model("Antminer", "S19aPro"), "S19a Pro");
|
||||
// asic-rs Unknown passthrough carrying the raw vendor string (a NoPIC
|
||||
// S19 seen live at 10.4.x): drop the redundant brand, keep the rest.
|
||||
assert_eq!(clean_model("Antminer", "ANTMINER S19 (88)"), "S19 (88)");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn whatsminer_model_and_submodel() {
|
||||
assert_eq!(clean_model("Whatsminer", "M30SPlusVE40"), "M30S+");
|
||||
assert_eq!(submodel("Whatsminer", "M30SPlusVE40"), "VE40");
|
||||
assert_eq!(clean_model("Whatsminer", "M30SPlusPlusVE40"), "M30S++");
|
||||
assert_eq!(submodel("Whatsminer", "M30SPlusPlusVE40"), "VE40");
|
||||
assert_eq!(clean_model("Whatsminer", "M30SVE40"), "M30S");
|
||||
assert_eq!(submodel("Whatsminer", "M30SVE40"), "VE40");
|
||||
assert_eq!(clean_model("Whatsminer", "M20S"), "M20S");
|
||||
assert_eq!(submodel("Whatsminer", "M20S"), "");
|
||||
assert_eq!(clean_model("Whatsminer", "M50S++VK30"), "M50S++");
|
||||
assert_eq!(submodel("Whatsminer", "M50S++VK30"), "VK30");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn antminer_has_no_submodel() {
|
||||
assert_eq!(submodel("Antminer", "S19KPro"), "");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn control_board_short_codes() {
|
||||
// Antminer families (board name as asic-rs renders the enum variant).
|
||||
assert_eq!(control_board_code("Antminer", "BeagleBoneBlack", "S19"), "BBB (C77)");
|
||||
// Also accept the spaced form some layers produce.
|
||||
assert_eq!(control_board_code("Antminer", "BeagleBone Black", "S19"), "BBB (C77)");
|
||||
assert_eq!(control_board_code("Antminer", "CVITek", "S21 Pro"), "CVI (C88)");
|
||||
assert_eq!(control_board_code("Antminer", "Xilinx", "S17 Pro"), "XIL (C49)");
|
||||
assert_eq!(control_board_code("Antminer", "Xilinx", "T17"), "XIL (C49)");
|
||||
assert_eq!(control_board_code("Antminer", "Xilinx", "S19 Pro"), "XIL (C55)");
|
||||
assert_eq!(control_board_code("Antminer", "AMLogic", "S19j Pro"), "AML (C76)");
|
||||
assert_eq!(control_board_code("Antminer", "AMLogic", "S19k Pro"), "AML (CBE)");
|
||||
assert_eq!(control_board_code("Antminer", "AMLogic", "S19 XP"), "AML (CBE)");
|
||||
// WhatsMiner families.
|
||||
assert_eq!(control_board_code("Whatsminer", "H3", "M30S"), "H3 (CB2)");
|
||||
assert_eq!(control_board_code("Whatsminer", "H6", "M50"), "H6 (CB4)");
|
||||
assert_eq!(control_board_code("Whatsminer", "H6OS", "M50"), "H6os (CB4)");
|
||||
assert_eq!(control_board_code("Whatsminer", "H616", "M30S+"), "H616 (CB6)");
|
||||
// Unknown / blank pass through.
|
||||
assert_eq!(control_board_code("Antminer", "Unknown: FOO", "S19"), "Unknown: FOO");
|
||||
assert_eq!(control_board_code("Antminer", "", "S19"), "");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn control_board_cpu_and_board_split() {
|
||||
// CPU column vs board-code column.
|
||||
assert_eq!(control_board_cpu("Antminer", "AMLogic", "S19j Pro"), "AML");
|
||||
assert_eq!(control_board_board("Antminer", "AMLogic", "S19j Pro"), "C76");
|
||||
assert_eq!(control_board_cpu("Antminer", "CVITek", "S21 Pro"), "CVI");
|
||||
assert_eq!(control_board_board("Antminer", "CVITek", "S21 Pro"), "C88");
|
||||
assert_eq!(control_board_cpu("Whatsminer", "H616", "M30S+"), "H616");
|
||||
assert_eq!(control_board_board("Whatsminer", "H616", "M30S+"), "CB6");
|
||||
// S21 Pro on an AMLogic board is the 140mm CBE, not C76.
|
||||
assert_eq!(control_board_board("Antminer", "AMLogic", "S21 Pro"), "CBE");
|
||||
assert_eq!(control_board_code("Antminer", "AMLogic", "S21 Pro"), "AML (CBE)");
|
||||
// Unknown -> cpu holds the raw string, no board code.
|
||||
assert_eq!(control_board_cpu("Antminer", "Unknown: FOO", "S19"), "Unknown: FOO");
|
||||
assert_eq!(control_board_board("Antminer", "Unknown: FOO", "S19"), "");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn firmware_family_splits_vendor_prefix() {
|
||||
// Stock firmware: vendor word moves out of the family word (round 11 #6).
|
||||
assert_eq!(firmware_family("AntMiner Stock"), ("Stock".to_string(), Some("AntMiner".to_string())));
|
||||
assert_eq!(
|
||||
firmware_family("WhatsMiner Stock"),
|
||||
("Stock".to_string(), Some("WhatsMiner".to_string()))
|
||||
);
|
||||
// Aftermarket families pass through with no vendor prefix.
|
||||
assert_eq!(firmware_family("VNish"), ("VNish".to_string(), None));
|
||||
assert_eq!(firmware_family("Braiins"), ("Braiins".to_string(), None));
|
||||
// A bare vendor word with nothing after it is left as-is (not emptied).
|
||||
assert_eq!(firmware_family("AntMiner"), ("AntMiner".to_string(), None));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn liquid_cooling_detection() {
|
||||
assert!(is_liquid_cooled("S21 XP Hydro"));
|
||||
assert!(is_liquid_cooled("Antminer S19 Hydro"));
|
||||
assert!(is_liquid_cooled("M53 immersion"));
|
||||
assert!(!is_liquid_cooled("S21 Pro"));
|
||||
assert!(!is_liquid_cooled("M30S++"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,223 @@
|
||||
//! Real PIC-vs-noPIC detection for Antminer control boards, over SSH + i2c-tools.
|
||||
//!
|
||||
//! asic-rs and the miner's network API cannot report PIC presence (see the
|
||||
//! project wiki, 30-power-thermal-and-board-identity/hashboard-eeprom-pic.md);
|
||||
//! the authoritative tell lives on the control board's I2C bus. On a
|
||||
//! PIC/MCU-equipped board, I2C 0x48 is a hashboard MCU exposing an 8-byte
|
||||
//! register file that WRAPS every 8 bytes (e.g. `17 00 4b 50 7f 00 00 00 ...`);
|
||||
//! on a noPIC board, 0x48 is a plain LM75 temperature sensor with a 4-register
|
||||
//! layout that wraps every 4 bytes. We read 0x48 with `i2cdump` over SSH and
|
||||
//! discriminate by that period.
|
||||
//!
|
||||
//! This is a slow, credentialed, opt-in probe (an SSH handshake + shell command
|
||||
//! per miner), never part of the fast network scan. We shell out to `ssh`
|
||||
//! (via `sshpass` for password auth) rather than pull in an SSH crate, so the
|
||||
//! offline/vendored build is unaffected.
|
||||
|
||||
use std::process::Command;
|
||||
use std::time::Duration;
|
||||
|
||||
/// SSH login for the miner's control board (distinct from the web/API creds).
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct SshCreds {
|
||||
pub user: String,
|
||||
/// Empty means key-based auth (BatchMode); otherwise `sshpass` is used.
|
||||
pub pass: String,
|
||||
}
|
||||
|
||||
/// Which I2C bus to probe, chosen from the control-board family. AMLogic uses
|
||||
/// i2c-1, BeagleBone uses i2c-0; for anything else (Xilinx/CVITek/unknown) we
|
||||
/// try both. The wiki confirms the AML/BB buses; Zynx/CVITek are unconfirmed.
|
||||
pub fn bus_candidates(control_board: &str) -> Vec<u8> {
|
||||
let cb = control_board.to_lowercase();
|
||||
if cb.contains("amlogic") || cb.contains("aml") {
|
||||
vec![1]
|
||||
} else if cb.contains("beaglebone") || cb.contains("bb") {
|
||||
vec![0]
|
||||
} else {
|
||||
vec![1, 0]
|
||||
}
|
||||
}
|
||||
|
||||
/// Classify an `i2cdump -y <bus> 0x48 b` dump: `Some(true)` = PIC (8-byte MCU
|
||||
/// register file), `Some(false)` = noPIC (4-register LM75), `None` = couldn't
|
||||
/// tell (address unresponsive, no periodicity, or unparseable). Conservative:
|
||||
/// anything ambiguous is `None`, never a guess.
|
||||
pub fn classify_i2cdump(stdout: &str) -> Option<bool> {
|
||||
let bytes = parse_dump_offset0(stdout)?;
|
||||
// An LM75's 4 registers repeat every 4 bytes; check that first because a
|
||||
// period-4 sequence is trivially also period-8.
|
||||
let period4 = (0..12).all(|i| bytes[i] == bytes[i + 4]);
|
||||
if period4 {
|
||||
return Some(false); // LM75 -> noPIC
|
||||
}
|
||||
let period8 = (0..8).all(|i| bytes[i] == bytes[i + 8]);
|
||||
if period8 {
|
||||
return Some(true); // 8-byte MCU register file -> PIC
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Parse the 16 bytes of the `00:` row of an `i2cdump ... b` output. Returns
|
||||
/// `None` if the row is missing or any cell is unreadable ("XX").
|
||||
fn parse_dump_offset0(stdout: &str) -> Option<[u8; 16]> {
|
||||
let line = stdout.lines().find_map(|l| {
|
||||
let l = l.trim();
|
||||
l.strip_prefix("00:").map(str::trim_start)
|
||||
})?;
|
||||
// The row is "<16 hex/XX cells> <ascii gutter>"; take the first 16 cells.
|
||||
let mut out = [0u8; 16];
|
||||
let mut n = 0;
|
||||
for tok in line.split_whitespace() {
|
||||
if n == 16 {
|
||||
break;
|
||||
}
|
||||
if tok.len() != 2 {
|
||||
break; // reached the ascii gutter
|
||||
}
|
||||
match u8::from_str_radix(tok, 16) {
|
||||
Ok(b) => {
|
||||
out[n] = b;
|
||||
n += 1;
|
||||
}
|
||||
Err(_) => return None, // "XX" = no response -> indeterminate
|
||||
}
|
||||
}
|
||||
(n == 16).then_some(out)
|
||||
}
|
||||
|
||||
/// Build the ssh argv for one `i2cdump` on `bus`. Uses `sshpass -p <pass>` when
|
||||
/// a password is set, else relies on key auth (BatchMode).
|
||||
fn ssh_command(ip: &str, bus: u8, creds: &SshCreds) -> Command {
|
||||
let remote = format!("i2cdump -y {bus} 0x48 b");
|
||||
let target = format!("{}@{ip}", creds.user);
|
||||
let ssh_opts = [
|
||||
"-o", "StrictHostKeyChecking=no",
|
||||
"-o", "UserKnownHostsFile=/dev/null",
|
||||
"-o", "ConnectTimeout=6",
|
||||
"-o", "NumberOfPasswordPrompts=1",
|
||||
];
|
||||
if creds.pass.is_empty() {
|
||||
let mut c = Command::new("ssh");
|
||||
c.arg("-o").arg("BatchMode=yes");
|
||||
c.args(ssh_opts).arg(&target).arg(&remote);
|
||||
c
|
||||
} else {
|
||||
// sshpass reads the password from the env var named after -e's default,
|
||||
// but we use -p for simplicity; the password never reaches the argv of
|
||||
// a child that logs it (sshpass scrubs its own argv).
|
||||
let mut c = Command::new("sshpass");
|
||||
c.arg("-p").arg(&creds.pass).arg("ssh");
|
||||
c.args(ssh_opts).arg(&target).arg(&remote);
|
||||
c
|
||||
}
|
||||
}
|
||||
|
||||
/// Probe one miner's PIC state over SSH. Returns `Ok(Some(true/false))` on a
|
||||
/// confident PIC/noPIC read, `Ok(None)` if reachable but indeterminate, or
|
||||
/// `Err` on an SSH/connection/auth failure.
|
||||
pub fn probe_pic(ip: &str, control_board: &str, creds: &SshCreds) -> Result<Option<bool>, String> {
|
||||
let mut last_err = String::from("no i2c bus responded");
|
||||
for bus in bus_candidates(control_board) {
|
||||
match run_probe(ip, bus, creds) {
|
||||
Ok(Some(v)) => return Ok(Some(v)),
|
||||
Ok(None) => last_err = format!("i2c-0x48 on bus {bus} was indeterminate"),
|
||||
Err(e) => return Err(e), // an auth/connection error won't improve on another bus
|
||||
}
|
||||
}
|
||||
// Reachable but couldn't classify on any candidate bus.
|
||||
let _ = last_err;
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
fn run_probe(ip: &str, bus: u8, creds: &SshCreds) -> Result<Option<bool>, String> {
|
||||
let out = wait_with_timeout(ssh_command(ip, bus, creds), Duration::from_secs(12))?;
|
||||
if !out.status.success() {
|
||||
let err = String::from_utf8_lossy(&out.stderr);
|
||||
// A failed i2cdump on this bus (e.g. bus doesn't exist) is not fatal --
|
||||
// let the caller try the next bus. But an SSH/auth failure is fatal.
|
||||
let e = err.trim().to_string();
|
||||
if e.to_lowercase().contains("permission denied")
|
||||
|| e.to_lowercase().contains("connection")
|
||||
|| e.to_lowercase().contains("timed out")
|
||||
|| e.to_lowercase().contains("no route")
|
||||
|| e.to_lowercase().contains("host key")
|
||||
{
|
||||
return Err(if e.is_empty() { "ssh failed".into() } else { e });
|
||||
}
|
||||
return Ok(None);
|
||||
}
|
||||
Ok(classify_i2cdump(&String::from_utf8_lossy(&out.stdout)))
|
||||
}
|
||||
|
||||
/// Run a command with a wall-clock timeout (SSH can hang on a dead host).
|
||||
fn wait_with_timeout(mut cmd: Command, timeout: Duration) -> Result<std::process::Output, String> {
|
||||
use std::io::Read;
|
||||
cmd.stdout(std::process::Stdio::piped()).stderr(std::process::Stdio::piped());
|
||||
let mut child = cmd.spawn().map_err(|e| format!("spawn ssh: {e}"))?;
|
||||
let start = std::time::Instant::now();
|
||||
loop {
|
||||
match child.try_wait().map_err(|e| e.to_string())? {
|
||||
Some(status) => {
|
||||
let mut stdout = Vec::new();
|
||||
let mut stderr = Vec::new();
|
||||
if let Some(mut o) = child.stdout.take() {
|
||||
let _ = o.read_to_end(&mut stdout);
|
||||
}
|
||||
if let Some(mut e) = child.stderr.take() {
|
||||
let _ = e.read_to_end(&mut stderr);
|
||||
}
|
||||
return Ok(std::process::Output { status, stdout, stderr });
|
||||
}
|
||||
None => {
|
||||
if start.elapsed() >= timeout {
|
||||
let _ = child.kill();
|
||||
return Err("ssh timed out".into());
|
||||
}
|
||||
std::thread::sleep(Duration::from_millis(100));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn classify_pic_from_wiki_dump() {
|
||||
// The wiki's PIC/MCU board dump: 8-byte register file that wraps.
|
||||
let dump = "\
|
||||
0 1 2 3 4 5 6 7 8 9 a b c d e f 0123456789abcdef
|
||||
00: 17 00 4b 50 7f 00 00 00 17 00 4b 50 7f 00 00 00 ................
|
||||
10: 17 00 4b 50 7f 00 00 00 17 00 4b 50 7f 00 00 00 ................";
|
||||
assert_eq!(classify_i2cdump(dump), Some(true), "8-byte wrap -> PIC");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn classify_nopic_from_lm75() {
|
||||
// An LM75 has 4 registers (temp/config/Thyst/Tos) that wrap every 4.
|
||||
let dump = "\
|
||||
0 1 2 3 4 5 6 7 8 9 a b c d e f 0123456789abcdef
|
||||
00: 19 00 4b 50 19 00 4b 50 19 00 4b 50 19 00 4b 50 ................";
|
||||
assert_eq!(classify_i2cdump(dump), Some(false), "4-register LM75 -> noPIC");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn classify_indeterminate() {
|
||||
// No response (XX) or no periodicity -> None (never a guess).
|
||||
let xx = "00: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX";
|
||||
assert_eq!(classify_i2cdump(xx), None);
|
||||
let noisy = "00: 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10";
|
||||
assert_eq!(classify_i2cdump(noisy), None);
|
||||
assert_eq!(classify_i2cdump("no offset row here"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bus_from_control_board() {
|
||||
assert_eq!(bus_candidates("AMLogic"), vec![1]);
|
||||
assert_eq!(bus_candidates("BeagleBone Black"), vec![0]);
|
||||
assert_eq!(bus_candidates("Xilinx"), vec![1, 0]);
|
||||
assert_eq!(bus_candidates(""), vec![1, 0]);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,153 @@
|
||||
//! Saved view presets: named snapshots of the table's column arrangement,
|
||||
//! visibility, sort, and filters. Persisted as JSON in the config dir. The
|
||||
//! first preset is always a built-in "Default" profile.
|
||||
|
||||
use std::collections::{HashMap, HashSet};
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::model::{ColFilter, Column, ViewState, ALL_COLUMNS};
|
||||
use crate::scan::config_path;
|
||||
|
||||
pub const PRESETS_FILE: &str = "presets.json";
|
||||
|
||||
/// The built-in default profile's visible columns, in display order (Ip first):
|
||||
/// IP, model, errors, hashrate, power, chip temp, firmware, CPU, boards
|
||||
/// (hashboard health), access.
|
||||
const DEFAULT_PROFILE: [Column; 10] = [
|
||||
Column::Ip,
|
||||
Column::Model,
|
||||
Column::Error,
|
||||
Column::Hashrate,
|
||||
Column::Power,
|
||||
Column::ChipTemp,
|
||||
Column::Firmware,
|
||||
Column::Cpu,
|
||||
Column::Hashboards,
|
||||
Column::Locked,
|
||||
];
|
||||
|
||||
/// A serializable snapshot of a `ViewState` (Vec-based so JSON has no map keys
|
||||
/// that are enums, and column order within `visible` is preserved).
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct PresetView {
|
||||
pub order: Vec<Column>,
|
||||
pub visible: Vec<Column>,
|
||||
pub sort: Option<(Column, bool)>,
|
||||
pub filters: Vec<(Column, ColFilter)>,
|
||||
}
|
||||
|
||||
impl PresetView {
|
||||
pub fn from_view(v: &ViewState) -> PresetView {
|
||||
PresetView {
|
||||
order: v.order.clone(),
|
||||
// keep the visible columns in display order for stability
|
||||
visible: v.order.iter().copied().filter(|c| v.visible.contains(c)).collect(),
|
||||
sort: v.sort,
|
||||
filters: v.filters.iter().map(|(k, f)| (*k, f.clone())).collect(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Rebuild a `ViewState` from this snapshot. Any column missing from a
|
||||
/// loaded (possibly older) preset is appended to `order` and left hidden, so
|
||||
/// the result always covers every `Column`.
|
||||
pub fn to_view(&self) -> ViewState {
|
||||
let mut order = self.order.clone();
|
||||
for c in ALL_COLUMNS {
|
||||
if !order.contains(&c) {
|
||||
order.push(c);
|
||||
}
|
||||
}
|
||||
let mut visible: HashSet<Column> = self.visible.iter().copied().collect();
|
||||
visible.insert(Column::Ip); // IP is always shown
|
||||
let filters: HashMap<Column, ColFilter> = self.filters.iter().cloned().collect();
|
||||
ViewState { order, visible, sort: self.sort, filters }
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct Preset {
|
||||
pub name: String,
|
||||
pub view: PresetView,
|
||||
}
|
||||
|
||||
/// The built-in default profile (always present as the first preset).
|
||||
pub fn default_preset() -> Preset {
|
||||
let mut order: Vec<Column> = DEFAULT_PROFILE.to_vec();
|
||||
for c in ALL_COLUMNS {
|
||||
if !order.contains(&c) {
|
||||
order.push(c);
|
||||
}
|
||||
}
|
||||
Preset {
|
||||
name: "Default".to_string(),
|
||||
view: PresetView {
|
||||
order,
|
||||
visible: DEFAULT_PROFILE.to_vec(),
|
||||
sort: None,
|
||||
filters: Vec::new(),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
/// Load saved presets, always with the built-in "Default" first. A missing or
|
||||
/// unreadable file yields just the default.
|
||||
pub fn load_presets() -> Vec<Preset> {
|
||||
let mut presets = std::fs::read_to_string(config_path(PRESETS_FILE))
|
||||
.ok()
|
||||
.and_then(|s| serde_json::from_str::<Vec<Preset>>(&s).ok())
|
||||
.unwrap_or_default();
|
||||
// The default profile is always present and always first.
|
||||
presets.retain(|p| p.name != "Default");
|
||||
presets.insert(0, default_preset());
|
||||
presets
|
||||
}
|
||||
|
||||
/// Persist presets (the built-in "Default" is not written; it is re-seeded on
|
||||
/// load). Best-effort: errors are returned for the caller to surface.
|
||||
pub fn save_presets(presets: &[Preset]) -> std::io::Result<()> {
|
||||
let p = config_path(PRESETS_FILE);
|
||||
if let Some(dir) = p.parent() {
|
||||
std::fs::create_dir_all(dir)?;
|
||||
}
|
||||
let user: Vec<&Preset> = presets.iter().filter(|p| p.name != "Default").collect();
|
||||
let json = serde_json::to_string_pretty(&user)
|
||||
.map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?;
|
||||
std::fs::write(p, json)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn default_preset_round_trips_through_view() {
|
||||
let p = default_preset();
|
||||
let view = p.view.to_view();
|
||||
// IP first + the requested default columns visible.
|
||||
assert!(view.visible.contains(&Column::Ip));
|
||||
assert!(view.visible.contains(&Column::Model));
|
||||
assert!(view.visible.contains(&Column::Error));
|
||||
assert!(view.visible.contains(&Column::Cpu));
|
||||
assert!(view.visible.contains(&Column::Hashboards));
|
||||
assert!(view.visible.contains(&Column::Locked));
|
||||
// Columns dropped from the default profile in round 11.
|
||||
assert!(!view.visible.contains(&Column::BoardCode), "not in the default profile");
|
||||
assert!(!view.visible.contains(&Column::Cooling), "not in the default profile");
|
||||
// to_view covers every column in `order`.
|
||||
assert_eq!(view.order.len(), ALL_COLUMNS.len());
|
||||
// Round-trip a snapshot back out.
|
||||
let snap = PresetView::from_view(&view);
|
||||
assert_eq!(snap.visible.first(), Some(&Column::Ip));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn preset_json_round_trip() {
|
||||
let p = default_preset();
|
||||
let json = serde_json::to_string(&vec![&p]).unwrap();
|
||||
let back: Vec<Preset> = serde_json::from_str(&json).unwrap();
|
||||
assert_eq!(back.len(), 1);
|
||||
assert_eq!(back[0].name, "Default");
|
||||
assert_eq!(back[0].view.visible, DEFAULT_PROFILE.to_vec());
|
||||
}
|
||||
}
|
||||
+384
-46
@@ -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,40 @@ pub fn start_scan(lines: Vec<String>) -> ScanHandle {
|
||||
ScanHandle { rx, cancel }
|
||||
}
|
||||
|
||||
/// Flatten a miner's structured messages into concise display lines for the
|
||||
/// Errors column's hover tooltip (the column cell itself shows only the count).
|
||||
/// Only actionable messages (Error + Warning) are kept -- Info is dropped as
|
||||
/// noise. Each line is just "message (component)" (no repetitive "[Error]"
|
||||
/// prefix), duplicates are collapsed, and errors sort before warnings.
|
||||
fn summarize_messages(messages: &[asic_rs::core::data::message::MinerMessage]) -> Vec<String> {
|
||||
use asic_rs::core::data::message::MessageSeverity;
|
||||
let mut ranked: Vec<(u8, String)> = messages
|
||||
.iter()
|
||||
.filter_map(|m| {
|
||||
let rank = match m.severity {
|
||||
MessageSeverity::Error => 0u8,
|
||||
MessageSeverity::Warning => 1,
|
||||
MessageSeverity::Info => return None, // informational, not an error/warning
|
||||
};
|
||||
let text = m.message.trim();
|
||||
if text.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let line = match m.component.as_ref().map(|c| c.to_string()) {
|
||||
Some(c) if !c.trim().is_empty() => format!("{text} ({})", c.trim()),
|
||||
_ => text.to_string(),
|
||||
};
|
||||
Some((rank, line))
|
||||
})
|
||||
.collect();
|
||||
// Stable sort keeps discovery order within a severity; errors before warnings.
|
||||
ranked.sort_by_key(|(r, _)| *r);
|
||||
// Collapse exact duplicates (asic-rs sometimes repeats the same fault per board).
|
||||
let mut seen = HashSet::new();
|
||||
ranked.retain(|(_, s)| seen.insert(s.clone()));
|
||||
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
|
||||
@@ -379,6 +449,19 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
.as_ref()
|
||||
.map(|t| t.as_celsius())
|
||||
.unwrap_or(0.0);
|
||||
// Per-hashboard chip temperature (hottest chip per board, falling back to
|
||||
// the board/PCB temp), for the "77 / 64 / 74" Chip-temp cell.
|
||||
let board_temps: Vec<f64> = data
|
||||
.hashboards
|
||||
.iter()
|
||||
.filter_map(|b| {
|
||||
b.outlet_chip_temperature
|
||||
.as_ref()
|
||||
.or(b.board_temperature.as_ref())
|
||||
.map(|t| t.as_celsius())
|
||||
})
|
||||
.filter(|&t| t > 0.0)
|
||||
.collect();
|
||||
let fan_rpms: Vec<f64> = data
|
||||
.fans
|
||||
.iter()
|
||||
@@ -413,17 +496,38 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
)
|
||||
})
|
||||
.collect();
|
||||
let firmware = match (&data.device_info.firmware, &data.firmware_version) {
|
||||
(fw, Some(v)) if !fw.is_empty() => format!("{fw} {v}"),
|
||||
(fw, Some(v)) => format!("{fw}{v}"),
|
||||
(fw, None) => fw.clone(),
|
||||
// Firmware family (coloured column) and version go in separate columns. Strip
|
||||
// the vendor word asic-rs prepends on stock firmware ("AntMiner Stock" ->
|
||||
// "Stock") and carry it into the version instead (round 11 #6).
|
||||
let (firmware, fw_vendor) = crate::naming::firmware_family(&data.device_info.firmware);
|
||||
let raw_fw_version = data.firmware_version.clone().unwrap_or_default();
|
||||
let fw_version = match (fw_vendor, raw_fw_version.is_empty()) {
|
||||
(Some(vendor), false) => format!("{vendor} {raw_fw_version}"),
|
||||
(Some(vendor), true) => vendor,
|
||||
(None, _) => raw_fw_version,
|
||||
};
|
||||
let model = if data.device_info.make.is_empty() {
|
||||
data.device_info.model.clone()
|
||||
// Split asic-rs's compact make/model identifiers into the human-facing
|
||||
// Brand / Model / Submodel the table shows (see crate::naming). asic-rs hands
|
||||
// us "Antminer"/"S19KPro"; we render brand "Antminer", model "S19k Pro".
|
||||
let make = data.device_info.make.clone();
|
||||
let model_id = data.device_info.model.clone();
|
||||
let brand = crate::naming::brand(&make);
|
||||
let model = crate::naming::clean_model(&make, &model_id);
|
||||
let submodel = crate::naming::submodel(&make, &model_id);
|
||||
let raw_board = data.control_board_version.as_ref().map(|c| c.to_string()).unwrap_or_default();
|
||||
let control_board = crate::naming::control_board_code(&make, &raw_board, &model);
|
||||
let cpu = crate::naming::control_board_cpu(&make, &raw_board, &model);
|
||||
let board_code = crate::naming::control_board_board(&make, &raw_board, &model);
|
||||
// asic-rs has no cooling-type field and reports air-cooled miners' ambient
|
||||
// reading in `fluid_temperature` (the WhatsMiner backends read the "Env
|
||||
// Temp"/"environment-temperature" key). Route it to the Env-temp column for
|
||||
// air-cooled models so it isn't mislabelled as a coolant temp (round 11 #17).
|
||||
let reported_fluid = data.fluid_temperature.as_ref().map(|t| t.as_celsius()).unwrap_or(0.0);
|
||||
let (fluid_temp_c, env_temp_c) = if crate::naming::is_liquid_cooled(&model) {
|
||||
(reported_fluid, 0.0)
|
||||
} else {
|
||||
format!("{} {}", data.device_info.make, data.device_info.model)
|
||||
(0.0, reported_fluid)
|
||||
};
|
||||
let fluid_temp_c = data.fluid_temperature.as_ref().map(|t| t.as_celsius()).unwrap_or(0.0);
|
||||
let outlet_temp_c = data
|
||||
.outlet_fluid_temperature
|
||||
.as_ref()
|
||||
@@ -434,40 +538,90 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
.iter()
|
||||
.filter_map(|f| f.rpm.as_ref().map(|r| r.as_rpm()))
|
||||
.fold(0.0f64, f64::max);
|
||||
let algorithm = data.hashrate.as_ref().map(|h| h.algo.to_string()).unwrap_or_default();
|
||||
let is_mining = data.is_mining;
|
||||
let slow = crate::model::is_slow(is_mining, hashrate_ths, expected_ths);
|
||||
let operating_state = data.operating_state.as_ref().map(|s| s.to_string()).unwrap_or_default();
|
||||
let paused = crate::model::is_paused(&operating_state, is_mining);
|
||||
// asic-rs advertises supports_set_power_limit=true unconditionally for whole
|
||||
// firmware families, VNish included -- where, per operator guidance, the
|
||||
// power-limit control should not be offered (round-9 #3). Mask it off for
|
||||
// VNish; Braiins and the rest keep asic-rs's answer.
|
||||
let power_limit = miner.supports_set_power_limit()
|
||||
&& !data.device_info.firmware.eq_ignore_ascii_case("VNish");
|
||||
// Probe what this miner supports being told to do (sync, no extra I/O).
|
||||
let caps = MinerCaps {
|
||||
fault_light: miner.supports_set_fault_light(),
|
||||
restart: miner.supports_restart(),
|
||||
pause: miner.supports_pause(),
|
||||
resume: miner.supports_resume(),
|
||||
power_limit: miner.supports_set_power_limit(),
|
||||
power_limit,
|
||||
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());
|
||||
// Per-hashboard health for the Boards status dots (round 11 #10): green =
|
||||
// present & hashing, red = present but idle/faulty, grey = expected but not
|
||||
// detected. Boards keep asic-rs's reported order (board 1 first); any boards
|
||||
// expected beyond those reported are padded as Missing.
|
||||
let mut board_status: Vec<crate::model::BoardHealth> = data
|
||||
.hashboards
|
||||
.iter()
|
||||
.map(|b| {
|
||||
let ok = match (b.active, b.working_chips) {
|
||||
(Some(a), _) => a,
|
||||
(None, Some(c)) => c > 0,
|
||||
(None, None) => true,
|
||||
};
|
||||
if ok {
|
||||
crate::model::BoardHealth::Ok
|
||||
} else {
|
||||
crate::model::BoardHealth::Fault
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
if let Some(exp) = data.expected_hashboards {
|
||||
while board_status.len() < exp as usize {
|
||||
board_status.push(crate::model::BoardHealth::Missing);
|
||||
}
|
||||
}
|
||||
let errors = summarize_messages(&data.messages);
|
||||
MinerRow {
|
||||
ip: data.ip.to_string(),
|
||||
selected: false,
|
||||
// A miner that responded to the scan is reachable.
|
||||
offline: false,
|
||||
caps,
|
||||
algorithm,
|
||||
pic_present,
|
||||
write_locked,
|
||||
errors,
|
||||
model,
|
||||
brand,
|
||||
submodel,
|
||||
mac: data.mac.map(|m| m.to_string()).unwrap_or_default(),
|
||||
hostname: data.hostname.clone().unwrap_or_default(),
|
||||
serial: data.serial_number.clone().unwrap_or_default(),
|
||||
firmware,
|
||||
fw_version,
|
||||
api_version: data.api_version.clone().unwrap_or_default(),
|
||||
control_board: data.control_board_version.as_ref().map(|c| c.to_string()).unwrap_or_default(),
|
||||
control_board,
|
||||
cpu,
|
||||
board_code,
|
||||
hashrate_ths,
|
||||
expected_ths,
|
||||
efficiency: data.efficiency.unwrap_or(0.0),
|
||||
power_w,
|
||||
tuning_percent: data.tuning_percent,
|
||||
chip_temp_c,
|
||||
board_temps,
|
||||
fluid_temp_c,
|
||||
env_temp_c,
|
||||
outlet_temp_c,
|
||||
fan_rpms,
|
||||
psu_fan_rpm,
|
||||
@@ -477,6 +631,7 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
expected_chips: data.expected_chips.map(|v| v as u32),
|
||||
hashboards: (!data.hashboards.is_empty()).then_some(data.hashboards.len() as u32),
|
||||
expected_hashboards: data.expected_hashboards.map(|v| v as u32),
|
||||
board_status,
|
||||
worker,
|
||||
pool_url,
|
||||
pools,
|
||||
@@ -507,8 +662,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(),
|
||||
@@ -831,6 +986,167 @@ pub fn start_firmware_flash_action(ips: Vec<String>, image: FirmwareImage) -> Ac
|
||||
ActionHandle { rx, cancel }
|
||||
}
|
||||
|
||||
/// Progress/results from a background SSH PIC probe of specific miners.
|
||||
pub enum PicProbeMsg {
|
||||
Started { total: usize },
|
||||
/// One miner's PIC result: `pic` = Some(true/false)/None (indeterminate),
|
||||
/// or `error` set on an SSH/connection failure.
|
||||
Result { ip: String, pic: Option<bool>, error: Option<String> },
|
||||
Done { total: usize },
|
||||
}
|
||||
|
||||
/// A running PIC probe; `stop` cancels the remaining miners.
|
||||
pub struct PicProbeHandle {
|
||||
pub rx: Receiver<PicProbeMsg>,
|
||||
cancel: Arc<AtomicBool>,
|
||||
}
|
||||
|
||||
impl PicProbeHandle {
|
||||
pub fn stop(&self) {
|
||||
self.cancel.store(true, Ordering::Relaxed);
|
||||
}
|
||||
}
|
||||
|
||||
/// Probe the PIC state of `targets` (ip + control-board string) over SSH on a
|
||||
/// background thread, one miner at a time (each is a slow SSH round trip). In
|
||||
/// fake-scan mode it reports simulated results without touching the network.
|
||||
pub fn start_pic_probe(
|
||||
targets: Vec<(String, String)>,
|
||||
creds: crate::pic_probe::SshCreds,
|
||||
) -> PicProbeHandle {
|
||||
let (tx, rx) = channel();
|
||||
let cancel = Arc::new(AtomicBool::new(false));
|
||||
let total = targets.len();
|
||||
let _ = tx.send(PicProbeMsg::Started { total });
|
||||
|
||||
if fake_scan_enabled() {
|
||||
let err_tx = tx.clone();
|
||||
let thread_cancel = cancel.clone();
|
||||
let res = std::thread::Builder::new().name("fake-pic-probe".into()).spawn(move || {
|
||||
for (ip, cb) in targets {
|
||||
if thread_cancel.load(Ordering::Relaxed) {
|
||||
break;
|
||||
}
|
||||
// Deterministic demo: Antminer S21 (CVITek) noPIC, other
|
||||
// Antminers PIC, WhatsMiner indeterminate.
|
||||
let pic = if cb.to_lowercase().contains("cvitek") {
|
||||
Some(false)
|
||||
} else if !cb.is_empty() {
|
||||
Some(true)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let _ = tx.send(PicProbeMsg::Result { ip, pic, error: None });
|
||||
}
|
||||
let _ = tx.send(PicProbeMsg::Done { total });
|
||||
});
|
||||
if res.is_err() {
|
||||
let _ = err_tx.send(PicProbeMsg::Done { total });
|
||||
}
|
||||
return PicProbeHandle { rx, cancel };
|
||||
}
|
||||
|
||||
let thread_cancel = cancel.clone();
|
||||
let err_tx = tx.clone();
|
||||
let res = std::thread::Builder::new().name("pic-probe".into()).spawn(move || {
|
||||
for (ip, cb) in targets {
|
||||
if thread_cancel.load(Ordering::Relaxed) {
|
||||
break;
|
||||
}
|
||||
let (pic, error) = match crate::pic_probe::probe_pic(&ip, &cb, &creds) {
|
||||
Ok(v) => (v, None),
|
||||
Err(e) => (None, Some(e)),
|
||||
};
|
||||
if tx.send(PicProbeMsg::Result { ip, pic, error }).is_err() {
|
||||
return; // UI gone
|
||||
}
|
||||
}
|
||||
let _ = tx.send(PicProbeMsg::Done { total });
|
||||
});
|
||||
if res.is_err() {
|
||||
let _ = err_tx.send(PicProbeMsg::Done { total });
|
||||
}
|
||||
PicProbeHandle { rx, cancel }
|
||||
}
|
||||
|
||||
/// Progress/results from a background access (lock-state) probe.
|
||||
pub enum AccessProbeMsg {
|
||||
Started { total: usize },
|
||||
/// `locked` = Some(true) locked/view-only, Some(false) unlocked/writable,
|
||||
/// None indeterminate; `error` set only when the probe couldn't run.
|
||||
Result { ip: String, locked: Option<bool>, error: Option<String> },
|
||||
Done { total: usize },
|
||||
}
|
||||
|
||||
/// A running access probe; `stop` cancels the remaining miners.
|
||||
pub struct AccessProbeHandle {
|
||||
pub rx: Receiver<AccessProbeMsg>,
|
||||
cancel: Arc<AtomicBool>,
|
||||
}
|
||||
|
||||
impl AccessProbeHandle {
|
||||
pub fn stop(&self) {
|
||||
self.cancel.store(true, Ordering::Relaxed);
|
||||
}
|
||||
}
|
||||
|
||||
/// Probe the access/lock state of `targets` (ip + firmware string) over the web
|
||||
/// API with `creds` (user, pass), on a background thread. A digest-auth GET is
|
||||
/// fast, but we still run one miner at a time with cancel-between. Fake-scan mode
|
||||
/// returns deterministic demo results.
|
||||
pub fn start_access_probe(
|
||||
targets: Vec<(String, String)>,
|
||||
creds: (String, String),
|
||||
) -> AccessProbeHandle {
|
||||
let (tx, rx) = channel();
|
||||
let cancel = Arc::new(AtomicBool::new(false));
|
||||
let total = targets.len();
|
||||
let _ = tx.send(AccessProbeMsg::Started { total });
|
||||
let (user, pass) = creds;
|
||||
|
||||
if fake_scan_enabled() {
|
||||
let err_tx = tx.clone();
|
||||
let thread_cancel = cancel.clone();
|
||||
let res = std::thread::Builder::new().name("fake-access-probe".into()).spawn(move || {
|
||||
for (ip, _fw) in targets {
|
||||
if thread_cancel.load(Ordering::Relaxed) {
|
||||
break;
|
||||
}
|
||||
// Demo: the WardenOS-dev unit (.115) is locked, others unlocked.
|
||||
let locked = Some(ip.ends_with(".115"));
|
||||
let _ = tx.send(AccessProbeMsg::Result { ip, locked, error: None });
|
||||
}
|
||||
let _ = tx.send(AccessProbeMsg::Done { total });
|
||||
});
|
||||
if res.is_err() {
|
||||
let _ = err_tx.send(AccessProbeMsg::Done { total });
|
||||
}
|
||||
return AccessProbeHandle { rx, cancel };
|
||||
}
|
||||
|
||||
let thread_cancel = cancel.clone();
|
||||
let err_tx = tx.clone();
|
||||
let res = std::thread::Builder::new().name("access-probe".into()).spawn(move || {
|
||||
for (ip, fw) in targets {
|
||||
if thread_cancel.load(Ordering::Relaxed) {
|
||||
break;
|
||||
}
|
||||
let (locked, error) = match crate::access_probe::probe_access(&ip, &fw, &user, &pass) {
|
||||
Ok(v) => (v, None),
|
||||
Err(e) => (None, Some(e)),
|
||||
};
|
||||
if tx.send(AccessProbeMsg::Result { ip, locked, error }).is_err() {
|
||||
return; // UI gone
|
||||
}
|
||||
}
|
||||
let _ = tx.send(AccessProbeMsg::Done { total });
|
||||
});
|
||||
if res.is_err() {
|
||||
let _ = err_tx.send(AccessProbeMsg::Done { total });
|
||||
}
|
||||
AccessProbeHandle { rx, cancel }
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
@@ -864,6 +1180,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();
|
||||
@@ -1080,8 +1421,8 @@ mod tests {
|
||||
let deadline = Duration::from_secs(5);
|
||||
std::env::set_var(FAKE_SCAN_ENV, "1");
|
||||
|
||||
// start_scan: every probed IP produces a Row, including a synthetic
|
||||
// unreachable host that must come back as an offline row.
|
||||
// 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();
|
||||
@@ -1096,13 +1437,10 @@ mod tests {
|
||||
Err(RecvTimeoutError::Disconnected) => break,
|
||||
}
|
||||
}
|
||||
assert_eq!(rows.len(), total, "one Row per probed target, incl. the offline host");
|
||||
let offline = rows
|
||||
.iter()
|
||||
.find(|r| r.ip == "10.255.1.254")
|
||||
.expect("synthetic offline row must be emitted");
|
||||
assert!(offline.offline);
|
||||
assert_eq!(offline.status(), "offline");
|
||||
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
|
||||
|
||||
+1082
-136
File diff suppressed because it is too large
Load Diff
@@ -20,7 +20,15 @@ vendor/ cargo-managed crate sources ONLY (regenerated by
|
||||
`cargo vendor vendor`; it deletes unmanaged dirs - never
|
||||
put hand-made trees here; learned the hard way)
|
||||
thirdparty/
|
||||
asic-rs lives in vendor/ (pure crates.io dep, cargo-vendored)
|
||||
asic-rs the vendored crates live in vendor/ (crates.io dep,
|
||||
VERSION cargo-vendored); this dir holds their patch queue:
|
||||
patches/ 0001 whatsminer set_power_limit error propagation (#4)
|
||||
refresh-checksums.py rewrites a vendored crate's .cargo-checksum.json
|
||||
after a patch (cargo verifies each file's SHA256)
|
||||
The committed vendor/ tree has the patches applied and the
|
||||
affected .cargo-checksum.json refreshed, so builds need
|
||||
nothing extra. On re-vendor, run
|
||||
scripts/apply-asic-rs-patches.sh to re-apply + refresh.
|
||||
wxwidgets/
|
||||
wxWidgets-3.3.3/ pristine release tree, never edited directly
|
||||
VERSION upstream version + tarball URL + sha256
|
||||
|
||||
@@ -0,0 +1,33 @@
|
||||
#!/bin/bash
|
||||
# Re-apply the asic-rs patch queue to the cargo-vendored tree and refresh the
|
||||
# affected crates' .cargo-checksum.json. Run this after `cargo vendor vendor`
|
||||
# (which regenerates a pristine vendor/ and drops our edits). A normal build
|
||||
# does NOT need this -- the committed vendor/ tree already has the patches
|
||||
# applied and checksums refreshed; this is the re-vendoring recipe (ADR 0003).
|
||||
set -euo pipefail
|
||||
REPO=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
|
||||
cd "$REPO"
|
||||
|
||||
PATCHES_DIR="thirdparty/asic-rs/patches"
|
||||
shopt -s nullglob
|
||||
patches=("$PATCHES_DIR"/*.patch)
|
||||
if [ ${#patches[@]} -eq 0 ]; then
|
||||
echo "no patches in $PATCHES_DIR"
|
||||
exit 0
|
||||
fi
|
||||
|
||||
for p in "${patches[@]}"; do
|
||||
echo "== applying $p =="
|
||||
if git apply --check -p1 "$p" 2>/dev/null; then
|
||||
git apply -p1 "$p"
|
||||
elif git apply --check -p1 --reverse "$p" 2>/dev/null; then
|
||||
echo " (already applied -- skipping)"
|
||||
else
|
||||
echo "ERROR: $p does not apply cleanly; resolve manually." >&2
|
||||
exit 1
|
||||
fi
|
||||
done
|
||||
|
||||
echo "== refreshing checksums for all vendored asic-rs crates =="
|
||||
python3 thirdparty/asic-rs/refresh-checksums.py --all
|
||||
echo "done."
|
||||
Vendored
+37
@@ -0,0 +1,37 @@
|
||||
upstream: asic-rs (crates.io)
|
||||
version: 0.8.1 (cargo-vendored under vendor/, per ADR 0003)
|
||||
state: pristine cargo-vendored tree + this patch queue.
|
||||
|
||||
asic-rs is materialized with `cargo vendor vendor` and consumed through
|
||||
.cargo/config.toml's vendored-sources replacement (directory = "vendor").
|
||||
Unlike wx-rs, asic-rs is many crates (asic-rs, asic-rs-core, and the
|
||||
per-make / per-firmware crates); a change to any of them lives here as a
|
||||
numbered .patch, NOT as an in-place edit of the pristine tree (ADR 0003).
|
||||
|
||||
The committed vendor/ tree already has the patches applied AND its affected
|
||||
crates' .cargo-checksum.json refreshed, so a normal build needs nothing extra
|
||||
-- the patch queue is provenance + the re-vendoring recipe.
|
||||
|
||||
GOTCHA (cargo caching): cargo fingerprints a registry/vendored crate by
|
||||
(name, version, source), NOT by file content, so it will REUSE a cached
|
||||
build of a vendored crate even after its source is edited. CI is unaffected
|
||||
(fresh target/ each run compiles the patched source). But an incremental
|
||||
LOCAL build that already compiled the unpatched crate must be forced:
|
||||
cargo clean -p asic-rs-firmwares-whatsminer # then rebuild
|
||||
Otherwise the local binary silently keeps the old behaviour.
|
||||
|
||||
Update / re-vendor flow:
|
||||
1. bump the pin in crates/alkane-gui/Cargo.toml, `cargo vendor vendor`
|
||||
(this regenerates a pristine vendor/ and DROPS our edits)
|
||||
2. scripts/apply-asic-rs-patches.sh # re-applies patches/ + refreshes checksums
|
||||
3. resolve any patch that no longer applies, rebuild, commit
|
||||
|
||||
patches/:
|
||||
0001 whatsminer set_power_limit (round-9 #4): fix the v3 (WhatsMinerOS)
|
||||
privileged auth -- the "super" account's token password is the separate
|
||||
v3 credential (default "super"), not the web/admin password -- and send
|
||||
the watts as a bare integer; also treat the apply-restart's transient
|
||||
RPC error as success. See the patch header.
|
||||
0002 antminer Equihash (Z15/Z15J) hashrate (round-10 #8): the cgminer "GHS"
|
||||
key carries a Sol/s value, so use the base Hash unit for Equihash so the
|
||||
SI prefix is correct ("288k", not "288T"). See the patch header.
|
||||
+104
@@ -0,0 +1,104 @@
|
||||
Subject: [PATCH 0001] whatsminer set_power_limit: v3 auth/param fix + restart-tolerant result
|
||||
|
||||
Round-9 #4 -- "the power-limit on the WhatsMiners doesn't apply properly" --
|
||||
root-caused and verified against the live fleet.
|
||||
|
||||
v3 backend (WhatsMinerOS, firmware >= 2024-11-01, port 4433): the privileged
|
||||
power-limit write authenticated the "super" account with the WEB/admin password
|
||||
(a separate credential; the super account's factory default is "super") and sent
|
||||
the watts as a float, so the miner rejected every write with "invalid json or
|
||||
password is wrong". Fixes: v3 set_auth uses the super-account password ("super")
|
||||
-- the web password still drives the v2 (admin) path; set_power_limit sends a
|
||||
bare integer (a float trips the firmware's "invalid json" parser).
|
||||
|
||||
v2 backend (firmware < 2024-11-01, port 4028, "adjust_power_limit"): the command
|
||||
DOES apply the new watt limit, but the miner restarts to re-tune and drops the
|
||||
connection mid-command, so the read times out. Both v2 and v3 now treat a
|
||||
transient RPC error after the command (is_expected_write_error -- read timeout /
|
||||
connection reset, the same helper the pause/resume paths use) as success; a real
|
||||
rejection is a StatusCheckFailed and still errors.
|
||||
|
||||
Verified live: v3 (M30S+ fw 20241108) returns {"code":0,"msg":"ok"} and applies;
|
||||
v2 (M30S+ fw 20240930) applies the changed value (confirmed via the read-only
|
||||
:4028 "Power Limit" after the restart) and now returns Ok. All test miners were
|
||||
returned to their prior configured limit. Matches the pyasic / HashSource
|
||||
whatsminer-api-3 references.
|
||||
|
||||
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
|
||||
index c7b00e3b..096b2fcb 100644
|
||||
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
|
||||
@@ -637,11 +637,21 @@ impl SetFaultLight for WhatsMinerV2 {
|
||||
impl SetPowerLimit for WhatsMinerV2 {
|
||||
async fn set_power_limit(&self, limit: Power) -> anyhow::Result<bool> {
|
||||
let parameters = Some(json!({"power_limit": limit.as_watts().to_string()}));
|
||||
- let data = self
|
||||
+ match self
|
||||
.rpc
|
||||
.send_command("adjust_power_limit", true, parameters)
|
||||
- .await;
|
||||
- Ok(data.is_ok())
|
||||
+ .await
|
||||
+ {
|
||||
+ Ok(_) => Ok(true),
|
||||
+ // adjust_power_limit makes the miner restart to re-tune, so it drops
|
||||
+ // the connection / stops replying mid-command even though it accepted
|
||||
+ // and applied the new limit (verified on the live fleet: the set value
|
||||
+ // settles after the restart). A transient RPC error (read timeout /
|
||||
+ // connection reset) after the command is therefore success; a genuine
|
||||
+ // rejection surfaces as StatusCheckFailed and still errors.
|
||||
+ Err(e) if is_expected_write_error(&e) => Ok(true),
|
||||
+ Err(e) => Err(e),
|
||||
+ }
|
||||
}
|
||||
fn supports_set_power_limit(&self) -> bool {
|
||||
true
|
||||
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
|
||||
index 77d724d5..c00c6d44 100644
|
||||
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
|
||||
@@ -669,12 +669,21 @@ impl SetFaultLight for WhatsMinerV3 {
|
||||
#[async_trait]
|
||||
impl SetPowerLimit for WhatsMinerV3 {
|
||||
async fn set_power_limit(&self, limit: Power) -> anyhow::Result<bool> {
|
||||
- let data = self
|
||||
+ // WhatsMinerOS wants a BARE INTEGER watt value; a float ("3000.0")
|
||||
+ // trips the firmware's "invalid json" parser (round-9 #4).
|
||||
+ let watts = limit.as_watts().round() as u64;
|
||||
+ match self
|
||||
.rpc
|
||||
- .send_command("set.miner.power_limit", true, Some(json!(limit.as_watts())))
|
||||
- .await;
|
||||
-
|
||||
- Ok(data.is_ok())
|
||||
+ .send_command("set.miner.power_limit", true, Some(json!(watts)))
|
||||
+ .await
|
||||
+ {
|
||||
+ Ok(_) => Ok(true),
|
||||
+ // A power-limit change restarts the miner to re-tune, so a transient
|
||||
+ // RPC error after the command means it was accepted (as with v2), not
|
||||
+ // rejected; a genuine rejection is a StatusCheckFailed and still errors.
|
||||
+ Err(e) if is_expected_write_error(&e) => Ok(true),
|
||||
+ Err(e) => Err(e),
|
||||
+ }
|
||||
}
|
||||
fn supports_set_power_limit(&self) -> bool {
|
||||
true
|
||||
@@ -806,8 +815,15 @@ impl HasDefaultAuth for WhatsMinerV3 {
|
||||
|
||||
impl HasAuth for WhatsMinerV3 {
|
||||
fn set_auth(&mut self, auth: MinerAuth) {
|
||||
- // WhatsMiner V3 username is always "super", V2 is always "admin"
|
||||
- self.rpc.set_auth(MinerAuth::new("super", auth.password()));
|
||||
+ // WhatsMiner V3 username is always "super", V2 is always "admin".
|
||||
+ // The V3 privileged token authenticates against the "super" ACCOUNT,
|
||||
+ // whose password is a separate v3 credential (factory default "super")
|
||||
+ // -- NOT the web/admin password carried by `auth`. Pairing account
|
||||
+ // "super" with the web password made every v3 privileged write fail with
|
||||
+ // "invalid json or password is wrong" (round-9 #4, confirmed on the live
|
||||
+ // fleet). Keep the super-account default password here; the web password
|
||||
+ // still drives the v2 (admin) path below.
|
||||
+ self.rpc.set_auth(MinerAuth::new("super", "super"));
|
||||
self.v2_rpc
|
||||
.set_auth(MinerAuth::new("admin", auth.password()));
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
Subject: [PATCH 0002] antminer: Equihash (Z15/Z15J) hashrate uses base Sol/s unit
|
||||
|
||||
Round-10 #8 -- a Z15 shows its hashrate in 'T' (e.g. "288T") when it should be
|
||||
'k' (~288 kSol/s). Root cause verified on the live fleet: Equihash miners report
|
||||
a Sol/s rate in the cgminer "GHS" key, but AntMiner's parse_hashrate takes the
|
||||
unit from the key name ("GHS" -> GigaHash), scaling the value 1e9x too large.
|
||||
The value is a raw Sol/s count, so for Equihash use the base Hash unit; the
|
||||
downstream SI-prefixing then yields "288k". Matched by algorithm, and by "Z15"
|
||||
model name for the Z15J which asic-rs leaves algo Unknown. Applies to both the
|
||||
v2020 and v2023_07 backends. Verified: Z15 288T -> 288k, Z15J 138T -> 110k.
|
||||
|
||||
diff --git a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
|
||||
index cd4f7cbd..5b9f77b3 100644
|
||||
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
|
||||
@@ -14,7 +14,7 @@ use asic_rs_core::{
|
||||
DataCollector, DataExtensions, DataExtractor, DataField, DataLocation, get_by_pointer,
|
||||
},
|
||||
command::MinerCommand,
|
||||
- device::DeviceInfo,
|
||||
+ device::{DeviceInfo, HashAlgorithm},
|
||||
fan::FanData,
|
||||
firmware::FirmwareImage,
|
||||
hashrate::{HashRate, HashRateUnit},
|
||||
@@ -722,6 +722,15 @@ impl GetHashrate for AntMinerV2020 {
|
||||
})
|
||||
})?;
|
||||
|
||||
+ // Equihash miners (e.g. Z15/Z15J) report a Sol/s rate in the cgminer
|
||||
+ // "GHS" key, so the key's GigaHash label is wrong -- the value is the
|
||||
+ // raw Sol/s count. Use the base unit so the magnitude (and SI prefix)
|
||||
+ // is correct (e.g. ~288000 Sol/s -> "288k", not "288T"). Match by algo,
|
||||
+ // and by Z15 model name for the Z15J which asic-rs leaves algo Unknown.
|
||||
+ let is_equihash = self.device_info.algo == HashAlgorithm::Equihash
|
||||
+ || self.device_info.model.to_string().to_ascii_uppercase().contains("Z15");
|
||||
+ let unit = if is_equihash { HashRateUnit::Hash } else { unit };
|
||||
+
|
||||
Some(
|
||||
HashRate {
|
||||
value,
|
||||
diff --git a/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs b/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs
|
||||
index 4ba13537..6d6dc593 100644
|
||||
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs
|
||||
@@ -16,7 +16,7 @@ use asic_rs_core::{
|
||||
DataCollector, DataExtensions, DataExtractor, DataField, DataLocation, get_by_pointer,
|
||||
},
|
||||
command::MinerCommand,
|
||||
- device::DeviceInfo,
|
||||
+ device::{DeviceInfo, HashAlgorithm},
|
||||
fan::FanData,
|
||||
firmware::FirmwareImage,
|
||||
hashrate::{HashRate, HashRateUnit},
|
||||
@@ -698,6 +698,15 @@ impl GetHashrate for AntMinerV202307 {
|
||||
})
|
||||
})?;
|
||||
|
||||
+ // Equihash miners (e.g. Z15/Z15J) report a Sol/s rate in the cgminer
|
||||
+ // "GHS" key, so the key's GigaHash label is wrong -- the value is the
|
||||
+ // raw Sol/s count. Use the base unit so the magnitude (and SI prefix)
|
||||
+ // is correct (e.g. ~288000 Sol/s -> "288k", not "288T"). Match by algo,
|
||||
+ // and by Z15 model name for the Z15J which asic-rs leaves algo Unknown.
|
||||
+ let is_equihash = self.device_info.algo == HashAlgorithm::Equihash
|
||||
+ || self.device_info.model.to_string().to_ascii_uppercase().contains("Z15");
|
||||
+ let unit = if is_equihash { HashRateUnit::Hash } else { unit };
|
||||
+
|
||||
Some(
|
||||
HashRate {
|
||||
value,
|
||||
+74
@@ -0,0 +1,74 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Refresh the .cargo-checksum.json of vendored asic-rs crates after the patch
|
||||
queue (thirdparty/asic-rs/patches/) has been applied to the cargo-vendored tree.
|
||||
|
||||
cargo verifies each vendored file against the per-file SHA256 in that crate's
|
||||
.cargo-checksum.json; a patched file whose checksum is stale fails the build. For
|
||||
every crate named on the command line (or, with --all, every asic-rs* crate under
|
||||
vendor/), this recomputes the SHA256 of each file already listed in the manifest
|
||||
and rewrites it, preserving the top-level "package"/"$comment" keys. Files not
|
||||
listed are left alone (cargo only checks listed files).
|
||||
|
||||
Usage:
|
||||
refresh-checksums.py <crate-dir> [<crate-dir> ...]
|
||||
refresh-checksums.py --all # every vendor/asic-rs* crate
|
||||
"""
|
||||
import hashlib
|
||||
import json
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
REPO = Path(__file__).resolve().parents[2]
|
||||
VENDOR = REPO / "vendor"
|
||||
|
||||
|
||||
def sha256(path: Path) -> str:
|
||||
h = hashlib.sha256()
|
||||
with open(path, "rb") as f:
|
||||
for chunk in iter(lambda: f.read(1 << 16), b""):
|
||||
h.update(chunk)
|
||||
return h.hexdigest()
|
||||
|
||||
|
||||
def refresh(crate_dir: Path) -> int:
|
||||
manifest = crate_dir / ".cargo-checksum.json"
|
||||
if not manifest.exists():
|
||||
print(f"skip {crate_dir.name}: no .cargo-checksum.json")
|
||||
return 0
|
||||
data = json.loads(manifest.read_text())
|
||||
files = data.get("files", {})
|
||||
changed = 0
|
||||
for rel in list(files):
|
||||
fp = crate_dir / rel
|
||||
if not fp.exists():
|
||||
print(f" WARN {crate_dir.name}: listed file missing: {rel}")
|
||||
continue
|
||||
new = sha256(fp)
|
||||
if new != files[rel]:
|
||||
files[rel] = new
|
||||
changed += 1
|
||||
if changed:
|
||||
manifest.write_text(json.dumps(data, separators=(",", ":")))
|
||||
print(f"{crate_dir.name}: refreshed {changed} checksum(s)")
|
||||
else:
|
||||
print(f"{crate_dir.name}: no changes")
|
||||
return changed
|
||||
|
||||
|
||||
def main() -> None:
|
||||
args = sys.argv[1:]
|
||||
if not args:
|
||||
print(__doc__)
|
||||
sys.exit(2)
|
||||
if args == ["--all"]:
|
||||
crates = sorted(p for p in VENDOR.glob("asic-rs*") if p.is_dir())
|
||||
else:
|
||||
crates = [Path(a) if Path(a).is_absolute() else (VENDOR / a) for a in args]
|
||||
total = 0
|
||||
for c in crates:
|
||||
total += refresh(c)
|
||||
print(f"done: {total} checksum(s) refreshed across {len(crates)} crate(s)")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
+113
-1
@@ -10,7 +10,7 @@
|
||||
+pub use widgets::*;
|
||||
--- a/src/widgets.rs
|
||||
+++ b/src/widgets.rs
|
||||
@@ -0,0 +1,688 @@
|
||||
@@ -0,0 +1,800 @@
|
||||
+// 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).
|
||||
@@ -36,6 +36,8 @@
|
||||
+ pub fn wxbr_set_sizer(win: *mut c_void, sizer: *mut c_void);
|
||||
+ pub fn wxbr_layout(win: *mut c_void);
|
||||
+ pub fn wxbr_sizer_detach(sizer: *mut c_void, win: *mut c_void);
|
||||
+ pub fn wxbr_sizer_show(sizer: *mut c_void, win: *mut c_void, show: c_int);
|
||||
+ pub fn wxbr_bind_size(win: *mut c_void);
|
||||
+ pub fn wxbr_fit(win: *mut c_void);
|
||||
+ pub fn wxbr_set_min_size(win: *mut c_void, w: c_int, h: c_int);
|
||||
+ pub fn wxbr_static_text(parent: *mut c_void, label: *const c_char) -> *mut c_void;
|
||||
@@ -71,8 +73,10 @@
|
||||
+ pub fn wxbr_dvlc_clear(win: *mut c_void);
|
||||
+ pub fn wxbr_dvlc_row_count(win: *mut c_void) -> c_int;
|
||||
+ pub fn wxbr_dvlc_set_cell(win: *mut c_void, row: usize, col: usize, value: *const c_char);
|
||||
+ pub fn wxbr_dvlc_set_cell_tooltip(win: *mut c_void, row: usize, col: usize, text: *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,9 +86,14 @@
|
||||
+ 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;
|
||||
+ pub fn wxbr_reorder_list(parent: *mut c_void, n: c_int, order: *const c_int, items: *const *const c_char) -> *mut c_void;
|
||||
+ pub fn wxbr_reorder_get_order(win: *mut c_void, buf: *mut c_int, cap: c_int) -> c_int;
|
||||
+ pub fn wxbr_menu_new() -> *mut c_void;
|
||||
+ pub fn wxbr_menu_append(menu: *mut c_void, id: c_int, label: *const c_char);
|
||||
+ pub fn wxbr_menu_append_separator(menu: *mut c_void);
|
||||
@@ -107,10 +116,13 @@
|
||||
+ pub fn wxbr_choice_get_selection(win: *mut c_void) -> c_int;
|
||||
+ pub fn wxbr_choice_set_selection(win: *mut c_void, i: c_int);
|
||||
+ pub fn wxbr_media_button(parent: *mut c_void, id: c_int, kind: c_int, r: c_int, g: c_int, b: c_int) -> *mut c_void;
|
||||
+ pub fn wxbr_kpi_icon(parent: *mut c_void, kind: c_int, r: c_int, g: c_int, b: c_int) -> *mut c_void;
|
||||
+ pub fn wxbr_bind_sys_colour(win: *mut c_void);
|
||||
+ pub fn wxbr_destroy(win: *mut c_void);
|
||||
+ pub fn wxbr_destroy_children(win: *mut c_void);
|
||||
+ pub fn wxbr_call_after(id: c_int);
|
||||
+ pub fn wxbr_status_indicator_init(frame: *mut c_void);
|
||||
+ pub fn wxbr_status_indicator_set(text: *const c_char, r: c_int, g: c_int, b: c_int);
|
||||
+ }
|
||||
+}
|
||||
+
|
||||
@@ -146,6 +158,9 @@
|
||||
+ ChoiceChanged,
|
||||
+ SysColour,
|
||||
+ Deferred,
|
||||
+ DvlcHeaderRightClick,
|
||||
+ /// Window resized; p1 = new client width, p2 = new client height.
|
||||
+ Sized,
|
||||
+}
|
||||
+
|
||||
+impl WxEventKind {
|
||||
@@ -164,6 +179,8 @@
|
||||
+ 12 => WxEventKind::ChoiceChanged,
|
||||
+ 13 => WxEventKind::SysColour,
|
||||
+ 14 => WxEventKind::Deferred,
|
||||
+ 15 => WxEventKind::DvlcHeaderRightClick,
|
||||
+ 16 => WxEventKind::Sized,
|
||||
+ _ => return None,
|
||||
+ })
|
||||
+ }
|
||||
@@ -181,6 +198,21 @@
|
||||
+ unsafe { notsafe::wxbr_call_after(id as c_int) }
|
||||
+}
|
||||
+
|
||||
+/// Reconfigure the frame's status bar to two fields and attach a colour-tinted
|
||||
+/// label pinned to the right-hand field (bottom-right corner). Call once after
|
||||
+/// `create_status_bar()`. The main scan status keeps using the left field via
|
||||
+/// the upstream `set_status_text` path.
|
||||
+pub fn status_indicator_init(frame: Widget) {
|
||||
+ unsafe { notsafe::wxbr_status_indicator_init(frame.0) }
|
||||
+}
|
||||
+
|
||||
+/// Set the bottom-right status indicator's text and colour (an empty string
|
||||
+/// clears it). Used for scan/apply errors (red) and warnings (amber).
|
||||
+pub fn status_indicator_set(text: &str, r: u8, g: u8, b: u8) {
|
||||
+ let c = CString::new(text).unwrap_or_default();
|
||||
+ unsafe { notsafe::wxbr_status_indicator_set(c.as_ptr(), r as c_int, g as c_int, b as c_int) }
|
||||
+}
|
||||
+
|
||||
+/// Open a URL in the system default browser. Returns true on success.
|
||||
+pub fn launch_browser(url: &str) -> bool {
|
||||
+ let c = CString::new(url).unwrap_or_default();
|
||||
@@ -297,6 +329,18 @@
|
||||
+ unsafe { notsafe::wxbr_sizer_detach(self.0, win.0) }
|
||||
+ }
|
||||
+
|
||||
+ /// Show or hide a child window in this sizer (self = a sizer), reclaiming or
|
||||
+ /// restoring its space on the next `layout()`.
|
||||
+ pub fn sizer_show(&self, win: Widget, show: bool) {
|
||||
+ unsafe { notsafe::wxbr_sizer_show(self.0, win.0, show as c_int) }
|
||||
+ }
|
||||
+
|
||||
+ /// Emit `WxEventKind::Sized` (p1 = width, p2 = height) whenever this window
|
||||
+ /// is resized.
|
||||
+ pub fn bind_size(&self) {
|
||||
+ unsafe { notsafe::wxbr_bind_size(self.0) }
|
||||
+ }
|
||||
+
|
||||
+ pub fn fit(&self, win: Widget) {
|
||||
+ unsafe { notsafe::wxbr_fit(win.0) }
|
||||
+ }
|
||||
@@ -489,6 +533,13 @@
|
||||
+ unsafe { notsafe::wxbr_dvlc_set_cell(self.0, row, col, c.as_ptr()) }
|
||||
+ }
|
||||
+
|
||||
+ /// Set the hover tooltip for one cell (empty clears it). GTK only; a no-op
|
||||
+ /// on other platforms until they gain per-cell tooltip support.
|
||||
+ pub fn dvlc_set_cell_tooltip(&self, row: usize, col: usize, text: &str) {
|
||||
+ let c = CString::new(text).unwrap_or_default();
|
||||
+ unsafe { notsafe::wxbr_dvlc_set_cell_tooltip(self.0, row, col, c.as_ptr()) }
|
||||
+ }
|
||||
+
|
||||
+ pub fn dvlc_get_cell(&self, row: usize, col: usize) -> Option<String> {
|
||||
+ let mut buf = vec![0i8; 4096];
|
||||
+ let n = unsafe {
|
||||
@@ -505,6 +556,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 +604,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`
|
||||
@@ -569,6 +646,27 @@
|
||||
+ buf.into_iter().take(n.max(0) as usize).collect()
|
||||
+ }
|
||||
+
|
||||
+ /// A checkable, multi-select, drag-reorderable column list (round 11 #4):
|
||||
+ /// like `rearrange_list` but with no up/down buttons -- rows are reordered by
|
||||
+ /// dragging, and selected with shift/ctrl-click or a rubber-band drag. Same
|
||||
+ /// `[idx | !idx]` order encoding.
|
||||
+ pub fn reorder_list(parent: Widget, order: &[i32], items: &[&str]) -> Widget {
|
||||
+ let cs: Vec<CString> = items.iter().map(|s| CString::new(*s).unwrap_or_default()).collect();
|
||||
+ let ptrs: Vec<*const c_char> = cs.iter().map(|c| c.as_ptr()).collect();
|
||||
+ Widget(unsafe {
|
||||
+ notsafe::wxbr_reorder_list(parent.0, items.len() as c_int, order.as_ptr(), ptrs.as_ptr())
|
||||
+ })
|
||||
+ }
|
||||
+
|
||||
+ /// Read back the current order from a `reorder_list` (same encoding).
|
||||
+ pub fn reorder_get_order(&self) -> Vec<i32> {
|
||||
+ let mut buf = vec![0i32; 4096];
|
||||
+ let n = unsafe {
|
||||
+ notsafe::wxbr_reorder_get_order(self.0, buf.as_mut_ptr(), buf.len() as c_int)
|
||||
+ };
|
||||
+ buf.into_iter().take(n.max(0) as usize).collect()
|
||||
+ }
|
||||
+
|
||||
+ // ---- popup menu ----
|
||||
+
|
||||
+ pub fn menu_new() -> Widget {
|
||||
@@ -683,6 +781,20 @@
|
||||
+ })
|
||||
+ }
|
||||
+
|
||||
+ /// A small drawn KPI icon (static bitmap). kind: 0 rabbit, 1 turtle,
|
||||
+ /// 2 broken wine glass, 3 otter, 4 hive, 5 lightning bolt (round 11 #15).
|
||||
+ pub fn kpi_icon(parent: Widget, kind: i32, color: (u8, u8, u8)) -> Widget {
|
||||
+ Widget(unsafe {
|
||||
+ notsafe::wxbr_kpi_icon(
|
||||
+ parent.0,
|
||||
+ kind,
|
||||
+ color.0 as c_int,
|
||||
+ color.1 as c_int,
|
||||
+ color.2 as c_int,
|
||||
+ )
|
||||
+ })
|
||||
+ }
|
||||
+
|
||||
+ /// Listen for OS light/dark theme changes on this window (emits `SysColour`).
|
||||
+ pub fn bind_sys_colour(&self) {
|
||||
+ unsafe { notsafe::wxbr_bind_sys_colour(self.0) }
|
||||
|
||||
+609
-18
@@ -1,6 +1,6 @@
|
||||
--- a/cpp_src/widgets_bridge.cpp
|
||||
+++ b/cpp_src/widgets_bridge.cpp
|
||||
@@ -0,0 +1,892 @@
|
||||
@@ -0,0 +1,1483 @@
|
||||
+// 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).
|
||||
@@ -22,6 +22,7 @@
|
||||
+#include <wx/utils.h>
|
||||
+#include <wx/app.h>
|
||||
+#include <wx/rearrangectrl.h>
|
||||
+#include <wx/listctrl.h>
|
||||
+#include <wx/menu.h>
|
||||
+#include <wx/choice.h>
|
||||
+#include <wx/bmpbuttn.h>
|
||||
@@ -32,13 +33,27 @@
|
||||
+#include <wx/graphics.h>
|
||||
+#include <wx/wrapsizer.h>
|
||||
+#include <wx/filedlg.h>
|
||||
+#include <wx/statusbr.h>
|
||||
+#include <cstring>
|
||||
+#include <cstdio>
|
||||
+#include <map>
|
||||
+#include <vector>
|
||||
+#ifdef __WXGTK__
|
||||
+// For native GtkTreeView rubber-band (click-drag) selection, which wx does not
|
||||
+// enable and which cannot be done via wx mouse events on GTK (the native widget
|
||||
+// grabs the pointer during a drag). Guarded so non-GTK builds are unaffected.
|
||||
+#include <gtk/gtk.h>
|
||||
+#endif
|
||||
+
|
||||
+typedef void (*WxWidgetEventFn)(int kind, long p1, long p2);
|
||||
+static WxWidgetEventFn g_widget_event = nullptr;
|
||||
+
|
||||
+#ifndef __WXGTK__
|
||||
+// Anchor row per data-view control for the wx-mouse-event rubber-band fallback
|
||||
+// (non-GTK platforms; GTK uses native GtkTreeView rubber-banding instead).
|
||||
+static std::map<wxDataViewCtrl*, int> g_drag_anchor;
|
||||
+#endif
|
||||
+
|
||||
+// Event kinds (must match Rust WxEventKind in src/widgets.rs)
|
||||
+enum WxWidgetEventKind {
|
||||
+ WxEV_BUTTON_CLICKED = 1,
|
||||
@@ -54,23 +69,36 @@
|
||||
+ WxEV_CHOICE_CHANGED = 12,
|
||||
+ WxEV_SYS_COLOUR = 13,
|
||||
+ WxEV_DEFERRED = 14,
|
||||
+ WxEV_DVLC_HEADER_RIGHT_CLICK = 15,
|
||||
+ WxEV_SIZE = 16, // p1 = new client width, p2 = new client height
|
||||
+};
|
||||
+
|
||||
+// 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
|
||||
+ // Per-cell hover tooltip text, keyed by (row, model column). Used for the
|
||||
+ // Errors column's full-message tooltip (see the GTK query-tooltip handler).
|
||||
+ std::map<std::pair<unsigned, unsigned>, wxString> cell_tip;
|
||||
+ 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;
|
||||
+ }
|
||||
+};
|
||||
+
|
||||
@@ -123,6 +151,57 @@
|
||||
+ return segs;
|
||||
+}
|
||||
+
|
||||
+// Shape sentinels a segment's text may carry instead of glyphs (round 11
|
||||
+// #10/#13): a single control char selects a small vector icon drawn in the
|
||||
+// segment's colour. These are control characters (never emoji/pictographs) so
|
||||
+// they are safe in source and independent of the font's glyph coverage.
|
||||
+const wxUniChar SHAPE_DOT = 0x07; // filled status dot (hashboards, locate light)
|
||||
+const wxUniChar SHAPE_LOCK = 0x02; // closed padlock (locked / view-only)
|
||||
+const wxUniChar SHAPE_UNLOCK = 0x03; // open padlock (unlocked / writable)
|
||||
+const int SHAPE_ADVANCE = 15; // horizontal space one shape occupies
|
||||
+
|
||||
+bool IsShapeSentinel(const wxString& s, wxUniChar& out) {
|
||||
+ if (s.length() != 1) return false;
|
||||
+ wxUniChar c = s[0];
|
||||
+ if (c == SHAPE_DOT || c == SHAPE_LOCK || c == SHAPE_UNLOCK) {
|
||||
+ out = c;
|
||||
+ return true;
|
||||
+ }
|
||||
+ return false;
|
||||
+}
|
||||
+
|
||||
+// Draw one shape sentinel, centred in the SHAPE_ADVANCE-wide slot at x.
|
||||
+void DrawShape(wxDC* dc, wxUniChar shape, wxCoord x, const wxRect& cell, const wxColour& colour) {
|
||||
+ int cy = cell.y + cell.height / 2;
|
||||
+ int cx = x + SHAPE_ADVANCE / 2;
|
||||
+ if (shape == SHAPE_DOT) {
|
||||
+ dc->SetPen(*wxTRANSPARENT_PEN);
|
||||
+ dc->SetBrush(wxBrush(colour));
|
||||
+ dc->DrawCircle(cx, cy, 4);
|
||||
+ return;
|
||||
+ }
|
||||
+ // Padlock: a filled body with a staple shackle above. The colour carries the
|
||||
+ // state (green = unlocked, red = locked); the shackle is drawn ajar when open.
|
||||
+ bool open = (shape == SHAPE_UNLOCK);
|
||||
+ int bw = 9, bh = 7;
|
||||
+ int bx = cx - bw / 2;
|
||||
+ int by = cy - bh / 2 + 1;
|
||||
+ dc->SetPen(*wxTRANSPARENT_PEN);
|
||||
+ dc->SetBrush(wxBrush(colour));
|
||||
+ dc->DrawRoundedRectangle(bx, by, bw, bh, 1.5);
|
||||
+ dc->SetBrush(*wxTRANSPARENT_BRUSH);
|
||||
+ dc->SetPen(wxPen(colour, 2));
|
||||
+ int sr = 3;
|
||||
+ int legTop = by - sr - 1;
|
||||
+ int lx = cx - sr, rx = cx + sr;
|
||||
+ dc->DrawLine(lx, by, lx, legTop); // left leg
|
||||
+ dc->DrawLine(lx, legTop, rx, legTop); // top bar
|
||||
+ if (open)
|
||||
+ dc->DrawLine(rx, legTop, rx, legTop + sr); // ajar: right leg lifted
|
||||
+ else
|
||||
+ dc->DrawLine(rx, legTop, rx, by); // closed: right leg to body
|
||||
+}
|
||||
+
|
||||
+} // namespace
|
||||
+
|
||||
+class SegmentRenderer : public wxDataViewCustomRenderer {
|
||||
@@ -142,12 +221,59 @@
|
||||
+
|
||||
+ bool Render(wxRect cell, wxDC* dc, int state) override {
|
||||
+ bool selected = (state & wxDATAVIEW_CELL_SELECTED) != 0;
|
||||
+ // wxGTK does NOT paint a custom renderer's cell background, so the per-row
|
||||
+ // (zebra) background set via GetAttrByRow shows on the native columns but
|
||||
+ // not here -- the zebra looked inconsistent across columns. Paint it here so
|
||||
+ // every column stripes the same (skip when the row is selected: the control
|
||||
+ // already drew the selection highlight).
|
||||
+ if (!selected && GetAttr().HasBackgroundColour()) {
|
||||
+ dc->SetBrush(wxBrush(GetAttr().GetBackgroundColour()));
|
||||
+ dc->SetPen(*wxTRANSPARENT_PEN);
|
||||
+ // The `cell` rect wx hands a custom renderer is shrunk to the content
|
||||
+ // (text/shape) size by the alignment logic, so filling it alone left the
|
||||
+ // zebra covering only the text and looking inconsistent with the full-cell
|
||||
+ // native columns. Fill the whole column-wide cell instead; wxGTK clips the
|
||||
+ // cell DC to the visible cell area, so the over-wide rect lands exactly on
|
||||
+ // this cell without bleeding into the next column (round 11 #3).
|
||||
+ wxRect bg = cell;
|
||||
+ if (wxDataViewColumn* owner = const_cast<SegmentRenderer*>(this)->GetOwner()) {
|
||||
+ int cw = owner->GetWidth();
|
||||
+ if (cw > bg.width) bg.width = cw;
|
||||
+ }
|
||||
+ dc->DrawRectangle(bg);
|
||||
+ }
|
||||
+ wxColour highlight = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
|
||||
+ wxColour plain = GetAttr().HasColour()
|
||||
+ ? GetAttr().GetColour()
|
||||
+ : wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
|
||||
+ // An uncoloured (default) segment -- the "/" in a combined cell, a "Stock"
|
||||
+ // firmware family, etc. -- must dim exactly like the native columns when the
|
||||
+ // top-level window is backdropped. wxGTK dims a native cell's text via the
|
||||
+ // widget's themed state colour, but a custom renderer's DC keeps the normal
|
||||
+ // WINDOWTEXT, so ask the tree widget for its themed text colour AT ITS
|
||||
+ // CURRENT STATE (which carries GTK_STATE_FLAG_BACKDROP while unfocused) and
|
||||
+ // use that; off-GTK (or if the widget isn't reachable) fall back to the DC
|
||||
+ // then the system colour (round 11 #1/#7).
|
||||
+ wxColour plain;
|
||||
+ if (GetAttr().HasColour()) {
|
||||
+ plain = GetAttr().GetColour();
|
||||
+ } else {
|
||||
+ plain = ThemedTextColour();
|
||||
+ }
|
||||
+ if (!plain.IsOk()) {
|
||||
+ plain = dc->GetTextForeground();
|
||||
+ }
|
||||
+ if (!plain.IsOk()) {
|
||||
+ plain = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
|
||||
+ }
|
||||
+ wxCoord x = cell.x;
|
||||
+ for (const ColorSegment& seg : ParseColorSegments(m_value)) {
|
||||
+ // Shape segments (status dots, access padlock) keep their own semantic
|
||||
+ // colour even on a selected row, so the green/red reading survives the
|
||||
+ // selection highlight (round 11 #10/#13).
|
||||
+ wxUniChar shape;
|
||||
+ if (IsShapeSentinel(seg.text, shape)) {
|
||||
+ DrawShape(dc, shape, x, cell, seg.has_colour ? seg.colour : plain);
|
||||
+ x += SHAPE_ADVANCE;
|
||||
+ continue;
|
||||
+ }
|
||||
+ if (seg.text.IsEmpty()) continue;
|
||||
+ dc->SetTextForeground(selected ? highlight : (seg.has_colour ? seg.colour : plain));
|
||||
+ wxSize extent = dc->GetTextExtent(seg.text);
|
||||
@@ -159,14 +285,49 @@
|
||||
+ }
|
||||
+
|
||||
+ wxSize GetSize() const override {
|
||||
+ wxString plain;
|
||||
+ for (const ColorSegment& seg : ParseColorSegments(m_value)) plain += seg.text;
|
||||
+ wxSize sz = GetTextExtent(plain);
|
||||
+ if (sz.GetWidth() < 1) sz.SetWidth(1);
|
||||
+ return sz;
|
||||
+ int w = 0, h = 0;
|
||||
+ for (const ColorSegment& seg : ParseColorSegments(m_value)) {
|
||||
+ wxUniChar shape;
|
||||
+ if (IsShapeSentinel(seg.text, shape)) {
|
||||
+ w += SHAPE_ADVANCE;
|
||||
+ if (h < 12) h = 12;
|
||||
+ continue;
|
||||
+ }
|
||||
+ wxSize e = GetTextExtent(seg.text);
|
||||
+ w += e.GetWidth();
|
||||
+ if (e.GetHeight() > h) h = e.GetHeight();
|
||||
+ }
|
||||
+ if (w < 1) w = 1;
|
||||
+ if (h < 1) h = 1;
|
||||
+ return wxSize(w, h);
|
||||
+ }
|
||||
+
|
||||
+ private:
|
||||
+ // The owning tree widget's themed text colour at its current GTK state, so
|
||||
+ // uncoloured segments dim on window-backdrop like the native columns
|
||||
+ // (round 11 #1/#7). Returns an invalid colour off wxGTK or when the widget is
|
||||
+ // unreachable, so the caller falls back to the DC / system colour.
|
||||
+ wxColour ThemedTextColour() const {
|
||||
+#ifdef __WXGTK__
|
||||
+ wxDataViewColumn* col = const_cast<SegmentRenderer*>(this)->GetOwner();
|
||||
+ if (col && col->GetOwner()) {
|
||||
+ GtkWidget* tv = col->GetOwner()->GtkGetTreeView();
|
||||
+ if (tv && GTK_IS_WIDGET(tv)) {
|
||||
+ GtkStyleContext* ctx = gtk_widget_get_style_context(tv);
|
||||
+ GtkStateFlags st = gtk_widget_get_state_flags(tv);
|
||||
+ GdkRGBA c;
|
||||
+ G_GNUC_BEGIN_IGNORE_DEPRECATIONS
|
||||
+ gtk_style_context_get_color(ctx, st, &c);
|
||||
+ G_GNUC_END_IGNORE_DEPRECATIONS
|
||||
+ return wxColour((unsigned char)(c.red * 255.0 + 0.5),
|
||||
+ (unsigned char)(c.green * 255.0 + 0.5),
|
||||
+ (unsigned char)(c.blue * 255.0 + 0.5));
|
||||
+ }
|
||||
+ }
|
||||
+#endif
|
||||
+ return wxColour();
|
||||
+ }
|
||||
+
|
||||
+ wxString m_value;
|
||||
+};
|
||||
+
|
||||
@@ -191,7 +352,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):
|
||||
@@ -244,6 +409,23 @@
|
||||
+ ((wxSizer*)sizer)->Detach((wxWindow*)win);
|
||||
+}
|
||||
+
|
||||
+// Show or hide a sizer-managed child window AND reclaim (or restore) its space
|
||||
+// on the next Layout(). Used to collapse the wide KPI cards when the window is
|
||||
+// too narrow (round 11 #2).
|
||||
+void wxbr_sizer_show(void* sizer, void* win, int show) {
|
||||
+ ((wxSizer*)sizer)->Show((wxWindow*)win, show != 0);
|
||||
+}
|
||||
+
|
||||
+// Emit WxEV_SIZE (p1 = new client width, p2 = height) whenever this window is
|
||||
+// resized. e.Skip() keeps the normal sizer layout running (round 11 #2).
|
||||
+void wxbr_bind_size(void* win) {
|
||||
+ ((wxWindow*)win)->Bind(wxEVT_SIZE, [](wxSizeEvent& e) {
|
||||
+ if (g_widget_event) g_widget_event(WxEV_SIZE, (long)e.GetSize().GetWidth(),
|
||||
+ (long)e.GetSize().GetHeight());
|
||||
+ e.Skip();
|
||||
+ });
|
||||
+}
|
||||
+
|
||||
+void wxbr_fit(void* win) { ((wxWindow*)win)->Fit(); }
|
||||
+
|
||||
+void wxbr_set_min_size(void* win, int w, int h) {
|
||||
@@ -436,13 +618,44 @@
|
||||
+ return static_cast<AttrListStore*>(((wxDataViewCtrl*)win)->GetModel());
|
||||
+}
|
||||
+
|
||||
+#ifdef __WXGTK__
|
||||
+// GtkTreeView "query-tooltip" handler: show the per-cell tooltip stored for the
|
||||
+// (row, model column) under the pointer (used by the Errors column). wx does
|
||||
+// not surface per-cell tooltips on wxDataViewCtrl, and mouse-motion events are
|
||||
+// not delivered to wx handlers on the native GTK control, so this hooks the
|
||||
+// native signal directly.
|
||||
+static gboolean dvlc_query_tooltip(GtkWidget* tv, gint x, gint y, gboolean keyboard,
|
||||
+ GtkTooltip* tooltip, gpointer user_data) {
|
||||
+ (void)keyboard;
|
||||
+ wxDataViewCtrl* dv = static_cast<wxDataViewCtrl*>(user_data);
|
||||
+ gint bx = 0, by = 0;
|
||||
+ gtk_tree_view_convert_widget_to_bin_window_coords(GTK_TREE_VIEW(tv), x, y, &bx, &by);
|
||||
+ GtkTreePath* path = nullptr;
|
||||
+ GtkTreeViewColumn* gcol = nullptr;
|
||||
+ if (!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(tv), bx, by, &path, &gcol, nullptr, nullptr))
|
||||
+ return FALSE;
|
||||
+ gint* idx = gtk_tree_path_get_indices(path);
|
||||
+ int row = idx ? idx[0] : -1;
|
||||
+ gtk_tree_path_free(path);
|
||||
+ if (row < 0 || !gcol) return FALSE;
|
||||
+ wxDataViewColumn* wxcol = dv->GTKColumnToWX(gcol);
|
||||
+ if (!wxcol) return FALSE;
|
||||
+ AttrListStore* store = static_cast<AttrListStore*>(dv->GetModel());
|
||||
+ auto it = store->cell_tip.find({(unsigned)row, wxcol->GetModelColumn()});
|
||||
+ if (it == store->cell_tip.end() || it->second.IsEmpty()) return FALSE;
|
||||
+ gtk_tooltip_set_text(tooltip, it->second.utf8_str());
|
||||
+ return TRUE;
|
||||
+}
|
||||
+#endif
|
||||
+
|
||||
+void* wxbr_dvlc(void* parent) {
|
||||
+ // Multi-select (ctrl/shift-click) + row lines. Selection replaces the old
|
||||
+ // checkbox column. A custom AttrListStore backs it so rows can be coloured by
|
||||
+ // 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 +678,73 @@
|
||||
+ 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.
|
||||
+#ifdef __WXGTK__
|
||||
+ // On GTK the control wraps a GtkTreeView, which supports native rubber-band
|
||||
+ // selection -- just not enabled by wx. Enable it directly. (wx delivers no
|
||||
+ // MOTION events during the native drag, so the mouse-event fallback below is
|
||||
+ // inapplicable on GTK.)
|
||||
+ {
|
||||
+ GtkWidget* tv = dv->GtkGetTreeView();
|
||||
+ if (tv) {
|
||||
+ gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(tv), TRUE);
|
||||
+ // Per-cell hover tooltips (Errors column) via the native signal.
|
||||
+ gtk_widget_set_has_tooltip(tv, TRUE);
|
||||
+ g_signal_connect(tv, "query-tooltip", G_CALLBACK(dvlc_query_tooltip), dv);
|
||||
+ }
|
||||
+ }
|
||||
+#else
|
||||
+ // Non-GTK fallback: track a drag anchor and extend the selection to the row
|
||||
+ // under the cursor. LEFT_DOWN records the anchor (and lets the native handler
|
||||
+ // select it); dragging with the button down selects the inclusive range.
|
||||
+ 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();
|
||||
+ });
|
||||
+#endif
|
||||
+ // 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) {
|
||||
@@ -539,6 +816,18 @@
|
||||
+ AttrListStore* store = dvlc_store(win);
|
||||
+ store->DeleteAllItems();
|
||||
+ store->row_fg.clear();
|
||||
+ store->cell_tip.clear();
|
||||
+}
|
||||
+
|
||||
+// Set (or clear, with an empty string) the hover tooltip for one cell,
|
||||
+// addressed by (row, model column). Used for the Errors column's full text.
|
||||
+void wxbr_dvlc_set_cell_tooltip(void* win, unsigned row, unsigned col, const char* text) {
|
||||
+ AttrListStore* store = dvlc_store(win);
|
||||
+ if (text && text[0]) {
|
||||
+ store->cell_tip[{row, col}] = wxString::FromUTF8(text);
|
||||
+ } else {
|
||||
+ store->cell_tip.erase({row, col});
|
||||
+ }
|
||||
+}
|
||||
+
|
||||
+// Set (or clear, when r<0) a row's text colour; used to paint rows by status.
|
||||
@@ -549,6 +838,31 @@
|
||||
+ 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 -- GetItem()
|
||||
+// itself asserts on row >= count, so the bound MUST be checked before calling.
|
||||
+void wxbr_dvlc_ensure_visible(void* win, unsigned row) {
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
+ if (row >= (unsigned)dvlc_store(win)->GetItemCount()) return;
|
||||
+ 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 +893,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) {
|
||||
@@ -608,6 +930,25 @@
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
+ unsigned n = dv->GetColumnCount();
|
||||
+ if (pos < 0 || (unsigned)pos >= n) return -1;
|
||||
+#ifdef __WXGTK__
|
||||
+ // wxGTK's GetColumnPosition() does NOT reflect a native GtkTreeView column
|
||||
+ // drag, so after the user reorders columns it reports the creation order and
|
||||
+ // the reorder is silently lost. Read the real display order from the
|
||||
+ // GtkTreeView instead, then map the column back to its wx creation index.
|
||||
+ GtkWidget* tvw = dv->GtkGetTreeView();
|
||||
+ if (tvw) {
|
||||
+ GList* cols = gtk_tree_view_get_columns(GTK_TREE_VIEW(tvw)); // display order
|
||||
+ GtkTreeViewColumn* gcol = (GtkTreeViewColumn*)g_list_nth_data(cols, (guint)pos);
|
||||
+ g_list_free(cols);
|
||||
+ if (gcol) {
|
||||
+ wxDataViewColumn* wxcol = dv->GTKColumnToWX(gcol);
|
||||
+ for (unsigned i = 0; i < n; i++) {
|
||||
+ if (dv->GetColumn(i) == wxcol) return (int)i;
|
||||
+ }
|
||||
+ }
|
||||
+ return -1;
|
||||
+ }
|
||||
+#endif
|
||||
+ for (unsigned i = 0; i < n; i++) {
|
||||
+ wxDataViewColumn* c = dv->GetColumn(i);
|
||||
+ if (c && dv->GetColumnPosition(c) == (unsigned)pos) return (int)i;
|
||||
@@ -639,9 +980,11 @@
|
||||
+void wxbr_dvlc_select_rows(void* win, const int* rows, int n) {
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
+ wxDataViewIndexListModel* m = (wxDataViewIndexListModel*)dv->GetModel();
|
||||
+ int count = (int)dvlc_store(win)->GetItemCount();
|
||||
+ dv->UnselectAll();
|
||||
+ for (int i = 0; i < n; i++) {
|
||||
+ if (rows[i] >= 0) dv->Select(m->GetItem((unsigned)rows[i]));
|
||||
+ // GetItem() asserts on an out-of-range row, so bound both ends.
|
||||
+ if (rows[i] >= 0 && rows[i] < count) dv->Select(m->GetItem((unsigned)rows[i]));
|
||||
+ }
|
||||
+}
|
||||
+
|
||||
@@ -660,6 +1003,7 @@
|
||||
+ if (row < 0) return;
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
+ wxDataViewIndexListModel* m = (wxDataViewIndexListModel*)dv->GetModel();
|
||||
+ if (row >= (long)dvlc_store(win)->GetItemCount()) return;
|
||||
+ dv->Select(m->GetItem((unsigned)row));
|
||||
+}
|
||||
+
|
||||
@@ -770,6 +1114,109 @@
|
||||
+ return n < cap ? n : cap;
|
||||
+}
|
||||
+
|
||||
+// ---- reorder list: a checkable, multi-select, drag-reorderable column list
|
||||
+// for the Columns dialog (round 11 #4). Replaces wxRearrangeCtrl (which had
|
||||
+// up/down buttons and no drag / multi-select). It is a single-column headerless
|
||||
+// wxListCtrl with native checkboxes; rows carry their base model index as item
|
||||
+// data, and the check state + row order encode the same [idx | ~idx] contract
|
||||
+// as wxbr_rearrange_get_order. Selection (shift/ctrl-click, rubber-band drag) is
|
||||
+// native to wxListCtrl. Drag-reorder: on begin-drag we record the selected rows'
|
||||
+// base indices, and on the following mouse-up we move that group to the row
|
||||
+// under the cursor (we never start a real DnD loop, so the mouse-up still
|
||||
+// arrives).
|
||||
+static wxVector<long> g_reorder_drag;
|
||||
+static wxListCtrl* g_reorder_list = nullptr;
|
||||
+
|
||||
+void* wxbr_reorder_list(void* parent, int n, const int* order, const char** items) {
|
||||
+ wxListCtrl* lc = new wxListCtrl((wxWindow*)parent, wxID_ANY, wxDefaultPosition,
|
||||
+ wxSize(-1, 240), wxLC_REPORT | wxLC_NO_HEADER);
|
||||
+ lc->EnableCheckBoxes(true);
|
||||
+ lc->InsertColumn(0, wxT("Column"), wxLIST_FORMAT_LEFT, 260);
|
||||
+ for (int i = 0; i < n; i++) {
|
||||
+ int enc = order[i];
|
||||
+ int idx = enc < 0 ? ~enc : enc;
|
||||
+ long row = lc->InsertItem(i, wxString::FromUTF8(items[idx]));
|
||||
+ lc->SetItemData(row, (long)idx);
|
||||
+ lc->CheckItem(row, enc >= 0);
|
||||
+ }
|
||||
+ lc->Bind(wxEVT_LIST_BEGIN_DRAG, [lc](wxListEvent&) {
|
||||
+ g_reorder_drag.clear();
|
||||
+ g_reorder_list = lc;
|
||||
+ long it = -1;
|
||||
+ for (;;) {
|
||||
+ it = lc->GetNextItem(it, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
|
||||
+ if (it == -1) break;
|
||||
+ g_reorder_drag.push_back(lc->GetItemData(it));
|
||||
+ }
|
||||
+ });
|
||||
+ lc->Bind(wxEVT_LEFT_UP, [lc](wxMouseEvent& e) {
|
||||
+ e.Skip();
|
||||
+ if (g_reorder_list != lc || g_reorder_drag.empty()) return;
|
||||
+ struct Row {
|
||||
+ long data;
|
||||
+ bool checked;
|
||||
+ wxString text;
|
||||
+ };
|
||||
+ int count = lc->GetItemCount();
|
||||
+ wxVector<Row> rows;
|
||||
+ for (int i = 0; i < count; i++) {
|
||||
+ Row r;
|
||||
+ r.data = lc->GetItemData(i);
|
||||
+ r.checked = lc->IsItemChecked(i);
|
||||
+ r.text = lc->GetItemText(i);
|
||||
+ rows.push_back(r);
|
||||
+ }
|
||||
+ auto isDragged = [](long d) {
|
||||
+ for (size_t i = 0; i < g_reorder_drag.size(); i++)
|
||||
+ if (g_reorder_drag[i] == d) return true;
|
||||
+ return false;
|
||||
+ };
|
||||
+ int flags = 0;
|
||||
+ long targetRow = lc->HitTest(e.GetPosition(), flags);
|
||||
+ long anchor = (targetRow >= 0 && targetRow < count) ? rows[targetRow].data : -1;
|
||||
+ if (anchor >= 0 && isDragged(anchor)) anchor = -1;
|
||||
+ wxVector<Row> remaining, moved;
|
||||
+ for (size_t i = 0; i < rows.size(); i++) {
|
||||
+ if (isDragged(rows[i].data))
|
||||
+ moved.push_back(rows[i]);
|
||||
+ else
|
||||
+ remaining.push_back(rows[i]);
|
||||
+ }
|
||||
+ int insertAt = (int)remaining.size();
|
||||
+ if (anchor >= 0) {
|
||||
+ for (size_t i = 0; i < remaining.size(); i++)
|
||||
+ if (remaining[i].data == anchor) {
|
||||
+ insertAt = (int)i;
|
||||
+ break;
|
||||
+ }
|
||||
+ }
|
||||
+ wxVector<Row> result;
|
||||
+ for (int i = 0; i < insertAt; i++) result.push_back(remaining[i]);
|
||||
+ for (size_t i = 0; i < moved.size(); i++) result.push_back(moved[i]);
|
||||
+ for (int i = insertAt; i < (int)remaining.size(); i++) result.push_back(remaining[i]);
|
||||
+ lc->DeleteAllItems();
|
||||
+ for (size_t i = 0; i < result.size(); i++) {
|
||||
+ long row = lc->InsertItem((long)i, result[i].text);
|
||||
+ lc->SetItemData(row, result[i].data);
|
||||
+ lc->CheckItem(row, result[i].checked);
|
||||
+ }
|
||||
+ g_reorder_drag.clear();
|
||||
+ g_reorder_list = nullptr;
|
||||
+ });
|
||||
+ return (void*)lc;
|
||||
+}
|
||||
+
|
||||
+int wxbr_reorder_get_order(void* win, int* buf, int cap) {
|
||||
+ wxListCtrl* lc = (wxListCtrl*)win;
|
||||
+ int count = lc->GetItemCount();
|
||||
+ int n = 0;
|
||||
+ for (int i = 0; i < count && n < cap; i++) {
|
||||
+ int idx = (int)lc->GetItemData(i);
|
||||
+ buf[n++] = lc->IsItemChecked(i) ? idx : ~idx;
|
||||
+ }
|
||||
+ return n;
|
||||
+}
|
||||
+
|
||||
+// ---- popup menu (right-click context menu) ----------------------------------
|
||||
+
|
||||
+void* wxbr_menu_new() { return (void*)new wxMenu(); }
|
||||
@@ -862,6 +1309,101 @@
|
||||
+ return (void*)btn;
|
||||
+}
|
||||
+
|
||||
+// A small vector icon drawn into a transparent bitmap and wrapped in a
|
||||
+// wxStaticBitmap, for the KPI cards (round 11 #15). kind: 0 rabbit (hashing),
|
||||
+// 1 turtle (slow), 2 broken wine glass (not hashing), 3 otter (paused),
|
||||
+// 4 hive (hashrate), 5 lightning bolt (power). Drawn as simple silhouettes so
|
||||
+// they read at ~22px; the colour matches the card's value colour.
|
||||
+void* wxbr_kpi_icon(void* parent, int kind, int r, int g, int b) {
|
||||
+ const int sz = 22;
|
||||
+ wxImage img(sz, sz);
|
||||
+ img.InitAlpha();
|
||||
+ unsigned char* a = img.GetAlpha();
|
||||
+ if (a) memset(a, 0, (size_t)sz * sz);
|
||||
+ wxBitmap bmp(img);
|
||||
+ {
|
||||
+ wxMemoryDC mdc(bmp);
|
||||
+ wxGraphicsContext* gc = wxGraphicsContext::Create(mdc);
|
||||
+ if (gc) {
|
||||
+ gc->SetAntialiasMode(wxANTIALIAS_DEFAULT);
|
||||
+ wxColour col(r, g, b);
|
||||
+ wxColour dark((unsigned char)(r * 0.5), (unsigned char)(g * 0.5), (unsigned char)(b * 0.5));
|
||||
+ gc->SetBrush(wxBrush(col));
|
||||
+ gc->SetPen(wxPen(col, 1.0));
|
||||
+ switch (kind) {
|
||||
+ case 0: { // rabbit: low haunch body + head + two long spread ears
|
||||
+ gc->DrawEllipse(4, 12, 14, 8); // haunch (low, wide)
|
||||
+ gc->DrawEllipse(6.5, 7, 8, 8); // head
|
||||
+ gc->DrawEllipse(6, 0, 2.6, 9); // left ear (long)
|
||||
+ gc->DrawEllipse(12, 0, 2.6, 9); // right ear (long, spread)
|
||||
+ break;
|
||||
+ }
|
||||
+ case 1: { // turtle: wide shell + head + two visible legs
|
||||
+ gc->DrawEllipse(4, 6, 13, 9);
|
||||
+ gc->DrawEllipse(15.5, 8, 4.5, 4.5); // head
|
||||
+ gc->DrawEllipse(4.5, 12.5, 4, 4); // front leg
|
||||
+ gc->DrawEllipse(11, 12.5, 4, 4); // back leg
|
||||
+ break;
|
||||
+ }
|
||||
+ case 2: { // broken wine glass: bowl + stem + base, with a crack
|
||||
+ wxGraphicsPath bowl = gc->CreatePath();
|
||||
+ bowl.MoveToPoint(5, 3);
|
||||
+ bowl.AddLineToPoint(17, 3);
|
||||
+ bowl.AddLineToPoint(11, 12);
|
||||
+ bowl.CloseSubpath();
|
||||
+ gc->FillPath(bowl);
|
||||
+ gc->DrawRectangle(10.2, 12, 1.6, 6);
|
||||
+ gc->DrawRoundedRectangle(7, 18, 8, 2, 1);
|
||||
+ wxGraphicsPath crack = gc->CreatePath(); // jagged crack across the bowl
|
||||
+ crack.MoveToPoint(11, 3);
|
||||
+ crack.AddLineToPoint(9, 6);
|
||||
+ crack.AddLineToPoint(12.5, 8);
|
||||
+ crack.AddLineToPoint(10.5, 11.5);
|
||||
+ gc->SetPen(wxPen(dark, 1.4));
|
||||
+ gc->StrokePath(crack);
|
||||
+ break;
|
||||
+ }
|
||||
+ case 3: { // otter: upright tapered body + head + small ears + thick tail
|
||||
+ wxGraphicsPath tail = gc->CreatePath(); // thick tapering tail curving right
|
||||
+ tail.MoveToPoint(13, 17);
|
||||
+ tail.AddCurveToPoint(19, 16, 21, 20, 19, 21);
|
||||
+ tail.AddCurveToPoint(17, 21, 15, 20, 12, 19);
|
||||
+ tail.CloseSubpath();
|
||||
+ gc->FillPath(tail);
|
||||
+ gc->DrawEllipse(6, 8, 10, 13); // body (tapered upright)
|
||||
+ gc->DrawEllipse(7, 3, 8, 8); // head (wide)
|
||||
+ gc->DrawEllipse(7, 2.5, 2.6, 2.6); // ear L
|
||||
+ gc->DrawEllipse(12.4, 2.5, 2.6, 2.6);// ear R
|
||||
+ break;
|
||||
+ }
|
||||
+ case 4: { // hive (skep): three stacked bands narrowing upward + entrance
|
||||
+ gc->DrawRoundedRectangle(6, 2.5, 10, 4, 2);
|
||||
+ gc->DrawRoundedRectangle(4, 7, 14, 4, 2);
|
||||
+ gc->DrawRoundedRectangle(2.5, 11.5, 17, 5, 2.5);
|
||||
+ gc->SetBrush(wxBrush(dark));
|
||||
+ gc->SetPen(wxPen(dark, 1.0));
|
||||
+ gc->DrawEllipse(9.3, 13, 3.4, 3.6);
|
||||
+ break;
|
||||
+ }
|
||||
+ default: { // 5 lightning bolt
|
||||
+ wxGraphicsPath p = gc->CreatePath();
|
||||
+ p.MoveToPoint(13, 2);
|
||||
+ p.AddLineToPoint(5, 12);
|
||||
+ p.AddLineToPoint(10, 12);
|
||||
+ p.AddLineToPoint(8, 20);
|
||||
+ p.AddLineToPoint(17, 9);
|
||||
+ p.AddLineToPoint(11, 9);
|
||||
+ p.CloseSubpath();
|
||||
+ gc->FillPath(p);
|
||||
+ break;
|
||||
+ }
|
||||
+ }
|
||||
+ delete gc;
|
||||
+ }
|
||||
+ }
|
||||
+ return (void*)new wxStaticBitmap((wxWindow*)parent, wxID_ANY, bmp);
|
||||
+}
|
||||
+
|
||||
+// ---- live theme changes -----------------------------------------------------
|
||||
+
|
||||
+// Emit WxEV_SYS_COLOUR when the OS light/dark theme changes so the app can
|
||||
@@ -884,6 +1426,55 @@
|
||||
+ }
|
||||
+}
|
||||
+
|
||||
+// ---- status-bar error/warning indicator -------------------------------------
|
||||
+// A colour-tinted static text pinned to the RIGHT-hand field of the frame's
|
||||
+// status bar, so scan/apply errors surface in the bottom-right corner without
|
||||
+// overwriting the main (left) scan-status text. The status bar is reconfigured
|
||||
+// to two fields: field 0 (stretch) carries the scan status set via the upstream
|
||||
+// SetStatusText path; field 1 (fixed) hosts this coloured label, which we
|
||||
+// reposition into that field's rect whenever the bar is resized.
|
||||
+static wxStaticText* g_status_indicator = nullptr;
|
||||
+
|
||||
+static void reposition_status_indicator() {
|
||||
+ if (!g_status_indicator) return;
|
||||
+ wxStatusBar* sb = wxDynamicCast(g_status_indicator->GetParent(), wxStatusBar);
|
||||
+ if (!sb) return;
|
||||
+ wxRect r;
|
||||
+ if (!sb->GetFieldRect(1, r)) return;
|
||||
+ wxSize best = g_status_indicator->GetBestSize();
|
||||
+ int h = best.GetHeight();
|
||||
+ int y = r.y + (r.height - h) / 2;
|
||||
+ g_status_indicator->SetSize(r.x + 4, y, r.width - 8, h);
|
||||
+}
|
||||
+
|
||||
+void wxbr_status_indicator_init(void* frame_ptr) {
|
||||
+ wxFrame* frame = (wxFrame*)frame_ptr;
|
||||
+ wxStatusBar* sb = frame->GetStatusBar();
|
||||
+ if (!sb) sb = frame->CreateStatusBar();
|
||||
+ int widths[2] = { -1, 340 };
|
||||
+ sb->SetFieldsCount(2);
|
||||
+ sb->SetStatusWidths(2, widths);
|
||||
+ if (!g_status_indicator) {
|
||||
+ g_status_indicator = new wxStaticText(sb, wxID_ANY, wxEmptyString,
|
||||
+ wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT | wxST_NO_AUTORESIZE);
|
||||
+ sb->Bind(wxEVT_SIZE, [](wxSizeEvent& ev) {
|
||||
+ reposition_status_indicator();
|
||||
+ ev.Skip();
|
||||
+ });
|
||||
+ }
|
||||
+ reposition_status_indicator();
|
||||
+}
|
||||
+
|
||||
+// Set the bottom-right indicator text and its colour. An empty string clears it.
|
||||
+void wxbr_status_indicator_set(const char* text, int r, int g, int b) {
|
||||
+ if (!g_status_indicator) return;
|
||||
+ g_status_indicator->SetLabel(wxString::FromUTF8(text ? text : ""));
|
||||
+ g_status_indicator->SetForegroundColour(
|
||||
+ wxColour((unsigned char)r, (unsigned char)g, (unsigned char)b));
|
||||
+ reposition_status_indicator();
|
||||
+ g_status_indicator->Refresh();
|
||||
+}
|
||||
+
|
||||
+// ---- deferred destroy (safe from event handlers) ----------------------------
|
||||
+
|
||||
+void wxbr_destroy(void* win) { ((wxWindow*)win)->Destroy(); }
|
||||
|
||||
+608
-17
@@ -19,6 +19,7 @@
|
||||
#include <wx/utils.h>
|
||||
#include <wx/app.h>
|
||||
#include <wx/rearrangectrl.h>
|
||||
#include <wx/listctrl.h>
|
||||
#include <wx/menu.h>
|
||||
#include <wx/choice.h>
|
||||
#include <wx/bmpbuttn.h>
|
||||
@@ -29,13 +30,27 @@
|
||||
#include <wx/graphics.h>
|
||||
#include <wx/wrapsizer.h>
|
||||
#include <wx/filedlg.h>
|
||||
#include <wx/statusbr.h>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#ifdef __WXGTK__
|
||||
// For native GtkTreeView rubber-band (click-drag) selection, which wx does not
|
||||
// enable and which cannot be done via wx mouse events on GTK (the native widget
|
||||
// grabs the pointer during a drag). Guarded so non-GTK builds are unaffected.
|
||||
#include <gtk/gtk.h>
|
||||
#endif
|
||||
|
||||
typedef void (*WxWidgetEventFn)(int kind, long p1, long p2);
|
||||
static WxWidgetEventFn g_widget_event = nullptr;
|
||||
|
||||
#ifndef __WXGTK__
|
||||
// Anchor row per data-view control for the wx-mouse-event rubber-band fallback
|
||||
// (non-GTK platforms; GTK uses native GtkTreeView rubber-banding instead).
|
||||
static std::map<wxDataViewCtrl*, int> g_drag_anchor;
|
||||
#endif
|
||||
|
||||
// Event kinds (must match Rust WxEventKind in src/widgets.rs)
|
||||
enum WxWidgetEventKind {
|
||||
WxEV_BUTTON_CLICKED = 1,
|
||||
@@ -51,23 +66,36 @@ enum WxWidgetEventKind {
|
||||
WxEV_CHOICE_CHANGED = 12,
|
||||
WxEV_SYS_COLOUR = 13,
|
||||
WxEV_DEFERRED = 14,
|
||||
WxEV_DVLC_HEADER_RIGHT_CLICK = 15,
|
||||
WxEV_SIZE = 16, // p1 = new client width, p2 = new client height
|
||||
};
|
||||
|
||||
// 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
|
||||
// Per-cell hover tooltip text, keyed by (row, model column). Used for the
|
||||
// Errors column's full-message tooltip (see the GTK query-tooltip handler).
|
||||
std::map<std::pair<unsigned, unsigned>, wxString> cell_tip;
|
||||
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;
|
||||
}
|
||||
};
|
||||
|
||||
@@ -120,6 +148,57 @@ std::vector<ColorSegment> ParseColorSegments(const wxString& value) {
|
||||
return segs;
|
||||
}
|
||||
|
||||
// Shape sentinels a segment's text may carry instead of glyphs (round 11
|
||||
// #10/#13): a single control char selects a small vector icon drawn in the
|
||||
// segment's colour. These are control characters (never emoji/pictographs) so
|
||||
// they are safe in source and independent of the font's glyph coverage.
|
||||
const wxUniChar SHAPE_DOT = 0x07; // filled status dot (hashboards, locate light)
|
||||
const wxUniChar SHAPE_LOCK = 0x02; // closed padlock (locked / view-only)
|
||||
const wxUniChar SHAPE_UNLOCK = 0x03; // open padlock (unlocked / writable)
|
||||
const int SHAPE_ADVANCE = 15; // horizontal space one shape occupies
|
||||
|
||||
bool IsShapeSentinel(const wxString& s, wxUniChar& out) {
|
||||
if (s.length() != 1) return false;
|
||||
wxUniChar c = s[0];
|
||||
if (c == SHAPE_DOT || c == SHAPE_LOCK || c == SHAPE_UNLOCK) {
|
||||
out = c;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// Draw one shape sentinel, centred in the SHAPE_ADVANCE-wide slot at x.
|
||||
void DrawShape(wxDC* dc, wxUniChar shape, wxCoord x, const wxRect& cell, const wxColour& colour) {
|
||||
int cy = cell.y + cell.height / 2;
|
||||
int cx = x + SHAPE_ADVANCE / 2;
|
||||
if (shape == SHAPE_DOT) {
|
||||
dc->SetPen(*wxTRANSPARENT_PEN);
|
||||
dc->SetBrush(wxBrush(colour));
|
||||
dc->DrawCircle(cx, cy, 4);
|
||||
return;
|
||||
}
|
||||
// Padlock: a filled body with a staple shackle above. The colour carries the
|
||||
// state (green = unlocked, red = locked); the shackle is drawn ajar when open.
|
||||
bool open = (shape == SHAPE_UNLOCK);
|
||||
int bw = 9, bh = 7;
|
||||
int bx = cx - bw / 2;
|
||||
int by = cy - bh / 2 + 1;
|
||||
dc->SetPen(*wxTRANSPARENT_PEN);
|
||||
dc->SetBrush(wxBrush(colour));
|
||||
dc->DrawRoundedRectangle(bx, by, bw, bh, 1.5);
|
||||
dc->SetBrush(*wxTRANSPARENT_BRUSH);
|
||||
dc->SetPen(wxPen(colour, 2));
|
||||
int sr = 3;
|
||||
int legTop = by - sr - 1;
|
||||
int lx = cx - sr, rx = cx + sr;
|
||||
dc->DrawLine(lx, by, lx, legTop); // left leg
|
||||
dc->DrawLine(lx, legTop, rx, legTop); // top bar
|
||||
if (open)
|
||||
dc->DrawLine(rx, legTop, rx, legTop + sr); // ajar: right leg lifted
|
||||
else
|
||||
dc->DrawLine(rx, legTop, rx, by); // closed: right leg to body
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
class SegmentRenderer : public wxDataViewCustomRenderer {
|
||||
@@ -139,12 +218,59 @@ class SegmentRenderer : public wxDataViewCustomRenderer {
|
||||
|
||||
bool Render(wxRect cell, wxDC* dc, int state) override {
|
||||
bool selected = (state & wxDATAVIEW_CELL_SELECTED) != 0;
|
||||
// wxGTK does NOT paint a custom renderer's cell background, so the per-row
|
||||
// (zebra) background set via GetAttrByRow shows on the native columns but
|
||||
// not here -- the zebra looked inconsistent across columns. Paint it here so
|
||||
// every column stripes the same (skip when the row is selected: the control
|
||||
// already drew the selection highlight).
|
||||
if (!selected && GetAttr().HasBackgroundColour()) {
|
||||
dc->SetBrush(wxBrush(GetAttr().GetBackgroundColour()));
|
||||
dc->SetPen(*wxTRANSPARENT_PEN);
|
||||
// The `cell` rect wx hands a custom renderer is shrunk to the content
|
||||
// (text/shape) size by the alignment logic, so filling it alone left the
|
||||
// zebra covering only the text and looking inconsistent with the full-cell
|
||||
// native columns. Fill the whole column-wide cell instead; wxGTK clips the
|
||||
// cell DC to the visible cell area, so the over-wide rect lands exactly on
|
||||
// this cell without bleeding into the next column (round 11 #3).
|
||||
wxRect bg = cell;
|
||||
if (wxDataViewColumn* owner = const_cast<SegmentRenderer*>(this)->GetOwner()) {
|
||||
int cw = owner->GetWidth();
|
||||
if (cw > bg.width) bg.width = cw;
|
||||
}
|
||||
dc->DrawRectangle(bg);
|
||||
}
|
||||
wxColour highlight = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
|
||||
wxColour plain = GetAttr().HasColour()
|
||||
? GetAttr().GetColour()
|
||||
: wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
|
||||
// An uncoloured (default) segment -- the "/" in a combined cell, a "Stock"
|
||||
// firmware family, etc. -- must dim exactly like the native columns when the
|
||||
// top-level window is backdropped. wxGTK dims a native cell's text via the
|
||||
// widget's themed state colour, but a custom renderer's DC keeps the normal
|
||||
// WINDOWTEXT, so ask the tree widget for its themed text colour AT ITS
|
||||
// CURRENT STATE (which carries GTK_STATE_FLAG_BACKDROP while unfocused) and
|
||||
// use that; off-GTK (or if the widget isn't reachable) fall back to the DC
|
||||
// then the system colour (round 11 #1/#7).
|
||||
wxColour plain;
|
||||
if (GetAttr().HasColour()) {
|
||||
plain = GetAttr().GetColour();
|
||||
} else {
|
||||
plain = ThemedTextColour();
|
||||
}
|
||||
if (!plain.IsOk()) {
|
||||
plain = dc->GetTextForeground();
|
||||
}
|
||||
if (!plain.IsOk()) {
|
||||
plain = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
|
||||
}
|
||||
wxCoord x = cell.x;
|
||||
for (const ColorSegment& seg : ParseColorSegments(m_value)) {
|
||||
// Shape segments (status dots, access padlock) keep their own semantic
|
||||
// colour even on a selected row, so the green/red reading survives the
|
||||
// selection highlight (round 11 #10/#13).
|
||||
wxUniChar shape;
|
||||
if (IsShapeSentinel(seg.text, shape)) {
|
||||
DrawShape(dc, shape, x, cell, seg.has_colour ? seg.colour : plain);
|
||||
x += SHAPE_ADVANCE;
|
||||
continue;
|
||||
}
|
||||
if (seg.text.IsEmpty()) continue;
|
||||
dc->SetTextForeground(selected ? highlight : (seg.has_colour ? seg.colour : plain));
|
||||
wxSize extent = dc->GetTextExtent(seg.text);
|
||||
@@ -156,14 +282,49 @@ class SegmentRenderer : public wxDataViewCustomRenderer {
|
||||
}
|
||||
|
||||
wxSize GetSize() const override {
|
||||
wxString plain;
|
||||
for (const ColorSegment& seg : ParseColorSegments(m_value)) plain += seg.text;
|
||||
wxSize sz = GetTextExtent(plain);
|
||||
if (sz.GetWidth() < 1) sz.SetWidth(1);
|
||||
return sz;
|
||||
int w = 0, h = 0;
|
||||
for (const ColorSegment& seg : ParseColorSegments(m_value)) {
|
||||
wxUniChar shape;
|
||||
if (IsShapeSentinel(seg.text, shape)) {
|
||||
w += SHAPE_ADVANCE;
|
||||
if (h < 12) h = 12;
|
||||
continue;
|
||||
}
|
||||
wxSize e = GetTextExtent(seg.text);
|
||||
w += e.GetWidth();
|
||||
if (e.GetHeight() > h) h = e.GetHeight();
|
||||
}
|
||||
if (w < 1) w = 1;
|
||||
if (h < 1) h = 1;
|
||||
return wxSize(w, h);
|
||||
}
|
||||
|
||||
private:
|
||||
// The owning tree widget's themed text colour at its current GTK state, so
|
||||
// uncoloured segments dim on window-backdrop like the native columns
|
||||
// (round 11 #1/#7). Returns an invalid colour off wxGTK or when the widget is
|
||||
// unreachable, so the caller falls back to the DC / system colour.
|
||||
wxColour ThemedTextColour() const {
|
||||
#ifdef __WXGTK__
|
||||
wxDataViewColumn* col = const_cast<SegmentRenderer*>(this)->GetOwner();
|
||||
if (col && col->GetOwner()) {
|
||||
GtkWidget* tv = col->GetOwner()->GtkGetTreeView();
|
||||
if (tv && GTK_IS_WIDGET(tv)) {
|
||||
GtkStyleContext* ctx = gtk_widget_get_style_context(tv);
|
||||
GtkStateFlags st = gtk_widget_get_state_flags(tv);
|
||||
GdkRGBA c;
|
||||
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
|
||||
gtk_style_context_get_color(ctx, st, &c);
|
||||
G_GNUC_END_IGNORE_DEPRECATIONS
|
||||
return wxColour((unsigned char)(c.red * 255.0 + 0.5),
|
||||
(unsigned char)(c.green * 255.0 + 0.5),
|
||||
(unsigned char)(c.blue * 255.0 + 0.5));
|
||||
}
|
||||
}
|
||||
#endif
|
||||
return wxColour();
|
||||
}
|
||||
|
||||
wxString m_value;
|
||||
};
|
||||
|
||||
@@ -188,7 +349,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):
|
||||
@@ -241,6 +406,23 @@ void wxbr_sizer_detach(void* sizer, void* win) {
|
||||
((wxSizer*)sizer)->Detach((wxWindow*)win);
|
||||
}
|
||||
|
||||
// Show or hide a sizer-managed child window AND reclaim (or restore) its space
|
||||
// on the next Layout(). Used to collapse the wide KPI cards when the window is
|
||||
// too narrow (round 11 #2).
|
||||
void wxbr_sizer_show(void* sizer, void* win, int show) {
|
||||
((wxSizer*)sizer)->Show((wxWindow*)win, show != 0);
|
||||
}
|
||||
|
||||
// Emit WxEV_SIZE (p1 = new client width, p2 = height) whenever this window is
|
||||
// resized. e.Skip() keeps the normal sizer layout running (round 11 #2).
|
||||
void wxbr_bind_size(void* win) {
|
||||
((wxWindow*)win)->Bind(wxEVT_SIZE, [](wxSizeEvent& e) {
|
||||
if (g_widget_event) g_widget_event(WxEV_SIZE, (long)e.GetSize().GetWidth(),
|
||||
(long)e.GetSize().GetHeight());
|
||||
e.Skip();
|
||||
});
|
||||
}
|
||||
|
||||
void wxbr_fit(void* win) { ((wxWindow*)win)->Fit(); }
|
||||
|
||||
void wxbr_set_min_size(void* win, int w, int h) {
|
||||
@@ -433,13 +615,44 @@ static AttrListStore* dvlc_store(void* win) {
|
||||
return static_cast<AttrListStore*>(((wxDataViewCtrl*)win)->GetModel());
|
||||
}
|
||||
|
||||
#ifdef __WXGTK__
|
||||
// GtkTreeView "query-tooltip" handler: show the per-cell tooltip stored for the
|
||||
// (row, model column) under the pointer (used by the Errors column). wx does
|
||||
// not surface per-cell tooltips on wxDataViewCtrl, and mouse-motion events are
|
||||
// not delivered to wx handlers on the native GTK control, so this hooks the
|
||||
// native signal directly.
|
||||
static gboolean dvlc_query_tooltip(GtkWidget* tv, gint x, gint y, gboolean keyboard,
|
||||
GtkTooltip* tooltip, gpointer user_data) {
|
||||
(void)keyboard;
|
||||
wxDataViewCtrl* dv = static_cast<wxDataViewCtrl*>(user_data);
|
||||
gint bx = 0, by = 0;
|
||||
gtk_tree_view_convert_widget_to_bin_window_coords(GTK_TREE_VIEW(tv), x, y, &bx, &by);
|
||||
GtkTreePath* path = nullptr;
|
||||
GtkTreeViewColumn* gcol = nullptr;
|
||||
if (!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(tv), bx, by, &path, &gcol, nullptr, nullptr))
|
||||
return FALSE;
|
||||
gint* idx = gtk_tree_path_get_indices(path);
|
||||
int row = idx ? idx[0] : -1;
|
||||
gtk_tree_path_free(path);
|
||||
if (row < 0 || !gcol) return FALSE;
|
||||
wxDataViewColumn* wxcol = dv->GTKColumnToWX(gcol);
|
||||
if (!wxcol) return FALSE;
|
||||
AttrListStore* store = static_cast<AttrListStore*>(dv->GetModel());
|
||||
auto it = store->cell_tip.find({(unsigned)row, wxcol->GetModelColumn()});
|
||||
if (it == store->cell_tip.end() || it->second.IsEmpty()) return FALSE;
|
||||
gtk_tooltip_set_text(tooltip, it->second.utf8_str());
|
||||
return TRUE;
|
||||
}
|
||||
#endif
|
||||
|
||||
void* wxbr_dvlc(void* parent) {
|
||||
// Multi-select (ctrl/shift-click) + row lines. Selection replaces the old
|
||||
// checkbox column. A custom AttrListStore backs it so rows can be coloured by
|
||||
// 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 +675,73 @@ 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.
|
||||
#ifdef __WXGTK__
|
||||
// On GTK the control wraps a GtkTreeView, which supports native rubber-band
|
||||
// selection -- just not enabled by wx. Enable it directly. (wx delivers no
|
||||
// MOTION events during the native drag, so the mouse-event fallback below is
|
||||
// inapplicable on GTK.)
|
||||
{
|
||||
GtkWidget* tv = dv->GtkGetTreeView();
|
||||
if (tv) {
|
||||
gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(tv), TRUE);
|
||||
// Per-cell hover tooltips (Errors column) via the native signal.
|
||||
gtk_widget_set_has_tooltip(tv, TRUE);
|
||||
g_signal_connect(tv, "query-tooltip", G_CALLBACK(dvlc_query_tooltip), dv);
|
||||
}
|
||||
}
|
||||
#else
|
||||
// Non-GTK fallback: track a drag anchor and extend the selection to the row
|
||||
// under the cursor. LEFT_DOWN records the anchor (and lets the native handler
|
||||
// select it); dragging with the button down selects the inclusive range.
|
||||
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();
|
||||
});
|
||||
#endif
|
||||
// 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) {
|
||||
@@ -536,6 +813,18 @@ void wxbr_dvlc_clear(void* win) {
|
||||
AttrListStore* store = dvlc_store(win);
|
||||
store->DeleteAllItems();
|
||||
store->row_fg.clear();
|
||||
store->cell_tip.clear();
|
||||
}
|
||||
|
||||
// Set (or clear, with an empty string) the hover tooltip for one cell,
|
||||
// addressed by (row, model column). Used for the Errors column's full text.
|
||||
void wxbr_dvlc_set_cell_tooltip(void* win, unsigned row, unsigned col, const char* text) {
|
||||
AttrListStore* store = dvlc_store(win);
|
||||
if (text && text[0]) {
|
||||
store->cell_tip[{row, col}] = wxString::FromUTF8(text);
|
||||
} else {
|
||||
store->cell_tip.erase({row, col});
|
||||
}
|
||||
}
|
||||
|
||||
// Set (or clear, when r<0) a row's text colour; used to paint rows by status.
|
||||
@@ -546,6 +835,31 @@ 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 -- GetItem()
|
||||
// itself asserts on row >= count, so the bound MUST be checked before calling.
|
||||
void wxbr_dvlc_ensure_visible(void* win, unsigned row) {
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
if (row >= (unsigned)dvlc_store(win)->GetItemCount()) return;
|
||||
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 +890,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) {
|
||||
@@ -605,6 +927,25 @@ int wxbr_dvlc_col_at_pos(void* win, int pos) {
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
unsigned n = dv->GetColumnCount();
|
||||
if (pos < 0 || (unsigned)pos >= n) return -1;
|
||||
#ifdef __WXGTK__
|
||||
// wxGTK's GetColumnPosition() does NOT reflect a native GtkTreeView column
|
||||
// drag, so after the user reorders columns it reports the creation order and
|
||||
// the reorder is silently lost. Read the real display order from the
|
||||
// GtkTreeView instead, then map the column back to its wx creation index.
|
||||
GtkWidget* tvw = dv->GtkGetTreeView();
|
||||
if (tvw) {
|
||||
GList* cols = gtk_tree_view_get_columns(GTK_TREE_VIEW(tvw)); // display order
|
||||
GtkTreeViewColumn* gcol = (GtkTreeViewColumn*)g_list_nth_data(cols, (guint)pos);
|
||||
g_list_free(cols);
|
||||
if (gcol) {
|
||||
wxDataViewColumn* wxcol = dv->GTKColumnToWX(gcol);
|
||||
for (unsigned i = 0; i < n; i++) {
|
||||
if (dv->GetColumn(i) == wxcol) return (int)i;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
#endif
|
||||
for (unsigned i = 0; i < n; i++) {
|
||||
wxDataViewColumn* c = dv->GetColumn(i);
|
||||
if (c && dv->GetColumnPosition(c) == (unsigned)pos) return (int)i;
|
||||
@@ -636,9 +977,11 @@ int wxbr_dvlc_get_selections(void* win, int* buf, int cap) {
|
||||
void wxbr_dvlc_select_rows(void* win, const int* rows, int n) {
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
wxDataViewIndexListModel* m = (wxDataViewIndexListModel*)dv->GetModel();
|
||||
int count = (int)dvlc_store(win)->GetItemCount();
|
||||
dv->UnselectAll();
|
||||
for (int i = 0; i < n; i++) {
|
||||
if (rows[i] >= 0) dv->Select(m->GetItem((unsigned)rows[i]));
|
||||
// GetItem() asserts on an out-of-range row, so bound both ends.
|
||||
if (rows[i] >= 0 && rows[i] < count) dv->Select(m->GetItem((unsigned)rows[i]));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -657,6 +1000,7 @@ void wxbr_dvlc_select_row(void* win, long row) {
|
||||
if (row < 0) return;
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
wxDataViewIndexListModel* m = (wxDataViewIndexListModel*)dv->GetModel();
|
||||
if (row >= (long)dvlc_store(win)->GetItemCount()) return;
|
||||
dv->Select(m->GetItem((unsigned)row));
|
||||
}
|
||||
|
||||
@@ -767,6 +1111,109 @@ int wxbr_rearrange_get_order(void* win, int* buf, int cap) {
|
||||
return n < cap ? n : cap;
|
||||
}
|
||||
|
||||
// ---- reorder list: a checkable, multi-select, drag-reorderable column list
|
||||
// for the Columns dialog (round 11 #4). Replaces wxRearrangeCtrl (which had
|
||||
// up/down buttons and no drag / multi-select). It is a single-column headerless
|
||||
// wxListCtrl with native checkboxes; rows carry their base model index as item
|
||||
// data, and the check state + row order encode the same [idx | ~idx] contract
|
||||
// as wxbr_rearrange_get_order. Selection (shift/ctrl-click, rubber-band drag) is
|
||||
// native to wxListCtrl. Drag-reorder: on begin-drag we record the selected rows'
|
||||
// base indices, and on the following mouse-up we move that group to the row
|
||||
// under the cursor (we never start a real DnD loop, so the mouse-up still
|
||||
// arrives).
|
||||
static wxVector<long> g_reorder_drag;
|
||||
static wxListCtrl* g_reorder_list = nullptr;
|
||||
|
||||
void* wxbr_reorder_list(void* parent, int n, const int* order, const char** items) {
|
||||
wxListCtrl* lc = new wxListCtrl((wxWindow*)parent, wxID_ANY, wxDefaultPosition,
|
||||
wxSize(-1, 240), wxLC_REPORT | wxLC_NO_HEADER);
|
||||
lc->EnableCheckBoxes(true);
|
||||
lc->InsertColumn(0, wxT("Column"), wxLIST_FORMAT_LEFT, 260);
|
||||
for (int i = 0; i < n; i++) {
|
||||
int enc = order[i];
|
||||
int idx = enc < 0 ? ~enc : enc;
|
||||
long row = lc->InsertItem(i, wxString::FromUTF8(items[idx]));
|
||||
lc->SetItemData(row, (long)idx);
|
||||
lc->CheckItem(row, enc >= 0);
|
||||
}
|
||||
lc->Bind(wxEVT_LIST_BEGIN_DRAG, [lc](wxListEvent&) {
|
||||
g_reorder_drag.clear();
|
||||
g_reorder_list = lc;
|
||||
long it = -1;
|
||||
for (;;) {
|
||||
it = lc->GetNextItem(it, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
|
||||
if (it == -1) break;
|
||||
g_reorder_drag.push_back(lc->GetItemData(it));
|
||||
}
|
||||
});
|
||||
lc->Bind(wxEVT_LEFT_UP, [lc](wxMouseEvent& e) {
|
||||
e.Skip();
|
||||
if (g_reorder_list != lc || g_reorder_drag.empty()) return;
|
||||
struct Row {
|
||||
long data;
|
||||
bool checked;
|
||||
wxString text;
|
||||
};
|
||||
int count = lc->GetItemCount();
|
||||
wxVector<Row> rows;
|
||||
for (int i = 0; i < count; i++) {
|
||||
Row r;
|
||||
r.data = lc->GetItemData(i);
|
||||
r.checked = lc->IsItemChecked(i);
|
||||
r.text = lc->GetItemText(i);
|
||||
rows.push_back(r);
|
||||
}
|
||||
auto isDragged = [](long d) {
|
||||
for (size_t i = 0; i < g_reorder_drag.size(); i++)
|
||||
if (g_reorder_drag[i] == d) return true;
|
||||
return false;
|
||||
};
|
||||
int flags = 0;
|
||||
long targetRow = lc->HitTest(e.GetPosition(), flags);
|
||||
long anchor = (targetRow >= 0 && targetRow < count) ? rows[targetRow].data : -1;
|
||||
if (anchor >= 0 && isDragged(anchor)) anchor = -1;
|
||||
wxVector<Row> remaining, moved;
|
||||
for (size_t i = 0; i < rows.size(); i++) {
|
||||
if (isDragged(rows[i].data))
|
||||
moved.push_back(rows[i]);
|
||||
else
|
||||
remaining.push_back(rows[i]);
|
||||
}
|
||||
int insertAt = (int)remaining.size();
|
||||
if (anchor >= 0) {
|
||||
for (size_t i = 0; i < remaining.size(); i++)
|
||||
if (remaining[i].data == anchor) {
|
||||
insertAt = (int)i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
wxVector<Row> result;
|
||||
for (int i = 0; i < insertAt; i++) result.push_back(remaining[i]);
|
||||
for (size_t i = 0; i < moved.size(); i++) result.push_back(moved[i]);
|
||||
for (int i = insertAt; i < (int)remaining.size(); i++) result.push_back(remaining[i]);
|
||||
lc->DeleteAllItems();
|
||||
for (size_t i = 0; i < result.size(); i++) {
|
||||
long row = lc->InsertItem((long)i, result[i].text);
|
||||
lc->SetItemData(row, result[i].data);
|
||||
lc->CheckItem(row, result[i].checked);
|
||||
}
|
||||
g_reorder_drag.clear();
|
||||
g_reorder_list = nullptr;
|
||||
});
|
||||
return (void*)lc;
|
||||
}
|
||||
|
||||
int wxbr_reorder_get_order(void* win, int* buf, int cap) {
|
||||
wxListCtrl* lc = (wxListCtrl*)win;
|
||||
int count = lc->GetItemCount();
|
||||
int n = 0;
|
||||
for (int i = 0; i < count && n < cap; i++) {
|
||||
int idx = (int)lc->GetItemData(i);
|
||||
buf[n++] = lc->IsItemChecked(i) ? idx : ~idx;
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
// ---- popup menu (right-click context menu) ----------------------------------
|
||||
|
||||
void* wxbr_menu_new() { return (void*)new wxMenu(); }
|
||||
@@ -859,6 +1306,101 @@ void* wxbr_media_button(void* parent, int id, int kind, int r, int g, int b) {
|
||||
return (void*)btn;
|
||||
}
|
||||
|
||||
// A small vector icon drawn into a transparent bitmap and wrapped in a
|
||||
// wxStaticBitmap, for the KPI cards (round 11 #15). kind: 0 rabbit (hashing),
|
||||
// 1 turtle (slow), 2 broken wine glass (not hashing), 3 otter (paused),
|
||||
// 4 hive (hashrate), 5 lightning bolt (power). Drawn as simple silhouettes so
|
||||
// they read at ~22px; the colour matches the card's value colour.
|
||||
void* wxbr_kpi_icon(void* parent, int kind, int r, int g, int b) {
|
||||
const int sz = 22;
|
||||
wxImage img(sz, sz);
|
||||
img.InitAlpha();
|
||||
unsigned char* a = img.GetAlpha();
|
||||
if (a) memset(a, 0, (size_t)sz * sz);
|
||||
wxBitmap bmp(img);
|
||||
{
|
||||
wxMemoryDC mdc(bmp);
|
||||
wxGraphicsContext* gc = wxGraphicsContext::Create(mdc);
|
||||
if (gc) {
|
||||
gc->SetAntialiasMode(wxANTIALIAS_DEFAULT);
|
||||
wxColour col(r, g, b);
|
||||
wxColour dark((unsigned char)(r * 0.5), (unsigned char)(g * 0.5), (unsigned char)(b * 0.5));
|
||||
gc->SetBrush(wxBrush(col));
|
||||
gc->SetPen(wxPen(col, 1.0));
|
||||
switch (kind) {
|
||||
case 0: { // rabbit: low haunch body + head + two long spread ears
|
||||
gc->DrawEllipse(4, 12, 14, 8); // haunch (low, wide)
|
||||
gc->DrawEllipse(6.5, 7, 8, 8); // head
|
||||
gc->DrawEllipse(6, 0, 2.6, 9); // left ear (long)
|
||||
gc->DrawEllipse(12, 0, 2.6, 9); // right ear (long, spread)
|
||||
break;
|
||||
}
|
||||
case 1: { // turtle: wide shell + head + two visible legs
|
||||
gc->DrawEllipse(4, 6, 13, 9);
|
||||
gc->DrawEllipse(15.5, 8, 4.5, 4.5); // head
|
||||
gc->DrawEllipse(4.5, 12.5, 4, 4); // front leg
|
||||
gc->DrawEllipse(11, 12.5, 4, 4); // back leg
|
||||
break;
|
||||
}
|
||||
case 2: { // broken wine glass: bowl + stem + base, with a crack
|
||||
wxGraphicsPath bowl = gc->CreatePath();
|
||||
bowl.MoveToPoint(5, 3);
|
||||
bowl.AddLineToPoint(17, 3);
|
||||
bowl.AddLineToPoint(11, 12);
|
||||
bowl.CloseSubpath();
|
||||
gc->FillPath(bowl);
|
||||
gc->DrawRectangle(10.2, 12, 1.6, 6);
|
||||
gc->DrawRoundedRectangle(7, 18, 8, 2, 1);
|
||||
wxGraphicsPath crack = gc->CreatePath(); // jagged crack across the bowl
|
||||
crack.MoveToPoint(11, 3);
|
||||
crack.AddLineToPoint(9, 6);
|
||||
crack.AddLineToPoint(12.5, 8);
|
||||
crack.AddLineToPoint(10.5, 11.5);
|
||||
gc->SetPen(wxPen(dark, 1.4));
|
||||
gc->StrokePath(crack);
|
||||
break;
|
||||
}
|
||||
case 3: { // otter: upright tapered body + head + small ears + thick tail
|
||||
wxGraphicsPath tail = gc->CreatePath(); // thick tapering tail curving right
|
||||
tail.MoveToPoint(13, 17);
|
||||
tail.AddCurveToPoint(19, 16, 21, 20, 19, 21);
|
||||
tail.AddCurveToPoint(17, 21, 15, 20, 12, 19);
|
||||
tail.CloseSubpath();
|
||||
gc->FillPath(tail);
|
||||
gc->DrawEllipse(6, 8, 10, 13); // body (tapered upright)
|
||||
gc->DrawEllipse(7, 3, 8, 8); // head (wide)
|
||||
gc->DrawEllipse(7, 2.5, 2.6, 2.6); // ear L
|
||||
gc->DrawEllipse(12.4, 2.5, 2.6, 2.6);// ear R
|
||||
break;
|
||||
}
|
||||
case 4: { // hive (skep): three stacked bands narrowing upward + entrance
|
||||
gc->DrawRoundedRectangle(6, 2.5, 10, 4, 2);
|
||||
gc->DrawRoundedRectangle(4, 7, 14, 4, 2);
|
||||
gc->DrawRoundedRectangle(2.5, 11.5, 17, 5, 2.5);
|
||||
gc->SetBrush(wxBrush(dark));
|
||||
gc->SetPen(wxPen(dark, 1.0));
|
||||
gc->DrawEllipse(9.3, 13, 3.4, 3.6);
|
||||
break;
|
||||
}
|
||||
default: { // 5 lightning bolt
|
||||
wxGraphicsPath p = gc->CreatePath();
|
||||
p.MoveToPoint(13, 2);
|
||||
p.AddLineToPoint(5, 12);
|
||||
p.AddLineToPoint(10, 12);
|
||||
p.AddLineToPoint(8, 20);
|
||||
p.AddLineToPoint(17, 9);
|
||||
p.AddLineToPoint(11, 9);
|
||||
p.CloseSubpath();
|
||||
gc->FillPath(p);
|
||||
break;
|
||||
}
|
||||
}
|
||||
delete gc;
|
||||
}
|
||||
}
|
||||
return (void*)new wxStaticBitmap((wxWindow*)parent, wxID_ANY, bmp);
|
||||
}
|
||||
|
||||
// ---- live theme changes -----------------------------------------------------
|
||||
|
||||
// Emit WxEV_SYS_COLOUR when the OS light/dark theme changes so the app can
|
||||
@@ -881,6 +1423,55 @@ void wxbr_call_after(int id) {
|
||||
}
|
||||
}
|
||||
|
||||
// ---- status-bar error/warning indicator -------------------------------------
|
||||
// A colour-tinted static text pinned to the RIGHT-hand field of the frame's
|
||||
// status bar, so scan/apply errors surface in the bottom-right corner without
|
||||
// overwriting the main (left) scan-status text. The status bar is reconfigured
|
||||
// to two fields: field 0 (stretch) carries the scan status set via the upstream
|
||||
// SetStatusText path; field 1 (fixed) hosts this coloured label, which we
|
||||
// reposition into that field's rect whenever the bar is resized.
|
||||
static wxStaticText* g_status_indicator = nullptr;
|
||||
|
||||
static void reposition_status_indicator() {
|
||||
if (!g_status_indicator) return;
|
||||
wxStatusBar* sb = wxDynamicCast(g_status_indicator->GetParent(), wxStatusBar);
|
||||
if (!sb) return;
|
||||
wxRect r;
|
||||
if (!sb->GetFieldRect(1, r)) return;
|
||||
wxSize best = g_status_indicator->GetBestSize();
|
||||
int h = best.GetHeight();
|
||||
int y = r.y + (r.height - h) / 2;
|
||||
g_status_indicator->SetSize(r.x + 4, y, r.width - 8, h);
|
||||
}
|
||||
|
||||
void wxbr_status_indicator_init(void* frame_ptr) {
|
||||
wxFrame* frame = (wxFrame*)frame_ptr;
|
||||
wxStatusBar* sb = frame->GetStatusBar();
|
||||
if (!sb) sb = frame->CreateStatusBar();
|
||||
int widths[2] = { -1, 340 };
|
||||
sb->SetFieldsCount(2);
|
||||
sb->SetStatusWidths(2, widths);
|
||||
if (!g_status_indicator) {
|
||||
g_status_indicator = new wxStaticText(sb, wxID_ANY, wxEmptyString,
|
||||
wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT | wxST_NO_AUTORESIZE);
|
||||
sb->Bind(wxEVT_SIZE, [](wxSizeEvent& ev) {
|
||||
reposition_status_indicator();
|
||||
ev.Skip();
|
||||
});
|
||||
}
|
||||
reposition_status_indicator();
|
||||
}
|
||||
|
||||
// Set the bottom-right indicator text and its colour. An empty string clears it.
|
||||
void wxbr_status_indicator_set(const char* text, int r, int g, int b) {
|
||||
if (!g_status_indicator) return;
|
||||
g_status_indicator->SetLabel(wxString::FromUTF8(text ? text : ""));
|
||||
g_status_indicator->SetForegroundColour(
|
||||
wxColour((unsigned char)r, (unsigned char)g, (unsigned char)b));
|
||||
reposition_status_indicator();
|
||||
g_status_indicator->Refresh();
|
||||
}
|
||||
|
||||
// ---- deferred destroy (safe from event handlers) ----------------------------
|
||||
|
||||
void wxbr_destroy(void* win) { ((wxWindow*)win)->Destroy(); }
|
||||
|
||||
+112
@@ -23,6 +23,8 @@ mod notsafe {
|
||||
pub fn wxbr_set_sizer(win: *mut c_void, sizer: *mut c_void);
|
||||
pub fn wxbr_layout(win: *mut c_void);
|
||||
pub fn wxbr_sizer_detach(sizer: *mut c_void, win: *mut c_void);
|
||||
pub fn wxbr_sizer_show(sizer: *mut c_void, win: *mut c_void, show: c_int);
|
||||
pub fn wxbr_bind_size(win: *mut c_void);
|
||||
pub fn wxbr_fit(win: *mut c_void);
|
||||
pub fn wxbr_set_min_size(win: *mut c_void, w: c_int, h: c_int);
|
||||
pub fn wxbr_static_text(parent: *mut c_void, label: *const c_char) -> *mut c_void;
|
||||
@@ -58,8 +60,10 @@ mod notsafe {
|
||||
pub fn wxbr_dvlc_clear(win: *mut c_void);
|
||||
pub fn wxbr_dvlc_row_count(win: *mut c_void) -> c_int;
|
||||
pub fn wxbr_dvlc_set_cell(win: *mut c_void, row: usize, col: usize, value: *const c_char);
|
||||
pub fn wxbr_dvlc_set_cell_tooltip(win: *mut c_void, row: usize, col: usize, text: *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,9 +73,14 @@ 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;
|
||||
pub fn wxbr_reorder_list(parent: *mut c_void, n: c_int, order: *const c_int, items: *const *const c_char) -> *mut c_void;
|
||||
pub fn wxbr_reorder_get_order(win: *mut c_void, buf: *mut c_int, cap: c_int) -> c_int;
|
||||
pub fn wxbr_menu_new() -> *mut c_void;
|
||||
pub fn wxbr_menu_append(menu: *mut c_void, id: c_int, label: *const c_char);
|
||||
pub fn wxbr_menu_append_separator(menu: *mut c_void);
|
||||
@@ -94,10 +103,13 @@ mod notsafe {
|
||||
pub fn wxbr_choice_get_selection(win: *mut c_void) -> c_int;
|
||||
pub fn wxbr_choice_set_selection(win: *mut c_void, i: c_int);
|
||||
pub fn wxbr_media_button(parent: *mut c_void, id: c_int, kind: c_int, r: c_int, g: c_int, b: c_int) -> *mut c_void;
|
||||
pub fn wxbr_kpi_icon(parent: *mut c_void, kind: c_int, r: c_int, g: c_int, b: c_int) -> *mut c_void;
|
||||
pub fn wxbr_bind_sys_colour(win: *mut c_void);
|
||||
pub fn wxbr_destroy(win: *mut c_void);
|
||||
pub fn wxbr_destroy_children(win: *mut c_void);
|
||||
pub fn wxbr_call_after(id: c_int);
|
||||
pub fn wxbr_status_indicator_init(frame: *mut c_void);
|
||||
pub fn wxbr_status_indicator_set(text: *const c_char, r: c_int, g: c_int, b: c_int);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -133,6 +145,9 @@ pub enum WxEventKind {
|
||||
ChoiceChanged,
|
||||
SysColour,
|
||||
Deferred,
|
||||
DvlcHeaderRightClick,
|
||||
/// Window resized; p1 = new client width, p2 = new client height.
|
||||
Sized,
|
||||
}
|
||||
|
||||
impl WxEventKind {
|
||||
@@ -151,6 +166,8 @@ impl WxEventKind {
|
||||
12 => WxEventKind::ChoiceChanged,
|
||||
13 => WxEventKind::SysColour,
|
||||
14 => WxEventKind::Deferred,
|
||||
15 => WxEventKind::DvlcHeaderRightClick,
|
||||
16 => WxEventKind::Sized,
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
@@ -168,6 +185,21 @@ pub fn call_after(id: i32) {
|
||||
unsafe { notsafe::wxbr_call_after(id as c_int) }
|
||||
}
|
||||
|
||||
/// Reconfigure the frame's status bar to two fields and attach a colour-tinted
|
||||
/// label pinned to the right-hand field (bottom-right corner). Call once after
|
||||
/// `create_status_bar()`. The main scan status keeps using the left field via
|
||||
/// the upstream `set_status_text` path.
|
||||
pub fn status_indicator_init(frame: Widget) {
|
||||
unsafe { notsafe::wxbr_status_indicator_init(frame.0) }
|
||||
}
|
||||
|
||||
/// Set the bottom-right status indicator's text and colour (an empty string
|
||||
/// clears it). Used for scan/apply errors (red) and warnings (amber).
|
||||
pub fn status_indicator_set(text: &str, r: u8, g: u8, b: u8) {
|
||||
let c = CString::new(text).unwrap_or_default();
|
||||
unsafe { notsafe::wxbr_status_indicator_set(c.as_ptr(), r as c_int, g as c_int, b as c_int) }
|
||||
}
|
||||
|
||||
/// Open a URL in the system default browser. Returns true on success.
|
||||
pub fn launch_browser(url: &str) -> bool {
|
||||
let c = CString::new(url).unwrap_or_default();
|
||||
@@ -284,6 +316,18 @@ impl Widget {
|
||||
unsafe { notsafe::wxbr_sizer_detach(self.0, win.0) }
|
||||
}
|
||||
|
||||
/// Show or hide a child window in this sizer (self = a sizer), reclaiming or
|
||||
/// restoring its space on the next `layout()`.
|
||||
pub fn sizer_show(&self, win: Widget, show: bool) {
|
||||
unsafe { notsafe::wxbr_sizer_show(self.0, win.0, show as c_int) }
|
||||
}
|
||||
|
||||
/// Emit `WxEventKind::Sized` (p1 = width, p2 = height) whenever this window
|
||||
/// is resized.
|
||||
pub fn bind_size(&self) {
|
||||
unsafe { notsafe::wxbr_bind_size(self.0) }
|
||||
}
|
||||
|
||||
pub fn fit(&self, win: Widget) {
|
||||
unsafe { notsafe::wxbr_fit(win.0) }
|
||||
}
|
||||
@@ -476,6 +520,13 @@ impl Widget {
|
||||
unsafe { notsafe::wxbr_dvlc_set_cell(self.0, row, col, c.as_ptr()) }
|
||||
}
|
||||
|
||||
/// Set the hover tooltip for one cell (empty clears it). GTK only; a no-op
|
||||
/// on other platforms until they gain per-cell tooltip support.
|
||||
pub fn dvlc_set_cell_tooltip(&self, row: usize, col: usize, text: &str) {
|
||||
let c = CString::new(text).unwrap_or_default();
|
||||
unsafe { notsafe::wxbr_dvlc_set_cell_tooltip(self.0, row, col, c.as_ptr()) }
|
||||
}
|
||||
|
||||
pub fn dvlc_get_cell(&self, row: usize, col: usize) -> Option<String> {
|
||||
let mut buf = vec![0i8; 4096];
|
||||
let n = unsafe {
|
||||
@@ -492,6 +543,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 +591,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`
|
||||
@@ -556,6 +633,27 @@ impl Widget {
|
||||
buf.into_iter().take(n.max(0) as usize).collect()
|
||||
}
|
||||
|
||||
/// A checkable, multi-select, drag-reorderable column list (round 11 #4):
|
||||
/// like `rearrange_list` but with no up/down buttons -- rows are reordered by
|
||||
/// dragging, and selected with shift/ctrl-click or a rubber-band drag. Same
|
||||
/// `[idx | !idx]` order encoding.
|
||||
pub fn reorder_list(parent: Widget, order: &[i32], items: &[&str]) -> Widget {
|
||||
let cs: Vec<CString> = items.iter().map(|s| CString::new(*s).unwrap_or_default()).collect();
|
||||
let ptrs: Vec<*const c_char> = cs.iter().map(|c| c.as_ptr()).collect();
|
||||
Widget(unsafe {
|
||||
notsafe::wxbr_reorder_list(parent.0, items.len() as c_int, order.as_ptr(), ptrs.as_ptr())
|
||||
})
|
||||
}
|
||||
|
||||
/// Read back the current order from a `reorder_list` (same encoding).
|
||||
pub fn reorder_get_order(&self) -> Vec<i32> {
|
||||
let mut buf = vec![0i32; 4096];
|
||||
let n = unsafe {
|
||||
notsafe::wxbr_reorder_get_order(self.0, buf.as_mut_ptr(), buf.len() as c_int)
|
||||
};
|
||||
buf.into_iter().take(n.max(0) as usize).collect()
|
||||
}
|
||||
|
||||
// ---- popup menu ----
|
||||
|
||||
pub fn menu_new() -> Widget {
|
||||
@@ -670,6 +768,20 @@ impl Widget {
|
||||
})
|
||||
}
|
||||
|
||||
/// A small drawn KPI icon (static bitmap). kind: 0 rabbit, 1 turtle,
|
||||
/// 2 broken wine glass, 3 otter, 4 hive, 5 lightning bolt (round 11 #15).
|
||||
pub fn kpi_icon(parent: Widget, kind: i32, color: (u8, u8, u8)) -> Widget {
|
||||
Widget(unsafe {
|
||||
notsafe::wxbr_kpi_icon(
|
||||
parent.0,
|
||||
kind,
|
||||
color.0 as c_int,
|
||||
color.1 as c_int,
|
||||
color.2 as c_int,
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
/// Listen for OS light/dark theme changes on this window (emits `SysColour`).
|
||||
pub fn bind_sys_colour(&self) {
|
||||
unsafe { notsafe::wxbr_bind_sys_colour(self.0) }
|
||||
|
||||
+1
-1
@@ -1 +1 @@
|
||||
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"6e42d50107b1a43fd7cf4a4c4f538468a337ed219ad8d6b23bd9abdabd123bd5","Cargo.lock":"7f984c7231c91f2def8f3e2e923a85c2e0b3239492f5ce23400881ea4de1aa16","Cargo.toml":"8a447efc18cd97d019a9771fb258b06f694499500561564eec75480e46bcc554","Cargo.toml.orig":"6c9e7b86804255debe03545c6358eb975d3d470810a19e6c40c680299a686b1f","src/backends/mod.rs":"65cdc60cdf38968f5a7e197338f4cf6173406ce69a4f0aaa96a9e29f4f581b6e","src/backends/v2020/firmware.rs":"5a41bfb8f42f17523e68f8702e87d75bcdb268bd4950bb66227f6966ef3576a9","src/backends/v2020/mod.rs":"eceda61bfe623493964bda3f6164cdb376be0f1112102dd2895524728fca33de","src/backends/v2020/rpc.rs":"2b24bbb432b302dd15f7a354054fc96c6a75cac2c8e75b8bcc11da37255a05a3","src/backends/v2020/web.rs":"d39b67ed83781b2c4fa84a445b9ffe785ae3001941f800ad9860e050c61c6506","src/backends/v2023_07/firmware.rs":"c07668e351d48dab3e24511b1aa9ab5e408bbcb5a438fdb0542a1377f94b9bbb","src/backends/v2023_07/mod.rs":"8cf8031c39f283bd8531de81b7811db48451aff92328a3676aaffdb3cc96fbad","src/backends/v2023_07/rpc.rs":"2b24bbb432b302dd15f7a354054fc96c6a75cac2c8e75b8bcc11da37255a05a3","src/backends/v2023_07/web.rs":"d39b67ed83781b2c4fa84a445b9ffe785ae3001941f800ad9860e050c61c6506","src/firmware.rs":"55d5b722632c0a5cfcf1f8c8252a88c5a1ece887173bb513cca0b22b874d628f","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"a3ef4d6805bb4f8ea087e3a9b875e5a1664580e1ff3e3cd2015bb0c5c18ae7bb","src/test/json/v2020/devs.json":"df17cdfc9522e23450702b93f70ff701892db54c6ce6d986300453ad5e0d22db","src/test/json/v2020/mod.rs":"4c2512d36af834d400a865a94c2e8b1919f9d8dcbf54ab2530c73861c51af67d","src/test/json/v2020/pools.json":"4c4d19ad3ef0de84bfb18daaa48428b5f7917d23287c0196eacf3a6e389e7634","src/test/json/v2020/stats.json":"6d3cb463abb7539ae77aa44ef38e62a5dc0db54670aeacf3bbd01e83f49aa1fd","src/test/json/v2020/summary.json":"2f18c81f989b7c5f70dcb0ddac0520e56ec98b6da25c24e59354a6126c965dae","src/test/json/v2020/system_info.json":"51d1ce922e39a254518a24be56ca86ef1b5843582fb26c1ff0ec4ff6f8f91ccf","src/test/json/v2020/version.json":"ae898c4c9ea3462c3e79f9de755f1fccb4ef122b94a4a512e61aa74491c1a8e9","src/test/json/v2023_07/l11_stats.json":"2eab324f253ced9a0ea4e46466691e0e71fc6fde7558fec86bd5acf6bb9c717d","src/test/json/v2023_07/l11_summary.json":"1e0fdb61b968005d0ec5393d9dc889b09efb1398ffa427629bcc0a98d1b67c22","src/test/json/v2023_07/l11_version.json":"d116921a71731c6e492aed109731c39561e34a24c7df2a88d11ac52b80f6100a","src/test/json/v2023_07/l9_stats.json":"731ee545f16dafd356d22703248b91a37f74585ad73cc27441eb3461ce53dca0","src/test/json/v2023_07/l9_summary.json":"b32b5131ad46859b270d2dbb6bdba3c4e5d7301298daee4ce56332c98faaf81d","src/test/json/v2023_07/l9_version.json":"82f03ca6ea8873f12c4d9455f21b98c547801b58fbff1dcd83c837c0f337a129","src/test/json/v2023_07/mod.rs":"1360a8b155b120f2e755ede0736bcc0d76a9d1d693b984a1b51a16e6c0413791","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"0c06e3ecbf95ae3fe5e30aacae55cf6e7ad3d965f4a93b2f85c7b64f61fc75e2"}
|
||||
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"6e42d50107b1a43fd7cf4a4c4f538468a337ed219ad8d6b23bd9abdabd123bd5","Cargo.lock":"7f984c7231c91f2def8f3e2e923a85c2e0b3239492f5ce23400881ea4de1aa16","Cargo.toml":"8a447efc18cd97d019a9771fb258b06f694499500561564eec75480e46bcc554","Cargo.toml.orig":"6c9e7b86804255debe03545c6358eb975d3d470810a19e6c40c680299a686b1f","src/backends/mod.rs":"65cdc60cdf38968f5a7e197338f4cf6173406ce69a4f0aaa96a9e29f4f581b6e","src/backends/v2020/firmware.rs":"5a41bfb8f42f17523e68f8702e87d75bcdb268bd4950bb66227f6966ef3576a9","src/backends/v2020/mod.rs":"f1972769a1b4811d5772e96b2e6c45b461cdcb4175355dba2b586b9df776fc1d","src/backends/v2020/rpc.rs":"2b24bbb432b302dd15f7a354054fc96c6a75cac2c8e75b8bcc11da37255a05a3","src/backends/v2020/web.rs":"d39b67ed83781b2c4fa84a445b9ffe785ae3001941f800ad9860e050c61c6506","src/backends/v2023_07/firmware.rs":"c07668e351d48dab3e24511b1aa9ab5e408bbcb5a438fdb0542a1377f94b9bbb","src/backends/v2023_07/mod.rs":"278e4dd04a753858e12df96ead3522aef0616ebf6f27b3da4f1a12b064c19ee6","src/backends/v2023_07/rpc.rs":"2b24bbb432b302dd15f7a354054fc96c6a75cac2c8e75b8bcc11da37255a05a3","src/backends/v2023_07/web.rs":"d39b67ed83781b2c4fa84a445b9ffe785ae3001941f800ad9860e050c61c6506","src/firmware.rs":"55d5b722632c0a5cfcf1f8c8252a88c5a1ece887173bb513cca0b22b874d628f","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"a3ef4d6805bb4f8ea087e3a9b875e5a1664580e1ff3e3cd2015bb0c5c18ae7bb","src/test/json/v2020/devs.json":"df17cdfc9522e23450702b93f70ff701892db54c6ce6d986300453ad5e0d22db","src/test/json/v2020/mod.rs":"4c2512d36af834d400a865a94c2e8b1919f9d8dcbf54ab2530c73861c51af67d","src/test/json/v2020/pools.json":"4c4d19ad3ef0de84bfb18daaa48428b5f7917d23287c0196eacf3a6e389e7634","src/test/json/v2020/stats.json":"6d3cb463abb7539ae77aa44ef38e62a5dc0db54670aeacf3bbd01e83f49aa1fd","src/test/json/v2020/summary.json":"2f18c81f989b7c5f70dcb0ddac0520e56ec98b6da25c24e59354a6126c965dae","src/test/json/v2020/system_info.json":"51d1ce922e39a254518a24be56ca86ef1b5843582fb26c1ff0ec4ff6f8f91ccf","src/test/json/v2020/version.json":"ae898c4c9ea3462c3e79f9de755f1fccb4ef122b94a4a512e61aa74491c1a8e9","src/test/json/v2023_07/l11_stats.json":"2eab324f253ced9a0ea4e46466691e0e71fc6fde7558fec86bd5acf6bb9c717d","src/test/json/v2023_07/l11_summary.json":"1e0fdb61b968005d0ec5393d9dc889b09efb1398ffa427629bcc0a98d1b67c22","src/test/json/v2023_07/l11_version.json":"d116921a71731c6e492aed109731c39561e34a24c7df2a88d11ac52b80f6100a","src/test/json/v2023_07/l9_stats.json":"731ee545f16dafd356d22703248b91a37f74585ad73cc27441eb3461ce53dca0","src/test/json/v2023_07/l9_summary.json":"b32b5131ad46859b270d2dbb6bdba3c4e5d7301298daee4ce56332c98faaf81d","src/test/json/v2023_07/l9_version.json":"82f03ca6ea8873f12c4d9455f21b98c547801b58fbff1dcd83c837c0f337a129","src/test/json/v2023_07/mod.rs":"1360a8b155b120f2e755ede0736bcc0d76a9d1d693b984a1b51a16e6c0413791","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"0c06e3ecbf95ae3fe5e30aacae55cf6e7ad3d965f4a93b2f85c7b64f61fc75e2"}
|
||||
+10
-1
@@ -14,7 +14,7 @@ use asic_rs_core::{
|
||||
DataCollector, DataExtensions, DataExtractor, DataField, DataLocation, get_by_pointer,
|
||||
},
|
||||
command::MinerCommand,
|
||||
device::DeviceInfo,
|
||||
device::{DeviceInfo, HashAlgorithm},
|
||||
fan::FanData,
|
||||
firmware::FirmwareImage,
|
||||
hashrate::{HashRate, HashRateUnit},
|
||||
@@ -722,6 +722,15 @@ impl GetHashrate for AntMinerV2020 {
|
||||
})
|
||||
})?;
|
||||
|
||||
// Equihash miners (e.g. Z15/Z15J) report a Sol/s rate in the cgminer
|
||||
// "GHS" key, so the key's GigaHash label is wrong -- the value is the
|
||||
// raw Sol/s count. Use the base unit so the magnitude (and SI prefix)
|
||||
// is correct (e.g. ~288000 Sol/s -> "288k", not "288T"). Match by algo,
|
||||
// and by Z15 model name for the Z15J which asic-rs leaves algo Unknown.
|
||||
let is_equihash = self.device_info.algo == HashAlgorithm::Equihash
|
||||
|| self.device_info.model.to_string().to_ascii_uppercase().contains("Z15");
|
||||
let unit = if is_equihash { HashRateUnit::Hash } else { unit };
|
||||
|
||||
Some(
|
||||
HashRate {
|
||||
value,
|
||||
|
||||
@@ -16,7 +16,7 @@ use asic_rs_core::{
|
||||
DataCollector, DataExtensions, DataExtractor, DataField, DataLocation, get_by_pointer,
|
||||
},
|
||||
command::MinerCommand,
|
||||
device::DeviceInfo,
|
||||
device::{DeviceInfo, HashAlgorithm},
|
||||
fan::FanData,
|
||||
firmware::FirmwareImage,
|
||||
hashrate::{HashRate, HashRateUnit},
|
||||
@@ -698,6 +698,15 @@ impl GetHashrate for AntMinerV202307 {
|
||||
})
|
||||
})?;
|
||||
|
||||
// Equihash miners (e.g. Z15/Z15J) report a Sol/s rate in the cgminer
|
||||
// "GHS" key, so the key's GigaHash label is wrong -- the value is the
|
||||
// raw Sol/s count. Use the base unit so the magnitude (and SI prefix)
|
||||
// is correct (e.g. ~288000 Sol/s -> "288k", not "288T"). Match by algo,
|
||||
// and by Z15 model name for the Z15J which asic-rs leaves algo Unknown.
|
||||
let is_equihash = self.device_info.algo == HashAlgorithm::Equihash
|
||||
|| self.device_info.model.to_string().to_ascii_uppercase().contains("Z15");
|
||||
let unit = if is_equihash { HashRateUnit::Hash } else { unit };
|
||||
|
||||
Some(
|
||||
HashRate {
|
||||
value,
|
||||
|
||||
@@ -1 +1 @@
|
||||
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"30f09ad063df45fdf223aff235fe2da15cb1a7e79e86d7012074153b91662fc4","Cargo.lock":"9d0886791db53421d3218ab72d964145b86cfbe9738eaf09aac5d3c89a1c0190","Cargo.toml":"8c2e9938436850f2e250e8268ed7b385fce903e2077923b207a0560ca3e3242c","Cargo.toml.orig":"891fcfa45e79d6bc4d838c4f3075618f791bd013c99231da48e752b987f409d5","src/backends/mod.rs":"0f5a0ae31d5443d0d0f41a2540def806196238c92d22761b3ad9843cb2e77f45","src/backends/v1/mod.rs":"80f3915f1e87c6f7483e9bd0e5b1fb5552f8d017634c82eea6150fe5134b171f","src/backends/v1/rpc.rs":"4cee9caeb9bc291c4efec04f4b7fc2b8eaead904a1f2d0f30e13236476d9aac5","src/backends/v2/mod.rs":"a1a054eda0b1466b8ae1693f47d6f2d79cc0ac067eb82320c4d659c9e1eaef0f","src/backends/v2/rpc.rs":"b7afc5357d24de42350d4ec15a6b5a37698e4fd77b2c2cc8071f303ee62e957c","src/backends/v3/mod.rs":"fd232f2df64b148f0998726fc41c089d08080ba25b3ca37bcb1c7f43b08b1c17","src/backends/v3/rpc.rs":"7a5f80aec4af1bcaa0d36e67345aa9acbbd8ead73c0be474f06305358b38e81b","src/error_codes.rs":"de85845f52b1d4e1a0bff73462cef00962b60fad8a3ed71c7bb083c02df3a413","src/firmware.rs":"6d002e481ce0a897c0485b9393b0382fcb25811164e893eb8eb67b2ff392ca0d","src/lib.rs":"710b46c9d934f26f900e1366ca1df5f872896e7d8da03569c0f159859e899cc9","src/test/json/mod.rs":"99760925ccfefc40d2455d3567fb1ecfc99e9e55e70478190ef372a954825909","src/test/json/v1/devs.json":"b4fd010f0bae3584efde93387cf2dab5933b499cc30a2dd7635fdc994b56c3b8","src/test/json/v1/get_psu.json":"8c11b6495e0bd5da496dd5c10ca53ec53b2d8fe9a3737f470ec9ce2c1aaf9d99","src/test/json/v1/get_version.json":"c43e947e654792ab191210d50c6f793ee0dd7af41e8cb59f0722b70f32a203bc","src/test/json/v1/mod.rs":"e79509eee78a1fef63735afe385299813726822c8259a02d1dcf5e8b4db9d04e","src/test/json/v1/pools.json":"b570808a3428a0773d7d2ee322150d8fd0794a33804af970300a7fef128a8a01","src/test/json/v1/status.json":"00ec38dd9f980b7ac0ffd6f815374afdbbed98d601bd8ef18bcf0f76ae0aa853","src/test/json/v1/summary.json":"d6e3e75654eb4019e1f479b3d9cf3097130f1afb85dd3338682c094fd4ab498a","src/test/json/v1/summary_with_errors.json":"1ba682f6ad5c43e41ae22a4069d0f52f04da3f07a18031bf4c07e07b3c59cc97","src/test/json/v2/devs.json":"2d203e41ef6ef337c0c81456b73d08730882c3167403c557c3c9776022a972d1","src/test/json/v2/get_error_code.json":"e90b702fd97bceb4f62dcb8228f75ff5ce930290355dca94eefd7192f7f57009","src/test/json/v2/get_error_code_with_errors.json":"6cb6038366eb3835684421c41be0b2b30ae8ce79a7ed51a85f4f52f70da9df16","src/test/json/v2/get_miner_info.json":"55d2af984833a692f502188ae4df4e41bdc10386b47f921c896a452ef1de9062","src/test/json/v2/get_psu.json":"b43086b65897061521d1f6611e200ef372a1724f9ea1876e347c03d5fb19b8f2","src/test/json/v2/get_version.json":"b17e3a81603b43186b2e15745e6822b6c82b3c6f5928b22f84e683d7728dbfcd","src/test/json/v2/mod.rs":"c847205d076323bbd9698e393d241b08f3cf75d32aae86f7058cf8748266b935","src/test/json/v2/pools.json":"926d34e8dae774473ebfec83d4a38e77ca73231708f07683763e212be7af0580","src/test/json/v2/status.json":"fc268cd23864ef99e84813dbf8eb916b2e6f339351a0ee5dab217cbe02569fc3","src/test/json/v2/summary.json":"4e4c01b986e2960893f58d0f1ea4dce23b8ef88db4985348f7f0183eb4818478","src/test/json/v3/get_device_info.json":"83ac22ea9a11adbceb4c963db80aa62d9a2aa50d019a372394dece817d924cda","src/test/json/v3/get_device_info_with_errors.json":"24cee4b7840e87e12147cbfddf6c361f3b378a15bb85330b339d3be9e17cdbd5","src/test/json/v3/get_miner_status_edevs.json":"2d831c06113f555e0988df994c2e602a053a4aea603dded0db8f0f80e191ca5a","src/test/json/v3/get_miner_status_pools.json":"cd65c2efd3a5ce80b57aae46c420298a34ca06df7ac7f8c36fd556217703d242","src/test/json/v3/get_miner_status_summary.json":"799a94ba13ef54aed0f81a3d041d6c1fa263d4183754b384c69ca12d85a8d3ba","src/test/json/v3/mod.rs":"7ea3a8ff1b81c7a5b0f44f7c12dda880a9aeac5b0e6b56ac4fff4f4a7cbfe451","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"c85da6325b62f061327dc5f7605dd3721c823a9e8a2cfd6a356363dfbc84d66e"}
|
||||
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"30f09ad063df45fdf223aff235fe2da15cb1a7e79e86d7012074153b91662fc4","Cargo.lock":"9d0886791db53421d3218ab72d964145b86cfbe9738eaf09aac5d3c89a1c0190","Cargo.toml":"8c2e9938436850f2e250e8268ed7b385fce903e2077923b207a0560ca3e3242c","Cargo.toml.orig":"891fcfa45e79d6bc4d838c4f3075618f791bd013c99231da48e752b987f409d5","src/backends/mod.rs":"0f5a0ae31d5443d0d0f41a2540def806196238c92d22761b3ad9843cb2e77f45","src/backends/v1/mod.rs":"80f3915f1e87c6f7483e9bd0e5b1fb5552f8d017634c82eea6150fe5134b171f","src/backends/v1/rpc.rs":"4cee9caeb9bc291c4efec04f4b7fc2b8eaead904a1f2d0f30e13236476d9aac5","src/backends/v2/mod.rs":"68fd8c1762b424a7785174fdb3ae4fede1d599632657808d4b7c76bcfbfb202c","src/backends/v2/rpc.rs":"b7afc5357d24de42350d4ec15a6b5a37698e4fd77b2c2cc8071f303ee62e957c","src/backends/v3/mod.rs":"f19e673c47c2cc366e2ff7782bca93daf750563d62221a12a043b3ee79a15251","src/backends/v3/rpc.rs":"7a5f80aec4af1bcaa0d36e67345aa9acbbd8ead73c0be474f06305358b38e81b","src/error_codes.rs":"de85845f52b1d4e1a0bff73462cef00962b60fad8a3ed71c7bb083c02df3a413","src/firmware.rs":"6d002e481ce0a897c0485b9393b0382fcb25811164e893eb8eb67b2ff392ca0d","src/lib.rs":"710b46c9d934f26f900e1366ca1df5f872896e7d8da03569c0f159859e899cc9","src/test/json/mod.rs":"99760925ccfefc40d2455d3567fb1ecfc99e9e55e70478190ef372a954825909","src/test/json/v1/devs.json":"b4fd010f0bae3584efde93387cf2dab5933b499cc30a2dd7635fdc994b56c3b8","src/test/json/v1/get_psu.json":"8c11b6495e0bd5da496dd5c10ca53ec53b2d8fe9a3737f470ec9ce2c1aaf9d99","src/test/json/v1/get_version.json":"c43e947e654792ab191210d50c6f793ee0dd7af41e8cb59f0722b70f32a203bc","src/test/json/v1/mod.rs":"e79509eee78a1fef63735afe385299813726822c8259a02d1dcf5e8b4db9d04e","src/test/json/v1/pools.json":"b570808a3428a0773d7d2ee322150d8fd0794a33804af970300a7fef128a8a01","src/test/json/v1/status.json":"00ec38dd9f980b7ac0ffd6f815374afdbbed98d601bd8ef18bcf0f76ae0aa853","src/test/json/v1/summary.json":"d6e3e75654eb4019e1f479b3d9cf3097130f1afb85dd3338682c094fd4ab498a","src/test/json/v1/summary_with_errors.json":"1ba682f6ad5c43e41ae22a4069d0f52f04da3f07a18031bf4c07e07b3c59cc97","src/test/json/v2/devs.json":"2d203e41ef6ef337c0c81456b73d08730882c3167403c557c3c9776022a972d1","src/test/json/v2/get_error_code.json":"e90b702fd97bceb4f62dcb8228f75ff5ce930290355dca94eefd7192f7f57009","src/test/json/v2/get_error_code_with_errors.json":"6cb6038366eb3835684421c41be0b2b30ae8ce79a7ed51a85f4f52f70da9df16","src/test/json/v2/get_miner_info.json":"55d2af984833a692f502188ae4df4e41bdc10386b47f921c896a452ef1de9062","src/test/json/v2/get_psu.json":"b43086b65897061521d1f6611e200ef372a1724f9ea1876e347c03d5fb19b8f2","src/test/json/v2/get_version.json":"b17e3a81603b43186b2e15745e6822b6c82b3c6f5928b22f84e683d7728dbfcd","src/test/json/v2/mod.rs":"c847205d076323bbd9698e393d241b08f3cf75d32aae86f7058cf8748266b935","src/test/json/v2/pools.json":"926d34e8dae774473ebfec83d4a38e77ca73231708f07683763e212be7af0580","src/test/json/v2/status.json":"fc268cd23864ef99e84813dbf8eb916b2e6f339351a0ee5dab217cbe02569fc3","src/test/json/v2/summary.json":"4e4c01b986e2960893f58d0f1ea4dce23b8ef88db4985348f7f0183eb4818478","src/test/json/v3/get_device_info.json":"83ac22ea9a11adbceb4c963db80aa62d9a2aa50d019a372394dece817d924cda","src/test/json/v3/get_device_info_with_errors.json":"24cee4b7840e87e12147cbfddf6c361f3b378a15bb85330b339d3be9e17cdbd5","src/test/json/v3/get_miner_status_edevs.json":"2d831c06113f555e0988df994c2e602a053a4aea603dded0db8f0f80e191ca5a","src/test/json/v3/get_miner_status_pools.json":"cd65c2efd3a5ce80b57aae46c420298a34ca06df7ac7f8c36fd556217703d242","src/test/json/v3/get_miner_status_summary.json":"799a94ba13ef54aed0f81a3d041d6c1fa263d4183754b384c69ca12d85a8d3ba","src/test/json/v3/mod.rs":"7ea3a8ff1b81c7a5b0f44f7c12dda880a9aeac5b0e6b56ac4fff4f4a7cbfe451","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"c85da6325b62f061327dc5f7605dd3721c823a9e8a2cfd6a356363dfbc84d66e"}
|
||||
+13
-3
@@ -637,11 +637,21 @@ impl SetFaultLight for WhatsMinerV2 {
|
||||
impl SetPowerLimit for WhatsMinerV2 {
|
||||
async fn set_power_limit(&self, limit: Power) -> anyhow::Result<bool> {
|
||||
let parameters = Some(json!({"power_limit": limit.as_watts().to_string()}));
|
||||
let data = self
|
||||
match self
|
||||
.rpc
|
||||
.send_command("adjust_power_limit", true, parameters)
|
||||
.await;
|
||||
Ok(data.is_ok())
|
||||
.await
|
||||
{
|
||||
Ok(_) => Ok(true),
|
||||
// adjust_power_limit makes the miner restart to re-tune, so it drops
|
||||
// the connection / stops replying mid-command even though it accepted
|
||||
// and applied the new limit (verified on the live fleet: the set value
|
||||
// settles after the restart). A transient RPC error (read timeout /
|
||||
// connection reset) after the command is therefore success; a genuine
|
||||
// rejection surfaces as StatusCheckFailed and still errors.
|
||||
Err(e) if is_expected_write_error(&e) => Ok(true),
|
||||
Err(e) => Err(e),
|
||||
}
|
||||
}
|
||||
fn supports_set_power_limit(&self) -> bool {
|
||||
true
|
||||
|
||||
+23
-7
@@ -669,12 +669,21 @@ impl SetFaultLight for WhatsMinerV3 {
|
||||
#[async_trait]
|
||||
impl SetPowerLimit for WhatsMinerV3 {
|
||||
async fn set_power_limit(&self, limit: Power) -> anyhow::Result<bool> {
|
||||
let data = self
|
||||
// WhatsMinerOS wants a BARE INTEGER watt value; a float ("3000.0")
|
||||
// trips the firmware's "invalid json" parser (round-9 #4).
|
||||
let watts = limit.as_watts().round() as u64;
|
||||
match self
|
||||
.rpc
|
||||
.send_command("set.miner.power_limit", true, Some(json!(limit.as_watts())))
|
||||
.await;
|
||||
|
||||
Ok(data.is_ok())
|
||||
.send_command("set.miner.power_limit", true, Some(json!(watts)))
|
||||
.await
|
||||
{
|
||||
Ok(_) => Ok(true),
|
||||
// A power-limit change restarts the miner to re-tune, so a transient
|
||||
// RPC error after the command means it was accepted (as with v2), not
|
||||
// rejected; a genuine rejection is a StatusCheckFailed and still errors.
|
||||
Err(e) if is_expected_write_error(&e) => Ok(true),
|
||||
Err(e) => Err(e),
|
||||
}
|
||||
}
|
||||
fn supports_set_power_limit(&self) -> bool {
|
||||
true
|
||||
@@ -806,8 +815,15 @@ impl HasDefaultAuth for WhatsMinerV3 {
|
||||
|
||||
impl HasAuth for WhatsMinerV3 {
|
||||
fn set_auth(&mut self, auth: MinerAuth) {
|
||||
// WhatsMiner V3 username is always "super", V2 is always "admin"
|
||||
self.rpc.set_auth(MinerAuth::new("super", auth.password()));
|
||||
// WhatsMiner V3 username is always "super", V2 is always "admin".
|
||||
// The V3 privileged token authenticates against the "super" ACCOUNT,
|
||||
// whose password is a separate v3 credential (factory default "super")
|
||||
// -- NOT the web/admin password carried by `auth`. Pairing account
|
||||
// "super" with the web password made every v3 privileged write fail with
|
||||
// "invalid json or password is wrong" (round-9 #4, confirmed on the live
|
||||
// fleet). Keep the super-account default password here; the web password
|
||||
// still drives the v2 (admin) path below.
|
||||
self.rpc.set_auth(MinerAuth::new("super", "super"));
|
||||
self.v2_rpc
|
||||
.set_auth(MinerAuth::new("admin", auth.password()));
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user