Compare commits

...
39 Commits
Author SHA1 Message Date
noahandClaude Opus 4.8 b7a77cbed8 GUI round 12 (#7): batch multi-select in the Columns and Filter menus
Both list widgets now support Excel-style batch selection so several rows can be
toggled at once.

- Filter menu value list (wxCheckListBox): was wxLB_SINGLE, so only one value
  could ever be selected. Switched to wxLB_EXTENDED -- ctrl-click, shift-click
  and rubber-band drag now select a range of values. Clicking any selected
  row's checkbox applies that new checked state to every selected row.
- Columns menu list (wxListCtrl): already multi-select for the drag-reorder, but
  a checkbox toggle only affected the clicked row. A toggle on a row that is part
  of a multi-row selection now applies to every selected row, so several columns
  can be shown/hidden together. Re-entrancy guarded (CheckItem re-fires the
  event).

Verified under Xvfb by driving the real dialogs: ctrl-click selects several
columns and one checkbox click toggles them together; shift-click selects a
range of filter values and one checkbox click toggles them together. Headless
self-test still passes. wx-rs patch 0003 regenerated to match the edited bridge.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 23:38:57 -06:00
noahandClaude Opus 4.8 606ae85781 GUI round 12 (#2): keep KPI units visible when the window shrinks
The two wide KPI cards (SHA-256 Hashrate, Est. power) carry a units-bearing
value like "685 TH" / "21.3 kW". When the window was narrowed the row squeezed
these cards below the width their value needs, clipping the trailing unit so it
read as "21.3" with no "kW". Two fixes:

- A nested wxPanel does not re-run its own sizer when its parent resizes it, so
  each card's value/label centring kept whatever slot width it had at the
  previous window size. on_resize now re-lays-out every card on each size event,
  so the value stays centred and gets its full best-size width allocation.
- Raise the wide-card minimum width (150 -> 176) to fit a ~20px icon + a value
  up to "118.0 PH" + the card's side inset, and derive the collapse threshold
  from the real per-card minimums. The wide cards now either show their full
  units or drop out of the row cleanly -- they never render a clipped value.

Verified under Xvfb: at 1050px all seven cards show "685 TH" / "21.3 kW" in
full; at 960px the two wide cards collapse and the five count cards fill the
row. Headless self-test still passes.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 23:29:36 -06:00
noahandClaude Opus 4.8 ad9b0dc868 GUI round 12 (batch 1): black hashrate value, Control Board label, blank placeholder serials, sensible WhatsMiner temps
- #1: the total-hashrate KPI value renders in the default (black) text colour
  instead of accent blue (and now dims with focus like the other neutral cards).
- #4: the board-code column header is now "Control Board".
- #5 (serial): placeholder serials ("N/A", "none", "null", ...) render as an
  empty cell instead of the literal placeholder.
- #3: the Chip-temp cell now prefers each board's board/PCB temperature over the
  hottest-chip (outlet) reading. WhatsMiner's outlet_chip is the max chip temp
  (verified live: ~100C on the hottest board of a M30S+ VE40) which read
  alarmingly high and didn't match the ~60-79C the miner itself reports; the
  board temperature is the figure the miner's UI shows. Falls back to the chip
  temp when no board temp is reported. Applies to all makes for consistency.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 23:02:39 -06:00
noahandClaude Opus 4.8 aaf049bbfc GUI round 11: use the exact potraced beehive for the Hashrate KPI icon
Replaced the hand-traced beehive with an exact potrace of the operator-supplied
beehive.png (parent miner-firmware folder): potrace -s on the flattened bilevel
bitmap, then the black fill rewritten to currentColor so it recolours to the
Hashrate accent. Renders correctly via wxBitmapBundle::FromSVG (nanosvg).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 22:26:02 -06:00
noahandClaude Opus 4.8 8b7b0c70b4 GUI round 11: hand-traced beehive KPI icon (Hashrate)
Replaced the placeholder skep with a beehive matching the operator's reference
(branch + hook on top, stacked pill bands, centre entrance), as an outline SVG
using stroke="currentColor" so it recolours to the Hashrate accent. Hand-traced
because a chat-pasted raster can't be reached as a file for potrace; if the
source raster is saved to disk later, it can be image-traced for an exact match.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 22:14:12 -06:00
noahandClaude Opus 4.8 3ae80efdde GUI round 11: KPI icons match their card text colour + recolour SVGs without a fill
- Each KPI icon now uses its card's value colour (dropped the amber special-case),
  so the otter matches the Paused text colour and the lightning bolt matches the
  Est-power text colour, etc.
- svg_recolored also injects a root fill: some Font Awesome exports (e.g. the Free
  otter) omit fill entirely and default to black, so replacing currentColor alone
  left them black. Now shapes without their own fill inherit the card colour.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 20:53:28 -06:00
noahandClaude Opus 4.8 7901d82c4b GUI round 11 follow-ups: equal-height zebra, backdrop dimming, SVG KPI icons, boards sort
- Zebra stripe heights: the cell rect wx hands a custom renderer is shrunk to the
  content size in BOTH dimensions, so shape cells (dots) and text cells filled
  different-height bands -> unequal stripes across columns. SegmentRenderer now
  fills an over-sized rect (full column width + well beyond the row vertically);
  the cell DC clips it to the real cell, giving uniform full-row stripes. Verified
  in a screenshot.
- Focus dimming: the treeview's own state flags don't carry GTK_STATE_FLAG_BACKDROP
  (that lives on the toplevel), so uncoloured segments (combined-cell slashes,
  target hashrate, "Stock") never dimmed. ThemedTextColour now reads the toplevel
  window's active state (gtk_window_is_active) and forces BACKDROP onto the
  style-context state when inactive, so those segments take the same dimmed themed
  colour the native columns do.
- KPI icons: replaced the hand-drawn vectors with operator-supplied Font Awesome
  Pro SVGs (rabbit=hashing, turtle=slow, cracked wine glass=not hashing,
  otter=paused) plus matching in-repo bolt (power) and hive (hashrate) SVGs. New
  wxbr_svg_icon renders an SVG via wxBitmapBundle::FromSVG; the GUI recolours
  each icon's currentColor to the card's colour and sizes it to the SVG aspect
  ratio. Removed the old wxbr_kpi_icon path.
- Boards column sort: it sorted by total board count (all ~3, so no visible
  order). It now sorts by the number of ONLINE (green) boards, total count as a
  tiebreaker, so units with dead/missing boards surface.

wx-rs bridge/Rust changes mirrored into patches 0002 (widgets.rs) and 0003
(widgets_bridge.cpp) per ADR 0003.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 11:55:39 -06:00
noahandClaude Opus 4.8 8f7aab3f80 GUI round 11 (live-miner items #5/#6b/#8/#11): control-board scan gaps, VNish partner build, CVITek PIC bus
All root-caused and fixed against the live fleet (read-only scans; no device
state changed). asic-rs changes go through the vendored tree + thirdparty/asic-rs
patch queue (0003-0005) with refreshed checksums, per ADR 0003.

#5 (XIL/CVITek + WhatsMiner blank control board):
- VNish reports the board in short form in /api/v1/info "platform": "cv"
  (CVITek), "xil" (Xilinx), "aml" (AMLogic); AntMinerControlBoard::parse matched
  only the full names, so CVITek/Xilinx boards were blank. Added CV/XIL.
- Old M30S firmware (< 2022.7.29 -> v1 backend) omits summary's "CB Platform"
  and v1's parse mandatorily stripped an "ALLWINNER_" prefix. Added get_version
  /Msg/platform as a fallback source and made the strip optional.
- Verified live: S19k Pro cv->CVITek, S19 xil->Xilinx, M30S+ VE40->H6OS.

#6b/#11 (VNish partner / shared-devfee build):
- The partner build shows as /api/v1/info "build_name" ("WildRose",
  "vnishreturn"). The VNish backend (v1_2_0 + v1_3_0) now reads /build_name and
  combines it with the /fw_version number, so firmware_version reads e.g.
  "WildRose 1.2.7". Verified live on S19j Pro / S19k Pro.

#8 (hashboard PIC detection):
- pic_probe tried i2c-1/i2c-0 for CVITek, but a live VNish CVITek S19k Pro
  exposes the hashboard MCU on i2c-3 (i2cdump 0x48 = period-8 -> PIC). Broadened
  bus_candidates (cvi->[3,4,1,0], aml->[1,3,4,0], bb->[0,1,3,4], else->[1,0,3,4]);
  probe_pic stops at the first bus that classifies. The classify logic was
  already correct + unit-tested; only the bus map was wrong.

The GUI picks up #5/#6b automatically through asic-rs (CPU/Board columns now
populate for VNish CVITek/Xilinx and old M30S; FW Version shows the partner
build); #8 is fixed in the GUI's own pic_probe. The miner_probe diagnostic's
local-only mutation modes are left uncommitted as before.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 09:07:57 -06:00
noahandClaude Opus 4.8 e593548746 GUI round 11 (#4): drag-reorder + multi-select columns dialog (no up/down buttons)
Replaces the columns dialog's wxRearrangeCtrl (checkboxes + up/down buttons)
with a wxListCtrl-based list (new wxbr_reorder_list / Widget::reorder_list):
- No up/down buttons; rows are reordered by dragging.
- Native multi-select: Shift/Ctrl-click and rubber-band drag.
- Keeps per-row checkboxes for show/hide; same [idx | !idx] order encoding, so
  apply_columns is unchanged.

Drag-reorder is implemented by recording the selected rows' base indices on
wxEVT_LIST_BEGIN_DRAG and moving that group to the row under the cursor on the
following mouse-up (no real DnD loop is started, so the mouse-up still arrives).

Verified: the dialog opens without crashing and renders the checkable, button-
free list (headless click test). The drag and shift/ctrl multi-select
interactions are not headlessly simulatable and need interactive confirmation.

Bridge + Rust mirrored into patches 0002 (widgets.rs) and 0003
(widgets_bridge.cpp) per ADR 0003.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 18:03:47 -06:00
noahandClaude Opus 4.8 2fd433c3b0 GUI round 11 (#15): drawn icons on the KPI cards
Each KPI card's value now leads with a small vector icon drawn into a
transparent bitmap via wxGraphicsContext (new wxbr_kpi_icon -> Widget::kpi_icon):
rabbit = Hashing, turtle = Slow, broken wine glass = Not hashing, otter =
Paused, hive = SHA-256 Hashrate, lightning bolt = Est. power; Total has none.
The icon takes the card's value colour (amber on the neutral Est. power card so
the bolt reads).

The icons are simple flat silhouettes so they render at ~22px without external
assets (no emoji/pictographs in source). The rabbit, turtle, wine glass, hive,
and lightning read clearly; the otter is the least distinct at this size.

Bridge + Rust mirrored into patches 0002 (widgets.rs) and 0003
(widgets_bridge.cpp) per ADR 0003. Self-test passes.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 17:51:09 -06:00
noahandClaude Opus 4.8 5399f9fc49 GUI round 11: fix headless self-test after Status dropped from default columns
Round 11 #12 removed the Status column from the default view, but the runtime
self-test (CI's "Headless UI self-test", separate from cargo test) read each
miner's status from the displayed Status cell -- now absent -- so three status
spot-checks failed and the self-test binary exited non-zero, failing CI. Status
is a model property, so the checks now read it straight from the row
(status_of(row) = rows[view_idx[row]].status()) instead of a displayed cell.
Self-test passes (exit 0).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 17:42:53 -06:00
noahandClaude Opus 4.8 6b4961d7bc GUI round 11 (#2): collapse the two wide KPI cards when the window is too narrow
When the window is narrowed past the width needed to fit all seven KPI cards at
their minimum size, the two wide cards (SHA-256 Hashrate, Est. power) are hidden
so the five miner-count cards fill the row; they return when there is room again.
The five count cards still floor the window's minimum width (unchanged).

Adds a resize event to the wx-rs bridge (WxEV_SIZE -> WxEventKind::Sized, p1 =
client width) and a wxbr_sizer_show helper to hide/restore a sizer child and
reclaim its space. The main panel binds it; App::on_resize toggles the two cards
on a state change only (no per-drag relayout thrash). Bridge + Rust changes
mirrored into patches 0002 (widgets.rs) and 0003 (widgets_bridge.cpp) per
ADR 0003.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 17:39:56 -06:00
noahandClaude Opus 4.8 fc7c665166 GUI round 11 (#9): option to hide columns with no scanned values
The Columns dialog gains a "Hide columns with no scanned values" checkbox. When
on, columns whose cell is blank for every current row are hidden from the table.
It is non-destructive: the hiding is applied at table-build time via a new
App::table_columns() (used by every table-path caller in place of
view.display_columns()), so clearing the option restores the columns and the
underlying column order/visibility is never mutated. IP is never hidden, and
nothing is hidden before the first scan (no rows -> nothing empty).

Note: while the option is hiding columns, drag-reorder of the header is a no-op
(the reorder validates against the full visible set); turn the option off to
reorder.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 17:32:20 -06:00
noahandClaude Opus 4.8 ae437c0d24 GUI round 11 (batch 1): default columns, control-board split cleanup, Stock/Env fixes, relative sort, consistent zebra + focus-dimming, hashboard/light dots, access icon
Table/model (Rust):
- #12: default columns are now IP, Model, Errors, Hashrate, Power, Chip temp,
  Firmware, CPU, Boards, Access, in that display order (initial ViewState and the
  built-in "Default" preset both updated).
- #14: removed the Control board column (CPU + Board replace it); the underlying
  control-board string stays on MinerRow for the SSH PIC probe.
- #6 (part 1): firmware family strips the vendor word asic-rs prepends on stock
  firmware ("AntMiner Stock" -> "Stock"), moving it into FW Version.
- #17: air-cooled miners' ambient reading routes to a new "Env temp" column
  instead of "Fluid temp" (asic-rs reports ambient in its fluid field and has no
  cooling-type flag; cooling type is inferred from the model name).
- #16: relative-hashrate (actual/expected) sort -- the Hashrate header cycles
  absolute-asc/desc then relative-asc/desc, with right-click menu entries;
  HashrateRel is a sort-only pseudo-column.

Rendering (wx-rs SegmentRenderer bridge, mirrored to patches/0003 per ADR 0003):
- #3: the per-row zebra background now fills the whole column-wide cell (wx
  shrinks a custom renderer's rect to the content size, so the earlier fill
  covered only the text; Render now fills GetOwner()->GetWidth() and wxGTK clips
  it to the cell).
- #1/#7: uncoloured segments (combined-cell slashes, "Stock" firmware) take the
  tree widget's themed text colour at its live GTK state, so they dim on
  window-backdrop like the native cells.
- #10: the Boards column renders per-hashboard status dots (green hashing / red
  faulted / grey undetected, board 1 rightmost); the Light column renders a
  yellow locate dot while flashing.
- #13: the Access column renders a padlock icon (green open = writable, red
  closed = view-only) instead of "locked"/"unlocked" text.

Shapes draw from control-char sentinels (never emoji/pictographs), font-
independent. Self-test verifies the icon columns structurally. 82 unit tests
pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 17:24:09 -06:00
noahandClaude Opus 4.8 b343746718 GUI round 10 (batch 2): consistent zebra on custom columns + neutral KPIs dim with focus
R10.1 (zebra consistency): wxGTK does not paint a custom renderer's cell
background, so the per-row zebra colour set via GetAttrByRow appeared on the
native columns but not on the SegmentRenderer columns (Hashrate, Chip temp,
Firmware, ...), making the striping look inconsistent. SegmentRenderer::Render
now paints the row's GetAttr() background itself (skipping selected rows, which
the control already highlights) so every column stripes identically.

R10.2 (focus dimming): the Total-miners and Est-power KPI cards and the plain
segments in combined cells forced an explicit foreground colour, so they did
not dim when the window lost focus like the rest of the dashboard. mk_card and
repaint_theme now leave ColorKind::Neutral cards on the default text colour, and
SegmentRenderer draws an uncoloured segment with the DC's current text
foreground (falling back to wxSYS_COLOUR_WINDOWTEXT) instead of a hardcoded
system colour.

The widgets_bridge.cpp edit is mirrored into the wx-rs patch queue
(patches/0003-widget-bridge-cpp.patch) per ADR 0003.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 15:44:48 -06:00
noahandClaude Opus 4.8 aa75031112 GUI round 10 (batch 1): firmware family colour + FW Version, CPU/Board split, per-board chip temp, error count
#3 Firmware column now shows the firmware FAMILY, coloured (Stock=default,
VNish=green, Braiins=purple, LuxOS=gold, BixBit=pink, ePIC=light-blue,
Hive=orange, Alkane=navy -- Alkane wired for our future scannable firmware);
the version moves to a new "FW Version" column.

#4 Control board split into a "CPU" column (AML/CVI/BBB/XIL, WhatsMiner
H3/H6/H616) and a "Board" column (C76/C88/CBE/C49/C55, CB2/CB4/CB6). Fixed the
AMLogic 140mm heuristic so S21 Pro -> CBE (was C76). The combined ControlBoard
column stays available (hidden).

#5 "Worker" now shows just the rig name; a new "Pool account" column holds the
account (pool username "account.rig" split on the first dot).

#6 Chip temp shows per-hashboard temps as integers ("77 / 64 / 74"), each
coloured on the blue-to-red scale, falling back to the integer average.

#7 Errors column shows just the count (a number, even for one; no "errors"
word); the hover tooltip lists the messages, now concise -- Info dropped, the
repetitive "[Error]"/"[Warning]" prefixes stripped, and duplicates collapsed.

