Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
b7a77cbed8 | ||
|
|
606ae85781 | ||
|
|
ad9b0dc868 | ||
|
|
aaf049bbfc | ||
|
|
8b7b0c70b4 | ||
|
|
3ae80efdde | ||
|
|
7901d82c4b | ||
|
|
8f7aab3f80 | ||
|
|
e593548746 | ||
|
|
2fd433c3b0 | ||
|
|
5399f9fc49 | ||
|
|
6b4961d7bc | ||
|
|
fc7c665166 | ||
|
|
ae437c0d24 | ||
|
|
b343746718 | ||
|
|
aa75031112 | ||
|
|
8eb9a2caad | ||
|
|
9e2b453eb5 | ||
|
|
3530d67a5c | ||
|
|
3ac4e104a0 | ||
|
|
3c99934513 | ||
|
|
9b5d811b1e | ||
|
|
77399bdd06 | ||
|
|
408b7d12b4 | ||
|
|
50cd463bee | ||
|
|
d73299166e |
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 384 512"><path fill="currentColor" d="M240 8L48 296h112L128 504 336 216H224L272 8z"/></svg>
|
||||
|
After Width: | Height: | Size: 145 B |
@@ -0,0 +1 @@
|
||||
<svg version="1.0" xmlns="http://www.w3.org/2000/svg" width="511.104248pt" height="512.144915pt" viewBox="0 0 511.104248 512.144915" preserveAspectRatio="xMidYMid meet"><g transform="translate(-0.500000,511.997478) scale(0.100000,-0.100000)" fill="currentColor" stroke="none"><path d="M82 5103 c-52 -25 -77 -69 -77 -133 0 -41 6 -63 22 -86 49 -68 -31 -64 1237 -64 l1146 0 0 -150 0 -150 -323 0 c-292 0 -332 -2 -403 -20 -201 -52 -370 -228 -414 -432 -8 -34 -11 -94 -8 -155 5 -90 12 -119 52 -214 6 -14 -9 -17 -121 -22 -142 -7 -205 -22 -304 -73 -123 -65 -229 -192 -272 -329 -33 -106 -30 -264 7 -360 15 -38 30 -77 32 -85 4 -12 -9 -20 -49 -33 -76 -24 -163 -83 -228 -156 -160 -176 -193 -424 -86 -638 61 -123 195 -242 315 -280 40 -13 52 -21 48 -33 -2 -8 -17 -46 -32 -85 -38 -95 -41 -253 -7 -360 56 -178 206 -323 393 -380 32 -9 108 -19 182 -22 l126 -6 -25 -66 c-31 -81 -42 -233 -23 -319 45 -210 221 -387 433 -437 94 -22 1622 -22 1716 0 108 26 188 71 272 155 126 125 176 255 167 437 -5 90 -12 119 -52 214 -6 14 9 17 122 22 147 6 246 33 337 92 110 70 199 186 238 310 33 106 30 264 -7 360 -15 39 -30 77 -32 85 -4 12 9 20 49 33 211 67 377 303 377 537 0 233 -167 470 -378 537 -40 13 -52 21 -48 33 2 8 17 47 32 85 37 96 40 254 7 360 -39 122 -130 241 -240 311 -89 58 -188 85 -335 91 -113 5 -128 8 -122 22 40 95 47 124 52 214 6 119 -7 184 -55 287 -46 97 -157 210 -254 257 -117 58 -159 63 -516 63 l-323 0 0 150 0 150 618 0 617 0 210 -211 c116 -116 227 -219 247 -230 122 -63 256 59 207 187 -5 16 -60 79 -121 141 l-112 113 313 0 c346 0 360 2 404 64 31 43 31 129 0 172 -50 70 173 64 -2535 64 -2230 0 -2446 -2 -2476 -17z m3337 -918 c94 -52 141 -134 141 -244 -1 -102 -60 -192 -155 -237 l-50 -24 -795 0 -795 0 -50 24 c-61 28 -116 87 -140 149 -26 70 -17 172 21 235 31 49 104 105 158 121 18 6 363 9 821 8 l790 -2 54 -30z m649 -834 c95 -43 162 -147 162 -251 0 -66 -30 -131 -85 -187 -84 -83 -84 -83 -593 -83 l-434 0 -55 50 c-281 257 -719 257 -1005 0 l-57 -51 -453 3 c-452 3 -453 3 -500 26 -92 45 -158 151 -158 252 0 119 99 235 221 259 24 5 688 8 1474 8 l1430 -2 53 -24z m-1317 -623 c130 -64 224 -184 249 -317 5 -29 10 -98 10 -151 0 -53 -5 -122 -10 -151 -25 -133 -119 -253 -249 -317 -73 -36 -77 -37 -191 -37 -114 0 -118 1 -191 37 -125 62 -210 164 -244 293 -20 79 -20 271 0 350 39 149 147 263 300 318 38 13 74 17 151 15 93 -3 107 -6 175 -40z m-924 -235 c-16 -51 -16 -415 0 -465 l11 -38 -547 0 -548 0 -62 31 c-87 43 -138 117 -148 213 -11 110 44 211 145 263 l64 33 548 0 548 0 -11 -37z m2580 24 c60 -22 117 -72 148 -128 26 -46 30 -64 30 -129 0 -65 -4 -83 -30 -129 -31 -56 -88 -106 -148 -128 -23 -8 -187 -12 -578 -12 l-546 -1 13 68 c17 86 17 318 0 405 l-13 67 546 -1 c391 0 555 -4 578 -12z m-2349 -878 c286 -256 725 -255 1006 1 l55 51 453 -3 c452 -3 453 -3 500 -26 90 -44 158 -151 158 -247 0 -99 -69 -204 -162 -246 l-53 -24 -1455 0 -1455 0 -53 24 c-95 43 -162 147 -162 251 0 66 30 131 85 187 83 82 79 81 588 82 l439 1 56 -51z m1342 -820 c97 -43 160 -138 160 -240 0 -111 -47 -192 -141 -244 l-54 -30 -783 -3 c-518 -2 -796 1 -822 8 -59 16 -131 70 -164 122 -38 63 -47 165 -21 235 24 62 79 121 140 149 l50 24 795 0 c778 0 796 -1 840 -21z"/></g></svg>
|
||||
|
After Width: | Height: | Size: 3.0 KiB |
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640"><!--!Font Awesome Free 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--><path d="M181.5 261.1L194.4 267.5C200.3 270.5 206.8 272 213.5 272C237 272 256.1 252.9 256.1 229.4L256.1 208C256.1 172.7 227.4 144 192.1 144L128.1 144C92.8 144 64.1 172.7 64.1 208L64.1 229.4C64.1 252.9 83.2 272 106.7 272C113.3 272 119.8 270.5 125.8 267.5C135.1 262.8 142.2 259.3 147 256.9L135.1 249C130.6 246 128 241 128 235.7L128 232C128 218.7 138.7 208 152 208L168 208C181.3 208 192 218.7 192 232L192 235.7C192 241 189.3 246 184.9 249L173.1 256.9L181.5 261.1zM172.9 310.5L160 304.1L147.1 310.5C134.5 316.8 120.6 320.1 106.6 320.1C103 320.1 99.5 319.9 96 319.5L96 320.1C96 355.4 124.7 384.1 160 384.1L224 384.1C241.7 384.1 256 398.4 256 416.1C256 433.8 241.7 448.1 224 448.1L384 448.1L384 384.1C384 360.4 396.9 339.7 416 328.7C425.4 323.3 436.3 320.1 448 320.1L448 304.1C448 277.6 469.5 256.1 496 256.1C504.8 256.1 512 263.3 512 272.1L512 368.1C512 376.9 519.2 384.1 528 384.1C536.8 384.1 544 376.9 544 368.1L544 268.4C544 220.2 513.2 177.4 467.4 162.1L458.9 159.3C450.9 156.6 446.3 148.2 448.5 140C450.7 131.8 458.8 126.8 467.1 128.4L487 132.4C576 150.1 640 228.2 640 318.9L640 320L640 320C640 443.7 539.7 544 416 544L255.4 544C132 544 32 444 32 320.6L32 280.8C21.9 266.2 16 248.5 16 229.4L16 208L16 206.6C6.7 203.3 0 194.5 0 184C0 170.7 10.7 160 24 160L26.8 160C44.8 122.2 83.3 96 128 96L192 96C236.7 96 275.2 122.2 293.2 160L296 160C309.3 160 320 170.7 320 184C320 194.5 313.3 203.3 304 206.6L304 208L304 229.4C304 230.8 304 232.2 303.9 233.7C315.9 227.5 329.6 224.1 344 224.1L352 224.1C369.7 224.1 384 238.4 384 256.1C384 273.8 369.7 288.1 352 288.1L344 288.1C330.7 288.1 320 298.8 320 312.1L320 320.1L376.4 320.1C361.2 337.1 352 359.5 352 384.1L320 384.1C277.7 384.1 241.8 356.7 229 318.8C223.9 319.7 218.7 320.1 213.4 320.1C199.3 320.1 185.5 316.8 172.9 310.5zM96 192C104.8 192 112 199.2 112 208C112 216.8 104.8 224 96 224C87.2 224 80 216.8 80 208C80 199.2 87.2 192 96 192zM208 208C208 199.2 215.2 192 224 192C232.8 192 240 199.2 240 208C240 216.8 232.8 224 224 224C215.2 224 208 216.8 208 208z"/></svg>
|
||||
|
After Width: | Height: | Size: 2.2 KiB |
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 576 512"><!--! Font Awesome Pro 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2026 Fonticons, Inc. --><path fill="currentColor" d="M460.7 39.3l-2.2-2.1c-4.7-4.6-11.5-6.4-17.9-4.7s-11.4 6.6-13.1 13l-.8 2.9c-3.3 11.8-5.1 23.7-5.5 35.6 24.3 20.6 42.9 47.8 53.3 78.8-8.2-1.9-16.5-2.9-25-2.9-.6 0-1.1 0-1.7 0-18.4-44-56.5-77.4-103.6-89.3l-3.4-.9c-6.2-1.6-12.9-.6-18.5 2.6-10.8 6.2-15.6 19.5-11.2 31.1 14.9 39.5 44.3 71.4 81.4 89.7-3.7 6.6-6.4 14-7.6 21.8L279.7 154.9c-30.9-17.7-65.9-26.9-101.5-26.9-32.3 0-62.2 16.8-78.9 44.4-10.3-12.5-25.8-20.4-43.2-20.4-30.9 0-56 25.1-56 56s25.1 56 56 56c11.3 0 21.8-3.3 30.6-9.1 4.9 17.2 14.5 33.1 28.4 45.9L257.2 431.2C269 442 284.4 448 300.4 448L416 448c17.7 0 32-14.3 32-32s-14.3-32-32-32l-96 0 0-43.5c0-42.9-28.4-80.5-69.6-92.3l-30.8-8.8c-8.5-2.4-13.4-11.3-11-19.8s11.3-13.4 19.8-11l30.8 8.8c55 15.7 92.8 65.9 92.8 123.1l0 15.7 56-32.4 6.4-3.7 101.3 0c33.3 0 60.3-27 60.3-60.3 0-18.1-8.2-35.3-22.2-46.7l-34.6-28.2c-4.6-3.7-9.4-7.1-14.5-10 8.4-49.3-7.8-100-43.9-135.5zm-318.5 382c-14.7 9.8-18.7 29.7-8.9 44.4s29.7 18.7 44.4 8.9l46-30.7-48.6-44.5-32.9 22zM480 240a16 16 0 1 1 32 0 16 16 0 1 1 -32 0z"/></svg>
|
||||
|
After Width: | Height: | Size: 1.2 KiB |
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 576 512"><!--! Font Awesome Pro 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2026 Fonticons, Inc. --><path fill="currentColor" d="M384 249.2c0 21.4-17.4 38.8-38.8 38.8L70.8 288C49.4 288 32 270.6 32 249.2L32 208c0-97.2 78.8-176 176-176s176 78.8 176 176l0 41.2zM480 288c-2 0-4-.1-5.9-.3-16.3 53.3-64.3 92.7-122.1 96l0 56.2c0 22.1-17.9 40-40 40l-48 0c-22.1 0-40-17.9-40-40l0-56-32 0 0 56c0 22.1-17.9 40-40 40l-48 0c-22.1 0-40-17.9-40-40l0-56-32 0c-17.7 0-32-14.3-32-32s14.3-32 32-32l312 0c39.8 0 72-32.2 72-72l0-72c0-35.3 28.7-64 64-64 53 0 96 43 96 96l0 16c0 35.3-28.7 64-64 64l-32 0zm16-64a16 16 0 1 0 0-32 16 16 0 1 0 0 32z"/></svg>
|
||||
|
After Width: | Height: | Size: 761 B |
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640"><!--! Font Awesome Pro 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2026 Fonticons, Inc. --><path fill="currentColor" d="M205 64L434.9 64L439.3 82.4L475.6 234.9C478.5 247 480 259.5 480 272C480 352.2 421 418.7 344 430.2L344 560L432 560L432 608L208 608L208 560L296 560L296 430.2C219 418.6 160 352.2 160 272C160 259.5 161.5 247 164.4 234.9L200.7 82.4L205 64zM243 112L211 246C209 254.5 208 263.2 208 272C208 333.9 258.2 384 320 384C381.8 384 432 333.8 432 272C432 263.3 431 254.5 429 246L397.1 112L371.3 112L384.1 176L320.1 216L352.1 320L256.1 216L328.1 144L306.8 112L243.1 112z"/></svg>
|
||||
|
After Width: | Height: | Size: 721 B |
@@ -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
|
||||
|
||||
@@ -14,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,
|
||||
@@ -47,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,
|
||||
@@ -74,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()
|
||||
@@ -106,22 +159,13 @@ impl Board {
|
||||
tuning: self.mining,
|
||||
firmware_flash,
|
||||
},
|
||||
// Demo values for the round-8 columns (synthetic, so the columns
|
||||
// show variety offline).
|
||||
control_board: if self.model.contains("S17") {
|
||||
"Xilinx".to_string()
|
||||
} else if self.model.contains("S19j") || self.model.contains("S19k") {
|
||||
"AMLogic".to_string()
|
||||
} else if self.model.contains("S19") {
|
||||
"BeagleBone Black".to_string()
|
||||
} else if self.model.contains("S21") {
|
||||
"CVITek".to_string()
|
||||
} else {
|
||||
String::new()
|
||||
},
|
||||
pic_present: if self.model.contains("S21") {
|
||||
// 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.model.starts_with("Antminer") {
|
||||
} else if self.make.eq_ignore_ascii_case("antminer") {
|
||||
Some(true)
|
||||
} else {
|
||||
None // WhatsMiner: unknown over the network
|
||||
@@ -129,10 +173,12 @@ impl Board {
|
||||
// Access: idle/view-only units (no worker) shown locked; the rest
|
||||
// unlocked. (Live rows infer this from control capabilities.)
|
||||
write_locked: Some(self.worker.is_empty()),
|
||||
errors: if self.model.contains("S21 Pro") {
|
||||
// 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![
|
||||
"[Warning] hashrate 70% below expected".to_string(),
|
||||
"[Warning] chip temperature high (HashBoard 2)".to_string(),
|
||||
"hashrate 70% below expected".to_string(),
|
||||
"chip temperature high (HashBoard 2)".to_string(),
|
||||
]
|
||||
} else {
|
||||
Vec::new()
|
||||
@@ -152,33 +198,35 @@ impl Board {
|
||||
/// 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 },
|
||||
];
|
||||
|
||||
@@ -1,9 +1,12 @@
|
||||
//! 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;
|
||||
|
||||
+203
-30
@@ -134,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 {
|
||||
@@ -226,6 +236,16 @@ impl MinerCaps {
|
||||
}
|
||||
}
|
||||
|
||||
/// 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
|
||||
/// scalar fields the table can display. Absent metrics are `None` / empty /
|
||||
/// 0.0 and render as a blank cell.
|
||||
@@ -237,12 +257,27 @@ 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
|
||||
@@ -264,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.
|
||||
@@ -278,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,
|
||||
@@ -349,15 +400,25 @@ pub fn flash_confirmed(input: &str) -> bool {
|
||||
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,
|
||||
@@ -368,7 +429,9 @@ pub enum Column {
|
||||
Hostname,
|
||||
Serial,
|
||||
ApiVersion,
|
||||
ControlBoard,
|
||||
Cpu,
|
||||
BoardCode,
|
||||
Algorithm,
|
||||
Pic,
|
||||
Locked,
|
||||
Error,
|
||||
@@ -389,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; 38] = [
|
||||
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,
|
||||
@@ -411,7 +479,9 @@ pub const ALL_COLUMNS: [Column; 38] = [
|
||||
Column::Hostname,
|
||||
Column::Serial,
|
||||
Column::ApiVersion,
|
||||
Column::ControlBoard,
|
||||
Column::Cpu,
|
||||
Column::BoardCode,
|
||||
Column::Algorithm,
|
||||
Column::Pic,
|
||||
Column::Locked,
|
||||
Column::Error,
|
||||
@@ -430,16 +500,19 @@ pub const ALL_COLUMNS: [Column; 38] = [
|
||||
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 {
|
||||
@@ -447,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",
|
||||
@@ -466,7 +545,9 @@ impl Column {
|
||||
Column::Hostname => "Hostname",
|
||||
Column::Serial => "Serial",
|
||||
Column::ApiVersion => "API ver",
|
||||
Column::ControlBoard => "Control board",
|
||||
Column::Cpu => "CPU",
|
||||
Column::BoardCode => "Control Board",
|
||||
Column::Algorithm => "Algorithm",
|
||||
Column::Pic => "PIC",
|
||||
Column::Locked => "Access",
|
||||
Column::Error => "Errors",
|
||||
@@ -490,19 +571,26 @@ 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,
|
||||
@@ -521,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
|
||||
@@ -572,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
|
||||
@@ -586,7 +682,21 @@ impl Column {
|
||||
Column::FanCount => SortKey::Num(r.fan_count.map(|v| v as f64).unwrap_or(none)),
|
||||
Column::ExpectedFans => SortKey::Num(r.expected_fans.map(|v| v as f64).unwrap_or(none)),
|
||||
Column::TotalChips => SortKey::Num(r.total_chips.map(|v| v as f64).unwrap_or(none)),
|
||||
Column::Hashboards => SortKey::Num(r.hashboards.map(|v| v as f64).unwrap_or(none)),
|
||||
// The Boards column shows per-hashboard health dots, so sort by the
|
||||
// number of ONLINE (green) boards -- surfacing units with dead/missing
|
||||
// boards -- with the total board count as a tiebreaker (so full-health
|
||||
// units still order by how many boards they have). Falls back to the
|
||||
// reported board count when no per-board health is available (round 11).
|
||||
Column::Hashboards => {
|
||||
if r.board_status.is_empty() {
|
||||
SortKey::Num(r.hashboards.map(|v| v as f64).unwrap_or(none))
|
||||
} else {
|
||||
let online =
|
||||
r.board_status.iter().filter(|h| matches!(h, BoardHealth::Ok)).count();
|
||||
let total = r.board_status.len();
|
||||
SortKey::Num((online * 100 + total) as f64)
|
||||
}
|
||||
}
|
||||
Column::Uptime => SortKey::Num(if r.uptime_secs > 0 { r.uptime_secs as f64 } else { none }),
|
||||
Column::BestShare => SortKey::Num(r.best_share.unwrap_or(none)),
|
||||
Column::SessionBestShare => SortKey::Num(r.session_best_share.unwrap_or(none)),
|
||||
@@ -616,6 +726,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")
|
||||
@@ -624,8 +739,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("/")
|
||||
@@ -636,14 +760,20 @@ 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(),
|
||||
@@ -654,10 +784,11 @@ impl Column {
|
||||
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(),
|
||||
1 => r.errors[0].clone(),
|
||||
n => format!("{n} errors"),
|
||||
n => n.to_string(),
|
||||
},
|
||||
Column::Status => r.status().to_string(),
|
||||
Column::Uptime => format_uptime(r.uptime_secs),
|
||||
@@ -764,9 +895,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() }
|
||||
@@ -783,6 +922,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
|
||||
}
|
||||
@@ -852,6 +1001,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 {
|
||||
@@ -863,7 +1017,11 @@ 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
|
||||
@@ -876,7 +1034,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
|
||||
}
|
||||
|
||||
@@ -1040,9 +1210,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());
|
||||
@@ -1204,13 +1377,13 @@ mod tests {
|
||||
assert_eq!(Column::Locked.cell(&unlocked), "unlocked");
|
||||
assert_eq!(Column::Locked.cell(&MinerRow::default()), "?");
|
||||
|
||||
// Error column: blank / single message / count.
|
||||
// Error column shows only the count (blank when none), even for one.
|
||||
let none = MinerRow { errors: vec![], ..Default::default() };
|
||||
let one = MinerRow { errors: vec!["[Error] boom".into()], ..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), "[Error] boom");
|
||||
assert_eq!(Column::Error.cell(&many), "3 errors");
|
||||
assert_eq!(Column::Error.cell(&one), "1");
|
||||
assert_eq!(Column::Error.cell(&many), "3");
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -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,238 @@
|
||||
//! 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,
|
||||
}
|
||||
|
||||
/// I2C buses to probe for the hashboard MCU/LM75 at 0x48, most-likely first,
|
||||
/// chosen from the control-board family. `probe_pic` tries them in order and
|
||||
/// stops at the first bus that classifies definitively, so extra fallbacks only
|
||||
/// cost an SSH round-trip when earlier buses are absent/indeterminate.
|
||||
///
|
||||
/// Confirmed live (2026-09-19): a VNish CVITek S19k Pro exposes the hashboard
|
||||
/// MCU on i2c-3 (i2c-4 is the second, usually empty); its buses are i2c-3/i2c-4,
|
||||
/// NOT i2c-0/i2c-1 -- the earlier CVITek -> [1,0] guess never found the MCU,
|
||||
/// which is why PIC detection appeared not to work. AMLogic=i2c-1 and
|
||||
/// BeagleBone=i2c-0 are from the wiki; buses vary across firmware, so each family
|
||||
/// also lists the others as fallbacks.
|
||||
pub fn bus_candidates(control_board: &str) -> Vec<u8> {
|
||||
let cb = control_board.to_lowercase();
|
||||
if cb.contains("cvi") {
|
||||
vec![3, 4, 1, 0]
|
||||
} else if cb.contains("amlogic") || cb.contains("aml") {
|
||||
vec![1, 3, 4, 0]
|
||||
} else if cb.contains("beaglebone") || cb.contains("bb") {
|
||||
vec![0, 1, 3, 4]
|
||||
} else {
|
||||
// Xilinx / unknown: try the common buses.
|
||||
vec![1, 0, 3, 4]
|
||||
}
|
||||
}
|
||||
|
||||
/// 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() {
|
||||
// Most-likely bus first, then fallbacks. CVITek's i2c-3 first is the live
|
||||
// fix; AMLogic i2c-1 and BeagleBone i2c-0 keep their wiki-confirmed lead.
|
||||
assert_eq!(bus_candidates("CVI (C88)"), vec![3, 4, 1, 0]);
|
||||
assert_eq!(bus_candidates("CVITek"), vec![3, 4, 1, 0]);
|
||||
assert_eq!(bus_candidates("AMLogic")[0], 1);
|
||||
assert_eq!(bus_candidates("BeagleBone Black")[0], 0);
|
||||
assert_eq!(bus_candidates("Xilinx")[0], 1);
|
||||
assert_eq!(bus_candidates("")[0], 1);
|
||||
}
|
||||
}
|
||||
@@ -11,17 +11,20 @@ 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).
|
||||
const DEFAULT_PROFILE: [Column; 9] = [
|
||||
/// 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::ControlBoard,
|
||||
Column::Pic,
|
||||
Column::Status,
|
||||
Column::Cpu,
|
||||
Column::Hashboards,
|
||||
Column::Locked,
|
||||
];
|
||||
|
||||
/// A serializable snapshot of a `ViewState` (Vec-based so JSON has no map keys
|
||||
@@ -123,9 +126,13 @@ mod tests {
|
||||
let view = p.view.to_view();
|
||||
// IP first + the requested default columns visible.
|
||||
assert!(view.visible.contains(&Column::Ip));
|
||||
assert!(view.visible.contains(&Column::ControlBoard));
|
||||
assert!(view.visible.contains(&Column::Pic));
|
||||
assert!(view.visible.contains(&Column::Status));
|
||||
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());
|
||||
|
||||
+288
-27
@@ -397,31 +397,37 @@ pub fn start_scan(lines: Vec<String>) -> ScanHandle {
|
||||
ScanHandle { rx, cancel }
|
||||
}
|
||||
|
||||
/// Flatten a miner's structured messages into display lines, most severe first
|
||||
/// ("[Error] text (component)"), for the Errors column + hover tooltip.
|
||||
/// 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 rank = |s: &MessageSeverity| match s {
|
||||
MessageSeverity::Error => 0u8,
|
||||
MessageSeverity::Warning => 1,
|
||||
MessageSeverity::Info => 2,
|
||||
};
|
||||
let mut ranked: Vec<(u8, String)> = messages
|
||||
.iter()
|
||||
.map(|m| {
|
||||
let sev = match m.severity {
|
||||
MessageSeverity::Error => "Error",
|
||||
MessageSeverity::Warning => "Warning",
|
||||
MessageSeverity::Info => "Info",
|
||||
.filter_map(|m| {
|
||||
let rank = match m.severity {
|
||||
MessageSeverity::Error => 0u8,
|
||||
MessageSeverity::Warning => 1,
|
||||
MessageSeverity::Info => return None, // informational, not an error/warning
|
||||
};
|
||||
let line = match &m.component {
|
||||
Some(c) => format!("[{sev}] {} ({c})", m.message),
|
||||
None => format!("[{sev}] {}", m.message),
|
||||
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(),
|
||||
};
|
||||
(rank(&m.severity), line)
|
||||
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()
|
||||
}
|
||||
|
||||
@@ -443,6 +449,23 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
.as_ref()
|
||||
.map(|t| t.as_celsius())
|
||||
.unwrap_or(0.0);
|
||||
// Per-hashboard temperature for the "77 / 64 / 74" Chip-temp cell. Prefer the
|
||||
// board/PCB temperature over the hottest-chip (outlet) reading: WhatsMiner's
|
||||
// outlet_chip is the max chip temp (~100C on the hottest board), which read
|
||||
// alarmingly high and didn't match the temperature the miner itself reports;
|
||||
// the board temperature (~60-79C) is the figure the miner's own UI shows
|
||||
// (round 12 #3). Falls back to the chip temp when no board temp is reported.
|
||||
let board_temps: Vec<f64> = data
|
||||
.hashboards
|
||||
.iter()
|
||||
.filter_map(|b| {
|
||||
b.board_temperature
|
||||
.as_ref()
|
||||
.or(b.outlet_chip_temperature.as_ref())
|
||||
.map(|t| t.as_celsius())
|
||||
})
|
||||
.filter(|&t| t > 0.0)
|
||||
.collect();
|
||||
let fan_rpms: Vec<f64> = data
|
||||
.fans
|
||||
.iter()
|
||||
@@ -477,17 +500,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()
|
||||
@@ -498,17 +542,24 @@ 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(),
|
||||
};
|
||||
@@ -520,28 +571,76 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
// 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,
|
||||
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(),
|
||||
serial: {
|
||||
// Some miners report a placeholder serial ("N/A", "none", ...); show
|
||||
// those as an empty cell rather than the literal placeholder (round 12).
|
||||
let s = data.serial_number.clone().unwrap_or_default();
|
||||
let t = s.trim();
|
||||
if t.is_empty()
|
||||
|| t.eq_ignore_ascii_case("n/a")
|
||||
|| t.eq_ignore_ascii_case("na")
|
||||
|| t.eq_ignore_ascii_case("none")
|
||||
|| t.eq_ignore_ascii_case("null")
|
||||
{
|
||||
String::new()
|
||||
} else {
|
||||
s
|
||||
}
|
||||
},
|
||||
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,
|
||||
@@ -551,6 +650,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,
|
||||
@@ -905,6 +1005,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::*;
|
||||
|
||||
+802
-85
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,
|
||||
@@ -0,0 +1,29 @@
|
||||
Subject: [PATCH 0003] antminer: recognise VNish short control-board platforms (CV, XIL)
|
||||
|
||||
Round-11 #5 -- VNish reports the control board in short form via /api/v1/info
|
||||
"platform": "cv" (CVITek), "xil" (Xilinx), "aml" (AMLogic). asic-rs's
|
||||
AntMinerControlBoard::parse matched the full names (CVITEK, XILINX) but not the
|
||||
short "CV"/"XIL", so VNish CVITek and Xilinx boards showed a blank control board
|
||||
(the "can't scan XIL or CVITek boards" bug). Add the short forms. Verified live:
|
||||
S19k Pro platform "cv" -> CVITek, S19 platform "xil" -> Xilinx.
|
||||
|
||||
diff --git a/vendor/asic-rs-makes-antminer/src/hardware.rs b/vendor/asic-rs-makes-antminer/src/hardware.rs
|
||||
index 41a73240..aa0923c8 100644
|
||||
--- a/vendor/asic-rs-makes-antminer/src/hardware.rs
|
||||
+++ b/vendor/asic-rs-makes-antminer/src/hardware.rs
|
||||
@@ -268,11 +268,13 @@ impl AntMinerControlBoard {
|
||||
.collect::<String>();
|
||||
|
||||
match compact.as_str() {
|
||||
- "XILINX" => Some(Self::Xilinx),
|
||||
+ // "XIL" is VNish's short platform form for a Xilinx control board.
|
||||
+ "XILINX" | "XIL" => Some(Self::Xilinx),
|
||||
"BBB" | "BBCTRL" | "BB" | "BEAGLEBONE" | "BEAGLEBONEBLACK" => {
|
||||
Some(Self::BeagleBoneBlack)
|
||||
}
|
||||
- "CVITEK" | "CVCTRL" => Some(Self::CVITek),
|
||||
+ // "CV" is VNish's short platform form for a CVITek control board.
|
||||
+ "CVITEK" | "CVCTRL" | "CV" => Some(Self::CVITek),
|
||||
"AMLOGIC" | "AML" => Some(Self::AMLogic),
|
||||
"AMCB07" => Some(Self::Xilinx), // Mara FW
|
||||
"ZYNQ7007" => Some(Self::Xilinx),
|
||||
@@ -0,0 +1,65 @@
|
||||
Subject: [PATCH 0004] whatsminer v1: control-board fallback + optional ALLWINNER_ prefix
|
||||
|
||||
Round-11 #5 -- older M30S firmware (< 2022.7.29, the v1 backend) often omits
|
||||
"CB Platform" from the summary RPC, and its parse mandatorily stripped an
|
||||
"ALLWINNER_" prefix (strip_prefix(..)? -> None when absent), so those units
|
||||
showed a blank control board. Add get_version /Msg/platform (the source v2 uses)
|
||||
as a fallback location, and make the ALLWINNER_ strip optional. Verified live:
|
||||
M30S+ VE40 (fw 20220422, v1) blank -> H6OS.
|
||||
|
||||
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
|
||||
index b4a27db8..f95a22ae 100644
|
||||
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
|
||||
@@ -131,14 +131,28 @@ impl GetDataLocations for WhatsMinerV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
- DataField::ControlBoardVersion => vec![(
|
||||
- RPC_SUMMARY,
|
||||
- DataExtractor {
|
||||
- func: get_by_pointer,
|
||||
- key: Some("/SUMMARY/0/CB Platform"),
|
||||
- tag: None,
|
||||
- },
|
||||
- )],
|
||||
+ DataField::ControlBoardVersion => vec![
|
||||
+ (
|
||||
+ RPC_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/SUMMARY/0/CB Platform"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ ),
|
||||
+ // Older M30S firmware (< 2022.7.29, so this v1 backend) often omits
|
||||
+ // "CB Platform" from summary but still reports the board under
|
||||
+ // get_version /Msg/platform (the source v2 uses). Fall back to it so
|
||||
+ // those units don't show a blank control board.
|
||||
+ (
|
||||
+ RPC_GET_VERSION,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/Msg/platform"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ ),
|
||||
+ ],
|
||||
DataField::TuningTarget => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
@@ -285,8 +299,12 @@ impl GetControlBoardVersion for WhatsMinerV1 {
|
||||
) -> Option<MinerControlBoard> {
|
||||
data.extract::<String>(DataField::ControlBoardVersion)
|
||||
.and_then(|s| {
|
||||
- WhatsMinerControlBoard::parse(s.to_uppercase().strip_prefix("ALLWINNER_")?)
|
||||
- .map(|cb| cb.into())
|
||||
+ // The "ALLWINNER_" prefix is optional: summary's CB Platform carries
|
||||
+ // it (e.g. "ALLWINNER_H6"), but the get_version /Msg/platform fallback
|
||||
+ // does not (e.g. "H6OS"). Strip it only when present.
|
||||
+ let up = s.to_uppercase();
|
||||
+ let board = up.strip_prefix("ALLWINNER_").unwrap_or(&up);
|
||||
+ WhatsMinerControlBoard::parse(board).map(|cb| cb.into())
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,93 @@
|
||||
Subject: [PATCH 0005] vnish: surface the partner build name in the firmware version
|
||||
|
||||
Round-11 #6b/#11 -- VNish /api/v1/info carries a partner/reseller "build_name"
|
||||
("WildRose", "vnishreturn", ...) alongside "fw_version"; it is shown in the
|
||||
Hashcore toolkit but asic-rs did not expose it. Point the FirmwareVersion
|
||||
extractor at /build_name and combine it with the /fw_version number (still on
|
||||
ApiVersion) in parse_firmware_version, so firmware_version reads "<build>
|
||||
<version>", e.g. "WildRose 1.2.7". Applies to both the v1_2_0 and v1_3_0
|
||||
backends. Verified live: S19j Pro -> "WildRose 1.2.7", S19k Pro -> "vnishreturn 1.3.5".
|
||||
|
||||
diff --git a/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs b/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs
|
||||
index 4cc1434a..e734a03e 100644
|
||||
--- a/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs
|
||||
@@ -179,11 +179,15 @@ impl GetDataLocations for VnishV120 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // The partner/reseller build name ("WildRose", "vnishreturn", ...) --
|
||||
+ // combined with the version number in parse_firmware_version so the FW
|
||||
+ // Version column shows e.g. "WildRose 1.3.5". ApiVersion still carries
|
||||
+ // the bare /fw_version.
|
||||
DataField::FirmwareVersion => vec![(
|
||||
WEB_INFO,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
- key: Some("/fw_version"),
|
||||
+ key: Some("/build_name"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
@@ -415,7 +419,20 @@ impl GetApiVersion for VnishV120 {
|
||||
|
||||
impl GetFirmwareVersion for VnishV120 {
|
||||
fn parse_firmware_version(&self, data: &HashMap<DataField, Value>) -> Option<String> {
|
||||
- data.extract::<String>(DataField::FirmwareVersion)
|
||||
+ // FirmwareVersion carries /build_name (the partner build), ApiVersion the
|
||||
+ // /fw_version number; show "<build> <version>" when both are present, else
|
||||
+ // whichever is available.
|
||||
+ let build = data
|
||||
+ .extract::<String>(DataField::FirmwareVersion)
|
||||
+ .filter(|b| !b.is_empty());
|
||||
+ let version = data
|
||||
+ .extract::<String>(DataField::ApiVersion)
|
||||
+ .filter(|v| !v.is_empty());
|
||||
+ match (build, version) {
|
||||
+ (Some(b), Some(v)) => Some(format!("{b} {v}")),
|
||||
+ (Some(b), None) => Some(b),
|
||||
+ (None, v) => v,
|
||||
+ }
|
||||
}
|
||||
}
|
||||
|
||||
diff --git a/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs b/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs
|
||||
index 6975d9e5..0a5d694e 100644
|
||||
--- a/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs
|
||||
@@ -179,11 +179,13 @@ impl GetDataLocations for VnishV130 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // Partner/reseller build name; combined with the version number in
|
||||
+ // parse_firmware_version (FW Version shows e.g. "WildRose 1.3.5").
|
||||
DataField::FirmwareVersion => vec![(
|
||||
WEB_INFO,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
- key: Some("/fw_version"),
|
||||
+ key: Some("/build_name"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
@@ -423,7 +425,19 @@ impl GetApiVersion for VnishV130 {
|
||||
|
||||
impl GetFirmwareVersion for VnishV130 {
|
||||
fn parse_firmware_version(&self, data: &HashMap<DataField, Value>) -> Option<String> {
|
||||
- data.extract::<String>(DataField::FirmwareVersion)
|
||||
+ // FirmwareVersion carries /build_name (partner build), ApiVersion the
|
||||
+ // /fw_version number; show "<build> <version>" when both are present.
|
||||
+ let build = data
|
||||
+ .extract::<String>(DataField::FirmwareVersion)
|
||||
+ .filter(|b| !b.is_empty());
|
||||
+ let version = data
|
||||
+ .extract::<String>(DataField::ApiVersion)
|
||||
+ .filter(|v| !v.is_empty());
|
||||
+ match (build, version) {
|
||||
+ (Some(b), Some(v)) => Some(format!("{b} {v}")),
|
||||
+ (Some(b), None) => Some(b),
|
||||
+ (None, v) => v,
|
||||
+ }
|
||||
}
|
||||
}
|
||||
|
||||
+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()
|
||||
+67
-1
@@ -10,7 +10,7 @@
|
||||
+pub use widgets::*;
|
||||
--- a/src/widgets.rs
|
||||
+++ b/src/widgets.rs
|
||||
@@ -0,0 +1,728 @@
|
||||
@@ -0,0 +1,794 @@
|
||||
+// 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;
|
||||
@@ -90,6 +92,8 @@
|
||||
+ 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);
|
||||
@@ -112,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_svg_icon(parent: *mut c_void, svg: *const c_char, w: c_int, h: 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);
|
||||
+ }
|
||||
+}
|
||||
+
|
||||
@@ -152,6 +159,8 @@
|
||||
+ SysColour,
|
||||
+ Deferred,
|
||||
+ DvlcHeaderRightClick,
|
||||
+ /// Window resized; p1 = new client width, p2 = new client height.
|
||||
+ Sized,
|
||||
+}
|
||||
+
|
||||
+impl WxEventKind {
|
||||
@@ -171,6 +180,7 @@
|
||||
+ 13 => WxEventKind::SysColour,
|
||||
+ 14 => WxEventKind::Deferred,
|
||||
+ 15 => WxEventKind::DvlcHeaderRightClick,
|
||||
+ 16 => WxEventKind::Sized,
|
||||
+ _ => return None,
|
||||
+ })
|
||||
+ }
|
||||
@@ -188,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();
|
||||
@@ -304,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) }
|
||||
+ }
|
||||
@@ -609,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 {
|
||||
@@ -723,6 +781,14 @@
|
||||
+ })
|
||||
+ }
|
||||
+
|
||||
+ /// Render an SVG string (recolour it first -- its fill must be an explicit
|
||||
+ /// colour, not "currentColor") into a static-bitmap icon at `w`x`h` px
|
||||
+ /// (round 11 #15).
|
||||
+ pub fn svg_icon(parent: Widget, svg: &str, w: i32, h: i32) -> Widget {
|
||||
+ let c = CString::new(svg).unwrap_or_default();
|
||||
+ Widget(unsafe { notsafe::wxbr_svg_icon(parent.0, c.as_ptr(), w as c_int, h 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) }
|
||||
|
||||
+414
-13
@@ -1,6 +1,6 @@
|
||||
--- a/cpp_src/widgets_bridge.cpp
|
||||
+++ b/cpp_src/widgets_bridge.cpp
|
||||
@@ -0,0 +1,1059 @@
|
||||
@@ -0,0 +1,1460 @@
|
||||
+// 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,16 +22,19 @@
|
||||
+#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>
|
||||
+#include <wx/bitmap.h>
|
||||
+#include <wx/bmpbndl.h>
|
||||
+#include <wx/image.h>
|
||||
+#include <wx/dcmemory.h>
|
||||
+#include <wx/dcgraph.h>
|
||||
+#include <wx/graphics.h>
|
||||
+#include <wx/wrapsizer.h>
|
||||
+#include <wx/filedlg.h>
|
||||
+#include <wx/statusbr.h>
|
||||
+#include <cstring>
|
||||
+#include <cstdio>
|
||||
+#include <map>
|
||||
@@ -68,6 +71,7 @@
|
||||
+ 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 plus an
|
||||
@@ -148,6 +152,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 {
|
||||
@@ -167,12 +222,63 @@
|
||||
+
|
||||
+ 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 in BOTH dimensions by the alignment logic, so filling
|
||||
+ // it alone left the zebra covering only a content-sized band -- and since
|
||||
+ // shape cells (dots) and text cells have different content heights, the
|
||||
+ // stripes ended up unequal across columns. Fill an over-sized rect (full
|
||||
+ // column width, and well beyond the row vertically); wxGTK clips the cell
|
||||
+ // DC to the real cell background area, so this lands exactly on the full
|
||||
+ // row height of this cell without bleeding into neighbours (round 11 #1/#3).
|
||||
+ wxRect bg = cell;
|
||||
+ if (wxDataViewColumn* owner = const_cast<SegmentRenderer*>(this)->GetOwner()) {
|
||||
+ int cw = owner->GetWidth();
|
||||
+ if (cw > bg.width) bg.width = cw;
|
||||
+ }
|
||||
+ bg.y -= 40;
|
||||
+ bg.height += 80;
|
||||
+ 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);
|
||||
@@ -184,14 +290,60 @@
|
||||
+ }
|
||||
+
|
||||
+ 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)) {
|
||||
+ // The treeview's own state flags do NOT reliably carry
|
||||
+ // GTK_STATE_FLAG_BACKDROP (that lives on the toplevel), so query the
|
||||
+ // toplevel window's active state directly and force BACKDROP onto the
|
||||
+ // style-context state when it is inactive. Then the themed cell text
|
||||
+ // colour matches what GTK paints on the native columns when the window
|
||||
+ // loses focus (round 11 #1/#7).
|
||||
+ GtkWidget* top = gtk_widget_get_toplevel(tv);
|
||||
+ bool active = GTK_IS_WINDOW(top) && gtk_window_is_active(GTK_WINDOW(top));
|
||||
+ GtkStyleContext* ctx = gtk_widget_get_style_context(tv);
|
||||
+ GtkStateFlags st = gtk_widget_get_state_flags(tv);
|
||||
+ st = active ? (GtkStateFlags)(st & ~GTK_STATE_FLAG_BACKDROP)
|
||||
+ : (GtkStateFlags)(st | GTK_STATE_FLAG_BACKDROP);
|
||||
+ GdkRGBA c;
|
||||
+ gtk_style_context_save(ctx);
|
||||
+ gtk_style_context_set_state(ctx, st);
|
||||
+ gtk_style_context_get_color(ctx, gtk_style_context_get_state(ctx), &c);
|
||||
+ gtk_style_context_restore(ctx);
|
||||
+ 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;
|
||||
+};
|
||||
+
|
||||
@@ -273,6 +425,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) {
|
||||
@@ -383,12 +552,31 @@
|
||||
+// ---- check list box ---------------------------------------------------------
|
||||
+
|
||||
+void* wxbr_check_list_box(void* parent) {
|
||||
+ // wxLB_EXTENDED so several rows can be selected at once (ctrl/shift-click and
|
||||
+ // rubber-band drag, native to wxListBox); a checkbox toggle on any selected
|
||||
+ // row then applies to every selected row (see the handler below). This is the
|
||||
+ // Excel-style batch-check the filter menu needs (round 12 #7).
|
||||
+ wxCheckListBox* clb = new wxCheckListBox((wxWindow*)parent, wxID_ANY,
|
||||
+ wxDefaultPosition, wxSize(-1, -1),
|
||||
+ 0, NULL, wxLB_SINGLE | wxLB_NEEDED_SB);
|
||||
+ 0, NULL, wxLB_EXTENDED | wxLB_NEEDED_SB);
|
||||
+ clb->Bind(wxEVT_CHECKLISTBOX, [clb](wxCommandEvent& e) {
|
||||
+ int idx = e.GetInt();
|
||||
+ // Batch toggle: if the clicked row is part of a multi-row selection, give
|
||||
+ // every selected row the clicked row's new state. Check() does not itself
|
||||
+ // fire wxEVT_CHECKLISTBOX, so there is no recursion.
|
||||
+ wxArrayInt sel;
|
||||
+ clb->GetSelections(sel);
|
||||
+ if (sel.GetCount() > 1) {
|
||||
+ bool inSel = false;
|
||||
+ for (size_t i = 0; i < sel.GetCount(); i++)
|
||||
+ if (sel[i] == idx) { inSel = true; break; }
|
||||
+ if (inSel) {
|
||||
+ bool state = clb->IsChecked(idx);
|
||||
+ for (size_t i = 0; i < sel.GetCount(); i++) clb->Check(sel[i], state);
|
||||
+ }
|
||||
+ }
|
||||
+ if (g_widget_event)
|
||||
+ g_widget_event(WxEV_CLB_TOGGLED, (long)(intptr_t)clb, e.GetInt());
|
||||
+ g_widget_event(WxEV_CLB_TOGGLED, (long)(intptr_t)clb, idx);
|
||||
+ });
|
||||
+ return (void*)clb;
|
||||
+}
|
||||
@@ -701,9 +889,11 @@
|
||||
+}
|
||||
+
|
||||
+// 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.
|
||||
+// 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);
|
||||
+}
|
||||
@@ -775,6 +965,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;
|
||||
@@ -806,9 +1015,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]));
|
||||
+ }
|
||||
+}
|
||||
+
|
||||
@@ -827,6 +1038,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));
|
||||
+}
|
||||
+
|
||||
@@ -937,6 +1149,137 @@
|
||||
+ 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);
|
||||
+ }
|
||||
+ // Batch checkbox toggle: checking/unchecking a row that is part of a
|
||||
+ // multi-row selection applies the same state to every selected row, so the
|
||||
+ // user can ctrl/shift-click several columns and show/hide them together
|
||||
+ // (round 12 #7). CheckItem() re-enters this handler, so guard against it.
|
||||
+ auto batchCheck = [lc](long item, bool state) {
|
||||
+ static bool busy = false;
|
||||
+ if (busy) return;
|
||||
+ if (!(lc->GetItemState(item, wxLIST_STATE_SELECTED) & wxLIST_STATE_SELECTED))
|
||||
+ return;
|
||||
+ wxVector<long> sel;
|
||||
+ long it = -1;
|
||||
+ for (;;) {
|
||||
+ it = lc->GetNextItem(it, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
|
||||
+ if (it == -1) break;
|
||||
+ sel.push_back(it);
|
||||
+ }
|
||||
+ if (sel.size() <= 1) return;
|
||||
+ busy = true;
|
||||
+ for (size_t i = 0; i < sel.size(); i++)
|
||||
+ if (sel[i] != item) lc->CheckItem(sel[i], state);
|
||||
+ busy = false;
|
||||
+ };
|
||||
+ lc->Bind(wxEVT_LIST_ITEM_CHECKED, [batchCheck](wxListEvent& e) {
|
||||
+ batchCheck(e.GetIndex(), true);
|
||||
+ });
|
||||
+ lc->Bind(wxEVT_LIST_ITEM_UNCHECKED, [batchCheck](wxListEvent& e) {
|
||||
+ batchCheck(e.GetIndex(), false);
|
||||
+ });
|
||||
+ 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(); }
|
||||
@@ -1029,6 +1372,15 @@
|
||||
+ return (void*)btn;
|
||||
+}
|
||||
+
|
||||
+// Render an SVG (already recoloured on the Rust side -- its fill is an explicit
|
||||
+// #RRGGBB) into a wxStaticBitmap for the KPI cards (round 11 #15). The caller
|
||||
+// passes the target pixel size (w chosen from the SVG aspect ratio, h fixed).
|
||||
+void* wxbr_svg_icon(void* parent, const char* svg, int w, int h) {
|
||||
+ wxBitmapBundle bundle = wxBitmapBundle::FromSVG(svg, wxSize(w, h));
|
||||
+ wxBitmap bmp = bundle.GetBitmap(wxSize(w, h));
|
||||
+ 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
|
||||
@@ -1051,6 +1403,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(); }
|
||||
|
||||
+413
-12
@@ -19,16 +19,19 @@
|
||||
#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>
|
||||
#include <wx/bitmap.h>
|
||||
#include <wx/bmpbndl.h>
|
||||
#include <wx/image.h>
|
||||
#include <wx/dcmemory.h>
|
||||
#include <wx/dcgraph.h>
|
||||
#include <wx/graphics.h>
|
||||
#include <wx/wrapsizer.h>
|
||||
#include <wx/filedlg.h>
|
||||
#include <wx/statusbr.h>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <map>
|
||||
@@ -65,6 +68,7 @@ enum WxWidgetEventKind {
|
||||
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 plus an
|
||||
@@ -145,6 +149,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 {
|
||||
@@ -164,12 +219,63 @@ 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 in BOTH dimensions by the alignment logic, so filling
|
||||
// it alone left the zebra covering only a content-sized band -- and since
|
||||
// shape cells (dots) and text cells have different content heights, the
|
||||
// stripes ended up unequal across columns. Fill an over-sized rect (full
|
||||
// column width, and well beyond the row vertically); wxGTK clips the cell
|
||||
// DC to the real cell background area, so this lands exactly on the full
|
||||
// row height of this cell without bleeding into neighbours (round 11 #1/#3).
|
||||
wxRect bg = cell;
|
||||
if (wxDataViewColumn* owner = const_cast<SegmentRenderer*>(this)->GetOwner()) {
|
||||
int cw = owner->GetWidth();
|
||||
if (cw > bg.width) bg.width = cw;
|
||||
}
|
||||
bg.y -= 40;
|
||||
bg.height += 80;
|
||||
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);
|
||||
@@ -181,14 +287,60 @@ 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)) {
|
||||
// The treeview's own state flags do NOT reliably carry
|
||||
// GTK_STATE_FLAG_BACKDROP (that lives on the toplevel), so query the
|
||||
// toplevel window's active state directly and force BACKDROP onto the
|
||||
// style-context state when it is inactive. Then the themed cell text
|
||||
// colour matches what GTK paints on the native columns when the window
|
||||
// loses focus (round 11 #1/#7).
|
||||
GtkWidget* top = gtk_widget_get_toplevel(tv);
|
||||
bool active = GTK_IS_WINDOW(top) && gtk_window_is_active(GTK_WINDOW(top));
|
||||
GtkStyleContext* ctx = gtk_widget_get_style_context(tv);
|
||||
GtkStateFlags st = gtk_widget_get_state_flags(tv);
|
||||
st = active ? (GtkStateFlags)(st & ~GTK_STATE_FLAG_BACKDROP)
|
||||
: (GtkStateFlags)(st | GTK_STATE_FLAG_BACKDROP);
|
||||
GdkRGBA c;
|
||||
gtk_style_context_save(ctx);
|
||||
gtk_style_context_set_state(ctx, st);
|
||||
gtk_style_context_get_color(ctx, gtk_style_context_get_state(ctx), &c);
|
||||
gtk_style_context_restore(ctx);
|
||||
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;
|
||||
};
|
||||
|
||||
@@ -270,6 +422,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) {
|
||||
@@ -380,12 +549,31 @@ void wxbr_check_box_set(void* win, int v) {
|
||||
// ---- check list box ---------------------------------------------------------
|
||||
|
||||
void* wxbr_check_list_box(void* parent) {
|
||||
// wxLB_EXTENDED so several rows can be selected at once (ctrl/shift-click and
|
||||
// rubber-band drag, native to wxListBox); a checkbox toggle on any selected
|
||||
// row then applies to every selected row (see the handler below). This is the
|
||||
// Excel-style batch-check the filter menu needs (round 12 #7).
|
||||
wxCheckListBox* clb = new wxCheckListBox((wxWindow*)parent, wxID_ANY,
|
||||
wxDefaultPosition, wxSize(-1, -1),
|
||||
0, NULL, wxLB_SINGLE | wxLB_NEEDED_SB);
|
||||
0, NULL, wxLB_EXTENDED | wxLB_NEEDED_SB);
|
||||
clb->Bind(wxEVT_CHECKLISTBOX, [clb](wxCommandEvent& e) {
|
||||
int idx = e.GetInt();
|
||||
// Batch toggle: if the clicked row is part of a multi-row selection, give
|
||||
// every selected row the clicked row's new state. Check() does not itself
|
||||
// fire wxEVT_CHECKLISTBOX, so there is no recursion.
|
||||
wxArrayInt sel;
|
||||
clb->GetSelections(sel);
|
||||
if (sel.GetCount() > 1) {
|
||||
bool inSel = false;
|
||||
for (size_t i = 0; i < sel.GetCount(); i++)
|
||||
if (sel[i] == idx) { inSel = true; break; }
|
||||
if (inSel) {
|
||||
bool state = clb->IsChecked(idx);
|
||||
for (size_t i = 0; i < sel.GetCount(); i++) clb->Check(sel[i], state);
|
||||
}
|
||||
}
|
||||
if (g_widget_event)
|
||||
g_widget_event(WxEV_CLB_TOGGLED, (long)(intptr_t)clb, e.GetInt());
|
||||
g_widget_event(WxEV_CLB_TOGGLED, (long)(intptr_t)clb, idx);
|
||||
});
|
||||
return (void*)clb;
|
||||
}
|
||||
@@ -698,9 +886,11 @@ int wxbr_dvlc_get_top_row(void* win) {
|
||||
}
|
||||
|
||||
// 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.
|
||||
// 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);
|
||||
}
|
||||
@@ -772,6 +962,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;
|
||||
@@ -803,9 +1012,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]));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -824,6 +1035,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));
|
||||
}
|
||||
|
||||
@@ -934,6 +1146,137 @@ 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);
|
||||
}
|
||||
// Batch checkbox toggle: checking/unchecking a row that is part of a
|
||||
// multi-row selection applies the same state to every selected row, so the
|
||||
// user can ctrl/shift-click several columns and show/hide them together
|
||||
// (round 12 #7). CheckItem() re-enters this handler, so guard against it.
|
||||
auto batchCheck = [lc](long item, bool state) {
|
||||
static bool busy = false;
|
||||
if (busy) return;
|
||||
if (!(lc->GetItemState(item, wxLIST_STATE_SELECTED) & wxLIST_STATE_SELECTED))
|
||||
return;
|
||||
wxVector<long> sel;
|
||||
long it = -1;
|
||||
for (;;) {
|
||||
it = lc->GetNextItem(it, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
|
||||
if (it == -1) break;
|
||||
sel.push_back(it);
|
||||
}
|
||||
if (sel.size() <= 1) return;
|
||||
busy = true;
|
||||
for (size_t i = 0; i < sel.size(); i++)
|
||||
if (sel[i] != item) lc->CheckItem(sel[i], state);
|
||||
busy = false;
|
||||
};
|
||||
lc->Bind(wxEVT_LIST_ITEM_CHECKED, [batchCheck](wxListEvent& e) {
|
||||
batchCheck(e.GetIndex(), true);
|
||||
});
|
||||
lc->Bind(wxEVT_LIST_ITEM_UNCHECKED, [batchCheck](wxListEvent& e) {
|
||||
batchCheck(e.GetIndex(), false);
|
||||
});
|
||||
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(); }
|
||||
@@ -1026,6 +1369,15 @@ void* wxbr_media_button(void* parent, int id, int kind, int r, int g, int b) {
|
||||
return (void*)btn;
|
||||
}
|
||||
|
||||
// Render an SVG (already recoloured on the Rust side -- its fill is an explicit
|
||||
// #RRGGBB) into a wxStaticBitmap for the KPI cards (round 11 #15). The caller
|
||||
// passes the target pixel size (w chosen from the SVG aspect ratio, h fixed).
|
||||
void* wxbr_svg_icon(void* parent, const char* svg, int w, int h) {
|
||||
wxBitmapBundle bundle = wxBitmapBundle::FromSVG(svg, wxSize(w, h));
|
||||
wxBitmap bmp = bundle.GetBitmap(wxSize(w, h));
|
||||
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
|
||||
@@ -1048,6 +1400,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(); }
|
||||
|
||||
@@ -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;
|
||||
@@ -77,6 +79,8 @@ mod notsafe {
|
||||
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);
|
||||
@@ -99,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_svg_icon(parent: *mut c_void, svg: *const c_char, w: c_int, h: 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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -139,6 +146,8 @@ pub enum WxEventKind {
|
||||
SysColour,
|
||||
Deferred,
|
||||
DvlcHeaderRightClick,
|
||||
/// Window resized; p1 = new client width, p2 = new client height.
|
||||
Sized,
|
||||
}
|
||||
|
||||
impl WxEventKind {
|
||||
@@ -158,6 +167,7 @@ impl WxEventKind {
|
||||
13 => WxEventKind::SysColour,
|
||||
14 => WxEventKind::Deferred,
|
||||
15 => WxEventKind::DvlcHeaderRightClick,
|
||||
16 => WxEventKind::Sized,
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
@@ -175,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();
|
||||
@@ -291,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) }
|
||||
}
|
||||
@@ -596,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 {
|
||||
@@ -710,6 +768,14 @@ impl Widget {
|
||||
})
|
||||
}
|
||||
|
||||
/// Render an SVG string (recolour it first -- its fill must be an explicit
|
||||
/// colour, not "currentColor") into a static-bitmap icon at `w`x`h` px
|
||||
/// (round 11 #15).
|
||||
pub fn svg_icon(parent: Widget, svg: &str, w: i32, h: i32) -> Widget {
|
||||
let c = CString::new(svg).unwrap_or_default();
|
||||
Widget(unsafe { notsafe::wxbr_svg_icon(parent.0, c.as_ptr(), w as c_int, h 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
@@ -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":"de321c89f62a60690ba07d6bb145ac688c6141c458638e68b3ed36b50b8de1f1","Cargo.lock":"5942ec7c9cf5c201bd32442d65020dc3ae72e33cb5aaf374b2a26501571a1487","Cargo.toml":"cb9ee00cbb415fa66a71a7d4822839bb3552336ec9ab975ae7b1137c711449cb","Cargo.toml.orig":"08409c395e4d502015da62e97efdc9c5bc6e3076031144f3f5aa35c900c7c735","src/backends/mod.rs":"26591e67688f8d015242295dde5050c4b34986e9980018a855346291a0472206","src/backends/v1_2_0/mod.rs":"c87949458cf3c73ef957b319abc1a39c4755d709d7e3cf5ea9b9b326eb054605","src/backends/v1_2_0/web.rs":"ac89f16bf623f7d85590d34b45c99b0e522d9d434b4c22af7fa8a8a653e09d2e","src/backends/v1_3_0/mod.rs":"722301b45abe8177269cc008a528ae5c5b122f4d0ced28aaa5bee6b5b9f0c062","src/backends/v1_3_0/web.rs":"1ec4cbe6bdc26f165d9e54e9bf2aac4c3706357ce4677dc21113710d4a26c3c1","src/firmware.rs":"168eeffaef90cb1525bb2e126e73905b5205d49215437263813e30323f6b7a05","src/lib.rs":"16ea1c0007fa6d6c86c1f83d3ac9cdf065cd9936cd52f35ef89c227397bbc54a","src/timezone.rs":"309bf23de1bdc9126bde5db8dabff0d2c0fea797dbf2630a772a18539838a05e"},"package":"1cb662e56f104c0fe45c8ccdac13f60cbcaad45ac228f939c6ac46ff40335052"}
|
||||
{"$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":"de321c89f62a60690ba07d6bb145ac688c6141c458638e68b3ed36b50b8de1f1","Cargo.lock":"5942ec7c9cf5c201bd32442d65020dc3ae72e33cb5aaf374b2a26501571a1487","Cargo.toml":"cb9ee00cbb415fa66a71a7d4822839bb3552336ec9ab975ae7b1137c711449cb","Cargo.toml.orig":"08409c395e4d502015da62e97efdc9c5bc6e3076031144f3f5aa35c900c7c735","src/backends/mod.rs":"26591e67688f8d015242295dde5050c4b34986e9980018a855346291a0472206","src/backends/v1_2_0/mod.rs":"fc68a12769890e18231255c6a53cb2c68e4706a887d91f49113c6192684340d2","src/backends/v1_2_0/web.rs":"ac89f16bf623f7d85590d34b45c99b0e522d9d434b4c22af7fa8a8a653e09d2e","src/backends/v1_3_0/mod.rs":"0bba1bf94e7a86d763dbedda3bb5d68cf760e17f744204b0bbc0de4e3754f795","src/backends/v1_3_0/web.rs":"1ec4cbe6bdc26f165d9e54e9bf2aac4c3706357ce4677dc21113710d4a26c3c1","src/firmware.rs":"168eeffaef90cb1525bb2e126e73905b5205d49215437263813e30323f6b7a05","src/lib.rs":"16ea1c0007fa6d6c86c1f83d3ac9cdf065cd9936cd52f35ef89c227397bbc54a","src/timezone.rs":"309bf23de1bdc9126bde5db8dabff0d2c0fea797dbf2630a772a18539838a05e"},"package":"1cb662e56f104c0fe45c8ccdac13f60cbcaad45ac228f939c6ac46ff40335052"}
|
||||
+19
-2
@@ -179,11 +179,15 @@ impl GetDataLocations for VnishV120 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// The partner/reseller build name ("WildRose", "vnishreturn", ...) --
|
||||
// combined with the version number in parse_firmware_version so the FW
|
||||
// Version column shows e.g. "WildRose 1.3.5". ApiVersion still carries
|
||||
// the bare /fw_version.
|
||||
DataField::FirmwareVersion => vec![(
|
||||
WEB_INFO,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/fw_version"),
|
||||
key: Some("/build_name"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
@@ -415,7 +419,20 @@ impl GetApiVersion for VnishV120 {
|
||||
|
||||
impl GetFirmwareVersion for VnishV120 {
|
||||
fn parse_firmware_version(&self, data: &HashMap<DataField, Value>) -> Option<String> {
|
||||
data.extract::<String>(DataField::FirmwareVersion)
|
||||
// FirmwareVersion carries /build_name (the partner build), ApiVersion the
|
||||
// /fw_version number; show "<build> <version>" when both are present, else
|
||||
// whichever is available.
|
||||
let build = data
|
||||
.extract::<String>(DataField::FirmwareVersion)
|
||||
.filter(|b| !b.is_empty());
|
||||
let version = data
|
||||
.extract::<String>(DataField::ApiVersion)
|
||||
.filter(|v| !v.is_empty());
|
||||
match (build, version) {
|
||||
(Some(b), Some(v)) => Some(format!("{b} {v}")),
|
||||
(Some(b), None) => Some(b),
|
||||
(None, v) => v,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+16
-2
@@ -179,11 +179,13 @@ impl GetDataLocations for VnishV130 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Partner/reseller build name; combined with the version number in
|
||||
// parse_firmware_version (FW Version shows e.g. "WildRose 1.3.5").
|
||||
DataField::FirmwareVersion => vec![(
|
||||
WEB_INFO,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/fw_version"),
|
||||
key: Some("/build_name"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
@@ -423,7 +425,19 @@ impl GetApiVersion for VnishV130 {
|
||||
|
||||
impl GetFirmwareVersion for VnishV130 {
|
||||
fn parse_firmware_version(&self, data: &HashMap<DataField, Value>) -> Option<String> {
|
||||
data.extract::<String>(DataField::FirmwareVersion)
|
||||
// FirmwareVersion carries /build_name (partner build), ApiVersion the
|
||||
// /fw_version number; show "<build> <version>" when both are present.
|
||||
let build = data
|
||||
.extract::<String>(DataField::FirmwareVersion)
|
||||
.filter(|b| !b.is_empty());
|
||||
let version = data
|
||||
.extract::<String>(DataField::ApiVersion)
|
||||
.filter(|v| !v.is_empty());
|
||||
match (build, version) {
|
||||
(Some(b), Some(v)) => Some(format!("{b} {v}")),
|
||||
(Some(b), None) => Some(b),
|
||||
(None, v) => v,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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":"b96cd7679b575335d716b114a3986167b2696b9e94a1a06a4696757aef08c7d1","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"}
|
||||
+28
-10
@@ -131,14 +131,28 @@ impl GetDataLocations for WhatsMinerV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::ControlBoardVersion => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/SUMMARY/0/CB Platform"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::ControlBoardVersion => vec![
|
||||
(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/SUMMARY/0/CB Platform"),
|
||||
tag: None,
|
||||
},
|
||||
),
|
||||
// Older M30S firmware (< 2022.7.29, so this v1 backend) often omits
|
||||
// "CB Platform" from summary but still reports the board under
|
||||
// get_version /Msg/platform (the source v2 uses). Fall back to it so
|
||||
// those units don't show a blank control board.
|
||||
(
|
||||
RPC_GET_VERSION,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/Msg/platform"),
|
||||
tag: None,
|
||||
},
|
||||
),
|
||||
],
|
||||
DataField::TuningTarget => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
@@ -285,8 +299,12 @@ impl GetControlBoardVersion for WhatsMinerV1 {
|
||||
) -> Option<MinerControlBoard> {
|
||||
data.extract::<String>(DataField::ControlBoardVersion)
|
||||
.and_then(|s| {
|
||||
WhatsMinerControlBoard::parse(s.to_uppercase().strip_prefix("ALLWINNER_")?)
|
||||
.map(|cb| cb.into())
|
||||
// The "ALLWINNER_" prefix is optional: summary's CB Platform carries
|
||||
// it (e.g. "ALLWINNER_H6"), but the get_version /Msg/platform fallback
|
||||
// does not (e.g. "H6OS"). Strip it only when present.
|
||||
let up = s.to_uppercase();
|
||||
let board = up.strip_prefix("ALLWINNER_").unwrap_or(&up);
|
||||
WhatsMinerControlBoard::parse(board).map(|cb| cb.into())
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
+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()));
|
||||
}
|
||||
|
||||
+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":"aaaa0f14e3aff2543d3d09a4515efa5ab439f0651a36b582e87b9843d0475752","Cargo.lock":"58da2f3399ff680bf7d619204897b4edf5c03d336a8c3cceb54c9aba280bfed1","Cargo.toml":"57f92bf3808fa6f468dbabf43763a808d9ead128eef83b748f940ef3b219a80e","Cargo.toml.orig":"cbfb99fc843dd61ad2025dcfc16bd435afd2b6d43c2c983867af08af415916f1","src/hardware.rs":"77612b4f39e9c15355172b0582693d86b2fe44a305f5b01eef592e5a34b37188","src/lib.rs":"b2f55767a7f3fdacb1e898c5cb961c2dec8481823f94386ee67628960e91bf7d","src/make.rs":"e968e4dbd745d485fc9ad4c5a4c081d679eddce11f66e572f81f2dbe37ede3f0","src/models.rs":"da72a570d8cbb2c843c04047c3d879ca9709455f9bd6a02c3f2ab739e1b5be60"},"package":"67cca6e6bf4ac14562084ce7534521ffa7cd313fa39e2392f98ff98a047a4353"}
|
||||
{"$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":"aaaa0f14e3aff2543d3d09a4515efa5ab439f0651a36b582e87b9843d0475752","Cargo.lock":"58da2f3399ff680bf7d619204897b4edf5c03d336a8c3cceb54c9aba280bfed1","Cargo.toml":"57f92bf3808fa6f468dbabf43763a808d9ead128eef83b748f940ef3b219a80e","Cargo.toml.orig":"cbfb99fc843dd61ad2025dcfc16bd435afd2b6d43c2c983867af08af415916f1","src/hardware.rs":"c3edc06f2404efd473bcc4ab16d66bb647369f2d43c0a10cb77bbc12cb98bf43","src/lib.rs":"b2f55767a7f3fdacb1e898c5cb961c2dec8481823f94386ee67628960e91bf7d","src/make.rs":"e968e4dbd745d485fc9ad4c5a4c081d679eddce11f66e572f81f2dbe37ede3f0","src/models.rs":"da72a570d8cbb2c843c04047c3d879ca9709455f9bd6a02c3f2ab739e1b5be60"},"package":"67cca6e6bf4ac14562084ce7534521ffa7cd313fa39e2392f98ff98a047a4353"}
|
||||
+4
-2
@@ -268,11 +268,13 @@ impl AntMinerControlBoard {
|
||||
.collect::<String>();
|
||||
|
||||
match compact.as_str() {
|
||||
"XILINX" => Some(Self::Xilinx),
|
||||
// "XIL" is VNish's short platform form for a Xilinx control board.
|
||||
"XILINX" | "XIL" => Some(Self::Xilinx),
|
||||
"BBB" | "BBCTRL" | "BB" | "BEAGLEBONE" | "BEAGLEBONEBLACK" => {
|
||||
Some(Self::BeagleBoneBlack)
|
||||
}
|
||||
"CVITEK" | "CVCTRL" => Some(Self::CVITek),
|
||||
// "CV" is VNish's short platform form for a CVITek control board.
|
||||
"CVITEK" | "CVCTRL" | "CV" => Some(Self::CVITek),
|
||||
"AMLOGIC" | "AML" => Some(Self::AMLogic),
|
||||
"AMCB07" => Some(Self::Xilinx), // Mara FW
|
||||
"ZYNQ7007" => Some(Self::Xilinx),
|
||||
|
||||
Reference in New Issue
Block a user