Compare commits

...
9 Commits
Author SHA1 Message Date
noahandClaude Opus 4.8 c4c85d5b3d Round 17 B (part 1, CLI): timezone / change-password / factory-reset verbs (G10/G11/G12)
Round B wires the already-complete SupportsTimezoneConfig / ChangePassword /
FactoryReset backends to the toolkit. Part 1 adds the committed CLI surface
(GUI dialogs follow in part 2):
- `timezone <ip> [<IANA>]` - read (no arg) or set the timezone (gated on
  supports_timezone_config: Braiins/VNish/ePIC).
- `passwd <ip> <newpass>`  - change the web/API password (gated).
- `factoryreset <ip>`      - factory reset (gated).
Each is capability-gated and the usage banner marks passwd/factoryreset DANGEROUS.

Verified live: timezone set/read/restore end-to-end on Braiins 10.4.1.83
(set America/Edmonton -> read back -> restore Etc/GMT, all Ok). change-password
and factory-reset are implemented + gated but NOT live-run: both are destructive
on the shared corpus (change-password breaks the default auth every other test
relies on; factory-reset can reset a unit to DHCP and lose its IP) -- they need a
dedicated sacrificial/console-attached unit to verify live.

Also: ci/compute-version.sh now treats crates/alkane-gui/src/bin/* as a UI change
so CLI-tool changes trigger a release.

Note: the VNish timezone READ errors ("Unrecognised VNish timezone GMT, expected
GMT+N/-N") is a pre-existing vnish backend parse quirk, separate from this wiring.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 22:58:43 -06:00
noahandClaude Opus 4.8 25c8ccf1ff Round 17 A (part 2, G13): LuxOS pool ops privileged + removepool
The luxminer pool write commands (addgroup/groupquota/removegroup/addpool/
switchpool/enablepool/disablepool) sent privileged=false -> no session_id, which
fails with "Missing session_id" on password-set LuxOS units (all other LuxOS
writes are already privileged). Flipped all seven to privileged=true and added the
missing removepool. asic-rs patch 0014.

Verified no regression on default corpus unit 10.4.1.60 (set_pools_config still
applies). The password-set failure needs a password-set LuxOS unit to verify live.

Round A remaining: G8 (constraints/limits reads) and G14 (telemetry enrichment) are
deferred to the rounds that consume them (G8 -> the tuning/cooling dialogs in C/D;
G14 -> detail-panel/tooltip work) rather than built as unused plumbing now.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 22:47:18 -06:00
noahandClaude Opus 4.8 307539543d Round 17 A (part 1): committed write CLI (G1) + best-share reads (G9) + parity roadmap
Executing the aftermarket config+scan parity plan (docs/aftermarket-parity-roadmap.md,
from the ultracode writer/adversary workflow). This is Round A's foundation + first cheap win.

G1 - miner_probe is now a committed config+scan CLI, not a local-only diagnostic. Added
capability-gated write verbs: `light <ip> <on|off>`, `pause`, `resume`, `restart` (alongside
the existing setpl/setpools/led), a READ vs WRITE usage banner warning that write verbs mutate
(use the test-bed miners, not production), and best_share/session_best_share columns in `scan`.
Verified: `light on`/`light off` on a LuxOS corpus unit -> Ok(true) (reversible).

G9 - implement GetBestShare/GetSessionBestShare (were empty impls feeding two dead columns):
Braiins v26_04 reads miner/stats -> /miner_stats/best_share; LuxMiner v1 reads summary ->
/SUMMARY/0/Best Share + Best Session Share. Both reuse already-collected responses (no extra
calls). asic-rs patch 0013. Verified live read-only: BOS 10.4.1.83 = 130601978 (no session on
BOS); LuxOS 10.4.1.60 = 638881749/638881749, 10.4.1.67 = 497802665/497802665 -- exact API match.
(WhatsMiner stock summary exposes no best-share on the tested units; deferred. The roadmap's BOS
source "miner_stats" was a typo for the real "miner/stats" endpoint.)

Also commits the parity roadmap (docs/) as the plan of record for rounds A-F.
Round A remainder (G8 constraints reads, G13 LuxOS pool-op privileged fix, G14 telemetry
enrichment) follows; G13 needs a password-set LuxOS unit to fully verify.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 22:36:59 -06:00
noahandClaude Opus 4.8 561c50e5dc GUI round 16 (#4/#5/#6/#7): UMC OS colour, pool + restore dialog polish, new icons
- #4 ePIC miners report their firmware family as "UMC OS"; colour that row light
  blue in the Firmware column (was falling through to the theme default / black),
  matching the existing ePIC colour.
- #5 Configure-pools dialog: widen the "+" buttons so the glyph shows; the dropdown
  "add" entry now reads "Add new"; user-added values can be removed via a "Remove
  saved value" submenu (pool_prefs::remove_saved); dropped the intro tidbit and
  narrowed the window.
- #6 Restore-to-stock confirmation: the miner list is now a height-capped,
  scrollable text box instead of one unbounded label, so restoring hundreds at
  once stays usable. Removed the "Flash firmware..." right-click option for now
  (the in-app flash path is parked while it is reworked).
- #7 Replaced the brain (control board) and fan Health icons with the new
  operator-supplied artwork, image-traced from PNG to SVG (potrace) and stripped
  of explicit fills so the Health column's per-state recolouring still applies.

Headless selftest passes (fixtures render through the real widgets); all GUI unit
tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 17:43:45 -06:00
noahandClaude Opus 4.8 74b97162f5 GUI round 16 (#1/#2/#3): per-component health attribution + tooltips
Health icons and their hover tooltips now reflect the miner's actual per-component
faults instead of a generic "faulted".

- #1 Each Health icon's tooltip carries the specific fault text for THAT component
  (e.g. "Slot 0 error reading chip id.", "Power current error."), sourced from
  asic-rs's structured MinerMessage.component (HashBoard idx / PowerSupply / Fan /
  ControlBoard) rather than fragile string matching on the summary. New MinerRow
  `faults` field + FaultComponent/Fault types; scan.rs maps messages -> faults.
- #2 A power-supply fault turns the bolt icon red, lists the PSU faults on its
  tooltip, and greys (not reds) every hashboard -- the boards can't be powered or
  tested, so they read "unpowered (PSU fault)".
- #3 When the miner reports board-specific faults, ONLY the named boards are red;
  the rest stay green. A whole-miner stall zeroes every board's hashrate, which
  previously reddened working boards the error codes actually exonerate.

Backend enabler (asic-rs patch 0012): the WhatsMiner V1 backend now sources faults
from get_error_code (like V2/V3; its summary error fields are empty on H6OS), and
a targeted repair fixes firmware that emits an invalid bare-pair error_code array.

Verified live: 10.7.1.231 (PSU) greys its boards + shows the 4 PSU faults on the
bolt; 10.8.1.234 (540/541/561) reds boards 1+2 and leaves board 3 green. Unit
tests cover the attribution and the malformed-array repair; all suites pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 17:30:18 -06:00
noahandClaude Opus 4.8 75663f4c23 asic-rs: implement LuxOS set_power_limit (via profiles); document ePIC PSU gating
Follow-up to the Round 15 corpus. The toolkit reported supports_power_limit=false
for LuxOS and ePIC; investigated both against the live corpus (S19j Pro).

LuxOS was genuinely under-reporting: it tunes by discrete named profiles that each
carry a Watts rating (the `profiles` RPC gives Step + Watts), applied via
profileset -- pure frequency/voltage tuning, no PSU dependency. Implemented
SetPowerLimit to map the requested watts to the highest profile whose Watts does
not exceed it (or the lowest profile when the target is below all of them). The
pure mapping (parse_profile_watts + select_profile_at_or_below) has a unit test.
Live-verified: set_power_limit(2500) on an S19j Pro picked step -4 (2385 W) and
the miner's active profile became 445MHz/-4.

ePIC is left at false, now with a comment explaining why: PowerPlay's only true
power-limit path is the PowerTune perpetual-tune algorithm, which the firmware
gates on the PSU -- on a fixed-voltage Bitmain APW12 (S19j Pro) it answers "Power
optimization is not supported by this PSU". That is a per-PSU runtime property the
synchronous capability check cannot see, so reporting true would over-advertise on
most reflashed Antminers. Hashrate tuning remains available via set_tuning_config.

Captured as asic-rs patch 0011. luxminer + epic crate tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 16:40:38 -06:00
noahandClaude Opus 4.8 9eb6a0f229 asic-rs: fix Antminer locate-LED (and reboot) on legacy web-UI firmware
Round 15 #7. The "flash the light" action failed on old (< 2023.07) Antminer
firmware -- the LuCI web-UI generation, e.g. the Z15/Z15J. set_fault_light
returned Ok(false) on live hardware while appearing to "succeed".

Root cause (confirmed on a live Z15): that firmware's blink.cgi ignores the JSON
body {"blink":"true"} the backend sent (answering 200 with an empty text/html
body, so the JSON parse fails and the error is swallowed into Ok(false)). Its own
blink.html POSTs a form field action=startBlink/stopBlink and reads state back via
action=onPageLoaded -> {"isBlinking":bool}; the action handler also often answers
401/500 even on success, so HTTP status is not a reliable signal.

Fix (v2020 backend): add a form-encoded POST helper; blink() now fires
action=startBlink/stopBlink, ignores the unreliable status, and reads the real
state back via onPageLoaded; set_fault_light reports success only when the observed
isBlinking matches the request. The LightFlashing read is routed to the same path
(get_blink_status.cgi is 404 here) and remapped to {"blink":bool}.

Also switch reboot() from POST to GET to match the same firmware's reboot.html (the
Restart action was affected); not live-fired, to avoid rebooting production miners.

Captured as asic-rs patch 0010. Also teach ci/compute-version.sh that vendor/* and
thirdparty/asic-rs/* are backend changes, so vendored fixes trigger a release.

Verified live: Z15/Z15J now return Ok(true) with the light genuinely toggling;
VNish (4 control boards) and WhatsMiner (H6OS/H616) unchanged; antminer tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 15:19:05 -06:00
noahandClaude Opus 4.8 bafbd519bb GUI round 15 (part 2, #13): Settings menu, localization, Logs page
Add a Settings menu (the old Credentials toolbar button is now "Settings")
containing Credentials, a Language sub-menu, and a Logs page.

Localization (#13): a small i18n layer -- visible strings are wrapped in
t("English") and looked up per language, falling back to English. Built-in
translations for Mandarin, Russian, French, Spanish and Portuguese cover the
toolbar buttons, KPI captions and table column headers; changing the language
re-labels them live (columns via a table rebuild) and localizes dialogs as
they open. The choice persists under the config dir and loads at startup.
(Dialog-internal strings and status text are not yet fully translated -- the
framework is in place to extend them.)

Logs page (#13): an in-app activity log (scans, operations applied, export,
language change) shown in Settings > Logs with Refresh / Clear.

New wx-rs bridge: menu sub-menus (menu_append_submenu). Bridge patches
0002/0003 regenerated. Unit tests + headless selftest pass; the Chinese UI
was verified rendering end to end.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 14:54:10 -06:00
noahandClaude Opus 4.8 0d19e958f0 GUI round 15 (part 1): pool dropdowns, aligned health icons, export, more
Twelve of the round-15 items (the code items; the live-hardware flashing/
testing and the settings/localization/logs work follow separately):

#1 Configure-pools: three pool rows (address, account, worker, password),
each field with a "+" dropdown of presets (top-11 BTC pool stratums;
worker-name placeholders) plus user-addable, persisted entries. Worker
picks insert at the cursor rather than replacing. Writes up to three pools
per miner via set_pools_config, worker expanded per unit.

#2 PIC detection: replace the broken SSH i2cdump (it read 0x48, the temp
sensor, not the PIC) with a model lookup -- no firmware exposes PIC over the
network, so infer it from the model (noPIC: S19k Pro, S21 family, T21,
explicit noPIC; PIC: rest of the S19 line).

#4 Zoom: an editable percent field in the status bar (type an exact scale)
and Ctrl +/- / Ctrl+0 to zoom in/out/reset.

#5 Health icons align in fixed slots (power, control, fans, hashboards);
miners with fewer fans/boards leave a gap so hashboards still line up. The
max fan/board counts are computed parametrically from the fleet.

#6 Light: the locate-light column is on by default (last), shown as a
green-over-red beacon flashing quickly instead of a single amber dot.

#8 The bottom-left status line is now scan-only; operation progress lives in
the Health column (per miner) and failures in the bottom-right indicator.

#9 / #10 / #11: drop the Credentials-dialog blurb; move the scan-ranges
format help to a tooltip; make Restore-to-stock a plain confirmation (no
typed keyword, no warning wall).

#12 Z15 fans: the v2020 backend now reads fans from higher fan slots
(the Z15 reports fan3/fan4 with fan1/fan2 = 0). Vendored patch 0009.

#14 Export: an Export button writes every scanned data point to a CSV, one
value per cell (lists expanded to indexed columns) -- complete and
machine-readable, unlike the on-screen table.

#15 Health tooltips are per-icon: hovering a specific fan or hashboard shows
just that component's state, with errors attributed to the board that names
them in the message.

New wx-rs bridge surface: widget tooltips, save-file dialog, insert-at-cursor,
status-bar zoom entry + Ctrl+/-, the light beacon + alignment-gap sentinels,
and per-icon cell tooltips (bridge patches 0002/0003 regenerated). Unit tests
(worker templates, PIC map, CSV export, health) + headless selftest pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 14:43:00 -06:00
38 changed files with 3489 additions and 357 deletions
+4 -2
View File
@@ -30,12 +30,14 @@ ui=false; backend=false
while IFS= read -r f; do
[ -z "$f" ] && continue
case "$f" in
crates/alkane-gui/src/ui.rs|crates/alkane-gui/src/fixtures.rs|thirdparty/wx-rs/*)
crates/alkane-gui/src/ui.rs|crates/alkane-gui/src/fixtures.rs|thirdparty/wx-rs/*|\
crates/alkane-gui/src/bin/*)
ui=true ;;
crates/alkane-core/*|crates/alkane-discovery/*|crates/alkane-access/*|\
crates/alkane-flash/*|crates/alkane-artifacts/*|crates/alkane-cli/*|\
crates/alkane-gui/src/scan.rs|crates/alkane-gui/src/model.rs|\
crates/alkane-gui/src/main.rs|Cargo.toml|Cargo.lock|.gitea/*|ci/*|scripts/*)
crates/alkane-gui/src/main.rs|Cargo.toml|Cargo.lock|.gitea/*|ci/*|scripts/*|\
vendor/*|thirdparty/asic-rs/*)
backend=true ;;
*) : ;; # docs, HANDOFF, README, thirdparty/wxwidgets tree: no bump
esac
@@ -1 +1,29 @@
<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="M184 120C184 89.1 209.1 64 240 64L264 64C281.7 64 296 78.3 296 96L296 544C296 561.7 281.7 576 264 576L232 576C202.2 576 177.1 555.6 170 528C169.3 528 168.7 528 168 528C123.8 528 88 492.2 88 448C88 430 94 413.4 104 400C84.6 385.4 72 362.2 72 336C72 305.1 89.6 278.2 115.2 264.9C108.1 252.9 104 238.9 104 224C104 179.8 139.8 144 184 144L184 120zM456 120L456 144C500.2 144 536 179.8 536 224C536 239 531.9 253 524.8 264.9C550.5 278.2 568 305 568 336C568 362.2 555.4 385.4 536 400C546 413.4 552 430 552 448C552 492.2 516.2 528 472 528C471.3 528 470.7 528 470 528C462.9 555.6 437.8 576 408 576L376 576C358.3 576 344 561.7 344 544L344 96C344 78.3 358.3 64 376 64L400 64C430.9 64 456 89.1 456 120z"/></svg>
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><g transform="translate(0.000000,512.000000) scale(0.100000,-0.100000)" >
<path d="M2152 4645 c-35 -8 -95 -28 -133 -46 l-70 -32 39 -41 c109 -115 121
-180 41 -222 -48 -24 -74 -11 -168 85 -225 229 -555 240 -774 25 l-59 -57 57
-22 c103 -38 134 -107 76 -166 -36 -36 -54 -36 -145 -3 -290 107 -608 -44
-712 -339 -13 -36 -13 -39 4 -32 147 57 237 37 237 -54 0 -56 -26 -78 -115
-101 -479 -123 -584 -723 -175 -995 92 -62 102 -71 105 -100 4 -40 -1 -56 -25
-80 -34 -35 -81 -33 -146 5 -28 17 -53 29 -55 27 -2 -2 14 -38 35 -80 114
-227 341 -383 586 -404 l70 -5 1 103 c4 397 280 752 674 870 70 21 101 23 447
28 l373 6 25 26 c19 18 28 42 35 85 15 107 57 173 141 219 54 30 55 30 234 33
108 2 191 -1 207 -7 60 -23 72 -111 21 -151 -23 -18 -41 -20 -185 -20 -200 0
-238 -16 -238 -98 0 -66 -30 -134 -84 -188 -82 -81 -98 -84 -482 -84 -348 0
-405 -6 -526 -55 -355 -144 -547 -560 -421 -912 156 -434 650 -621 1049 -398
60 34 224 176 224 195 0 4 -17 19 -38 33 -109 72 -138 132 -92 190 43 54 75
48 192 -36 291 -208 673 -260 1012 -136 205 74 390 218 518 399 71 102 72 106
48 140 -37 52 -90 177 -90 213 0 68 62 109 126 82 25 -10 36 -26 58 -81 153
-385 618 -488 905 -201 197 197 213 494 39 725 -38 52 -148 142 -172 142 -6 0
-20 -33 -30 -72 -33 -128 -107 -172 -175 -104 -31 32 -31 62 3 171 114 371
-43 798 -372 1015 -71 47 -198 108 -206 99 -3 -2 13 -40 35 -84 46 -92 43
-132 -12 -160 -64 -34 -95 -17 -149 81 -251 454 -793 618 -1249 378 -99 -52
-140 -57 -176 -18 -43 46 -30 109 28 144 l31 19 -39 17 c-102 42 -247 54 -363
29z"/>
<path d="M4064 2007 c-184 -270 -531 -485 -854 -529 -49 -7 -90 -16 -90 -20 0
-19 163 -171 228 -213 494 -318 1255 -101 1387 395 15 55 18 199 6 254 l-6 30
-155 1 c-119 1 -168 6 -210 19 -67 22 -184 79 -226 111 l-31 24 -49 -72z"/>
<path d="M2431 1509 c-51 -58 -53 -62 -47 -103 13 -83 97 -179 179 -205 18 -5
62 -12 98 -16 138 -13 125 -2 531 -464 231 -265 244 -275 305 -259 63 17 68
37 68 276 l0 214 -80 27 c-237 80 -440 241 -552 441 -23 41 -33 50 -56 50 -49
0 -179 30 -284 66 -55 19 -103 34 -105 34 -2 0 -28 -27 -57 -61z"/>
</g></svg>

Before

Width:  |  Height:  |  Size: 920 B

After

Width:  |  Height:  |  Size: 2.0 KiB

@@ -1 +1,38 @@
<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="M224 208C224 128.5 288.5 64 368 64C376.8 64 384 71.2 384 80L384 232.2C399 226.9 415.2 224 432 224C511.5 224 576 288.5 576 368C576 376.8 568.8 384 560 384L407.8 384C413.1 399 416 415.2 416 432C416 511.5 351.5 576 272 576C263.2 576 256 568.8 256 560L256 407.8C241 413.1 224.8 416 208 416C128.5 416 64 351.5 64 272C64 263.2 71.2 256 80 256L232.2 256C226.9 241 224 224.8 224 208zM320 352C337.7 352 352 337.7 352 320C352 302.3 337.7 288 320 288C302.3 288 288 302.3 288 320C288 337.7 302.3 352 320 352z"/></svg>
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><g transform="translate(0.000000,512.000000) scale(0.100000,-0.100000)" >
<path d="M1970 5109 c-158 -18 -233 -52 -290 -130 -63 -88 -40 -168 95 -329
290 -345 492 -728 595 -1130 7 -25 34 -86 61 -136 l49 -91 108 -6 c76 -3 130
-12 187 -31 44 -14 83 -22 87 -18 13 13 87 322 112 470 126 749 -33 1218 -462
1362 -134 45 -353 60 -542 39z"/>
<path d="M3615 4886 c-82 -30 -119 -107 -130 -271 -29 -409 -151 -830 -337
-1160 -41 -74 -72 -146 -94 -220 l-33 -110 34 -27 c45 -38 120 -139 157 -213
17 -33 32 -61 33 -63 10 -11 325 187 480 303 704 524 836 1036 386 1499 -221
228 -372 307 -496 262z"/>
<path d="M975 4370 c-226 -36 -431 -174 -638 -430 -97 -120 -131 -220 -107
-310 24 -90 105 -132 280 -145 435 -32 872 -164 1211 -366 30 -17 103 -47 163
-64 l108 -33 29 33 c42 48 130 113 209 154 l70 37 -56 99 c-246 438 -574 799
-857 943 -131 67 -298 101 -412 82z"/>
<path d="M4795 3451 c-23 -10 -86 -56 -140 -103 -326 -277 -690 -475 -1066
-579 -76 -21 -144 -48 -205 -82 l-91 -51 -6 -105 c-3 -75 -13 -130 -31 -186
-14 -44 -22 -83 -18 -87 10 -10 261 -74 382 -97 794 -154 1301 2 1450 447 74
222 63 625 -20 756 -63 99 -158 131 -255 87z"/>
<path d="M2443 3095 c-206 -45 -374 -215 -418 -422 -82 -385 263 -730 648
-648 209 44 378 213 423 424 81 385 -268 730 -653 646z m152 -179 c59 -25 75
-97 31 -141 -24 -24 -35 -28 -111 -40 -54 -9 -121 -76 -130 -130 -12 -76 -16
-87 -40 -111 -26 -26 -72 -32 -107 -13 -49 26 -54 133 -10 232 45 101 163 191
274 207 29 4 54 8 56 9 1 0 18 -5 37 -13z"/>
<path d="M767 3009 c-562 -63 -820 -407 -758 -1013 20 -185 49 -255 133 -316
87 -64 167 -40 333 100 329 276 698 475 1070 575 65 18 132 45 192 79 l93 51
0 73 c0 79 21 199 46 258 20 47 20 47 -116 83 -359 95 -742 138 -993 110z"/>
<path d="M1770 2244 c-141 -81 -339 -216 -449 -304 -716 -578 -764 -1101 -146
-1599 106 -85 171 -115 255 -115 139 -2 184 64 206 302 43 463 178 899 372
1206 14 23 40 90 58 151 l33 109 -40 34 c-48 41 -117 137 -155 215 -16 31 -31
57 -34 56 -3 0 -48 -25 -100 -55z"/>
<path d="M3098 2066 c-35 -44 -138 -121 -213 -158 -33 -17 -61 -32 -63 -33
-12 -10 203 -350 312 -494 527 -695 1026 -820 1490 -372 193 187 268 305 270
421 1 129 -67 183 -251 201 -210 20 -292 32 -408 55 -297 62 -591 172 -836
314 -36 21 -106 50 -155 64 -50 14 -97 28 -105 31 -8 3 -25 -9 -41 -29z"/>
<path d="M2256 1882 c-25 -41 -108 -428 -131 -612 -18 -143 -21 -439 -5 -550
74 -535 419 -776 1015 -710 174 19 246 50 305 131 63 87 39 170 -92 324 -277
326 -474 689 -579 1066 -21 74 -49 146 -82 207 l-51 92 -73 0 c-79 0 -200 21
-257 45 -41 17 -43 18 -50 7z"/>
</g></svg>

Before

Width:  |  Height:  |  Size: 727 B

After

Width:  |  Height:  |  Size: 2.5 KiB

+410 -6
View File
@@ -8,15 +8,26 @@
//! 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.
//! miner_probe setpl <ip> <watts>
//! Apply a power limit to ONE miner and print the setter's result. This
//! MUTATES the device -- capture and restore its prior configured limit
//! separately (e.g. WhatsMiner cgminer API on :4028 reports "Power Limit"
//! read-only). asic-rs has no power-limit read-back, so this tool cannot
//! restore on its own.
//!
//! Credentials come from ~/.config/alkane-toolkit/scan-credentials.txt, or from
//! ALKANE_PROBE_USER / ALKANE_PROBE_PASS if set (so a test can authenticate
//! without touching the app's saved config).
use asic_rs::MinerFactory;
use asic_rs::core::traits::miner::MinerAuth;
use futures_util::StreamExt;
use measurements::Power;
fn load_creds() -> Option<(String, String)> {
if let (Ok(u), Ok(pw)) = (std::env::var("ALKANE_PROBE_USER"), std::env::var("ALKANE_PROBE_PASS")) {
return Some((u, pw));
}
let home = std::env::var("HOME").ok()?;
let p = std::path::PathBuf::from(home)
.join(".config/alkane-toolkit/scan-credentials.txt");
@@ -51,7 +62,7 @@ async fn scan(cidrs: &[String]) {
}
};
}
println!("ip\tmake\tfirmware\tmodel_id\tcontrol_board\twatts\tsupports_power_limit\tsupports_tuning");
println!("ip\tmake\tfirmware\tfw_version\tmodel_id\tcontrol_board\twatts\tsupports_power_limit\tsupports_tuning\tbest_share\tsession_best_share");
let mut stream = f.scan_stream_with_ip();
let mut found = 0usize;
while let Some((ip, miner)) = stream.next().await {
@@ -63,10 +74,14 @@ async fn scan(cidrs: &[String]) {
.as_ref()
.map(|c| c.to_string())
.unwrap_or_default();
let fw_ver = data.firmware_version.clone().unwrap_or_default();
let bs = data.best_share.map(|v| format!("{v:.0}")).unwrap_or_default();
let sbs = data.session_best_share.map(|v| format!("{v:.0}")).unwrap_or_default();
println!(
"{ip}\t{}\t{}\t{}\t{}\t{watts:.0}\t{}\t{}",
"{ip}\t{}\t{}\t{}\t{}\t{}\t{watts:.0}\t{}\t{}\t{bs}\t{sbs}",
data.device_info.make,
data.device_info.firmware,
fw_ver,
data.device_info.model,
cb,
m.supports_set_power_limit(),
@@ -78,6 +93,349 @@ async fn scan(cidrs: &[String]) {
eprintln!("scan complete: {found} miner(s) responded");
}
/// Dump raw hashrate value/unit/algo (and expected) as asic-rs reports them,
/// to diagnose the SI-prefix handling for non-SHA algorithms (round-9 #8, Z15).
async fn hashrate(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\tmodel\talgo\thr_value\thr_unit\texp_value\texp_unit");
let mut stream = f.scan_stream_with_ip();
while let Some((ip, miner)) = stream.next().await {
if let Some(m) = miner {
let data = m.get_data().await;
let hr = data.hashrate.as_ref();
let exp = data.expected_hashrate.as_ref();
println!(
"{ip}\t{}\t{}\t{}\t{}\t{}\t{}",
data.device_info.model,
hr.map(|h| h.algo.to_string()).unwrap_or_default(),
hr.map(|h| h.value).unwrap_or(0.0),
hr.map(|h| format!("{:?}", h.unit)).unwrap_or_default(),
exp.map(|h| h.value).unwrap_or(0.0),
exp.map(|h| format!("{:?}", h.unit)).unwrap_or_default(),
);
}
}
eprintln!("hashrate dump complete");
}
async fn setpl(ip_s: &str, watts: f64) {
let ip: std::net::IpAddr = match ip_s.parse() {
Ok(ip) => ip,
Err(e) => {
eprintln!("bad ip {ip_s}: {e}");
return;
}
};
let f = factory();
match f.scan_miner(ip).await {
Ok(Some(m)) => {
let data = m.get_data().await;
eprintln!(
"target {ip}: {} {} {} (supports_power_limit={})",
data.device_info.make,
data.device_info.firmware,
data.device_info.model,
m.supports_set_power_limit()
);
match m.set_power_limit(Power::from_watts(watts)).await {
Ok(v) => println!("set_power_limit({watts:.0} W) -> Ok({v})"),
// {e:#} prints the full anyhow chain (the miner's own Msg is the
// root cause), which is exactly what we need to characterise #4.
Err(e) => println!("set_power_limit({watts:.0} W) -> Err: {e:#}"),
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// LOCAL-ONLY: toggle a miner's locate light on then back off, to validate the
/// (token-authenticated) write path safely -- the LED is reversible and does not
/// disturb mining. Restores the light to off afterward.
async fn led(ip_s: &str) {
let ip: std::net::IpAddr = match ip_s.parse() {
Ok(ip) => ip,
Err(e) => {
eprintln!("bad ip {ip_s}: {e}");
return;
}
};
let f = factory();
match f.scan_miner(ip).await {
Ok(Some(m)) => {
let data = m.get_data().await;
eprintln!(
"target {ip}: {} {} {} (supports_set_fault_light={})",
data.device_info.make,
data.device_info.firmware,
data.device_info.model,
m.supports_set_fault_light()
);
match m.set_fault_light(true).await {
Ok(v) => println!("set_fault_light(on) -> Ok({v})"),
Err(e) => println!("set_fault_light(on) -> Err: {e:#}"),
}
let after_on = m.get_data().await.light_flashing;
println!(" light_flashing after on = {after_on:?}");
// Restore: turn the locate light back off.
match m.set_fault_light(false).await {
Ok(v) => println!("set_fault_light(off) [restore] -> Ok({v})"),
Err(e) => println!("set_fault_light(off) [restore] -> Err: {e:#}"),
}
let after_off = m.get_data().await.light_flashing;
println!(" light_flashing after off = {after_off:?}");
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// Apply a single "default" pool group to ONE miner via asic-rs set_pools_config
/// (the same path the GUI's pool feature uses). MUTATES the device's pool config.
/// Usage: setpools <ip> <url> <user> <pass>
async fn setpools(ip_s: &str, url: &str, user: &str, pass: &str) {
use asic_rs::core::config::pools::{PoolConfig, PoolGroupConfig};
use asic_rs::core::data::pool::PoolURL;
let ip: std::net::IpAddr = match ip_s.parse() {
Ok(ip) => ip,
Err(e) => {
eprintln!("bad ip {ip_s}: {e}");
return;
}
};
let f = factory();
match f.scan_miner(ip).await {
Ok(Some(m)) => {
let data = m.get_data().await;
eprintln!(
"target {ip}: {} {} {} (supports_pools_config={})",
data.device_info.make,
data.device_info.firmware,
data.device_info.model,
m.supports_pools_config()
);
let group = PoolGroupConfig {
name: "default".to_string(),
quota: 1,
pools: vec![PoolConfig {
url: PoolURL::from(url.to_string()),
username: user.to_string(),
password: pass.to_string(),
}],
};
match m.set_pools_config(vec![group]).await {
Ok(v) => println!("set_pools_config -> Ok({v})"),
Err(e) => println!("set_pools_config -> Err: {e:#}"),
}
// Read back the configured pools to verify.
let after = m.get_data().await;
for (i, p) in after.pools.iter().flat_map(|g| g.pools.iter()).enumerate() {
let u = p.url.as_ref().map(|u| u.to_string()).unwrap_or_default();
let acct = p.user.clone().unwrap_or_default();
println!(" pool[{i}] {u} user={acct}");
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// READ-ONLY: dump a miner's structured messages (code + severity + component +
/// text) plus its per-board data, to design health/error attribution.
async fn msgs(ip_s: &str) {
let ip: std::net::IpAddr = match ip_s.parse() {
Ok(ip) => ip,
Err(e) => {
eprintln!("bad ip {ip_s}: {e}");
return;
}
};
let f = factory();
match f.scan_miner(ip).await {
Ok(Some(m)) => {
let d = m.get_data().await;
println!(
"{ip}: {} {} hashboards={:?} expected={:?}",
d.device_info.firmware,
d.device_info.model,
d.hashboards.len(),
d.expected_hashboards,
);
for b in d.hashboards.iter() {
println!(
" board position={} hashrate={:?} chips={:?}/{:?}",
b.position,
b.hashrate.clone().map(|h| h.as_unit(asic_rs::core::data::hashrate::HashRateUnit::TeraHash).value),
b.working_chips,
b.expected_chips,
);
}
if d.messages.is_empty() {
println!(" (no messages)");
}
for msg in &d.messages {
println!(
" MSG code={} sev={:?} comp={:?} :: {}",
msg.code, msg.severity, msg.component, msg.message
);
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// Set the locate light to an explicit on/off state (round 16/G1). Capability-gated.
async fn light(ip_s: &str, on: bool) {
let Ok(ip) = ip_s.parse::<std::net::IpAddr>() else {
eprintln!("bad ip {ip_s}");
return;
};
match factory().scan_miner(ip).await {
Ok(Some(m)) => {
if !m.supports_set_fault_light() {
eprintln!("{ip}: locate light not supported");
return;
}
match m.set_fault_light(on).await {
Ok(v) => println!("{ip} light {} -> Ok({v})", if on { "on" } else { "off" }),
Err(e) => println!("{ip} light -> Err: {e:#}"),
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// Run a simple lifecycle action (restart / pause / resume) on one miner (G1).
/// Capability-gated; MUTATES (pause/restart disrupt mining -- run on the test bed).
async fn lifecycle(ip_s: &str, verb: &str) {
let Ok(ip) = ip_s.parse::<std::net::IpAddr>() else {
eprintln!("bad ip {ip_s}");
return;
};
match factory().scan_miner(ip).await {
Ok(Some(m)) => {
let res = match verb {
"restart" if m.supports_restart() => m.restart().await,
"pause" if m.supports_pause() => m.pause(None).await,
"resume" if m.supports_resume() => m.resume(None).await,
"restart" | "pause" | "resume" => {
eprintln!("{ip}: {verb} not supported");
return;
}
_ => {
eprintln!("unknown lifecycle verb {verb}");
return;
}
};
match res {
Ok(v) => println!("{ip} {verb} -> Ok({v})"),
Err(e) => println!("{ip} {verb} -> Err: {e:#}"),
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// Read (no tz arg) or set the miner's timezone (round 16 / G10). Capability-gated.
async fn timezone(ip_s: &str, tz: Option<&str>) {
use asic_rs::core::config::timezone::{Tz, TimezoneConfig};
let Ok(ip) = ip_s.parse::<std::net::IpAddr>() else {
eprintln!("bad ip {ip_s}");
return;
};
match factory().scan_miner(ip).await {
Ok(Some(m)) => {
if !m.supports_timezone_config() {
eprintln!("{ip}: timezone config not supported");
return;
}
if let Some(tz_s) = tz {
let Ok(zone) = tz_s.parse::<Tz>() else {
eprintln!("bad IANA timezone '{tz_s}' (e.g. America/Edmonton)");
return;
};
let cfg = TimezoneConfig {
timezone: Some(zone),
available: Vec::new(),
};
match m.set_timezone_config(cfg).await {
Ok(v) => println!("{ip} set timezone {zone} -> Ok({v})"),
Err(e) => println!("{ip} set timezone -> Err: {e:#}"),
}
}
match m.get_timezone_config().await {
Ok(c) => println!(
"{ip} timezone now: {:?} ({} available)",
c.timezone.map(|t| t.to_string()),
c.available.len()
),
Err(e) => println!("{ip} read timezone -> Err: {e:#}"),
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// Change the miner's web/API password (round 16 / G11). Capability-gated.
/// DANGEROUS: a failed change can lock the toolkit out -- use a dedicated unit.
async fn passwd(ip_s: &str, newpass: &str) {
let Ok(ip) = ip_s.parse::<std::net::IpAddr>() else {
eprintln!("bad ip {ip_s}");
return;
};
match factory().scan_miner(ip).await {
Ok(Some(mut m)) => {
if !m.supports_change_password() {
eprintln!("{ip}: change password not supported");
return;
}
match m.change_password(newpass).await {
Ok(v) => println!("{ip} change_password -> Ok({v})"),
Err(e) => println!("{ip} change_password -> Err: {e:#}"),
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// Factory-reset the miner (round 16 / G12). Capability-gated. DESTRUCTIVE:
/// wipes config and may reset the network (unit can drop off its IP) -- only run
/// on a sacrificial/console-attached unit.
async fn factoryreset(ip_s: &str) {
let Ok(ip) = ip_s.parse::<std::net::IpAddr>() else {
eprintln!("bad ip {ip_s}");
return;
};
match factory().scan_miner(ip).await {
Ok(Some(m)) => {
if !m.supports_factory_reset() {
eprintln!("{ip}: factory reset not supported");
return;
}
match m.factory_reset().await {
Ok(v) => println!("{ip} factory_reset -> Ok({v})"),
Err(e) => println!("{ip} factory_reset -> Err: {e:#}"),
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
fn main() {
let args: Vec<String> = std::env::args().collect();
let rt = match tokio::runtime::Builder::new_current_thread().enable_all().build() {
@@ -89,8 +447,54 @@ fn main() {
};
match args.get(1).map(String::as_str) {
Some("scan") if args.len() >= 3 => rt.block_on(scan(&args[2..])),
Some("hashrate") if args.len() >= 3 => rt.block_on(hashrate(&args[2..])),
Some("setpl") if args.len() == 4 => {
let watts: f64 = args[3].parse().unwrap_or(-1.0);
if watts <= 0.0 {
eprintln!("watts must be a positive number");
std::process::exit(2);
}
rt.block_on(setpl(&args[2], watts));
}
Some("led") if args.len() == 3 => rt.block_on(led(&args[2])),
Some("light") if args.len() == 4 && matches!(args[3].as_str(), "on" | "off") => {
rt.block_on(light(&args[2], args[3] == "on"))
}
Some(v @ ("restart" | "pause" | "resume")) if args.len() == 3 => {
rt.block_on(lifecycle(&args[2], v))
}
Some("setpools") if args.len() == 6 => {
rt.block_on(setpools(&args[2], &args[3], &args[4], &args[5]))
}
Some("msgs") if args.len() == 3 => rt.block_on(msgs(&args[2])),
Some("timezone") if args.len() == 3 => rt.block_on(timezone(&args[2], None)),
Some("timezone") if args.len() == 4 => rt.block_on(timezone(&args[2], Some(&args[3]))),
Some("passwd") if args.len() == 4 => rt.block_on(passwd(&args[2], &args[3])),
Some("factoryreset") if args.len() == 3 => rt.block_on(factoryreset(&args[2])),
_ => {
eprintln!("usage: miner_probe scan <cidr> [<cidr>...]");
eprintln!(
"miner_probe -- asic-rs config + scan CLI for the alkane-toolkit fleet\n\
\n\
READ (safe on any miner):\n\
\x20 scan <cidr> [<cidr>...] discover + telemetry (TSV)\n\
\x20 hashrate <cidr> [<cidr>...] raw hashrate/algo dump\n\
\x20 msgs <ip> structured faults + per-board data\n\
\n\
WRITE (MUTATES the miner -- use the test-bed miners, not production):\n\
\x20 light <ip> <on|off> set the locate light\n\
\x20 led <ip> toggle locate light on then off (reversible test)\n\
\x20 pause <ip> pause mining\n\
\x20 resume <ip> resume mining\n\
\x20 restart <ip> restart/reboot\n\
\x20 setpl <ip> <watts> set power limit\n\
\x20 setpools <ip> <url> <user> <pass> set the default pool group\n\
\x20 timezone <ip> [<IANA>] read (no arg) or set the timezone\n\
\x20 passwd <ip> <newpass> change the web/API password (DANGEROUS)\n\
\x20 factoryreset <ip> factory reset (DESTRUCTIVE; sacrificial units only)\n\
\n\
Each write verb is capability-gated (skips miners that do not support it).\n\
Credentials: ALKANE_PROBE_USER/PASS or ~/.config/alkane-toolkit/scan-credentials.txt."
);
std::process::exit(2);
}
}
+187
View File
@@ -0,0 +1,187 @@
//! CSV export of the full scan data (round 15 #14).
//!
//! Unlike the on-screen table (which packs several values into one cell, e.g.
//! "95T/96T" or a row of health icons), the export is one value per cell and
//! covers every scanned data point, so it is complete and machine-readable.
//! Variable-length fields (per-board temps, per-fan RPMs, per-board health, the
//! pool list) are expanded into indexed columns out to the widest miner in the
//! set, so every row has the same columns.
use crate::model::{BoardHealth, MinerRow};
/// Escape one CSV field: quote it when it contains a comma, quote, CR or LF, and
/// double any embedded quotes.
fn esc(s: &str) -> String {
if s.contains([',', '"', '\n', '\r']) {
format!("\"{}\"", s.replace('"', "\"\""))
} else {
s.to_string()
}
}
fn num(v: f64) -> String {
if v == 0.0 {
String::new()
} else if v.fract() == 0.0 {
format!("{v:.0}")
} else {
format!("{v:.3}")
}
}
fn opt_bool(v: Option<bool>, yes: &str, no: &str) -> String {
match v {
Some(true) => yes.to_string(),
Some(false) => no.to_string(),
None => String::new(),
}
}
fn board_health_str(h: &BoardHealth) -> &'static str {
match h {
BoardHealth::Ok => "ok",
BoardHealth::Fault => "fault",
BoardHealth::Missing => "missing",
}
}
/// The fixed scalar columns, in order: (header, extractor).
type Col = (&'static str, fn(&MinerRow) -> String);
fn scalar_columns() -> Vec<Col> {
vec![
("ip", |r| r.ip.clone()),
("model", |r| r.model.clone()),
("brand", |r| r.brand.clone()),
("submodel", |r| r.submodel.clone()),
("mac", |r| r.mac.clone()),
("hostname", |r| r.hostname.clone()),
("serial", |r| r.serial.clone()),
("firmware", |r| r.firmware.clone()),
("fw_version", |r| r.fw_version.clone()),
("api_version", |r| r.api_version.clone()),
("control_board", |r| r.control_board.clone()),
("cpu", |r| r.cpu.clone()),
("board_code", |r| r.board_code.clone()),
("algorithm", |r| r.algorithm.clone()),
("status", |r| r.status().to_string()),
("operating_state", |r| r.operating_state.clone()),
("is_mining", |r| r.is_mining.to_string()),
("slow", |r| r.slow.to_string()),
("paused", |r| r.paused.to_string()),
("pic", |r| opt_bool(r.pic_present, "PIC", "noPIC")),
("write_locked", |r| opt_bool(r.write_locked, "locked", "unlocked")),
("light_flashing", |r| opt_bool(r.light_flashing, "on", "off")),
("hashrate_ths", |r| num(r.hashrate_ths)),
("expected_ths", |r| num(r.expected_ths)),
("efficiency_j_th", |r| num(r.efficiency)),
("power_w", |r| num(r.power_w)),
("tuning_percent", |r| r.tuning_percent.map(|v| v.to_string()).unwrap_or_default()),
("chip_temp_c", |r| num(r.chip_temp_c)),
("fluid_temp_c", |r| num(r.fluid_temp_c)),
("env_temp_c", |r| num(r.env_temp_c)),
("outlet_temp_c", |r| num(r.outlet_temp_c)),
("psu_fan_rpm", |r| num(r.psu_fan_rpm)),
("fan_count", |r| r.fan_count.map(|v| v.to_string()).unwrap_or_default()),
("expected_fans", |r| r.expected_fans.map(|v| v.to_string()).unwrap_or_default()),
("total_chips", |r| r.total_chips.map(|v| v.to_string()).unwrap_or_default()),
("expected_chips", |r| r.expected_chips.map(|v| v.to_string()).unwrap_or_default()),
("hashboards", |r| r.hashboards.map(|v| v.to_string()).unwrap_or_default()),
("expected_hashboards", |r| r.expected_hashboards.map(|v| v.to_string()).unwrap_or_default()),
("uptime_secs", |r| if r.uptime_secs > 0 { r.uptime_secs.to_string() } else { String::new() }),
("best_share", |r| r.best_share.map(num).unwrap_or_default()),
("session_best_share", |r| r.session_best_share.map(num).unwrap_or_default()),
("pool_account", |r| r.worker.split_once('.').map(|(a, _)| a).unwrap_or(&r.worker).to_string()),
("pool_url", |r| r.pool_url.clone()),
("errors", |r| r.errors.join("; ")),
]
}
/// Build the full CSV for `rows`. Empty rows still emit a header line.
pub fn rows_to_csv(rows: &[MinerRow]) -> String {
let cols = scalar_columns();
// Widest variable-length fields across the set.
let max_board_temps = rows.iter().map(|r| r.board_temps.len()).max().unwrap_or(0);
let max_fans = rows.iter().map(|r| r.fan_rpms.len()).max().unwrap_or(0);
let max_boards = rows.iter().map(|r| r.board_status.len()).max().unwrap_or(0);
let max_pools = rows.iter().map(|r| r.pools.len()).max().unwrap_or(0);
// Header.
let mut headers: Vec<String> = cols.iter().map(|(h, _)| (*h).to_string()).collect();
for i in 1..=max_board_temps {
headers.push(format!("board_temp_{i}_c"));
}
for i in 1..=max_fans {
headers.push(format!("fan_{i}_rpm"));
}
for i in 1..=max_boards {
headers.push(format!("board_{i}_status"));
}
for i in 1..=max_pools {
headers.push(format!("pool_{i}_url"));
headers.push(format!("pool_{i}_worker"));
}
let mut out = String::new();
out.push_str(&headers.iter().map(|h| esc(h)).collect::<Vec<_>>().join(","));
out.push('\n');
for r in rows {
let mut vals: Vec<String> = cols.iter().map(|(_, f)| f(r)).collect();
for i in 0..max_board_temps {
vals.push(r.board_temps.get(i).map(|&t| num(t)).unwrap_or_default());
}
for i in 0..max_fans {
vals.push(r.fan_rpms.get(i).map(|&t| num(t)).unwrap_or_default());
}
for i in 0..max_boards {
vals.push(r.board_status.get(i).map(board_health_str).unwrap_or("").to_string());
}
for i in 0..max_pools {
let (u, w) = r.pools.get(i).cloned().unwrap_or_default();
vals.push(u);
vals.push(w);
}
out.push_str(&vals.iter().map(|v| esc(v)).collect::<Vec<_>>().join(","));
out.push('\n');
}
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn csv_has_header_and_one_row_per_miner() {
let rows = vec![
MinerRow {
ip: "10.0.0.1".into(),
model: "S19".into(),
hashrate_ths: 95.0,
expected_ths: 96.0,
board_temps: vec![77.0, 64.0, 74.0],
fan_rpms: vec![6000.0, 6100.0],
..Default::default()
},
MinerRow { ip: "10.0.0.2".into(), model: "M30S".into(), ..Default::default() },
];
let csv = rows_to_csv(&rows);
let lines: Vec<&str> = csv.lines().collect();
assert_eq!(lines.len(), 3, "header + 2 rows");
assert!(lines[0].starts_with("ip,model,brand,"));
// Expanded columns out to the widest miner (3 board temps, 2 fans).
assert!(lines[0].contains("board_temp_3_c"));
assert!(lines[0].contains("fan_2_rpm"));
assert!(lines[1].starts_with("10.0.0.1,S19,"));
// One value per cell: hashrate and expected are separate columns.
assert!(lines[1].contains(",95,96,") || lines[1].contains("95,96"));
}
#[test]
fn csv_escapes_commas_and_quotes() {
assert_eq!(esc("a,b"), "\"a,b\"");
assert_eq!(esc("he said \"hi\""), "\"he said \"\"hi\"\"\"");
assert_eq!(esc("plain"), "plain");
}
}
+162
View File
@@ -0,0 +1,162 @@
//! Lightweight UI localization (round 15 #13).
//!
//! Visible strings are wrapped in `t("English text")`; the English text is the
//! lookup key. `t` returns the translation for the current language, falling back
//! to the English key when a string has no translation yet. The language is a
//! process-global, persisted under the config dir; changing it re-titles the
//! table columns and toolbar/KPI labels live and localizes dialogs as they open.
use std::path::PathBuf;
use std::sync::atomic::{AtomicU8, Ordering};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Lang {
En,
Zh,
Ru,
Fr,
Es,
Pt,
}
impl Lang {
pub fn all() -> [Lang; 6] {
[Lang::En, Lang::Zh, Lang::Ru, Lang::Fr, Lang::Es, Lang::Pt]
}
/// The language's own name, for the selector menu.
pub fn label(self) -> &'static str {
match self {
Lang::En => "English",
Lang::Zh => "\u{4e2d}\u{6587}", // 中文
Lang::Ru => "\u{0420}\u{0443}\u{0441}\u{0441}\u{043a}\u{0438}\u{0439}", // Русский
Lang::Fr => "Fran\u{e7}ais",
Lang::Es => "Espa\u{f1}ol",
Lang::Pt => "Portugu\u{ea}s",
}
}
fn code(self) -> &'static str {
match self {
Lang::En => "en",
Lang::Zh => "zh",
Lang::Ru => "ru",
Lang::Fr => "fr",
Lang::Es => "es",
Lang::Pt => "pt",
}
}
fn from_code(s: &str) -> Lang {
match s.trim() {
"zh" => Lang::Zh,
"ru" => Lang::Ru,
"fr" => Lang::Fr,
"es" => Lang::Es,
"pt" => Lang::Pt,
_ => Lang::En,
}
}
fn index(self) -> usize {
match self {
Lang::En => 0,
Lang::Zh => 1,
Lang::Ru => 2,
Lang::Fr => 3,
Lang::Es => 4,
Lang::Pt => 5,
}
}
}
static CURRENT: AtomicU8 = AtomicU8::new(0);
const LANG_FILE: &str = "language.txt";
fn config_path() -> PathBuf {
let home = std::env::var("HOME").unwrap_or_else(|_| ".".into());
PathBuf::from(home).join(".config/alkane-toolkit").join(LANG_FILE)
}
/// Load the saved language into the global (call once at startup).
pub fn init() {
let l = std::fs::read_to_string(config_path())
.ok()
.map(|s| Lang::from_code(&s))
.unwrap_or(Lang::En);
CURRENT.store(lang_to_u8(l), Ordering::Relaxed);
}
pub fn current() -> Lang {
u8_to_lang(CURRENT.load(Ordering::Relaxed))
}
/// Set + persist the language.
pub fn set(l: Lang) {
CURRENT.store(lang_to_u8(l), Ordering::Relaxed);
let p = config_path();
if let Some(dir) = p.parent() {
let _ = std::fs::create_dir_all(dir);
}
let _ = std::fs::write(p, l.code());
}
fn lang_to_u8(l: Lang) -> u8 {
l.index() as u8
}
fn u8_to_lang(v: u8) -> Lang {
Lang::all().get(v as usize).copied().unwrap_or(Lang::En)
}
/// Translate `key` (an English string) to the current language, or return `key`
/// when there is no translation.
pub fn t(key: &str) -> String {
let lang = current();
if lang == Lang::En {
return key.to_string();
}
for (en, tr) in TABLE {
if *en == key {
let s = tr[lang.index()];
if !s.is_empty() {
return s.to_string();
}
break;
}
}
key.to_string()
}
// Translation table: (English, [en, zh, ru, fr, es, pt]). The en slot mirrors the
// key (unused by `t`, kept for readability). An empty slot falls back to English.
#[rustfmt::skip]
const TABLE: &[(&str, [&str; 6])] = &[
// Toolbar + settings
("Scan ranges", ["Scan ranges", "\u{626b}\u{63cf}\u{8303}\u{56f4}", "\u{0414}\u{0438}\u{0430}\u{043f}\u{0430}\u{0437}\u{043e}\u{043d}\u{044b}", "Plages", "Rangos", "Faixas"]),
("Presets", ["Presets", "\u{9884}\u{8bbe}", "\u{041f}\u{0440}\u{0435}\u{0441}\u{0435}\u{0442}\u{044b}", "Pr\u{e9}r\u{e9}glages", "Ajustes", "Predefini\u{e7}\u{f5}es"]),
("Filter", ["Filter", "\u{7b5b}\u{9009}", "\u{0424}\u{0438}\u{043b}\u{044c}\u{0442}\u{0440}", "Filtre", "Filtro", "Filtro"]),
("Columns", ["Columns", "\u{5217}", "\u{0421}\u{0442}\u{043e}\u{043b}\u{0431}\u{0446}\u{044b}", "Colonnes", "Columnas", "Colunas"]),
("Export", ["Export", "\u{5bfc}\u{51fa}", "\u{042d}\u{043a}\u{0441}\u{043f}\u{043e}\u{0440}\u{0442}", "Exporter", "Exportar", "Exportar"]),
("Settings", ["Settings", "\u{8bbe}\u{7f6e}", "\u{041d}\u{0430}\u{0441}\u{0442}\u{0440}\u{043e}\u{0439}\u{043a}\u{0438}", "Param\u{e8}tres", "Ajustes", "Configura\u{e7}\u{f5}es"]),
("Credentials", ["Credentials", "\u{51ed}\u{636e}", "\u{0423}\u{0447}\u{0451}\u{0442}\u{043d}\u{044b}\u{0435} \u{0434}\u{0430}\u{043d}\u{043d}\u{044b}\u{0435}", "Identifiants", "Credenciales", "Credenciais"]),
("Language", ["Language", "\u{8bed}\u{8a00}", "\u{042f}\u{0437}\u{044b}\u{043a}", "Langue", "Idioma", "Idioma"]),
("Logs", ["Logs", "\u{65e5}\u{5fd7}", "\u{0416}\u{0443}\u{0440}\u{043d}\u{0430}\u{043b}", "Journaux", "Registros", "Registos"]),
// KPI captions
("Total", ["Total", "\u{603b}\u{6570}", "\u{0412}\u{0441}\u{0435}\u{0433}\u{043e}", "Total", "Total", "Total"]),
("Hashing", ["Hashing", "\u{6b63}\u{5728}\u{6316}\u{77ff}", "\u{0425}\u{0435}\u{0448}\u{0438}\u{0440}\u{043e}\u{0432}\u{0430}\u{043d}\u{0438}\u{0435}", "Minage", "Minando", "Minerando"]),
("Slow", ["Slow", "\u{7f13}\u{6162}", "\u{041c}\u{0435}\u{0434}\u{043b}\u{0435}\u{043d}\u{043d}\u{043e}", "Lent", "Lento", "Lento"]),
("Not hashing", ["Not hashing", "\u{672a}\u{6316}\u{77ff}", "\u{041d}\u{0435} \u{0445}\u{0435}\u{0448}\u{0438}\u{0440}\u{0443}\u{0435}\u{0442}", "Inactif", "Inactivo", "Inativo"]),
("Paused", ["Paused", "\u{5df2}\u{6682}\u{505c}", "\u{041f}\u{0430}\u{0443}\u{0437}\u{0430}", "En pause", "Pausado", "Pausado"]),
("Est. power", ["Est. power", "\u{4f30}\u{8ba1}\u{529f}\u{7387}", "\u{041e}\u{0446}. \u{043c}\u{043e}\u{0449}\u{043d}.", "Puiss. est.", "Pot. est.", "Pot. est."]),
// Column headers (the default-visible set + common ones)
("Model", ["Model", "\u{578b}\u{53f7}", "\u{041c}\u{043e}\u{0434}\u{0435}\u{043b}\u{044c}", "Mod\u{e8}le", "Modelo", "Modelo"]),
("Health", ["Health", "\u{72b6}\u{6001}", "\u{0421}\u{043e}\u{0441}\u{0442}\u{043e}\u{044f}\u{043d}\u{0438}\u{0435}", "\u{c9}tat", "Estado", "Sa\u{fa}de"]),
("Hashrate", ["Hashrate", "\u{7b97}\u{529b}", "\u{0425}\u{0435}\u{0448}\u{0440}\u{0435}\u{0439}\u{0442}", "Hashrate", "Hashrate", "Hashrate"]),
("Power", ["Power", "\u{529f}\u{7387}", "\u{041c}\u{043e}\u{0449}\u{043d}\u{043e}\u{0441}\u{0442}\u{044c}", "Puissance", "Potencia", "Pot\u{ea}ncia"]),
("Chip temp", ["Chip temp", "\u{82af}\u{7247}\u{6e29}\u{5ea6}", "\u{0422}\u{0435}\u{043c}\u{043f}. \u{0447}\u{0438}\u{043f}\u{0430}", "Temp. puce", "Temp. chip", "Temp. chip"]),
("Firmware", ["Firmware", "\u{56fa}\u{4ef6}", "\u{041f}\u{0440}\u{043e}\u{0448}\u{0438}\u{0432}\u{043a}\u{0430}", "Firmware", "Firmware", "Firmware"]),
("CPU", ["CPU", "CPU", "\u{041f}\u{0440}\u{043e}\u{0446}.", "Processeur", "CPU", "CPU"]),
("Access", ["Access", "\u{8bbf}\u{95ee}", "\u{0414}\u{043e}\u{0441}\u{0442}\u{0443}\u{043f}", "Acc\u{e8}s", "Acceso", "Acesso"]),
("Light", ["Light", "\u{6307}\u{793a}\u{706f}", "\u{041f}\u{043e}\u{0434}\u{0441}\u{0432}\u{0435}\u{0442}\u{043a}\u{0430}", "Voyant", "Luz", "Luz"]),
("Fan (RPM)", ["Fan (RPM)", "\u{98ce}\u{6247} (RPM)", "\u{0412}\u{0435}\u{043d}\u{0442}. (\u{043e}\u{0431}/\u{043c}\u{0438}\u{043d})", "Ventilo (TR/M)", "Ventilador (RPM)", "Ventoinha (RPM)"]),
("Control Board", ["Control Board", "\u{63a7}\u{5236}\u{677f}", "\u{041f}\u{043b}\u{0430}\u{0442}\u{0430} \u{0443}\u{043f}\u{0440}.", "Carte de contr\u{f4}le", "Placa control", "Placa controlo"]),
("Uptime", ["Uptime", "\u{8fd0}\u{884c}\u{65f6}\u{95f4}", "\u{0412}\u{0440}\u{0435}\u{043c}\u{044f} \u{0440}\u{0430}\u{0431}.", "Dur\u{e9}e", "Tiempo activo", "Tempo ativo"]),
("Serial", ["Serial", "\u{5e8f}\u{5217}\u{53f7}", "\u{0421}\u{0435}\u{0440}\u{0438}\u{0439}\u{043d}\u{044b}\u{0439}", "N\u{b0} de s\u{e9}rie", "N\u{b0} de serie", "N\u{b0} de s\u{e9}rie"]),
];
+42
View File
@@ -0,0 +1,42 @@
//! In-app activity log (round 15 #13). A small, process-global ring buffer of
//! timestamped messages -- scans starting/finishing, operations applied, errors --
//! shown in the Settings > Logs page. Thread-safe so background workers can append.
use std::sync::Mutex;
use std::time::{SystemTime, UNIX_EPOCH};
const MAX_ENTRIES: usize = 2000;
static LOG: Mutex<Vec<String>> = Mutex::new(Vec::new());
/// Local wall-clock HH:MM:SS for a log line. Uses the system clock offset from
/// UTC via the TZ-less epoch; good enough for an activity log timestamp.
fn stamp() -> String {
let secs = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(0);
let t = secs % 86_400;
format!("{:02}:{:02}:{:02}", t / 3600, (t % 3600) / 60, t % 60)
}
/// Append a message to the activity log (timestamped).
pub fn log(msg: impl Into<String>) {
let line = format!("{} {}", stamp(), msg.into());
if let Ok(mut v) = LOG.lock() {
v.push(line);
let len = v.len();
if len > MAX_ENTRIES {
v.drain(0..len - MAX_ENTRIES);
}
}
}
/// The whole log as one string, newest last (for the Logs page text box).
pub fn dump() -> String {
LOG.lock().map(|v| v.join("\n")).unwrap_or_default()
}
/// Clear the log.
pub fn clear() {
if let Ok(mut v) = LOG.lock() {
v.clear();
}
}
+7
View File
@@ -3,10 +3,14 @@
mod access_probe;
mod credentials;
mod export;
mod fixtures;
mod i18n;
mod logs;
mod log_scan;
mod model;
mod naming;
mod pool_prefs;
mod presets;
mod restore;
mod scan;
@@ -65,6 +69,9 @@ fn main() {
std::process::exit(0);
}
// Load the saved UI language before any strings are built (round 15 #13).
i18n::init();
// Bootstrap the wx app + main frame (upstream bridge).
wx_rs::init_app("alkane-toolkit", 1280, 800);
// Follow the system light/dark appearance.
+261 -22
View File
@@ -275,6 +275,30 @@ pub enum BoardHealth {
Missing,
}
/// Which physical component a miner fault message is attributed to (round 16 #1).
/// Mapped from asic-rs's structured `MinerMessage.component`; `Other` covers
/// messages with no specific component (e.g. an ambient-temperature warning).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FaultComponent {
Power,
Control,
Fan(usize),
Board(usize),
Other,
}
/// One structured fault/message from a miner (round 16 #1). Carries the specific
/// human-readable text and the component it belongs to, so the Health column's
/// per-icon tooltips can show the actual fault (e.g. "Slot 0 error reading chip
/// id") on the specific board rather than a generic "faulted".
#[derive(Debug, Clone)]
pub struct Fault {
pub component: FaultComponent,
pub message: String,
/// True for Error severity; false for Warning. (Info is dropped upstream.)
pub is_error: bool,
}
/// One component's health for the Health icon column (round 13 #3). Rendered as a
/// coloured icon: grey = unreachable / not detected, red = detected but not
/// functioning, yellow = functioning sub-optimally, green = fully functioning.
@@ -353,6 +377,9 @@ pub struct MinerRow {
/// severe first. Empty means none. The Error column shows a summary; the
/// full list is the hover tooltip (added with the tooltip bridge support).
pub errors: Vec<String>,
/// Structured faults with their attributed component (round 16 #1/#2/#3),
/// used to colour each Health icon and drive its specific per-icon tooltip.
pub faults: Vec<Fault>,
// performance
pub hashrate_ths: f64,
pub expected_ths: f64,
@@ -431,6 +458,11 @@ impl MinerRow {
/// live); grey (unknown) otherwise -- asic-rs has no direct PSU-fault flag, so
/// a missing wattage reading is treated as unknown, never a false "down".
pub fn power_health(&self) -> CompHealth {
// A reported power-supply fault (round 16 #2) is authoritative: red, even
// if a residual wattage is still being read.
if self.faults_for(FaultComponent::Power).next().is_some() {
return CompHealth::Down;
}
if self.power_w > 0.0 || self.psu_fan_rpm > 0.0 || self.is_mining {
CompHealth::Ok
} else {
@@ -438,11 +470,39 @@ impl MinerRow {
}
}
/// Control-board health (round 13 #3). The miner answered the scan, so its
/// control board is reachable and running; there is no network signal for a
/// degraded controller, so this is green for any responding miner.
/// Control-board health (round 13 #3, round 16 #1). The miner answered the
/// scan, so its control board is reachable; red if the miner reports a
/// control-board fault, yellow if it reports a miner-level fault with no
/// specific component (e.g. ambient temperature too high), else green.
pub fn control_health(&self) -> CompHealth {
CompHealth::Ok
if self.faults_for(FaultComponent::Control).next().is_some() {
CompHealth::Down
} else if self.general_faults().next().is_some() {
CompHealth::Degraded
} else {
CompHealth::Ok
}
}
/// Iterator over this row's Error-severity faults for a given component.
fn faults_for(&self, component: FaultComponent) -> impl Iterator<Item = &Fault> {
self.faults
.iter()
.filter(move |f| f.is_error && f.component == component)
}
/// Error-severity faults not tied to a specific component (control-board /
/// miner-level), for the control-board icon tooltip.
fn general_faults(&self) -> impl Iterator<Item = &Fault> {
self.faults
.iter()
.filter(|f| f.is_error && matches!(f.component, FaultComponent::Other))
}
/// True when the miner reports a power-supply fault, which means the
/// hashboards cannot be powered or evaluated (round 16 #2).
fn power_supply_faulted(&self) -> bool {
self.faults_for(FaultComponent::Power).next().is_some()
}
/// Per-fan health (round 13 #3), front-to-back / top-to-bottom in the order
@@ -470,31 +530,52 @@ impl MinerRow {
.collect()
}
/// Per-hashboard health (round 13 #3). Uses the per-board status when the
/// miner reports it (green ok / red faulted / grey missing); otherwise falls
/// back to the present-vs-expected board counts (present green, shortfall
/// grey). Empty when neither is known.
/// Per-hashboard health (round 13 #3, reworked round 16 #2/#3). Layers three
/// signals, most-authoritative last:
/// 1. Base: the per-board status the miner reports (green ok / red faulted /
/// grey missing), else the present-vs-expected board counts.
/// 2. Per-board fault messages (round 16 #3): when the miner reports
/// board-specific faults, ONLY the named boards are red and the rest are
/// green -- a whole-miner stall zeroes every board's hashrate, so the raw
/// status wrongly reds working boards that the error codes exonerate.
/// 3. Power-supply fault (round 16 #2): the boards can't be powered or
/// evaluated, so every board is grey (not red).
pub fn board_healths(&self) -> Vec<CompHealth> {
if !self.board_status.is_empty() {
// A miner that is mining but "slow" is hashing sub-optimally, so its
// present-and-hashing boards read yellow rather than green.
let ok = if self.slow { CompHealth::Degraded } else { CompHealth::Ok };
return self
.board_status
// 1. Base health from board status / counts.
let ok = if self.slow { CompHealth::Degraded } else { CompHealth::Ok };
let mut base: Vec<CompHealth> = if !self.board_status.is_empty() {
self.board_status
.iter()
.map(|h| match h {
BoardHealth::Ok => ok,
BoardHealth::Fault => CompHealth::Down,
BoardHealth::Missing => CompHealth::Unreachable,
})
.collect();
.collect()
} else {
let present = self.hashboards.map(|n| n as usize).unwrap_or(0);
let expected = self.expected_hashboards.map(|n| n as usize).unwrap_or(present);
let n = present.max(expected);
(0..n)
.map(|i| if i < present { CompHealth::Ok } else { CompHealth::Unreachable })
.collect()
};
if base.is_empty() {
return base;
}
let present = self.hashboards.map(|n| n as usize).unwrap_or(0);
let expected = self.expected_hashboards.map(|n| n as usize).unwrap_or(present);
let n = present.max(expected);
(0..n)
.map(|i| if i < present { CompHealth::Ok } else { CompHealth::Unreachable })
.collect()
// 3. A PSU fault means no board can be powered/tested -> all grey.
if self.power_supply_faulted() {
return vec![CompHealth::Unreachable; base.len()];
}
// 2. Board-specific faults are authoritative: red only the named boards,
// green the rest (overriding a stall-induced all-red).
let board_faulted = |i: usize| self.faults_for(FaultComponent::Board(i)).next().is_some();
if (0..base.len()).any(board_faulted) {
for (i, h) in base.iter_mut().enumerate() {
*h = if board_faulted(i) { CompHealth::Down } else { ok };
}
}
base
}
/// The sort key for the Health column and its facet pseudo-columns (round 13
@@ -527,6 +608,111 @@ impl MinerRow {
val as f64
}
/// Human-readable fault messages attributed to a specific component
/// (round 16 #1), for that Health icon's hover tooltip.
fn fault_texts_for(&self, component: FaultComponent) -> Vec<String> {
self.faults
.iter()
.filter(|f| f.component == component)
.map(|f| f.message.clone())
.collect()
}
/// Fault messages not tied to a specific board/fan/PSU (miner-level or
/// control-board), for the control-board icon tooltip (round 16 #1).
fn general_fault_texts(&self) -> Vec<String> {
self.faults
.iter()
.filter(|f| matches!(f.component, FaultComponent::Other | FaultComponent::Control))
.map(|f| f.message.clone())
.collect()
}
/// Per-icon hover tooltips for the Health column, in the same draw order (and
/// length) as `encode_component_health`'s segments: power, control, each fan
/// padded to `max_fans`, each hashboard padded to `max_boards` (round 15 #15,
/// round 16 #1/#2). Each icon's tooltip carries the specific faults the miner
/// reports for that component.
pub fn health_tooltips(&self, max_fans: usize, max_boards: usize) -> Vec<String> {
let mut tips: Vec<String> = Vec::with_capacity(2 + max_fans + max_boards);
// Power -- the bolt icon carries any power-supply faults (round 16 #2).
let power_faults = self.fault_texts_for(FaultComponent::Power);
let mut power = format!(
"Power supply: {}",
match self.power_health() {
CompHealth::Ok => "OK (drawing power)",
CompHealth::Down if !power_faults.is_empty() => "fault reported",
CompHealth::Down => "detected but not delivering",
CompHealth::Degraded => "sub-optimal",
CompHealth::Unreachable => "unknown (no wattage/PSU-fan reported)",
}
);
for e in &power_faults {
power.push('\n');
power.push_str(e);
}
tips.push(power);
// Control board -- also carries the miner's un-attributed / control faults.
let mut ctl = format!(
"Control board: {}",
match self.control_health() {
CompHealth::Ok => "OK (miner reachable)",
CompHealth::Degraded => "miner-level fault",
CompHealth::Down => "fault reported",
CompHealth::Unreachable => "unknown",
}
);
for e in self.general_fault_texts() {
ctl.push('\n');
ctl.push_str(&e);
}
tips.push(ctl);
// Fans.
let fans = self.fan_healths();
for i in 0..max_fans {
let s = match fans.get(i) {
Some(CompHealth::Ok) => {
let rpm = self.fan_rpms.get(i).map(|r| format!(" ({:.0} rpm)", r)).unwrap_or_default();
format!("spinning{rpm}")
}
Some(CompHealth::Degraded) => {
let rpm = self.fan_rpms.get(i).map(|r| format!(" ({:.0} rpm)", r)).unwrap_or_default();
format!("slow{rpm}")
}
Some(CompHealth::Down) => "stopped (0 rpm)".to_string(),
Some(CompHealth::Unreachable) => "expected but not detected".to_string(),
None => "not present".to_string(),
};
let mut t = format!("Fan {}: {s}", i + 1);
for e in self.fault_texts_for(FaultComponent::Fan(i)) {
t.push('\n');
t.push_str(&e);
}
tips.push(t);
}
// Hashboards. When the PSU has failed the boards can't be tested, so they
// read "unpowered" (grey) rather than "faulted" (round 16 #2/#3).
let boards = self.board_healths();
let psu_down = self.power_supply_faulted();
for i in 0..max_boards {
let s = match boards.get(i) {
Some(CompHealth::Ok) => "hashing".to_string(),
Some(CompHealth::Degraded) => "hashing sub-optimally".to_string(),
Some(CompHealth::Down) => "faulted".to_string(),
Some(CompHealth::Unreachable) if psu_down => "unpowered (PSU fault)".to_string(),
Some(CompHealth::Unreachable) => "expected but not detected".to_string(),
None => "not present".to_string(),
};
let mut t = format!("Hashboard {}: {s}", i + 1);
for e in self.fault_texts_for(FaultComponent::Board(i)) {
t.push('\n');
t.push_str(&e);
}
tips.push(t);
}
tips
}
/// Compact plain-text summary of component health (round 13 #3), used as the
/// Health column's filter/sort-fallback text and the base of its hover
/// tooltip. e.g. "power ok, fans 3/4, boards 3/3".
@@ -738,7 +924,7 @@ pub const ALL_COLUMNS: [Column; 43] = [
/// order: model, health (component icons), hashrate, power, chip temp, firmware,
/// CPU, access. The Health column (round 13 #3) folds the old Errors, Boards and
/// Status columns into one row of per-component icons.
pub const DEFAULT_VISIBLE: [Column; 8] = [
pub const DEFAULT_VISIBLE: [Column; 9] = [
Column::Model,
Column::Health,
Column::Hashrate,
@@ -747,6 +933,8 @@ pub const DEFAULT_VISIBLE: [Column; 8] = [
Column::Firmware,
Column::Cpu,
Column::Locked,
// Locate-light beacon, last (round 15 #6).
Column::Light,
];
impl Column {
@@ -1437,6 +1625,57 @@ mod tests {
assert!(broken < healthy, "broken {broken} should score below healthy {healthy}");
}
#[test]
fn faults_attribute_to_the_right_component() {
// Round 16 #3: a whole-miner stall zeroes every board's hashrate, but the
// per-board fault codes name only some boards. Only the named boards go
// red; the un-named board stays green, and the tooltips carry the specific
// message on the right board.
let fault = |c: FaultComponent, m: &str| Fault {
component: c,
message: m.to_string(),
is_error: true,
};
let r = MinerRow {
is_mining: false,
board_status: vec![BoardHealth::Fault, BoardHealth::Fault, BoardHealth::Fault],
expected_fans: Some(2),
fan_rpms: vec![6000.0, 6000.0],
power_w: 3000.0,
faults: vec![
fault(FaultComponent::Board(0), "Slot 0 error reading chip id."),
fault(FaultComponent::Board(1), "Slot 1 loss of balance error."),
],
..Default::default()
};
let boards = r.board_healths();
assert_eq!(boards[0], CompHealth::Down); // named -> red
assert_eq!(boards[1], CompHealth::Down); // named -> red
assert_eq!(boards[2], CompHealth::Ok); // NOT named -> green, despite Fault status
// Tooltip for board 1 carries its specific message (not board 3's).
let tips = r.health_tooltips(2, 3);
let board_tips = &tips[2 + 2..]; // after power, control, 2 fans
assert!(board_tips[0].contains("Slot 0 error reading chip id."));
assert!(!board_tips[2].contains("Slot"), "board 3 has no fault text");
// Round 16 #2: a power-supply fault greys every board (they can't be
// powered/tested), turns the bolt red, and the PSU message shows on the
// power tooltip.
let psu = MinerRow {
power_w: 40.0,
board_status: vec![BoardHealth::Fault, BoardHealth::Fault, BoardHealth::Fault],
expected_fans: Some(2),
fan_rpms: vec![6000.0, 6000.0],
faults: vec![fault(FaultComponent::Power, "Power current error.")],
..Default::default()
};
assert_eq!(psu.power_health(), CompHealth::Down);
assert!(psu.board_healths().iter().all(|h| *h == CompHealth::Unreachable));
let ptips = psu.health_tooltips(2, 3);
assert!(ptips[0].contains("Power current error."));
assert!(ptips[2 + 2].contains("unpowered")); // first board tooltip
}
#[test]
fn kpis_match_expected_hardware_output() {
// This does not hardcode fixture counts: it independently recomputes
+131
View File
@@ -0,0 +1,131 @@
//! Dropdown presets + user-saved values for the Configure-pools dialog (round 15
//! #1). Each pool field (address / account / worker / password) has a "+" menu
//! offering built-in presets (pool stratums, worker placeholders) plus values the
//! user has saved, and the user can add the current box value to the saved list.
//! Saved lists persist one-per-line under the config dir.
use std::path::PathBuf;
const CONFIG_DIR: &str = ".config/alkane-toolkit";
/// Which pool field a "+" menu belongs to.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PoolField {
Address,
Account,
Worker,
Password,
}
impl PoolField {
fn saved_file(self) -> &'static str {
match self {
PoolField::Address => "pool-addresses.txt",
PoolField::Account => "pool-accounts.txt",
PoolField::Worker => "pool-workers.txt",
PoolField::Password => "pool-passwords.txt",
}
}
/// Built-in presets offered before the user's saved values.
pub fn presets(self) -> Vec<&'static str> {
match self {
// Top Bitcoin pools by hashrate with their primary stratum endpoints
// (researched round 15; verify in-app before relying on any one).
PoolField::Address => POOL_STRATUMS.iter().map(|(_, u)| *u).collect(),
PoolField::Account => Vec::new(),
// Per-miner worker-name placeholders (see MinerRow::expand_worker_template).
PoolField::Worker => vec![
"{ip1}", "{ip2}", "{ip3}", "{ip4}", "{serial}", "{mac}", "{nameplate-hr}",
"{brand}", "{model}", "{submodel}", "{cpu}", "{cb}", "{firmware}", "{hostname}",
],
PoolField::Password => vec!["x"],
}
}
}
/// (pool name, primary stratum URL). Used for the address dropdown labels.
pub const POOL_STRATUMS: &[(&str, &str)] = &[
("Foundry USA", "stratum+tcp://btc.foundryusapool.com:3333"),
("AntPool", "stratum+tcp://ss.antpool.com:3333"),
("F2Pool", "stratum+tcp://btc.f2pool.com:1314"),
("ViaBTC", "stratum+tcp://btc.viabtc.io:3333"),
("SpiderPool", "stratum+tcp://btc-us.spiderpool.com:2309"),
("Binance Pool", "stratum+tcp://bs.poolbinance.com:3333"),
("Luxor", "stratum+tcp://btc.global.luxor.tech:700"),
("SBI Crypto", "stratum+tcp://us1.sbicrypto.com:3333"),
("Braiins Pool", "stratum+tcp://stratum.braiins.com:3333"),
("ULTIMUSPOOL", "stratum+tcp://bs.ultimuspool.com:8888"),
("SECPOOL", "stratum+tcp://btc.secpool.com:3333"),
];
fn config_path(file: &str) -> PathBuf {
let home = std::env::var("HOME").unwrap_or_else(|_| ".".into());
PathBuf::from(home).join(CONFIG_DIR).join(file)
}
/// The user's saved values for `field`, in save order (most recent last).
pub fn load_saved(field: PoolField) -> Vec<String> {
std::fs::read_to_string(config_path(field.saved_file()))
.ok()
.map(|s| s.lines().map(str::trim).filter(|l| !l.is_empty()).map(String::from).collect())
.unwrap_or_default()
}
/// Add `value` to `field`'s saved list (deduplicated, no-op if empty/already
/// present or already a preset). Returns true if it was newly added.
pub fn add_saved(field: PoolField, value: &str) -> bool {
let value = value.trim();
if value.is_empty() {
return false;
}
if field.presets().iter().any(|p| *p == value) {
return false;
}
let mut saved = load_saved(field);
if saved.iter().any(|s| s == value) {
return false;
}
saved.push(value.to_string());
let p = config_path(field.saved_file());
if let Some(dir) = p.parent() {
let _ = std::fs::create_dir_all(dir);
}
let _ = std::fs::write(p, saved.join("\n"));
true
}
/// Remove `value` from `field`'s saved list (round 16 #5). Returns true if it was
/// present and removed. Presets cannot be removed (they are not in the saved file).
pub fn remove_saved(field: PoolField, value: &str) -> bool {
let value = value.trim();
let mut saved = load_saved(field);
let before = saved.len();
saved.retain(|s| s != value);
if saved.len() == before {
return false;
}
let p = config_path(field.saved_file());
let _ = std::fs::write(p, saved.join("\n"));
true
}
/// The full dropdown list for a field: presets first, then the user's saved
/// values. For the address field each entry is labelled with the pool name.
pub fn dropdown_entries(field: PoolField) -> Vec<(String, String)> {
// (label, value)
let mut out: Vec<(String, String)> = Vec::new();
if field == PoolField::Address {
for (name, url) in POOL_STRATUMS {
out.push((format!("{name} -- {url}"), url.to_string()));
}
} else {
for p in field.presets() {
out.push((p.to_string(), p.to_string()));
}
}
for s in load_saved(field) {
out.push((s.clone(), s));
}
out
}
+2 -1
View File
@@ -15,7 +15,7 @@ pub const PRESETS_FILE: &str = "presets.json";
/// IP, model, health (component icons), hashrate, power, chip temp, firmware,
/// CPU, access. The Health column (round 13 #3) replaced the old errors, boards
/// (hashboard dots) and status columns.
const DEFAULT_PROFILE: [Column; 9] = [
const DEFAULT_PROFILE: [Column; 10] = [
Column::Ip,
Column::Model,
Column::Health,
@@ -25,6 +25,7 @@ const DEFAULT_PROFILE: [Column; 9] = [
Column::Firmware,
Column::Cpu,
Column::Locked,
Column::Light,
];
/// A serializable snapshot of a `ViewState` (Vec-based so JSON has no map keys
+90 -15
View File
@@ -455,6 +455,70 @@ fn summarize_messages(messages: &[asic_rs::core::data::message::MinerMessage]) -
ranked.into_iter().map(|(_, s)| s).collect()
}
/// Convert a miner's structured messages into `Fault`s with their attributed
/// component (round 16 #1/#2/#3), so the Health column can colour and describe
/// each icon from the actual per-component faults. Info-severity messages are
/// dropped; Error and Warning are kept (only Error drives colour).
fn messages_to_faults(
messages: &[asic_rs::core::data::message::MinerMessage],
) -> Vec<crate::model::Fault> {
use asic_rs::core::data::message::{MessageSeverity, MinerComponent};
use crate::model::{Fault, FaultComponent};
messages
.iter()
.filter_map(|m| {
let is_error = match m.severity {
MessageSeverity::Error => true,
MessageSeverity::Warning => false,
MessageSeverity::Info => return None,
};
let text = m.message.trim();
if text.is_empty() {
return None;
}
let component = match &m.component {
Some(MinerComponent::PowerSupply { .. }) => FaultComponent::Power,
Some(MinerComponent::ControlBoard {}) => FaultComponent::Control,
Some(MinerComponent::Fan { idx }) => FaultComponent::Fan(*idx as usize),
Some(MinerComponent::HashBoard { idx, .. }) => FaultComponent::Board(*idx as usize),
None => FaultComponent::Other,
};
Some(Fault {
component,
message: text.to_string(),
is_error,
})
})
.collect()
}
/// Infer whether an Antminer's hashboards carry a per-board PIC MCU from the
/// model string (round 14 #2). No firmware (stock cgminer, Vnish, LuxOS, Braiins)
/// exposes a PIC flag over the network; PIC-vs-noPIC is fixed by the hashboard
/// type, so a model map is the only network-only method:
/// - noPIC: an explicit "noPIC" model, the S19k Pro board, and the BM1368+
/// generation (S21 family, T21), where Bitmain dropped the per-board PIC.
/// - PIC: the rest of the S19 line (BM1362/BM1366, PIC16F1704/1542).
/// - unknown: everything else (older Antminers, non-Antminer makes).
/// The one genuinely ambiguous model is the plain "S19j Pro" (both PIC and noPIC
/// revisions exist); it is assumed PIC unless the model string says noPIC.
fn infer_pic(model: &str) -> Option<bool> {
let m = model.to_lowercase();
if m.contains("nopic") {
return Some(false);
}
if m.contains("s21") || m.contains("t21") {
return Some(false);
}
if m.contains("s19k") {
return Some(false);
}
if m.contains("s19") {
return Some(true);
}
None
}
async fn to_row(miner: &dyn Miner) -> MinerRow {
let data = miner.get_data().await;
let hashrate_ths = data
@@ -588,10 +652,10 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
firmware_flash: miner.supports_upgrade_firmware(),
pools: miner.supports_pools_config(),
};
// PIC vs noPIC is not reported over the network by asic-rs; best-effort
// heuristic from the model string, else unknown (true detection needs an
// on-board SSH/I2C probe -- a separate feature).
let pic_present = if model.to_lowercase().contains("nopic") { Some(false) } else { None };
// PIC vs noPIC (round 14 #2 rework). No firmware exposes a PIC flag over the
// network -- it's a fixed hardware property of the hashboard type -- so infer
// it from the model, which every API reports. See `infer_pic`.
let pic_present = infer_pic(&model);
// Access: locked/view-only when the miner exposes no writable control at
// all, otherwise unlocked. Inferred from asic-rs capabilities (there is no
// direct lock-state field). This now covers WhatsMiner too: since round 12
@@ -626,6 +690,7 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
}
}
let errors = summarize_messages(&data.messages);
let faults = messages_to_faults(&data.messages);
MinerRow {
ip: data.ip.to_string(),
selected: false,
@@ -634,6 +699,7 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
pic_present,
write_locked,
errors,
faults,
model,
brand,
submodel,
@@ -842,16 +908,20 @@ pub fn start_config_action(ips: Vec<String>, action: ConfigAction) -> ActionHand
ActionHandle { rx, cancel }
}
/// One miner's pool config to write (round 14 #7). The worker `username` has
/// already been expanded from the per-firmware worker template in the UI (which
/// holds the scanned MinerRow), so this carries a fully-resolved endpoint.
pub struct PoolTarget {
pub ip: String,
/// One resolved pool endpoint (worker already expanded from the template).
pub struct PoolEntry {
pub url: String,
pub username: String,
pub password: String,
}
/// One miner's pool config to write (round 14 #7, round 15 #1): up to three
/// pools (primary + backups), each already worker-expanded in the UI.
pub struct PoolTarget {
pub ip: String,
pub pools: Vec<PoolEntry>,
}
/// Apply a single "default" pool group to each target miner on a background
/// thread (round 14 #7). Reuses the ActionMsg/ActionHandle plumbing so the
/// existing drain_action + status handling covers it. Miners whose backend does
@@ -869,10 +939,11 @@ pub fn start_pools_action(targets: Vec<PoolTarget>) -> ActionHandle {
let err_tx = tx.clone();
let res = std::thread::Builder::new().name("fake-pools".into()).spawn(move || {
for t in targets {
let first = t.pools.first().map(|p| p.username.clone()).unwrap_or_default();
let _ = tx.send(ActionMsg::Result {
ip: t.ip,
ok: true,
detail: format!("simulated ({})", t.username),
detail: format!("simulated ({} pool(s), {first})", t.pools.len()),
});
}
let _ = tx.send(ActionMsg::Done { ok: total, total });
@@ -910,11 +981,15 @@ pub fn start_pools_action(targets: Vec<PoolTarget>) -> ActionHandle {
let group = PoolGroupConfig {
name: "default".to_string(),
quota: 1,
pools: vec![PoolConfig {
url: PoolURL::from(t.url.clone()),
username: t.username.clone(),
password: t.password.clone(),
}],
pools: t
.pools
.iter()
.map(|p| PoolConfig {
url: PoolURL::from(p.url.clone()),
username: p.username.clone(),
password: p.password.clone(),
})
.collect(),
};
match miner.set_pools_config(vec![group]).await {
Ok(true) => (true, "ok".to_string()),
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,39 @@
Subject: [PATCH 0009] antminer: read Z15-style fans from higher fan slots
Round-15 #12. The v2020 backend's parse_fans only read fan1..hardware.fans, but
some models report their fans in higher slots and leave the low ones at 0 -- the
Z15 has fan_num=2 yet reports its two fans in fan3/fan4 with fan1/fan2 = 0, so no
fans were read. Scan a generous range of fan slots (1..16) and collect the
non-zero readings instead, renumbered 0.. in the order found. Verified against a
live Z15 (fan3=4920, fan4=5160). The antminer crate tests pass unchanged.
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 0ce462c9..38935a59 100644
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
@@ -833,15 +833,23 @@ impl GetFans for AntMinerV2020 {
let mut fans: Vec<FanData> = Vec::new();
if let Some(stats_data) = data.get(&DataField::Fans) {
- for i in 1..=self.device_info.hardware.fans.unwrap_or(4) {
+ // Some models report their fans in higher fan slots and leave the low
+ // ones at 0 -- the Z15, for example, has fan_num=2 but reports its two
+ // fans in fan3/fan4 with fan1/fan2 = 0. So scan a generous range of
+ // slots and collect the non-zero readings rather than only reading
+ // fan1..hardware.fans (which missed the Z15 entirely). The collected
+ // fans are renumbered 0.. in the order found (round 14 #12).
+ let mut pos: i16 = 0;
+ for i in 1..=16 {
if let Some(fan_speed) =
stats_data.get(format!("fan{}", i)).and_then(|v| v.as_f64())
&& fan_speed > 0.0
{
fans.push(FanData {
- position: (i - 1) as i16,
+ position: pos,
rpm: Some(AngularVelocity::from_rpm(fan_speed)),
});
+ pos += 1;
}
}
}
@@ -0,0 +1,183 @@
Subject: [PATCH 0010] antminer: fix v2020 locate-LED + reboot for the legacy web UI
Round-15 #7. On old (< 2023.07) Antminer firmware -- the LuCI-derived web UI, e.g.
the Z15/Z15J -- the "flash the locate light" action never worked: set_fault_light
returned Ok(false) on real hardware even though the request "succeeded".
Root cause (confirmed against a live Z15): that firmware's blink.cgi does NOT take
the JSON body {"blink":"true"} the backend sent (it silently ignores it, answering
200 with an empty text/html body, so the JSON parse fails and the error is swallowed
into Ok(false)). Its own blink.html instead POSTs a form field action=startBlink /
stopBlink, and reads state back with action=onPageLoaded -> {"isBlinking":bool}.
The action handler also frequently answers 401/500 even when the toggle succeeds, so
its HTTP status is not a reliable success signal.
Fix: add send_web_form_command (application/x-www-form-urlencoded POST; this reqwest
build has no .form()); blink() now fires action=startBlink/stopBlink, ignores the
unreliable status, and reads the real state back via onPageLoaded; set_fault_light
reports success only when the observed isBlinking matches the request. The LightFlashing
data read is routed to the same onPageLoaded path (get_blink_status.cgi is 404 on this
firmware) and remapped to {"blink":bool} so the shared /blink extractor still works.
Also fixes reboot() for the same generation: reboot.html does type:'GET', but the
backend POSTed to reboot.cgi. Switched to GET to match the vendor UI (the Restart
action was affected). Not live-fired, to avoid rebooting production miners.
Verified live: Z15 and Z15J now return set_fault_light(on/off) -> Ok(true) with the
light genuinely toggling; VNish (AMLogic/CVITek/Xilinx/BeagleBoneBlack) and WhatsMiner
(H6OS/H616) remain Ok(true) with no regression.
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 38935a59..bd8662b1 100644
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
@@ -1111,9 +1111,17 @@ impl SetFaultLight for AntMinerV2020 {
true
}
- #[allow(unused_variables)]
async fn set_fault_light(&self, fault: bool) -> anyhow::Result<bool> {
- Ok(self.web.blink(fault).await.is_ok())
+ // `blink()` fires the toggle then reads the state back as `{"isBlinking":
+ // bool}` (the legacy CGI's own HTTP status is unreliable). Report success
+ // only when the observed locate-LED state matches what was requested.
+ let observed = self
+ .web
+ .blink(fault)
+ .await?
+ .get("isBlinking")
+ .and_then(serde_json::Value::as_bool);
+ Ok(observed == Some(fault))
}
}
diff --git a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/web.rs b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/web.rs
index 7d6f237c..a50cc4ee 100644
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/web.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/web.rs
@@ -240,6 +240,45 @@ impl AntMinerWebAPI {
Ok(response)
}
+ /// POST a form-encoded (`application/x-www-form-urlencoded`) body to a CGI
+ /// endpoint and parse the JSON reply. The legacy LuCI web UI endpoints (e.g.
+ /// `blink.cgi`) expect `action=...` form fields, not a JSON body. An empty
+ /// reply parses to `{}`; a non-2xx status bails.
+ async fn send_web_form_command(&self, command: &str, form: &[(&str, &str)]) -> Result<Value> {
+ let url = format!("http://{}:{}/cgi-bin/{}.cgi", self.ip, self.port, command);
+ // Build an application/x-www-form-urlencoded body by hand (this reqwest
+ // build has no `.form()` helper). The only fields used are `action` with
+ // fixed ASCII values, so percent-encoding is unnecessary.
+ let body = form
+ .iter()
+ .map(|(k, v)| format!("{k}={v}"))
+ .collect::<Vec<_>>()
+ .join("&");
+ let response = self
+ .client()?
+ .post(&url)
+ .header(
+ reqwest::header::CONTENT_TYPE,
+ "application/x-www-form-urlencoded",
+ )
+ .body(body)
+ .timeout(self.timeout)
+ .send_digest_auth((self.auth.username(), self.auth.password()))
+ .await
+ .map_err(|e| anyhow!(e.to_string()))?;
+
+ let status = response.status();
+ if !status.is_success() {
+ bail!("HTTP request failed with status code {}", status);
+ }
+ let text = response.text().await.map_err(|e| anyhow!(e.to_string()))?;
+ if text.trim().is_empty() {
+ Ok(json!({}))
+ } else {
+ serde_json::from_str(&text).map_err(|e| anyhow!(e.to_string()))
+ }
+ }
+
pub async fn get_miner_conf(&self) -> Result<Value> {
self.send_web_command("get_miner_conf", false, None, Method::GET)
.await
@@ -257,17 +296,31 @@ impl AntMinerWebAPI {
}
pub async fn blink(&self, blink: bool) -> Result<Value> {
- let param = if blink {
- json!({"blink": "true"})
- } else {
- json!({"blink": "false"})
- };
- self.send_web_command("blink", false, Some(param), Method::POST)
+ // Legacy LuCI web UI: the locate LED is toggled by POSTing an `action`
+ // form field to blink.cgi (`startBlink`/`stopBlink`) -- NOT a JSON body
+ // like the newer (>= 2023.07) firmware expects. The handler performs the
+ // action but frequently answers 401/500 even on success, so its HTTP
+ // status is not a reliable signal: fire it, ignore the response, then read
+ // the real state back via `onPageLoaded`.
+ let action = if blink { "startBlink" } else { "stopBlink" };
+ let _ = self
+ .send_web_form_command("blink", &[("action", action)])
+ .await;
+ self.blink_status().await
+ }
+
+ /// Query the locate-LED state via the legacy blink.cgi `onPageLoaded` action,
+ /// which reliably answers `200 {"isBlinking": bool}`.
+ pub async fn blink_status(&self) -> Result<Value> {
+ self.send_web_form_command("blink", &[("action", "onPageLoaded")])
.await
}
pub async fn reboot(&self) -> Result<Value> {
- self.send_web_command("reboot", false, None, Method::POST)
+ // The legacy LuCI web UI reboots via GET /cgi-bin/reboot.cgi (its own
+ // reboot.html does `type: 'GET'`); a POST is not what this firmware
+ // generation expects.
+ self.send_web_command("reboot", false, None, Method::GET)
.await
}
@@ -350,8 +403,17 @@ impl AntMinerWebAPI {
}
pub async fn get_blink_status(&self) -> Result<Value> {
- self.send_web_command("get_blink_status", false, None, Method::GET)
- .await
+ // The old firmware has no `get_blink_status.cgi` (it answers 404); the
+ // locate state lives behind blink.cgi's `onPageLoaded` action as
+ // `{"isBlinking": bool}`. Remap it to `{"blink": bool}` so the shared
+ // LightFlashing extractor (key `/blink`) keeps working.
+ let flashing = self
+ .blink_status()
+ .await?
+ .get("isBlinking")
+ .and_then(Value::as_bool)
+ .unwrap_or(false);
+ Ok(json!({ "blink": flashing }))
}
pub async fn set_network_conf(
@@ -383,10 +445,16 @@ impl APIClient for AntMinerWebAPI {
MinerCommand::WebAPI {
command,
parameters,
- } => self
- .send_web_command(command, false, parameters.clone(), Method::GET)
- .await
- .map_err(|e| anyhow!(e.to_string())),
+ } => {
+ // The legacy blink status lives behind a POST form action, not a
+ // GET .cgi (which 404s), so route it through the dedicated helper.
+ if *command == "get_blink_status" {
+ return self.get_blink_status().await;
+ }
+ self.send_web_command(command, false, parameters.clone(), Method::GET)
+ .await
+ .map_err(|e| anyhow!(e.to_string()))
+ }
_ => Err(anyhow!("Unsupported command type for Web client")),
}
}
@@ -0,0 +1,162 @@
Subject: [PATCH 0011] luxminer: implement set_power_limit; epic: document PSU gating
Round-15 follow-up. The toolkit reported supports_power_limit=false for LuxOS and
ePIC (UMC OS) miners. Investigated against the live corpus (S19j Pro on both).
LuxOS: genuinely under-reported. LuxOS tunes by discrete named profiles, each
carrying a Watts rating (the `profiles` RPC returns Step + Watts), applied with
profileset -- pure frequency/voltage tuning, no special PSU needed. Implemented
SetPowerLimit by mapping the requested watts to the highest profile whose Watts
does not exceed it (or the lowest profile when the target is below all of them),
then profileset. supports_set_power_limit now returns true. The pure mapping is
factored into parse_profile_watts + select_profile_at_or_below with a unit test.
Verified live: set_power_limit(2500) on an S19j Pro selected step -4 (2385 W, the
highest <= 2500) and the miner's active profile became 445MHz/-4.
ePIC: NOT under-reporting after all -- left at false, with a comment explaining
why. ePIC PowerPlay's only true power-limit path is the PowerTune perpetual-tune
algorithm, which the firmware gates on the PSU: on a fixed-voltage Bitmain PSU
(the APW12 on an S19j Pro) perpetualtune/algo rejects it with "Power optimization
is not supported by this PSU". That support is a per-PSU runtime property this
synchronous, no-I/O capability check cannot observe, so advertising true would
over-report on most reflashed Antminers. (Hashrate tuning stays available via
set_tuning_config.)
diff --git a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
index a6f555f7..c21e05b1 100644
--- a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
@@ -1369,6 +1369,14 @@ impl SetFaultLight for PowerPlayV1 {
#[async_trait]
impl SetPowerLimit for PowerPlayV1 {
fn supports_set_power_limit(&self) -> bool {
+ // ePIC PowerPlay's only true power-limit mechanism is the PowerTune
+ // perpetual-tune algorithm, which the firmware gates on the PSU: on a
+ // fixed-voltage Bitmain PSU (e.g. the APW12 on an S19j Pro) the
+ // perpetualtune/algo endpoint rejects it with "Power optimization is not
+ // supported by this PSU". Since that support is a per-PSU runtime property
+ // that this synchronous, no-I/O capability check cannot observe, report
+ // false rather than over-advertise a control that fails on most reflashed
+ // Antminers. (Hashrate tuning is exposed separately via set_tuning_config.)
false
}
}
diff --git a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
index af89167c..aac39eb6 100644
--- a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
@@ -1052,10 +1052,66 @@ impl SetFaultLight for LuxMinerV1 {
}
}
+/// Parse a LuxOS `profiles` RPC reply into (step name, watts) pairs, keeping only
+/// profiles that report both a `Step` and a `Watts` value.
+fn parse_profile_watts(profiles: &Value) -> Vec<(String, f64)> {
+ profiles
+ .get("PROFILES")
+ .and_then(Value::as_array)
+ .map(|arr| {
+ arr.iter()
+ .filter_map(|p| {
+ let step = p.get("Step").and_then(Value::as_str)?.to_string();
+ let watts = p.get("Watts").and_then(Value::as_f64)?;
+ Some((step, watts))
+ })
+ .collect()
+ })
+ .unwrap_or_default()
+}
+
+/// Choose the LuxOS profile step to satisfy a watts power limit: the highest-watt
+/// profile that does not exceed `target_w`, or -- when the target is below every
+/// profile -- the lowest-watt profile. Returns None only when there are no
+/// profiles to choose from.
+fn select_profile_at_or_below(steps: &[(String, f64)], target_w: f64) -> Option<String> {
+ if steps.is_empty() {
+ return None;
+ }
+ let mut sorted: Vec<&(String, f64)> = steps.iter().collect();
+ sorted.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal));
+ sorted
+ .iter()
+ .rev()
+ .find(|(_, w)| *w <= target_w)
+ .or_else(|| sorted.first())
+ .map(|(s, _)| s.clone())
+}
+
#[async_trait]
impl SetPowerLimit for LuxMinerV1 {
fn supports_set_power_limit(&self) -> bool {
- false
+ true
+ }
+
+ async fn set_power_limit(&self, power: Power) -> anyhow::Result<bool> {
+ // LuxOS tunes by discrete named profiles (each carries a Watts rating),
+ // not a raw watts setpoint. Map the requested limit to the highest profile
+ // whose Watts does not exceed it (or the lowest profile when the target is
+ // below every profile), then apply it with profileset.
+ let profiles = self.rpc.profiles().await?;
+ let steps = parse_profile_watts(&profiles);
+ let Some(chosen) = select_profile_at_or_below(&steps, power.as_watts()) else {
+ anyhow::bail!("LuxOS reported no tunable profiles with a Step/Watts pair");
+ };
+ let resp = self.rpc.profileset(&chosen).await?;
+ // LuxOS answers with a STATUS array; "S"/"I" is success. A missing status
+ // after a non-error reply is treated as applied.
+ Ok(resp
+ .pointer("/STATUS/0/STATUS")
+ .and_then(Value::as_str)
+ .map(|s| matches!(s, "S" | "I"))
+ .unwrap_or(true))
}
}
@@ -1231,6 +1287,46 @@ mod tests {
POWER, PROFILES, STATS, SUMMARY, TEMPS, VERSION, VOLTAGEGET_0, VOLTAGEGET_1, VOLTAGEGET_2,
};
+ #[test]
+ fn power_limit_profile_selection() {
+ // LuxOS reports a ladder of profiles, each with a Step name and Watts.
+ let steps = vec![
+ ("-16".to_string(), 865.0),
+ ("-4".to_string(), 2385.0),
+ ("-2".to_string(), 2790.0),
+ ("0".to_string(), 3100.0),
+ ];
+ // The highest profile at or below the requested watts limit.
+ assert_eq!(
+ select_profile_at_or_below(&steps, 2500.0).as_deref(),
+ Some("-4")
+ );
+ assert_eq!(
+ select_profile_at_or_below(&steps, 2790.0).as_deref(),
+ Some("-2")
+ );
+ // Above every profile -> the maximum profile (a limit can't exceed the
+ // hardware's top profile).
+ assert_eq!(
+ select_profile_at_or_below(&steps, 9000.0).as_deref(),
+ Some("0")
+ );
+ // Below every profile -> the minimum profile.
+ assert_eq!(
+ select_profile_at_or_below(&steps, 100.0).as_deref(),
+ Some("-16")
+ );
+ // No profiles -> nothing to choose.
+ assert_eq!(select_profile_at_or_below(&[], 2500.0), None);
+
+ // parse_profile_watts against the captured LuxOS `profiles` reply: it
+ // yields tunable profiles and selection finds a real step among them.
+ let profiles: Value = serde_json::from_str(PROFILES).unwrap();
+ let parsed = parse_profile_watts(&profiles);
+ assert!(!parsed.is_empty(), "fixture should carry tunable profiles");
+ assert!(select_profile_at_or_below(&parsed, 2500.0).is_some());
+ }
+
#[tokio::test]
async fn test_luxminer_v1() -> anyhow::Result<()> {
@@ -0,0 +1,229 @@
Subject: [PATCH 0012] whatsminer: robust per-component fault messages (V1 source + malformed-array repair)
Round-16 #1/#3. The toolkit could not attribute WhatsMiner faults to specific
hashboards. Two backend gaps, both found against live H6OS units:
1. V1 backend sourced messages from `summary` (/SUMMARY/0 "Error Code N"), which
is empty on these units -- the real faults are in get_error_code, like V2/V3.
Repointed DataField::Messages to get_error_code (/Msg/error_code) and rewrote
parse_messages to read the {code: timestamp} array (mirroring V2). asic-rs's
error_codes::error_info already maps each code to a MinerComponent (HashBoard
idx / PowerSupply / Fan / ControlBoard) and human text.
2. Some firmware emits an INVALID error_code array of bare "code":"timestamp"
pairs (`["540":"..","541":".."]`) instead of objects (`[{"540":".."}]`), which
fails the whole response parse so no messages surface at all. Added
error_codes::repair_error_code_array (targeted, no-op on valid input) and call
it in the V1 and V2 RPC read paths before parsing.
Verified live: 10.7.1.231 -> PowerSupply errors 205/206/217/251; 10.8.1.234 (the
malformed-array unit) -> 540 HashBoard 0, 541/561 HashBoard 1, 600 miner-level --
board 2 correctly clean. Unit test covers the repair; whatsminer tests pass.
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 c9c96713..67907049 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
@@ -117,6 +117,10 @@ impl GetDataLocations for WhatsMinerV1 {
command: "get_psu",
parameters: None,
};
+ const RPC_GET_ERROR_CODE: MinerCommand = MinerCommand::RPC {
+ command: "get_error_code",
+ parameters: None,
+ };
match data_field {
DataField::Mac => vec![(
@@ -254,10 +258,10 @@ impl GetDataLocations for WhatsMinerV1 {
},
)],
DataField::Messages => vec![(
- RPC_SUMMARY,
+ RPC_GET_ERROR_CODE,
DataExtractor {
func: get_by_pointer,
- key: Some("/SUMMARY/0"),
+ key: Some("/Msg/error_code"),
tag: None,
},
)],
@@ -471,32 +475,43 @@ impl GetTuningCapabilities for WhatsMinerV1 {}
impl GetLightFlashing for WhatsMinerV1 {}
impl GetMessages for WhatsMinerV1 {
fn parse_messages(&self, data: &HashMap<DataField, Value>) -> Vec<MinerMessage> {
+ // WhatsMiner V1 (H6OS) reports faults via get_error_code -> Msg.error_code,
+ // an array of {code: timestamp} objects (the same shape as V2/V3; the RPC
+ // layer repairs the occasional invalid bare-pair array first). The older
+ // summary "Error Code N" fields are frequently empty on these units.
let mut messages = Vec::new();
-
- let error_count = data
- .get(&DataField::Messages)
- .and_then(|val| {
- val.pointer("/Error Code Count")
- .and_then(|val| val.as_u64())
- })
- .unwrap_or(0u64) as usize;
- for idx in 0..error_count {
- let e_code = data
- .get(&DataField::Messages)
- .and_then(|val| val.pointer(&format!("/Error Code {}", idx)))
- .and_then(|val| val.as_u64());
- if let Some(code) = e_code {
- let info = crate::error_codes::error_info(code);
+ let Some(errors) = data.get(&DataField::Messages) else {
+ return messages;
+ };
+ for obj in errors.as_array().unwrap_or(&Vec::new()).iter() {
+ let Some(obj) = obj.as_object() else {
+ continue;
+ };
+ for (code, time) in obj.iter() {
+ let Some(time_str) = time.as_str() else {
+ continue;
+ };
+ let timestamp =
+ chrono::NaiveDateTime::parse_from_str(time_str, "%Y-%m-%d %H:%M:%S")
+ .map(|t| {
+ chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
+ t,
+ chrono::Utc,
+ )
+ })
+ .map(|dt| dt.timestamp() as u32)
+ .unwrap_or(0);
+ let parsed_code = code.parse::<u64>().unwrap_or(0);
+ let info = crate::error_codes::error_info(parsed_code);
messages.push(MinerMessage::with_component(
- 0,
- code,
+ timestamp,
+ parsed_code,
info.message,
MessageSeverity::Error,
info.component,
));
}
}
-
messages
}
}
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/rpc.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/rpc.rs
index 6e6c604e..384bbcd3 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/rpc.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/rpc.rs
@@ -106,6 +106,9 @@ impl RPCAPIClient for WhatsMinerRPCAPI {
let response = response
.replace('\n', "") // Fix for WM V1, can have newlines in version which breaks the json parser
.replace(",}", "}"); // Fix for WM V1, can have trailing commas which breaks the json parser
+ // Fix for WM V1 get_error_code, which can emit an invalid array of bare
+ // "code":"timestamp" pairs (`["540":".."]`) that fails the whole parse.
+ let response = crate::error_codes::repair_error_code_array(&response);
self.parse_rpc_result(&response)
}
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/rpc.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/rpc.rs
index 9eec7a93..99da6a89 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/rpc.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/rpc.rs
@@ -202,6 +202,9 @@ impl WhatsMinerRPCAPI {
read_stream_response(&mut stream, DEFAULT_RPC_TIMEOUT).await
};
let response = response?;
+ // Repair the occasional invalid get_error_code array (bare
+ // "code":"timestamp" pairs) before parsing; a no-op on valid responses.
+ let response = crate::error_codes::repair_error_code_array(&response);
self.parse_rpc_result(&response)
}
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/error_codes.rs b/vendor/asic-rs-firmwares-whatsminer/src/error_codes.rs
index b442e9dc..5bd8b02a 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/error_codes.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/error_codes.rs
@@ -2,6 +2,56 @@ use asic_rs_core::data::message::MinerComponent;
const UNKNOWN: &str = "Unknown error type.";
+/// Repair an invalid `error_code` array emitted by some WhatsMiner firmware.
+///
+/// Certain (older, H6OS) firmwares report the fault list as bare
+/// `"code":"timestamp"` pairs directly inside a JSON array
+/// (`"error_code":["540":"..","541":".."]`) rather than an array of single-key
+/// objects (`[{"540":".."},{"541":".."}]`). The bare form is not valid JSON and
+/// fails the whole response parse, so no messages are surfaced at all. Rewrite the
+/// bare pairs into objects; already-valid (object-wrapped or empty) arrays and
+/// responses without an `error_code` array are returned unchanged.
+pub fn repair_error_code_array(raw: &str) -> String {
+ const KEY: &str = "\"error_code\":[";
+ let Some(pos) = raw.find(KEY) else {
+ return raw.to_string();
+ };
+ let open = pos + KEY.len() - 1; // index of the '['
+ let bytes = raw.as_bytes();
+ let mut depth = 0i32;
+ let mut close = None;
+ for (i, &b) in bytes.iter().enumerate().skip(open) {
+ match b {
+ b'[' => depth += 1,
+ b']' => {
+ depth -= 1;
+ if depth == 0 {
+ close = Some(i);
+ break;
+ }
+ }
+ _ => {}
+ }
+ }
+ let Some(close) = close else {
+ return raw.to_string();
+ };
+ let inner = &raw[open + 1..close];
+ // Already valid (each entry object-wrapped) or empty -> leave untouched.
+ if inner.trim().is_empty() || inner.contains('{') {
+ return raw.to_string();
+ }
+ // Timestamps carry no commas, so a top-level comma split isolates each pair.
+ let wrapped = inner
+ .split(',')
+ .map(str::trim)
+ .filter(|s| !s.is_empty())
+ .map(|pair| format!("{{{pair}}}"))
+ .collect::<Vec<_>>()
+ .join(",");
+ format!("{}{}{}", &raw[..=open], wrapped, &raw[close..])
+}
+
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ErrorInfo {
pub message: String,
@@ -514,6 +564,27 @@ fn serial_info_error(sub: u64, val: u64) -> String {
mod tests {
use super::*;
+ #[test]
+ fn repair_malformed_error_code_array() {
+ // Bare "code":"timestamp" pairs inside the array (invalid JSON) -> objects.
+ let bad = r#"{"STATUS":"S","Msg":{"error_code":["540":"2026-09-22 07:08:14","561":"2026-09-21 22:26:36"]},"Description":""}"#;
+ let fixed = repair_error_code_array(bad);
+ let v: serde_json::Value = serde_json::from_str(&fixed).expect("repaired JSON must parse");
+ let arr = v["Msg"]["error_code"].as_array().unwrap();
+ assert_eq!(arr.len(), 2);
+ assert_eq!(arr[0]["540"], "2026-09-22 07:08:14");
+ assert_eq!(arr[1]["561"], "2026-09-21 22:26:36");
+
+ // Already-valid (object-wrapped) arrays are returned unchanged.
+ let good = r#"{"Msg":{"error_code":[{"205":"2026-09-20 03:35:44"}]}}"#;
+ assert_eq!(repair_error_code_array(good), good);
+ // Empty array and no-array responses are untouched.
+ let empty = r#"{"Msg":{"error_code":[]}}"#;
+ assert_eq!(repair_error_code_array(empty), empty);
+ let none = r#"{"STATUS":"S"}"#;
+ assert_eq!(repair_error_code_array(none), none);
+ }
+
#[test]
fn short_code_returns_unknown() {
// Act
@@ -0,0 +1,98 @@
Subject: [PATCH 0013] braiins+luxminer: implement best-share / session-best-share (round 16 G9)
The GetBestShare/GetSessionBestShare traits had empty impls on every backend, so
MinerData.best_share/session_best_share were always None and the toolkit's two
"Best share" / "Session best" columns were dead.
Braiins v26_04: map DataField::BestShare to the already-fetched miner/stats WebAPI
response (/miner_stats/best_share) and parse it. (BOS has no session-best field ->
session stays None.) Verified live read-only on 10.4.1.83: 130601978.
LuxMiner v1: map DataField::BestShare + SessionBestShare to the already-fetched
summary RPC (/SUMMARY/0/Best Share and /Best Session Share) and parse both.
Verified live read-only on 10.4.1.60 (638881749/638881749) and 10.4.1.67
(497802665/497802665).
No extra network calls (both reuse commands already collected by get_data).
diff --git a/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs b/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs
index fa947aee..e65fb201 100644
--- a/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs
+++ b/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs
@@ -286,6 +286,14 @@ impl GetDataLocations for BraiinsV2604 {
tag: None,
},
)],
+ DataField::BestShare => vec![(
+ WEB_MINER_STATS,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/miner_stats/best_share"),
+ tag: None,
+ },
+ )],
DataField::TuningTarget => vec![
(
WEB_MINER_CONFIGURATION,
@@ -548,7 +556,13 @@ impl GetUptime for BraiinsV2604 {
}
}
-impl GetBestShare for BraiinsV2604 {}
+impl GetBestShare for BraiinsV2604 {
+ fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ // Braiins OS reports the all-time best share at miner/stats -> miner_stats.best_share
+ // (round 16 / G9). Large diffs may exceed f64 exactness but are fine for display.
+ data.extract::<f64>(DataField::BestShare)
+ }
+}
impl GetSessionBestShare for BraiinsV2604 {}
impl GetOperatingState for BraiinsV2604 {
diff --git a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
index aac39eb6..2d1331bf 100644
--- a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
@@ -445,6 +445,22 @@ impl GetDataLocations for LuxMinerV1 {
tag: None,
},
)],
+ DataField::BestShare => vec![(
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0/Best Share"),
+ tag: None,
+ },
+ )],
+ DataField::SessionBestShare => vec![(
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0/Best Session Share"),
+ tag: None,
+ },
+ )],
DataField::Uptime => vec![(
RPC_STATS,
DataExtractor {
@@ -888,8 +904,18 @@ impl GetUptime for LuxMinerV1 {
}
}
-impl GetBestShare for LuxMinerV1 {}
-impl GetSessionBestShare for LuxMinerV1 {}
+impl GetBestShare for LuxMinerV1 {
+ fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ // LuxOS summary -> "Best Share" (all-time), round 16 / G9.
+ data.extract::<f64>(DataField::BestShare)
+ }
+}
+impl GetSessionBestShare for LuxMinerV1 {
+ fn parse_session_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ // LuxOS summary -> "Best Session Share" (since boot), round 16 / G9.
+ data.extract::<f64>(DataField::SessionBestShare)
+ }
+}
impl GetOperatingState for LuxMinerV1 {}
@@ -0,0 +1,88 @@
Subject: [PATCH 0014] luxminer: pool ops must be privileged (send session_id); add removepool
Round 16 / G13. The LuxOS pool write commands (addgroup, groupquota, removegroup,
addpool, switchpool, enablepool, disablepool) were sent with privileged=false, so
no session_id was included. That works on default units but FAILS with a
"Missing session_id" error on password-set LuxOS units (every other LuxOS write --
profileset/fanset/curtail/etc. -- is already privileged=true). Flip all seven pool
ops to privileged=true so send_command prepends the logon session token, and add
the missing rpc.removepool (privileged) for future incremental pool editing.
Verified no regression on a default corpus unit (10.4.1.60): set_pools_config still
applies correctly via the new privileged path. The password-set failure path is a
code-correct fix but needs a password-set LuxOS unit to reproduce/verify live.
diff --git a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/rpc.rs b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/rpc.rs
index 1afc686c..39d7ef63 100644
--- a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/rpc.rs
+++ b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/rpc.rs
@@ -239,7 +239,7 @@ impl LUXMinerRPCAPI {
pub async fn addgroup(&self, name: &str, quota: u32) -> anyhow::Result<Value> {
self.send_command(
"addgroup",
- false,
+ true,
Some(Value::String(format!("{name},{quota}"))),
)
.await
@@ -248,7 +248,7 @@ impl LUXMinerRPCAPI {
pub async fn groupquota(&self, group_id: u32, quota: u32) -> anyhow::Result<Value> {
self.send_command(
"groupquota",
- false,
+ true,
Some(Value::String(format!("{group_id},{quota}"))),
)
.await
@@ -257,7 +257,7 @@ impl LUXMinerRPCAPI {
pub async fn removegroup(&self, group_id: u32) -> anyhow::Result<Value> {
self.send_command(
"removegroup",
- false,
+ true,
Some(Value::String(group_id.to_string())),
)
.await
@@ -275,14 +275,14 @@ impl LUXMinerRPCAPI {
params.push(group_id);
}
- self.send_command("addpool", false, Some(Value::String(params.join(","))))
+ self.send_command("addpool", true, Some(Value::String(params.join(","))))
.await
}
pub async fn switchpool(&self, pool_id: i32) -> anyhow::Result<Value> {
self.send_command(
"switchpool",
- false,
+ true,
Some(Value::String(pool_id.to_string())),
)
.await
@@ -291,7 +291,7 @@ impl LUXMinerRPCAPI {
pub async fn enablepool(&self, pool_id: i32) -> anyhow::Result<Value> {
self.send_command(
"enablepool",
- false,
+ true,
Some(Value::String(pool_id.to_string())),
)
.await
@@ -300,7 +300,16 @@ impl LUXMinerRPCAPI {
pub async fn disablepool(&self, pool_id: i32) -> anyhow::Result<Value> {
self.send_command(
"disablepool",
- false,
+ true,
+ Some(Value::String(pool_id.to_string())),
+ )
+ .await
+ }
+
+ pub async fn removepool(&self, pool_id: i32) -> anyhow::Result<Value> {
+ self.send_command(
+ "removepool",
+ true,
Some(Value::String(pool_id.to_string())),
)
.await
+65 -1
View File
@@ -10,7 +10,7 @@
+pub use widgets::*;
--- a/src/widgets.rs
+++ b/src/widgets.rs
@@ -0,0 +1,847 @@
@@ -0,0 +1,911 @@
+// 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).
@@ -40,6 +40,7 @@
+ 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_set_tooltip(win: *mut c_void, text: *const c_char);
+ pub fn wxbr_static_text(parent: *mut c_void, label: *const c_char) -> *mut c_void;
+ pub fn wxbr_set_label(win: *mut c_void, label: *const c_char);
+ pub fn wxbr_get_label(win: *mut c_void, buf: *mut c_char, cap: c_int) -> c_int;
@@ -50,6 +51,7 @@
+ pub fn wxbr_text_ctrl(parent: *mut c_void, multiline: c_int) -> *mut c_void;
+ pub fn wxbr_text_ctrl_get(win: *mut c_void, buf: *mut c_char, cap: c_int) -> c_int;
+ pub fn wxbr_text_ctrl_set(win: *mut c_void, value: *const c_char);
+ pub fn wxbr_text_ctrl_write(win: *mut c_void, value: *const c_char);
+ pub fn wxbr_check_box(parent: *mut c_void, label: *const c_char) -> *mut c_void;
+ pub fn wxbr_check_box_get(win: *mut c_void) -> c_int;
+ pub fn wxbr_check_box_set(win: *mut c_void, v: c_int);
@@ -64,6 +66,7 @@
+ pub fn wxbr_dialog_show_modal(win: *mut c_void) -> c_int;
+ pub fn wxbr_dialog_close(win: *mut c_void, code: c_int);
+ pub fn wxbr_file_dialog(parent: *mut c_void, title: *const c_char, buf: *mut c_char, cap: c_int) -> c_int;
+ pub fn wxbr_save_file_dialog(parent: *mut c_void, title: *const c_char, default_name: *const c_char, wildcard: *const c_char, buf: *mut c_char, cap: c_int) -> c_int;
+ pub fn wxbr_dvlc(parent: *mut c_void) -> *mut c_void;
+ pub fn wxbr_dvlc_append_text_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int);
+ pub fn wxbr_dvlc_append_colored_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int) -> *mut c_void;
@@ -74,6 +77,7 @@
+ pub fn wxbr_dvlc_row_count(win: *mut c_void) -> c_int;
+ pub fn wxbr_dvlc_set_cell(win: *mut c_void, row: usize, col: usize, value: *const c_char);
+ pub fn wxbr_dvlc_set_cell_tooltip(win: *mut c_void, row: usize, col: usize, text: *const c_char);
+ pub fn wxbr_dvlc_set_icon_tooltips(win: *mut c_void, row: usize, col: usize, joined: *const c_char);
+ pub fn wxbr_dvlc_get_cell(win: *mut c_void, row: usize, col: usize, buf: *mut c_char, cap: c_int) -> c_int;
+ pub fn wxbr_dvlc_col_count(win: *mut c_void) -> c_int;
+ pub fn wxbr_dvlc_autosize_col(win: *mut c_void, pos: c_int);
@@ -98,6 +102,7 @@
+ 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);
+ pub fn wxbr_menu_append_submenu(menu: *mut c_void, label: *const c_char, submenu: *mut c_void);
+ pub fn wxbr_popup_menu(win: *mut c_void, menu: *mut c_void);
+ pub fn wxbr_timer(id: c_int, ms: c_int) -> *mut c_void;
+ pub fn wxbr_gauge(parent: *mut c_void, range: c_int) -> *mut c_void;
@@ -391,6 +396,12 @@
+ unsafe { notsafe::wxbr_set_min_size(self.0, w, h) }
+ }
+
+ /// Attach a hover tooltip to this widget (round 15 #10). Empty clears it.
+ pub fn set_tool_tip(&self, text: &str) {
+ let c = CString::new(text).unwrap_or_default();
+ unsafe { notsafe::wxbr_set_tooltip(self.0, c.as_ptr()) }
+ }
+
+ pub fn static_text(parent: Widget, label: &str) -> Widget {
+ let c = CString::new(label).unwrap_or_default();
+ Widget(unsafe { notsafe::wxbr_static_text(parent.0, c.as_ptr()) })
@@ -452,6 +463,13 @@
+ unsafe { notsafe::wxbr_text_ctrl_set(self.0, c.as_ptr()) }
+ }
+
+ /// Insert `value` at the text control's cursor (replacing any selection),
+ /// rather than replacing the whole contents (round 15 #1).
+ pub fn write_text(&self, value: &str) {
+ let c = CString::new(value).unwrap_or_default();
+ unsafe { notsafe::wxbr_text_ctrl_write(self.0, c.as_ptr()) }
+ }
+
+ pub fn check_box(parent: Widget, label: &str) -> Widget {
+ let c = CString::new(label).unwrap_or_default();
+ Widget(unsafe { notsafe::wxbr_check_box(parent.0, c.as_ptr()) })
@@ -529,6 +547,36 @@
+ Some(String::from_utf8_lossy(&bytes).into_owned())
+ }
+
+ /// Save-file dialog (round 15 #14): returns the chosen path, or None if
+ /// cancelled. `default_name` prefills the filename; `wildcard` is a wx filter
+ /// string like "CSV files (*.csv)|*.csv".
+ pub fn save_file_dialog(
+ parent: Widget,
+ title: &str,
+ default_name: &str,
+ wildcard: &str,
+ ) -> Option<String> {
+ let t = CString::new(title).unwrap_or_default();
+ let d = CString::new(default_name).unwrap_or_default();
+ let w = CString::new(wildcard).unwrap_or_default();
+ let mut buf = vec![0i8; 4096];
+ let n = unsafe {
+ notsafe::wxbr_save_file_dialog(
+ parent.0,
+ t.as_ptr(),
+ d.as_ptr(),
+ w.as_ptr(),
+ buf.as_mut_ptr(),
+ buf.len() as c_int,
+ )
+ };
+ if n <= 0 {
+ return None;
+ }
+ let bytes: Vec<u8> = buf[..(n - 1) as usize].iter().map(|&b| b as u8).collect();
+ Some(String::from_utf8_lossy(&bytes).into_owned())
+ }
+
+ // ---- data view list ctrl ----
+
+ pub fn dvlc(parent: Widget) -> Widget {
@@ -582,6 +630,15 @@
+ unsafe { notsafe::wxbr_dvlc_set_cell_tooltip(self.0, row, col, c.as_ptr()) }
+ }
+
+ /// Set per-icon hover tooltips for a cell (round 15 #15): one tooltip per icon
+ /// in draw order. The bridge shows the one under the pointer. Passing an empty
+ /// slice clears them.
+ pub fn dvlc_set_icon_tooltips(&self, row: usize, col: usize, tips: &[String]) {
+ let joined = tips.join("\u{1f}");
+ let c = CString::new(joined).unwrap_or_default();
+ unsafe { notsafe::wxbr_dvlc_set_icon_tooltips(self.0, row, col, c.as_ptr()) }
+ }
+
+ pub fn dvlc_get_cell(&self, row: usize, col: usize) -> Option<String> {
+ let mut buf = vec![0i8; 4096];
+ let n = unsafe {
@@ -735,6 +792,13 @@
+ unsafe { notsafe::wxbr_menu_append_separator(self.0) }
+ }
+
+ /// Append `submenu` under this menu with `label` (round 15 #13). This menu
+ /// takes ownership of the submenu.
+ pub fn menu_append_submenu(&self, label: &str, submenu: Widget) {
+ let c = CString::new(label).unwrap_or_default();
+ unsafe { notsafe::wxbr_menu_append_submenu(self.0, c.as_ptr(), submenu.0) }
+ }
+
+ /// Show `menu` as a popup on this window; blocks until dismissed.
+ pub fn popup_menu(&self, menu: Widget) {
+ unsafe { notsafe::wxbr_popup_menu(self.0, menu.0) }
+188 -21
View File
@@ -1,6 +1,6 @@
--- a/cpp_src/widgets_bridge.cpp
+++ b/cpp_src/widgets_bridge.cpp
@@ -0,0 +1,1886 @@
@@ -0,0 +1,2053 @@
+// 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).
@@ -88,6 +88,10 @@
+ // Per-cell hover tooltip text, keyed by (row, model column). Used for the
+ // Errors column's full-message tooltip (see the GTK query-tooltip handler).
+ std::map<std::pair<unsigned, unsigned>, wxString> cell_tip;
+ // Per-ICON hover tooltips for a cell (round 15 #15): the Health column stores
+ // one tooltip per component icon so the tooltip pertains to the icon under the
+ // pointer, not the whole cell.
+ std::map<std::pair<unsigned, unsigned>, std::vector<wxString>> icon_tip;
+ bool GetAttrByRow(unsigned int row, unsigned int col,
+ wxDataViewItemAttr& attr) const override {
+ (void)col;
@@ -176,6 +180,13 @@
+const wxUniChar SHAPE_BRAIN = 0x0E; // control board
+const wxUniChar SHAPE_FAN = 0x0F; // cooling fan
+const wxUniChar SHAPE_CHIP = 0x10; // hashboard
+// Locate-light beacon (round 15 #6): a green dot above a red dot, both flashing
+// quickly while the miner's locate light is on.
+const wxUniChar SHAPE_LIGHT_BEACON = 0x11;
+// Health-column alignment gap (round 15 #5): draws nothing but advances by one
+// health-icon width, so component icons line up in fixed slots across rows even
+// when a miner has fewer fans/boards than the widest in the fleet.
+const wxUniChar SHAPE_GAP = 0x12;
+const int SHAPE_ADVANCE = 15; // horizontal space one shape occupies
+
+// Table zoom factor (round 14 #3), 1.0 = 100%. A status-bar slider scales the
@@ -186,7 +197,7 @@
+static wxFont g_zoom_base_font; // its font at 100% (captured lazily)
+static wxVector<int> g_zoom_base_w; // column widths at 100% (per column)
+static wxSlider* g_zoom_slider = nullptr; // the status-bar zoom slider
+static wxStaticText* g_zoom_label = nullptr; // the "100%" readout next to it
+static wxTextCtrl* g_zoom_entry = nullptr; // the editable "100%" field next to it
+
+// Animation phase for the pulsing locate-light dot (round 12 #6), advanced by a
+// wxTimer while any such dot is on screen; the treeview it repaints is tracked so
@@ -199,7 +210,8 @@
+ wxUniChar c = s[0];
+ if (c == SHAPE_DOT || c == SHAPE_LOCK || c == SHAPE_UNLOCK ||
+ c == SHAPE_HASHING || c == SHAPE_SLOW || c == SHAPE_NOTHASHING ||
+ c == SHAPE_PAUSED || c == SHAPE_PULSE_DOT ||
+ c == SHAPE_PAUSED || c == SHAPE_PULSE_DOT || c == SHAPE_LIGHT_BEACON ||
+ c == SHAPE_GAP ||
+ c == SHAPE_BOLT || c == SHAPE_BRAIN || c == SHAPE_FAN || c == SHAPE_CHIP) {
+ out = c;
+ return true;
@@ -299,6 +311,18 @@
+int DrawShape(wxDC* dc, wxUniChar shape, wxCoord x, const wxRect& cell,
+ const wxColour& colour, const wxColour& bg) {
+ int cy = cell.y + cell.height / 2;
+ // Health-column alignment gap (round 15 #5): occupy one health-icon width but
+ // draw nothing, so component icons line up in fixed slots across rows. The
+ // health icons are square, so the advance is (h - 3) just like a real one.
+ if (shape == SHAPE_GAP) {
+ int h = cell.height - 1;
+ int cap = (int)(28 * g_table_zoom + 0.5);
+ if (cap < 8) cap = 8;
+ if (h > cap) h = cap;
+ if (h < 8) h = 8;
+ int adv = h - 3;
+ return adv < 1 ? 1 : adv;
+ }
+ // SVG-backed icon (access padlocks #9, status KPI icons #11): recolour to the
+ // segment colour, rasterise (cached), and draw centred in its slot.
+ if (const ShapeSvg* sv = LookupShapeSvg(shape)) {
@@ -330,6 +354,20 @@
+ }
+ }
+ int cx = x + SHAPE_ADVANCE / 2;
+ if (shape == SHAPE_LIGHT_BEACON) {
+ // A green dot above a red dot, both flashing quickly (round 15 #6). The blink
+ // is a fast on/off (~0.5 s) driven by the shared pulse phase.
+ double a = (std::sin(g_pulse_phase * 3.0) > 0.0) ? 1.0 : 0.18;
+ wxColour green = BlendColour(bg, wxColour(30, 175, 70), a);
+ wxColour red = BlendColour(bg, wxColour(215, 45, 40), a);
+ int r = 3;
+ dc->SetPen(*wxTRANSPARENT_PEN);
+ dc->SetBrush(wxBrush(green));
+ dc->DrawCircle(cx, cy - (r + 1), r);
+ dc->SetBrush(wxBrush(red));
+ dc->DrawCircle(cx, cy + (r + 1), r);
+ return SHAPE_ADVANCE;
+ }
+ if (shape == SHAPE_DOT || shape == SHAPE_PULSE_DOT) {
+ wxColour fill = colour;
+ if (shape == SHAPE_PULSE_DOT) {
@@ -478,7 +516,12 @@
+ // with the table zoom (round 14 #3).
+ int hh = (int)((health ? 22 : 15) * g_table_zoom + 0.5);
+ if (hh < 8) hh = 8;
+ if (const ShapeSvg* sv = LookupShapeSvg(shape)) {
+ // The alignment gap is one health-icon-width slot that draws nothing
+ // (round 15 #5); health icons are square, so its advance is hh - 3.
+ if (shape == SHAPE_GAP) {
+ adv = hh - 3;
+ if (adv < 1) adv = 1;
+ } else if (const ShapeSvg* sv = LookupShapeSvg(shape)) {
+ int ww = (sv->vbh > 0) ? (int)((double)hh * sv->vbw / sv->vbh + 0.5) : hh;
+ if (health) {
+ adv = ww - 3;
@@ -641,6 +684,16 @@
+ ((wxWindow*)win)->SetMinSize(wxSize(w, h));
+}
+
+// Attach a hover tooltip to any widget (round 15 #10). An empty string clears it.
+void wxbr_set_tooltip(void* win, const char* text) {
+ wxWindow* w = (wxWindow*)win;
+ if (text && *text) {
+ w->SetToolTip(wxString::FromUTF8(text));
+ } else {
+ w->UnsetToolTip();
+ }
+}
+
+// ---- static text / fonts --------------------------------------------------
+
+void* wxbr_static_text(void* parent, const char* label) {
@@ -727,6 +780,15 @@
+ ((wxTextCtrl*)win)->SetValue(wxString::FromUTF8(value));
+}
+
+// Insert text at the current cursor position, replacing any selection (round 15
+// #1: worker-name placeholders are inserted, not overwritten). Leaves focus + the
+// cursor after the inserted text.
+void wxbr_text_ctrl_write(void* win, const char* value) {
+ wxTextCtrl* t = (wxTextCtrl*)win;
+ t->WriteText(wxString::FromUTF8(value));
+ t->SetFocus();
+}
+
+// ---- checkbox -------------------------------------------------------------
+
+void* wxbr_check_box(void* parent, const char* label) {
@@ -840,6 +902,25 @@
+ return n + 1;
+}
+
+// Save-file dialog (round 15 #14). `default_name` prefills the filename;
+// `wildcard` is a wxWidgets filter string (e.g. "CSV files (*.csv)|*.csv").
+// Returns the chosen path in `buf` (length+1), or 0 if cancelled.
+int wxbr_save_file_dialog(void* parent, const char* title, const char* default_name,
+ const char* wildcard, char* buf, int cap) {
+ wxString wc = (wildcard && *wildcard) ? wxString::FromUTF8(wildcard)
+ : wxString(wxFileSelectorDefaultWildcardStr);
+ wxFileDialog dlg((wxWindow*)parent, wxString::FromUTF8(title), wxEmptyString,
+ wxString::FromUTF8(default_name ? default_name : ""), wc,
+ wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
+ if (dlg.ShowModal() != wxID_OK) return 0;
+ wxCharBuffer b = dlg.GetPath().ToUTF8();
+ int n = (int)strlen(b.data());
+ if (n >= cap) n = cap - 1;
+ memcpy(buf, b.data(), n);
+ buf[n] = 0;
+ return n + 1;
+}
+
+// ---- data view list ctrl ------------------------------------------------------
+
+static AttrListStore* dvlc_store(void* win) {
@@ -864,12 +945,38 @@
+ return FALSE;
+ gint* idx = gtk_tree_path_get_indices(path);
+ int row = idx ? idx[0] : -1;
+ gtk_tree_path_free(path);
+ if (row < 0 || !gcol) return FALSE;
+ if (row < 0 || !gcol) { gtk_tree_path_free(path); return FALSE; }
+ wxDataViewColumn* wxcol = dv->GTKColumnToWX(gcol);
+ if (!wxcol) return FALSE;
+ if (!wxcol) { gtk_tree_path_free(path); return FALSE; }
+ AttrListStore* store = static_cast<AttrListStore*>(dv->GetModel());
+ auto it = store->cell_tip.find({(unsigned)row, wxcol->GetModelColumn()});
+ unsigned mcol = wxcol->GetModelColumn();
+ // Per-icon tooltip (round 15 #15): if this cell has one tooltip per icon, pick
+ // the one under the pointer from the icon slot the x-offset falls in.
+ auto iit = store->icon_tip.find({(unsigned)row, mcol});
+ if (iit != store->icon_tip.end() && !iit->second.empty()) {
+ GdkRectangle crect;
+ gtk_tree_view_get_cell_area(GTK_TREE_VIEW(tv), path, gcol, &crect);
+ gtk_tree_path_free(path);
+ // Icon advance matches DrawShape's health-icon width (square icons: h - 3).
+ int h = crect.height - 1;
+ int cap = (int)(28 * g_table_zoom + 0.5);
+ if (cap < 8) cap = 8;
+ if (h > cap) h = cap;
+ if (h < 8) h = 8;
+ int adv = h - 3;
+ if (adv < 1) adv = 1;
+ int off = bx - crect.x;
+ if (off < 0) off = 0;
+ int slot = off / adv;
+ if (slot < 0) slot = 0;
+ if (slot >= (int)iit->second.size()) slot = (int)iit->second.size() - 1;
+ const wxString& tip = iit->second[(size_t)slot];
+ if (tip.IsEmpty()) return FALSE;
+ gtk_tooltip_set_text(tooltip, tip.utf8_str());
+ return TRUE;
+ }
+ gtk_tree_path_free(path);
+ auto it = store->cell_tip.find({(unsigned)row, mcol});
+ if (it == store->cell_tip.end() || it->second.IsEmpty()) return FALSE;
+ gtk_tooltip_set_text(tooltip, it->second.utf8_str());
+ return TRUE;
@@ -1054,6 +1161,30 @@
+ store->DeleteAllItems();
+ store->row_fg.clear();
+ store->cell_tip.clear();
+ store->icon_tip.clear();
+}
+
+// Set per-icon tooltips for one cell (round 15 #15): `joined` is the tooltips for
+// each icon in draw order, separated by 0x1f. An empty string clears them.
+void wxbr_dvlc_set_icon_tooltips(void* win, unsigned row, unsigned col, const char* joined) {
+ AttrListStore* store = dvlc_store(win);
+ if (!joined || !joined[0]) {
+ store->icon_tip.erase({row, col});
+ return;
+ }
+ std::vector<wxString> tips;
+ wxString s = wxString::FromUTF8(joined);
+ wxString cur;
+ for (size_t i = 0; i < s.length(); i++) {
+ if (s[i] == wxUniChar(0x1f)) {
+ tips.push_back(cur);
+ cur.clear();
+ } else {
+ cur += s[i];
+ }
+ }
+ tips.push_back(cur);
+ store->icon_tip[{row, col}] = tips;
+}
+
+// Set (or clear, with an empty string) the hover tooltip for one cell,
@@ -1597,6 +1728,12 @@
+ ((wxMenu*)menu)->Append(id, wxString::FromUTF8(label));
+}
+
+// Append `submenu` under `menu` as a labelled sub-menu (round 15 #13); `menu`
+// takes ownership of `submenu`.
+void wxbr_menu_append_submenu(void* menu, const char* label, void* submenu) {
+ ((wxMenu*)menu)->AppendSubMenu((wxMenu*)submenu, wxString::FromUTF8(label));
+}
+
+void wxbr_menu_append_separator(void* menu) {
+ ((wxMenu*)menu)->AppendSeparator();
+}
@@ -1754,17 +1891,17 @@
+ g_status_indicator->SetSize(r.x + 4, y, r.width - 8, h);
+ }
+ }
+ // Zoom slider + "NNN%" label in the far-right field (round 14 #3): label at the
+ // right edge, slider filling the space to its left.
+ if (g_zoom_slider && g_zoom_label) {
+ // Zoom slider + editable "NNN%" entry in the far-right field (round 14 #3, #4):
+ // the entry at the right edge, slider filling the space to its left.
+ if (g_zoom_slider && g_zoom_entry) {
+ int fld = (sb->GetFieldsCount() >= 3) ? 2 : 1;
+ wxRect r;
+ if (sb->GetFieldRect(fld, r)) {
+ wxSize lbest = g_zoom_label->GetBestSize();
+ int lw = lbest.GetWidth() + 6;
+ int lh = lbest.GetHeight();
+ g_zoom_label->SetSize(r.x + r.width - lw, r.y + (r.height - lh) / 2, lw, lh);
+ int sw = r.width - lw - 8;
+ int ew = 52;
+ int eh = g_zoom_entry->GetBestSize().GetHeight();
+ if (eh > r.height - 2) eh = r.height - 2;
+ g_zoom_entry->SetSize(r.x + r.width - ew - 2, r.y + (r.height - eh) / 2, ew, eh);
+ int sw = r.width - ew - 10;
+ if (sw < 20) sw = 20;
+ int sh = r.height - 2;
+ g_zoom_slider->SetSize(r.x + 2, r.y + (r.height - sh) / 2, sw, sh);
@@ -1799,9 +1936,9 @@
+ g_zoom_table->Refresh();
+ g_zoom_table->Update();
+ }
+ if (g_zoom_label) {
+ g_zoom_label->SetLabel(wxString::Format(wxT("%d%%"), (int)(factor * 100 + 0.5)));
+ reposition_status_indicator();
+ if (g_zoom_entry) {
+ // ChangeValue does not fire wxEVT_TEXT, so this never loops back into a zoom.
+ g_zoom_entry->ChangeValue(wxString::Format(wxT("%d%%"), (int)(factor * 100 + 0.5)));
+ }
+}
+
@@ -1837,6 +1974,7 @@
+// #3). Widens the bar to three fields (status | indicator | zoom) and wires the
+// slider straight to apply_table_zoom -- no Rust round-trip. Call after the table
+// exists so the slider can find it.
+void wxbr_table_set_zoom(double factor); // defined below; used by the handlers here
+void wxbr_status_zoom_init(void* frame_ptr) {
+ wxFrame* frame = (wxFrame*)frame_ptr;
+ wxStatusBar* sb = frame->GetStatusBar();
@@ -1850,15 +1988,44 @@
+ if (!g_zoom_slider) {
+ g_zoom_slider = new wxSlider(sb, wxID_ANY, 100, 50, 250);
+ g_zoom_slider->SetToolTip(wxT("Table zoom"));
+ g_zoom_label = new wxStaticText(sb, wxID_ANY, wxT("100%"),
+ wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT | wxST_NO_AUTORESIZE);
+ // Editable percent field (round 15 #4): type an exact scale and press Enter.
+ g_zoom_entry = new wxTextCtrl(sb, wxID_ANY, wxT("100%"), wxDefaultPosition,
+ wxDefaultSize, wxTE_PROCESS_ENTER | wxTE_RIGHT);
+ g_zoom_entry->SetToolTip(wxT("Table zoom (type a %, Enter)"));
+ g_zoom_slider->Bind(wxEVT_SLIDER, [](wxCommandEvent& e) {
+ apply_table_zoom(e.GetInt() / 100.0);
+ });
+ g_zoom_entry->Bind(wxEVT_TEXT_ENTER, [](wxCommandEvent&) {
+ if (!g_zoom_entry) return;
+ wxString s = g_zoom_entry->GetValue();
+ s.Replace("%", "");
+ s.Trim(true).Trim(false);
+ long pct = 0;
+ if (s.ToLong(&pct) && pct > 0) wxbr_table_set_zoom(pct / 100.0);
+ });
+ sb->Bind(wxEVT_SIZE, [](wxSizeEvent& ev) {
+ reposition_status_indicator();
+ ev.Skip();
+ });
+ // Ctrl +/- / Ctrl+0 zoom the table from anywhere in the window (round 15 #4).
+ frame->Bind(wxEVT_CHAR_HOOK, [](wxKeyEvent& e) {
+ if (e.ControlDown()) {
+ int k = e.GetKeyCode();
+ if (k == '=' || k == '+' || k == WXK_NUMPAD_ADD) {
+ wxbr_table_set_zoom(g_table_zoom + 0.1);
+ return;
+ }
+ if (k == '-' || k == WXK_NUMPAD_SUBTRACT) {
+ wxbr_table_set_zoom(g_table_zoom - 0.1);
+ return;
+ }
+ if (k == '0' || k == WXK_NUMPAD0) {
+ wxbr_table_set_zoom(1.0);
+ return;
+ }
+ }
+ e.Skip();
+ });
+ }
+ reposition_status_indicator();
+}
@@ -85,6 +85,10 @@ class AttrListStore : public wxDataViewListStore {
// Per-cell hover tooltip text, keyed by (row, model column). Used for the
// Errors column's full-message tooltip (see the GTK query-tooltip handler).
std::map<std::pair<unsigned, unsigned>, wxString> cell_tip;
// Per-ICON hover tooltips for a cell (round 15 #15): the Health column stores
// one tooltip per component icon so the tooltip pertains to the icon under the
// pointer, not the whole cell.
std::map<std::pair<unsigned, unsigned>, std::vector<wxString>> icon_tip;
bool GetAttrByRow(unsigned int row, unsigned int col,
wxDataViewItemAttr& attr) const override {
(void)col;
@@ -173,6 +177,13 @@ const wxUniChar SHAPE_BOLT = 0x0C; // power supply
const wxUniChar SHAPE_BRAIN = 0x0E; // control board
const wxUniChar SHAPE_FAN = 0x0F; // cooling fan
const wxUniChar SHAPE_CHIP = 0x10; // hashboard
// Locate-light beacon (round 15 #6): a green dot above a red dot, both flashing
// quickly while the miner's locate light is on.
const wxUniChar SHAPE_LIGHT_BEACON = 0x11;
// Health-column alignment gap (round 15 #5): draws nothing but advances by one
// health-icon width, so component icons line up in fixed slots across rows even
// when a miner has fewer fans/boards than the widest in the fleet.
const wxUniChar SHAPE_GAP = 0x12;
const int SHAPE_ADVANCE = 15; // horizontal space one shape occupies
// Table zoom factor (round 14 #3), 1.0 = 100%. A status-bar slider scales the
@@ -183,7 +194,7 @@ static wxDataViewCtrl* g_zoom_table = nullptr; // the table the zoom scales
static wxFont g_zoom_base_font; // its font at 100% (captured lazily)
static wxVector<int> g_zoom_base_w; // column widths at 100% (per column)
static wxSlider* g_zoom_slider = nullptr; // the status-bar zoom slider
static wxStaticText* g_zoom_label = nullptr; // the "100%" readout next to it
static wxTextCtrl* g_zoom_entry = nullptr; // the editable "100%" field next to it
// Animation phase for the pulsing locate-light dot (round 12 #6), advanced by a
// wxTimer while any such dot is on screen; the treeview it repaints is tracked so
@@ -196,7 +207,8 @@ bool IsShapeSentinel(const wxString& s, wxUniChar& out) {
wxUniChar c = s[0];
if (c == SHAPE_DOT || c == SHAPE_LOCK || c == SHAPE_UNLOCK ||
c == SHAPE_HASHING || c == SHAPE_SLOW || c == SHAPE_NOTHASHING ||
c == SHAPE_PAUSED || c == SHAPE_PULSE_DOT ||
c == SHAPE_PAUSED || c == SHAPE_PULSE_DOT || c == SHAPE_LIGHT_BEACON ||
c == SHAPE_GAP ||
c == SHAPE_BOLT || c == SHAPE_BRAIN || c == SHAPE_FAN || c == SHAPE_CHIP) {
out = c;
return true;
@@ -296,6 +308,18 @@ const wxBitmap& ShapeBitmap(wxUniChar shape, const ShapeSvg& sv, const wxColour&
int DrawShape(wxDC* dc, wxUniChar shape, wxCoord x, const wxRect& cell,
const wxColour& colour, const wxColour& bg) {
int cy = cell.y + cell.height / 2;
// Health-column alignment gap (round 15 #5): occupy one health-icon width but
// draw nothing, so component icons line up in fixed slots across rows. The
// health icons are square, so the advance is (h - 3) just like a real one.
if (shape == SHAPE_GAP) {
int h = cell.height - 1;
int cap = (int)(28 * g_table_zoom + 0.5);
if (cap < 8) cap = 8;
if (h > cap) h = cap;
if (h < 8) h = 8;
int adv = h - 3;
return adv < 1 ? 1 : adv;
}
// SVG-backed icon (access padlocks #9, status KPI icons #11): recolour to the
// segment colour, rasterise (cached), and draw centred in its slot.
if (const ShapeSvg* sv = LookupShapeSvg(shape)) {
@@ -327,6 +351,20 @@ int DrawShape(wxDC* dc, wxUniChar shape, wxCoord x, const wxRect& cell,
}
}
int cx = x + SHAPE_ADVANCE / 2;
if (shape == SHAPE_LIGHT_BEACON) {
// A green dot above a red dot, both flashing quickly (round 15 #6). The blink
// is a fast on/off (~0.5 s) driven by the shared pulse phase.
double a = (std::sin(g_pulse_phase * 3.0) > 0.0) ? 1.0 : 0.18;
wxColour green = BlendColour(bg, wxColour(30, 175, 70), a);
wxColour red = BlendColour(bg, wxColour(215, 45, 40), a);
int r = 3;
dc->SetPen(*wxTRANSPARENT_PEN);
dc->SetBrush(wxBrush(green));
dc->DrawCircle(cx, cy - (r + 1), r);
dc->SetBrush(wxBrush(red));
dc->DrawCircle(cx, cy + (r + 1), r);
return SHAPE_ADVANCE;
}
if (shape == SHAPE_DOT || shape == SHAPE_PULSE_DOT) {
wxColour fill = colour;
if (shape == SHAPE_PULSE_DOT) {
@@ -475,7 +513,12 @@ class SegmentRenderer : public wxDataViewCustomRenderer {
// with the table zoom (round 14 #3).
int hh = (int)((health ? 22 : 15) * g_table_zoom + 0.5);
if (hh < 8) hh = 8;
if (const ShapeSvg* sv = LookupShapeSvg(shape)) {
// The alignment gap is one health-icon-width slot that draws nothing
// (round 15 #5); health icons are square, so its advance is hh - 3.
if (shape == SHAPE_GAP) {
adv = hh - 3;
if (adv < 1) adv = 1;
} else if (const ShapeSvg* sv = LookupShapeSvg(shape)) {
int ww = (sv->vbh > 0) ? (int)((double)hh * sv->vbw / sv->vbh + 0.5) : hh;
if (health) {
adv = ww - 3;
@@ -638,6 +681,16 @@ void wxbr_set_min_size(void* win, int w, int h) {
((wxWindow*)win)->SetMinSize(wxSize(w, h));
}
// Attach a hover tooltip to any widget (round 15 #10). An empty string clears it.
void wxbr_set_tooltip(void* win, const char* text) {
wxWindow* w = (wxWindow*)win;
if (text && *text) {
w->SetToolTip(wxString::FromUTF8(text));
} else {
w->UnsetToolTip();
}
}
// ---- static text / fonts --------------------------------------------------
void* wxbr_static_text(void* parent, const char* label) {
@@ -724,6 +777,15 @@ void wxbr_text_ctrl_set(void* win, const char* value) {
((wxTextCtrl*)win)->SetValue(wxString::FromUTF8(value));
}
// Insert text at the current cursor position, replacing any selection (round 15
// #1: worker-name placeholders are inserted, not overwritten). Leaves focus + the
// cursor after the inserted text.
void wxbr_text_ctrl_write(void* win, const char* value) {
wxTextCtrl* t = (wxTextCtrl*)win;
t->WriteText(wxString::FromUTF8(value));
t->SetFocus();
}
// ---- checkbox -------------------------------------------------------------
void* wxbr_check_box(void* parent, const char* label) {
@@ -837,6 +899,25 @@ int wxbr_file_dialog(void* parent, const char* title, char* buf, int cap) {
return n + 1;
}
// Save-file dialog (round 15 #14). `default_name` prefills the filename;
// `wildcard` is a wxWidgets filter string (e.g. "CSV files (*.csv)|*.csv").
// Returns the chosen path in `buf` (length+1), or 0 if cancelled.
int wxbr_save_file_dialog(void* parent, const char* title, const char* default_name,
const char* wildcard, char* buf, int cap) {
wxString wc = (wildcard && *wildcard) ? wxString::FromUTF8(wildcard)
: wxString(wxFileSelectorDefaultWildcardStr);
wxFileDialog dlg((wxWindow*)parent, wxString::FromUTF8(title), wxEmptyString,
wxString::FromUTF8(default_name ? default_name : ""), wc,
wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
if (dlg.ShowModal() != wxID_OK) return 0;
wxCharBuffer b = dlg.GetPath().ToUTF8();
int n = (int)strlen(b.data());
if (n >= cap) n = cap - 1;
memcpy(buf, b.data(), n);
buf[n] = 0;
return n + 1;
}
// ---- data view list ctrl ------------------------------------------------------
static AttrListStore* dvlc_store(void* win) {
@@ -861,12 +942,38 @@ static gboolean dvlc_query_tooltip(GtkWidget* tv, gint x, gint y, gboolean keybo
return FALSE;
gint* idx = gtk_tree_path_get_indices(path);
int row = idx ? idx[0] : -1;
gtk_tree_path_free(path);
if (row < 0 || !gcol) return FALSE;
if (row < 0 || !gcol) { gtk_tree_path_free(path); return FALSE; }
wxDataViewColumn* wxcol = dv->GTKColumnToWX(gcol);
if (!wxcol) return FALSE;
if (!wxcol) { gtk_tree_path_free(path); return FALSE; }
AttrListStore* store = static_cast<AttrListStore*>(dv->GetModel());
auto it = store->cell_tip.find({(unsigned)row, wxcol->GetModelColumn()});
unsigned mcol = wxcol->GetModelColumn();
// Per-icon tooltip (round 15 #15): if this cell has one tooltip per icon, pick
// the one under the pointer from the icon slot the x-offset falls in.
auto iit = store->icon_tip.find({(unsigned)row, mcol});
if (iit != store->icon_tip.end() && !iit->second.empty()) {
GdkRectangle crect;
gtk_tree_view_get_cell_area(GTK_TREE_VIEW(tv), path, gcol, &crect);
gtk_tree_path_free(path);
// Icon advance matches DrawShape's health-icon width (square icons: h - 3).
int h = crect.height - 1;
int cap = (int)(28 * g_table_zoom + 0.5);
if (cap < 8) cap = 8;
if (h > cap) h = cap;
if (h < 8) h = 8;
int adv = h - 3;
if (adv < 1) adv = 1;
int off = bx - crect.x;
if (off < 0) off = 0;
int slot = off / adv;
if (slot < 0) slot = 0;
if (slot >= (int)iit->second.size()) slot = (int)iit->second.size() - 1;
const wxString& tip = iit->second[(size_t)slot];
if (tip.IsEmpty()) return FALSE;
gtk_tooltip_set_text(tooltip, tip.utf8_str());
return TRUE;
}
gtk_tree_path_free(path);
auto it = store->cell_tip.find({(unsigned)row, mcol});
if (it == store->cell_tip.end() || it->second.IsEmpty()) return FALSE;
gtk_tooltip_set_text(tooltip, it->second.utf8_str());
return TRUE;
@@ -1051,6 +1158,30 @@ void wxbr_dvlc_clear(void* win) {
store->DeleteAllItems();
store->row_fg.clear();
store->cell_tip.clear();
store->icon_tip.clear();
}
// Set per-icon tooltips for one cell (round 15 #15): `joined` is the tooltips for
// each icon in draw order, separated by 0x1f. An empty string clears them.
void wxbr_dvlc_set_icon_tooltips(void* win, unsigned row, unsigned col, const char* joined) {
AttrListStore* store = dvlc_store(win);
if (!joined || !joined[0]) {
store->icon_tip.erase({row, col});
return;
}
std::vector<wxString> tips;
wxString s = wxString::FromUTF8(joined);
wxString cur;
for (size_t i = 0; i < s.length(); i++) {
if (s[i] == wxUniChar(0x1f)) {
tips.push_back(cur);
cur.clear();
} else {
cur += s[i];
}
}
tips.push_back(cur);
store->icon_tip[{row, col}] = tips;
}
// Set (or clear, with an empty string) the hover tooltip for one cell,
@@ -1594,6 +1725,12 @@ void wxbr_menu_append(void* menu, int id, const char* label) {
((wxMenu*)menu)->Append(id, wxString::FromUTF8(label));
}
// Append `submenu` under `menu` as a labelled sub-menu (round 15 #13); `menu`
// takes ownership of `submenu`.
void wxbr_menu_append_submenu(void* menu, const char* label, void* submenu) {
((wxMenu*)menu)->AppendSubMenu((wxMenu*)submenu, wxString::FromUTF8(label));
}
void wxbr_menu_append_separator(void* menu) {
((wxMenu*)menu)->AppendSeparator();
}
@@ -1751,17 +1888,17 @@ static void reposition_status_indicator() {
g_status_indicator->SetSize(r.x + 4, y, r.width - 8, h);
}
}
// Zoom slider + "NNN%" label in the far-right field (round 14 #3): label at the
// right edge, slider filling the space to its left.
if (g_zoom_slider && g_zoom_label) {
// Zoom slider + editable "NNN%" entry in the far-right field (round 14 #3, #4):
// the entry at the right edge, slider filling the space to its left.
if (g_zoom_slider && g_zoom_entry) {
int fld = (sb->GetFieldsCount() >= 3) ? 2 : 1;
wxRect r;
if (sb->GetFieldRect(fld, r)) {
wxSize lbest = g_zoom_label->GetBestSize();
int lw = lbest.GetWidth() + 6;
int lh = lbest.GetHeight();
g_zoom_label->SetSize(r.x + r.width - lw, r.y + (r.height - lh) / 2, lw, lh);
int sw = r.width - lw - 8;
int ew = 52;
int eh = g_zoom_entry->GetBestSize().GetHeight();
if (eh > r.height - 2) eh = r.height - 2;
g_zoom_entry->SetSize(r.x + r.width - ew - 2, r.y + (r.height - eh) / 2, ew, eh);
int sw = r.width - ew - 10;
if (sw < 20) sw = 20;
int sh = r.height - 2;
g_zoom_slider->SetSize(r.x + 2, r.y + (r.height - sh) / 2, sw, sh);
@@ -1796,9 +1933,9 @@ static void apply_table_zoom(double factor) {
g_zoom_table->Refresh();
g_zoom_table->Update();
}
if (g_zoom_label) {
g_zoom_label->SetLabel(wxString::Format(wxT("%d%%"), (int)(factor * 100 + 0.5)));
reposition_status_indicator();
if (g_zoom_entry) {
// ChangeValue does not fire wxEVT_TEXT, so this never loops back into a zoom.
g_zoom_entry->ChangeValue(wxString::Format(wxT("%d%%"), (int)(factor * 100 + 0.5)));
}
}
@@ -1834,6 +1971,7 @@ void wxbr_status_indicator_set(const char* text, int r, int g, int b) {
// #3). Widens the bar to three fields (status | indicator | zoom) and wires the
// slider straight to apply_table_zoom -- no Rust round-trip. Call after the table
// exists so the slider can find it.
void wxbr_table_set_zoom(double factor); // defined below; used by the handlers here
void wxbr_status_zoom_init(void* frame_ptr) {
wxFrame* frame = (wxFrame*)frame_ptr;
wxStatusBar* sb = frame->GetStatusBar();
@@ -1847,15 +1985,44 @@ void wxbr_status_zoom_init(void* frame_ptr) {
if (!g_zoom_slider) {
g_zoom_slider = new wxSlider(sb, wxID_ANY, 100, 50, 250);
g_zoom_slider->SetToolTip(wxT("Table zoom"));
g_zoom_label = new wxStaticText(sb, wxID_ANY, wxT("100%"),
wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT | wxST_NO_AUTORESIZE);
// Editable percent field (round 15 #4): type an exact scale and press Enter.
g_zoom_entry = new wxTextCtrl(sb, wxID_ANY, wxT("100%"), wxDefaultPosition,
wxDefaultSize, wxTE_PROCESS_ENTER | wxTE_RIGHT);
g_zoom_entry->SetToolTip(wxT("Table zoom (type a %, Enter)"));
g_zoom_slider->Bind(wxEVT_SLIDER, [](wxCommandEvent& e) {
apply_table_zoom(e.GetInt() / 100.0);
});
g_zoom_entry->Bind(wxEVT_TEXT_ENTER, [](wxCommandEvent&) {
if (!g_zoom_entry) return;
wxString s = g_zoom_entry->GetValue();
s.Replace("%", "");
s.Trim(true).Trim(false);
long pct = 0;
if (s.ToLong(&pct) && pct > 0) wxbr_table_set_zoom(pct / 100.0);
});
sb->Bind(wxEVT_SIZE, [](wxSizeEvent& ev) {
reposition_status_indicator();
ev.Skip();
});
// Ctrl +/- / Ctrl+0 zoom the table from anywhere in the window (round 15 #4).
frame->Bind(wxEVT_CHAR_HOOK, [](wxKeyEvent& e) {
if (e.ControlDown()) {
int k = e.GetKeyCode();
if (k == '=' || k == '+' || k == WXK_NUMPAD_ADD) {
wxbr_table_set_zoom(g_table_zoom + 0.1);
return;
}
if (k == '-' || k == WXK_NUMPAD_SUBTRACT) {
wxbr_table_set_zoom(g_table_zoom - 0.1);
return;
}
if (k == '0' || k == WXK_NUMPAD0) {
wxbr_table_set_zoom(1.0);
return;
}
}
e.Skip();
});
}
reposition_status_indicator();
}
+64
View File
@@ -27,6 +27,7 @@ mod notsafe {
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_set_tooltip(win: *mut c_void, text: *const c_char);
pub fn wxbr_static_text(parent: *mut c_void, label: *const c_char) -> *mut c_void;
pub fn wxbr_set_label(win: *mut c_void, label: *const c_char);
pub fn wxbr_get_label(win: *mut c_void, buf: *mut c_char, cap: c_int) -> c_int;
@@ -37,6 +38,7 @@ mod notsafe {
pub fn wxbr_text_ctrl(parent: *mut c_void, multiline: c_int) -> *mut c_void;
pub fn wxbr_text_ctrl_get(win: *mut c_void, buf: *mut c_char, cap: c_int) -> c_int;
pub fn wxbr_text_ctrl_set(win: *mut c_void, value: *const c_char);
pub fn wxbr_text_ctrl_write(win: *mut c_void, value: *const c_char);
pub fn wxbr_check_box(parent: *mut c_void, label: *const c_char) -> *mut c_void;
pub fn wxbr_check_box_get(win: *mut c_void) -> c_int;
pub fn wxbr_check_box_set(win: *mut c_void, v: c_int);
@@ -51,6 +53,7 @@ mod notsafe {
pub fn wxbr_dialog_show_modal(win: *mut c_void) -> c_int;
pub fn wxbr_dialog_close(win: *mut c_void, code: c_int);
pub fn wxbr_file_dialog(parent: *mut c_void, title: *const c_char, buf: *mut c_char, cap: c_int) -> c_int;
pub fn wxbr_save_file_dialog(parent: *mut c_void, title: *const c_char, default_name: *const c_char, wildcard: *const c_char, buf: *mut c_char, cap: c_int) -> c_int;
pub fn wxbr_dvlc(parent: *mut c_void) -> *mut c_void;
pub fn wxbr_dvlc_append_text_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int);
pub fn wxbr_dvlc_append_colored_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int) -> *mut c_void;
@@ -61,6 +64,7 @@ mod notsafe {
pub fn wxbr_dvlc_row_count(win: *mut c_void) -> c_int;
pub fn wxbr_dvlc_set_cell(win: *mut c_void, row: usize, col: usize, value: *const c_char);
pub fn wxbr_dvlc_set_cell_tooltip(win: *mut c_void, row: usize, col: usize, text: *const c_char);
pub fn wxbr_dvlc_set_icon_tooltips(win: *mut c_void, row: usize, col: usize, joined: *const c_char);
pub fn wxbr_dvlc_get_cell(win: *mut c_void, row: usize, col: usize, buf: *mut c_char, cap: c_int) -> c_int;
pub fn wxbr_dvlc_col_count(win: *mut c_void) -> c_int;
pub fn wxbr_dvlc_autosize_col(win: *mut c_void, pos: c_int);
@@ -85,6 +89,7 @@ mod notsafe {
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);
pub fn wxbr_menu_append_submenu(menu: *mut c_void, label: *const c_char, submenu: *mut c_void);
pub fn wxbr_popup_menu(win: *mut c_void, menu: *mut c_void);
pub fn wxbr_timer(id: c_int, ms: c_int) -> *mut c_void;
pub fn wxbr_gauge(parent: *mut c_void, range: c_int) -> *mut c_void;
@@ -378,6 +383,12 @@ impl Widget {
unsafe { notsafe::wxbr_set_min_size(self.0, w, h) }
}
/// Attach a hover tooltip to this widget (round 15 #10). Empty clears it.
pub fn set_tool_tip(&self, text: &str) {
let c = CString::new(text).unwrap_or_default();
unsafe { notsafe::wxbr_set_tooltip(self.0, c.as_ptr()) }
}
pub fn static_text(parent: Widget, label: &str) -> Widget {
let c = CString::new(label).unwrap_or_default();
Widget(unsafe { notsafe::wxbr_static_text(parent.0, c.as_ptr()) })
@@ -439,6 +450,13 @@ impl Widget {
unsafe { notsafe::wxbr_text_ctrl_set(self.0, c.as_ptr()) }
}
/// Insert `value` at the text control's cursor (replacing any selection),
/// rather than replacing the whole contents (round 15 #1).
pub fn write_text(&self, value: &str) {
let c = CString::new(value).unwrap_or_default();
unsafe { notsafe::wxbr_text_ctrl_write(self.0, c.as_ptr()) }
}
pub fn check_box(parent: Widget, label: &str) -> Widget {
let c = CString::new(label).unwrap_or_default();
Widget(unsafe { notsafe::wxbr_check_box(parent.0, c.as_ptr()) })
@@ -516,6 +534,36 @@ impl Widget {
Some(String::from_utf8_lossy(&bytes).into_owned())
}
/// Save-file dialog (round 15 #14): returns the chosen path, or None if
/// cancelled. `default_name` prefills the filename; `wildcard` is a wx filter
/// string like "CSV files (*.csv)|*.csv".
pub fn save_file_dialog(
parent: Widget,
title: &str,
default_name: &str,
wildcard: &str,
) -> Option<String> {
let t = CString::new(title).unwrap_or_default();
let d = CString::new(default_name).unwrap_or_default();
let w = CString::new(wildcard).unwrap_or_default();
let mut buf = vec![0i8; 4096];
let n = unsafe {
notsafe::wxbr_save_file_dialog(
parent.0,
t.as_ptr(),
d.as_ptr(),
w.as_ptr(),
buf.as_mut_ptr(),
buf.len() as c_int,
)
};
if n <= 0 {
return None;
}
let bytes: Vec<u8> = buf[..(n - 1) as usize].iter().map(|&b| b as u8).collect();
Some(String::from_utf8_lossy(&bytes).into_owned())
}
// ---- data view list ctrl ----
pub fn dvlc(parent: Widget) -> Widget {
@@ -569,6 +617,15 @@ impl Widget {
unsafe { notsafe::wxbr_dvlc_set_cell_tooltip(self.0, row, col, c.as_ptr()) }
}
/// Set per-icon hover tooltips for a cell (round 15 #15): one tooltip per icon
/// in draw order. The bridge shows the one under the pointer. Passing an empty
/// slice clears them.
pub fn dvlc_set_icon_tooltips(&self, row: usize, col: usize, tips: &[String]) {
let joined = tips.join("\u{1f}");
let c = CString::new(joined).unwrap_or_default();
unsafe { notsafe::wxbr_dvlc_set_icon_tooltips(self.0, row, col, c.as_ptr()) }
}
pub fn dvlc_get_cell(&self, row: usize, col: usize) -> Option<String> {
let mut buf = vec![0i8; 4096];
let n = unsafe {
@@ -722,6 +779,13 @@ impl Widget {
unsafe { notsafe::wxbr_menu_append_separator(self.0) }
}
/// Append `submenu` under this menu with `label` (round 15 #13). This menu
/// takes ownership of the submenu.
pub fn menu_append_submenu(&self, label: &str, submenu: Widget) {
let c = CString::new(label).unwrap_or_default();
unsafe { notsafe::wxbr_menu_append_submenu(self.0, c.as_ptr(), submenu.0) }
}
/// Show `menu` as a popup on this window; blocks until dismissed.
pub fn popup_menu(&self, menu: Widget) {
unsafe { notsafe::wxbr_popup_menu(self.0, menu.0) }
+1 -1
View File
@@ -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":"cf1bd56ca56178968f8ef57955f06d14f4c3775f27ca3a85ac280919f19b8e50","src/backends/v2020/rpc.rs":"b517f88b9125fe1d8a20d5167f5d0d105b1339fce3d1a9fad5592e00470f46fb","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":"e75c21d63218204b61bfab067599402e5c0b20452beaf0b16bfa79bf8afb6b35","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":"efcaa6b186c8b6e79e9799a647291b895c5ff59f058722e98455ef68bc97c548","src/backends/v2020/rpc.rs":"b517f88b9125fe1d8a20d5167f5d0d105b1339fce3d1a9fad5592e00470f46fb","src/backends/v2020/web.rs":"a6a3ad3eb77551b098b0092553b02cee43d165476d8c92164e12a1e765753b0d","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":"e75c21d63218204b61bfab067599402e5c0b20452beaf0b16bfa79bf8afb6b35","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"}
+20 -4
View File
@@ -833,15 +833,23 @@ impl GetFans for AntMinerV2020 {
let mut fans: Vec<FanData> = Vec::new();
if let Some(stats_data) = data.get(&DataField::Fans) {
for i in 1..=self.device_info.hardware.fans.unwrap_or(4) {
// Some models report their fans in higher fan slots and leave the low
// ones at 0 -- the Z15, for example, has fan_num=2 but reports its two
// fans in fan3/fan4 with fan1/fan2 = 0. So scan a generous range of
// slots and collect the non-zero readings rather than only reading
// fan1..hardware.fans (which missed the Z15 entirely). The collected
// fans are renumbered 0.. in the order found (round 14 #12).
let mut pos: i16 = 0;
for i in 1..=16 {
if let Some(fan_speed) =
stats_data.get(format!("fan{}", i)).and_then(|v| v.as_f64())
&& fan_speed > 0.0
{
fans.push(FanData {
position: (i - 1) as i16,
position: pos,
rpm: Some(AngularVelocity::from_rpm(fan_speed)),
});
pos += 1;
}
}
}
@@ -1103,9 +1111,17 @@ impl SetFaultLight for AntMinerV2020 {
true
}
#[allow(unused_variables)]
async fn set_fault_light(&self, fault: bool) -> anyhow::Result<bool> {
Ok(self.web.blink(fault).await.is_ok())
// `blink()` fires the toggle then reads the state back as `{"isBlinking":
// bool}` (the legacy CGI's own HTTP status is unreliable). Report success
// only when the observed locate-LED state matches what was requested.
let observed = self
.web
.blink(fault)
.await?
.get("isBlinking")
.and_then(serde_json::Value::as_bool);
Ok(observed == Some(fault))
}
}
+81 -13
View File
@@ -240,6 +240,45 @@ impl AntMinerWebAPI {
Ok(response)
}
/// POST a form-encoded (`application/x-www-form-urlencoded`) body to a CGI
/// endpoint and parse the JSON reply. The legacy LuCI web UI endpoints (e.g.
/// `blink.cgi`) expect `action=...` form fields, not a JSON body. An empty
/// reply parses to `{}`; a non-2xx status bails.
async fn send_web_form_command(&self, command: &str, form: &[(&str, &str)]) -> Result<Value> {
let url = format!("http://{}:{}/cgi-bin/{}.cgi", self.ip, self.port, command);
// Build an application/x-www-form-urlencoded body by hand (this reqwest
// build has no `.form()` helper). The only fields used are `action` with
// fixed ASCII values, so percent-encoding is unnecessary.
let body = form
.iter()
.map(|(k, v)| format!("{k}={v}"))
.collect::<Vec<_>>()
.join("&");
let response = self
.client()?
.post(&url)
.header(
reqwest::header::CONTENT_TYPE,
"application/x-www-form-urlencoded",
)
.body(body)
.timeout(self.timeout)
.send_digest_auth((self.auth.username(), self.auth.password()))
.await
.map_err(|e| anyhow!(e.to_string()))?;
let status = response.status();
if !status.is_success() {
bail!("HTTP request failed with status code {}", status);
}
let text = response.text().await.map_err(|e| anyhow!(e.to_string()))?;
if text.trim().is_empty() {
Ok(json!({}))
} else {
serde_json::from_str(&text).map_err(|e| anyhow!(e.to_string()))
}
}
pub async fn get_miner_conf(&self) -> Result<Value> {
self.send_web_command("get_miner_conf", false, None, Method::GET)
.await
@@ -257,17 +296,31 @@ impl AntMinerWebAPI {
}
pub async fn blink(&self, blink: bool) -> Result<Value> {
let param = if blink {
json!({"blink": "true"})
} else {
json!({"blink": "false"})
};
self.send_web_command("blink", false, Some(param), Method::POST)
// Legacy LuCI web UI: the locate LED is toggled by POSTing an `action`
// form field to blink.cgi (`startBlink`/`stopBlink`) -- NOT a JSON body
// like the newer (>= 2023.07) firmware expects. The handler performs the
// action but frequently answers 401/500 even on success, so its HTTP
// status is not a reliable signal: fire it, ignore the response, then read
// the real state back via `onPageLoaded`.
let action = if blink { "startBlink" } else { "stopBlink" };
let _ = self
.send_web_form_command("blink", &[("action", action)])
.await;
self.blink_status().await
}
/// Query the locate-LED state via the legacy blink.cgi `onPageLoaded` action,
/// which reliably answers `200 {"isBlinking": bool}`.
pub async fn blink_status(&self) -> Result<Value> {
self.send_web_form_command("blink", &[("action", "onPageLoaded")])
.await
}
pub async fn reboot(&self) -> Result<Value> {
self.send_web_command("reboot", false, None, Method::POST)
// The legacy LuCI web UI reboots via GET /cgi-bin/reboot.cgi (its own
// reboot.html does `type: 'GET'`); a POST is not what this firmware
// generation expects.
self.send_web_command("reboot", false, None, Method::GET)
.await
}
@@ -350,8 +403,17 @@ impl AntMinerWebAPI {
}
pub async fn get_blink_status(&self) -> Result<Value> {
self.send_web_command("get_blink_status", false, None, Method::GET)
.await
// The old firmware has no `get_blink_status.cgi` (it answers 404); the
// locate state lives behind blink.cgi's `onPageLoaded` action as
// `{"isBlinking": bool}`. Remap it to `{"blink": bool}` so the shared
// LightFlashing extractor (key `/blink`) keeps working.
let flashing = self
.blink_status()
.await?
.get("isBlinking")
.and_then(Value::as_bool)
.unwrap_or(false);
Ok(json!({ "blink": flashing }))
}
pub async fn set_network_conf(
@@ -383,10 +445,16 @@ impl APIClient for AntMinerWebAPI {
MinerCommand::WebAPI {
command,
parameters,
} => self
.send_web_command(command, false, parameters.clone(), Method::GET)
.await
.map_err(|e| anyhow!(e.to_string())),
} => {
// The legacy blink status lives behind a POST form action, not a
// GET .cgi (which 404s), so route it through the dedicated helper.
if *command == "get_blink_status" {
return self.get_blink_status().await;
}
self.send_web_command(command, false, parameters.clone(), Method::GET)
.await
.map_err(|e| anyhow!(e.to_string()))
}
_ => Err(anyhow!("Unsupported command type for Web client")),
}
}
File diff suppressed because one or more lines are too long
+15 -1
View File
@@ -286,6 +286,14 @@ impl GetDataLocations for BraiinsV2604 {
tag: None,
},
)],
DataField::BestShare => vec![(
WEB_MINER_STATS,
DataExtractor {
func: get_by_pointer,
key: Some("/miner_stats/best_share"),
tag: None,
},
)],
DataField::TuningTarget => vec![
(
WEB_MINER_CONFIGURATION,
@@ -548,7 +556,13 @@ impl GetUptime for BraiinsV2604 {
}
}
impl GetBestShare for BraiinsV2604 {}
impl GetBestShare for BraiinsV2604 {
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
// Braiins OS reports the all-time best share at miner/stats -> miner_stats.best_share
// (round 16 / G9). Large diffs may exceed f64 exactness but are fine for display.
data.extract::<f64>(DataField::BestShare)
}
}
impl GetSessionBestShare for BraiinsV2604 {}
impl GetOperatingState for BraiinsV2604 {
+1 -1
View File
@@ -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":"4c9489c1f9b5f16e3fd8ab777da35bb120ccd0ca05f780cf94853c89fb5c8946","Cargo.lock":"69db8793725d6071e21b4353fb89537912096d7eccebd6ee597367330141f613","Cargo.toml":"df82261a9c3187bee15a7d6092d54ad2e9c7e4d1f127cd577c457d913f6881cf","Cargo.toml.orig":"e7c4ef90bc86763dad35d1a4da1c17c7e2f59eaac79e2f011647ae31c43d5e2b","src/backends/mod.rs":"1362c4d3805dccb7a78ef6b45d6a81b8f63b2be75fcf80329b6c2b0dd9e2d5c5","src/backends/v1/mod.rs":"360f173deb62c38bceb907774be6caaea5814b4f543d8d7f3c72828db31640b9","src/backends/v1/web.rs":"3a567a4f581baa5d9d2d4e59d8acc754eec51d49b0a4f5434d87614b037a4a55","src/firmware.rs":"fb88124a51089756cc3271f3d4a234d73add61ab919c4710ef26a52dc8b5ef80","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"24191681066d5cf6a3022ad59c1baa92b57e3ce7717bb78d6a682af9e19a38c4","src/test/json/v1/capabilities.json":"d2b3dae7aa2a1e2977e0ddf62cf2d730de64cf12bf62388c12fd23dc5278bbcb","src/test/json/v1/chip_clocks.json":"d1f46d3aad6ad55ec1c02d0b26aa4c5034c1ccaefb130d7b0e46efe48bb122a0","src/test/json/v1/chip_hashrates.json":"9601a1289f93fe4e27c722d51b3a31daa71aec71f2c29e71f6d1eefe01edf7f2","src/test/json/v1/chip_temps.json":"cb7390e424af57f55f0c974ddfe0c98c4d5b4dbcd85887e38ff8caf7b19f62fe","src/test/json/v1/chip_voltages.json":"cb7390e424af57f55f0c974ddfe0c98c4d5b4dbcd85887e38ff8caf7b19f62fe","src/test/json/v1/mod.rs":"5671105221b84b0b6edb2df34b25bfc9e33459da285d4316be0db23ddb630e8d","src/test/json/v1/network.json":"3374b419fa2f0bc19544c670e08118bbc45bd4d121a577c5a6403c8c8100f628","src/test/json/v1/summary.json":"ac8ac018da9d619b5884f283b730bad2bf0a7e8f2032a7119193c9e5d87d6a7c","src/test/json/v1/temps.json":"794edf870985ed4398ead96670b8f5d01deb4d825fb14a8325087a29cd939fa8","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"268dc7c8b3289fccd3230ff87f7bfc727a3e7e2f6f72ae56ab9d27c63eabc5cf"}
{"$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":"4c9489c1f9b5f16e3fd8ab777da35bb120ccd0ca05f780cf94853c89fb5c8946","Cargo.lock":"69db8793725d6071e21b4353fb89537912096d7eccebd6ee597367330141f613","Cargo.toml":"df82261a9c3187bee15a7d6092d54ad2e9c7e4d1f127cd577c457d913f6881cf","Cargo.toml.orig":"e7c4ef90bc86763dad35d1a4da1c17c7e2f59eaac79e2f011647ae31c43d5e2b","src/backends/mod.rs":"1362c4d3805dccb7a78ef6b45d6a81b8f63b2be75fcf80329b6c2b0dd9e2d5c5","src/backends/v1/mod.rs":"fff17902f8fa033d5b67c6131ea2ff01b80f9a9c8e02dd0511e1e87521d23e47","src/backends/v1/web.rs":"3a567a4f581baa5d9d2d4e59d8acc754eec51d49b0a4f5434d87614b037a4a55","src/firmware.rs":"fb88124a51089756cc3271f3d4a234d73add61ab919c4710ef26a52dc8b5ef80","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"24191681066d5cf6a3022ad59c1baa92b57e3ce7717bb78d6a682af9e19a38c4","src/test/json/v1/capabilities.json":"d2b3dae7aa2a1e2977e0ddf62cf2d730de64cf12bf62388c12fd23dc5278bbcb","src/test/json/v1/chip_clocks.json":"d1f46d3aad6ad55ec1c02d0b26aa4c5034c1ccaefb130d7b0e46efe48bb122a0","src/test/json/v1/chip_hashrates.json":"9601a1289f93fe4e27c722d51b3a31daa71aec71f2c29e71f6d1eefe01edf7f2","src/test/json/v1/chip_temps.json":"cb7390e424af57f55f0c974ddfe0c98c4d5b4dbcd85887e38ff8caf7b19f62fe","src/test/json/v1/chip_voltages.json":"cb7390e424af57f55f0c974ddfe0c98c4d5b4dbcd85887e38ff8caf7b19f62fe","src/test/json/v1/mod.rs":"5671105221b84b0b6edb2df34b25bfc9e33459da285d4316be0db23ddb630e8d","src/test/json/v1/network.json":"3374b419fa2f0bc19544c670e08118bbc45bd4d121a577c5a6403c8c8100f628","src/test/json/v1/summary.json":"ac8ac018da9d619b5884f283b730bad2bf0a7e8f2032a7119193c9e5d87d6a7c","src/test/json/v1/temps.json":"794edf870985ed4398ead96670b8f5d01deb4d825fb14a8325087a29cd939fa8","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"268dc7c8b3289fccd3230ff87f7bfc727a3e7e2f6f72ae56ab9d27c63eabc5cf"}
+8
View File
@@ -1369,6 +1369,14 @@ impl SetFaultLight for PowerPlayV1 {
#[async_trait]
impl SetPowerLimit for PowerPlayV1 {
fn supports_set_power_limit(&self) -> bool {
// ePIC PowerPlay's only true power-limit mechanism is the PowerTune
// perpetual-tune algorithm, which the firmware gates on the PSU: on a
// fixed-voltage Bitmain PSU (e.g. the APW12 on an S19j Pro) the
// perpetualtune/algo endpoint rejects it with "Power optimization is not
// supported by this PSU". Since that support is a per-PSU runtime property
// that this synchronous, no-I/O capability check cannot observe, report
// false rather than over-advertise a control that fails on most reflashed
// Antminers. (Hashrate tuning is exposed separately via set_tuning_config.)
false
}
}
+1 -1
View File
@@ -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":"fe8effe2bfdda5d4c390656c016729f531a2b1c60033228557659c0befdde9f2","Cargo.lock":"a2b2cb45bb8b574e4f29ffdcdb5ebafd1dd87a0e6e11b47383973a99be367784","Cargo.toml":"503efa00123f8567f5fe40bf6a93e9e453d13094df0e0e1b7e98bdacdfbd2595","Cargo.toml.orig":"1c4ba0315fb491c086fc22a5c9bafaf7288c6b1fd48679c3d03dbd9df156a8b5","src/backends/mod.rs":"548d988b877410e330a55e275f64b2adad95ca5f1a0f085fe144957c96b8906f","src/backends/v1/mod.rs":"fc109beb7fa4713b5f7a6d717e225ff91baa6f8ef497bc770a435f92981c2879","src/backends/v1/rpc.rs":"9dea9c65629e1e9b833b96a4ae88014f7195a26036104f92daa264fbdf13feba","src/firmware.rs":"d95345295ae5043dfc357e69ae56c564b261fdb3b19b5c0ad1765267ff05ab3f","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"24191681066d5cf6a3022ad59c1baa92b57e3ce7717bb78d6a682af9e19a38c4","src/test/json/v1/config.json":"6ca9e6217d853d4bf1e75d69159630e9c9184ede96751706b88dfb699b5d59ad","src/test/json/v1/devs.json":"8f746dc6a02953eee5ee96dcf53be8dc7880a8ffc2c6e303f0284bcf6a97f42d","src/test/json/v1/events.json":"913683ff97af3333018807e1cc6e43467ea8a55925e5964dc402616615e2a5e3","src/test/json/v1/fans.json":"f8a9a1234d651055c80f4ebb1380bbb4e6d19eb33012902c55fff1385e592447","src/test/json/v1/healthchipget_0.json":"10619460049333ca016b2beec59ecc514ed9077fb19bdf7d0ed697201f8cb96c","src/test/json/v1/healthchipget_1.json":"80927fb1480c95be7f3a4e155d63f68f97720530ff7cf5d5ade06f2a3e810bf0","src/test/json/v1/healthchipget_2.json":"1e93ee2ab472ee7af58add08b4251e3ce0ad4f986d4325abbf43fd4c9b3dd28f","src/test/json/v1/mod.rs":"5a050f07455e622e35ad79ab1c8a6daf2ea38c4198472e49c6bbfe80538a9e48","src/test/json/v1/pools.json":"0068745327e31853fec051172abb7337f18a4cf9972c51967113d63f4f31f504","src/test/json/v1/power.json":"80534bb4581de7c8b747bf33b5d629b909c6e16a531d18ecb4afd7ffad3f014f","src/test/json/v1/profiles.json":"1f00429036e270daa08f12cd2d7357135070c57acd7a899a3c0af6167fe82abb","src/test/json/v1/stats.json":"2b105f0eb927046c9d2389bde978a43e3d54d12a420dfbe400786bb2f0ae31ca","src/test/json/v1/summary.json":"aaea3378eb7040952037e2f1ef7bd5f20a1b242bf93d4ba0501c46104b0b31a0","src/test/json/v1/temps.json":"1ee781cd2be3ed6a6a07e23be930248735fb51348c160453ba10f6ef71fcb7f1","src/test/json/v1/version.json":"4beb6ca5c0ebf359cee0434fdcc4d0a1a0607436634e46be3fd951e2256595df","src/test/json/v1/voltageget_0.json":"c445fa8674c2542b2d296fbafdd3166c53008dfbd9da8095327217989d37f1da","src/test/json/v1/voltageget_1.json":"96b91c3447dd66e7f1f575ed3b99611062e8b1d516d31422b74e425c46b2f49c","src/test/json/v1/voltageget_2.json":"7d40544021b2e32401135ae333067b770d2d736ada9e60deaca8fd8f5a79a1e3","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"513792d93a2a21d5258d9e6ac0e6dc9e0a6365118934514b4e656792add78066"}
{"$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":"fe8effe2bfdda5d4c390656c016729f531a2b1c60033228557659c0befdde9f2","Cargo.lock":"a2b2cb45bb8b574e4f29ffdcdb5ebafd1dd87a0e6e11b47383973a99be367784","Cargo.toml":"503efa00123f8567f5fe40bf6a93e9e453d13094df0e0e1b7e98bdacdfbd2595","Cargo.toml.orig":"1c4ba0315fb491c086fc22a5c9bafaf7288c6b1fd48679c3d03dbd9df156a8b5","src/backends/mod.rs":"548d988b877410e330a55e275f64b2adad95ca5f1a0f085fe144957c96b8906f","src/backends/v1/mod.rs":"3e57d2c72d1d48c0b86f5438202633fcd9c1ebf375bd87ffe53ea5298ae936ad","src/backends/v1/rpc.rs":"25b0b9d56fbf113d5b8c3d3bc8eb7a0d67967b1f90f6d855da0b9f6ff24ae335","src/firmware.rs":"d95345295ae5043dfc357e69ae56c564b261fdb3b19b5c0ad1765267ff05ab3f","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"24191681066d5cf6a3022ad59c1baa92b57e3ce7717bb78d6a682af9e19a38c4","src/test/json/v1/config.json":"6ca9e6217d853d4bf1e75d69159630e9c9184ede96751706b88dfb699b5d59ad","src/test/json/v1/devs.json":"8f746dc6a02953eee5ee96dcf53be8dc7880a8ffc2c6e303f0284bcf6a97f42d","src/test/json/v1/events.json":"913683ff97af3333018807e1cc6e43467ea8a55925e5964dc402616615e2a5e3","src/test/json/v1/fans.json":"f8a9a1234d651055c80f4ebb1380bbb4e6d19eb33012902c55fff1385e592447","src/test/json/v1/healthchipget_0.json":"10619460049333ca016b2beec59ecc514ed9077fb19bdf7d0ed697201f8cb96c","src/test/json/v1/healthchipget_1.json":"80927fb1480c95be7f3a4e155d63f68f97720530ff7cf5d5ade06f2a3e810bf0","src/test/json/v1/healthchipget_2.json":"1e93ee2ab472ee7af58add08b4251e3ce0ad4f986d4325abbf43fd4c9b3dd28f","src/test/json/v1/mod.rs":"5a050f07455e622e35ad79ab1c8a6daf2ea38c4198472e49c6bbfe80538a9e48","src/test/json/v1/pools.json":"0068745327e31853fec051172abb7337f18a4cf9972c51967113d63f4f31f504","src/test/json/v1/power.json":"80534bb4581de7c8b747bf33b5d629b909c6e16a531d18ecb4afd7ffad3f014f","src/test/json/v1/profiles.json":"1f00429036e270daa08f12cd2d7357135070c57acd7a899a3c0af6167fe82abb","src/test/json/v1/stats.json":"2b105f0eb927046c9d2389bde978a43e3d54d12a420dfbe400786bb2f0ae31ca","src/test/json/v1/summary.json":"aaea3378eb7040952037e2f1ef7bd5f20a1b242bf93d4ba0501c46104b0b31a0","src/test/json/v1/temps.json":"1ee781cd2be3ed6a6a07e23be930248735fb51348c160453ba10f6ef71fcb7f1","src/test/json/v1/version.json":"4beb6ca5c0ebf359cee0434fdcc4d0a1a0607436634e46be3fd951e2256595df","src/test/json/v1/voltageget_0.json":"c445fa8674c2542b2d296fbafdd3166c53008dfbd9da8095327217989d37f1da","src/test/json/v1/voltageget_1.json":"96b91c3447dd66e7f1f575ed3b99611062e8b1d516d31422b74e425c46b2f49c","src/test/json/v1/voltageget_2.json":"7d40544021b2e32401135ae333067b770d2d736ada9e60deaca8fd8f5a79a1e3","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"513792d93a2a21d5258d9e6ac0e6dc9e0a6365118934514b4e656792add78066"}
+125 -3
View File
@@ -445,6 +445,22 @@ impl GetDataLocations for LuxMinerV1 {
tag: None,
},
)],
DataField::BestShare => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0/Best Share"),
tag: None,
},
)],
DataField::SessionBestShare => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0/Best Session Share"),
tag: None,
},
)],
DataField::Uptime => vec![(
RPC_STATS,
DataExtractor {
@@ -888,8 +904,18 @@ impl GetUptime for LuxMinerV1 {
}
}
impl GetBestShare for LuxMinerV1 {}
impl GetSessionBestShare for LuxMinerV1 {}
impl GetBestShare for LuxMinerV1 {
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
// LuxOS summary -> "Best Share" (all-time), round 16 / G9.
data.extract::<f64>(DataField::BestShare)
}
}
impl GetSessionBestShare for LuxMinerV1 {
fn parse_session_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
// LuxOS summary -> "Best Session Share" (since boot), round 16 / G9.
data.extract::<f64>(DataField::SessionBestShare)
}
}
impl GetOperatingState for LuxMinerV1 {}
@@ -1052,10 +1078,66 @@ impl SetFaultLight for LuxMinerV1 {
}
}
/// Parse a LuxOS `profiles` RPC reply into (step name, watts) pairs, keeping only
/// profiles that report both a `Step` and a `Watts` value.
fn parse_profile_watts(profiles: &Value) -> Vec<(String, f64)> {
profiles
.get("PROFILES")
.and_then(Value::as_array)
.map(|arr| {
arr.iter()
.filter_map(|p| {
let step = p.get("Step").and_then(Value::as_str)?.to_string();
let watts = p.get("Watts").and_then(Value::as_f64)?;
Some((step, watts))
})
.collect()
})
.unwrap_or_default()
}
/// Choose the LuxOS profile step to satisfy a watts power limit: the highest-watt
/// profile that does not exceed `target_w`, or -- when the target is below every
/// profile -- the lowest-watt profile. Returns None only when there are no
/// profiles to choose from.
fn select_profile_at_or_below(steps: &[(String, f64)], target_w: f64) -> Option<String> {
if steps.is_empty() {
return None;
}
let mut sorted: Vec<&(String, f64)> = steps.iter().collect();
sorted.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal));
sorted
.iter()
.rev()
.find(|(_, w)| *w <= target_w)
.or_else(|| sorted.first())
.map(|(s, _)| s.clone())
}
#[async_trait]
impl SetPowerLimit for LuxMinerV1 {
fn supports_set_power_limit(&self) -> bool {
false
true
}
async fn set_power_limit(&self, power: Power) -> anyhow::Result<bool> {
// LuxOS tunes by discrete named profiles (each carries a Watts rating),
// not a raw watts setpoint. Map the requested limit to the highest profile
// whose Watts does not exceed it (or the lowest profile when the target is
// below every profile), then apply it with profileset.
let profiles = self.rpc.profiles().await?;
let steps = parse_profile_watts(&profiles);
let Some(chosen) = select_profile_at_or_below(&steps, power.as_watts()) else {
anyhow::bail!("LuxOS reported no tunable profiles with a Step/Watts pair");
};
let resp = self.rpc.profileset(&chosen).await?;
// LuxOS answers with a STATUS array; "S"/"I" is success. A missing status
// after a non-error reply is treated as applied.
Ok(resp
.pointer("/STATUS/0/STATUS")
.and_then(Value::as_str)
.map(|s| matches!(s, "S" | "I"))
.unwrap_or(true))
}
}
@@ -1231,6 +1313,46 @@ mod tests {
POWER, PROFILES, STATS, SUMMARY, TEMPS, VERSION, VOLTAGEGET_0, VOLTAGEGET_1, VOLTAGEGET_2,
};
#[test]
fn power_limit_profile_selection() {
// LuxOS reports a ladder of profiles, each with a Step name and Watts.
let steps = vec![
("-16".to_string(), 865.0),
("-4".to_string(), 2385.0),
("-2".to_string(), 2790.0),
("0".to_string(), 3100.0),
];
// The highest profile at or below the requested watts limit.
assert_eq!(
select_profile_at_or_below(&steps, 2500.0).as_deref(),
Some("-4")
);
assert_eq!(
select_profile_at_or_below(&steps, 2790.0).as_deref(),
Some("-2")
);
// Above every profile -> the maximum profile (a limit can't exceed the
// hardware's top profile).
assert_eq!(
select_profile_at_or_below(&steps, 9000.0).as_deref(),
Some("0")
);
// Below every profile -> the minimum profile.
assert_eq!(
select_profile_at_or_below(&steps, 100.0).as_deref(),
Some("-16")
);
// No profiles -> nothing to choose.
assert_eq!(select_profile_at_or_below(&[], 2500.0), None);
// parse_profile_watts against the captured LuxOS `profiles` reply: it
// yields tunable profiles and selection finds a real step among them.
let profiles: Value = serde_json::from_str(PROFILES).unwrap();
let parsed = parse_profile_watts(&profiles);
assert!(!parsed.is_empty(), "fixture should carry tunable profiles");
assert!(select_profile_at_or_below(&parsed, 2500.0).is_some());
}
#[tokio::test]
async fn test_luxminer_v1() -> anyhow::Result<()> {
+16 -7
View File
@@ -239,7 +239,7 @@ impl LUXMinerRPCAPI {
pub async fn addgroup(&self, name: &str, quota: u32) -> anyhow::Result<Value> {
self.send_command(
"addgroup",
false,
true,
Some(Value::String(format!("{name},{quota}"))),
)
.await
@@ -248,7 +248,7 @@ impl LUXMinerRPCAPI {
pub async fn groupquota(&self, group_id: u32, quota: u32) -> anyhow::Result<Value> {
self.send_command(
"groupquota",
false,
true,
Some(Value::String(format!("{group_id},{quota}"))),
)
.await
@@ -257,7 +257,7 @@ impl LUXMinerRPCAPI {
pub async fn removegroup(&self, group_id: u32) -> anyhow::Result<Value> {
self.send_command(
"removegroup",
false,
true,
Some(Value::String(group_id.to_string())),
)
.await
@@ -275,14 +275,14 @@ impl LUXMinerRPCAPI {
params.push(group_id);
}
self.send_command("addpool", false, Some(Value::String(params.join(","))))
self.send_command("addpool", true, Some(Value::String(params.join(","))))
.await
}
pub async fn switchpool(&self, pool_id: i32) -> anyhow::Result<Value> {
self.send_command(
"switchpool",
false,
true,
Some(Value::String(pool_id.to_string())),
)
.await
@@ -291,7 +291,7 @@ impl LUXMinerRPCAPI {
pub async fn enablepool(&self, pool_id: i32) -> anyhow::Result<Value> {
self.send_command(
"enablepool",
false,
true,
Some(Value::String(pool_id.to_string())),
)
.await
@@ -300,7 +300,16 @@ impl LUXMinerRPCAPI {
pub async fn disablepool(&self, pool_id: i32) -> anyhow::Result<Value> {
self.send_command(
"disablepool",
false,
true,
Some(Value::String(pool_id.to_string())),
)
.await
}
pub async fn removepool(&self, pool_id: i32) -> anyhow::Result<Value> {
self.send_command(
"removepool",
true,
Some(Value::String(pool_id.to_string())),
)
.await
+1 -1
View File
@@ -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":"e46575e2bea28ad2933c09c69d0324e3fe1407fe42736b2f1882ec52721cc042","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"}
{"$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":"3a8bdecd1eb271de474b2aca85b5f8e598ba64fe5defc9c8dd9b8c66444a2ed4","src/backends/v1/rpc.rs":"72f9b67c2389ab6e9968e0eb340bd2b6aad9aaf059f4429eb31398863bb87f42","src/backends/v2/mod.rs":"68fd8c1762b424a7785174fdb3ae4fede1d599632657808d4b7c76bcfbfb202c","src/backends/v2/rpc.rs":"52f8d504c236009b020bf33b5550236e36d07b2c73a15bdcfcafa5188e4e1cb6","src/backends/v3/mod.rs":"f19e673c47c2cc366e2ff7782bca93daf750563d62221a12a043b3ee79a15251","src/backends/v3/rpc.rs":"7a5f80aec4af1bcaa0d36e67345aa9acbbd8ead73c0be474f06305358b38e81b","src/error_codes.rs":"b2af610880fb400a9e6297662371a6b3b55077b72cf11115b77fd4d2df44e6a1","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"}
+35 -20
View File
@@ -117,6 +117,10 @@ impl GetDataLocations for WhatsMinerV1 {
command: "get_psu",
parameters: None,
};
const RPC_GET_ERROR_CODE: MinerCommand = MinerCommand::RPC {
command: "get_error_code",
parameters: None,
};
match data_field {
DataField::Mac => vec![(
@@ -254,10 +258,10 @@ impl GetDataLocations for WhatsMinerV1 {
},
)],
DataField::Messages => vec![(
RPC_SUMMARY,
RPC_GET_ERROR_CODE,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0"),
key: Some("/Msg/error_code"),
tag: None,
},
)],
@@ -471,32 +475,43 @@ impl GetTuningCapabilities for WhatsMinerV1 {}
impl GetLightFlashing for WhatsMinerV1 {}
impl GetMessages for WhatsMinerV1 {
fn parse_messages(&self, data: &HashMap<DataField, Value>) -> Vec<MinerMessage> {
// WhatsMiner V1 (H6OS) reports faults via get_error_code -> Msg.error_code,
// an array of {code: timestamp} objects (the same shape as V2/V3; the RPC
// layer repairs the occasional invalid bare-pair array first). The older
// summary "Error Code N" fields are frequently empty on these units.
let mut messages = Vec::new();
let error_count = data
.get(&DataField::Messages)
.and_then(|val| {
val.pointer("/Error Code Count")
.and_then(|val| val.as_u64())
})
.unwrap_or(0u64) as usize;
for idx in 0..error_count {
let e_code = data
.get(&DataField::Messages)
.and_then(|val| val.pointer(&format!("/Error Code {}", idx)))
.and_then(|val| val.as_u64());
if let Some(code) = e_code {
let info = crate::error_codes::error_info(code);
let Some(errors) = data.get(&DataField::Messages) else {
return messages;
};
for obj in errors.as_array().unwrap_or(&Vec::new()).iter() {
let Some(obj) = obj.as_object() else {
continue;
};
for (code, time) in obj.iter() {
let Some(time_str) = time.as_str() else {
continue;
};
let timestamp =
chrono::NaiveDateTime::parse_from_str(time_str, "%Y-%m-%d %H:%M:%S")
.map(|t| {
chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
t,
chrono::Utc,
)
})
.map(|dt| dt.timestamp() as u32)
.unwrap_or(0);
let parsed_code = code.parse::<u64>().unwrap_or(0);
let info = crate::error_codes::error_info(parsed_code);
messages.push(MinerMessage::with_component(
0,
code,
timestamp,
parsed_code,
info.message,
MessageSeverity::Error,
info.component,
));
}
}
messages
}
}
@@ -106,6 +106,9 @@ impl RPCAPIClient for WhatsMinerRPCAPI {
let response = response
.replace('\n', "") // Fix for WM V1, can have newlines in version which breaks the json parser
.replace(",}", "}"); // Fix for WM V1, can have trailing commas which breaks the json parser
// Fix for WM V1 get_error_code, which can emit an invalid array of bare
// "code":"timestamp" pairs (`["540":".."]`) that fails the whole parse.
let response = crate::error_codes::repair_error_code_array(&response);
self.parse_rpc_result(&response)
}
@@ -202,6 +202,9 @@ impl WhatsMinerRPCAPI {
read_stream_response(&mut stream, DEFAULT_RPC_TIMEOUT).await
};
let response = response?;
// Repair the occasional invalid get_error_code array (bare
// "code":"timestamp" pairs) before parsing; a no-op on valid responses.
let response = crate::error_codes::repair_error_code_array(&response);
self.parse_rpc_result(&response)
}
+71
View File
@@ -2,6 +2,56 @@ use asic_rs_core::data::message::MinerComponent;
const UNKNOWN: &str = "Unknown error type.";
/// Repair an invalid `error_code` array emitted by some WhatsMiner firmware.
///
/// Certain (older, H6OS) firmwares report the fault list as bare
/// `"code":"timestamp"` pairs directly inside a JSON array
/// (`"error_code":["540":"..","541":".."]`) rather than an array of single-key
/// objects (`[{"540":".."},{"541":".."}]`). The bare form is not valid JSON and
/// fails the whole response parse, so no messages are surfaced at all. Rewrite the
/// bare pairs into objects; already-valid (object-wrapped or empty) arrays and
/// responses without an `error_code` array are returned unchanged.
pub fn repair_error_code_array(raw: &str) -> String {
const KEY: &str = "\"error_code\":[";
let Some(pos) = raw.find(KEY) else {
return raw.to_string();
};
let open = pos + KEY.len() - 1; // index of the '['
let bytes = raw.as_bytes();
let mut depth = 0i32;
let mut close = None;
for (i, &b) in bytes.iter().enumerate().skip(open) {
match b {
b'[' => depth += 1,
b']' => {
depth -= 1;
if depth == 0 {
close = Some(i);
break;
}
}
_ => {}
}
}
let Some(close) = close else {
return raw.to_string();
};
let inner = &raw[open + 1..close];
// Already valid (each entry object-wrapped) or empty -> leave untouched.
if inner.trim().is_empty() || inner.contains('{') {
return raw.to_string();
}
// Timestamps carry no commas, so a top-level comma split isolates each pair.
let wrapped = inner
.split(',')
.map(str::trim)
.filter(|s| !s.is_empty())
.map(|pair| format!("{{{pair}}}"))
.collect::<Vec<_>>()
.join(",");
format!("{}{}{}", &raw[..=open], wrapped, &raw[close..])
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ErrorInfo {
pub message: String,
@@ -514,6 +564,27 @@ fn serial_info_error(sub: u64, val: u64) -> String {
mod tests {
use super::*;
#[test]
fn repair_malformed_error_code_array() {
// Bare "code":"timestamp" pairs inside the array (invalid JSON) -> objects.
let bad = r#"{"STATUS":"S","Msg":{"error_code":["540":"2026-09-22 07:08:14","561":"2026-09-21 22:26:36"]},"Description":""}"#;
let fixed = repair_error_code_array(bad);
let v: serde_json::Value = serde_json::from_str(&fixed).expect("repaired JSON must parse");
let arr = v["Msg"]["error_code"].as_array().unwrap();
assert_eq!(arr.len(), 2);
assert_eq!(arr[0]["540"], "2026-09-22 07:08:14");
assert_eq!(arr[1]["561"], "2026-09-21 22:26:36");
// Already-valid (object-wrapped) arrays are returned unchanged.
let good = r#"{"Msg":{"error_code":[{"205":"2026-09-20 03:35:44"}]}}"#;
assert_eq!(repair_error_code_array(good), good);
// Empty array and no-array responses are untouched.
let empty = r#"{"Msg":{"error_code":[]}}"#;
assert_eq!(repair_error_code_array(empty), empty);
let none = r#"{"STATUS":"S"}"#;
assert_eq!(repair_error_code_array(none), none);
}
#[test]
fn short_code_returns_unknown() {
// Act