Default profile updated to show Firmware/FW Version/CPU/Board/Errors. 80 offline
tests pass; headless self-test PASS; screenshot-verified the colours, splits,
per-board temps and error counts in the offline demo.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 15:32:38 -06:00
noahandClaude Opus 4.8 8eb9a2caad GUI round 10 (#8): Z15/Z15J Equihash hashrate shows the correct SI prefix (k, not T)
Root-caused and verified against the live fleet. An Antminer Z15 shows its
hashrate as e.g. "288T" when it is really ~288 kSol/s ("288k"). Equihash miners
report a Sol/s rate in the cgminer "GHS" key, but asic-rs AntMiner parse_hashrate
takes the unit from the key name ("GHS" -> GigaHash), scaling the value 1e9x too
large. The value is a raw Sol/s count, so for Equihash use the base Hash unit;
the toolkit`s SI-prefixing then yields "288k".

Matched by algorithm, and by "Z15" model name for the Z15J (which asic-rs leaves
algo Unknown). Fixed in both the v2020 and v2023_07 AntMiner backends, via
asic-rs patch queue 0002. Verified live: Z15 288T -> ~288k, Z15J 138T -> ~110k.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 15:18:12 -06:00
noahandClaude Opus 4.8 9e2b453eb5 GUI round 9 (#4 v2): WhatsMiner v2 power-limit now reports success on the apply-restart
Follow-up to 3530d67a. Verified on the live fleet that the v2 (firmware
< 2024-11-01) "adjust_power_limit" command DOES apply the new watt limit --
confirmed the set value settles via the read-only :4028 "Power Limit" after the
miner restarts to re-tune. But the restart drops the connection mid-command, so
the read times out; the code then reported that as a failure even though it
applied.

Both v2 and v3 set_power_limit now treat a transient RPC error after the command
(is_expected_write_error -- read timeout / connection reset, the helper the
pause/resume paths already use) as success. A genuine rejection is a
StatusCheckFailed and still errors. v1 miners keep the "not supported" bail.

Verified: v2 M30S+ (fw 20240930) set 3500 -> :4028 settles to 3500, restore 3600
-> settles to 3600 and the miner resumes hashing.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 15:01:42 -06:00
noahandClaude Opus 4.8 3530d67a5c GUI round 9 (#4): fix WhatsMiner power-limit (v3 auth/param) + asic-rs patch queue
Round-9 #4 -- "the power-limit on the WhatsMiners doesn't apply properly" --
root-caused and verified against the live fleet, then fixed in vendored asic-rs
via a new patch queue (ADR 0003).

Root cause: asic-rs routes a WhatsMiner to its v3 (WhatsMinerOS) backend when
the firmware date is >= 2024-11-01. The v3 privileged power-limit write
(command "set.miner.power_limit" on port 4433) authenticated against account
"super" but hashed the token with the WEB/admin password, and sent the watt
value as a float -- so the miner rejected every write with "invalid json or
password is wrong". asic-rs then swallowed that (Ok(data.is_ok()) -> Ok(false))
so the GUI showed "refused" with no reason. (Older miners, fw < 2024-11-01, use
the v2 "adjust_power_limit" path, which restarts the miner on a change -- see
below.)

Fix (thirdparty/asic-rs/patches/0001):
- v3 set_auth: the "super" account's token password is a SEPARATE v3 credential
  (factory default "super"), NOT the web/admin password carried by `auth`; use
  "super". The web password still drives the v2 (admin) path.
- v3 set_power_limit: send the watts as a bare integer (a float trips the
  firmware's "invalid json" parser).
- v2 + v3: propagate the RPC error with `?` instead of swallowing it to
  Ok(false), so a real failure reaches the round-9 bottom-right error indicator
  with the miner's own message.

Verified on a live M30S+ (fw 20241108, api 3.0.1) via a read-only 4028
capture/restore harness: the fixed request returns {"code":0,"msg":"ok"};
asic-rs set_power_limit now returns Ok(true) and the miner applies the limit
(it restarts to re-tune, ~10 min ramp -- expected WhatsMiner behaviour). Matches
the pyasic and HashSource whatsminer-api-3 references. All test miners were
returned to their prior configured limit.

asic-rs patch-queue mechanism (ADR 0003 updated): asic-rs is cargo-vendored, so
in-place edits are documented as a numbered patch under thirdparty/asic-rs/
plus a checksum-refresh helper and scripts/apply-asic-rs-patches.sh for
re-vendoring. The committed vendor/ tree has the patch applied and its
.cargo-checksum.json refreshed, so builds need nothing extra (CI builds fresh;
a note documents the local `cargo clean -p` cargo-caching gotcha).

Known follow-up: the v2 backend (fw < 2024-11-01) reaches the miner via
"adjust_power_limit" but a changed value restarts the miner and the in-restart
status check reports failure; whether it applies correctly needs its own
verification. The error-propagation change surfaces that honestly meanwhile.

Compile-checked (release + tests); 79 offline tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 14:10:05 -06:00
noahandClaude Opus 4.8 3ac4e104a0 GUI round 9 (#3): mask power-limit on VNish; naming passthrough fix; live-scan probe tool
#3 (power-limit shown where it shouldn't be): asic-rs advertises
supports_set_power_limit = true unconditionally for whole firmware families,
VNish included. Per operator guidance -- VNish Antminers should not expose the
power-limit control, while Braiins keeps it -- mask the capability for VNish
firmware in to_row; every other backend keeps asic-rs's answer. Verified
against the live fleet (all VNish Antminers report true; Antminer stock Z15 /
S21Pro already report false).

#11 follow-up: asic-rs Unknown-model passthroughs carry the raw vendor string
with the brand still in it (seen live: a NoPIC S19 as "ANTMINER S19 (88)").
Drop a redundant leading brand word in clean_antminer so the Model column
never repeats the Brand column: "ANTMINER S19 (88)" -> "S19 (88)".

New read-only diagnostic: crates/alkane-gui/src/bin/miner_probe.rs -- a
standalone asic-rs CLI (`miner_probe scan <cidr>...`) that reuses the GUI's
MinerFactory + saved-credential setup to inventory a range (ip/make/firmware/
model/control-board/watts/supports_power_limit/supports_tuning) without going
through the wx event loop. Used to validate the round-9 naming + capability
work against real hardware; kept as a hardware-check tool. It performs no
mutations (asic-rs exposes no power-limit read-back, so exact restore-to-prior
cannot be guaranteed from it alone).

naming unit tests + headless self-test PASS; 80 offline tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 12:05:37 -06:00
noahandClaude Opus 4.8 3c99934513 GUI round 9 (#11): device-naming cleanup -- Brand/Submodel columns, clean model names, control-board short codes
asic-rs hands us compact Rust-identifier model strings ("S19KPro",
"M30SPlusVE40") and bare control-board family names ("Xilinx", "AMLogic",
"BeagleBoneBlack", WhatsMiner "H3"/"H6"/"H6OS"/"H616"). This adds a pure
display-layer transform (new crate::naming) that turns those into the
human-facing identity the table shows -- no asic-rs edit, so it stays a
build-on-top layer over the vendored crate.

- Model column now shows the cleaned name: brand dropped, family-letter
  suffix lowercased, word suffixes spaced, "+"/"++" for Plus/PlusPlus, and
  (WhatsMiner) the trailing version block moved out. "S19KPro" -> "S19k Pro",
  "S21Pro" -> "S21 Pro", "M30SPlusVE40" -> "M30S+".
- New Brand column ("Antminer"/"WhatsMiner"/...) and Submodel column
  (WhatsMiner version block, e.g. "VE40"; blank for Antminer -- its hashboard
  type is not reported over the network). Both hidden by default; available
  via the Columns menu and filterable.
- Control-board column now shows the Bitmain short code: BeagleBoneBlack ->
  "BBB (C77)", CVITek -> "CVI (C88)", Xilinx -> "XIL (C49)" (S17-era) /
  "XIL (C55)" (S19-era), AMLogic -> "AML (C76)" (120mm) / "AML (CBE)"
  (140mm); WhatsMiner H3 -> "H3 (CB2)", H6 -> "H6 (CB4)", H6OS ->
  "H6os (CB4)", H616 -> "H616 (CB6)". Xilinx/CVITek/AMLogic/BeagleBone are
  already detected by asic-rs, so no crate extension was needed.

Heuristics (asic-rs reports only the board family, never the exact board
number): the AMLogic 120mm-vs-140mm (C76/CBE) and Xilinx S17-vs-S19-era
(C49/C55) splits are inferred from the model family. These are documented in
crate::naming and are the one place a live-hardware correction may be needed.

ALL_COLUMNS is now 41. Fixtures refactored to carry asic-rs-style
make/model_id/board so they exercise the real transform. naming has unit
tests for the model/submodel/brand/control-board rules; the headless
self-test gained 32 checks (brand/model/submodel/control-board per fixture),
all PASS. 79 offline tests pass; screenshot-verified the cleaned Model and
control-board codes in the default view.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 11:29:15 -06:00
noahandClaude Opus 4.8 9b5d811b1e GUI round 9 (batch 2): KPI box layout, bottom-right error indicator, algorithm filter + hashrate cycling
Round-9 UI items #5, #6, #7 and the #9 algorithm-cycle follow-on.

#6 KPI boxes: switch the header from a wrap sizer to a horizontal box
sizer with every card at proportion 1 + EXPAND, so the cards are always
equal width and grow to span the full window; a per-card min size
(116x62) floors them at their largest content. Fix the filter-alignment
drift by re-running each card's sizer in refresh_kpis after set_label
(the centring spacers now recompute around the new value width). The
active-filter highlight now paints the card panel and both its texts, so
the whole box tints instead of only the strip behind the text. Bind the
card click on the value and label static texts too (a click on the number
or caption registers the quick-filter, not just the card gap).

#5 error indicator: add a second, colour-tinted status-bar field pinned
to the bottom-right corner (wxbr_status_indicator_init/set in the widget
bridge; a wxStaticText repositioned into the right field on resize). Scan
and apply outcomes route here without overwriting the left scan-status
text: a total apply failure and a scan failure show red, a partial apply
failure amber, full success clears it; a new scan/action clears any stale
message.

#7 algorithm filter: the Filter dialog now offers every column (via a new
ViewState::filter_columns) rather than only the visible ones, so Algorithm
-- and any other hidden metric -- can be filtered without first un-hiding
its column. Filters already match on the plain model cell, independent of
visibility.

#9 hashrate cycling: compute per-algorithm hashrate totals in compute_kpis
(Kpis::hashrate_by_algo, ordered by total). The hashrate KPI card shows
the selected algorithm's total under a "<Algo> Hashrate" caption and
cycles through the running algorithms when clicked (a no-op with a single
algorithm). SHA256 renders as "SHA-256".

Bridge provenance patches 0002/0003 regenerated to match the -patched tree.
Compile-checked (release + tests); 74 offline tests pass; headless
self-test PASS; screenshot-verified equal-width cards, full-box highlight,
click-through-text, and centred values after filtering.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 11:09:50 -06:00
noahandClaude Opus 4.8 77399bdd06 GUI round 9 (batch 1): column-reorder persistence, post-action refresh, algorithm column, hashrate KPI label
- #1 Column reorder now persists (incl. after sorting a moved column). On wxGTK,
  GetColumnPosition() does not reflect a native GtkTreeView column drag, so the
  reorder was read as a no-op and the rebuild snapped columns back. dvlc_col_at_pos
  now reads the real display order from the GtkTreeView (gtk_tree_view_get_columns
  + GTKColumnToWX) on __WXGTK__, falling back to GetColumnPosition elsewhere.
- #2 A right-click config action (e.g. Flash lights) now re-probes the miners it
  targeted when it finishes, so the change shows in the table (skipped after a
  flash, since the unit is rebooting). New App.action_targets.
- #7 New Algorithm column (from asic-rs hashrate.algo: SHA256/Scrypt/Equihash/...),
  categorical so it is filterable via the value checklist.
- #9 SHA-256 Hashrate KPI: card relabelled "SHA-256 Hashrate" and the value drops
  the "/s" ("685 TH", "1.2 PH"). (Per-algorithm click-cycling deferred.)

Note on #8 (Z15 shows T not k): our formatting already derives the SI prefix from
the base value (si_mantissa), so a wrong 'T' means asic-rs reports the wrong unit
for that Equihash model -- an asic-rs backend fix that needs a live Z15 to verify.

cargo check --release --tests clean; patch 0003 regenerated + validated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 10:41:21 -06:00
noahandClaude Opus 4.8 408b7d12b4 GUI: real access/lock-state detection via credentialed digest probe
asic-rs has no lock-state signal (a wrong-password miner just silently returns
fewer fields, because the collector drops the 401). This builds the real check
ON TOP of asic-rs:

- access_probe.rs: a NON-mutating, digest-authenticated GET to a privileged
  endpoint (Antminer get_miner_conf.cgi, read-only). The HTTP status is decisive
  -- 200 = credentials authenticate (writable -> unlocked), 401/403 = rejected
  (view-only -> locked); anything else -> indeterminate. Pure classifier +
  unit tests; shells out to curl --digest (no HTTP crate) so the offline build
  is unaffected.
- Right-click "Check access (auth)" on the selected miners runs start_access_probe
  on a background thread using the saved scan (web) credentials (default root/root),
  updating write_locked in the rows as results arrive. Fake-scan mode returns
  deterministic demo results. Guarded against a flash / concurrent probe.

Replaces the previous capability-based inference for the miners the user
explicitly checks. cargo check --release --tests clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 10:32:44 -06:00
noahandClaude Opus 4.8 50cd463bee GUI fix: guard out-of-range dvlc GetItem (crash selecting rows after refresh)
Round-9 #10: selecting miners could trip
`datavcmn.cpp: assert "row < m_hash.GetCount()" failed in GetItem(): invalid
index` and crash. wxDataViewIndexListModel::GetItem() asserts on an out-of-range
row, and three bridge helpers called it with an index that can go stale when the
row set shrinks (a filter, or a scan that returns fewer rows): wxbr_dvlc_
ensure_visible (the round-8 scroll-hold, unguarded), wxbr_dvlc_select_rows and
wxbr_dvlc_select_row (only lower-bounded). All three now bound the row against
the store's item count before calling GetItem, so a stale/empty index is a
no-op instead of a crash.

Local wx-rs bridge compile clean; patch 0003 regenerated + validated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 10:29:14 -06:00
noahandClaude Opus 4.8 d73299166e GUI: real PIC detection via on-board SSH + i2c probe (right-click action)
asic-rs and the miner's network API cannot report PIC-vs-noPIC (only one legacy
SKU, ANTMINER S19J88NOPIC, carries it in the model string; the authoritative
signal lives on the control board's I2C bus). So this builds the real detector
ON TOP of asic-rs as an opt-in SSH probe, per the project wiki
(30-power-thermal-and-board-identity/hashboard-eeprom-pic.md):

- pic_probe.rs: SSH to the control board and run i2cdump -y <bus> 0x48 b, then
  discriminate by the register period -- a PIC/MCU board exposes an 8-byte
  register file that WRAPS every 8 bytes ("17 00 4b 50 7f 00 00 00 ..."), while
  a noPIC board has a 4-register LM75 temp sensor (4-byte wrap). The classifier
  is pure + unit-tested against the wiki's example dumps and is conservative
  (indeterminate -> None, never a guess). The I2C bus is chosen from the
  control-board family (AMLogic->1, BeagleBone->0, else try both). We shell out
  to ssh/sshpass (no SSH crate) so the offline/vendored build is unaffected.
- Right-click "Detect PIC (SSH)..." on the selected miners: a dialog collects
  SSH login (prefilled from a new 0600 ssh-credentials.txt, default user root),
  then start_pic_probe runs one miner at a time on a background thread (each is a
  slow SSH round trip; never part of the fast network scan) and upserts
  pic_present into the rows as results arrive. Fake-scan mode returns
  deterministic demo results. Guarded against a firmware flash / concurrent probe.

The classifier is unit-tested; the live SSH round-trip needs a reachable bench
miner with SSH + i2c-tools to verify end-to-end. cargo check --release --tests
clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 10:25:15 -06:00
noahandClaude Opus 4.8 a81fef3c7d GUI round 8: Errors column hover tooltip (full message list)
Item 12 (tooltip half): hovering an Errors cell now shows the full list of the
miner's error/event messages ("[Severity] text (component)", most severe first)
as a tooltip; the cell itself keeps the compact red summary.

wxDataViewCtrl has no per-cell tooltip API, and wx mouse-motion events are not
delivered to wx handlers on the native GTK control, so this uses GtkTreeView's
native "query-tooltip" signal directly (guarded by __WXGTK__): a per-cell
tooltip map (row, model column) -> text on the AttrListStore, populated from
Rust via a new dvlc_set_cell_tooltip bridge fn, and looked up by the signal
handler using dv->GTKColumnToWX(gcol)->GetModelColumn(). The map is populated on
every platform (a no-op where nothing reads it) so the non-GTK platform round
can wire its own tooltip surface later.

Local wx-rs bridge compile + full cargo check clean; patches 0002/0003
regenerated + validated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 17:37:18 -06:00
noahandClaude Opus 4.8 365732b5d4 GUI round 8b.2 fix: rubber-band drag-select uses native GtkTreeView on GTK
The wx-mouse-event rubber-band approach (LEFT_DOWN/MOTION/LEFT_UP) does not work
on the native GTK wxDataViewCtrl: the underlying GtkTreeView grabs the pointer
during a button drag, so wx never delivers the MOTION events, and only the
initial click row was selected (verified against the shipped binary).

Fix: on GTK, enable the GtkTreeView's own native rubber-band selection via
dv->GtkGetTreeView() + gtk_tree_view_set_rubber_banding(TRUE), guarded by
__WXGTK__ (gtk/gtk.h included only there). The wx-mouse-event approach is kept
as the non-GTK fallback for the future Windows/macOS builds, where it will be
verified in the platform round. The column-header right-click menu (native wx
dataview event) already worked and is unchanged.

Local wx-rs bridge compile clean; patch 0003 regenerated + validated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 17:27:16 -06:00
noahandClaude Opus 4.8 98603077e3 GUI round 8: view presets (save/load column arrangement, filters, sort)
Item 11: a "Presets" button (top-right) opens a dialog to save the current
table view -- column arrangement + visibility, sort, and all active filters --
as a named profile, load a saved one, or delete it. The built-in "Default"
profile is always the first preset and shows IP, Model, Hashrate, Power, Chip
temp, Firmware, Control board, PIC and Status; the app now boots with it.

- New presets.rs: a serde-serialized PresetView snapshot of ViewState (Vec-based
  so the JSON has no enum map keys), Preset { name, view }, and load/save to
  ~/.config/alkane-toolkit/presets.json. "Default" is re-seeded on load and not
  written, so it can't be lost or deleted. A loaded preset missing newer columns
  still covers every column (they're appended hidden).
- serde/serde_json added to alkane-gui (already vendored + locked via asic-rs);
  Column/ColFilter/TextOp/NumOp derive Serialize/Deserialize and ViewState is
  now Clone.
- ui.rs: build_presets_dialog + apply_preset_load/save/delete, wired to the new
  Presets button.

Unit tests: default-preset round-trips through ViewState and JSON.
cargo check --release --tests is clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 17:21:49 -06:00
noahandClaude Opus 4.8 bc9f847689 GUI round 8b.2: column-header menu + rubber-band drag-select
Bridge + UI (local wx-rs bridge compile + full cargo check clean).

- Column-header right-click menu (#5): right-clicking a column header opens an
  Excel-style menu -- Sort ascending / descending, Auto-size this column, Hide
  <column> (not offered for the fixed IP column), and Columns... (the full
  show/hide picker). New wx event WxEV_DVLC_HEADER_RIGHT_CLICK bound from the
  native wxEVT_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK, plus a wxbr_dvlc_autosize_col
  bridge fn (wxCOL_WIDTH_AUTOSIZE). (Sticky/frozen columns are the separate 8c
  dual-control piece.)
- Rubber-band (click-drag) range selection (#10): wxDataViewCtrl has no native
  drag-to-extend selection (only ctrl/shift-click), so it is tracked in the
  bridge -- LEFT_DOWN records the anchor row (and lets the native handler select
  it), dragging with the button down selects the inclusive row range under the
  cursor, LEFT_UP clears the anchor; modifier-clicks are left to the native
  multi-select. Reuses the existing Select/UnselectAll primitives and emits
  SELECTION_CHANGED so the model's selected-IP set stays in sync.
- KPI cards widened to 150px so "685 TH/s" / "21.3 kW" are no longer clipped.

wx-rs patches 0002/0003 regenerated + round-trip validated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 17:13:27 -06:00
noahandClaude Opus 4.8 71cdf2d988 GUI round 8b.1: scroll-hold, zebra striping + vertical gridlines, default-colour text
Bridge + rendering rework (validated with a local wx-rs bridge compile + full
cargo check; CI is the build oracle).

- Scroll position hold (#2): the table no longer jumps to the top as new rows
  stream in during a scan. fill_rows captures the top visible row before the
  clear+refill and restores it after (new wx-rs bridge fns dvlc_get_top_row /
  dvlc_ensure_visible, wrapping wxDataViewCtrl::GetTopItem / EnsureVisible).
- Default-colour text (#3b): rows are no longer tinted wholesale by status. Every
  cell is now the default text colour (black in light mode, white in dark -- the
  SegmentRenderer falls back to wxSYS_COLOUR_WINDOWTEXT for any run with no
  explicit colour), so IP addresses, slashes, expected/target values and all
  non-conditional cells read in the default colour. Only the conditionally-
  formatted columns carry colour: Hashrate/Boards/Chips actual (ratio scale),
  Chip temp (blue-red), fans (grey-blue), Access (red/green), Errors (red), and
  the Status column keeps its own status colour on its own cell.
- Zebra striping (#8): odd rows get a subtle theme-aware background via the
  AttrListStore (a per-row BACKGROUND attr, so it does not disturb the
  default-foreground fallback and the native selection highlight still shows
  through). This replaces the status row-tint as the row separator. (The earlier
  abandoned attempt used SetAlternateRowColour / GTK CSS against the status
  foreground tint; removing that tint is what makes the background approach
  clean now.)
- Vertical gridlines (#8): wxDV_VERT_RULES added to the table style (row lines
  were already on), so columns have borders.
- KPI cards: wxWrapSizer now drops wxEXTEND_LAST_ON_EACH_LINE, so the last card
  on a line is no longer stretched -- the uniform-size KPI boxes stay uniform.

wx-rs patches 0002/0003 regenerated and round-trip-validated against the source.
cargo check --release --tests is clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 16:55:27 -06:00
noahandClaude Opus 4.8 4fea3becf6 GUI round 8a.2: PIC, Access (locked), and Errors columns
Adds the round-8 columns that asic-rs either already exposes or that we infer.
Control board type (#9) and identify-light state (#4b) were already scannable
columns; this adds the three new ones:

- PIC (#9): asic-rs does not report PIC-vs-noPIC over the network (it needs an
  on-board SSH/I2C probe -- a separate feature), so this is a best-effort
  inference from the model string ("NoPIC" variants), showing "?" when unknown.
  New MinerRow.pic_present.
- Access (#13): locked (view-only) vs unlocked (writable), inferred from whether
  the miner exposes any writable control capability (asic-rs has no direct
  lock-state field). Red = locked, green = unlocked. New MinerRow.write_locked
  and MinerCaps::any_control().
- Errors (#12): wires asic-rs's structured MinerData.messages (previously
  dropped) into MinerRow.errors as "[Severity] text (component)" lines, most
  severe first. The column shows a summary (blank / the single message / "N
  errors") in red when non-empty; the full list becomes a hover tooltip once the
  tooltip bridge support lands in 8b.

The identify-light column header is relabelled "Light" (from "Fault light") to
match the round-8 terminology. Fixtures populated with demo values so all new
columns render offline. Unit tests for the three cell renderers + any_control.

cargo check --release --tests is clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 16:37:21 -06:00
noahandClaude Opus 4.8 7781ff71d3 GUI round 8a: no phantom-offline rows, hashrate/temp conditional formatting, multi-range parse, uniform KPI cards
First slice of the round-8 batch (Linux; Windows/macOS builds deferred to a
dedicated platform round per the design discussion). Feature/format changes
with no C++ bridge dependency; the bridge-dependent items (scroll-hold, zebra +
default-colour rework, header menu, rubber-band select, tooltips, presets,
frozen columns, plus the new asic-rs columns) follow in 8b/8c.

- Offline recognition (reverses the round-6 interpretation): the scanner no
  longer fabricates a row for an address with no miner. Only miners that
  actually respond become rows; a responding non-mining miner is "not hashing".
  Removed the MinerRow.offline field, MinerRow::offline(), the "offline" status,
  and the synthetic fixture/fake-scan offline rows. The bench fleet is now 9
  rows (was 10); KPI not-hashing is 1.
- Hashrate conditional format: the scale now bottoms out at 50% (full red at
  <=50% of expected, amber at 75%, green at 100%+), matching "green = 100%,
  red = 50% or lower".
- Hashrate cell format: prefix-only unit, no space, no spaces around the slash
  (e.g. "60.0T/200T", "80.5T/95.0T") instead of "60.0 TH/s / 200 TH/s". The
  combined-cell encoder now builds from formatted parts rather than re-splitting
  a joined string on " / ", so hashrate ("/") and count columns (" / ") each
  keep their own separator.
- Chip temperature: new blue-to-red conditional scale (cool blue at/below 40 C
  to hot red at/above 90 C); the Chip temp column is now a coloured cell.
- Multi-range scan input: each octet may be a range, so "10.1-9.1.1-255" expands
  to the 9 /24s (cartesian per-octet parse). CIDR / full-range / short-range
  forms are preserved.
- KPI header: every card is now a uniform size with its value + label centred.
- Right-click menu: "Fault light on/off" relabelled to "Flash lights on/off"
  (the underlying asic-rs set_fault_light call is unchanged).

Tests updated for the new formats/counts; new unit tests for the 50%-100% ratio
scale, the blue-to-red temp scale, the parts-based combined encoder, and the
per-octet range parser. cargo check --release --tests is clean; CI runs the
release build + tests + headless self-test.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 16:26:19 -06:00
noahandClaude Opus 4.8 86e4761316 GUI round 7: code-review remediation (flash safety, unknown-actual colour, credentials, coverage)
Fixes the Critical/High findings from the round-6 review (6 parallel dimension
reviewers + adversarial verify), plus the cheap high-value non-blocking ones.
Full write-up in code-review-report.md.

Firmware-flash safety (the one irreversible, hardware-destroying action):
- Critical: re-triggering an action no longer races the previous one. A flash
  now takes an exclusive lock (new App.flashing): it will not start while any
  scan / refresh / config action is running, and none of those (nor another
  flash) start while it runs. begin_scan, start_action, start_refresh and
  apply_flash_confirm all gate on it, and the context menu offers only the
  read-only "Open in browser" while flashing. This removes the two overlapping-
  network-operation paths that could interrupt/corrupt an upload and brick a
  miner (old.stop() never joined the in-flight upload).
- High: the flash confirm dialog now lists every target IP + model and warns
  loudly when the batch spans more than one model (a single image is rarely
  valid for all), instead of showing only a bare count.

Correctness:
- High: combined columns no longer paint the "-" placeholder solid red when the
  actual is unknown but the expected is known (an idle/paused/booting miner of a
  recognised model looked like a 0% catastrophic failure). fill_rows now gates
  the ratio on the actual being known; unknown-actual falls to the plain,
  uncoloured segment. Was masked by the all-zero-expected fixtures.
- compute_kpis buckets by status() instead of re-deriving the precedence from
  raw flags (KPI header can no longer disagree with a row's status; offline
  folds into not_hashing).

Security:
- credentials file is created at 0600 up front (OpenOptions::mode) and
  re-tightened while still empty, so the plaintext password is never on disk
  under a looser mode (was create-0644 then chmod-0600).
- the "Set scan credentials" dialog no longer pre-fills the saved password in
  plaintext; a blank Password field keeps the stored one.

Robustness / API:
- the fake-scan branches of the config-action / refresh / flash background
  threads now honour the cancel flag (were ignored, so stop() was a no-op).
- MinerRow.online -> offline (default false = online), removing the footgun
  where a struct-update literal that forgot `online: true` read back offline.

Tests (the review's primary focus -- these paths had zero coverage):
- scan.rs fake_mode_background_actions: start_scan offline-row emission,
  start_refresh (Row/Failed/Done), start_firmware_flash_action, and that a
  cancelled run still terminates with Done rather than hanging.
- model.rs: flash_confirmed (exact/case/prefix/whitespace), compute_kpis vs
  status() consistency, Default-is-online.
- new ui::tests: ratio_color/fan_color/tint_toward stops+clamping+blends, and
  the combined-cell unknown-actual and cooling-cell encodings.
- credentials.rs: configured_factory smoke (both branches) + pre-existing-0644
  re-tighten.
- self-test: offline row (.199) spot-check, KPI quick-filter toggle on/off, and
  a numeric (not lexical) IP-sort assertion via model::ip_to_u32.

Deferred (non-blocking, tracked in code-review-report.md): start_* boilerplate
extraction; per-model firmware image-compatibility check; scoping saved
credentials to a chosen backend; a masked password field (needs a wx-rs
TE_PASSWORD binding); flash-specific status text; a segment-encode microbench.

Verified: cargo check --release --tests is clean; unit tests + benches + the
headless self-test run in CI (local release link is OOM-blocked on this
desktop).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 14:06:03 -06:00
noahandClaude Opus 4.8 c1234f6df7 GUI round 6 self-test fix: decode combined-column cells in spot-checks
The round-6 combined columns (Hashrate/Hashboards/TotalChips/Cooling) now
store colour-segment-encoded strings in the data view, so the headless
self-test's per-IP spot-checks read raw encoded bytes instead of plain text.
Two checks failed in CI as a result:
- S21 Pro (.149) hashrate read "B95E18<US>60.0 TH/s / 200 TH/s" (colour hex
  prefix + encoded combined text) rather than the plain value.
- S17 (.112) blank-hashrate read an encoded empty cell (invisible control
  chars), so is_empty() was false.

Fix: the spot-check `cell` closure now runs dvlc_get_cell output through
decode_segments_plain (a no-op for plain cells), and the S21 hashrate check
expects the combined "60.0 TH/s / 200 TH/s" form. The "every cell matches the
model" loop already decoded, so it was unaffected.

Verified: cargo check --release --tests is clean; the self-test itself is a
CI gate (local release link is OOM-blocked on this desktop).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 13:27:54 -06:00
noahandClaude Opus 4.8 b6afe08a5f GUI round 6: offline detection, combined columns, per-cell colours, paused status, credentials, refresh, firmware flash
Large round implemented via a research workflow (6 parallel readers) then a
file-partitioned implementation workflow (model/scan/bridge/ui/fixtures), all to
one shared contract.

Table / model:
- Offline recognition fix: the scan loop now emits a row for EVERY probed IP -
  non-responders become an "offline" row (new MinerRow.online flag +
  MinerRow::offline()), so unreachable miners show up (offline, red) instead of
  vanishing. Previously only responders got a row.
- Not-hashing rows are now RED (were grey); offline also red.
- New "paused" status (operating_state contains "pause" while not mining):
  its own blue row colour, a blue "Paused" KPI card, and a Kpis.paused count.
- Combined actual/expected columns: Hashrate, Hashboards and TotalChips fold
  their separate Expected* columns into one "actual / expected" cell; the actual
  is drawn on a smooth red->amber->green scale by ratio (100% = green), the
  expected in plain text, the slash black. num_value is carved out so a numeric
  filter never matches a row that only has an expected value.
- Fan column shows every fan's RPM as "rpm/rpm/rpm" (max 3 sig digits, SI-style),
  each fan coloured on its own grey->blue speed scale, slashes black.
- These four columns render via a new wxDataViewCustomRenderer (SegmentRenderer)
  that draws colour runs from a \x1f/\x1e-encoded value; every other column keeps
  the stock renderer and per-row status colour.

Interaction:
- KPI quick-filter: clicking the Hashing / Slow / Not hashing / Paused card
  filters the table to that status (composed with any column filters) and
  highlights the active card; clicking again clears it.
- Removed "Select all" / "Clear selection" from the right-click menu.
- Right-click "Refresh": re-polls the selected miners (asic-rs scan_miner) on a
  background thread and upserts the rows, without a full network scan.
- "Set scan credentials..." button (top-right): stores a username/password
  (~/.config/alkane-toolkit/scan-credentials.txt, 0600) that is fanned out to
  every asic-rs firmware backend via with_firmware_discovery_auth, so scans and
  all right-click actions authenticate. Applied through a new
  credentials::configured_factory() used everywhere MinerFactory::new() was.
- "Flash firmware..." (right-click): asic-rs UpgradeFirmware for the backends
  that support it (stock Antminer + EPIC; every other backend declines and is
  reported as unsupported). File picker (new wxFileDialog binding) + a typed
  "FLASH" confirmation; one miner at a time; cancel only between miners.
- Responsive layout: the KPI and controls rows use wxWrapSizer so they reflow
  when narrow; the min window size drops from 1200x720 to 640x480.

Bridge (wx-rs): SegmentRenderer + dvlc_append_colored_col, wrap_sizer,
bind_click (clickable KPI cards), file_dialog; dropped a vestigial gtk.h include.
Patches 0002/0003 regenerated + round-trip validated.

Portability note: every widget is a stock, natively-backed wxWidgets control
(ports to wxMSW/wxOSX); wxDataViewCtrl is native on Linux/macOS and wx's own
generic (still-correct) drawing on Windows.

Verified: cargo check --release --tests is clean; the release build + tests +
headless self-test run in CI. (Local release link is OOM-blocked on this
desktop; CI is the authoritative build.)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 13:09:16 -06:00
noahandClaude Opus 4.8 eb08a9ef97 GUI: per-miner capabilities + live config write path (right-click actions)
Completes the right-click config menu (round-2 item 11): the menu now offers
real actions computed from the intersection of what every selected miner
supports, and applies them to the fleet over the network.

- Capability detection: to_row probes each miner's asic-rs supports_* methods
  (fault light, restart, pause, resume, power limit, tuning) at scan time and
  stores them in MinerRow.caps -- no extra network round-trip.
- Intersection: MinerCaps::intersect_all yields the actions common to the whole
  selection; the context menu offers only those (a mixed mining + idle selection
  shows just fault light + restart; an all-mining selection shows everything).
- Write path: scan::start_config_action runs on a background thread -- it
  re-discovers each selected miner with asic-rs scan_miner(ip), applies the
  setter, and reports per-IP results that drain into the status bar (running
  progress while applying, a pass/fail summary when done). Cancellable, and a
  new action cancels any in-flight one so two never overlap. In fake-scan mode
  it simulates success so the flow is exercisable offline.
- Actions: fault light on/off, pause, resume, restart apply immediately; set
  power limit and set tuning % open a small value-prompt dialog first. Factory
  reset, change password, and firmware upgrade are deliberately not exposed in a
  casual right-click.

Adds the `measurements` dependency (already in the lock, transitive via asic-rs)
for Power::from_watts.

Review fixes (one review pass):
- Restart / pause / resume now require a confirmation dialog (naming the count)
  so a misclick can't stop a producing fleet; fault light stays instant, and
  power/tuning are confirmed by their value entry.
- The action result is held on the status bar for a few ticks so a fleet
  action's outcome (including failures) isn't clobbered by the next timer tick.
- The action loop uses a current-thread tokio runtime (it applies to one miner
  at a time; a worker pool was wasted).
- The value prompt validates before closing: a bad value keeps the dialog and
  the captured selection so it can be corrected.
- The menu's "(N)" counts use the rows-backed selection, matching what is
  actually acted on.

Verified off-screen: capability intersection (mixed vs all-mining selections),
the value-prompt and confirmation nested modals (menu -> dialog) with no crash,
the end-to-end apply flow, 46 unit tests (incl. a caps-intersection test), and
the headless self-test.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 11:05:15 -06:00
noahandClaude Opus 4.8 297e21a519 GUI round 3: Excel-style filters, status row colours, icon controls, context menu, live theme
Addresses the round-3 feedback batch:

- Right-click now works: a context menu (open selected in browser, select all,
  clear) pops up from the table. It was never wired before. (The live-config
  intersection over the selection remains a follow-up; no dead menu items.)
- Selection is readable again in both themes: the alt-row/zebra CSS hack (which
  painted row backgrounds over the native highlight, leaving white-on-white) is
  gone; the native selection highlight shows through.
- Row text is coloured by status (green = hashing, amber = slow, grey = not
  hashing), which also separates rows without fragile GTK zebra striping.
- Dark mode: KPI cards and rows follow the system theme (no more white boxes in
  dark mode); a system-colour-changed event repaints them live if the OS toggles
  light/dark while the app is open.
- Play / Pause / Stop are coloured media icons (green triangle / amber bars /
  red square) instead of text buttons.
- Filter panel redesigned Excel-style: a column dropdown at the top selects the
  column; controls adapt to its type. Text columns: a value checklist ("is any
  of") or a predicate (contains / does not contain / begins with / ends with /
  equals). Numeric columns: between / = / != / > / >= / < / <=. Filters AND
  across columns; edits held in a working copy, committed on Apply.
- Auto-rescan label shortened to "Rescan (s):" so the value field has room.

Table: replaced wxDataViewListCtrl with a raw wxDataViewCtrl + a custom
AttrListStore (per-row foreground via GetAttrByRow), which keeps in-table column
drag while enabling status row colours. New wx-rs bridge primitives: wxChoice
dropdown, coloured media buttons (drawn on a transparent bitmap via
wxGraphicsContext), a wxEVT_SYS_COLOUR_CHANGED event, destroy_children, and
call_after (deferred rebuilds). Patches 0002/0003 regenerated + round-trip
validated.

Model: ColFilter { Values, Text{op}, Num{op} } with TextOp/NumOp and
passes_filters -> ColFilter::matches; Column::num_value for numeric filtering.

Review fixes (one review pass):
- Deferred the two rebuilds that destroyed a control from inside its own event
  (filter op-dropdown change; column drag-reorder) via call_after, avoiding a
  use-after-free.
- num_value returns None for a blank-displaying value-type cell (Hashrate,
  Power, ChipTemp, ...), so "ChipTemp <= 50" no longer matches a miner with no
  temperature reading.
- Value checklist maps a checked entry back to its real value by index, so a
  literal "(blank)" value is not confused with an empty cell.

Verified off-screen: 45 unit tests, headless self-test (14 checks), and
interaction screenshots of selection, right-click, the text/numeric filter, the
comparator swap, and dark mode.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 09:19:38 -06:00
noahandClaude Opus 4.8 7fac0ce726 CI: make the headless UI self-test a hard gate
The self-test was continue-on-error while the container display path was
unproven. Run 529 confirmed it launches and passes (SELFTEST PASS) once xauth
was installed, so remove continue-on-error: a future regression that breaks GUI
init now fails the build instead of releasing silently.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-16 19:30:17 -06:00
45 changed files with 8520 additions and 467 deletions
-1
View File
@@ -75,7 +75,6 @@ jobs:
- name: Headless UI self-test
if: steps.ver.outputs.release == 'true'
continue-on-error: true
run: |
apt-get update -qq && apt-get install -y -qq --no-install-recommends \
xvfb xauth dbus-x11 fonts-dejavu-core >/dev/null
Generated
+3
View File
@@ -80,6 +80,9 @@ dependencies = [
"alkane-discovery",
"asic-rs",
"futures-util",
"measurements",
"serde",
"serde_json",
"tokio",
"wx-rs",
]
+3
View File
@@ -14,5 +14,8 @@ alkane-discovery = { path = "../alkane-discovery" }
# vendored + patched wx-rs (see vendor/wx-rs/patches/)
wx-rs = { path = "../../thirdparty/wx-rs/wx-rs-0.2.0-patched" }
asic-rs = "0.8.1"
measurements = "0.11"
tokio = { version = "1", features = ["rt"] }
futures-util = "0.3"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
+1
View File
@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 384 512"><path fill="currentColor" d="M240 8L48 296h112L128 504 336 216H224L272 8z"/></svg>

After

Width:  |  Height:  |  Size: 145 B

+1
View File
@@ -0,0 +1 @@
<svg version="1.0" xmlns="http://www.w3.org/2000/svg" width="511.104248pt" height="512.144915pt" viewBox="0 0 511.104248 512.144915" preserveAspectRatio="xMidYMid meet"><g transform="translate(-0.500000,511.997478) scale(0.100000,-0.100000)" fill="currentColor" stroke="none"><path d="M82 5103 c-52 -25 -77 -69 -77 -133 0 -41 6 -63 22 -86 49 -68 -31 -64 1237 -64 l1146 0 0 -150 0 -150 -323 0 c-292 0 -332 -2 -403 -20 -201 -52 -370 -228 -414 -432 -8 -34 -11 -94 -8 -155 5 -90 12 -119 52 -214 6 -14 -9 -17 -121 -22 -142 -7 -205 -22 -304 -73 -123 -65 -229 -192 -272 -329 -33 -106 -30 -264 7 -360 15 -38 30 -77 32 -85 4 -12 -9 -20 -49 -33 -76 -24 -163 -83 -228 -156 -160 -176 -193 -424 -86 -638 61 -123 195 -242 315 -280 40 -13 52 -21 48 -33 -2 -8 -17 -46 -32 -85 -38 -95 -41 -253 -7 -360 56 -178 206 -323 393 -380 32 -9 108 -19 182 -22 l126 -6 -25 -66 c-31 -81 -42 -233 -23 -319 45 -210 221 -387 433 -437 94 -22 1622 -22 1716 0 108 26 188 71 272 155 126 125 176 255 167 437 -5 90 -12 119 -52 214 -6 14 9 17 122 22 147 6 246 33 337 92 110 70 199 186 238 310 33 106 30 264 -7 360 -15 39 -30 77 -32 85 -4 12 9 20 49 33 211 67 377 303 377 537 0 233 -167 470 -378 537 -40 13 -52 21 -48 33 2 8 17 47 32 85 37 96 40 254 7 360 -39 122 -130 241 -240 311 -89 58 -188 85 -335 91 -113 5 -128 8 -122 22 40 95 47 124 52 214 6 119 -7 184 -55 287 -46 97 -157 210 -254 257 -117 58 -159 63 -516 63 l-323 0 0 150 0 150 618 0 617 0 210 -211 c116 -116 227 -219 247 -230 122 -63 256 59 207 187 -5 16 -60 79 -121 141 l-112 113 313 0 c346 0 360 2 404 64 31 43 31 129 0 172 -50 70 173 64 -2535 64 -2230 0 -2446 -2 -2476 -17z m3337 -918 c94 -52 141 -134 141 -244 -1 -102 -60 -192 -155 -237 l-50 -24 -795 0 -795 0 -50 24 c-61 28 -116 87 -140 149 -26 70 -17 172 21 235 31 49 104 105 158 121 18 6 363 9 821 8 l790 -2 54 -30z m649 -834 c95 -43 162 -147 162 -251 0 -66 -30 -131 -85 -187 -84 -83 -84 -83 -593 -83 l-434 0 -55 50 c-281 257 -719 257 -1005 0 l-57 -51 -453 3 c-452 3 -453 3 -500 26 -92 45 -158 151 -158 252 0 119 99 235 221 259 24 5 688 8 1474 8 l1430 -2 53 -24z m-1317 -623 c130 -64 224 -184 249 -317 5 -29 10 -98 10 -151 0 -53 -5 -122 -10 -151 -25 -133 -119 -253 -249 -317 -73 -36 -77 -37 -191 -37 -114 0 -118 1 -191 37 -125 62 -210 164 -244 293 -20 79 -20 271 0 350 39 149 147 263 300 318 38 13 74 17 151 15 93 -3 107 -6 175 -40z m-924 -235 c-16 -51 -16 -415 0 -465 l11 -38 -547 0 -548 0 -62 31 c-87 43 -138 117 -148 213 -11 110 44 211 145 263 l64 33 548 0 548 0 -11 -37z m2580 24 c60 -22 117 -72 148 -128 26 -46 30 -64 30 -129 0 -65 -4 -83 -30 -129 -31 -56 -88 -106 -148 -128 -23 -8 -187 -12 -578 -12 l-546 -1 13 68 c17 86 17 318 0 405 l-13 67 546 -1 c391 0 555 -4 578 -12z m-2349 -878 c286 -256 725 -255 1006 1 l55 51 453 -3 c452 -3 453 -3 500 -26 90 -44 158 -151 158 -247 0 -99 -69 -204 -162 -246 l-53 -24 -1455 0 -1455 0 -53 24 c-95 43 -162 147 -162 251 0 66 30 131 85 187 83 82 79 81 588 82 l439 1 56 -51z m1342 -820 c97 -43 160 -138 160 -240 0 -111 -47 -192 -141 -244 l-54 -30 -783 -3 c-518 -2 -796 1 -822 8 -59 16 -131 70 -164 122 -38 63 -47 165 -21 235 24 62 79 121 140 149 l50 24 795 0 c778 0 796 -1 840 -21z"/></g></svg>

After

Width:  |  Height:  |  Size: 3.0 KiB

+1
View File
@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640"><!--!Font Awesome Free 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--><path d="M181.5 261.1L194.4 267.5C200.3 270.5 206.8 272 213.5 272C237 272 256.1 252.9 256.1 229.4L256.1 208C256.1 172.7 227.4 144 192.1 144L128.1 144C92.8 144 64.1 172.7 64.1 208L64.1 229.4C64.1 252.9 83.2 272 106.7 272C113.3 272 119.8 270.5 125.8 267.5C135.1 262.8 142.2 259.3 147 256.9L135.1 249C130.6 246 128 241 128 235.7L128 232C128 218.7 138.7 208 152 208L168 208C181.3 208 192 218.7 192 232L192 235.7C192 241 189.3 246 184.9 249L173.1 256.9L181.5 261.1zM172.9 310.5L160 304.1L147.1 310.5C134.5 316.8 120.6 320.1 106.6 320.1C103 320.1 99.5 319.9 96 319.5L96 320.1C96 355.4 124.7 384.1 160 384.1L224 384.1C241.7 384.1 256 398.4 256 416.1C256 433.8 241.7 448.1 224 448.1L384 448.1L384 384.1C384 360.4 396.9 339.7 416 328.7C425.4 323.3 436.3 320.1 448 320.1L448 304.1C448 277.6 469.5 256.1 496 256.1C504.8 256.1 512 263.3 512 272.1L512 368.1C512 376.9 519.2 384.1 528 384.1C536.8 384.1 544 376.9 544 368.1L544 268.4C544 220.2 513.2 177.4 467.4 162.1L458.9 159.3C450.9 156.6 446.3 148.2 448.5 140C450.7 131.8 458.8 126.8 467.1 128.4L487 132.4C576 150.1 640 228.2 640 318.9L640 320L640 320C640 443.7 539.7 544 416 544L255.4 544C132 544 32 444 32 320.6L32 280.8C21.9 266.2 16 248.5 16 229.4L16 208L16 206.6C6.7 203.3 0 194.5 0 184C0 170.7 10.7 160 24 160L26.8 160C44.8 122.2 83.3 96 128 96L192 96C236.7 96 275.2 122.2 293.2 160L296 160C309.3 160 320 170.7 320 184C320 194.5 313.3 203.3 304 206.6L304 208L304 229.4C304 230.8 304 232.2 303.9 233.7C315.9 227.5 329.6 224.1 344 224.1L352 224.1C369.7 224.1 384 238.4 384 256.1C384 273.8 369.7 288.1 352 288.1L344 288.1C330.7 288.1 320 298.8 320 312.1L320 320.1L376.4 320.1C361.2 337.1 352 359.5 352 384.1L320 384.1C277.7 384.1 241.8 356.7 229 318.8C223.9 319.7 218.7 320.1 213.4 320.1C199.3 320.1 185.5 316.8 172.9 310.5zM96 192C104.8 192 112 199.2 112 208C112 216.8 104.8 224 96 224C87.2 224 80 216.8 80 208C80 199.2 87.2 192 96 192zM208 208C208 199.2 215.2 192 224 192C232.8 192 240 199.2 240 208C240 216.8 232.8 224 224 224C215.2 224 208 216.8 208 208z"/></svg>

After

Width:  |  Height:  |  Size: 2.2 KiB

@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 576 512"><!--! Font Awesome Pro 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2026 Fonticons, Inc. --><path fill="currentColor" d="M460.7 39.3l-2.2-2.1c-4.7-4.6-11.5-6.4-17.9-4.7s-11.4 6.6-13.1 13l-.8 2.9c-3.3 11.8-5.1 23.7-5.5 35.6 24.3 20.6 42.9 47.8 53.3 78.8-8.2-1.9-16.5-2.9-25-2.9-.6 0-1.1 0-1.7 0-18.4-44-56.5-77.4-103.6-89.3l-3.4-.9c-6.2-1.6-12.9-.6-18.5 2.6-10.8 6.2-15.6 19.5-11.2 31.1 14.9 39.5 44.3 71.4 81.4 89.7-3.7 6.6-6.4 14-7.6 21.8L279.7 154.9c-30.9-17.7-65.9-26.9-101.5-26.9-32.3 0-62.2 16.8-78.9 44.4-10.3-12.5-25.8-20.4-43.2-20.4-30.9 0-56 25.1-56 56s25.1 56 56 56c11.3 0 21.8-3.3 30.6-9.1 4.9 17.2 14.5 33.1 28.4 45.9L257.2 431.2C269 442 284.4 448 300.4 448L416 448c17.7 0 32-14.3 32-32s-14.3-32-32-32l-96 0 0-43.5c0-42.9-28.4-80.5-69.6-92.3l-30.8-8.8c-8.5-2.4-13.4-11.3-11-19.8s11.3-13.4 19.8-11l30.8 8.8c55 15.7 92.8 65.9 92.8 123.1l0 15.7 56-32.4 6.4-3.7 101.3 0c33.3 0 60.3-27 60.3-60.3 0-18.1-8.2-35.3-22.2-46.7l-34.6-28.2c-4.6-3.7-9.4-7.1-14.5-10 8.4-49.3-7.8-100-43.9-135.5zm-318.5 382c-14.7 9.8-18.7 29.7-8.9 44.4s29.7 18.7 44.4 8.9l46-30.7-48.6-44.5-32.9 22zM480 240a16 16 0 1 1 32 0 16 16 0 1 1 -32 0z"/></svg>

After

Width:  |  Height:  |  Size: 1.2 KiB

@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 576 512"><!--! Font Awesome Pro 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2026 Fonticons, Inc. --><path fill="currentColor" d="M384 249.2c0 21.4-17.4 38.8-38.8 38.8L70.8 288C49.4 288 32 270.6 32 249.2L32 208c0-97.2 78.8-176 176-176s176 78.8 176 176l0 41.2zM480 288c-2 0-4-.1-5.9-.3-16.3 53.3-64.3 92.7-122.1 96l0 56.2c0 22.1-17.9 40-40 40l-48 0c-22.1 0-40-17.9-40-40l0-56-32 0 0 56c0 22.1-17.9 40-40 40l-48 0c-22.1 0-40-17.9-40-40l0-56-32 0c-17.7 0-32-14.3-32-32s14.3-32 32-32l312 0c39.8 0 72-32.2 72-72l0-72c0-35.3 28.7-64 64-64 53 0 96 43 96 96l0 16c0 35.3-28.7 64-64 64l-32 0zm16-64a16 16 0 1 0 0-32 16 16 0 1 0 0 32z"/></svg>

After

Width:  |  Height:  |  Size: 761 B

@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640"><!--! Font Awesome Pro 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2026 Fonticons, Inc. --><path fill="currentColor" d="M205 64L434.9 64L439.3 82.4L475.6 234.9C478.5 247 480 259.5 480 272C480 352.2 421 418.7 344 430.2L344 560L432 560L432 608L208 608L208 560L296 560L296 430.2C219 418.6 160 352.2 160 272C160 259.5 161.5 247 164.4 234.9L200.7 82.4L205 64zM243 112L211 246C209 254.5 208 263.2 208 272C208 333.9 258.2 384 320 384C381.8 384 432 333.8 432 272C432 263.3 431 254.5 429 246L397.1 112L371.3 112L384.1 176L320.1 216L352.1 320L256.1 216L328.1 144L306.8 112L243.1 112z"/></svg>

After

Width:  |  Height:  |  Size: 721 B

+115
View File
@@ -0,0 +1,115 @@
//! Real access / lock-state detection: whether this miner accepts privileged
//! (credentialed) command writes, or is view-only.
//!
//! asic-rs has no lock-state signal (a wrong-password miner just silently
//! returns fewer fields, because the collector drops the 401). We build the real
//! check ON TOP of asic-rs: a NON-mutating, digest-authenticated GET to a
//! privileged endpoint. On Antminer every `/cgi-bin/*.cgi` requires digest auth,
//! so the HTTP status is decisive -- 200 means our credentials authenticate
//! (we can write -> unlocked), 401/403 means they are rejected (view-only ->
//! locked). We probe `get_miner_conf.cgi`, which is read-only (never the
//! mutating `set_miner_conf.cgi`).
//!
//! We shell out to `curl --digest` (already present, supports digest auth)
//! rather than add an HTTP+digest crate, so the offline/vendored build is
//! unaffected. `Some(true)` = locked, `Some(false)` = unlocked, `None` =
//! indeterminate (unreachable, or an endpoint/vendor this probe doesn't cover).
use std::process::Command;
use std::time::Duration;
/// Classify a miner's access state from an HTTP status code string (curl's
/// `%{http_code}` output). Conservative: anything other than a clear
/// authenticated/unauthorized answer is `None`.
pub fn classify_http_code(code: &str) -> Option<bool> {
match code.trim() {
"200" | "204" => Some(false), // authenticated -> unlocked/writable
"401" | "403" => Some(true), // rejected -> locked/view-only
_ => None, // 000 (no connect), 404, 5xx, ... -> unknown
}
}
/// The privileged, read-only endpoint we probe per firmware family. Antminer
/// stock/aftermarket all gate `get_miner_conf.cgi` behind digest auth.
fn endpoint(_firmware: &str) -> &'static str {
"/cgi-bin/get_miner_conf.cgi"
}
/// Probe one miner's access state over its web API with the given credentials.
/// Returns `Ok(Some(true/false))` on a decisive lock/unlock answer, `Ok(None)`
/// if reachable-but-indeterminate or a vendor this probe doesn't cover, or
/// `Err` only on a failure to run curl at all.
pub fn probe_access(ip: &str, firmware: &str, user: &str, pass: &str) -> Result<Option<bool>, String> {
let url = format!("http://{ip}{}", endpoint(firmware));
let userpass = format!("{user}:{pass}");
let mut cmd = Command::new("curl");
cmd.args([
"-s",
"-o",
"/dev/null",
"-w",
"%{http_code}",
"--digest",
"-u",
&userpass,
"--connect-timeout",
"5",
"--max-time",
"9",
&url,
]);
let out = wait_with_timeout(cmd, Duration::from_secs(12))?;
// curl prints the status code to stdout regardless of exit status (000 on a
// connection failure), so classify the code rather than the exit status.
let code = String::from_utf8_lossy(&out.stdout);
Ok(classify_http_code(&code))
}
/// Run a command with a wall-clock timeout (curl can hang past --max-time on a
/// black-holed host).
fn wait_with_timeout(mut cmd: Command, timeout: Duration) -> Result<std::process::Output, String> {
use std::io::Read;
cmd.stdout(std::process::Stdio::piped()).stderr(std::process::Stdio::piped());
let mut child = cmd.spawn().map_err(|e| format!("spawn curl: {e}"))?;
let start = std::time::Instant::now();
loop {
match child.try_wait().map_err(|e| e.to_string())? {
Some(status) => {
let mut stdout = Vec::new();
let mut stderr = Vec::new();
if let Some(mut o) = child.stdout.take() {
let _ = o.read_to_end(&mut stdout);
}
if let Some(mut e) = child.stderr.take() {
let _ = e.read_to_end(&mut stderr);
}
return Ok(std::process::Output { status, stdout, stderr });
}
None => {
if start.elapsed() >= timeout {
let _ = child.kill();
return Err("curl timed out".into());
}
std::thread::sleep(Duration::from_millis(100));
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn classify_codes() {
assert_eq!(classify_http_code("200"), Some(false), "authenticated -> unlocked");
assert_eq!(classify_http_code("204"), Some(false));
assert_eq!(classify_http_code("401"), Some(true), "unauthorized -> locked");
assert_eq!(classify_http_code("403"), Some(true));
assert_eq!(classify_http_code("000"), None, "no connection -> unknown");
assert_eq!(classify_http_code("404"), None, "endpoint absent -> unknown");
assert_eq!(classify_http_code("500"), None);
assert_eq!(classify_http_code(" 200 "), Some(false), "whitespace tolerated");
assert_eq!(classify_http_code(""), None);
}
}
+97
View File
@@ -0,0 +1,97 @@
//! miner_probe -- a read-only (by default) asic-rs diagnostic for live-hardware
//! verification of the round-9 power-limit work. It reuses the same MinerFactory
//! + saved-credential setup the GUI uses (see crate::credentials), but as a
//! standalone CLI so hardware checks don't go through the wx event loop.
//!
//! Usage:
//! miner_probe scan <cidr> [<cidr>...]
//! Scan the given subnets and print, per responder (TSV):
//! ip make firmware model_id control_board watts supports_power_limit supports_tuning
//!
//! Mutation modes (setpl) are intentionally NOT included here: asic-rs exposes
//! no read-back of a miner's configured power limit, so an exact
//! restore-to-prior-state cannot be guaranteed from this tool alone.
use asic_rs::MinerFactory;
use asic_rs::core::traits::miner::MinerAuth;
use futures_util::StreamExt;
fn load_creds() -> Option<(String, String)> {
let home = std::env::var("HOME").ok()?;
let p = std::path::PathBuf::from(home)
.join(".config/alkane-toolkit/scan-credentials.txt");
let s = std::fs::read_to_string(p).ok()?;
let mut l = s.lines();
let u = l.next()?.to_string();
let pw = l.next().unwrap_or("").to_string();
Some((u, pw))
}
fn factory() -> MinerFactory {
let mut f = MinerFactory::new();
if let Some((u, pw)) = load_creds() {
for fw in asic_rs::factory::default_firmware_registry() {
f = f.with_firmware_discovery_auth(fw.as_ref(), MinerAuth::new(u.clone(), pw.clone()));
}
eprintln!("(using saved scan credentials for discovery auth)");
} else {
eprintln!("(no saved credentials -- backends use their default auth)");
}
f
}
async fn scan(cidrs: &[String]) {
let mut f = factory();
for c in cidrs {
f = match f.with_subnet(c) {
Ok(f) => f,
Err(e) => {
eprintln!("bad subnet {c}: {e}");
return;
}
};
}
println!("ip\tmake\tfirmware\tmodel_id\tcontrol_board\twatts\tsupports_power_limit\tsupports_tuning");
let mut stream = f.scan_stream_with_ip();
let mut found = 0usize;
while let Some((ip, miner)) = stream.next().await {
if let Some(m) = miner {
let data = m.get_data().await;
let watts = data.wattage.as_ref().map(|p| p.as_watts()).unwrap_or(0.0);
let cb = data
.control_board_version
.as_ref()
.map(|c| c.to_string())
.unwrap_or_default();
println!(
"{ip}\t{}\t{}\t{}\t{}\t{watts:.0}\t{}\t{}",
data.device_info.make,
data.device_info.firmware,
data.device_info.model,
cb,
m.supports_set_power_limit(),
m.supports_set_tuning_percent(),
);
found += 1;
}
}
eprintln!("scan complete: {found} miner(s) responded");
}
fn main() {
let args: Vec<String> = std::env::args().collect();
let rt = match tokio::runtime::Builder::new_current_thread().enable_all().build() {
Ok(rt) => rt,
Err(e) => {
eprintln!("tokio runtime: {e}");
std::process::exit(2);
}
};
match args.get(1).map(String::as_str) {
Some("scan") if args.len() >= 3 => rt.block_on(scan(&args[2..])),
_ => {
eprintln!("usage: miner_probe scan <cidr> [<cidr>...]");
std::process::exit(2);
}
}
}
+158
View File
@@ -0,0 +1,158 @@
//! Optional saved miner credentials, applied to every asic-rs discovery call.
//!
//! asic-rs has no single global credential field on `MinerFactory`: auth is set
//! per firmware backend via `with_firmware_discovery_auth`. `configured_factory`
//! is the one place that fans a saved username/password out across the whole
//! firmware registry, so `scan`'s callers never have to think about it.
use std::io::Write;
use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
use asic_rs::MinerFactory;
use asic_rs::core::traits::miner::MinerAuth;
use crate::scan::config_path;
pub const CREDENTIALS_FILE: &str = "scan-credentials.txt";
/// SSH login for the control board (used by the PIC probe; distinct from the
/// web/API scan credentials above -- miners' SSH root login is usually not the
/// same account as the web digest-auth login).
pub const SSH_CREDENTIALS_FILE: &str = "ssh-credentials.txt";
/// Load a saved username/password pair from `file`, if present.
fn load_creds_file(file: &str) -> Option<(String, String)> {
let s = std::fs::read_to_string(config_path(file)).ok()?;
let mut lines = s.lines();
let user = lines.next()?.to_string();
let pass = lines.next().unwrap_or("").to_string();
Some((user, pass))
}
/// Save a username/password pair to `file`, restricting it to owner read/write
/// (credentials are plaintext on disk, so the mode matters).
fn save_creds_file(file: &str, user: &str, pass: &str) -> std::io::Result<()> {
let p = config_path(file);
if let Some(dir) = p.parent() {
std::fs::create_dir_all(dir)?;
}
// Open (and create) with mode 0600 up front so a freshly created file is
// never world/group-readable, even for the instant before the write. For a
// pre-existing file the create mode is ignored, so also tighten it to 0600
// while it is still empty (post-truncate, pre-write) -- the plaintext is
// never on disk under a looser mode.
let mut f = std::fs::OpenOptions::new()
.write(true)
.create(true)
.truncate(true)
.mode(0o600)
.open(&p)?;
f.set_permissions(std::fs::Permissions::from_mode(0o600))?;
f.write_all(format!("{user}\n{pass}\n").as_bytes())?;
Ok(())
}
fn clear_creds_file(file: &str) -> std::io::Result<()> {
match std::fs::remove_file(config_path(file)) {
Ok(()) => Ok(()),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()),
Err(e) => Err(e),
}
}
/// Load the saved miner web/API username/password, if any were saved.
pub fn load_credentials() -> Option<(String, String)> {
load_creds_file(CREDENTIALS_FILE)
}
/// Save the miner web/API username/password (0600).
pub fn save_credentials(user: &str, pass: &str) -> std::io::Result<()> {
save_creds_file(CREDENTIALS_FILE, user, pass)
}
/// Load the saved SSH username/password for the PIC probe, if any.
pub fn load_ssh_credentials() -> Option<(String, String)> {
load_creds_file(SSH_CREDENTIALS_FILE)
}
/// Save the SSH username/password for the PIC probe (0600).
pub fn save_ssh_credentials(user: &str, pass: &str) -> std::io::Result<()> {
save_creds_file(SSH_CREDENTIALS_FILE, user, pass)
}
/// Remove the saved web/API credentials, if any. Not an error if none were saved.
pub fn clear_credentials() -> std::io::Result<()> {
match clear_creds_file(CREDENTIALS_FILE) {
Ok(()) => Ok(()),
Err(e) => Err(e),
}
}
/// Build a `MinerFactory` with the saved credentials (if any) applied as
/// discovery auth for every firmware backend, so scans, refreshes, config
/// actions, and firmware flashes all authenticate against a non-default
/// login the same way. With no saved credentials this is plain `MinerFactory::new()`
/// and every backend falls back to its own default auth.
pub fn configured_factory() -> MinerFactory {
let mut factory = MinerFactory::new();
if let Some((user, pass)) = load_credentials() {
for fw in asic_rs::factory::default_firmware_registry() {
factory = factory.with_firmware_discovery_auth(fw.as_ref(), MinerAuth::new(user.clone(), pass.clone()));
}
}
factory
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn credentials_round_trip_and_file_perms() {
// config_path() reads $HOME; point it at a private temp dir. HOME is
// process-global, so this stays one test and restores HOME afterward
// (matching the pattern used by scan::tests::auto_secs_round_trip_and_defaults).
let prev = std::env::var_os("HOME");
let dir = std::env::temp_dir().join(format!("alkane-cred-test-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
std::env::set_var("HOME", &dir);
assert_eq!(load_credentials(), None, "no file -> None");
save_credentials("admin", "hunter2").unwrap();
assert_eq!(load_credentials(), Some(("admin".to_string(), "hunter2".to_string())));
let meta = std::fs::metadata(config_path(CREDENTIALS_FILE)).unwrap();
assert_eq!(meta.permissions().mode() & 0o777, 0o600, "credentials file must be 0600");
// configured_factory() must construct in both branches without panicking:
// with saved credentials (fans auth across every firmware backend) ...
let _ = configured_factory();
// A pre-existing, world-readable credentials file must be tightened to
// 0600 by save_credentials (the create-mode is ignored for an existing
// file, so the explicit set_permissions is what protects it).
let path = config_path(CREDENTIALS_FILE);
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o644)).unwrap();
save_credentials("admin2", "s3cr3t").unwrap();
let meta = std::fs::metadata(&path).unwrap();
assert_eq!(
meta.permissions().mode() & 0o777,
0o600,
"save over a pre-existing 0644 file must re-tighten to 0600"
);
assert_eq!(load_credentials(), Some(("admin2".to_string(), "s3cr3t".to_string())));
clear_credentials().unwrap();
// ... and with no saved credentials (plain MinerFactory::new()).
let _ = configured_factory();
assert_eq!(load_credentials(), None, "cleared -> None");
clear_credentials().unwrap(); // idempotent: clearing an already-clear store is not an error
match prev {
Some(v) => std::env::set_var("HOME", v),
None => std::env::remove_var("HOME"),
}
let _ = std::fs::remove_dir_all(&dir);
}
}
+147 -27
View File
@@ -2,7 +2,8 @@
//! 10.255.1.0/24 (see ../../../HANDOFF.md section 7 and the parent project's
//! [removed]). These are the reference values the workflow tests compare
//! the application's actual output against, and the rows the offline
//! `ALKANE_FAKE_SCAN` demo mode renders.
//! `ALKANE_FAKE_SCAN` demo mode renders. Only miners that respond become rows,
//! so there is no synthetic "offline" fixture.
//!
//! Hashrate/power/temp are representative per-model figures (the bench boards
//! are not always energised); the point of the fixtures is a fixed, known input
@@ -13,10 +14,16 @@
use crate::model::{is_slow, MinerRow};
/// One fixture board, pre-transform. `expected` of 0.0 means "band unknown".
/// `make`/`model_id`/`board` mirror what asic-rs actually reports (compact
/// identifiers + a bare control-board name) so the fixtures exercise the real
/// crate::naming transform, not pre-cleaned strings.
struct Board {
ip: &'static str,
model: &'static str,
make: &'static str,
model_id: &'static str,
board: &'static str,
firmware: &'static str,
fw_version: &'static str,
hashrate: f64,
expected: f64,
power: f64,
@@ -24,6 +31,10 @@ struct Board {
fan: f64,
worker: &'static str,
mining: bool,
/// True for the bench board deliberately rebucketed into the "paused"
/// status/KPI bucket (not-mining but operator-paused, distinct from a
/// unit that is simply idle/not-hashing).
paused: bool,
}
impl Board {
@@ -37,28 +48,89 @@ impl Board {
} else {
(None, None, 0.0)
};
let fan_rpms = if self.mining {
vec![self.fan, self.fan * 0.95, self.fan * 1.02]
} else {
vec![]
};
// Three per-hashboard chip temps around the average (so the offline demo
// shows the "77 / 64 / 74" per-board Chip-temp cell).
let board_temps = if self.mining && self.temp > 0.0 {
vec![self.temp + 2.0, self.temp - 3.0, self.temp + 1.0]
} else {
vec![]
};
// Air-cooled WhatsMiners report an ambient reading (asic-rs surfaces it in
// its fluid_temperature field); the scan routes it to env_temp for
// air-cooled models, so the demo mirrors that (round 11 #17).
let env_temp_c = if self.mining && self.make.eq_ignore_ascii_case("whatsminer") {
27.0
} else {
0.0
};
// Per-hashboard health dots for the Boards column (round 11 #10): mining
// units show three green dots, except two demo cases -- the slow S21 Pro
// has one faulted (red) board, and one VNish S19 has a board that wasn't
// detected (grey) -- so the offline demo exercises all three states.
use crate::model::BoardHealth::{Fault, Missing, Ok};
let board_status = if self.mining {
match self.ip {
"10.255.1.149" => vec![Ok, Fault, Ok],
"10.255.1.166" => vec![Ok, Ok, Missing],
_ => vec![Ok, Ok, Ok],
}
} else {
vec![]
};
// Firmware-flash capability is modeled on the real Bitmain/Antminer
// upgrade path (S17/S19/S21 family); WhatsMiner boards in this fleet
// don't advertise it, so both true and false show up and the
// firmware menu item is testable.
let firmware_flash = self.make.eq_ignore_ascii_case("antminer")
&& (self.model_id == "S17"
|| self.model_id.starts_with("S19")
|| self.model_id.starts_with("S21"));
// Derive the display identity through the same path the live scan uses.
let brand = crate::naming::brand(self.make);
let model = crate::naming::clean_model(self.make, self.model_id);
let submodel = crate::naming::submodel(self.make, self.model_id);
let control_board = crate::naming::control_board_code(self.make, self.board, &model);
let cpu = crate::naming::control_board_cpu(self.make, self.board, &model);
let board_code = crate::naming::control_board_board(self.make, self.board, &model);
MinerRow {
ip: self.ip.to_string(),
selected: false,
model: self.model.to_string(),
model,
brand,
submodel,
firmware: self.firmware.to_string(),
fw_version: self.fw_version.to_string(),
cpu,
board_code,
hashrate_ths: self.hashrate,
expected_ths: self.expected,
efficiency,
power_w: self.power,
chip_temp_c: self.temp,
fan_rpm: self.fan,
board_temps,
env_temp_c,
fan_rpms,
worker: self.worker.to_string(),
is_mining: self.mining,
slow,
paused: self.paused,
// offline defaults to false (online); these bench rows are reachable.
mac: format!("AA:BB:CC:00:{:02X}:{last_octet:02X}", last_octet.wrapping_mul(3)),
hostname: format!("miner-{last_octet}"),
hashboards: boards,
expected_hashboards: Some(3),
board_status,
total_chips: chips,
psu_fan_rpm: if self.mining { self.fan * 0.9 } else { 0.0 },
uptime_secs: if self.mining { 3600 * 24 * 2 + 3600 * 5 } else { 0 },
light_flashing: Some(false),
// One unit is "being located" so the Light column's yellow dot is
// demonstrable offline (round 11 #10).
light_flashing: Some(self.ip == "10.255.1.167"),
pool_url: if self.worker.is_empty() { String::new() } else { "stratum+tcp://pool.blueflare:3333".to_string() },
pools: if self.worker.is_empty() {
Vec::new()
@@ -68,47 +140,95 @@ impl Board {
("stratum+tcp://backup.blueflare:3333".to_string(), format!("{}_bak", self.worker)),
]
},
operating_state: if self.mining { "mining".to_string() } else { "idle".to_string() },
operating_state: if self.paused {
"paused".to_string()
} else if self.mining {
"mining".to_string()
} else {
"idle".to_string()
},
// Synthetic capabilities so the right-click config menu is
// exercisable offline: mining units support everything, idle ones
// only the fault light + restart (to show the capability intersection).
caps: crate::model::MinerCaps {
fault_light: true,
restart: true,
pause: self.mining,
resume: self.mining,
power_limit: self.mining,
tuning: self.mining,
firmware_flash,
},
// Demo values for the round-8/9 columns (synthetic, so the columns
// show variety offline). control_board is derived above via naming.
algorithm: "SHA256".to_string(),
control_board,
pic_present: if self.model_id.contains("S21") {
Some(false) // noPIC example
} else if self.make.eq_ignore_ascii_case("antminer") {
Some(true)
} else {
None // WhatsMiner: unknown over the network
},
// Access: idle/view-only units (no worker) shown locked; the rest
// unlocked. (Live rows infer this from control capabilities.)
write_locked: Some(self.worker.is_empty()),
// Concise, prefix-free lines (matching summarize_messages output):
// the Errors column shows the count, these are the hover tooltip.
errors: if self.model_id == "S21Pro" {
vec![
"hashrate 70% below expected".to_string(),
"chip temperature high (HashBoard 2)".to_string(),
]
} else {
Vec::new()
},
..Default::default()
}
}
}
/// The 9 bench boards. Two are idle (S17 stock, WardenOS dev), one is slow
/// (S21 Pro aml stock at ~30% of expected); the other six hash normally.
/// The 9 bench boards (9 rows total). One is idle/not-hashing (S17 stock,
/// .112); one is paused (WardenOS dev, .115 - deliberately rebucketed from idle
/// so the "paused" status/KPI bucket is exercisable offline); one is slow (S21
/// Pro aml stock at ~30% of expected); the other six hash normally.
///
/// Derived totals (used by the workflow tests):
/// total = 9, hashing = 6, slow = 1, not hashing = 2,
/// total = 9, hashing = 6, slow = 1, not hashing = 1, paused = 1,
/// total hashrate = 685.0 TH/s, total power = 21300 W.
pub fn bench_fleet() -> Vec<MinerRow> {
let boards = [
Board { ip: "10.255.1.112", model: "Antminer S17", firmware: "Stock",
// firmware families span the palette (Stock/VNish/Braiins/LuxOS/ePIC/
// Hive/BixBit/Alkane) so the offline demo shows the Firmware colouring.
Board { ip: "10.255.1.112", make: "Antminer", model_id: "S17", board: "Xilinx", firmware: "Stock", fw_version: "",
hashrate: 0.0, expected: 0.0, power: 0.0, temp: 0.0, fan: 0.0,
worker: "", mining: false },
Board { ip: "10.255.1.166", model: "Antminer S19", firmware: "[removed] 1.2",
worker: "", mining: false, paused: false },
Board { ip: "10.255.1.166", make: "Antminer", model_id: "S19", board: "BeagleBoneBlack", firmware: "VNish", fw_version: "1.2.8",
hashrate: 95.0, expected: 96.0, power: 3250.0, temp: 65.0, fan: 4200.0,
worker: "blueflare.s19", mining: true },
Board { ip: "10.255.1.152", model: "Antminer S19j Pro", firmware: "[removed] 1.2",
worker: "blueflare.s19", mining: true, paused: false },
Board { ip: "10.255.1.152", make: "Antminer", model_id: "S19jPro", board: "AMLogic", firmware: "Braiins", fw_version: "25.05.1",
hashrate: 100.0, expected: 104.0, power: 3100.0, temp: 62.0, fan: 3900.0,
worker: "blueflare.s19jpro", mining: true },
Board { ip: "10.255.1.167", model: "Antminer S19k Pro", firmware: "[removed] 1.2",
worker: "blueflare.s19jpro", mining: true, paused: false },
Board { ip: "10.255.1.167", make: "Antminer", model_id: "S19KPro", board: "AMLogic", firmware: "LuxOS", fw_version: "2024.9.0",
hashrate: 120.0, expected: 128.0, power: 3300.0, temp: 68.0, fan: 4500.0,
worker: "blueflare.s19kpro", mining: true },
Board { ip: "10.255.1.149", model: "Antminer S21 Pro", firmware: "Stock",
worker: "blueflare.s19kpro", mining: true, paused: false },
Board { ip: "10.255.1.149", make: "Antminer", model_id: "S21Pro", board: "CVITek", firmware: "ePIC", fw_version: "1.0.3",
hashrate: 60.0, expected: 200.0, power: 1500.0, temp: 55.0, fan: 3000.0,
worker: "blueflare.s21pro", mining: true }, // slow: 60/200 = 30%
Board { ip: "10.255.1.126", model: "WhatsMiner M30S", firmware: "WMOS H3",
worker: "blueflare.s21pro", mining: true, paused: false }, // slow: 60/200 = 30%
Board { ip: "10.255.1.126", make: "Whatsminer", model_id: "M30SVE40", board: "H3", firmware: "Stock", fw_version: "H3.0.1",
hashrate: 92.0, expected: 96.0, power: 3400.0, temp: 70.0, fan: 4800.0,
worker: "blueflare.h3", mining: true },
Board { ip: "10.255.1.131", model: "WhatsMiner M30S+", firmware: "WMOS H616",
worker: "blueflare.h3", mining: true, paused: false },
Board { ip: "10.255.1.131", make: "Whatsminer", model_id: "M30SPlusVE40", board: "H616", firmware: "Hive", fw_version: "1.0",
hashrate: 100.0, expected: 100.0, power: 3450.0, temp: 71.0, fan: 4900.0,
worker: "blueflare.h616", mining: true },
Board { ip: "10.255.1.148", model: "WhatsMiner M50", firmware: "WMOS CB4",
worker: "blueflare.h616", mining: true, paused: false },
Board { ip: "10.255.1.148", make: "Whatsminer", model_id: "M50VH50", board: "H6", firmware: "BixBit", fw_version: "2.1",
hashrate: 118.0, expected: 122.0, power: 3300.0, temp: 66.0, fan: 4600.0,
worker: "blueflare.m50", mining: true },
Board { ip: "10.255.1.115", model: "Antminer S19", firmware: "WardenOS dev",
worker: "blueflare.m50", mining: true, paused: false },
// Rebucketed from idle/not-hashing to paused so the "paused"
// status/KPI bucket is exercisable in the fake-scan/offline demo.
Board { ip: "10.255.1.115", make: "Antminer", model_id: "S19", board: "BeagleBoneBlack", firmware: "Alkane", fw_version: "0.1",
hashrate: 0.0, expected: 0.0, power: 0.0, temp: 0.0, fan: 0.0,
worker: "", mining: false },
worker: "", mining: false, paused: true },
];
boards.into_iter().map(Board::into_row).collect()
}
+5
View File
@@ -1,8 +1,13 @@
//! alkane-toolkit — primary view (docs/UI-SPEC.md).
//! Pure-Rust wxWidgets app on the vendored, patched wx-rs.
mod access_probe;
mod credentials;
mod fixtures;
mod model;
mod naming;
mod pic_probe;
mod presets;
mod scan;
mod ui;
File diff suppressed because it is too large Load Diff
+413
View File
@@ -0,0 +1,413 @@
//! Display-layer device-naming cleanup (round-9 item #11).
//!
//! asic-rs hands us compact Rust-identifier model strings and bare control-board
//! names, not human-facing labels:
//! - `device_info.make` = "Antminer" / "Whatsminer" (note the casing)
//! - `device_info.model` = the model enum's variant identifier verbatim, e.g.
//! "S19KPro", "S19jPro", "M30SPlusVE40", "M30SPlusPlusVE40" -- no spaces,
//! "+" rendered "Plus", "++" rendered "PlusPlus", the WhatsMiner version
//! block ("VE40") baked in.
//! - `control_board_version` = a bare board name ("Xilinx", "CVITek",
//! "AMLogic", "BeagleBoneBlack"; WhatsMiner "H3"/"H6"/"H6OS"/"H616").
//!
//! This module turns those into the Brand / Model / Submodel / control-board
//! short code the table shows. It is a pure string transform -- no asic-rs edit
//! -- so it stays a build-on-top layer over the vendored crate.
//!
//! Known limitations (asic-rs does not expose the data):
//! - Antminer has no hashboard-type/submodel over the network, so Submodel is
//! blank for Antminer (only WhatsMiner's version block is recoverable).
//! - asic-rs reports only "AMLogic" (not the 120mm C76 vs 140mm CBE board) and
//! only "Xilinx" (not C49 vs C55); we disambiguate by model family as a
//! best-effort heuristic documented at `control_board_code`.
/// Human brand from asic-rs `device_info.make`.
pub fn brand(make: &str) -> String {
match make.trim().to_ascii_lowercase().as_str() {
"antminer" => "Antminer".to_string(),
"whatsminer" => "WhatsMiner".to_string(),
"" => String::new(),
other => {
// Title-case an unknown make so the Brand column still reads well.
let mut c = other.chars();
match c.next() {
Some(f) => f.to_ascii_uppercase().to_string() + c.as_str(),
None => String::new(),
}
}
}
}
fn is_whatsminer(make: &str) -> bool {
make.trim().eq_ignore_ascii_case("whatsminer")
}
fn is_antminer(make: &str) -> bool {
make.trim().eq_ignore_ascii_case("antminer")
}
/// Split asic-rs's firmware family string into the family shown in the Firmware
/// column and an optional vendor prefix that moves into the FW Version column
/// (round 11 #6). asic-rs reports stock firmware as "AntMiner Stock" /
/// "WhatsMiner Stock"; the Firmware column should read just "Stock" (so it
/// colours as the neutral/default family), and the vendor word belongs with the
/// version. Aftermarket families ("VNish", "Braiins", ...) carry no vendor
/// prefix and pass through unchanged.
pub fn firmware_family(raw: &str) -> (String, Option<String>) {
let trimmed = raw.trim();
// Vendor prefixes asic-rs prepends on stock-firmware family strings, matched
// case-insensitively.
for vendor in ["AntMiner", "WhatsMiner"] {
if trimmed.len() > vendor.len() && trimmed[..vendor.len()].eq_ignore_ascii_case(vendor) {
let rest = trimmed[vendor.len()..].trim();
if !rest.is_empty() {
return (rest.to_string(), Some(vendor.to_string()));
}
}
}
(trimmed.to_string(), None)
}
/// Whether a miner is liquid-cooled (hydro / water / immersion) rather than
/// air-cooled, inferred from the model name (round 11 #17). asic-rs exposes no
/// cooling-type field, so this is a best-effort model-string heuristic: it
/// decides whether a reported "fluid" temperature is a real coolant reading or
/// (for air-cooled units) the ambient/environment temperature.
pub fn is_liquid_cooled(model: &str) -> bool {
let m = model.to_ascii_lowercase();
m.contains("hydro") || m.contains("immers") || m.contains("water")
}
/// The human model name for the Model column: brand dropped (it has its own
/// column), family-letter suffix lowercased, word suffixes spaced, "+"/"++" for
/// Plus/PlusPlus, and (WhatsMiner) the trailing version block moved to Submodel.
pub fn clean_model(make: &str, model_id: &str) -> String {
let id = model_id.trim();
if id.is_empty() {
return String::new();
}
if is_whatsminer(make) {
clean_whatsminer(id).0
} else if is_antminer(make) {
clean_antminer(id)
} else {
id.to_string()
}
}
/// The Submodel column value. WhatsMiner: the version block ("VE40"). Antminer:
/// empty -- the hashboard type is not reported over the network by asic-rs.
pub fn submodel(make: &str, model_id: &str) -> String {
if is_whatsminer(make) {
clean_whatsminer(model_id.trim()).1
} else {
String::new()
}
}
/// Split a WhatsMiner identifier into (clean model, version submodel). The
/// version block is the trailing run beginning at the first 'V' (WhatsMiner
/// tiers never contain a 'V', so the first 'V' always starts the version). The
/// prefix's Plus/PlusPlus become +/++.
fn clean_whatsminer(id: &str) -> (String, String) {
let (prefix, version) = match id.find('V') {
Some(i) => (&id[..i], id[i..].to_string()),
None => (id, String::new()),
};
let model = prefix.replace("PlusPlus", "++").replace("Plus", "+");
(model, version)
}
/// Known Antminer word-suffixes, longest-first so "PlusPlus" wins over "Plus"
/// and "NoPIC" is matched whole. Each maps to its spaced display form.
const ANT_SUFFIXES: &[(&str, &str)] = &[
("PlusPlus", "++"),
("Plus", "+"),
("NoPIC", " NoPIC"),
("Hydro", " Hydro"),
("Pro", " Pro"),
("XP", " XP"),
];
/// Clean an Antminer identifier, e.g. "S19KPro" -> "S19k Pro", "S21eXPHydro" ->
/// "S21e XP Hydro", "L3PlusPlus" -> "L3++". Unknown/odd inputs pass through.
fn clean_antminer(id: &str) -> String {
// asic-rs "Unknown" models pass the raw vendor string through with the brand
// still in it (e.g. "ANTMINER S19 (88)", a NoPIC S19); drop a redundant
// leading brand word so the Model column never repeats the Brand column.
let id = if id.len() >= 9 && id[..9].eq_ignore_ascii_case("ANTMINER ") {
id[9..].trim_start()
} else {
id
};
let bytes = id.as_bytes();
// Base = leading letters then digits ("S19", "KS5", "L3", "Z15"). Without a
// letter+digit base (e.g. an Unknown passthrough), return the id unchanged.
let mut i = 0;
while i < bytes.len() && bytes[i].is_ascii_alphabetic() {
i += 1;
}
let letters_end = i;
while i < bytes.len() && bytes[i].is_ascii_digit() {
i += 1;
}
if letters_end == 0 || i == letters_end {
return id.to_string();
}
let mut out = String::from(&id[..i]);
let mut rest = &id[i..];
// An optional single family letter directly after the digits (j/i/a/e/K/L),
// recognised as "not the start of a known suffix". Lowercase it, keep it
// attached to the base (no space): "S19K" -> "S19k".
if let Some(first) = rest.chars().next() {
let starts_suffix = ANT_SUFFIXES.iter().any(|(s, _)| rest.starts_with(s));
if first.is_ascii_alphabetic() && !starts_suffix {
out.push(first.to_ascii_lowercase());
rest = &rest[first.len_utf8()..];
}
}
// Remaining suffix words, matched greedily against the known set.
while !rest.is_empty() {
match ANT_SUFFIXES.iter().find(|(s, _)| rest.starts_with(s)) {
Some((s, disp)) => {
out.push_str(disp);
rest = &rest[s.len()..];
}
None => {
// Unknown trailing token: emit it space-separated and stop.
out.push(' ');
out.push_str(rest.trim_start());
break;
}
}
}
out
}
/// Normalise a raw control-board name for matching: drop spaces/punctuation and
/// uppercase, so "BeagleBone Black", "BeagleBoneBlack" and "BBB" all collapse.
fn compact_upper(s: &str) -> String {
s.chars().filter(|c| c.is_ascii_alphanumeric()).flat_map(|c| c.to_uppercase()).collect()
}
/// The control-board short code for the Control-board column, e.g.
/// "BeagleBoneBlack" -> "BBB (C77)", "Xilinx" on an S17 -> "XIL (C49)".
///
/// asic-rs reports only the board FAMILY ("AMLogic"/"Xilinx"), never the exact
/// Bitmain board number, so where a family spans two boards we disambiguate by
/// model era/class (best-effort, since the network data can't distinguish them):
/// - Xilinx: S17/T17-era -> C49, otherwise (S19-era) -> C55.
/// - AMLogic: XP-class / S19k (140mm fans) -> CBE, otherwise (120mm) -> C76.
/// `clean_model` is the already-cleaned model name (used for the era/class test).
pub fn control_board_code(make: &str, board_name: &str, clean_model: &str) -> String {
let (cpu, code) = control_board_split(make, board_name, clean_model);
if code.is_empty() {
cpu
} else {
format!("{cpu} ({code})")
}
}
/// The control-board CPU family short code alone ("AML", "CVI", "BBB", "XIL",
/// WhatsMiner "H3"/"H6"/"H6os"/"H616", or the raw name if unrecognised).
pub fn control_board_cpu(make: &str, board_name: &str, clean_model: &str) -> String {
control_board_split(make, board_name, clean_model).0
}
/// The Bitmain board code alone ("C77"/"C88"/"C49"/"C55"/"C76"/"CBE";
/// WhatsMiner "CB2"/"CB4"/"CB6"), or "" when unknown.
pub fn control_board_board(make: &str, board_name: &str, clean_model: &str) -> String {
control_board_split(make, board_name, clean_model).1
}
/// Split a raw control-board name into (CPU family short code, Bitmain board
/// code). asic-rs reports only the board FAMILY ("AMLogic"/"Xilinx"), never the
/// exact board number, so where a family spans two boards we disambiguate by
/// model era/class (best-effort):
/// - Xilinx: S17/T17-era -> C49, otherwise (S19-era) -> C55.
/// - AMLogic: XP-class / S19k / S21 (140mm fans) -> CBE, otherwise 120mm C76.
fn control_board_split(make: &str, board_name: &str, clean_model: &str) -> (String, String) {
let raw = board_name.trim();
if raw.is_empty() {
return (String::new(), String::new());
}
// asic-rs renders an unrecognised board as "Unknown: <raw>"; surface it in
// the CPU part with no code.
if raw.starts_with("Unknown") {
return (raw.to_string(), String::new());
}
let key = compact_upper(raw);
let pair = |cpu: &str, code: &str| (cpu.to_string(), code.to_string());
if is_whatsminer(make) {
return match key.as_str() {
"H3" => pair("H3", "CB2"),
"H6" => pair("H6", "CB4"),
"H6OS" => pair("H6os", "CB4"),
"H616" => pair("H616", "CB6"),
_ => (raw.to_string(), String::new()),
};
}
// Antminer (and any make that reports these families).
match key.as_str() {
"BEAGLEBONEBLACK" | "BBB" | "BB" | "BEAGLEBONE" => pair("BBB", "C77"),
"CVITEK" | "CVI" => pair("CVI", "C88"),
"XILINX" | "XIL" => {
if is_s17_era(clean_model) {
pair("XIL", "C49")
} else {
pair("XIL", "C55")
}
}
"AMLOGIC" | "AML" => {
if is_aml_140mm(clean_model) {
pair("AML", "CBE")
} else {
pair("AML", "C76")
}
}
_ => (raw.to_string(), String::new()),
}
}
/// S17/T17-era models use the Xilinx C49 control board.
fn is_s17_era(clean_model: &str) -> bool {
let m = clean_model.trim_start();
m.starts_with("S17") || m.starts_with("T17")
}
/// Best-effort: the 140mm-fan AMLogic board (CBE) is used on the XP-class, the
/// S19k Pro, and the S21 Pro; everything else AMLogic is the 120mm C76. asic-rs
/// cannot tell these apart, so this is a model-family heuristic, not a read.
fn is_aml_140mm(clean_model: &str) -> bool {
let m = clean_model.trim_start();
m.contains("XP") || m.starts_with("S19k") || m.starts_with("S21")
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn brand_normalises_case() {
assert_eq!(brand("Antminer"), "Antminer");
assert_eq!(brand("Whatsminer"), "WhatsMiner");
assert_eq!(brand("whatsminer"), "WhatsMiner");
assert_eq!(brand(""), "");
assert_eq!(brand("avalonminer"), "Avalonminer");
}
#[test]
fn antminer_model_cleanup() {
// The headline example from the spec.
assert_eq!(clean_model("Antminer", "S19KPro"), "S19k Pro");
assert_eq!(clean_model("Antminer", "S19jPro"), "S19j Pro");
assert_eq!(clean_model("Antminer", "S21Pro"), "S21 Pro");
assert_eq!(clean_model("Antminer", "S19"), "S19");
assert_eq!(clean_model("Antminer", "S19XP"), "S19 XP");
assert_eq!(clean_model("Antminer", "S19jXP"), "S19j XP");
assert_eq!(clean_model("Antminer", "S19Plus"), "S19+");
assert_eq!(clean_model("Antminer", "S19ProPlus"), "S19 Pro+");
assert_eq!(clean_model("Antminer", "S19jProPlus"), "S19j Pro+");
assert_eq!(clean_model("Antminer", "S19ProPlusHydro"), "S19 Pro+ Hydro");
assert_eq!(clean_model("Antminer", "S19jNoPIC"), "S19j NoPIC");
assert_eq!(clean_model("Antminer", "S21PlusPlus"), "S21++");
assert_eq!(clean_model("Antminer", "S21eXPHydro"), "S21e XP Hydro");
assert_eq!(clean_model("Antminer", "L3PlusPlus"), "L3++");
assert_eq!(clean_model("Antminer", "KS5Pro"), "KS5 Pro");
assert_eq!(clean_model("Antminer", "Z15Pro"), "Z15 Pro");
assert_eq!(clean_model("Antminer", "S9i"), "S9i");
assert_eq!(clean_model("Antminer", "S17e"), "S17e");
assert_eq!(clean_model("Antminer", "S19a"), "S19a");
assert_eq!(clean_model("Antminer", "S19aPro"), "S19a Pro");
// asic-rs Unknown passthrough carrying the raw vendor string (a NoPIC
// S19 seen live at 10.4.x): drop the redundant brand, keep the rest.
assert_eq!(clean_model("Antminer", "ANTMINER S19 (88)"), "S19 (88)");
}
#[test]
fn whatsminer_model_and_submodel() {
assert_eq!(clean_model("Whatsminer", "M30SPlusVE40"), "M30S+");
assert_eq!(submodel("Whatsminer", "M30SPlusVE40"), "VE40");
assert_eq!(clean_model("Whatsminer", "M30SPlusPlusVE40"), "M30S++");
assert_eq!(submodel("Whatsminer", "M30SPlusPlusVE40"), "VE40");
assert_eq!(clean_model("Whatsminer", "M30SVE40"), "M30S");
assert_eq!(submodel("Whatsminer", "M30SVE40"), "VE40");
assert_eq!(clean_model("Whatsminer", "M20S"), "M20S");
assert_eq!(submodel("Whatsminer", "M20S"), "");
assert_eq!(clean_model("Whatsminer", "M50S++VK30"), "M50S++");
assert_eq!(submodel("Whatsminer", "M50S++VK30"), "VK30");
}
#[test]
fn antminer_has_no_submodel() {
assert_eq!(submodel("Antminer", "S19KPro"), "");
}
#[test]
fn control_board_short_codes() {
// Antminer families (board name as asic-rs renders the enum variant).
assert_eq!(control_board_code("Antminer", "BeagleBoneBlack", "S19"), "BBB (C77)");
// Also accept the spaced form some layers produce.
assert_eq!(control_board_code("Antminer", "BeagleBone Black", "S19"), "BBB (C77)");
assert_eq!(control_board_code("Antminer", "CVITek", "S21 Pro"), "CVI (C88)");
assert_eq!(control_board_code("Antminer", "Xilinx", "S17 Pro"), "XIL (C49)");
assert_eq!(control_board_code("Antminer", "Xilinx", "T17"), "XIL (C49)");
assert_eq!(control_board_code("Antminer", "Xilinx", "S19 Pro"), "XIL (C55)");
assert_eq!(control_board_code("Antminer", "AMLogic", "S19j Pro"), "AML (C76)");
assert_eq!(control_board_code("Antminer", "AMLogic", "S19k Pro"), "AML (CBE)");
assert_eq!(control_board_code("Antminer", "AMLogic", "S19 XP"), "AML (CBE)");
// WhatsMiner families.
assert_eq!(control_board_code("Whatsminer", "H3", "M30S"), "H3 (CB2)");
assert_eq!(control_board_code("Whatsminer", "H6", "M50"), "H6 (CB4)");
assert_eq!(control_board_code("Whatsminer", "H6OS", "M50"), "H6os (CB4)");
assert_eq!(control_board_code("Whatsminer", "H616", "M30S+"), "H616 (CB6)");
// Unknown / blank pass through.
assert_eq!(control_board_code("Antminer", "Unknown: FOO", "S19"), "Unknown: FOO");
assert_eq!(control_board_code("Antminer", "", "S19"), "");
}
#[test]
fn control_board_cpu_and_board_split() {
// CPU column vs board-code column.
assert_eq!(control_board_cpu("Antminer", "AMLogic", "S19j Pro"), "AML");
assert_eq!(control_board_board("Antminer", "AMLogic", "S19j Pro"), "C76");
assert_eq!(control_board_cpu("Antminer", "CVITek", "S21 Pro"), "CVI");
assert_eq!(control_board_board("Antminer", "CVITek", "S21 Pro"), "C88");
assert_eq!(control_board_cpu("Whatsminer", "H616", "M30S+"), "H616");
assert_eq!(control_board_board("Whatsminer", "H616", "M30S+"), "CB6");
// S21 Pro on an AMLogic board is the 140mm CBE, not C76.
assert_eq!(control_board_board("Antminer", "AMLogic", "S21 Pro"), "CBE");
assert_eq!(control_board_code("Antminer", "AMLogic", "S21 Pro"), "AML (CBE)");
// Unknown -> cpu holds the raw string, no board code.
assert_eq!(control_board_cpu("Antminer", "Unknown: FOO", "S19"), "Unknown: FOO");
assert_eq!(control_board_board("Antminer", "Unknown: FOO", "S19"), "");
}
#[test]
fn firmware_family_splits_vendor_prefix() {
// Stock firmware: vendor word moves out of the family word (round 11 #6).
assert_eq!(firmware_family("AntMiner Stock"), ("Stock".to_string(), Some("AntMiner".to_string())));
assert_eq!(
firmware_family("WhatsMiner Stock"),
("Stock".to_string(), Some("WhatsMiner".to_string()))
);
// Aftermarket families pass through with no vendor prefix.
assert_eq!(firmware_family("VNish"), ("VNish".to_string(), None));
assert_eq!(firmware_family("Braiins"), ("Braiins".to_string(), None));
// A bare vendor word with nothing after it is left as-is (not emptied).
assert_eq!(firmware_family("AntMiner"), ("AntMiner".to_string(), None));
}
#[test]
fn liquid_cooling_detection() {
assert!(is_liquid_cooled("S21 XP Hydro"));
assert!(is_liquid_cooled("Antminer S19 Hydro"));
assert!(is_liquid_cooled("M53 immersion"));
assert!(!is_liquid_cooled("S21 Pro"));
assert!(!is_liquid_cooled("M30S++"));
}
}
+238
View File
@@ -0,0 +1,238 @@
//! Real PIC-vs-noPIC detection for Antminer control boards, over SSH + i2c-tools.
//!
//! asic-rs and the miner's network API cannot report PIC presence (see the
//! project wiki, 30-power-thermal-and-board-identity/hashboard-eeprom-pic.md);
//! the authoritative tell lives on the control board's I2C bus. On a
//! PIC/MCU-equipped board, I2C 0x48 is a hashboard MCU exposing an 8-byte
//! register file that WRAPS every 8 bytes (e.g. `17 00 4b 50 7f 00 00 00 ...`);
//! on a noPIC board, 0x48 is a plain LM75 temperature sensor with a 4-register
//! layout that wraps every 4 bytes. We read 0x48 with `i2cdump` over SSH and
//! discriminate by that period.
//!
//! This is a slow, credentialed, opt-in probe (an SSH handshake + shell command
//! per miner), never part of the fast network scan. We shell out to `ssh`
//! (via `sshpass` for password auth) rather than pull in an SSH crate, so the
//! offline/vendored build is unaffected.
use std::process::Command;
use std::time::Duration;
/// SSH login for the miner's control board (distinct from the web/API creds).
#[derive(Debug, Clone)]
pub struct SshCreds {
pub user: String,
/// Empty means key-based auth (BatchMode); otherwise `sshpass` is used.
pub pass: String,
}
/// I2C buses to probe for the hashboard MCU/LM75 at 0x48, most-likely first,
/// chosen from the control-board family. `probe_pic` tries them in order and
/// stops at the first bus that classifies definitively, so extra fallbacks only
/// cost an SSH round-trip when earlier buses are absent/indeterminate.
///
/// Confirmed live (2026-09-19): a VNish CVITek S19k Pro exposes the hashboard
/// MCU on i2c-3 (i2c-4 is the second, usually empty); its buses are i2c-3/i2c-4,
/// NOT i2c-0/i2c-1 -- the earlier CVITek -> [1,0] guess never found the MCU,
/// which is why PIC detection appeared not to work. AMLogic=i2c-1 and
/// BeagleBone=i2c-0 are from the wiki; buses vary across firmware, so each family
/// also lists the others as fallbacks.
pub fn bus_candidates(control_board: &str) -> Vec<u8> {
let cb = control_board.to_lowercase();
if cb.contains("cvi") {
vec![3, 4, 1, 0]
} else if cb.contains("amlogic") || cb.contains("aml") {
vec![1, 3, 4, 0]
} else if cb.contains("beaglebone") || cb.contains("bb") {
vec![0, 1, 3, 4]
} else {
// Xilinx / unknown: try the common buses.
vec![1, 0, 3, 4]
}
}
/// Classify an `i2cdump -y <bus> 0x48 b` dump: `Some(true)` = PIC (8-byte MCU
/// register file), `Some(false)` = noPIC (4-register LM75), `None` = couldn't
/// tell (address unresponsive, no periodicity, or unparseable). Conservative:
/// anything ambiguous is `None`, never a guess.
pub fn classify_i2cdump(stdout: &str) -> Option<bool> {
let bytes = parse_dump_offset0(stdout)?;
// An LM75's 4 registers repeat every 4 bytes; check that first because a
// period-4 sequence is trivially also period-8.
let period4 = (0..12).all(|i| bytes[i] == bytes[i + 4]);
if period4 {
return Some(false); // LM75 -> noPIC
}
let period8 = (0..8).all(|i| bytes[i] == bytes[i + 8]);
if period8 {
return Some(true); // 8-byte MCU register file -> PIC
}
None
}
/// Parse the 16 bytes of the `00:` row of an `i2cdump ... b` output. Returns
/// `None` if the row is missing or any cell is unreadable ("XX").
fn parse_dump_offset0(stdout: &str) -> Option<[u8; 16]> {
let line = stdout.lines().find_map(|l| {
let l = l.trim();
l.strip_prefix("00:").map(str::trim_start)
})?;
// The row is "<16 hex/XX cells> <ascii gutter>"; take the first 16 cells.
let mut out = [0u8; 16];
let mut n = 0;
for tok in line.split_whitespace() {
if n == 16 {
break;
}
if tok.len() != 2 {
break; // reached the ascii gutter
}
match u8::from_str_radix(tok, 16) {
Ok(b) => {
out[n] = b;
n += 1;
}
Err(_) => return None, // "XX" = no response -> indeterminate
}
}
(n == 16).then_some(out)
}
/// Build the ssh argv for one `i2cdump` on `bus`. Uses `sshpass -p <pass>` when
/// a password is set, else relies on key auth (BatchMode).
fn ssh_command(ip: &str, bus: u8, creds: &SshCreds) -> Command {
let remote = format!("i2cdump -y {bus} 0x48 b");
let target = format!("{}@{ip}", creds.user);
let ssh_opts = [
"-o", "StrictHostKeyChecking=no",
"-o", "UserKnownHostsFile=/dev/null",
"-o", "ConnectTimeout=6",
"-o", "NumberOfPasswordPrompts=1",
];
if creds.pass.is_empty() {
let mut c = Command::new("ssh");
c.arg("-o").arg("BatchMode=yes");
c.args(ssh_opts).arg(&target).arg(&remote);
c
} else {
// sshpass reads the password from the env var named after -e's default,
// but we use -p for simplicity; the password never reaches the argv of
// a child that logs it (sshpass scrubs its own argv).
let mut c = Command::new("sshpass");
c.arg("-p").arg(&creds.pass).arg("ssh");
c.args(ssh_opts).arg(&target).arg(&remote);
c
}
}
/// Probe one miner's PIC state over SSH. Returns `Ok(Some(true/false))` on a
/// confident PIC/noPIC read, `Ok(None)` if reachable but indeterminate, or
/// `Err` on an SSH/connection/auth failure.
pub fn probe_pic(ip: &str, control_board: &str, creds: &SshCreds) -> Result<Option<bool>, String> {
let mut last_err = String::from("no i2c bus responded");
for bus in bus_candidates(control_board) {
match run_probe(ip, bus, creds) {
Ok(Some(v)) => return Ok(Some(v)),
Ok(None) => last_err = format!("i2c-0x48 on bus {bus} was indeterminate"),
Err(e) => return Err(e), // an auth/connection error won't improve on another bus
}
}
// Reachable but couldn't classify on any candidate bus.
let _ = last_err;
Ok(None)
}
fn run_probe(ip: &str, bus: u8, creds: &SshCreds) -> Result<Option<bool>, String> {
let out = wait_with_timeout(ssh_command(ip, bus, creds), Duration::from_secs(12))?;
if !out.status.success() {
let err = String::from_utf8_lossy(&out.stderr);
// A failed i2cdump on this bus (e.g. bus doesn't exist) is not fatal --
// let the caller try the next bus. But an SSH/auth failure is fatal.
let e = err.trim().to_string();
if e.to_lowercase().contains("permission denied")
|| e.to_lowercase().contains("connection")
|| e.to_lowercase().contains("timed out")
|| e.to_lowercase().contains("no route")
|| e.to_lowercase().contains("host key")
{
return Err(if e.is_empty() { "ssh failed".into() } else { e });
}
return Ok(None);
}
Ok(classify_i2cdump(&String::from_utf8_lossy(&out.stdout)))
}
/// Run a command with a wall-clock timeout (SSH can hang on a dead host).
fn wait_with_timeout(mut cmd: Command, timeout: Duration) -> Result<std::process::Output, String> {
use std::io::Read;
cmd.stdout(std::process::Stdio::piped()).stderr(std::process::Stdio::piped());
let mut child = cmd.spawn().map_err(|e| format!("spawn ssh: {e}"))?;
let start = std::time::Instant::now();
loop {
match child.try_wait().map_err(|e| e.to_string())? {
Some(status) => {
let mut stdout = Vec::new();
let mut stderr = Vec::new();
if let Some(mut o) = child.stdout.take() {
let _ = o.read_to_end(&mut stdout);
}
if let Some(mut e) = child.stderr.take() {
let _ = e.read_to_end(&mut stderr);
}
return Ok(std::process::Output { status, stdout, stderr });
}
None => {
if start.elapsed() >= timeout {
let _ = child.kill();
return Err("ssh timed out".into());
}
std::thread::sleep(Duration::from_millis(100));
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn classify_pic_from_wiki_dump() {
// The wiki's PIC/MCU board dump: 8-byte register file that wraps.
let dump = "\
0 1 2 3 4 5 6 7 8 9 a b c d e f 0123456789abcdef
00: 17 00 4b 50 7f 00 00 00 17 00 4b 50 7f 00 00 00 ................
10: 17 00 4b 50 7f 00 00 00 17 00 4b 50 7f 00 00 00 ................";
assert_eq!(classify_i2cdump(dump), Some(true), "8-byte wrap -> PIC");
}
#[test]
fn classify_nopic_from_lm75() {
// An LM75 has 4 registers (temp/config/Thyst/Tos) that wrap every 4.
let dump = "\
0 1 2 3 4 5 6 7 8 9 a b c d e f 0123456789abcdef
00: 19 00 4b 50 19 00 4b 50 19 00 4b 50 19 00 4b 50 ................";
assert_eq!(classify_i2cdump(dump), Some(false), "4-register LM75 -> noPIC");
}
#[test]
fn classify_indeterminate() {
// No response (XX) or no periodicity -> None (never a guess).
let xx = "00: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX";
assert_eq!(classify_i2cdump(xx), None);
let noisy = "00: 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10";
assert_eq!(classify_i2cdump(noisy), None);
assert_eq!(classify_i2cdump("no offset row here"), None);
}
#[test]
fn bus_from_control_board() {
// Most-likely bus first, then fallbacks. CVITek's i2c-3 first is the live
// fix; AMLogic i2c-1 and BeagleBone i2c-0 keep their wiki-confirmed lead.
assert_eq!(bus_candidates("CVI (C88)"), vec![3, 4, 1, 0]);
assert_eq!(bus_candidates("CVITek"), vec![3, 4, 1, 0]);
assert_eq!(bus_candidates("AMLogic")[0], 1);
assert_eq!(bus_candidates("BeagleBone Black")[0], 0);
assert_eq!(bus_candidates("Xilinx")[0], 1);
assert_eq!(bus_candidates("")[0], 1);
}
}
+153
View File
@@ -0,0 +1,153 @@
//! Saved view presets: named snapshots of the table's column arrangement,
//! visibility, sort, and filters. Persisted as JSON in the config dir. The
//! first preset is always a built-in "Default" profile.
use std::collections::{HashMap, HashSet};
use serde::{Deserialize, Serialize};
use crate::model::{ColFilter, Column, ViewState, ALL_COLUMNS};
use crate::scan::config_path;
pub const PRESETS_FILE: &str = "presets.json";
/// The built-in default profile's visible columns, in display order (Ip first):
/// IP, model, errors, hashrate, power, chip temp, firmware, CPU, boards
/// (hashboard health), access.
const DEFAULT_PROFILE: [Column; 10] = [
Column::Ip,
Column::Model,
Column::Error,
Column::Hashrate,
Column::Power,
Column::ChipTemp,
Column::Firmware,
Column::Cpu,
Column::Hashboards,
Column::Locked,
];
/// A serializable snapshot of a `ViewState` (Vec-based so JSON has no map keys
/// that are enums, and column order within `visible` is preserved).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PresetView {
pub order: Vec<Column>,
pub visible: Vec<Column>,
pub sort: Option<(Column, bool)>,
pub filters: Vec<(Column, ColFilter)>,
}
impl PresetView {
pub fn from_view(v: &ViewState) -> PresetView {
PresetView {
order: v.order.clone(),
// keep the visible columns in display order for stability
visible: v.order.iter().copied().filter(|c| v.visible.contains(c)).collect(),
sort: v.sort,
filters: v.filters.iter().map(|(k, f)| (*k, f.clone())).collect(),
}
}
/// Rebuild a `ViewState` from this snapshot. Any column missing from a
/// loaded (possibly older) preset is appended to `order` and left hidden, so
/// the result always covers every `Column`.
pub fn to_view(&self) -> ViewState {
let mut order = self.order.clone();
for c in ALL_COLUMNS {
if !order.contains(&c) {
order.push(c);
}
}
let mut visible: HashSet<Column> = self.visible.iter().copied().collect();
visible.insert(Column::Ip); // IP is always shown
let filters: HashMap<Column, ColFilter> = self.filters.iter().cloned().collect();
ViewState { order, visible, sort: self.sort, filters }
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Preset {
pub name: String,
pub view: PresetView,
}
/// The built-in default profile (always present as the first preset).
pub fn default_preset() -> Preset {
let mut order: Vec<Column> = DEFAULT_PROFILE.to_vec();
for c in ALL_COLUMNS {
if !order.contains(&c) {
order.push(c);
}
}
Preset {
name: "Default".to_string(),
view: PresetView {
order,
visible: DEFAULT_PROFILE.to_vec(),
sort: None,
filters: Vec::new(),
},
}
}
/// Load saved presets, always with the built-in "Default" first. A missing or
/// unreadable file yields just the default.
pub fn load_presets() -> Vec<Preset> {
let mut presets = std::fs::read_to_string(config_path(PRESETS_FILE))
.ok()
.and_then(|s| serde_json::from_str::<Vec<Preset>>(&s).ok())
.unwrap_or_default();
// The default profile is always present and always first.
presets.retain(|p| p.name != "Default");
presets.insert(0, default_preset());
presets
}
/// Persist presets (the built-in "Default" is not written; it is re-seeded on
/// load). Best-effort: errors are returned for the caller to surface.
pub fn save_presets(presets: &[Preset]) -> std::io::Result<()> {
let p = config_path(PRESETS_FILE);
if let Some(dir) = p.parent() {
std::fs::create_dir_all(dir)?;
}
let user: Vec<&Preset> = presets.iter().filter(|p| p.name != "Default").collect();
let json = serde_json::to_string_pretty(&user)
.map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?;
std::fs::write(p, json)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn default_preset_round_trips_through_view() {
let p = default_preset();
let view = p.view.to_view();
// IP first + the requested default columns visible.
assert!(view.visible.contains(&Column::Ip));
assert!(view.visible.contains(&Column::Model));
assert!(view.visible.contains(&Column::Error));
assert!(view.visible.contains(&Column::Cpu));
assert!(view.visible.contains(&Column::Hashboards));
assert!(view.visible.contains(&Column::Locked));
// Columns dropped from the default profile in round 11.
assert!(!view.visible.contains(&Column::BoardCode), "not in the default profile");
assert!(!view.visible.contains(&Column::Cooling), "not in the default profile");
// to_view covers every column in `order`.
assert_eq!(view.order.len(), ALL_COLUMNS.len());
// Round-trip a snapshot back out.
let snap = PresetView::from_view(&view);
assert_eq!(snap.visible.first(), Some(&Column::Ip));
}
#[test]
fn preset_json_round_trip() {
let p = default_preset();
let json = serde_json::to_string(&vec![&p]).unwrap();
let back: Vec<Preset> = serde_json::from_str(&json).unwrap();
assert_eq!(back.len(), 1);
assert_eq!(back[0].name, "Default");
assert_eq!(back[0].view.visible, DEFAULT_PROFILE.to_vec());
}
}
+871 -20
View File
@@ -1,10 +1,11 @@
//! Scan engine: drives vendored asic-rs over the configured subnets and
//! streams MinerRow snapshots to the UI thread via a std channel.
use crate::model::MinerRow;
use asic_rs::MinerFactory;
use crate::model::{MinerCaps, MinerRow};
use asic_rs::core::data::firmware::FirmwareImage;
use asic_rs::core::traits::miner::Miner;
use futures_util::StreamExt;
use measurements::Power;
use std::collections::HashSet;
use std::net::Ipv4Addr;
use std::path::PathBuf;
@@ -119,6 +120,32 @@ pub fn parse_line(line: &str) -> Result<Vec<Ipv4Addr>, String> {
}
return Ok((0..count).map(|i| Ipv4Addr::from(base + i as u32)).collect());
}
// Per-octet ranges: each of the four octets may be a single number or an
// inclusive `a-b` range, e.g. "10.1-9.1.1-255" scans the cartesian product
// (the 9 /24s: 10.1.1.x .. 10.9.1.x). This also subsumes a plain single
// address and a bare last-octet range like "10.253.1.3-234".
let parts: Vec<&str> = line.split('.').collect();
if parts.len() == 4 && parts.iter().all(|p| is_octet_spec(p)) {
let r: Vec<(u8, u8)> =
parts.iter().map(|p| parse_octet_spec(p)).collect::<Result<_, String>>()?;
let count: u64 = r.iter().map(|(lo, hi)| (*hi as u64 - *lo as u64 + 1)).product();
if count > MAX_ADDRS {
return Err(format!("range too large (> {MAX_ADDRS} addresses): {line}"));
}
let mut out = Vec::with_capacity(count as usize);
for a in r[0].0..=r[0].1 {
for b in r[1].0..=r[1].1 {
for c in r[2].0..=r[2].1 {
for d in r[3].0..=r[3].1 {
out.push(Ipv4Addr::new(a, b, c, d));
}
}
}
}
return Ok(out);
}
// Full A-B range across two dotted addresses (e.g. "10.0.0.1-10.7.255.254"),
// which the per-octet form above cannot express.
if let Some((start_s, end_s)) = line.split_once('-') {
let start: Ipv4Addr = start_s
.trim()
@@ -147,6 +174,27 @@ pub fn parse_line(line: &str) -> Result<Vec<Ipv4Addr>, String> {
Ok(vec![addr])
}
/// Parse one octet spec: `"n"` -> `(n, n)`, or `"a-b"` -> `(a, b)` inclusive
/// (rejecting `a > b`). Used by the per-octet range form in `parse_line`.
fn parse_octet_spec(s: &str) -> Result<(u8, u8), String> {
let s = s.trim();
if let Some((lo, hi)) = s.split_once('-') {
let lo: u8 = lo.trim().parse().map_err(|_| format!("bad octet range: {s}"))?;
let hi: u8 = hi.trim().parse().map_err(|_| format!("bad octet range: {s}"))?;
if lo > hi {
return Err(format!("octet range start after end: {s}"));
}
Ok((lo, hi))
} else {
let n: u8 = s.parse().map_err(|_| format!("bad octet: {s}"))?;
Ok((n, n))
}
}
fn is_octet_spec(s: &str) -> bool {
parse_octet_spec(s).is_ok()
}
fn prefix_mask(prefix: u8) -> u32 {
if prefix == 0 {
0
@@ -305,7 +353,7 @@ pub fn start_scan(lines: Vec<String>) -> ScanHandle {
}
};
rt.block_on(async move {
let mut factory = MinerFactory::new();
let mut factory = crate::credentials::configured_factory();
for (ip, prefix) in &cidrs {
factory = match factory.with_subnet(&format!("{ip}/{prefix}")) {
Ok(f) => f,
@@ -325,8 +373,13 @@ pub fn start_scan(lines: Vec<String>) -> ScanHandle {
return; // Stop / re-scan requested
}
done += 1;
if let Some(miner) = miner {
let row = to_row(&*miner).await;
// Only surface a row for an address that actually has a miner
// behind it. A non-responding address is not shown -- we never
// fabricate a phantom "offline" row for an empty IP; a miner is
// reported as "not hashing" only when it responds and we can see
// it is not mining.
if let Some(m) = miner {
let row = to_row(&*m).await;
if tx.send(ScanMsg::Row(row)).is_err() {
return; // UI gone
}
@@ -344,6 +397,40 @@ pub fn start_scan(lines: Vec<String>) -> ScanHandle {
ScanHandle { rx, cancel }
}
/// Flatten a miner's structured messages into concise display lines for the
/// Errors column's hover tooltip (the column cell itself shows only the count).
/// Only actionable messages (Error + Warning) are kept -- Info is dropped as
/// noise. Each line is just "message (component)" (no repetitive "[Error]"
/// prefix), duplicates are collapsed, and errors sort before warnings.
fn summarize_messages(messages: &[asic_rs::core::data::message::MinerMessage]) -> Vec<String> {
use asic_rs::core::data::message::MessageSeverity;
let mut ranked: Vec<(u8, String)> = messages
.iter()
.filter_map(|m| {
let rank = match m.severity {
MessageSeverity::Error => 0u8,
MessageSeverity::Warning => 1,
MessageSeverity::Info => return None, // informational, not an error/warning
};
let text = m.message.trim();
if text.is_empty() {
return None;
}
let line = match m.component.as_ref().map(|c| c.to_string()) {
Some(c) if !c.trim().is_empty() => format!("{text} ({})", c.trim()),
_ => text.to_string(),
};
Some((rank, line))
})
.collect();
// Stable sort keeps discovery order within a severity; errors before warnings.
ranked.sort_by_key(|(r, _)| *r);
// Collapse exact duplicates (asic-rs sometimes repeats the same fault per board).
let mut seen = HashSet::new();
ranked.retain(|(_, s)| seen.insert(s.clone()));
ranked.into_iter().map(|(_, s)| s).collect()
}
async fn to_row(miner: &dyn Miner) -> MinerRow {
let data = miner.get_data().await;
let hashrate_ths = data
@@ -362,11 +449,28 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
.as_ref()
.map(|t| t.as_celsius())
.unwrap_or(0.0);
let fan_rpm = data
// Per-hashboard temperature for the "77 / 64 / 74" Chip-temp cell. Prefer the
// board/PCB temperature over the hottest-chip (outlet) reading: WhatsMiner's
// outlet_chip is the max chip temp (~100C on the hottest board), which read
// alarmingly high and didn't match the temperature the miner itself reports;
// the board temperature (~60-79C) is the figure the miner's own UI shows
// (round 12 #3). Falls back to the chip temp when no board temp is reported.
let board_temps: Vec<f64> = data
.hashboards
.iter()
.filter_map(|b| {
b.board_temperature
.as_ref()
.or(b.outlet_chip_temperature.as_ref())
.map(|t| t.as_celsius())
})
.filter(|&t| t > 0.0)
.collect();
let fan_rpms: Vec<f64> = data
.fans
.iter()
.filter_map(|f| f.rpm.as_ref().map(|r| r.as_rpm()))
.fold(0.0f64, f64::max);
.map(|f| f.rpm.as_ref().map(|r| r.as_rpm()).unwrap_or(0.0))
.collect();
let worker = data
.pools
.iter()
@@ -396,17 +500,38 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
)
})
.collect();
let firmware = match (&data.device_info.firmware, &data.firmware_version) {
(fw, Some(v)) if !fw.is_empty() => format!("{fw} {v}"),
(fw, Some(v)) => format!("{fw}{v}"),
(fw, None) => fw.clone(),
// Firmware family (coloured column) and version go in separate columns. Strip
// the vendor word asic-rs prepends on stock firmware ("AntMiner Stock" ->
// "Stock") and carry it into the version instead (round 11 #6).
let (firmware, fw_vendor) = crate::naming::firmware_family(&data.device_info.firmware);
let raw_fw_version = data.firmware_version.clone().unwrap_or_default();
let fw_version = match (fw_vendor, raw_fw_version.is_empty()) {
(Some(vendor), false) => format!("{vendor} {raw_fw_version}"),
(Some(vendor), true) => vendor,
(None, _) => raw_fw_version,
};
let model = if data.device_info.make.is_empty() {
data.device_info.model.clone()
// Split asic-rs's compact make/model identifiers into the human-facing
// Brand / Model / Submodel the table shows (see crate::naming). asic-rs hands
// us "Antminer"/"S19KPro"; we render brand "Antminer", model "S19k Pro".
let make = data.device_info.make.clone();
let model_id = data.device_info.model.clone();
let brand = crate::naming::brand(&make);
let model = crate::naming::clean_model(&make, &model_id);
let submodel = crate::naming::submodel(&make, &model_id);
let raw_board = data.control_board_version.as_ref().map(|c| c.to_string()).unwrap_or_default();
let control_board = crate::naming::control_board_code(&make, &raw_board, &model);
let cpu = crate::naming::control_board_cpu(&make, &raw_board, &model);
let board_code = crate::naming::control_board_board(&make, &raw_board, &model);
// asic-rs has no cooling-type field and reports air-cooled miners' ambient
// reading in `fluid_temperature` (the WhatsMiner backends read the "Env
// Temp"/"environment-temperature" key). Route it to the Env-temp column for
// air-cooled models so it isn't mislabelled as a coolant temp (round 11 #17).
let reported_fluid = data.fluid_temperature.as_ref().map(|t| t.as_celsius()).unwrap_or(0.0);
let (fluid_temp_c, env_temp_c) = if crate::naming::is_liquid_cooled(&model) {
(reported_fluid, 0.0)
} else {
format!("{} {}", data.device_info.make, data.device_info.model)
(0.0, reported_fluid)
};
let fluid_temp_c = data.fluid_temperature.as_ref().map(|t| t.as_celsius()).unwrap_or(0.0);
let outlet_temp_c = data
.outlet_fluid_temperature
.as_ref()
@@ -417,27 +542,107 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
.iter()
.filter_map(|f| f.rpm.as_ref().map(|r| r.as_rpm()))
.fold(0.0f64, f64::max);
let algorithm = data.hashrate.as_ref().map(|h| h.algo.to_string()).unwrap_or_default();
let is_mining = data.is_mining;
let slow = crate::model::is_slow(is_mining, hashrate_ths, expected_ths);
let operating_state = data.operating_state.as_ref().map(|s| s.to_string()).unwrap_or_default();
let paused = crate::model::is_paused(&operating_state, is_mining);
// asic-rs advertises supports_set_power_limit=true unconditionally for whole
// firmware families, VNish included -- where, per operator guidance, the
// power-limit control should not be offered (round-9 #3). Mask it off for
// VNish; Braiins and the rest keep asic-rs's answer.
let power_limit = miner.supports_set_power_limit()
&& !data.device_info.firmware.eq_ignore_ascii_case("VNish");
// Probe what this miner supports being told to do (sync, no extra I/O).
let caps = MinerCaps {
fault_light: miner.supports_set_fault_light(),
restart: miner.supports_restart(),
pause: miner.supports_pause(),
resume: miner.supports_resume(),
power_limit,
tuning: miner.supports_set_tuning_percent(),
firmware_flash: miner.supports_upgrade_firmware(),
};
// PIC vs noPIC is not reported over the network by asic-rs; best-effort
// heuristic from the model string, else unknown (true detection needs an
// on-board SSH/I2C probe -- a separate feature).
let pic_present = if model.to_lowercase().contains("nopic") { Some(false) } else { None };
// Access: locked/view-only when the miner exposes no writable control at
// all, otherwise unlocked. Inferred from capabilities (asic-rs has no direct
// lock-state field).
let write_locked = Some(!caps.any_control());
// Per-hashboard health for the Boards status dots (round 11 #10): green =
// present & hashing, red = present but idle/faulty, grey = expected but not
// detected. Boards keep asic-rs's reported order (board 1 first); any boards
// expected beyond those reported are padded as Missing.
let mut board_status: Vec<crate::model::BoardHealth> = data
.hashboards
.iter()
.map(|b| {
let ok = match (b.active, b.working_chips) {
(Some(a), _) => a,
(None, Some(c)) => c > 0,
(None, None) => true,
};
if ok {
crate::model::BoardHealth::Ok
} else {
crate::model::BoardHealth::Fault
}
})
.collect();
if let Some(exp) = data.expected_hashboards {
while board_status.len() < exp as usize {
board_status.push(crate::model::BoardHealth::Missing);
}
}
let errors = summarize_messages(&data.messages);
MinerRow {
ip: data.ip.to_string(),
selected: false,
caps,
algorithm,
pic_present,
write_locked,
errors,
model,
brand,
submodel,
mac: data.mac.map(|m| m.to_string()).unwrap_or_default(),
hostname: data.hostname.clone().unwrap_or_default(),
serial: data.serial_number.clone().unwrap_or_default(),
serial: {
// Some miners report a placeholder serial ("N/A", "none", ...); show
// those as an empty cell rather than the literal placeholder (round 12).
let s = data.serial_number.clone().unwrap_or_default();
let t = s.trim();
if t.is_empty()
|| t.eq_ignore_ascii_case("n/a")
|| t.eq_ignore_ascii_case("na")
|| t.eq_ignore_ascii_case("none")
|| t.eq_ignore_ascii_case("null")
{
String::new()
} else {
s
}
},
firmware,
fw_version,
api_version: data.api_version.clone().unwrap_or_default(),
control_board: data.control_board_version.as_ref().map(|c| c.to_string()).unwrap_or_default(),
control_board,
cpu,
board_code,
hashrate_ths,
expected_ths,
efficiency: data.efficiency.unwrap_or(0.0),
power_w,
tuning_percent: data.tuning_percent,
chip_temp_c,
board_temps,
fluid_temp_c,
env_temp_c,
outlet_temp_c,
fan_rpm,
fan_rpms,
psu_fan_rpm,
fan_count: (!data.fans.is_empty()).then_some(data.fans.len() as u32),
expected_fans: data.expected_fans.map(|v| v as u32),
@@ -445,6 +650,7 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
expected_chips: data.expected_chips.map(|v| v as u32),
hashboards: (!data.hashboards.is_empty()).then_some(data.hashboards.len() as u32),
expected_hashboards: data.expected_hashboards.map(|v| v as u32),
board_status,
worker,
pool_url,
pools,
@@ -452,13 +658,513 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
session_best_share: data.session_best_share,
uptime_secs: data.uptime.map(|d| d.as_secs()).unwrap_or(0),
light_flashing: data.light_flashing,
operating_state: data.operating_state.as_ref().map(|s| s.to_string()).unwrap_or_default(),
operating_state,
is_mining,
slow,
paused,
}
}
/// A one-shot configuration action applied to a set of miners from the
/// right-click menu.
#[derive(Debug, Clone)]
pub enum ConfigAction {
FaultLight(bool),
Restart,
Pause,
Resume,
PowerLimit(f64), // watts
TuningPercent(u8),
}
impl ConfigAction {
/// Short label for status text and summaries.
pub fn label(&self) -> String {
match self {
ConfigAction::FaultLight(true) => "flash lights on".into(),
ConfigAction::FaultLight(false) => "flash lights off".into(),
ConfigAction::Restart => "restart".into(),
ConfigAction::Pause => "pause".into(),
ConfigAction::Resume => "resume".into(),
ConfigAction::PowerLimit(w) => format!("power limit {w:.0} W"),
ConfigAction::TuningPercent(p) => format!("tuning {p}%"),
}
}
}
/// Progress/results from a running config action.
pub enum ActionMsg {
Started { total: usize },
Result { ip: String, ok: bool, detail: String },
Done { ok: usize, total: usize },
}
/// A running config action; `stop` cancels the remaining miners.
pub struct ActionHandle {
pub rx: Receiver<ActionMsg>,
cancel: Arc<AtomicBool>,
}
impl ActionHandle {
pub fn stop(&self) {
self.cancel.store(true, Ordering::Relaxed);
}
}
async fn apply_action(miner: &dyn Miner, action: &ConfigAction) -> Result<bool, String> {
let result = match action {
ConfigAction::FaultLight(on) => miner.set_fault_light(*on).await,
ConfigAction::Restart => miner.restart().await,
ConfigAction::Pause => miner.pause(None).await,
ConfigAction::Resume => miner.resume(None).await,
ConfigAction::PowerLimit(w) => miner.set_power_limit(Power::from_watts(*w)).await,
ConfigAction::TuningPercent(p) => miner.set_tuning_percent(*p).await,
};
result.map_err(|e| e.to_string())
}
/// Apply `action` to each miner in `ips` on a background thread: re-discover the
/// miner (asic-rs `scan_miner`), run the setter, and report per-IP results. In
/// fake-scan mode it reports simulated successes so the flow works offline.
pub fn start_config_action(ips: Vec<String>, action: ConfigAction) -> ActionHandle {
let (tx, rx) = channel();
let cancel = Arc::new(AtomicBool::new(false));
let total = ips.len();
let _ = tx.send(ActionMsg::Started { total });
if fake_scan_enabled() {
let err_tx = tx.clone();
let thread_cancel = cancel.clone();
let res = std::thread::Builder::new().name("fake-action".into()).spawn(move || {
let mut ok = 0usize;
for ip in ips {
if thread_cancel.load(Ordering::Relaxed) {
break;
}
let _ = tx.send(ActionMsg::Result { ip, ok: true, detail: "simulated".into() });
ok += 1;
}
let _ = tx.send(ActionMsg::Done { ok, total });
});
if res.is_err() {
let _ = err_tx.send(ActionMsg::Done { ok: 0, total });
}
return ActionHandle { rx, cancel };
}
let thread_cancel = cancel.clone();
let err_tx = tx.clone();
let res = std::thread::Builder::new().name("config-action".into()).spawn(move || {
// A single-threaded runtime: the loop applies to one miner at a time, so
// a worker-per-CPU pool would be wasted.
let rt = match tokio::runtime::Builder::new_current_thread().enable_all().build() {
Ok(rt) => rt,
Err(_) => {
let _ = tx.send(ActionMsg::Done { ok: 0, total });
return;
}
};
rt.block_on(async move {
let factory = crate::credentials::configured_factory();
let mut ok = 0usize;
for ip_s in ips {
if thread_cancel.load(Ordering::Relaxed) {
break;
}
let (success, detail) = match ip_s.parse::<std::net::IpAddr>() {
Err(_) => (false, "bad IP".to_string()),
Ok(ip) => match factory.scan_miner(ip).await {
Ok(Some(miner)) => match apply_action(&*miner, &action).await {
Ok(true) => (true, "ok".to_string()),
Ok(false) => (false, "refused".to_string()),
Err(e) => (false, format!("{e}")),
},
Ok(None) => (false, "no miner at IP".to_string()),
Err(e) => (false, format!("{e}")),
},
};
if success {
ok += 1;
}
if tx.send(ActionMsg::Result { ip: ip_s, ok: success, detail }).is_err() {
return; // UI gone
}
}
let _ = tx.send(ActionMsg::Done { ok, total });
});
});
if res.is_err() {
let _ = err_tx.send(ActionMsg::Done { ok: 0, total });
}
ActionHandle { rx, cancel }
}
/// Progress/results from a background refresh of a specific, already-known
/// set of miners (re-poll on a timer or after a right-click "Refresh" action,
/// as opposed to `start_scan`'s full subnet sweep).
pub enum RefreshMsg {
Started { total: usize },
/// A miner's telemetry was re-read successfully.
Row(MinerRow),
/// A miner could not be reached or re-identified.
Failed { ip: String, detail: String },
Done { ok: usize, total: usize },
}
/// A running refresh; `stop` cancels the remaining miners.
pub struct RefreshHandle {
pub rx: Receiver<RefreshMsg>,
cancel: Arc<AtomicBool>,
}
impl RefreshHandle {
pub fn stop(&self) {
self.cancel.store(true, Ordering::Relaxed);
}
}
/// Re-poll a specific list of already-known miner IPs on a background thread:
/// re-discover each one (asic-rs `scan_miner`) and report its fresh row. In
/// fake-scan mode it reports the matching bench-fleet fixture row per IP.
pub fn start_refresh(ips: Vec<String>) -> RefreshHandle {
let (tx, rx) = channel();
let cancel = Arc::new(AtomicBool::new(false));
let total = ips.len();
let _ = tx.send(RefreshMsg::Started { total });
if fake_scan_enabled() {
let err_tx = tx.clone();
let thread_cancel = cancel.clone();
let res = std::thread::Builder::new().name("fake-refresh".into()).spawn(move || {
let fleet = crate::fixtures::bench_fleet();
let mut ok = 0usize;
for ip in ips {
if thread_cancel.load(Ordering::Relaxed) {
break;
}
match fleet.iter().find(|r| r.ip == ip) {
Some(row) => {
if tx.send(RefreshMsg::Row(row.clone())).is_err() {
return; // UI gone
}
ok += 1;
}
None => {
if tx.send(RefreshMsg::Failed { ip, detail: "offline".into() }).is_err() {
return;
}
}
}
}
let _ = tx.send(RefreshMsg::Done { ok, total });
});
if res.is_err() {
let _ = err_tx.send(RefreshMsg::Done { ok: 0, total });
}
return RefreshHandle { rx, cancel };
}
let thread_cancel = cancel.clone();
let err_tx = tx.clone();
let res = std::thread::Builder::new().name("miner-refresh".into()).spawn(move || {
// A single-threaded runtime: the loop applies to one miner at a time, so
// a worker-per-CPU pool would be wasted.
let rt = match tokio::runtime::Builder::new_current_thread().enable_all().build() {
Ok(rt) => rt,
Err(_) => {
let _ = tx.send(RefreshMsg::Done { ok: 0, total });
return;
}
};
rt.block_on(async move {
let factory = crate::credentials::configured_factory();
let mut ok = 0usize;
for ip_s in ips {
if thread_cancel.load(Ordering::Relaxed) {
break;
}
let msg = match ip_s.parse::<std::net::IpAddr>() {
Err(_) => RefreshMsg::Failed { ip: ip_s, detail: "bad IP".to_string() },
Ok(ip) => match factory.scan_miner(ip).await {
Ok(Some(miner)) => {
ok += 1;
RefreshMsg::Row(to_row(&*miner).await)
}
Ok(None) => RefreshMsg::Failed { ip: ip_s, detail: "offline".to_string() },
Err(e) => RefreshMsg::Failed { ip: ip_s, detail: format!("{e}") },
},
};
if tx.send(msg).is_err() {
return; // UI gone
}
}
let _ = tx.send(RefreshMsg::Done { ok, total });
});
});
if res.is_err() {
let _ = err_tx.send(RefreshMsg::Done { ok: 0, total });
}
RefreshHandle { rx, cancel }
}
/// Prepare (if the backend supports it) then upload a firmware image to one
/// miner. Never interrupted once started: `start_firmware_flash_action` only
/// checks its cancel flag between miners, not while this is running.
async fn flash_one(miner: &dyn Miner, image: &FirmwareImage) -> Result<bool, String> {
let image = if miner.supports_prepare_firmware() {
miner.prepare_firmware(image.clone()).await.map_err(|e| e.to_string())?
} else {
image.clone()
};
miner.upgrade_firmware(image).await.map_err(|e| e.to_string())
}
/// Flash `image` to each miner in `ips` on a background thread: re-discover the
/// miner (asic-rs `scan_miner`), then prepare (if supported) and upload the
/// firmware, reporting per-IP results. Backends that don't implement firmware
/// upgrade report "unsupported" rather than attempting anything. The cancel
/// flag is only checked between miners: a flash in progress always runs to
/// completion instead of being interrupted mid-upload. In fake-scan mode it
/// reports simulated successes so the flow works offline.
pub fn start_firmware_flash_action(ips: Vec<String>, image: FirmwareImage) -> ActionHandle {
let (tx, rx) = channel();
let cancel = Arc::new(AtomicBool::new(false));
let total = ips.len();
let _ = tx.send(ActionMsg::Started { total });
if fake_scan_enabled() {
let err_tx = tx.clone();
let thread_cancel = cancel.clone();
let res = std::thread::Builder::new().name("fake-firmware-flash".into()).spawn(move || {
let mut ok = 0usize;
for ip in ips {
if thread_cancel.load(Ordering::Relaxed) {
break;
}
let _ = tx.send(ActionMsg::Result { ip, ok: true, detail: "simulated".into() });
ok += 1;
}
let _ = tx.send(ActionMsg::Done { ok, total });
});
if res.is_err() {
let _ = err_tx.send(ActionMsg::Done { ok: 0, total });
}
return ActionHandle { rx, cancel };
}
let thread_cancel = cancel.clone();
let err_tx = tx.clone();
let res = std::thread::Builder::new().name("firmware-flash".into()).spawn(move || {
// A single-threaded runtime: flashes run one miner at a time by
// design (see the cancel-between-miners note above).
let rt = match tokio::runtime::Builder::new_current_thread().enable_all().build() {
Ok(rt) => rt,
Err(_) => {
let _ = tx.send(ActionMsg::Done { ok: 0, total });
return;
}
};
rt.block_on(async move {
let factory = crate::credentials::configured_factory();
let mut ok = 0usize;
for ip_s in ips {
if thread_cancel.load(Ordering::Relaxed) {
break;
}
let (success, detail) = match ip_s.parse::<std::net::IpAddr>() {
Err(_) => (false, "bad IP".to_string()),
Ok(ip) => match factory.scan_miner(ip).await {
Ok(Some(miner)) => {
if !miner.supports_upgrade_firmware() {
(false, "unsupported".to_string())
} else {
match flash_one(&*miner, &image).await {
Ok(true) => (true, "ok".to_string()),
Ok(false) => (false, "refused".to_string()),
Err(e) => (false, format!("{e}")),
}
}
}
Ok(None) => (false, "no miner at IP".to_string()),
Err(e) => (false, format!("{e}")),
},
};
if success {
ok += 1;
}
if tx.send(ActionMsg::Result { ip: ip_s, ok: success, detail }).is_err() {
return; // UI gone
}
}
let _ = tx.send(ActionMsg::Done { ok, total });
});
});
if res.is_err() {
let _ = err_tx.send(ActionMsg::Done { ok: 0, total });
}
ActionHandle { rx, cancel }
}
/// Progress/results from a background SSH PIC probe of specific miners.
pub enum PicProbeMsg {
Started { total: usize },
/// One miner's PIC result: `pic` = Some(true/false)/None (indeterminate),
/// or `error` set on an SSH/connection failure.
Result { ip: String, pic: Option<bool>, error: Option<String> },
Done { total: usize },
}
/// A running PIC probe; `stop` cancels the remaining miners.
pub struct PicProbeHandle {
pub rx: Receiver<PicProbeMsg>,
cancel: Arc<AtomicBool>,
}
impl PicProbeHandle {
pub fn stop(&self) {
self.cancel.store(true, Ordering::Relaxed);
}
}
/// Probe the PIC state of `targets` (ip + control-board string) over SSH on a
/// background thread, one miner at a time (each is a slow SSH round trip). In
/// fake-scan mode it reports simulated results without touching the network.
pub fn start_pic_probe(
targets: Vec<(String, String)>,
creds: crate::pic_probe::SshCreds,
) -> PicProbeHandle {
let (tx, rx) = channel();
let cancel = Arc::new(AtomicBool::new(false));
let total = targets.len();
let _ = tx.send(PicProbeMsg::Started { total });
if fake_scan_enabled() {
let err_tx = tx.clone();
let thread_cancel = cancel.clone();
let res = std::thread::Builder::new().name("fake-pic-probe".into()).spawn(move || {
for (ip, cb) in targets {
if thread_cancel.load(Ordering::Relaxed) {
break;
}
// Deterministic demo: Antminer S21 (CVITek) noPIC, other
// Antminers PIC, WhatsMiner indeterminate.
let pic = if cb.to_lowercase().contains("cvitek") {
Some(false)
} else if !cb.is_empty() {
Some(true)
} else {
None
};
let _ = tx.send(PicProbeMsg::Result { ip, pic, error: None });
}
let _ = tx.send(PicProbeMsg::Done { total });
});
if res.is_err() {
let _ = err_tx.send(PicProbeMsg::Done { total });
}
return PicProbeHandle { rx, cancel };
}
let thread_cancel = cancel.clone();
let err_tx = tx.clone();
let res = std::thread::Builder::new().name("pic-probe".into()).spawn(move || {
for (ip, cb) in targets {
if thread_cancel.load(Ordering::Relaxed) {
break;
}
let (pic, error) = match crate::pic_probe::probe_pic(&ip, &cb, &creds) {
Ok(v) => (v, None),
Err(e) => (None, Some(e)),
};
if tx.send(PicProbeMsg::Result { ip, pic, error }).is_err() {
return; // UI gone
}
}
let _ = tx.send(PicProbeMsg::Done { total });
});
if res.is_err() {
let _ = err_tx.send(PicProbeMsg::Done { total });
}
PicProbeHandle { rx, cancel }
}
/// Progress/results from a background access (lock-state) probe.
pub enum AccessProbeMsg {
Started { total: usize },
/// `locked` = Some(true) locked/view-only, Some(false) unlocked/writable,
/// None indeterminate; `error` set only when the probe couldn't run.
Result { ip: String, locked: Option<bool>, error: Option<String> },
Done { total: usize },
}
/// A running access probe; `stop` cancels the remaining miners.
pub struct AccessProbeHandle {
pub rx: Receiver<AccessProbeMsg>,
cancel: Arc<AtomicBool>,
}
impl AccessProbeHandle {
pub fn stop(&self) {
self.cancel.store(true, Ordering::Relaxed);
}
}
/// Probe the access/lock state of `targets` (ip + firmware string) over the web
/// API with `creds` (user, pass), on a background thread. A digest-auth GET is
/// fast, but we still run one miner at a time with cancel-between. Fake-scan mode
/// returns deterministic demo results.
pub fn start_access_probe(
targets: Vec<(String, String)>,
creds: (String, String),
) -> AccessProbeHandle {
let (tx, rx) = channel();
let cancel = Arc::new(AtomicBool::new(false));
let total = targets.len();
let _ = tx.send(AccessProbeMsg::Started { total });
let (user, pass) = creds;
if fake_scan_enabled() {
let err_tx = tx.clone();
let thread_cancel = cancel.clone();
let res = std::thread::Builder::new().name("fake-access-probe".into()).spawn(move || {
for (ip, _fw) in targets {
if thread_cancel.load(Ordering::Relaxed) {
break;
}
// Demo: the WardenOS-dev unit (.115) is locked, others unlocked.
let locked = Some(ip.ends_with(".115"));
let _ = tx.send(AccessProbeMsg::Result { ip, locked, error: None });
}
let _ = tx.send(AccessProbeMsg::Done { total });
});
if res.is_err() {
let _ = err_tx.send(AccessProbeMsg::Done { total });
}
return AccessProbeHandle { rx, cancel };
}
let thread_cancel = cancel.clone();
let err_tx = tx.clone();
let res = std::thread::Builder::new().name("access-probe".into()).spawn(move || {
for (ip, fw) in targets {
if thread_cancel.load(Ordering::Relaxed) {
break;
}
let (locked, error) = match crate::access_probe::probe_access(&ip, &fw, &user, &pass) {
Ok(v) => (v, None),
Err(e) => (None, Some(e)),
};
if tx.send(AccessProbeMsg::Result { ip, locked, error }).is_err() {
return; // UI gone
}
}
let _ = tx.send(AccessProbeMsg::Done { total });
});
if res.is_err() {
let _ = err_tx.send(AccessProbeMsg::Done { total });
}
AccessProbeHandle { rx, cancel }
}
#[cfg(test)]
mod tests {
@@ -493,6 +1199,31 @@ mod tests {
assert_eq!(*ips.last().unwrap(), Ipv4Addr::new(10, 253, 1, 234));
}
#[test]
fn parse_per_octet_ranges() {
// The user's example: 9 /24s (octet2 1..9), each with .1.1-255.
let ips = parse_line("10.1-9.1.1-255").unwrap();
assert_eq!(ips.len(), 9 * 255, "9 /24 ranges of 255 addresses each");
assert_eq!(ips[0], Ipv4Addr::new(10, 1, 1, 1), "ascending, first combo");
assert_eq!(*ips.last().unwrap(), Ipv4Addr::new(10, 9, 1, 255));
// Ordered by octet: the second address is .1.1.2, the 256th is .2.1.1.
assert_eq!(ips[1], Ipv4Addr::new(10, 1, 1, 2));
assert_eq!(ips[255], Ipv4Addr::new(10, 2, 1, 1));
// Ranges in more than one octet.
let ips = parse_line("192.168.0-1.10-12").unwrap();
assert_eq!(ips.len(), 2 * 3);
assert_eq!(ips[0], Ipv4Addr::new(192, 168, 0, 10));
assert_eq!(*ips.last().unwrap(), Ipv4Addr::new(192, 168, 1, 12));
// A single address still works through the per-octet path.
assert_eq!(parse_line("10.0.0.5").unwrap(), vec![Ipv4Addr::new(10, 0, 0, 5)]);
// Reversed octet range is an error.
assert!(parse_line("10.9-1.1.1").is_err());
// Out-of-range octet falls through and is reported.
assert!(parse_line("10.1.1.999").is_err());
}
#[test]
fn parse_cross_octet_range() {
let ips = parse_line("10.253.1.250-10.253.2.5").unwrap();
@@ -694,4 +1425,124 @@ mod tests {
println!("bench_targets_to_cidrs_large_range: {} addrs -> {sink} cidrs, {:?}/op", ips.len(), per);
assert!(per.as_millis() < 200, "targets_to_cidrs regressed: {per:?}/op");
}
/// Exercise the round-6 background actions through their fake-scan branch:
/// offline-row emission (start_scan), per-IP refresh (start_refresh),
/// firmware flash (start_firmware_flash_action), and that a cancelled run
/// still terminates. ALKANE_FAKE_SCAN is process-global, but no other test
/// calls these functions, so setting it here only affects this one
/// (sequential) test; all fake-mode assertions live in a single #[test] so
/// they never race each other over the env var.
#[test]
fn fake_mode_background_actions() {
use std::sync::mpsc::RecvTimeoutError;
use std::time::Duration;
let deadline = Duration::from_secs(5);
std::env::set_var(FAKE_SCAN_ENV, "1");
// start_scan (fake): streams exactly the bench-fleet fixtures, one Row
// per fixture, and no fabricated rows for empty addresses.
{
let h = start_scan(vec!["10.255.1.0/30".into()]);
let mut rows = Vec::new();
let mut total = 0usize;
loop {
match h.rx.recv_timeout(deadline) {
Ok(ScanMsg::Started { total: t, .. }) => total = t,
Ok(ScanMsg::Row(r)) => rows.push(r),
Ok(ScanMsg::Done(_)) => break,
Ok(_) => {}
Err(RecvTimeoutError::Timeout) => panic!("fake start_scan hung"),
Err(RecvTimeoutError::Disconnected) => break,
}
}
let fleet = crate::fixtures::bench_fleet();
assert_eq!(rows.len(), fleet.len(), "one Row per fixture, no phantom offline rows");
assert_eq!(total, fleet.len());
assert!(rows.iter().all(|r| r.status() != "offline"), "no 'offline' status exists");
}
// start_refresh: a known fixture IP re-reads as a Row, an unknown IP is
// reported Failed{offline}, and the run ends with Done{ok:1,total:2}.
{
let known = "10.255.1.112".to_string(); // an S17 in bench_fleet
let unknown = "10.0.0.250".to_string();
let h = start_refresh(vec![known.clone(), unknown.clone()]);
let (mut rows, mut failed, mut done) = (0usize, 0usize, None);
loop {
match h.rx.recv_timeout(deadline) {
Ok(RefreshMsg::Started { .. }) => {}
Ok(RefreshMsg::Row(r)) => {
assert_eq!(r.ip, known);
rows += 1;
}
Ok(RefreshMsg::Failed { ip, detail }) => {
assert_eq!(ip, unknown);
assert_eq!(detail, "offline");
failed += 1;
}
Ok(RefreshMsg::Done { ok, total }) => {
done = Some((ok, total));
break;
}
Err(RecvTimeoutError::Timeout) => panic!("fake start_refresh hung"),
Err(RecvTimeoutError::Disconnected) => break,
}
}
assert_eq!(rows, 1);
assert_eq!(failed, 1);
assert_eq!(done, Some((1, 2)));
}
// start_firmware_flash_action: fake mode reports one simulated success
// per IP and a matching Done summary.
{
let image = FirmwareImage::new("fw.bin".to_string(), vec![0u8; 8]);
let h = start_firmware_flash_action(
vec!["10.255.1.166".into(), "10.255.1.149".into()],
image,
);
let (mut results, mut done) = (0usize, None);
loop {
match h.rx.recv_timeout(deadline) {
Ok(ActionMsg::Started { .. }) => {}
Ok(ActionMsg::Result { ok, detail, .. }) => {
assert!(ok);
assert_eq!(detail, "simulated");
results += 1;
}
Ok(ActionMsg::Done { ok, total }) => {
done = Some((ok, total));
break;
}
Err(RecvTimeoutError::Timeout) => panic!("fake flash hung"),
Err(RecvTimeoutError::Disconnected) => break,
}
}
assert_eq!(results, 2);
assert_eq!(done, Some((2, 2)));
}
// Cancellation contract: stopping a run still delivers a terminal Done
// rather than hanging (the fake branches now honour the cancel flag).
{
let big: Vec<String> = (0..200).map(|i| format!("10.9.0.{}", i % 256)).collect();
let h = start_refresh(big);
h.stop();
let mut saw_done = false;
loop {
match h.rx.recv_timeout(deadline) {
Ok(RefreshMsg::Done { .. }) => {
saw_done = true;
break;
}
Ok(_) => {}
Err(_) => break,
}
}
assert!(saw_done, "a cancelled fake refresh must still emit Done, not hang");
}
std::env::remove_var(FAKE_SCAN_ENV);
}
}
+2458 -144
View File
File diff suppressed because it is too large Load Diff
+9 -1
View File
@@ -20,7 +20,15 @@ vendor/ cargo-managed crate sources ONLY (regenerated by
`cargo vendor vendor`; it deletes unmanaged dirs - never
put hand-made trees here; learned the hard way)
thirdparty/
asic-rs lives in vendor/ (pure crates.io dep, cargo-vendored)
asic-rs the vendored crates live in vendor/ (crates.io dep,
VERSION cargo-vendored); this dir holds their patch queue:
patches/ 0001 whatsminer set_power_limit error propagation (#4)
refresh-checksums.py rewrites a vendored crate's .cargo-checksum.json
after a patch (cargo verifies each file's SHA256)
The committed vendor/ tree has the patches applied and the
affected .cargo-checksum.json refreshed, so builds need
nothing extra. On re-vendor, run
scripts/apply-asic-rs-patches.sh to re-apply + refresh.
wxwidgets/
wxWidgets-3.3.3/ pristine release tree, never edited directly
VERSION upstream version + tarball URL + sha256
+33
View File
@@ -0,0 +1,33 @@
#!/bin/bash
# Re-apply the asic-rs patch queue to the cargo-vendored tree and refresh the
# affected crates' .cargo-checksum.json. Run this after `cargo vendor vendor`
# (which regenerates a pristine vendor/ and drops our edits). A normal build
# does NOT need this -- the committed vendor/ tree already has the patches
# applied and checksums refreshed; this is the re-vendoring recipe (ADR 0003).
set -euo pipefail
REPO=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
cd "$REPO"
PATCHES_DIR="thirdparty/asic-rs/patches"
shopt -s nullglob
patches=("$PATCHES_DIR"/*.patch)
if [ ${#patches[@]} -eq 0 ]; then
echo "no patches in $PATCHES_DIR"
exit 0
fi
for p in "${patches[@]}"; do
echo "== applying $p =="
if git apply --check -p1 "$p" 2>/dev/null; then
git apply -p1 "$p"
elif git apply --check -p1 --reverse "$p" 2>/dev/null; then
echo " (already applied -- skipping)"
else
echo "ERROR: $p does not apply cleanly; resolve manually." >&2
exit 1
fi
done
echo "== refreshing checksums for all vendored asic-rs crates =="
python3 thirdparty/asic-rs/refresh-checksums.py --all
echo "done."
+37
View File
@@ -0,0 +1,37 @@
upstream: asic-rs (crates.io)
version: 0.8.1 (cargo-vendored under vendor/, per ADR 0003)
state: pristine cargo-vendored tree + this patch queue.
asic-rs is materialized with `cargo vendor vendor` and consumed through
.cargo/config.toml's vendored-sources replacement (directory = "vendor").
Unlike wx-rs, asic-rs is many crates (asic-rs, asic-rs-core, and the
per-make / per-firmware crates); a change to any of them lives here as a
numbered .patch, NOT as an in-place edit of the pristine tree (ADR 0003).
The committed vendor/ tree already has the patches applied AND its affected
crates' .cargo-checksum.json refreshed, so a normal build needs nothing extra
-- the patch queue is provenance + the re-vendoring recipe.
GOTCHA (cargo caching): cargo fingerprints a registry/vendored crate by
(name, version, source), NOT by file content, so it will REUSE a cached
build of a vendored crate even after its source is edited. CI is unaffected
(fresh target/ each run compiles the patched source). But an incremental
LOCAL build that already compiled the unpatched crate must be forced:
cargo clean -p asic-rs-firmwares-whatsminer # then rebuild
Otherwise the local binary silently keeps the old behaviour.
Update / re-vendor flow:
1. bump the pin in crates/alkane-gui/Cargo.toml, `cargo vendor vendor`
(this regenerates a pristine vendor/ and DROPS our edits)
2. scripts/apply-asic-rs-patches.sh # re-applies patches/ + refreshes checksums
3. resolve any patch that no longer applies, rebuild, commit
patches/:
0001 whatsminer set_power_limit (round-9 #4): fix the v3 (WhatsMinerOS)
privileged auth -- the "super" account's token password is the separate
v3 credential (default "super"), not the web/admin password -- and send
the watts as a bare integer; also treat the apply-restart's transient
RPC error as success. See the patch header.
0002 antminer Equihash (Z15/Z15J) hashrate (round-10 #8): the cgminer "GHS"
key carries a Sol/s value, so use the base Hash unit for Equihash so the
SI prefix is correct ("288k", not "288T"). See the patch header.
@@ -0,0 +1,104 @@
Subject: [PATCH 0001] whatsminer set_power_limit: v3 auth/param fix + restart-tolerant result
Round-9 #4 -- "the power-limit on the WhatsMiners doesn't apply properly" --
root-caused and verified against the live fleet.
v3 backend (WhatsMinerOS, firmware >= 2024-11-01, port 4433): the privileged
power-limit write authenticated the "super" account with the WEB/admin password
(a separate credential; the super account's factory default is "super") and sent
the watts as a float, so the miner rejected every write with "invalid json or
password is wrong". Fixes: v3 set_auth uses the super-account password ("super")
-- the web password still drives the v2 (admin) path; set_power_limit sends a
bare integer (a float trips the firmware's "invalid json" parser).
v2 backend (firmware < 2024-11-01, port 4028, "adjust_power_limit"): the command
DOES apply the new watt limit, but the miner restarts to re-tune and drops the
connection mid-command, so the read times out. Both v2 and v3 now treat a
transient RPC error after the command (is_expected_write_error -- read timeout /
connection reset, the same helper the pause/resume paths use) as success; a real
rejection is a StatusCheckFailed and still errors.
Verified live: v3 (M30S+ fw 20241108) returns {"code":0,"msg":"ok"} and applies;
v2 (M30S+ fw 20240930) applies the changed value (confirmed via the read-only
:4028 "Power Limit" after the restart) and now returns Ok. All test miners were
returned to their prior configured limit. Matches the pyasic / HashSource
whatsminer-api-3 references.
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
index c7b00e3b..096b2fcb 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
@@ -637,11 +637,21 @@ impl SetFaultLight for WhatsMinerV2 {
impl SetPowerLimit for WhatsMinerV2 {
async fn set_power_limit(&self, limit: Power) -> anyhow::Result<bool> {
let parameters = Some(json!({"power_limit": limit.as_watts().to_string()}));
- let data = self
+ match self
.rpc
.send_command("adjust_power_limit", true, parameters)
- .await;
- Ok(data.is_ok())
+ .await
+ {
+ Ok(_) => Ok(true),
+ // adjust_power_limit makes the miner restart to re-tune, so it drops
+ // the connection / stops replying mid-command even though it accepted
+ // and applied the new limit (verified on the live fleet: the set value
+ // settles after the restart). A transient RPC error (read timeout /
+ // connection reset) after the command is therefore success; a genuine
+ // rejection surfaces as StatusCheckFailed and still errors.
+ Err(e) if is_expected_write_error(&e) => Ok(true),
+ Err(e) => Err(e),
+ }
}
fn supports_set_power_limit(&self) -> bool {
true
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
index 77d724d5..c00c6d44 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
@@ -669,12 +669,21 @@ impl SetFaultLight for WhatsMinerV3 {
#[async_trait]
impl SetPowerLimit for WhatsMinerV3 {
async fn set_power_limit(&self, limit: Power) -> anyhow::Result<bool> {
- let data = self
+ // WhatsMinerOS wants a BARE INTEGER watt value; a float ("3000.0")
+ // trips the firmware's "invalid json" parser (round-9 #4).
+ let watts = limit.as_watts().round() as u64;
+ match self
.rpc
- .send_command("set.miner.power_limit", true, Some(json!(limit.as_watts())))
- .await;
-
- Ok(data.is_ok())
+ .send_command("set.miner.power_limit", true, Some(json!(watts)))
+ .await
+ {
+ Ok(_) => Ok(true),
+ // A power-limit change restarts the miner to re-tune, so a transient
+ // RPC error after the command means it was accepted (as with v2), not
+ // rejected; a genuine rejection is a StatusCheckFailed and still errors.
+ Err(e) if is_expected_write_error(&e) => Ok(true),
+ Err(e) => Err(e),
+ }
}
fn supports_set_power_limit(&self) -> bool {
true
@@ -806,8 +815,15 @@ impl HasDefaultAuth for WhatsMinerV3 {
impl HasAuth for WhatsMinerV3 {
fn set_auth(&mut self, auth: MinerAuth) {
- // WhatsMiner V3 username is always "super", V2 is always "admin"
- self.rpc.set_auth(MinerAuth::new("super", auth.password()));
+ // WhatsMiner V3 username is always "super", V2 is always "admin".
+ // The V3 privileged token authenticates against the "super" ACCOUNT,
+ // whose password is a separate v3 credential (factory default "super")
+ // -- NOT the web/admin password carried by `auth`. Pairing account
+ // "super" with the web password made every v3 privileged write fail with
+ // "invalid json or password is wrong" (round-9 #4, confirmed on the live
+ // fleet). Keep the super-account default password here; the web password
+ // still drives the v2 (admin) path below.
+ self.rpc.set_auth(MinerAuth::new("super", "super"));
self.v2_rpc
.set_auth(MinerAuth::new("admin", auth.password()));
}
@@ -0,0 +1,69 @@
Subject: [PATCH 0002] antminer: Equihash (Z15/Z15J) hashrate uses base Sol/s unit
Round-10 #8 -- a Z15 shows its hashrate in 'T' (e.g. "288T") when it should be
'k' (~288 kSol/s). Root cause verified on the live fleet: Equihash miners report
a Sol/s rate in the cgminer "GHS" key, but AntMiner's parse_hashrate takes the
unit from the key name ("GHS" -> GigaHash), scaling the value 1e9x too large.
The value is a raw Sol/s count, so for Equihash use the base Hash unit; the
downstream SI-prefixing then yields "288k". Matched by algorithm, and by "Z15"
model name for the Z15J which asic-rs leaves algo Unknown. Applies to both the
v2020 and v2023_07 backends. Verified: Z15 288T -> 288k, Z15J 138T -> 110k.
diff --git a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
index cd4f7cbd..5b9f77b3 100644
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
@@ -14,7 +14,7 @@ use asic_rs_core::{
DataCollector, DataExtensions, DataExtractor, DataField, DataLocation, get_by_pointer,
},
command::MinerCommand,
- device::DeviceInfo,
+ device::{DeviceInfo, HashAlgorithm},
fan::FanData,
firmware::FirmwareImage,
hashrate::{HashRate, HashRateUnit},
@@ -722,6 +722,15 @@ impl GetHashrate for AntMinerV2020 {
})
})?;
+ // Equihash miners (e.g. Z15/Z15J) report a Sol/s rate in the cgminer
+ // "GHS" key, so the key's GigaHash label is wrong -- the value is the
+ // raw Sol/s count. Use the base unit so the magnitude (and SI prefix)
+ // is correct (e.g. ~288000 Sol/s -> "288k", not "288T"). Match by algo,
+ // and by Z15 model name for the Z15J which asic-rs leaves algo Unknown.
+ let is_equihash = self.device_info.algo == HashAlgorithm::Equihash
+ || self.device_info.model.to_string().to_ascii_uppercase().contains("Z15");
+ let unit = if is_equihash { HashRateUnit::Hash } else { unit };
+
Some(
HashRate {
value,
diff --git a/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs b/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs
index 4ba13537..6d6dc593 100644
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs
@@ -16,7 +16,7 @@ use asic_rs_core::{
DataCollector, DataExtensions, DataExtractor, DataField, DataLocation, get_by_pointer,
},
command::MinerCommand,
- device::DeviceInfo,
+ device::{DeviceInfo, HashAlgorithm},
fan::FanData,
firmware::FirmwareImage,
hashrate::{HashRate, HashRateUnit},
@@ -698,6 +698,15 @@ impl GetHashrate for AntMinerV202307 {
})
})?;
+ // Equihash miners (e.g. Z15/Z15J) report a Sol/s rate in the cgminer
+ // "GHS" key, so the key's GigaHash label is wrong -- the value is the
+ // raw Sol/s count. Use the base unit so the magnitude (and SI prefix)
+ // is correct (e.g. ~288000 Sol/s -> "288k", not "288T"). Match by algo,
+ // and by Z15 model name for the Z15J which asic-rs leaves algo Unknown.
+ let is_equihash = self.device_info.algo == HashAlgorithm::Equihash
+ || self.device_info.model.to_string().to_ascii_uppercase().contains("Z15");
+ let unit = if is_equihash { HashRateUnit::Hash } else { unit };
+
Some(
HashRate {
value,
@@ -0,0 +1,29 @@
Subject: [PATCH 0003] antminer: recognise VNish short control-board platforms (CV, XIL)
Round-11 #5 -- VNish reports the control board in short form via /api/v1/info
"platform": "cv" (CVITek), "xil" (Xilinx), "aml" (AMLogic). asic-rs's
AntMinerControlBoard::parse matched the full names (CVITEK, XILINX) but not the
short "CV"/"XIL", so VNish CVITek and Xilinx boards showed a blank control board
(the "can't scan XIL or CVITek boards" bug). Add the short forms. Verified live:
S19k Pro platform "cv" -> CVITek, S19 platform "xil" -> Xilinx.
diff --git a/vendor/asic-rs-makes-antminer/src/hardware.rs b/vendor/asic-rs-makes-antminer/src/hardware.rs
index 41a73240..aa0923c8 100644
--- a/vendor/asic-rs-makes-antminer/src/hardware.rs
+++ b/vendor/asic-rs-makes-antminer/src/hardware.rs
@@ -268,11 +268,13 @@ impl AntMinerControlBoard {
.collect::<String>();
match compact.as_str() {
- "XILINX" => Some(Self::Xilinx),
+ // "XIL" is VNish's short platform form for a Xilinx control board.
+ "XILINX" | "XIL" => Some(Self::Xilinx),
"BBB" | "BBCTRL" | "BB" | "BEAGLEBONE" | "BEAGLEBONEBLACK" => {
Some(Self::BeagleBoneBlack)
}
- "CVITEK" | "CVCTRL" => Some(Self::CVITek),
+ // "CV" is VNish's short platform form for a CVITek control board.
+ "CVITEK" | "CVCTRL" | "CV" => Some(Self::CVITek),
"AMLOGIC" | "AML" => Some(Self::AMLogic),
"AMCB07" => Some(Self::Xilinx), // Mara FW
"ZYNQ7007" => Some(Self::Xilinx),
@@ -0,0 +1,65 @@
Subject: [PATCH 0004] whatsminer v1: control-board fallback + optional ALLWINNER_ prefix
Round-11 #5 -- older M30S firmware (< 2022.7.29, the v1 backend) often omits
"CB Platform" from the summary RPC, and its parse mandatorily stripped an
"ALLWINNER_" prefix (strip_prefix(..)? -> None when absent), so those units
showed a blank control board. Add get_version /Msg/platform (the source v2 uses)
as a fallback location, and make the ALLWINNER_ strip optional. Verified live:
M30S+ VE40 (fw 20220422, v1) blank -> H6OS.
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
index b4a27db8..f95a22ae 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
@@ -131,14 +131,28 @@ impl GetDataLocations for WhatsMinerV1 {
tag: None,
},
)],
- DataField::ControlBoardVersion => vec![(
- RPC_SUMMARY,
- DataExtractor {
- func: get_by_pointer,
- key: Some("/SUMMARY/0/CB Platform"),
- tag: None,
- },
- )],
+ DataField::ControlBoardVersion => vec![
+ (
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0/CB Platform"),
+ tag: None,
+ },
+ ),
+ // Older M30S firmware (< 2022.7.29, so this v1 backend) often omits
+ // "CB Platform" from summary but still reports the board under
+ // get_version /Msg/platform (the source v2 uses). Fall back to it so
+ // those units don't show a blank control board.
+ (
+ RPC_GET_VERSION,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/Msg/platform"),
+ tag: None,
+ },
+ ),
+ ],
DataField::TuningTarget => vec![(
RPC_SUMMARY,
DataExtractor {
@@ -285,8 +299,12 @@ impl GetControlBoardVersion for WhatsMinerV1 {
) -> Option<MinerControlBoard> {
data.extract::<String>(DataField::ControlBoardVersion)
.and_then(|s| {
- WhatsMinerControlBoard::parse(s.to_uppercase().strip_prefix("ALLWINNER_")?)
- .map(|cb| cb.into())
+ // The "ALLWINNER_" prefix is optional: summary's CB Platform carries
+ // it (e.g. "ALLWINNER_H6"), but the get_version /Msg/platform fallback
+ // does not (e.g. "H6OS"). Strip it only when present.
+ let up = s.to_uppercase();
+ let board = up.strip_prefix("ALLWINNER_").unwrap_or(&up);
+ WhatsMinerControlBoard::parse(board).map(|cb| cb.into())
})
}
}
@@ -0,0 +1,93 @@
Subject: [PATCH 0005] vnish: surface the partner build name in the firmware version
Round-11 #6b/#11 -- VNish /api/v1/info carries a partner/reseller "build_name"
("WildRose", "vnishreturn", ...) alongside "fw_version"; it is shown in the
Hashcore toolkit but asic-rs did not expose it. Point the FirmwareVersion
extractor at /build_name and combine it with the /fw_version number (still on
ApiVersion) in parse_firmware_version, so firmware_version reads "<build>
<version>", e.g. "WildRose 1.2.7". Applies to both the v1_2_0 and v1_3_0
backends. Verified live: S19j Pro -> "WildRose 1.2.7", S19k Pro -> "vnishreturn 1.3.5".
diff --git a/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs b/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs
index 4cc1434a..e734a03e 100644
--- a/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs
+++ b/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs
@@ -179,11 +179,15 @@ impl GetDataLocations for VnishV120 {
tag: None,
},
)],
+ // The partner/reseller build name ("WildRose", "vnishreturn", ...) --
+ // combined with the version number in parse_firmware_version so the FW
+ // Version column shows e.g. "WildRose 1.3.5". ApiVersion still carries
+ // the bare /fw_version.
DataField::FirmwareVersion => vec![(
WEB_INFO,
DataExtractor {
func: get_by_pointer,
- key: Some("/fw_version"),
+ key: Some("/build_name"),
tag: None,
},
)],
@@ -415,7 +419,20 @@ impl GetApiVersion for VnishV120 {
impl GetFirmwareVersion for VnishV120 {
fn parse_firmware_version(&self, data: &HashMap<DataField, Value>) -> Option<String> {
- data.extract::<String>(DataField::FirmwareVersion)
+ // FirmwareVersion carries /build_name (the partner build), ApiVersion the
+ // /fw_version number; show "<build> <version>" when both are present, else
+ // whichever is available.
+ let build = data
+ .extract::<String>(DataField::FirmwareVersion)
+ .filter(|b| !b.is_empty());
+ let version = data
+ .extract::<String>(DataField::ApiVersion)
+ .filter(|v| !v.is_empty());
+ match (build, version) {
+ (Some(b), Some(v)) => Some(format!("{b} {v}")),
+ (Some(b), None) => Some(b),
+ (None, v) => v,
+ }
}
}
diff --git a/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs b/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs
index 6975d9e5..0a5d694e 100644
--- a/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs
+++ b/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs
@@ -179,11 +179,13 @@ impl GetDataLocations for VnishV130 {
tag: None,
},
)],
+ // Partner/reseller build name; combined with the version number in
+ // parse_firmware_version (FW Version shows e.g. "WildRose 1.3.5").
DataField::FirmwareVersion => vec![(
WEB_INFO,
DataExtractor {
func: get_by_pointer,
- key: Some("/fw_version"),
+ key: Some("/build_name"),
tag: None,
},
)],
@@ -423,7 +425,19 @@ impl GetApiVersion for VnishV130 {
impl GetFirmwareVersion for VnishV130 {
fn parse_firmware_version(&self, data: &HashMap<DataField, Value>) -> Option<String> {
- data.extract::<String>(DataField::FirmwareVersion)
+ // FirmwareVersion carries /build_name (partner build), ApiVersion the
+ // /fw_version number; show "<build> <version>" when both are present.
+ let build = data
+ .extract::<String>(DataField::FirmwareVersion)
+ .filter(|b| !b.is_empty());
+ let version = data
+ .extract::<String>(DataField::ApiVersion)
+ .filter(|v| !v.is_empty());
+ match (build, version) {
+ (Some(b), Some(v)) => Some(format!("{b} {v}")),
+ (Some(b), None) => Some(b),
+ (None, v) => v,
+ }
}
}
+74
View File
@@ -0,0 +1,74 @@
#!/usr/bin/env python3
"""Refresh the .cargo-checksum.json of vendored asic-rs crates after the patch
queue (thirdparty/asic-rs/patches/) has been applied to the cargo-vendored tree.
cargo verifies each vendored file against the per-file SHA256 in that crate's
.cargo-checksum.json; a patched file whose checksum is stale fails the build. For
every crate named on the command line (or, with --all, every asic-rs* crate under
vendor/), this recomputes the SHA256 of each file already listed in the manifest
and rewrites it, preserving the top-level "package"/"$comment" keys. Files not
listed are left alone (cargo only checks listed files).
Usage:
refresh-checksums.py <crate-dir> [<crate-dir> ...]
refresh-checksums.py --all # every vendor/asic-rs* crate
"""
import hashlib
import json
import sys
from pathlib import Path
REPO = Path(__file__).resolve().parents[2]
VENDOR = REPO / "vendor"
def sha256(path: Path) -> str:
h = hashlib.sha256()
with open(path, "rb") as f:
for chunk in iter(lambda: f.read(1 << 16), b""):
h.update(chunk)
return h.hexdigest()
def refresh(crate_dir: Path) -> int:
manifest = crate_dir / ".cargo-checksum.json"
if not manifest.exists():
print(f"skip {crate_dir.name}: no .cargo-checksum.json")
return 0
data = json.loads(manifest.read_text())
files = data.get("files", {})
changed = 0
for rel in list(files):
fp = crate_dir / rel
if not fp.exists():
print(f" WARN {crate_dir.name}: listed file missing: {rel}")
continue
new = sha256(fp)
if new != files[rel]:
files[rel] = new
changed += 1
if changed:
manifest.write_text(json.dumps(data, separators=(",", ":")))
print(f"{crate_dir.name}: refreshed {changed} checksum(s)")
else:
print(f"{crate_dir.name}: no changes")
return changed
def main() -> None:
args = sys.argv[1:]
if not args:
print(__doc__)
sys.exit(2)
if args == ["--all"]:
crates = sorted(p for p in VENDOR.glob("asic-rs*") if p.is_dir())
else:
crates = [Path(a) if Path(a).is_absolute() else (VENDOR / a) for a in args]
total = 0
for c in crates:
total += refresh(c)
print(f"done: {total} checksum(s) refreshed across {len(crates)} crate(s)")
if __name__ == "__main__":
main()
+234 -1
View File
@@ -10,7 +10,7 @@
+pub use widgets::*;
--- a/src/widgets.rs
+++ b/src/widgets.rs
@@ -0,0 +1,561 @@
@@ -0,0 +1,794 @@
+// widgets.rs — alkane-toolkit extension: Rust bindings for the widget bridge
+// in cpp_src/widgets_bridge.cpp. Handles are opaque pointers owned by the
+// wxWidgets object tree (parents own children; nothing to free in Rust).
@@ -28,6 +28,7 @@
+ pub fn wxbr_main_frame() -> *mut c_void;
+ pub fn wxbr_panel(parent: *mut c_void) -> *mut c_void;
+ pub fn wxbr_box_sizer(vertical: c_int) -> *mut c_void;
+ pub fn wxbr_wrap_sizer(vertical: c_int) -> *mut c_void;
+ pub fn wxbr_sizer_add(sizer: *mut c_void, win: *mut c_void, proportion: c_int, flags: c_int, border: c_int);
+ pub fn wxbr_sizer_add_sizer(sizer: *mut c_void, subsizer: *mut c_void, proportion: c_int, flags: c_int, border: c_int);
+ pub fn wxbr_sizer_add_spacer(sizer: *mut c_void, px: c_int);
@@ -35,6 +36,8 @@
+ pub fn wxbr_set_sizer(win: *mut c_void, sizer: *mut c_void);
+ pub fn wxbr_layout(win: *mut c_void);
+ pub fn wxbr_sizer_detach(sizer: *mut c_void, win: *mut c_void);
+ pub fn wxbr_sizer_show(sizer: *mut c_void, win: *mut c_void, show: c_int);
+ pub fn wxbr_bind_size(win: *mut c_void);
+ pub fn wxbr_fit(win: *mut c_void);
+ pub fn wxbr_set_min_size(win: *mut c_void, w: c_int, h: c_int);
+ pub fn wxbr_static_text(parent: *mut c_void, label: *const c_char) -> *mut c_void;
@@ -43,6 +46,7 @@
+ pub fn wxbr_set_bold(win: *mut c_void);
+ pub fn wxbr_set_font_size(win: *mut c_void, pts: c_int);
+ pub fn wxbr_button(parent: *mut c_void, label: *const c_char, id: c_int) -> *mut c_void;
+ pub fn wxbr_bind_click(win: *mut c_void, id: c_int);
+ 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);
@@ -59,16 +63,20 @@
+ pub fn wxbr_dialog(parent: *mut c_void, title: *const c_char) -> *mut c_void;
+ 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_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;
+ pub fn wxbr_dvlc_append_toggle_col(win: *mut c_void, width: c_int);
+ pub fn wxbr_dvlc_append_row(win: *mut c_void, nvals: c_int, vals: *const *const c_char);
+ pub fn wxbr_dvlc_delete_row(win: *mut c_void, row: usize);
+ pub fn wxbr_dvlc_clear(win: *mut c_void);
+ pub fn wxbr_dvlc_row_count(win: *mut c_void) -> c_int;
+ pub fn wxbr_dvlc_set_cell(win: *mut c_void, row: usize, col: usize, value: *const c_char);
+ pub fn wxbr_dvlc_set_cell_tooltip(win: *mut c_void, row: usize, col: usize, text: *const c_char);
+ pub fn wxbr_dvlc_get_cell(win: *mut c_void, row: usize, col: usize, buf: *mut c_char, cap: c_int) -> c_int;
+ pub fn wxbr_dvlc_col_count(win: *mut c_void) -> c_int;
+ pub fn wxbr_dvlc_autosize_col(win: *mut c_void, pos: c_int);
+ pub fn wxbr_dvlc_set_col_title(win: *mut c_void, col: c_int, title: *const c_char);
+ pub fn wxbr_dvlc_set_sort_indicator(win: *mut c_void, col: c_int, active: c_int, ascending: c_int);
+ pub fn wxbr_dvlc_col_at_pos(win: *mut c_void, pos: c_int) -> c_int;
@@ -77,9 +85,15 @@
+ pub fn wxbr_dvlc_get_selections(win: *mut c_void, buf: *mut c_int, cap: c_int) -> c_int;
+ pub fn wxbr_dvlc_select_rows(win: *mut c_void, rows: *const c_int, n: c_int);
+ pub fn wxbr_dvlc_set_alt_row_color(win: *mut c_void, r: c_int, g: c_int, b: c_int);
+ pub fn wxbr_dvlc_set_row_color(win: *mut c_void, row: usize, r: c_int, g: c_int, b: c_int);
+ pub fn wxbr_dvlc_set_zebra(win: *mut c_void, r: c_int, g: c_int, b: c_int);
+ pub fn wxbr_dvlc_get_top_row(win: *mut c_void) -> c_int;
+ pub fn wxbr_dvlc_ensure_visible(win: *mut c_void, row: usize);
+ pub fn wxbr_apply_zebra_css(r: c_int, g: c_int, b: c_int);
+ pub fn wxbr_rearrange_list(parent: *mut c_void, n: c_int, order: *const c_int, items: *const *const c_char) -> *mut c_void;
+ pub fn wxbr_rearrange_get_order(win: *mut c_void, buf: *mut c_int, cap: c_int) -> c_int;
+ pub fn wxbr_reorder_list(parent: *mut c_void, n: c_int, order: *const c_int, items: *const *const c_char) -> *mut c_void;
+ pub fn wxbr_reorder_get_order(win: *mut c_void, buf: *mut c_int, cap: c_int) -> c_int;
+ pub fn wxbr_menu_new() -> *mut c_void;
+ pub fn wxbr_menu_append(menu: *mut c_void, id: c_int, label: *const c_char);
+ pub fn wxbr_menu_append_separator(menu: *mut c_void);
@@ -96,7 +110,19 @@
+ pub fn wxbr_system_color(which: c_int, r: *mut u8, g: *mut u8, b: *mut u8);
+ pub fn wxbr_set_bg(win: *mut c_void, r: c_int, g: c_int, b: c_int);
+ pub fn wxbr_set_fg(win: *mut c_void, r: c_int, g: c_int, b: c_int);
+ pub fn wxbr_choice(parent: *mut c_void, id: c_int) -> *mut c_void;
+ pub fn wxbr_choice_append(win: *mut c_void, label: *const c_char);
+ pub fn wxbr_choice_clear(win: *mut c_void);
+ pub fn wxbr_choice_get_selection(win: *mut c_void) -> c_int;
+ pub fn wxbr_choice_set_selection(win: *mut c_void, i: c_int);
+ pub fn wxbr_media_button(parent: *mut c_void, id: c_int, kind: c_int, r: c_int, g: c_int, b: c_int) -> *mut c_void;
+ pub fn wxbr_svg_icon(parent: *mut c_void, svg: *const c_char, w: c_int, h: c_int) -> *mut c_void;
+ pub fn wxbr_bind_sys_colour(win: *mut c_void);
+ pub fn wxbr_destroy(win: *mut c_void);
+ pub fn wxbr_destroy_children(win: *mut c_void);
+ pub fn wxbr_call_after(id: c_int);
+ pub fn wxbr_status_indicator_init(frame: *mut c_void);
+ pub fn wxbr_status_indicator_set(text: *const c_char, r: c_int, g: c_int, b: c_int);
+ }
+}
+
@@ -129,6 +155,12 @@
+ DvlcSelectionChanged,
+ DvlcContextMenu,
+ MenuItem,
+ ChoiceChanged,
+ SysColour,
+ Deferred,
+ DvlcHeaderRightClick,
+ /// Window resized; p1 = new client width, p2 = new client height.
+ Sized,
+}
+
+impl WxEventKind {
@@ -144,6 +176,11 @@
+ 9 => WxEventKind::DvlcSelectionChanged,
+ 10 => WxEventKind::DvlcContextMenu,
+ 11 => WxEventKind::MenuItem,
+ 12 => WxEventKind::ChoiceChanged,
+ 13 => WxEventKind::SysColour,
+ 14 => WxEventKind::Deferred,
+ 15 => WxEventKind::DvlcHeaderRightClick,
+ 16 => WxEventKind::Sized,
+ _ => return None,
+ })
+ }
@@ -154,6 +191,28 @@
+ unsafe { notsafe::wxbr_apply_zebra_css(r as c_int, g as c_int, b as c_int) }
+}
+
+/// Schedule a deferred action: a `Deferred` event carrying `id` is delivered
+/// from the event loop after the current event finishes. Use this to rebuild or
+/// destroy a control from outside its own event handler.
+pub fn call_after(id: i32) {
+ unsafe { notsafe::wxbr_call_after(id as c_int) }
+}
+
+/// Reconfigure the frame's status bar to two fields and attach a colour-tinted
+/// label pinned to the right-hand field (bottom-right corner). Call once after
+/// `create_status_bar()`. The main scan status keeps using the left field via
+/// the upstream `set_status_text` path.
+pub fn status_indicator_init(frame: Widget) {
+ unsafe { notsafe::wxbr_status_indicator_init(frame.0) }
+}
+
+/// Set the bottom-right status indicator's text and colour (an empty string
+/// clears it). Used for scan/apply errors (red) and warnings (amber).
+pub fn status_indicator_set(text: &str, r: u8, g: u8, b: u8) {
+ let c = CString::new(text).unwrap_or_default();
+ unsafe { notsafe::wxbr_status_indicator_set(c.as_ptr(), r as c_int, g as c_int, b as c_int) }
+}
+
+/// Open a URL in the system default browser. Returns true on success.
+pub fn launch_browser(url: &str) -> bool {
+ let c = CString::new(url).unwrap_or_default();
@@ -229,6 +288,14 @@
+ Widget(unsafe { notsafe::wxbr_box_sizer(vertical as c_int) })
+ }
+
+ /// A box sizer that wraps overflowing items onto additional lines instead
+ /// of shrinking them. wxWrapSizer is a wxBoxSizer subclass, so the result
+ /// accepts the same add/add_sizer/add_spacer/add_stretch/set_sizer_on
+ /// calls as `box_sizer`'s.
+ pub fn wrap_sizer(vertical: bool) -> Widget {
+ Widget(unsafe { notsafe::wxbr_wrap_sizer(vertical as c_int) })
+ }
+
+ pub fn add(&self, win: Widget, proportion: i32, flags: i32, border: i32) {
+ unsafe { notsafe::wxbr_sizer_add(self.0, win.0, proportion, flags, border) }
+ }
@@ -262,6 +329,18 @@
+ unsafe { notsafe::wxbr_sizer_detach(self.0, win.0) }
+ }
+
+ /// Show or hide a child window in this sizer (self = a sizer), reclaiming or
+ /// restoring its space on the next `layout()`.
+ pub fn sizer_show(&self, win: Widget, show: bool) {
+ unsafe { notsafe::wxbr_sizer_show(self.0, win.0, show as c_int) }
+ }
+
+ /// Emit `WxEventKind::Sized` (p1 = width, p2 = height) whenever this window
+ /// is resized.
+ pub fn bind_size(&self) {
+ unsafe { notsafe::wxbr_bind_size(self.0) }
+ }
+
+ pub fn fit(&self, win: Widget) {
+ unsafe { notsafe::wxbr_fit(win.0) }
+ }
@@ -305,6 +384,15 @@
+ Widget(unsafe { notsafe::wxbr_button(parent.0, c.as_ptr(), id) })
+ }
+
+ /// Make this window clickable: a left mouse down on it emits the same
+ /// `ButtonClicked` event a real button would, carrying `id`. Bind each
+ /// child that should also count as part of the click target (e.g. the
+ /// static text labels on a KPI card), since a child window swallows its
+ /// own mouse events rather than letting them propagate to the parent.
+ pub fn bind_click(&self, id: i32) {
+ unsafe { notsafe::wxbr_bind_click(self.0, id) }
+ }
+
+ pub fn text_ctrl(parent: Widget, multiline: bool) -> Widget {
+ Widget(unsafe { notsafe::wxbr_text_ctrl(parent.0, multiline as c_int) })
+ }
@@ -384,6 +472,21 @@
+ unsafe { notsafe::wxbr_dialog_close(self.0, code) }
+ }
+
+ /// Show a native "open file, must exist" dialog. Returns the chosen path,
+ /// or `None` if the dialog was cancelled.
+ pub fn file_dialog(parent: Widget, title: &str) -> Option<String> {
+ let c = CString::new(title).unwrap_or_default();
+ let mut buf = vec![0i8; 4096];
+ let n = unsafe {
+ notsafe::wxbr_file_dialog(parent.0, c.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 {
@@ -395,6 +498,14 @@
+ unsafe { notsafe::wxbr_dvlc_append_text_col(self.0, c.as_ptr(), width, reorderable as c_int) }
+ }
+
+ /// Like `dvlc_append_text_col`, but the column renders cell values through
+ /// the SegmentRenderer, so a value built with `model::encode_segments` is
+ /// drawn as coloured text runs (a plain string still renders normally).
+ pub fn dvlc_append_colored_col(&self, title: &str, width: i32, reorderable: bool) {
+ let c = CString::new(title).unwrap_or_default();
+ unsafe { notsafe::wxbr_dvlc_append_colored_col(self.0, c.as_ptr(), width, reorderable as c_int) };
+ }
+
+ pub fn dvlc_append_toggle_col(&self, width: i32) {
+ unsafe { notsafe::wxbr_dvlc_append_toggle_col(self.0, width) }
+ }
@@ -422,6 +533,13 @@
+ unsafe { notsafe::wxbr_dvlc_set_cell(self.0, row, col, c.as_ptr()) }
+ }
+
+ /// Set the hover tooltip for one cell (empty clears it). GTK only; a no-op
+ /// on other platforms until they gain per-cell tooltip support.
+ pub fn dvlc_set_cell_tooltip(&self, row: usize, col: usize, text: &str) {
+ let c = CString::new(text).unwrap_or_default();
+ unsafe { notsafe::wxbr_dvlc_set_cell_tooltip(self.0, row, col, c.as_ptr()) }
+ }
+
+ pub fn dvlc_get_cell(&self, row: usize, col: usize) -> Option<String> {
+ let mut buf = vec![0i8; 4096];
+ let n = unsafe {
@@ -438,6 +556,11 @@
+ unsafe { notsafe::wxbr_dvlc_col_count(self.0).max(0) as usize }
+ }
+
+ /// Auto-size the column at display position `pos` to fit its content.
+ pub fn dvlc_autosize_col(&self, pos: usize) {
+ unsafe { notsafe::wxbr_dvlc_autosize_col(self.0, pos as c_int) }
+ }
+
+ /// Model column index shown at display position `pos` (after drag reorder).
+ pub fn dvlc_col_at_pos(&self, pos: usize) -> Option<usize> {
+ let v = unsafe { notsafe::wxbr_dvlc_col_at_pos(self.0, pos as c_int) };
@@ -472,6 +595,36 @@
+ unsafe { notsafe::wxbr_dvlc_set_alt_row_color(self.0, r as c_int, g as c_int, b as c_int) }
+ }
+
+ /// Set a row's text colour (e.g. by miner status). Pass `None` to clear it.
+ pub fn dvlc_set_row_color(&self, row: usize, color: Option<(u8, u8, u8)>) {
+ let (r, g, b) = match color {
+ Some((r, g, b)) => (r as c_int, g as c_int, b as c_int),
+ None => (-1, -1, -1),
+ };
+ unsafe { notsafe::wxbr_dvlc_set_row_color(self.0, row, r, g, b) }
+ }
+
+ /// Set the alternating-row (zebra) background colour applied to odd rows.
+ /// Pass `None` to turn zebra striping off.
+ pub fn dvlc_set_zebra(&self, color: Option<(u8, u8, u8)>) {
+ let (r, g, b) = match color {
+ Some((r, g, b)) => (r as c_int, g as c_int, b as c_int),
+ None => (-1, -1, -1),
+ };
+ unsafe { notsafe::wxbr_dvlc_set_zebra(self.0, r, g, b) }
+ }
+
+ /// The model-row index of the top (first visible) row, or `None` if empty.
+ pub fn dvlc_get_top_row(&self) -> Option<usize> {
+ let r = unsafe { notsafe::wxbr_dvlc_get_top_row(self.0) };
+ (r >= 0).then_some(r as usize)
+ }
+
+ /// Scroll so `row` is visible (used to restore scroll position after a refill).
+ pub fn dvlc_ensure_visible(&self, row: usize) {
+ unsafe { notsafe::wxbr_dvlc_ensure_visible(self.0, row) }
+ }
+
+ // ---- rearrangeable check-list ----
+
+ /// Create a rearrangeable checklist. `order` uses wx encoding: a value `v`
@@ -493,6 +646,27 @@
+ buf.into_iter().take(n.max(0) as usize).collect()
+ }
+
+ /// A checkable, multi-select, drag-reorderable column list (round 11 #4):
+ /// like `rearrange_list` but with no up/down buttons -- rows are reordered by
+ /// dragging, and selected with shift/ctrl-click or a rubber-band drag. Same
+ /// `[idx | !idx]` order encoding.
+ pub fn reorder_list(parent: Widget, order: &[i32], items: &[&str]) -> Widget {
+ let cs: Vec<CString> = items.iter().map(|s| CString::new(*s).unwrap_or_default()).collect();
+ let ptrs: Vec<*const c_char> = cs.iter().map(|c| c.as_ptr()).collect();
+ Widget(unsafe {
+ notsafe::wxbr_reorder_list(parent.0, items.len() as c_int, order.as_ptr(), ptrs.as_ptr())
+ })
+ }
+
+ /// Read back the current order from a `reorder_list` (same encoding).
+ pub fn reorder_get_order(&self) -> Vec<i32> {
+ let mut buf = vec![0i32; 4096];
+ let n = unsafe {
+ notsafe::wxbr_reorder_get_order(self.0, buf.as_mut_ptr(), buf.len() as c_int)
+ };
+ buf.into_iter().take(n.max(0) as usize).collect()
+ }
+
+ // ---- popup menu ----
+
+ pub fn menu_new() -> Widget {
@@ -566,9 +740,68 @@
+ unsafe { notsafe::wxbr_set_fg(self.0, r as c_int, g as c_int, b as c_int) }
+ }
+
+ // ---- choice (dropdown) ----
+
+ /// Create a dropdown; selection changes emit `ChoiceChanged` with this id.
+ pub fn choice(parent: Widget, id: i32) -> Widget {
+ Widget(unsafe { notsafe::wxbr_choice(parent.0, id) })
+ }
+
+ pub fn choice_append(&self, label: &str) {
+ let c = CString::new(label).unwrap_or_default();
+ unsafe { notsafe::wxbr_choice_append(self.0, c.as_ptr()) }
+ }
+
+ pub fn choice_clear(&self) {
+ unsafe { notsafe::wxbr_choice_clear(self.0) }
+ }
+
+ pub fn choice_get_selection(&self) -> i32 {
+ unsafe { notsafe::wxbr_choice_get_selection(self.0) }
+ }
+
+ pub fn choice_set_selection(&self, i: i32) {
+ unsafe { notsafe::wxbr_choice_set_selection(self.0, i) }
+ }
+
+ // ---- media (icon) button ----
+
+ /// A coloured icon button: `kind` 0=play, 1=pause, 2=stop. Clicks emit
+ /// `ButtonClicked` with `id`, like a normal button.
+ pub fn media_button(parent: Widget, id: i32, kind: i32, color: (u8, u8, u8)) -> Widget {
+ Widget(unsafe {
+ notsafe::wxbr_media_button(
+ parent.0,
+ id,
+ kind,
+ color.0 as c_int,
+ color.1 as c_int,
+ color.2 as c_int,
+ )
+ })
+ }
+
+ /// Render an SVG string (recolour it first -- its fill must be an explicit
+ /// colour, not "currentColor") into a static-bitmap icon at `w`x`h` px
+ /// (round 11 #15).
+ pub fn svg_icon(parent: Widget, svg: &str, w: i32, h: i32) -> Widget {
+ let c = CString::new(svg).unwrap_or_default();
+ Widget(unsafe { notsafe::wxbr_svg_icon(parent.0, c.as_ptr(), w as c_int, h as c_int) })
+ }
+
+ /// Listen for OS light/dark theme changes on this window (emits `SysColour`).
+ pub fn bind_sys_colour(&self) {
+ unsafe { notsafe::wxbr_bind_sys_colour(self.0) }
+ }
+
+ /// Deferred destruction (safe from event handlers); used to rebuild
+ /// the table when its column set changes.
+ pub fn destroy(&self) {
+ unsafe { notsafe::wxbr_destroy(self.0) }
+ }
+
+ /// Destroy this window's children (to rebuild dynamic panel contents).
+ pub fn destroy_children(&self) {
+ unsafe { notsafe::wxbr_destroy_children(self.0) }
+ }
+}
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
+233
View File
@@ -15,6 +15,7 @@ mod notsafe {
pub fn wxbr_main_frame() -> *mut c_void;
pub fn wxbr_panel(parent: *mut c_void) -> *mut c_void;
pub fn wxbr_box_sizer(vertical: c_int) -> *mut c_void;
pub fn wxbr_wrap_sizer(vertical: c_int) -> *mut c_void;
pub fn wxbr_sizer_add(sizer: *mut c_void, win: *mut c_void, proportion: c_int, flags: c_int, border: c_int);
pub fn wxbr_sizer_add_sizer(sizer: *mut c_void, subsizer: *mut c_void, proportion: c_int, flags: c_int, border: c_int);
pub fn wxbr_sizer_add_spacer(sizer: *mut c_void, px: c_int);
@@ -22,6 +23,8 @@ mod notsafe {
pub fn wxbr_set_sizer(win: *mut c_void, sizer: *mut c_void);
pub fn wxbr_layout(win: *mut c_void);
pub fn wxbr_sizer_detach(sizer: *mut c_void, win: *mut c_void);
pub fn wxbr_sizer_show(sizer: *mut c_void, win: *mut c_void, show: c_int);
pub fn wxbr_bind_size(win: *mut c_void);
pub fn wxbr_fit(win: *mut c_void);
pub fn wxbr_set_min_size(win: *mut c_void, w: c_int, h: c_int);
pub fn wxbr_static_text(parent: *mut c_void, label: *const c_char) -> *mut c_void;
@@ -30,6 +33,7 @@ mod notsafe {
pub fn wxbr_set_bold(win: *mut c_void);
pub fn wxbr_set_font_size(win: *mut c_void, pts: c_int);
pub fn wxbr_button(parent: *mut c_void, label: *const c_char, id: c_int) -> *mut c_void;
pub fn wxbr_bind_click(win: *mut c_void, id: c_int);
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);
@@ -46,16 +50,20 @@ mod notsafe {
pub fn wxbr_dialog(parent: *mut c_void, title: *const c_char) -> *mut c_void;
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_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;
pub fn wxbr_dvlc_append_toggle_col(win: *mut c_void, width: c_int);
pub fn wxbr_dvlc_append_row(win: *mut c_void, nvals: c_int, vals: *const *const c_char);
pub fn wxbr_dvlc_delete_row(win: *mut c_void, row: usize);
pub fn wxbr_dvlc_clear(win: *mut c_void);
pub fn wxbr_dvlc_row_count(win: *mut c_void) -> c_int;
pub fn wxbr_dvlc_set_cell(win: *mut c_void, row: usize, col: usize, value: *const c_char);
pub fn wxbr_dvlc_set_cell_tooltip(win: *mut c_void, row: usize, col: usize, text: *const c_char);
pub fn wxbr_dvlc_get_cell(win: *mut c_void, row: usize, col: usize, buf: *mut c_char, cap: c_int) -> c_int;
pub fn wxbr_dvlc_col_count(win: *mut c_void) -> c_int;
pub fn wxbr_dvlc_autosize_col(win: *mut c_void, pos: c_int);
pub fn wxbr_dvlc_set_col_title(win: *mut c_void, col: c_int, title: *const c_char);
pub fn wxbr_dvlc_set_sort_indicator(win: *mut c_void, col: c_int, active: c_int, ascending: c_int);
pub fn wxbr_dvlc_col_at_pos(win: *mut c_void, pos: c_int) -> c_int;
@@ -64,9 +72,15 @@ mod notsafe {
pub fn wxbr_dvlc_get_selections(win: *mut c_void, buf: *mut c_int, cap: c_int) -> c_int;
pub fn wxbr_dvlc_select_rows(win: *mut c_void, rows: *const c_int, n: c_int);
pub fn wxbr_dvlc_set_alt_row_color(win: *mut c_void, r: c_int, g: c_int, b: c_int);
pub fn wxbr_dvlc_set_row_color(win: *mut c_void, row: usize, r: c_int, g: c_int, b: c_int);
pub fn wxbr_dvlc_set_zebra(win: *mut c_void, r: c_int, g: c_int, b: c_int);
pub fn wxbr_dvlc_get_top_row(win: *mut c_void) -> c_int;
pub fn wxbr_dvlc_ensure_visible(win: *mut c_void, row: usize);
pub fn wxbr_apply_zebra_css(r: c_int, g: c_int, b: c_int);
pub fn wxbr_rearrange_list(parent: *mut c_void, n: c_int, order: *const c_int, items: *const *const c_char) -> *mut c_void;
pub fn wxbr_rearrange_get_order(win: *mut c_void, buf: *mut c_int, cap: c_int) -> c_int;
pub fn wxbr_reorder_list(parent: *mut c_void, n: c_int, order: *const c_int, items: *const *const c_char) -> *mut c_void;
pub fn wxbr_reorder_get_order(win: *mut c_void, buf: *mut c_int, cap: c_int) -> c_int;
pub fn wxbr_menu_new() -> *mut c_void;
pub fn wxbr_menu_append(menu: *mut c_void, id: c_int, label: *const c_char);
pub fn wxbr_menu_append_separator(menu: *mut c_void);
@@ -83,7 +97,19 @@ mod notsafe {
pub fn wxbr_system_color(which: c_int, r: *mut u8, g: *mut u8, b: *mut u8);
pub fn wxbr_set_bg(win: *mut c_void, r: c_int, g: c_int, b: c_int);
pub fn wxbr_set_fg(win: *mut c_void, r: c_int, g: c_int, b: c_int);
pub fn wxbr_choice(parent: *mut c_void, id: c_int) -> *mut c_void;
pub fn wxbr_choice_append(win: *mut c_void, label: *const c_char);
pub fn wxbr_choice_clear(win: *mut c_void);
pub fn wxbr_choice_get_selection(win: *mut c_void) -> c_int;
pub fn wxbr_choice_set_selection(win: *mut c_void, i: c_int);
pub fn wxbr_media_button(parent: *mut c_void, id: c_int, kind: c_int, r: c_int, g: c_int, b: c_int) -> *mut c_void;
pub fn wxbr_svg_icon(parent: *mut c_void, svg: *const c_char, w: c_int, h: c_int) -> *mut c_void;
pub fn wxbr_bind_sys_colour(win: *mut c_void);
pub fn wxbr_destroy(win: *mut c_void);
pub fn wxbr_destroy_children(win: *mut c_void);
pub fn wxbr_call_after(id: c_int);
pub fn wxbr_status_indicator_init(frame: *mut c_void);
pub fn wxbr_status_indicator_set(text: *const c_char, r: c_int, g: c_int, b: c_int);
}
}
@@ -116,6 +142,12 @@ pub enum WxEventKind {
DvlcSelectionChanged,
DvlcContextMenu,
MenuItem,
ChoiceChanged,
SysColour,
Deferred,
DvlcHeaderRightClick,
/// Window resized; p1 = new client width, p2 = new client height.
Sized,
}
impl WxEventKind {
@@ -131,6 +163,11 @@ impl WxEventKind {
9 => WxEventKind::DvlcSelectionChanged,
10 => WxEventKind::DvlcContextMenu,
11 => WxEventKind::MenuItem,
12 => WxEventKind::ChoiceChanged,
13 => WxEventKind::SysColour,
14 => WxEventKind::Deferred,
15 => WxEventKind::DvlcHeaderRightClick,
16 => WxEventKind::Sized,
_ => return None,
})
}
@@ -141,6 +178,28 @@ pub fn apply_zebra_css(r: u8, g: u8, b: u8) {
unsafe { notsafe::wxbr_apply_zebra_css(r as c_int, g as c_int, b as c_int) }
}
/// Schedule a deferred action: a `Deferred` event carrying `id` is delivered
/// from the event loop after the current event finishes. Use this to rebuild or
/// destroy a control from outside its own event handler.
pub fn call_after(id: i32) {
unsafe { notsafe::wxbr_call_after(id as c_int) }
}
/// Reconfigure the frame's status bar to two fields and attach a colour-tinted
/// label pinned to the right-hand field (bottom-right corner). Call once after
/// `create_status_bar()`. The main scan status keeps using the left field via
/// the upstream `set_status_text` path.
pub fn status_indicator_init(frame: Widget) {
unsafe { notsafe::wxbr_status_indicator_init(frame.0) }
}
/// Set the bottom-right status indicator's text and colour (an empty string
/// clears it). Used for scan/apply errors (red) and warnings (amber).
pub fn status_indicator_set(text: &str, r: u8, g: u8, b: u8) {
let c = CString::new(text).unwrap_or_default();
unsafe { notsafe::wxbr_status_indicator_set(c.as_ptr(), r as c_int, g as c_int, b as c_int) }
}
/// Open a URL in the system default browser. Returns true on success.
pub fn launch_browser(url: &str) -> bool {
let c = CString::new(url).unwrap_or_default();
@@ -216,6 +275,14 @@ impl Widget {
Widget(unsafe { notsafe::wxbr_box_sizer(vertical as c_int) })
}
/// A box sizer that wraps overflowing items onto additional lines instead
/// of shrinking them. wxWrapSizer is a wxBoxSizer subclass, so the result
/// accepts the same add/add_sizer/add_spacer/add_stretch/set_sizer_on
/// calls as `box_sizer`'s.
pub fn wrap_sizer(vertical: bool) -> Widget {
Widget(unsafe { notsafe::wxbr_wrap_sizer(vertical as c_int) })
}
pub fn add(&self, win: Widget, proportion: i32, flags: i32, border: i32) {
unsafe { notsafe::wxbr_sizer_add(self.0, win.0, proportion, flags, border) }
}
@@ -249,6 +316,18 @@ impl Widget {
unsafe { notsafe::wxbr_sizer_detach(self.0, win.0) }
}
/// Show or hide a child window in this sizer (self = a sizer), reclaiming or
/// restoring its space on the next `layout()`.
pub fn sizer_show(&self, win: Widget, show: bool) {
unsafe { notsafe::wxbr_sizer_show(self.0, win.0, show as c_int) }
}
/// Emit `WxEventKind::Sized` (p1 = width, p2 = height) whenever this window
/// is resized.
pub fn bind_size(&self) {
unsafe { notsafe::wxbr_bind_size(self.0) }
}
pub fn fit(&self, win: Widget) {
unsafe { notsafe::wxbr_fit(win.0) }
}
@@ -292,6 +371,15 @@ impl Widget {
Widget(unsafe { notsafe::wxbr_button(parent.0, c.as_ptr(), id) })
}
/// Make this window clickable: a left mouse down on it emits the same
/// `ButtonClicked` event a real button would, carrying `id`. Bind each
/// child that should also count as part of the click target (e.g. the
/// static text labels on a KPI card), since a child window swallows its
/// own mouse events rather than letting them propagate to the parent.
pub fn bind_click(&self, id: i32) {
unsafe { notsafe::wxbr_bind_click(self.0, id) }
}
pub fn text_ctrl(parent: Widget, multiline: bool) -> Widget {
Widget(unsafe { notsafe::wxbr_text_ctrl(parent.0, multiline as c_int) })
}
@@ -371,6 +459,21 @@ impl Widget {
unsafe { notsafe::wxbr_dialog_close(self.0, code) }
}
/// Show a native "open file, must exist" dialog. Returns the chosen path,
/// or `None` if the dialog was cancelled.
pub fn file_dialog(parent: Widget, title: &str) -> Option<String> {
let c = CString::new(title).unwrap_or_default();
let mut buf = vec![0i8; 4096];
let n = unsafe {
notsafe::wxbr_file_dialog(parent.0, c.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 {
@@ -382,6 +485,14 @@ impl Widget {
unsafe { notsafe::wxbr_dvlc_append_text_col(self.0, c.as_ptr(), width, reorderable as c_int) }
}
/// Like `dvlc_append_text_col`, but the column renders cell values through
/// the SegmentRenderer, so a value built with `model::encode_segments` is
/// drawn as coloured text runs (a plain string still renders normally).
pub fn dvlc_append_colored_col(&self, title: &str, width: i32, reorderable: bool) {
let c = CString::new(title).unwrap_or_default();
unsafe { notsafe::wxbr_dvlc_append_colored_col(self.0, c.as_ptr(), width, reorderable as c_int) };
}
pub fn dvlc_append_toggle_col(&self, width: i32) {
unsafe { notsafe::wxbr_dvlc_append_toggle_col(self.0, width) }
}
@@ -409,6 +520,13 @@ impl Widget {
unsafe { notsafe::wxbr_dvlc_set_cell(self.0, row, col, c.as_ptr()) }
}
/// Set the hover tooltip for one cell (empty clears it). GTK only; a no-op
/// on other platforms until they gain per-cell tooltip support.
pub fn dvlc_set_cell_tooltip(&self, row: usize, col: usize, text: &str) {
let c = CString::new(text).unwrap_or_default();
unsafe { notsafe::wxbr_dvlc_set_cell_tooltip(self.0, row, col, c.as_ptr()) }
}
pub fn dvlc_get_cell(&self, row: usize, col: usize) -> Option<String> {
let mut buf = vec![0i8; 4096];
let n = unsafe {
@@ -425,6 +543,11 @@ impl Widget {
unsafe { notsafe::wxbr_dvlc_col_count(self.0).max(0) as usize }
}
/// Auto-size the column at display position `pos` to fit its content.
pub fn dvlc_autosize_col(&self, pos: usize) {
unsafe { notsafe::wxbr_dvlc_autosize_col(self.0, pos as c_int) }
}
/// Model column index shown at display position `pos` (after drag reorder).
pub fn dvlc_col_at_pos(&self, pos: usize) -> Option<usize> {
let v = unsafe { notsafe::wxbr_dvlc_col_at_pos(self.0, pos as c_int) };
@@ -459,6 +582,36 @@ impl Widget {
unsafe { notsafe::wxbr_dvlc_set_alt_row_color(self.0, r as c_int, g as c_int, b as c_int) }
}
/// Set a row's text colour (e.g. by miner status). Pass `None` to clear it.
pub fn dvlc_set_row_color(&self, row: usize, color: Option<(u8, u8, u8)>) {
let (r, g, b) = match color {
Some((r, g, b)) => (r as c_int, g as c_int, b as c_int),
None => (-1, -1, -1),
};
unsafe { notsafe::wxbr_dvlc_set_row_color(self.0, row, r, g, b) }
}
/// Set the alternating-row (zebra) background colour applied to odd rows.
/// Pass `None` to turn zebra striping off.
pub fn dvlc_set_zebra(&self, color: Option<(u8, u8, u8)>) {
let (r, g, b) = match color {
Some((r, g, b)) => (r as c_int, g as c_int, b as c_int),
None => (-1, -1, -1),
};
unsafe { notsafe::wxbr_dvlc_set_zebra(self.0, r, g, b) }
}
/// The model-row index of the top (first visible) row, or `None` if empty.
pub fn dvlc_get_top_row(&self) -> Option<usize> {
let r = unsafe { notsafe::wxbr_dvlc_get_top_row(self.0) };
(r >= 0).then_some(r as usize)
}
/// Scroll so `row` is visible (used to restore scroll position after a refill).
pub fn dvlc_ensure_visible(&self, row: usize) {
unsafe { notsafe::wxbr_dvlc_ensure_visible(self.0, row) }
}
// ---- rearrangeable check-list ----
/// Create a rearrangeable checklist. `order` uses wx encoding: a value `v`
@@ -480,6 +633,27 @@ impl Widget {
buf.into_iter().take(n.max(0) as usize).collect()
}
/// A checkable, multi-select, drag-reorderable column list (round 11 #4):
/// like `rearrange_list` but with no up/down buttons -- rows are reordered by
/// dragging, and selected with shift/ctrl-click or a rubber-band drag. Same
/// `[idx | !idx]` order encoding.
pub fn reorder_list(parent: Widget, order: &[i32], items: &[&str]) -> Widget {
let cs: Vec<CString> = items.iter().map(|s| CString::new(*s).unwrap_or_default()).collect();
let ptrs: Vec<*const c_char> = cs.iter().map(|c| c.as_ptr()).collect();
Widget(unsafe {
notsafe::wxbr_reorder_list(parent.0, items.len() as c_int, order.as_ptr(), ptrs.as_ptr())
})
}
/// Read back the current order from a `reorder_list` (same encoding).
pub fn reorder_get_order(&self) -> Vec<i32> {
let mut buf = vec![0i32; 4096];
let n = unsafe {
notsafe::wxbr_reorder_get_order(self.0, buf.as_mut_ptr(), buf.len() as c_int)
};
buf.into_iter().take(n.max(0) as usize).collect()
}
// ---- popup menu ----
pub fn menu_new() -> Widget {
@@ -553,9 +727,68 @@ impl Widget {
unsafe { notsafe::wxbr_set_fg(self.0, r as c_int, g as c_int, b as c_int) }
}
// ---- choice (dropdown) ----
/// Create a dropdown; selection changes emit `ChoiceChanged` with this id.
pub fn choice(parent: Widget, id: i32) -> Widget {
Widget(unsafe { notsafe::wxbr_choice(parent.0, id) })
}
pub fn choice_append(&self, label: &str) {
let c = CString::new(label).unwrap_or_default();
unsafe { notsafe::wxbr_choice_append(self.0, c.as_ptr()) }
}
pub fn choice_clear(&self) {
unsafe { notsafe::wxbr_choice_clear(self.0) }
}
pub fn choice_get_selection(&self) -> i32 {
unsafe { notsafe::wxbr_choice_get_selection(self.0) }
}
pub fn choice_set_selection(&self, i: i32) {
unsafe { notsafe::wxbr_choice_set_selection(self.0, i) }
}
// ---- media (icon) button ----
/// A coloured icon button: `kind` 0=play, 1=pause, 2=stop. Clicks emit
/// `ButtonClicked` with `id`, like a normal button.
pub fn media_button(parent: Widget, id: i32, kind: i32, color: (u8, u8, u8)) -> Widget {
Widget(unsafe {
notsafe::wxbr_media_button(
parent.0,
id,
kind,
color.0 as c_int,
color.1 as c_int,
color.2 as c_int,
)
})
}
/// Render an SVG string (recolour it first -- its fill must be an explicit
/// colour, not "currentColor") into a static-bitmap icon at `w`x`h` px
/// (round 11 #15).
pub fn svg_icon(parent: Widget, svg: &str, w: i32, h: i32) -> Widget {
let c = CString::new(svg).unwrap_or_default();
Widget(unsafe { notsafe::wxbr_svg_icon(parent.0, c.as_ptr(), w as c_int, h as c_int) })
}
/// Listen for OS light/dark theme changes on this window (emits `SysColour`).
pub fn bind_sys_colour(&self) {
unsafe { notsafe::wxbr_bind_sys_colour(self.0) }
}
/// Deferred destruction (safe from event handlers); used to rebuild
/// the table when its column set changes.
pub fn destroy(&self) {
unsafe { notsafe::wxbr_destroy(self.0) }
}
/// Destroy this window's children (to rebuild dynamic panel contents).
pub fn destroy_children(&self) {
unsafe { notsafe::wxbr_destroy_children(self.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":"eceda61bfe623493964bda3f6164cdb376be0f1112102dd2895524728fca33de","src/backends/v2020/rpc.rs":"2b24bbb432b302dd15f7a354054fc96c6a75cac2c8e75b8bcc11da37255a05a3","src/backends/v2020/web.rs":"d39b67ed83781b2c4fa84a445b9ffe785ae3001941f800ad9860e050c61c6506","src/backends/v2023_07/firmware.rs":"c07668e351d48dab3e24511b1aa9ab5e408bbcb5a438fdb0542a1377f94b9bbb","src/backends/v2023_07/mod.rs":"8cf8031c39f283bd8531de81b7811db48451aff92328a3676aaffdb3cc96fbad","src/backends/v2023_07/rpc.rs":"2b24bbb432b302dd15f7a354054fc96c6a75cac2c8e75b8bcc11da37255a05a3","src/backends/v2023_07/web.rs":"d39b67ed83781b2c4fa84a445b9ffe785ae3001941f800ad9860e050c61c6506","src/firmware.rs":"55d5b722632c0a5cfcf1f8c8252a88c5a1ece887173bb513cca0b22b874d628f","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"a3ef4d6805bb4f8ea087e3a9b875e5a1664580e1ff3e3cd2015bb0c5c18ae7bb","src/test/json/v2020/devs.json":"df17cdfc9522e23450702b93f70ff701892db54c6ce6d986300453ad5e0d22db","src/test/json/v2020/mod.rs":"4c2512d36af834d400a865a94c2e8b1919f9d8dcbf54ab2530c73861c51af67d","src/test/json/v2020/pools.json":"4c4d19ad3ef0de84bfb18daaa48428b5f7917d23287c0196eacf3a6e389e7634","src/test/json/v2020/stats.json":"6d3cb463abb7539ae77aa44ef38e62a5dc0db54670aeacf3bbd01e83f49aa1fd","src/test/json/v2020/summary.json":"2f18c81f989b7c5f70dcb0ddac0520e56ec98b6da25c24e59354a6126c965dae","src/test/json/v2020/system_info.json":"51d1ce922e39a254518a24be56ca86ef1b5843582fb26c1ff0ec4ff6f8f91ccf","src/test/json/v2020/version.json":"ae898c4c9ea3462c3e79f9de755f1fccb4ef122b94a4a512e61aa74491c1a8e9","src/test/json/v2023_07/l11_stats.json":"2eab324f253ced9a0ea4e46466691e0e71fc6fde7558fec86bd5acf6bb9c717d","src/test/json/v2023_07/l11_summary.json":"1e0fdb61b968005d0ec5393d9dc889b09efb1398ffa427629bcc0a98d1b67c22","src/test/json/v2023_07/l11_version.json":"d116921a71731c6e492aed109731c39561e34a24c7df2a88d11ac52b80f6100a","src/test/json/v2023_07/l9_stats.json":"731ee545f16dafd356d22703248b91a37f74585ad73cc27441eb3461ce53dca0","src/test/json/v2023_07/l9_summary.json":"b32b5131ad46859b270d2dbb6bdba3c4e5d7301298daee4ce56332c98faaf81d","src/test/json/v2023_07/l9_version.json":"82f03ca6ea8873f12c4d9455f21b98c547801b58fbff1dcd83c837c0f337a129","src/test/json/v2023_07/mod.rs":"1360a8b155b120f2e755ede0736bcc0d76a9d1d693b984a1b51a16e6c0413791","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"0c06e3ecbf95ae3fe5e30aacae55cf6e7ad3d965f4a93b2f85c7b64f61fc75e2"}
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"6e42d50107b1a43fd7cf4a4c4f538468a337ed219ad8d6b23bd9abdabd123bd5","Cargo.lock":"7f984c7231c91f2def8f3e2e923a85c2e0b3239492f5ce23400881ea4de1aa16","Cargo.toml":"8a447efc18cd97d019a9771fb258b06f694499500561564eec75480e46bcc554","Cargo.toml.orig":"6c9e7b86804255debe03545c6358eb975d3d470810a19e6c40c680299a686b1f","src/backends/mod.rs":"65cdc60cdf38968f5a7e197338f4cf6173406ce69a4f0aaa96a9e29f4f581b6e","src/backends/v2020/firmware.rs":"5a41bfb8f42f17523e68f8702e87d75bcdb268bd4950bb66227f6966ef3576a9","src/backends/v2020/mod.rs":"f1972769a1b4811d5772e96b2e6c45b461cdcb4175355dba2b586b9df776fc1d","src/backends/v2020/rpc.rs":"2b24bbb432b302dd15f7a354054fc96c6a75cac2c8e75b8bcc11da37255a05a3","src/backends/v2020/web.rs":"d39b67ed83781b2c4fa84a445b9ffe785ae3001941f800ad9860e050c61c6506","src/backends/v2023_07/firmware.rs":"c07668e351d48dab3e24511b1aa9ab5e408bbcb5a438fdb0542a1377f94b9bbb","src/backends/v2023_07/mod.rs":"278e4dd04a753858e12df96ead3522aef0616ebf6f27b3da4f1a12b064c19ee6","src/backends/v2023_07/rpc.rs":"2b24bbb432b302dd15f7a354054fc96c6a75cac2c8e75b8bcc11da37255a05a3","src/backends/v2023_07/web.rs":"d39b67ed83781b2c4fa84a445b9ffe785ae3001941f800ad9860e050c61c6506","src/firmware.rs":"55d5b722632c0a5cfcf1f8c8252a88c5a1ece887173bb513cca0b22b874d628f","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"a3ef4d6805bb4f8ea087e3a9b875e5a1664580e1ff3e3cd2015bb0c5c18ae7bb","src/test/json/v2020/devs.json":"df17cdfc9522e23450702b93f70ff701892db54c6ce6d986300453ad5e0d22db","src/test/json/v2020/mod.rs":"4c2512d36af834d400a865a94c2e8b1919f9d8dcbf54ab2530c73861c51af67d","src/test/json/v2020/pools.json":"4c4d19ad3ef0de84bfb18daaa48428b5f7917d23287c0196eacf3a6e389e7634","src/test/json/v2020/stats.json":"6d3cb463abb7539ae77aa44ef38e62a5dc0db54670aeacf3bbd01e83f49aa1fd","src/test/json/v2020/summary.json":"2f18c81f989b7c5f70dcb0ddac0520e56ec98b6da25c24e59354a6126c965dae","src/test/json/v2020/system_info.json":"51d1ce922e39a254518a24be56ca86ef1b5843582fb26c1ff0ec4ff6f8f91ccf","src/test/json/v2020/version.json":"ae898c4c9ea3462c3e79f9de755f1fccb4ef122b94a4a512e61aa74491c1a8e9","src/test/json/v2023_07/l11_stats.json":"2eab324f253ced9a0ea4e46466691e0e71fc6fde7558fec86bd5acf6bb9c717d","src/test/json/v2023_07/l11_summary.json":"1e0fdb61b968005d0ec5393d9dc889b09efb1398ffa427629bcc0a98d1b67c22","src/test/json/v2023_07/l11_version.json":"d116921a71731c6e492aed109731c39561e34a24c7df2a88d11ac52b80f6100a","src/test/json/v2023_07/l9_stats.json":"731ee545f16dafd356d22703248b91a37f74585ad73cc27441eb3461ce53dca0","src/test/json/v2023_07/l9_summary.json":"b32b5131ad46859b270d2dbb6bdba3c4e5d7301298daee4ce56332c98faaf81d","src/test/json/v2023_07/l9_version.json":"82f03ca6ea8873f12c4d9455f21b98c547801b58fbff1dcd83c837c0f337a129","src/test/json/v2023_07/mod.rs":"1360a8b155b120f2e755ede0736bcc0d76a9d1d693b984a1b51a16e6c0413791","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"0c06e3ecbf95ae3fe5e30aacae55cf6e7ad3d965f4a93b2f85c7b64f61fc75e2"}
+10 -1
View File
@@ -14,7 +14,7 @@ use asic_rs_core::{
DataCollector, DataExtensions, DataExtractor, DataField, DataLocation, get_by_pointer,
},
command::MinerCommand,
device::DeviceInfo,
device::{DeviceInfo, HashAlgorithm},
fan::FanData,
firmware::FirmwareImage,
hashrate::{HashRate, HashRateUnit},
@@ -722,6 +722,15 @@ impl GetHashrate for AntMinerV2020 {
})
})?;
// Equihash miners (e.g. Z15/Z15J) report a Sol/s rate in the cgminer
// "GHS" key, so the key's GigaHash label is wrong -- the value is the
// raw Sol/s count. Use the base unit so the magnitude (and SI prefix)
// is correct (e.g. ~288000 Sol/s -> "288k", not "288T"). Match by algo,
// and by Z15 model name for the Z15J which asic-rs leaves algo Unknown.
let is_equihash = self.device_info.algo == HashAlgorithm::Equihash
|| self.device_info.model.to_string().to_ascii_uppercase().contains("Z15");
let unit = if is_equihash { HashRateUnit::Hash } else { unit };
Some(
HashRate {
value,
@@ -16,7 +16,7 @@ use asic_rs_core::{
DataCollector, DataExtensions, DataExtractor, DataField, DataLocation, get_by_pointer,
},
command::MinerCommand,
device::DeviceInfo,
device::{DeviceInfo, HashAlgorithm},
fan::FanData,
firmware::FirmwareImage,
hashrate::{HashRate, HashRateUnit},
@@ -698,6 +698,15 @@ impl GetHashrate for AntMinerV202307 {
})
})?;
// Equihash miners (e.g. Z15/Z15J) report a Sol/s rate in the cgminer
// "GHS" key, so the key's GigaHash label is wrong -- the value is the
// raw Sol/s count. Use the base unit so the magnitude (and SI prefix)
// is correct (e.g. ~288000 Sol/s -> "288k", not "288T"). Match by algo,
// and by Z15 model name for the Z15J which asic-rs leaves algo Unknown.
let is_equihash = self.device_info.algo == HashAlgorithm::Equihash
|| self.device_info.model.to_string().to_ascii_uppercase().contains("Z15");
let unit = if is_equihash { HashRateUnit::Hash } else { unit };
Some(
HashRate {
value,
+1 -1
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":"de321c89f62a60690ba07d6bb145ac688c6141c458638e68b3ed36b50b8de1f1","Cargo.lock":"5942ec7c9cf5c201bd32442d65020dc3ae72e33cb5aaf374b2a26501571a1487","Cargo.toml":"cb9ee00cbb415fa66a71a7d4822839bb3552336ec9ab975ae7b1137c711449cb","Cargo.toml.orig":"08409c395e4d502015da62e97efdc9c5bc6e3076031144f3f5aa35c900c7c735","src/backends/mod.rs":"26591e67688f8d015242295dde5050c4b34986e9980018a855346291a0472206","src/backends/v1_2_0/mod.rs":"c87949458cf3c73ef957b319abc1a39c4755d709d7e3cf5ea9b9b326eb054605","src/backends/v1_2_0/web.rs":"ac89f16bf623f7d85590d34b45c99b0e522d9d434b4c22af7fa8a8a653e09d2e","src/backends/v1_3_0/mod.rs":"722301b45abe8177269cc008a528ae5c5b122f4d0ced28aaa5bee6b5b9f0c062","src/backends/v1_3_0/web.rs":"1ec4cbe6bdc26f165d9e54e9bf2aac4c3706357ce4677dc21113710d4a26c3c1","src/firmware.rs":"168eeffaef90cb1525bb2e126e73905b5205d49215437263813e30323f6b7a05","src/lib.rs":"16ea1c0007fa6d6c86c1f83d3ac9cdf065cd9936cd52f35ef89c227397bbc54a","src/timezone.rs":"309bf23de1bdc9126bde5db8dabff0d2c0fea797dbf2630a772a18539838a05e"},"package":"1cb662e56f104c0fe45c8ccdac13f60cbcaad45ac228f939c6ac46ff40335052"}
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"de321c89f62a60690ba07d6bb145ac688c6141c458638e68b3ed36b50b8de1f1","Cargo.lock":"5942ec7c9cf5c201bd32442d65020dc3ae72e33cb5aaf374b2a26501571a1487","Cargo.toml":"cb9ee00cbb415fa66a71a7d4822839bb3552336ec9ab975ae7b1137c711449cb","Cargo.toml.orig":"08409c395e4d502015da62e97efdc9c5bc6e3076031144f3f5aa35c900c7c735","src/backends/mod.rs":"26591e67688f8d015242295dde5050c4b34986e9980018a855346291a0472206","src/backends/v1_2_0/mod.rs":"fc68a12769890e18231255c6a53cb2c68e4706a887d91f49113c6192684340d2","src/backends/v1_2_0/web.rs":"ac89f16bf623f7d85590d34b45c99b0e522d9d434b4c22af7fa8a8a653e09d2e","src/backends/v1_3_0/mod.rs":"0bba1bf94e7a86d763dbedda3bb5d68cf760e17f744204b0bbc0de4e3754f795","src/backends/v1_3_0/web.rs":"1ec4cbe6bdc26f165d9e54e9bf2aac4c3706357ce4677dc21113710d4a26c3c1","src/firmware.rs":"168eeffaef90cb1525bb2e126e73905b5205d49215437263813e30323f6b7a05","src/lib.rs":"16ea1c0007fa6d6c86c1f83d3ac9cdf065cd9936cd52f35ef89c227397bbc54a","src/timezone.rs":"309bf23de1bdc9126bde5db8dabff0d2c0fea797dbf2630a772a18539838a05e"},"package":"1cb662e56f104c0fe45c8ccdac13f60cbcaad45ac228f939c6ac46ff40335052"}
+19 -2
View File
@@ -179,11 +179,15 @@ impl GetDataLocations for VnishV120 {
tag: None,
},
)],
// The partner/reseller build name ("WildRose", "vnishreturn", ...) --
// combined with the version number in parse_firmware_version so the FW
// Version column shows e.g. "WildRose 1.3.5". ApiVersion still carries
// the bare /fw_version.
DataField::FirmwareVersion => vec![(
WEB_INFO,
DataExtractor {
func: get_by_pointer,
key: Some("/fw_version"),
key: Some("/build_name"),
tag: None,
},
)],
@@ -415,7 +419,20 @@ impl GetApiVersion for VnishV120 {
impl GetFirmwareVersion for VnishV120 {
fn parse_firmware_version(&self, data: &HashMap<DataField, Value>) -> Option<String> {
data.extract::<String>(DataField::FirmwareVersion)
// FirmwareVersion carries /build_name (the partner build), ApiVersion the
// /fw_version number; show "<build> <version>" when both are present, else
// whichever is available.
let build = data
.extract::<String>(DataField::FirmwareVersion)
.filter(|b| !b.is_empty());
let version = data
.extract::<String>(DataField::ApiVersion)
.filter(|v| !v.is_empty());
match (build, version) {
(Some(b), Some(v)) => Some(format!("{b} {v}")),
(Some(b), None) => Some(b),
(None, v) => v,
}
}
}
+16 -2
View File
@@ -179,11 +179,13 @@ impl GetDataLocations for VnishV130 {
tag: None,
},
)],
// Partner/reseller build name; combined with the version number in
// parse_firmware_version (FW Version shows e.g. "WildRose 1.3.5").
DataField::FirmwareVersion => vec![(
WEB_INFO,
DataExtractor {
func: get_by_pointer,
key: Some("/fw_version"),
key: Some("/build_name"),
tag: None,
},
)],
@@ -423,7 +425,19 @@ impl GetApiVersion for VnishV130 {
impl GetFirmwareVersion for VnishV130 {
fn parse_firmware_version(&self, data: &HashMap<DataField, Value>) -> Option<String> {
data.extract::<String>(DataField::FirmwareVersion)
// FirmwareVersion carries /build_name (partner build), ApiVersion the
// /fw_version number; show "<build> <version>" when both are present.
let build = data
.extract::<String>(DataField::FirmwareVersion)
.filter(|b| !b.is_empty());
let version = data
.extract::<String>(DataField::ApiVersion)
.filter(|v| !v.is_empty());
match (build, version) {
(Some(b), Some(v)) => Some(format!("{b} {v}")),
(Some(b), None) => Some(b),
(None, v) => v,
}
}
}
+1 -1
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":"80f3915f1e87c6f7483e9bd0e5b1fb5552f8d017634c82eea6150fe5134b171f","src/backends/v1/rpc.rs":"4cee9caeb9bc291c4efec04f4b7fc2b8eaead904a1f2d0f30e13236476d9aac5","src/backends/v2/mod.rs":"a1a054eda0b1466b8ae1693f47d6f2d79cc0ac067eb82320c4d659c9e1eaef0f","src/backends/v2/rpc.rs":"b7afc5357d24de42350d4ec15a6b5a37698e4fd77b2c2cc8071f303ee62e957c","src/backends/v3/mod.rs":"fd232f2df64b148f0998726fc41c089d08080ba25b3ca37bcb1c7f43b08b1c17","src/backends/v3/rpc.rs":"7a5f80aec4af1bcaa0d36e67345aa9acbbd8ead73c0be474f06305358b38e81b","src/error_codes.rs":"de85845f52b1d4e1a0bff73462cef00962b60fad8a3ed71c7bb083c02df3a413","src/firmware.rs":"6d002e481ce0a897c0485b9393b0382fcb25811164e893eb8eb67b2ff392ca0d","src/lib.rs":"710b46c9d934f26f900e1366ca1df5f872896e7d8da03569c0f159859e899cc9","src/test/json/mod.rs":"99760925ccfefc40d2455d3567fb1ecfc99e9e55e70478190ef372a954825909","src/test/json/v1/devs.json":"b4fd010f0bae3584efde93387cf2dab5933b499cc30a2dd7635fdc994b56c3b8","src/test/json/v1/get_psu.json":"8c11b6495e0bd5da496dd5c10ca53ec53b2d8fe9a3737f470ec9ce2c1aaf9d99","src/test/json/v1/get_version.json":"c43e947e654792ab191210d50c6f793ee0dd7af41e8cb59f0722b70f32a203bc","src/test/json/v1/mod.rs":"e79509eee78a1fef63735afe385299813726822c8259a02d1dcf5e8b4db9d04e","src/test/json/v1/pools.json":"b570808a3428a0773d7d2ee322150d8fd0794a33804af970300a7fef128a8a01","src/test/json/v1/status.json":"00ec38dd9f980b7ac0ffd6f815374afdbbed98d601bd8ef18bcf0f76ae0aa853","src/test/json/v1/summary.json":"d6e3e75654eb4019e1f479b3d9cf3097130f1afb85dd3338682c094fd4ab498a","src/test/json/v1/summary_with_errors.json":"1ba682f6ad5c43e41ae22a4069d0f52f04da3f07a18031bf4c07e07b3c59cc97","src/test/json/v2/devs.json":"2d203e41ef6ef337c0c81456b73d08730882c3167403c557c3c9776022a972d1","src/test/json/v2/get_error_code.json":"e90b702fd97bceb4f62dcb8228f75ff5ce930290355dca94eefd7192f7f57009","src/test/json/v2/get_error_code_with_errors.json":"6cb6038366eb3835684421c41be0b2b30ae8ce79a7ed51a85f4f52f70da9df16","src/test/json/v2/get_miner_info.json":"55d2af984833a692f502188ae4df4e41bdc10386b47f921c896a452ef1de9062","src/test/json/v2/get_psu.json":"b43086b65897061521d1f6611e200ef372a1724f9ea1876e347c03d5fb19b8f2","src/test/json/v2/get_version.json":"b17e3a81603b43186b2e15745e6822b6c82b3c6f5928b22f84e683d7728dbfcd","src/test/json/v2/mod.rs":"c847205d076323bbd9698e393d241b08f3cf75d32aae86f7058cf8748266b935","src/test/json/v2/pools.json":"926d34e8dae774473ebfec83d4a38e77ca73231708f07683763e212be7af0580","src/test/json/v2/status.json":"fc268cd23864ef99e84813dbf8eb916b2e6f339351a0ee5dab217cbe02569fc3","src/test/json/v2/summary.json":"4e4c01b986e2960893f58d0f1ea4dce23b8ef88db4985348f7f0183eb4818478","src/test/json/v3/get_device_info.json":"83ac22ea9a11adbceb4c963db80aa62d9a2aa50d019a372394dece817d924cda","src/test/json/v3/get_device_info_with_errors.json":"24cee4b7840e87e12147cbfddf6c361f3b378a15bb85330b339d3be9e17cdbd5","src/test/json/v3/get_miner_status_edevs.json":"2d831c06113f555e0988df994c2e602a053a4aea603dded0db8f0f80e191ca5a","src/test/json/v3/get_miner_status_pools.json":"cd65c2efd3a5ce80b57aae46c420298a34ca06df7ac7f8c36fd556217703d242","src/test/json/v3/get_miner_status_summary.json":"799a94ba13ef54aed0f81a3d041d6c1fa263d4183754b384c69ca12d85a8d3ba","src/test/json/v3/mod.rs":"7ea3a8ff1b81c7a5b0f44f7c12dda880a9aeac5b0e6b56ac4fff4f4a7cbfe451","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"c85da6325b62f061327dc5f7605dd3721c823a9e8a2cfd6a356363dfbc84d66e"}
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"30f09ad063df45fdf223aff235fe2da15cb1a7e79e86d7012074153b91662fc4","Cargo.lock":"9d0886791db53421d3218ab72d964145b86cfbe9738eaf09aac5d3c89a1c0190","Cargo.toml":"8c2e9938436850f2e250e8268ed7b385fce903e2077923b207a0560ca3e3242c","Cargo.toml.orig":"891fcfa45e79d6bc4d838c4f3075618f791bd013c99231da48e752b987f409d5","src/backends/mod.rs":"0f5a0ae31d5443d0d0f41a2540def806196238c92d22761b3ad9843cb2e77f45","src/backends/v1/mod.rs":"b96cd7679b575335d716b114a3986167b2696b9e94a1a06a4696757aef08c7d1","src/backends/v1/rpc.rs":"4cee9caeb9bc291c4efec04f4b7fc2b8eaead904a1f2d0f30e13236476d9aac5","src/backends/v2/mod.rs":"68fd8c1762b424a7785174fdb3ae4fede1d599632657808d4b7c76bcfbfb202c","src/backends/v2/rpc.rs":"b7afc5357d24de42350d4ec15a6b5a37698e4fd77b2c2cc8071f303ee62e957c","src/backends/v3/mod.rs":"f19e673c47c2cc366e2ff7782bca93daf750563d62221a12a043b3ee79a15251","src/backends/v3/rpc.rs":"7a5f80aec4af1bcaa0d36e67345aa9acbbd8ead73c0be474f06305358b38e81b","src/error_codes.rs":"de85845f52b1d4e1a0bff73462cef00962b60fad8a3ed71c7bb083c02df3a413","src/firmware.rs":"6d002e481ce0a897c0485b9393b0382fcb25811164e893eb8eb67b2ff392ca0d","src/lib.rs":"710b46c9d934f26f900e1366ca1df5f872896e7d8da03569c0f159859e899cc9","src/test/json/mod.rs":"99760925ccfefc40d2455d3567fb1ecfc99e9e55e70478190ef372a954825909","src/test/json/v1/devs.json":"b4fd010f0bae3584efde93387cf2dab5933b499cc30a2dd7635fdc994b56c3b8","src/test/json/v1/get_psu.json":"8c11b6495e0bd5da496dd5c10ca53ec53b2d8fe9a3737f470ec9ce2c1aaf9d99","src/test/json/v1/get_version.json":"c43e947e654792ab191210d50c6f793ee0dd7af41e8cb59f0722b70f32a203bc","src/test/json/v1/mod.rs":"e79509eee78a1fef63735afe385299813726822c8259a02d1dcf5e8b4db9d04e","src/test/json/v1/pools.json":"b570808a3428a0773d7d2ee322150d8fd0794a33804af970300a7fef128a8a01","src/test/json/v1/status.json":"00ec38dd9f980b7ac0ffd6f815374afdbbed98d601bd8ef18bcf0f76ae0aa853","src/test/json/v1/summary.json":"d6e3e75654eb4019e1f479b3d9cf3097130f1afb85dd3338682c094fd4ab498a","src/test/json/v1/summary_with_errors.json":"1ba682f6ad5c43e41ae22a4069d0f52f04da3f07a18031bf4c07e07b3c59cc97","src/test/json/v2/devs.json":"2d203e41ef6ef337c0c81456b73d08730882c3167403c557c3c9776022a972d1","src/test/json/v2/get_error_code.json":"e90b702fd97bceb4f62dcb8228f75ff5ce930290355dca94eefd7192f7f57009","src/test/json/v2/get_error_code_with_errors.json":"6cb6038366eb3835684421c41be0b2b30ae8ce79a7ed51a85f4f52f70da9df16","src/test/json/v2/get_miner_info.json":"55d2af984833a692f502188ae4df4e41bdc10386b47f921c896a452ef1de9062","src/test/json/v2/get_psu.json":"b43086b65897061521d1f6611e200ef372a1724f9ea1876e347c03d5fb19b8f2","src/test/json/v2/get_version.json":"b17e3a81603b43186b2e15745e6822b6c82b3c6f5928b22f84e683d7728dbfcd","src/test/json/v2/mod.rs":"c847205d076323bbd9698e393d241b08f3cf75d32aae86f7058cf8748266b935","src/test/json/v2/pools.json":"926d34e8dae774473ebfec83d4a38e77ca73231708f07683763e212be7af0580","src/test/json/v2/status.json":"fc268cd23864ef99e84813dbf8eb916b2e6f339351a0ee5dab217cbe02569fc3","src/test/json/v2/summary.json":"4e4c01b986e2960893f58d0f1ea4dce23b8ef88db4985348f7f0183eb4818478","src/test/json/v3/get_device_info.json":"83ac22ea9a11adbceb4c963db80aa62d9a2aa50d019a372394dece817d924cda","src/test/json/v3/get_device_info_with_errors.json":"24cee4b7840e87e12147cbfddf6c361f3b378a15bb85330b339d3be9e17cdbd5","src/test/json/v3/get_miner_status_edevs.json":"2d831c06113f555e0988df994c2e602a053a4aea603dded0db8f0f80e191ca5a","src/test/json/v3/get_miner_status_pools.json":"cd65c2efd3a5ce80b57aae46c420298a34ca06df7ac7f8c36fd556217703d242","src/test/json/v3/get_miner_status_summary.json":"799a94ba13ef54aed0f81a3d041d6c1fa263d4183754b384c69ca12d85a8d3ba","src/test/json/v3/mod.rs":"7ea3a8ff1b81c7a5b0f44f7c12dda880a9aeac5b0e6b56ac4fff4f4a7cbfe451","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"c85da6325b62f061327dc5f7605dd3721c823a9e8a2cfd6a356363dfbc84d66e"}
+28 -10
View File
@@ -131,14 +131,28 @@ impl GetDataLocations for WhatsMinerV1 {
tag: None,
},
)],
DataField::ControlBoardVersion => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0/CB Platform"),
tag: None,
},
)],
DataField::ControlBoardVersion => vec![
(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0/CB Platform"),
tag: None,
},
),
// Older M30S firmware (< 2022.7.29, so this v1 backend) often omits
// "CB Platform" from summary but still reports the board under
// get_version /Msg/platform (the source v2 uses). Fall back to it so
// those units don't show a blank control board.
(
RPC_GET_VERSION,
DataExtractor {
func: get_by_pointer,
key: Some("/Msg/platform"),
tag: None,
},
),
],
DataField::TuningTarget => vec![(
RPC_SUMMARY,
DataExtractor {
@@ -285,8 +299,12 @@ impl GetControlBoardVersion for WhatsMinerV1 {
) -> Option<MinerControlBoard> {
data.extract::<String>(DataField::ControlBoardVersion)
.and_then(|s| {
WhatsMinerControlBoard::parse(s.to_uppercase().strip_prefix("ALLWINNER_")?)
.map(|cb| cb.into())
// The "ALLWINNER_" prefix is optional: summary's CB Platform carries
// it (e.g. "ALLWINNER_H6"), but the get_version /Msg/platform fallback
// does not (e.g. "H6OS"). Strip it only when present.
let up = s.to_uppercase();
let board = up.strip_prefix("ALLWINNER_").unwrap_or(&up);
WhatsMinerControlBoard::parse(board).map(|cb| cb.into())
})
}
}
+13 -3
View File
@@ -637,11 +637,21 @@ impl SetFaultLight for WhatsMinerV2 {
impl SetPowerLimit for WhatsMinerV2 {
async fn set_power_limit(&self, limit: Power) -> anyhow::Result<bool> {
let parameters = Some(json!({"power_limit": limit.as_watts().to_string()}));
let data = self
match self
.rpc
.send_command("adjust_power_limit", true, parameters)
.await;
Ok(data.is_ok())
.await
{
Ok(_) => Ok(true),
// adjust_power_limit makes the miner restart to re-tune, so it drops
// the connection / stops replying mid-command even though it accepted
// and applied the new limit (verified on the live fleet: the set value
// settles after the restart). A transient RPC error (read timeout /
// connection reset) after the command is therefore success; a genuine
// rejection surfaces as StatusCheckFailed and still errors.
Err(e) if is_expected_write_error(&e) => Ok(true),
Err(e) => Err(e),
}
}
fn supports_set_power_limit(&self) -> bool {
true
+23 -7
View File
@@ -669,12 +669,21 @@ impl SetFaultLight for WhatsMinerV3 {
#[async_trait]
impl SetPowerLimit for WhatsMinerV3 {
async fn set_power_limit(&self, limit: Power) -> anyhow::Result<bool> {
let data = self
// WhatsMinerOS wants a BARE INTEGER watt value; a float ("3000.0")
// trips the firmware's "invalid json" parser (round-9 #4).
let watts = limit.as_watts().round() as u64;
match self
.rpc
.send_command("set.miner.power_limit", true, Some(json!(limit.as_watts())))
.await;
Ok(data.is_ok())
.send_command("set.miner.power_limit", true, Some(json!(watts)))
.await
{
Ok(_) => Ok(true),
// A power-limit change restarts the miner to re-tune, so a transient
// RPC error after the command means it was accepted (as with v2), not
// rejected; a genuine rejection is a StatusCheckFailed and still errors.
Err(e) if is_expected_write_error(&e) => Ok(true),
Err(e) => Err(e),
}
}
fn supports_set_power_limit(&self) -> bool {
true
@@ -806,8 +815,15 @@ impl HasDefaultAuth for WhatsMinerV3 {
impl HasAuth for WhatsMinerV3 {
fn set_auth(&mut self, auth: MinerAuth) {
// WhatsMiner V3 username is always "super", V2 is always "admin"
self.rpc.set_auth(MinerAuth::new("super", auth.password()));
// WhatsMiner V3 username is always "super", V2 is always "admin".
// The V3 privileged token authenticates against the "super" ACCOUNT,
// whose password is a separate v3 credential (factory default "super")
// -- NOT the web/admin password carried by `auth`. Pairing account
// "super" with the web password made every v3 privileged write fail with
// "invalid json or password is wrong" (round-9 #4, confirmed on the live
// fleet). Keep the super-account default password here; the web password
// still drives the v2 (admin) path below.
self.rpc.set_auth(MinerAuth::new("super", "super"));
self.v2_rpc
.set_auth(MinerAuth::new("admin", auth.password()));
}
+1 -1
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":"aaaa0f14e3aff2543d3d09a4515efa5ab439f0651a36b582e87b9843d0475752","Cargo.lock":"58da2f3399ff680bf7d619204897b4edf5c03d336a8c3cceb54c9aba280bfed1","Cargo.toml":"57f92bf3808fa6f468dbabf43763a808d9ead128eef83b748f940ef3b219a80e","Cargo.toml.orig":"cbfb99fc843dd61ad2025dcfc16bd435afd2b6d43c2c983867af08af415916f1","src/hardware.rs":"77612b4f39e9c15355172b0582693d86b2fe44a305f5b01eef592e5a34b37188","src/lib.rs":"b2f55767a7f3fdacb1e898c5cb961c2dec8481823f94386ee67628960e91bf7d","src/make.rs":"e968e4dbd745d485fc9ad4c5a4c081d679eddce11f66e572f81f2dbe37ede3f0","src/models.rs":"da72a570d8cbb2c843c04047c3d879ca9709455f9bd6a02c3f2ab739e1b5be60"},"package":"67cca6e6bf4ac14562084ce7534521ffa7cd313fa39e2392f98ff98a047a4353"}
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"aaaa0f14e3aff2543d3d09a4515efa5ab439f0651a36b582e87b9843d0475752","Cargo.lock":"58da2f3399ff680bf7d619204897b4edf5c03d336a8c3cceb54c9aba280bfed1","Cargo.toml":"57f92bf3808fa6f468dbabf43763a808d9ead128eef83b748f940ef3b219a80e","Cargo.toml.orig":"cbfb99fc843dd61ad2025dcfc16bd435afd2b6d43c2c983867af08af415916f1","src/hardware.rs":"c3edc06f2404efd473bcc4ab16d66bb647369f2d43c0a10cb77bbc12cb98bf43","src/lib.rs":"b2f55767a7f3fdacb1e898c5cb961c2dec8481823f94386ee67628960e91bf7d","src/make.rs":"e968e4dbd745d485fc9ad4c5a4c081d679eddce11f66e572f81f2dbe37ede3f0","src/models.rs":"da72a570d8cbb2c843c04047c3d879ca9709455f9bd6a02c3f2ab739e1b5be60"},"package":"67cca6e6bf4ac14562084ce7534521ffa7cd313fa39e2392f98ff98a047a4353"}
+4 -2
View File
@@ -268,11 +268,13 @@ impl AntMinerControlBoard {
.collect::<String>();
match compact.as_str() {
"XILINX" => Some(Self::Xilinx),
// "XIL" is VNish's short platform form for a Xilinx control board.
"XILINX" | "XIL" => Some(Self::Xilinx),
"BBB" | "BBCTRL" | "BB" | "BEAGLEBONE" | "BEAGLEBONEBLACK" => {
Some(Self::BeagleBoneBlack)
}
"CVITEK" | "CVCTRL" => Some(Self::CVITek),
// "CV" is VNish's short platform form for a CVITek control board.
"CVITEK" | "CVCTRL" | "CV" => Some(Self::CVITek),
"AMLOGIC" | "AML" => Some(Self::AMLogic),
"AMCB07" => Some(Self::Xilinx), // Mara FW
"ZYNQ7007" => Some(Self::Xilinx),