Compare commits

...
20 Commits
Author SHA1 Message Date
noahandClaude Opus 4.8 0ab822940e coverage: count the headless self-test, reporting ~46% (was ~35%)
The self-test builds the real wxWidgets table and renders every fixture through
the real widgets, exercising ~27% of ui.rs (up from ~4%) -- but it runs as a
separate binary, so a plain `cargo llvm-cov` (which only runs the #[test]s) never
counted it, understating coverage. New ci/coverage.sh runs both the unit tests and
the self-test under one instrumentation pass and merges them, excluding the
vendored asic-rs / patched wx-rs from the report.

Our-source line coverage is now ~46% (model 81%, naming 95%, fixtures 100%,
credentials 92%); the remainder is click-driven dialogs and live-miner network
I/O, which unit tests can't reach without hardware or heavy mocks. Badge, report,
and README dev section updated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 08:09:02 -06:00
noahandClaude Opus 4.8 c1aa6db834 license: unify under MIT
Collapse the dual MIT OR Apache-2.0 licensing to MIT only (operator's choice):
set the workspace `license` field to "MIT" (all crates inherit it), replace
LICENSE-MIT + LICENSE-APACHE with a single LICENSE file, and update the README
license section and the license badge. deny.toml keeps its permissive allow-list
(that governs dependency licenses, which remain a mix of MIT/Apache-2.0/BSD/etc.);
only its project-license comment changed.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 08:05:11 -06:00
noahandClaude Opus 4.8 7feab6117b item 12 finale: shrink the release binary + code-review report
[profile.release] opt-level="s" + fat LTO + one codegen unit + strip cuts the
Linux binary from ~38M to ~19M (50%). panic stays "unwind" deliberately: the scan
runs many miners on tokio tasks and the wx dispatch relies on unwinding, so one
miner's panic must never abort the whole app. Verified: stripped binary, SELFTEST
PASS, 99 tests, clippy clean.

Adds code-review-report.md: the ship verdict and a full accounting of the five
recursive review rounds (all confirmed critical/high fixed; remaining items are
documented perf/dev-CLI tradeoffs). Badges refreshed (tests 99, coverage ~35%).

This completes the round-18 marathon: all 12 queued items plus Round C G3 (LuxOS
named presets) and G7 (per-board V/F read side), CI hardening (verify/release
split, clippy gate, audit, badges), README + docs, and the recursive multi-agent
code review.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 21:02:09 -06:00
noahandClaude Opus 4.8 808fd4de1d review wave 7: fifth-round findings (creds, scan race, refill throttle)
Fifth (final) review round; this clears its functional findings:

- HIGH config actions / pool writes could run concurrently with a live scan
  (start_action / apply_pools guarded flash + restore but not scanning); added
  the self.scanning guard, and begin_scan now defers while an action/restore runs,
  closing the race symmetrically.
- HIGH blanking a per-firmware credential row saved a live ("","") override that
  then broke that firmware's auth fleet-wide; a fully-blank row now clears the
  override (use the shipped default).
- HIGH a ChangePassword action never updated the toolkit's own saved credentials,
  so after a fleet-wide change it locked itself out; on full success it now updates
  the saved global password (and on a partial change logs a reconcile note rather
  than guessing).
- HIGH/perf fill_rows re-rated: a scan's streaming rows triggered a whole-table
  refill on every fast tick. New rows_dirty latch flushes the refill at most once
  per second during a scan (immediately once it ends).
- MED an indeterminate access-probe result no longer blanks a miner's already-known
  locked/unlocked state.
- LOW compute-version.sh header doc corrected to match the broadened rule;
  release.yml sets WX_RS_WXCONFIG once at job level instead of per step.

Accepted (documented) perf items that remain: per-render health recompute and
per-column cell-string allocation (small, fleet-scale), the linear upsert scan,
and synchronous scan-range parsing (bounded by the range caps).

99 tests + clippy-clean + selftest green. This was review round 5 (the harness's
iteration cap); every confirmed critical/high across all five rounds is fixed.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 20:59:03 -06:00
noahandClaude Opus 4.8 63ada5bb99 review wave 6: fourth-round findings (masked prompt, board grey, timeouts)
Fourth review round found further issues, two being gaps in earlier fixes; this
clears the actionable ones:

- HIGH board_healths() painted a genuinely-undetected board RED when a fault text
  also named it (e.g. "chain 2 not found" -> Board(2)); an undetected board now
  stays grey, matching the documented grey-vs-red invariant. Regression-tested.
- HIGH the Change-password prompt used an unmasked field (the Credentials dialog
  was masked in wave 1 but this prompt was missed) -> masked for PromptKind::Password.
- MED the WhatsMiner access probe aborted all remaining password candidates on one
  transient error -> transient errors now skip to the next candidate and never
  report a confident "locked" when the answer was really indeterminate.
- MED config actions / refresh / pools / flash ignored the operator's configured
  scan timeout (used asic-rs's 10s default) -> configured_factory now applies it,
  so a slow-link action reaches the same miners a longer-timeout scan found.
- MED the auto-rescan loop set a bogus "scanning..." status even when the scan was
  deferred (mid-flash) -> begin_scan reports whether it started.
- LOW is_aml_140mm matched every S21, not just the S21 Pro its doc names -> fixed.
- Offline fixtures now reuse scan::infer_pic instead of a diverging copy.

Accepted (documented) from this round: miner_probe's argv secrets (diagnostic CLI),
the rebuild_table/update_headers sort-marker duplication, the LuxOS substring
success check (command-specific reply), restore/flash target snapshot (dialogs are
modal), non-cancellable restore/probe batches, Braiins host-key (LAN reflash), and
the perf items (per-tick refill, health recompute, linear upsert, cell formatting).

99 tests + clippy-clean + selftest green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 20:29:52 -06:00
noahandClaude Opus 4.8 52b7c3f2a1 review wave 5: third-round findings (unreachable column, races, panics, DoS)
Third review round (over the wave 3/4 fixes) surfaced further findings, mostly in
new code paths; this clears them:

- HIGH the fully-built "Boards" column (Column::Hashboards: renderer, sort/filter
  logic, tests, a self-test check) was missing from ALL_COLUMNS, so it was
  unreachable in the UI and its self-test check was dead. Added to ALL_COLUMNS
  (opt-in; Health still shows composite board health by default) and the self-test
  now makes it visible -- the dot-sentinel check is live again.
- HIGH apply_pools() could start a pool write during a restore-to-stock (it sets
  self.action directly, bypassing start_action's guard) -> same restore guard.
- HIGH superseding an in-flight action/pools job left the old miners' Health cells
  frozen on the "…ing" label forever (the replaced handle's drain never runs) ->
  clear the superseded action's op-status.
- HIGH clean_antminer() byte-sliced a miner-supplied model string without a
  char-boundary check (panic DoS) -> use get(..9).
- MED access-probe errors were silently discarded -> surfaced in the indicator.
- MED the pool-password file was briefly world-readable before chmod -> created
  0600 from the start (OpenOptions mode).
- MED a miner-controlled log response was buffered unbounded (OOM DoS) -> capped.
- MED the language-menu id range was hardcoded (and 790-794 collided with the
  pool-preset / fw-preset dialog ids!) -> derived from Lang::all() and moved the
  dialog ids to a clear block.
- LOW restore_vnish now sends the unlock body via stdin (password off argv), and
  the LuxOS restore treats a reboot-dropped/empty reply as success.

Remaining round-3 findings are the previously-accepted perf tradeoffs (bulk-serial
writes, per-tick refill, per-render health recompute, linear upsert), documented
in code and in code-review-report.md.

99 tests + clippy-clean + selftest green (Boards-column check now live).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 19:53:56 -06:00
noahandClaude Opus 4.8 571c2305aa review wave 4: remaining round-2 findings (filters, creds, restore, panics)
Clears the rest of the second review round's confirmed findings:

- HIGH the Boards numeric filter compared the composite sort score (online*100+
  total) instead of the board count, so a filter like "Boards <= 3" matched
  nothing on healthy 3-board miners. num_value now returns the detected count;
  regression-tested with per-board health present (the path the old test missed).
- HIGH the WhatsMiner access probe ignored the operator's saved scan password
  (tried only admin/super), mis-reporting writable miners as locked. It now tries
  the caller's password first.
- HIGH firmware flash and config actions were not blocked during a restore-to-
  stock; start_action and both flash guards now refuse while a restore runs.
- MED log tail() could panic slicing at a non-UTF8 char boundary -> nudge to a
  boundary first (regression-tested).
- MED board_index_from_text grabbed an unrelated number far past the keyword
  (e.g. a temperature) -> only accept a number immediately after the keyword.
- MED a restore worker-thread spawn failure wedged the restore subsystem forever
  -> emit Done on spawn failure and treat a disconnected channel as done.
- MED LuxOS restore reported failure when the miner rebooted mid-reply -> an empty
  reply or dropped connection after a successful logon is the expected reboot.
- MED two tests raced on the process-global $HOME -> a shared serialization lock.
- LOW CSV export now neutralizes spreadsheet formula-injection prefixes on
  miner-supplied fields.
- Made miner_probe's global-only credential resolution explicit (it can't share
  the GUI's per-firmware configured_factory across the bin boundary).

99 tests (+3 regression tests) + clippy-clean + selftest green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 19:30:29 -06:00
noahandClaude Opus 4.8 79ecc100d3 review wave 3: log-fetch credential leak + JSON escaping + column-scan cost
Second review round (over the wave 1/2 fixes) surfaced further, mostly new-path
findings; this clears the substantive ones:

- HIGH log_scan.rs passed miner admin credentials on the curl command line (same
  class as the access-probe leak fixed in wave 1). Its curl() now takes optional
  stdin: the Antminer digest login goes through a curl config on stdin (-K -),
  the VNish unlock password through the POST body on stdin (-d @-), and the
  timeout path reaps the child so it no longer leaks a zombie.
- MEDIUM JSON injection/breakage: the VNish unlock body and the LuxOS
  uninstall command spliced a password / miner-supplied SessionID into JSON with
  format!. Both now build the JSON with serde_json, which escapes correctly.
- MEDIUM column scan cost: fill_rows computed table_columns() twice (my wave-2
  built_columns check added one), and with auto-hide-empty on that scans every
  cell of every row each time. It is now computed once and reused.

Accepted, documented tradeoffs from this round: miner_probe's setpools takes the
pool password as a CLI arg (inherent to a diagnostic CLI; it is the low-sensitivity
mining worker password), MinerRow::upsert_into's linear scan is fine at the tool's
fleet scale (hundreds), and bulk config-action writes stay serial deliberately.

96 tests + clippy-clean + selftest green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 19:18:27 -06:00
noahandClaude Opus 4.8 51b4eb2556 review wave 2: scan concurrency, table-column lockstep, background log fetch
Continuing the recursive review's confirmed findings:

- HIGH scan telemetry was serial: the consumer awaited each responder's to_row
  (get_data + presets, several REST calls) inline in the identification stream
  loop, so telemetry ran one miner at a time. Now buffer_unordered runs it
  concurrently up to SCAN_CONCURRENCY_LIMIT; identification (which buffers
  internally) is unaffected, and telemetry only hits live responders.
- HIGH table columns diverged from the built widget with auto-hide-empty on:
  (1) drag-reorder was silently rejected because column_reordered fed
  table_columns() (empty-filtered) to apply_visible_reorder, which compared it to
  display_columns() (unfiltered) -- apply_visible_reorder now reorders the shown
  subset in place; (2) a column flipping non-empty mid-scan left the widget stale,
  so fill_rows now rebuilds when the shown set no longer matches built_columns.
  Both covered by a new unit test.
- HIGH viewing a miner's log blocked the wx UI thread for up to ~20s. The fetch
  now runs on a background thread; the viewer opens from the tick drain when the
  result lands (tick returns the dialog for dispatch to show modally).
- LOW start_pools_action's fake branch now honours the cancel flag like its
  siblings.
- Documented the intentional tradeoffs the review flagged: scan-restart uses
  cooperative cancellation (a hard join would freeze the UI), and the aftermarket
  re-probe stays per-scan for freshness (firmware can change between scans).

96 tests (+subset-reorder) + clippy-clean + selftest green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 19:02:39 -06:00
noahandClaude Opus 4.8 3b18219e4e review wave 1: fix the critical restore false-success + security/correctness findings
From the recursive multi-agent review (18 confirmed findings). This wave clears
the critical, four highs, and several mediums/lows:

- CRITICAL restore.rs: a Braiins SSH restore reported SUCCESS on a wrong password
  or unreachable miner. run_with_timeout now captures the exit code and drains
  stderr on its own thread (also fixing the medium stderr-pipe stall), and a new
  testable classify_braiins() treats an ssh auth/connection failure (stderr
  diagnostic, empty stdout, non-zero exit) as failure while still reading a
  dropped connection / timeout as the expected reboot. Unit-tested.
- HIGH restore exclusivity: apply_restore_confirm now refuses when a scan/refresh/
  action/flash or another restore is in flight, so this destructive action never
  overlaps or orphans a running restore handle.
- HIGH secrets off the command line: Braiins SSH uses `sshpass -e` (env, not -p),
  and the access-probe curl passes credentials through a config on stdin (-K -)
  instead of `-u user:pass`; both were visible in the process list. New masked
  password field (wxTE_PASSWORD bridge) so the Credentials dialog no longer
  renders saved passwords in the clear.
- MEDIUM correctness: per-board Chip-temp readings are now index-aligned with the
  boards (a missing middle board shows "-" instead of shifting later boards left).
- MEDIUM: saved pool lists (which can hold a pool password) are chmod 0600.
- LOW: access-probe curl timeout now reaps the child (no zombie).

95 tests (+classify_braiins) + clippy-clean + selftest green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 18:45:56 -06:00
noahandClaude Opus 4.8 bcc0ba38b6 ci: install clippy component before the gate; classify all GUI src as backend
Run 82 failed because the alkane-ci image ships no clippy component
("cargo-clippy is not installed for the toolchain"). Both workflows now
`rustup component add clippy` before the gate.

Also broadened compute-version.sh: any crates/alkane-gui/src/* file is backend
logic (previously only scan.rs/model.rs/main.rs were, so a fix confined to
naming.rs / pool_prefs.rs / restore.rs / access_probe.rs / credentials.rs would
never cut a release). ui.rs/fixtures.rs/bin still match the UI arm first. All 9
compute-version tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 18:22:32 -06:00
noahandClaude Opus 4.8 749cdc4eed item 12: CI verify/release split, dependency audit, README + badges
CI is now two workflows: verify.yml (pull requests + non-main pushes) runs the
clippy gate, build, unit tests, microbenchmarks, the headless self-test, and a
best-effort dependency audit; release.yml (main) repeats the clippy gate + audit
before its existing build/test/selftest/package/release, then refreshes the
committed README badges and pushes any change back (best-effort, and a badges-
only push does not bump the version, so it does not loop).

Security: cargo audit found a build-time-only advisory (h2 0.3 in the wx-rs
build script's reqwest 0.11 subtree, never linked into the runtime binary and
never executed on Linux). The vendored/offline tree can't upgrade it without
re-vendoring, so it is documented and accepted in .cargo/audit.toml (mirrored in
deny.toml with the project's permissive-license policy).

Badges: ci/gen-badges.py emits self-contained shields-style SVGs into badges/
(tests, coverage 36%, bench, LOC 12.5k, clippy clean, dependencies, license) --
committed and referenced by relative path so a self-hosted Gitea renders them
with no external service. README rewritten around what the toolkit actually does
today (discover / monitor / operate / install), with build, CLI, dev, and
architecture sections and the dual-license note.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 18:17:31 -06:00
noahandClaude Opus 4.8 19e469ebc4 item 12: clippy-clean our crate + add LICENSE files
Cleared all clippy findings in alkane-gui (cargo clippy --no-deps): mechanical
fixes via clippy --fix (redundant imports, useless format!, manual_contains,
manual_is_multiple_of, unnecessary_map_or, unused parens) plus manual fixes:

- type_complexity: factored the segment tuple into model::{Rgb, Segment} aliases.
- large_enum_variant: #[allow] on ScanMsg/RefreshMsg with a note -- Row is the
  common variant, so boxing it to shrink the rare Started/Done would add an
  allocation per miner on the hot path.
- dead code: removed unused SHAPE_PULSE_DOT, ColorKind::Accent, clear_op_status,
  and RestoreMsg's unread `total`; kept the restore/access-probe cancel handles
  (workers honour cancellation; UI stop control pending) under #[allow].
- question_mark, needless_range_loop, drop_non_drop, doc_lazy_continuation fixes.

Only vendored wx-rs warnings remain (out of scope). Added LICENSE-MIT and
LICENSE-APACHE (Cargo.toml already declares MIT OR Apache-2.0). 94 tests +
selftest green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 18:01:49 -06:00
noahandClaude Opus 4.8 6cd732dec5 Round C G7 (read side): per-board voltage/frequency in the board tooltip
Surfaces the per-hashboard configured voltage (V) and frequency (MHz) that
asic-rs already reads into BoardData but the toolkit dropped. Added
MinerRow.board_voltages / board_frequencies (index-aligned with the boards,
0.0 where unreported), populated at scan time, and appended to the per-board
Health tooltip as extra middot segments after actual/expected hashrate.

Verified live on LuxOS S19j Pro (10.4.1.60): boards report 12.73 V (frequency
is None in LuxOS's live stats path -- a pre-existing backend gap; the tooltip
omits absent values). miner_probe `msgs` now prints board freq/volt too.

The G7 WRITE path (per-board V/F override) stays deferred: no firmware accepts
Manual targets today and a bad voltage can damage a board, so per the parity
roadmap it is bench-only and not shipped.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 17:40:32 -06:00
noahandClaude Opus 4.8 95b8428c12 Round C G3: named firmware presets (LuxOS) end to end
The flagship structured-tuning parity item: list and select a firmware's named
profiles/presets, not just map a watts number onto one.

Backend (vendored asic-rs, patch 0022): LuxOS now implements SupportsPresets
(get_presets reads the live `profiles` RPC) and a real SupportsTuningConfig
(set_tuning_config routes Preset(name) -> profileset, Power -> set_power_limit).
Unit-tested (parse_profiles_to_presets); verified live-read on two production
LuxOS S19j Pro (10.4.1.60/.67). VNish already exposed presets.

GUI: MinerCaps.supports_presets + MinerRow.presets (read live at scan time for
preset-capable miners; ~1 RPC per such miner per 300 s rescan). New "Set
profile..." right-click item opens a selector populated from the profiles
common to the whole selection (so the chosen name is valid on every target),
applied via the new ConfigAction::Preset. Offline fixtures seed demo presets.

CLI: `miner_probe presets <ip>` (list) and `setpreset <ip> <name>` (select).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 17:34:26 -06:00
noahandClaude Opus 4.8 a7ed34b8e4 gui: pool "+" "Add new..." opens a preset manager window (round 18 #8b)
The pool-field "+" menu previously offered a one-shot "Add new" (append
the current box value) plus a "Remove saved value" submenu. Both are now
replaced by "Add new...", which opens a small manager window: a multiline
editable list of all saved values for that field, seeded with the current
box value as the last line. Save rewrites the whole saved list at once.

- pool_prefs: new save_all() rewrites a field's saved list; the trim /
  drop-empties / drop-presets / de-dup step is factored into a pure
  dedupe_saved() with unit tests. Removed the now-unused add_saved /
  remove_saved.
- ui: build_pool_presets_dialog + apply_pool_presets, wired to
  ID_POOL_PRESETS_SAVE/CANCEL; "+" menu shows "Add new..." and no longer
  builds the remove submenu; ID_POOL_MENU_REMOVE_BASE dropped.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 17:10:45 -06:00
noahandClaude Opus 4.8 b839e9012d gui: default column widths fit contents, capped (round 18 #10)
Columns previously always opened at generous fixed defaults, wasting
horizontal space. Now, the first time the table is populated after a
(re)build, each column is sized to the smaller of its content-fit width
(wxCOL_WIDTH_AUTOSIZE, floored at 24px) and its configured default (the
cap). Done once per rebuild via a new columns_autosized latch, so a
user's later manual resize is preserved -- scan-update refills skip it.

New bridge: wxbr_dvlc_autosize_col_capped (SetWidth AUTOSIZE, read back,
floor, clamp to cap, SetWidth) + Widget::dvlc_autosize_col_capped.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 17:01:25 -06:00
noahandClaude Opus 4.8 d378a484d6 ui: attribute hashboard faults + pools dialog + widths (round 18 #5/#8a/#8c)
- #5 Antminer-hardware firmwares (stock/VNish/Braiins/LuxOS) report faults with no
  component, so a real per-board fault landed on the control-board tooltip instead
  of the board it names. messages_to_faults now recovers the board index from the
  self-describing message text ("Chain 2 ...", "hashboard 0 ...", "Slot 1 ...") so
  the issue shows on the right hashboard's tooltip. WhatsMiner (which does attribute
  HashBoard{idx}) is unchanged.
- #8a The pools dialog is widened so the rightmost "+" preset buttons (Password
  column) are no longer clipped off a too-narrow dialog.
- #8c The pool column headers now span field-width + the 34px "+" button, so the
  "Address/Account/Worker/Password" titles line up with the boxes below them.

board_index unit test + SELFTEST pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 16:52:24 -06:00
noahandClaude Opus 4.8 64e084ddee ui: per-icon tooltip repositioning + Zcash units/expected (round 18 #4a/#6/#7)
- #4a Health-column tooltips now reposition per icon: the query-tooltip handler
  scopes GTK's tip area to the hovered icon's slot, so moving across icons hides
  the old tooltip and shows a fresh one at the new position (was stuck in place).
- #6 Plain Antminer Z15 firmware omits the expected hashrate (the Z15j reports it),
  so it's filled from the model nameplate (420 KSol/s) -- the actual/expected
  column + colour now work for Z15 like every other miner.
- #7 Equihash hashrate now shows correct units: Sol/s (not TH/s). The stored value
  is Sol/s/1e12, so ths*1e12 recovers the Sol/s count; the per-board tooltip and
  the hashrate KPI card now label Equihash as Sol/s with an SI prefix.

Unit tests (equihash_hashrate_units) + health tests pass; SELFTEST PASS.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 16:45:45 -06:00
noahandClaude Opus 4.8 93bd528430 health: PSU-fault colour rules + per-board actual/expected tooltip (round 18 #2/#3/#4b)
- #2 A PSU fault while the miner is mining is now a warning (yellow) not a failure
  (red); a fault on a non-mining miner stays red. Fixes WhatsMiners flagged red
  while running fine.
- #4b A PSU fault no longer greys the hashboards. Board colour reflects the board's
  own state: running -> green, faulted (e.g. WhatsMiner 540/560) -> red, and grey
  ONLY when the board is genuinely not detected. Stall-reddened boards the fault
  codes don't name are still exonerated to green; undetected boards stay grey.
- #3 The per-board tooltip shows actual / expected hashrate (e.g. "2  .  33.5 / 35.0
  TH/s"); a not-detected board shows "not detected". Adds MinerRow.board_expected_
  hashrates (from BoardData.expected_hashrate) + an algorithm-aware hashrate unit
  (Equihash -> Sol/s, groundwork for #7).

Health tests updated + pass; SELFTEST PASS.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 16:36:00 -06:00
36 changed files with 2554 additions and 388 deletions
+20
View File
@@ -0,0 +1,20 @@
# cargo-audit configuration (read by `cargo audit` from the project root).
#
# The two entries below are accepted, documented exceptions -- both live only in
# the wx-rs BUILD-dependency tree (reqwest 0.11, used by wx-rs's build.rs to
# download the wxWidgets source on Windows/macOS). On Linux download_dist()
# returns before ever constructing an HTTP client, and none of this is linked
# into the runtime binary, which talks to miners over asic-rs's reqwest 0.13
# (hyper 1.x / h2 0.4). The build tree is fully vendored and offline, so these
# cannot be upgraded without re-vendoring a newer reqwest.
#
# Re-review whenever the vendored dependency set is refreshed.
[advisories]
ignore = [
# h2 0.3 unbounded empty DATA frames (DoS). Build-time only; our build-time
# HTTP client only fetches a fixed HTTPS URL, and only on Windows/macOS.
"RUSTSEC-2026-0258",
# rustls-pemfile 1.0.4 unmaintained. Same build-only reqwest 0.11 subtree.
"RUSTSEC-2025-0134",
]
+45 -3
View File
@@ -11,6 +11,9 @@ jobs:
runs-on: alkane-ci
env:
WX_PREFIX: /root/.cache/wx-3.3.3-linux
# Set once for the whole job so build/clippy/test/bench steps don't each
# re-export it (round 18 #12).
WX_RS_WXCONFIG: /root/.cache/wx-3.3.3-linux/bin/wx-config
steps:
- name: Checkout (full history for tags)
uses: actions/checkout@v4
@@ -49,6 +52,12 @@ jobs:
echo "wx prefix restored from cache"
fi
- name: Clippy (our crate, warnings are errors)
if: steps.ver.outputs.release == 'true'
run: |
rustup component add clippy >/dev/null 2>&1 || true
cargo clippy -p alkane-gui --no-deps --release --bins --offline -- -D warnings
- name: Set crate version to ${{ steps.ver.outputs.version }}
if: steps.ver.outputs.release == 'true'
run: |
@@ -58,19 +67,16 @@ jobs:
- name: Build release
if: steps.ver.outputs.release == 'true'
run: |
export WX_RS_WXCONFIG="$WX_PREFIX/bin/wx-config"
cargo build --release -p alkane-gui --offline
- name: Unit tests
if: steps.ver.outputs.release == 'true'
run: |
export WX_RS_WXCONFIG="$WX_PREFIX/bin/wx-config"
cargo test -p alkane-gui --offline
- name: Microbenchmarks
if: steps.ver.outputs.release == 'true'
run: |
export WX_RS_WXCONFIG="$WX_PREFIX/bin/wx-config"
cargo test -p alkane-gui --release --offline -- --ignored --nocapture bench_
- name: Headless UI self-test
@@ -81,6 +87,42 @@ jobs:
BIN=target/release/alkane-toolkit
xvfb-run -a env GDK_BACKEND=x11 ALKANE_SELFTEST=1 "$BIN"
- name: Dependency audit (best-effort)
if: steps.ver.outputs.release == 'true'
continue-on-error: true
run: |
if command -v cargo-audit >/dev/null 2>&1; then
cargo audit || echo "cargo audit reported findings (accepted ones in .cargo/audit.toml)"
else
echo "cargo-audit not installed on this runner; skipping"
fi
# Refresh the committed README badges from live metrics and push any change
# back to main. Best-effort: a locked-down runner that can't push must not
# fail the release. A badges-only push does not bump the version (see
# compute-version.sh), so it does not loop back into another release.
- name: Refresh badges
if: steps.ver.outputs.release == 'true'
continue-on-error: true
env:
TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
PASS=$(cargo test -p alkane-gui --offline 2>&1 \
| grep -hoE '[0-9]+ passed' | grep -oE '[0-9]+' | awk '{s+=$1} END{print s+0}')
python3 ci/gen-badges.py --tests "${PASS:-0}" --bench "row-render + scan-parse"
if [ -n "$(git status --porcelain badges)" ]; then
git config user.name "alkane-ci"
git config user.email "ci@bluefla.re"
git add badges
git commit -m "ci: refresh README badges [skip release]"
API="${GITHUB_API_URL:-https://gitea.bluefla.re/api/v1}"
HOST="${API%/api/v1}"
git push "${HOST}/${GITHUB_REPOSITORY}.git" "HEAD:main" \
-c http.extraheader="Authorization: token ${TOKEN}" || echo "badge push skipped"
else
echo "badges unchanged"
fi
- name: Package artifact
if: steps.ver.outputs.release == 'true'
id: pkg
+74
View File
@@ -0,0 +1,74 @@
name: verify
# Pre-merge quality gate: clippy + build + tests + microbenchmarks + the headless
# UI self-test, plus a best-effort dependency audit. Runs on pull requests and on
# pushes to any branch EXCEPT main (main is gated by release.yml, which repeats
# these checks before it cuts a release -- so no work is duplicated on main).
on:
pull_request:
push:
branches-ignore: [main]
jobs:
verify:
runs-on: alkane-ci
env:
WX_PREFIX: /root/.cache/wx-3.3.3-linux
WX_RS_WXCONFIG: /root/.cache/wx-3.3.3-linux/bin/wx-config
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Install build dependencies
run: |
apt-get update -qq
apt-get install -y -qq --no-install-recommends \
libssl-dev pkg-config ca-certificates >/dev/null
- name: Cache vendored wxWidgets build
uses: actions/cache@v4
with:
path: /root/.cache/wx-3.3.3-linux
key: wx-3.3.3-${{ runner.os }}-${{ hashFiles('thirdparty/wx-rs/VERSION') }}
- name: Build wxWidgets (once, then cached)
run: |
if [ ! -x "$WX_PREFIX/bin/wx-config" ]; then
bash scripts/build-wx-linux.sh
else
echo "wx prefix restored from cache"
fi
- name: Clippy (our crate, warnings are errors)
run: |
rustup component add clippy >/dev/null 2>&1 || true
cargo clippy -p alkane-gui --no-deps --release --bins --offline -- -D warnings
- name: Build
run: cargo build --release -p alkane-gui --offline
- name: Unit tests
run: cargo test -p alkane-gui --offline
- name: Microbenchmarks
run: cargo test -p alkane-gui --release --offline -- --ignored --nocapture bench_
- name: Headless UI self-test
run: |
apt-get update -qq && apt-get install -y -qq --no-install-recommends \
xvfb xauth dbus-x11 fonts-dejavu-core >/dev/null
BIN=target/release/alkane-toolkit
xvfb-run -a env GDK_BACKEND=x11 ALKANE_SELFTEST=1 "$BIN"
# Advisory audit is best-effort: it needs the RustSec DB over the network,
# which the vendored/offline build otherwise never touches, so a locked-down
# runner must not fail the gate on it. Accepted advisories live in
# .cargo/audit.toml.
- name: Dependency audit (best-effort)
continue-on-error: true
run: |
if command -v cargo-audit >/dev/null 2>&1; then
cargo audit || echo "cargo audit reported findings (see .cargo/audit.toml for accepted ones)"
else
echo "cargo-audit not installed on this runner; skipping"
fi
+13 -1
View File
@@ -13,9 +13,21 @@ members = [
[workspace.package]
version = "0.1.0"
edition = "2021"
license = "MIT OR Apache-2.0"
license = "MIT"
[workspace.dependencies]
thiserror = "2"
serde = { version = "1", features = ["derive"] }
sha2 = "0.10"
# Release binary: small, self-contained, and fast enough for a fleet GUI whose
# hot path is network I/O, not CPU (round 18 #12). opt-level "s" + fat LTO +
# one codegen unit + symbol stripping cut the binary substantially. panic stays
# "unwind" on purpose: the scan runs many miners on tokio tasks and the wx event
# dispatch relies on unwinding so one miner's panic never aborts the whole app.
[profile.release]
opt-level = "s"
lto = "fat"
codegen-units = 1
strip = true
+21
View File
@@ -0,0 +1,21 @@
MIT License
Copyright (c) 2026 Blueflare
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
+99 -21
View File
@@ -1,38 +1,116 @@
# alkane-toolkit
Cross-platform desktop toolkit (Rust core, native GUI) to install **stock** or
**alkaneOS** firmware on ASIC miner control boards, whatever they currently run
(stock, Vnish/AnthillOS, Braiins OS+, LuxOS, ePIC, BixBit, WardenOS).
[![CI](https://gitea.bluefla.re/blueflare/alkane-toolkit/actions/workflows/release.yml/badge.svg)](https://gitea.bluefla.re/blueflare/alkane-toolkit/actions)
![tests](badges/tests.svg)
![coverage](badges/coverage.svg)
![bench](badges/bench.svg)
![lines of code](badges/loc.svg)
![clippy](badges/quality.svg)
![dependencies](badges/dependencies.svg)
![license](badges/license.svg)
Sibling to [alkane-sdk](https://gitea.bluefla.re/blueflare/alkane-sdk): the SDK
owns board knowledge and build outputs; this toolkit is the orchestration
engine and operator UI that executes its install recipes safely.
A cross-platform desktop toolkit for discovering, monitoring, and re-flashing
ASIC miners. It scans a fleet over the network, shows live health and hashrate
in a sortable table, and installs **stock** or **alkaneOS** firmware onto a
control board whatever it currently runs (stock, VNish/AnthillOS, Braiins OS+,
LuxOS, ePIC, HiveOn, BixBit, WardenOS).
## Status
The core and UI are pure Rust; the native window is wxWidgets driven through a
vendored, patched [wx-rs](thirdparty/wx-rs) bridge, so there is no Electron,
no web view, and a single self-contained binary per platform.
M1 primary view ships: discovery (vendored asic-rs 0.8.1) + the UI-SPEC
table (6 KPIs, sortable/drag-reorderable columns, row checkboxes, scan-range
editor, Excel-style filter, columns panel). Pure-Rust GUI on wxWidgets via
vendored + patched wx-rs (docs/adr/0002, 0003).
## What it does
## Build + run (Debian)
- **Discover** a fleet by CIDR or IP range and identify each miner's make,
model, control board, and firmware (via a vendored [asic-rs](vendor/asic-rs)).
- **Monitor** hashrate vs. expected, per-board health, chip temperatures, fans,
PSU state, and pool workers, with an Excel-style filter and drag-reorderable
columns.
- **Operate** miners from a right-click menu: flash the locate light, pause /
resume, restart, set a power or hashrate target, select a firmware profile
(LuxOS/VNish presets), configure pools, set the timezone, and change the
password -- each action offered only when every selected miner supports it.
- **Install firmware**: push stock or aftermarket images, or revert an
aftermarket miner to stock, behind a typed confirmation.
Discovery and telemetry are read-only and safe to run against any fleet; every
mutating action is capability-gated and, where destructive, confirmed.
## Build and run (Debian/Ubuntu)
```sh
scripts/build-wx-linux.sh # once: builds vendored wx 3.3.3 to ~/.cache
scripts/build-wx-linux.sh # once: builds the vendored wxWidgets 3.3.3 into ~/.cache
scripts/build-gui-linux.sh # cargo build --release -p alkane-gui
~/.cache/alkane-tk-target/release/alkane-toolkit
```
Windows/macOS: `scripts/build-gui-windows.sh` (needs a Windows/msys2
toolchain) and `scripts/build-gui-macos.sh` (needs a Mac) - the GUI code is
shared; only the C++ bridge + wx differ per platform.
Runtime needs GTK 3: `sudo apt install libgtk-3-0`. To explore the UI with no
hardware, run the offline demo fleet:
See `docs/IMPLEMENTATION-PLAN.md` for the roadmap.
```sh
ALKANE_FAKE_SCAN=1 alkane-toolkit
```
## Hard rules (from alkane-sdk `docs/install-methods.md`, encoded in code)
Windows and macOS share all GUI code; only the C++ bridge and wx build differ
(`scripts/build-gui-windows.sh` needs an msys2 toolchain, `-macos.sh` needs a
Mac).
1. Never write the bootloader/secure region.
## Command-line probe
`miner_probe` is a headless companion for hardware checks that should not go
through the window event loop -- discovery, telemetry, and each write action:
```sh
miner_probe scan 10.0.0.0/24 # discover + telemetry (TSV)
miner_probe presets 10.0.0.5 # list a firmware's selectable profiles
miner_probe setpreset 10.0.0.5 540MHz
```
Run `miner_probe` with no arguments for the full verb list.
## Development
```sh
export WX_RS_WXCONFIG="$HOME/.cache/wx-3.3.3-linux/bin/wx-config"
export CARGO_TARGET_DIR="$HOME/.cache/alkane-tk-target" # keep the target tree off the source share
cargo test -p alkane-gui # unit tests
cargo test -p alkane-gui --release -- --ignored bench_ # microbenchmarks
cargo clippy -p alkane-gui --no-deps --bins -- -D warnings # lint gate
xvfb-run -a env ALKANE_SELFTEST=1 \
"$CARGO_TARGET_DIR/release/alkane-toolkit" # headless UI self-test
ci/coverage.sh --summary-only # coverage (tests + self-test)
```
CI mirrors these: `verify.yml` runs the lint, tests, benchmarks, self-test, and
a best-effort dependency audit on every pull request and branch push;
`release.yml` repeats them on `main` and cuts an `X.Y.Z` release with the built
binary attached when the change warrants it. Dependencies are vendored under
`vendor/`, so builds never touch the network.
## Architecture
- `crates/alkane-gui` -- the application: scan engine, data model, wxWidgets UI,
and the `miner_probe` CLI (the other `crates/alkane-*` are early scaffolding).
- `vendor/asic-rs` -- the miner-discovery and control library, vendored and
extended through numbered patches under `thirdparty/asic-rs/patches`.
- `thirdparty/wx-rs` -- the patched wxWidgets bridge (see `docs/adr/0002`,
`0003`).
See [`docs/IMPLEMENTATION-PLAN.md`](docs/IMPLEMENTATION-PLAN.md) for the roadmap
and [`docs/aftermarket-parity-roadmap.md`](docs/aftermarket-parity-roadmap.md)
for the firmware config/scan parity work.
## Firmware safety rules
Encoded in code, from alkane-sdk `docs/install-methods.md`:
1. Never write the bootloader or secure region.
2. Verify on a channel the installer does not control.
3. Reboot is root-only; a dropped SSH connection can be success.
4. A packer is per board; never reuse across boards.
3. Reboot is root-only; a dropped SSH connection can still be success.
4. A packer is per board; never reuse one across boards.
5. Boot-switch handling is an explicit, verified step.
## License
Licensed under the [MIT license](LICENSE).
+19
View File
@@ -0,0 +1,19 @@
<svg xmlns="http://www.w3.org/2000/svg" width="206.0" height="20" role="img" aria-label="bench: row-render + scan-parse">
<title>bench: row-render + scan-parse</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="206.0" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="44.5" height="20" fill="#555"/>
<rect x="44.5" width="161.5" height="20" fill="#007ec6"/>
<rect width="206.0" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="22.2" y="15" fill="#010101" fill-opacity=".3">bench</text>
<text x="22.2" y="14">bench</text>
<text x="125.2" y="15" fill="#010101" fill-opacity=".3">row-render + scan-parse</text>
<text x="125.2" y="14">row-render + scan-parse</text>
</g>
</svg>

After

Width:  |  Height:  |  Size: 993 B

+19
View File
@@ -0,0 +1,19 @@
<svg xmlns="http://www.w3.org/2000/svg" width="95.5" height="20" role="img" aria-label="coverage: 46%">
<title>coverage: 46%</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="95.5" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="64.0" height="20" fill="#555"/>
<rect x="64.0" width="31.5" height="20" fill="#dfb317"/>
<rect width="95.5" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="32.0" y="15" fill="#010101" fill-opacity=".3">coverage</text>
<text x="32.0" y="14">coverage</text>
<text x="79.8" y="15" fill="#010101" fill-opacity=".3">46%</text>
<text x="79.8" y="14">46%</text>
</g>
</svg>

After

Width:  |  Height:  |  Size: 919 B

+19
View File
@@ -0,0 +1,19 @@
<svg xmlns="http://www.w3.org/2000/svg" width="121.5" height="20" role="img" aria-label="dependencies: 349">
<title>dependencies: 349</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="121.5" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="90.0" height="20" fill="#555"/>
<rect x="90.0" width="31.5" height="20" fill="#007ec6"/>
<rect width="121.5" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="45.0" y="15" fill="#010101" fill-opacity=".3">dependencies</text>
<text x="45.0" y="14">dependencies</text>
<text x="105.8" y="15" fill="#010101" fill-opacity=".3">349</text>
<text x="105.8" y="14">349</text>
</g>
</svg>

After

Width:  |  Height:  |  Size: 940 B

+19
View File
@@ -0,0 +1,19 @@
<svg xmlns="http://www.w3.org/2000/svg" width="89.0" height="20" role="img" aria-label="license: MIT">
<title>license: MIT</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="89.0" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="57.5" height="20" fill="#555"/>
<rect x="57.5" width="31.5" height="20" fill="#007ec6"/>
<rect width="89.0" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="28.8" y="15" fill="#010101" fill-opacity=".3">license</text>
<text x="28.8" y="14">license</text>
<text x="73.2" y="15" fill="#010101" fill-opacity=".3">MIT</text>
<text x="73.2" y="14">MIT</text>
</g>
</svg>

After

Width:  |  Height:  |  Size: 915 B

+19
View File
@@ -0,0 +1,19 @@
<svg xmlns="http://www.w3.org/2000/svg" width="141.0" height="20" role="img" aria-label="lines of code: 13.2k">
<title>lines of code: 13.2k</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="141.0" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="96.5" height="20" fill="#555"/>
<rect x="96.5" width="44.5" height="20" fill="#007ec6"/>
<rect width="141.0" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="48.2" y="15" fill="#010101" fill-opacity=".3">lines of code</text>
<text x="48.2" y="14">lines of code</text>
<text x="118.8" y="15" fill="#010101" fill-opacity=".3">13.2k</text>
<text x="118.8" y="14">13.2k</text>
</g>
</svg>

After

Width:  |  Height:  |  Size: 952 B

+19
View File
@@ -0,0 +1,19 @@
<svg xmlns="http://www.w3.org/2000/svg" width="95.5" height="20" role="img" aria-label="clippy: clean">
<title>clippy: clean</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="95.5" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="51.0" height="20" fill="#555"/>
<rect x="51.0" width="44.5" height="20" fill="#4c1"/>
<rect width="95.5" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="25.5" y="15" fill="#010101" fill-opacity=".3">clippy</text>
<text x="25.5" y="14">clippy</text>
<text x="73.2" y="15" fill="#010101" fill-opacity=".3">clean</text>
<text x="73.2" y="14">clean</text>
</g>
</svg>

After

Width:  |  Height:  |  Size: 916 B

+19
View File
@@ -0,0 +1,19 @@
<svg xmlns="http://www.w3.org/2000/svg" width="121.5" height="20" role="img" aria-label="tests: 99 passing">
<title>tests: 99 passing</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="121.5" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="44.5" height="20" fill="#555"/>
<rect x="44.5" width="77.0" height="20" fill="#4c1"/>
<rect width="121.5" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="22.2" y="15" fill="#010101" fill-opacity=".3">tests</text>
<text x="22.2" y="14">tests</text>
<text x="83.0" y="15" fill="#010101" fill-opacity=".3">99 passing</text>
<text x="83.0" y="14">99 passing</text>
</g>
</svg>

After

Width:  |  Height:  |  Size: 935 B

+8 -5
View File
@@ -2,9 +2,10 @@
# Compute the next release version for alkane-toolkit from the latest release
# tag and the paths changed since it. Version scheme X.Y.Z:
# X - major, bumped manually (ci/version-x.txt); a bump resets Y.Z to 0.0
# Y - backend-logic changes (core/discovery/access/flash/artifacts/cli,
# scan+model+main in the GUI crate, build/CI config); resets Z to 0
# Z - UI changes (the GUI view + fixtures + the wx-rs widget bridge)
# Y - backend-logic changes (the alkane-* crates and any GUI crate source
# other than the view files below, plus vendored deps and build/CI config);
# resets Z to 0
# Z - UI changes (the GUI view: ui.rs + fixtures.rs + bin/ + the wx-rs bridge)
# When both backend and UI changed, backend wins (bump Y). Docs-only changes
# produce no release.
#
@@ -35,9 +36,11 @@ crates/alkane-gui/src/bin/*)
ui=true ;;
crates/alkane-core/*|crates/alkane-discovery/*|crates/alkane-access/*|\
crates/alkane-flash/*|crates/alkane-artifacts/*|crates/alkane-cli/*|\
crates/alkane-gui/src/scan.rs|crates/alkane-gui/src/model.rs|\
crates/alkane-gui/src/main.rs|Cargo.toml|Cargo.lock|.gitea/*|ci/*|scripts/*|\
crates/alkane-gui/src/*|Cargo.toml|Cargo.lock|.gitea/*|ci/*|scripts/*|\
vendor/*|thirdparty/asic-rs/*)
# Any other GUI source file (naming, scan, model, pool_prefs, restore,
# access_probe, credentials, ...) is backend logic. ui.rs/fixtures.rs/bin
# match the UI arm above first, so they still bump Z, not Y.
backend=true ;;
*) : ;; # docs, HANDOFF, README, thirdparty/wxwidgets tree: no bump
esac
+33
View File
@@ -0,0 +1,33 @@
#!/usr/bin/env bash
# Measure line coverage from BOTH the unit tests AND the headless UI self-test.
#
# The self-test (ALKANE_SELFTEST=1) builds the real wxWidgets table, renders every
# fixture through the real widgets, and checks each cell against the model -- it
# exercises most of ui.rs. Because it runs as a separate binary invocation, a plain
# `cargo llvm-cov` (which only runs the #[test]s) never counts it, so ui.rs shows
# ~4% even though it is integration-tested. This combines both runs' coverage.
#
# Usage: ci/coverage.sh [extra `cargo llvm-cov report` args, e.g. --summary-only]
set -euo pipefail
export WX_RS_WXCONFIG="${WX_RS_WXCONFIG:-$HOME/.cache/wx-3.3.3-linux/bin/wx-config}"
# A display for the self-test's real widgets.
need_xvfb() { command -v xvfb-run >/dev/null 2>&1; }
cargo llvm-cov clean --workspace
# 1. Unit tests.
cargo llvm-cov --no-report -p alkane-gui --bin alkane-toolkit
# 2. Headless UI self-test, under the same instrumentation, its coverage appended.
if need_xvfb; then
xvfb-run -a env GDK_BACKEND=x11 ALKANE_SELFTEST=1 \
cargo llvm-cov run --no-report --bin alkane-toolkit
else
echo "coverage.sh: xvfb-run not found; skipping the self-test run (unit tests only)" >&2
fi
# 3. Merged report, our source only (vendored asic-rs + the patched wx-rs bridge
# are out of scope).
cargo llvm-cov report --ignore-filename-regex '(thirdparty|vendor)/' "$@"
+165
View File
@@ -0,0 +1,165 @@
#!/usr/bin/env python3
"""Generate self-contained shields-style SVG badges into badges/.
Self-hosted Gitea renders a README's relative image links straight from the
repo, so committing the SVGs (rather than depending on an external badge
service that would have to reach a possibly-private Gitea) is the robust choice.
CI regenerates them from live metrics and commits any changes back.
Usage:
gen-badges.py --tests N --coverage PCT --bench "label" [--out badges]
Metrics not passed on the command line are computed here (LOC from the source
tree, dependency count from Cargo.lock, license from Cargo.toml).
"""
import argparse
import os
import re
import sys
# Approximate per-character width at 11px DejaVu Sans, in 1/10 px, matching the
# shields "flat" look closely enough for a fixed-width monospace-ish render.
CHAR_W = 6.5
PAD = 6.0
COLORS = {
"green": "#4c1",
"brightgreen": "#4c1",
"yellowgreen": "#a4a61d",
"yellow": "#dfb317",
"orange": "#fe7d37",
"red": "#e05d44",
"blue": "#007ec6",
"lightgrey": "#9f9f9f",
"grey": "#555",
}
def text_width(s: str) -> float:
return len(s) * CHAR_W + 2 * PAD
def badge_svg(label: str, message: str, color: str) -> str:
color = COLORS.get(color, color)
lw = round(text_width(label), 1)
mw = round(text_width(message), 1)
total = round(lw + mw, 1)
lx = round(lw / 2, 1)
mx = round(lw + mw / 2, 1)
# Text is drawn twice (a dark shadow then the light glyphs) for the shields look.
return f'''<svg xmlns="http://www.w3.org/2000/svg" width="{total}" height="20" role="img" aria-label="{label}: {message}">
<title>{label}: {message}</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="{total}" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="{lw}" height="20" fill="#555"/>
<rect x="{lw}" width="{mw}" height="20" fill="{color}"/>
<rect width="{total}" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="{lx}" y="15" fill="#010101" fill-opacity=".3">{label}</text>
<text x="{lx}" y="14">{label}</text>
<text x="{mx}" y="15" fill="#010101" fill-opacity=".3">{message}</text>
<text x="{mx}" y="14">{message}</text>
</g>
</svg>
'''
def count_loc(root: str) -> int:
total = 0
for base in ("crates",):
for dirpath, _dirs, files in os.walk(os.path.join(root, base)):
for f in files:
if f.endswith(".rs"):
try:
with open(os.path.join(dirpath, f), encoding="utf-8", errors="ignore") as fh:
total += sum(1 for _ in fh)
except OSError:
pass
return total
def count_deps(root: str) -> int:
lock = os.path.join(root, "Cargo.lock")
try:
with open(lock, encoding="utf-8") as fh:
return sum(1 for line in fh if line.startswith("name = "))
except OSError:
return 0
def read_license(root: str) -> str:
try:
with open(os.path.join(root, "Cargo.toml"), encoding="utf-8") as fh:
for line in fh:
m = re.match(r'\s*license\s*=\s*"([^"]+)"', line)
if m:
return m.group(1)
except OSError:
pass
return "unknown"
def loc_color(n: int) -> str:
return "blue"
def cov_color(pct: float) -> str:
if pct >= 80:
return "brightgreen"
if pct >= 60:
return "yellowgreen"
if pct >= 40:
return "yellow"
if pct >= 20:
return "orange"
return "red"
def human(n: int) -> str:
if n >= 1000:
return f"{n / 1000:.1f}k".replace(".0k", "k")
return str(n)
def main() -> int:
ap = argparse.ArgumentParser()
ap.add_argument("--out", default="badges")
ap.add_argument("--root", default=".")
ap.add_argument("--tests", type=int, default=None)
ap.add_argument("--coverage", type=float, default=None)
ap.add_argument("--bench", default=None)
ap.add_argument("--clippy", default="clean")
args = ap.parse_args()
os.makedirs(os.path.join(args.root, args.out), exist_ok=True)
def write(name, label, message, color):
path = os.path.join(args.root, args.out, name + ".svg")
with open(path, "w", encoding="utf-8") as fh:
fh.write(badge_svg(label, message, color))
print(f"wrote {path}: {label}={message}")
loc = count_loc(args.root)
deps = count_deps(args.root)
lic = read_license(args.root)
write("loc", "lines of code", human(loc), loc_color(loc))
write("license", "license", lic, "blue")
write("dependencies", "dependencies", str(deps), "blue")
write("quality", "clippy", args.clippy, "brightgreen" if args.clippy == "clean" else "orange")
if args.tests is not None:
write("tests", "tests", f"{args.tests} passing", "brightgreen")
if args.coverage is not None:
write("coverage", "coverage", f"{args.coverage:.0f}%", cov_color(args.coverage))
if args.bench is not None:
write("bench", "bench", args.bench, "blue")
return 0
if __name__ == "__main__":
sys.exit(main())
+75 -20
View File
@@ -61,10 +61,22 @@ fn endpoint(_firmware: &str) -> &'static str {
/// could not run at all.
pub fn probe_access(ip: &str, make: &str, user: &str, pass: &str) -> Result<Option<bool>, String> {
if make.eq_ignore_ascii_case("whatsminer") {
return Ok(probe_whatsminer_access(ip, &whatsminer_password_candidates()));
// Try the caller's saved scan password first (round 18 #12: it was being
// ignored for WhatsMiner, so a miner opened with the operator's real
// password was mis-reported as locked), then the per-firmware override and
// factory defaults. All attempts are non-mutating.
let mut candidates = Vec::new();
if !pass.is_empty() {
candidates.push(pass.to_string());
}
for c in whatsminer_password_candidates() {
if !candidates.contains(&c) {
candidates.push(c);
}
}
return Ok(probe_whatsminer_access(ip, &candidates));
}
let url = format!("http://{ip}{}", endpoint(make));
let userpass = format!("{user}:{pass}");
let mut cmd = Command::new("curl");
cmd.args([
"-s",
@@ -73,15 +85,18 @@ pub fn probe_access(ip: &str, make: &str, user: &str, pass: &str) -> Result<Opti
"-w",
"%{http_code}",
"--digest",
"-u",
&userpass,
"--connect-timeout",
"5",
"--max-time",
"9",
"-K",
"-", // read the rest of the config (the credentials) from stdin
&url,
]);
let out = wait_with_timeout(cmd, Duration::from_secs(12))?;
// The user:pass goes through a curl config on stdin, never argv, so it can't
// be read from the process list (round 18 #12).
let config = format!("user = \"{}\"\n", curl_config_quote(&format!("{user}:{pass}")));
let out = wait_with_timeout(cmd, Duration::from_secs(12), Some(config.as_bytes()))?;
// 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);
@@ -89,11 +104,25 @@ pub fn probe_access(ip: &str, make: &str, user: &str, pass: &str) -> Result<Opti
}
/// 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;
/// black-holed host). `stdin_data`, when set, is written to the child's stdin and
/// the pipe closed -- used to feed a curl config (with the credentials) instead
/// of putting them on the command line (round 18 #12).
fn wait_with_timeout(
mut cmd: Command,
timeout: Duration,
stdin_data: Option<&[u8]>,
) -> Result<std::process::Output, String> {
use std::io::{Read, Write};
cmd.stdout(std::process::Stdio::piped()).stderr(std::process::Stdio::piped());
if stdin_data.is_some() {
cmd.stdin(std::process::Stdio::piped());
}
let mut child = cmd.spawn().map_err(|e| format!("spawn curl: {e}"))?;
if let Some(data) = stdin_data {
if let Some(mut si) = child.stdin.take() {
let _ = si.write_all(data);
} // dropping `si` closes the pipe so curl stops reading the config
}
let start = std::time::Instant::now();
loop {
match child.try_wait().map_err(|e| e.to_string())? {
@@ -111,6 +140,7 @@ fn wait_with_timeout(mut cmd: Command, timeout: Duration) -> Result<std::process
None => {
if start.elapsed() >= timeout {
let _ = child.kill();
let _ = child.wait(); // reap so we never leave a zombie (round 18 #12)
return Err("curl timed out".into());
}
std::thread::sleep(Duration::from_millis(100));
@@ -119,6 +149,11 @@ fn wait_with_timeout(mut cmd: Command, timeout: Duration) -> Result<std::process
}
}
/// Escape a value for a curl `--config` file (double-quoted string).
fn curl_config_quote(s: &str) -> String {
s.replace('\\', "\\\\").replace('"', "\\\"")
}
/// Passwords to try for a WhatsMiner access check: a user-set per-firmware
/// override (round 12 #13) wins; otherwise the two factory defaults ("admin" for
/// V1/V2, "super" for V3). All attempts are non-mutating, so trying both is safe.
@@ -205,23 +240,39 @@ fn wm_aes_ecb_enc(pwd_md5: &str, data: &str) -> Option<String> {
fn probe_whatsminer_access(ip: &str, passwords: &[String]) -> Option<bool> {
let timeout = Duration::from_secs(6);
let mut reachable = false;
// A transient error on one candidate must not abandon the others (round 18 #12):
// skip to the next candidate, but remember it happened so we never report a
// confident "locked" when the answer was really indeterminate.
let mut errored = false;
for pass in passwords {
// 1. get_token (no auth) -> salt / newsalt / time.
let tok_resp = match wm_rpc(ip, "{\"command\":\"get_token\"}", timeout) {
Ok(s) => s,
Err(_) => return None,
Err(_) => {
errored = true;
continue;
}
};
let v: serde_json::Value = match serde_json::from_str(&tok_resp) {
Ok(v) => v,
Err(_) => return None,
Err(_) => {
errored = true;
continue;
}
};
let Some(msg) = v.get("Msg") else { return None };
let (Some(salt), Some(newsalt), Some(time)) = (
msg.get("salt").and_then(|s| s.as_str()),
msg.get("newsalt").and_then(|s| s.as_str()),
msg.get("time").and_then(|s| s.as_str()),
) else {
return None;
let (Some(salt), Some(newsalt), Some(time)) = v
.get("Msg")
.map(|msg| {
(
msg.get("salt").and_then(|s| s.as_str()),
msg.get("newsalt").and_then(|s| s.as_str()),
msg.get("time").and_then(|s| s.as_str()),
)
})
.unwrap_or((None, None, None))
else {
errored = true;
continue;
};
reachable = true;
// 2. Derive the md5crypt password hash + write-token from the password.
@@ -239,15 +290,19 @@ fn probe_whatsminer_access(ip: &str, passwords: &[String]) -> Option<bool> {
let payload = format!("{{\"enc\":1,\"data\":\"{enc}\"}}");
let resp = match wm_rpc(ip, &payload, timeout) {
Ok(s) => s,
Err(_) => return None,
Err(_) => {
errored = true;
continue;
}
};
if resp.contains("\"enc\"") {
return Some(false); // accepted -> unlocked/writable
}
// rejected -> try the next candidate password
}
// Reached the miner and every candidate password was rejected -> locked.
if reachable { Some(true) } else { None }
// Only report "locked" when we cleanly reached the miner and every candidate
// was rejected with no transient errors; otherwise the result is indeterminate.
if reachable && !errored { Some(true) } else { None }
}
#[cfg(test)]
+85 -3
View File
@@ -1,6 +1,6 @@
//! 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
//! and 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:
@@ -39,12 +39,17 @@ fn load_creds() -> Option<(String, String)> {
}
fn factory() -> MinerFactory {
// This diagnostic CLI is a separate binary from the GUI, so it cannot share
// the GUI's credentials::configured_factory. It applies only the global scan
// credentials to every firmware; the GUI's per-firmware credential overrides
// are NOT read here (round 18 #12), which the message below makes explicit so a
// probe result is never mistaken for what the GUI (with overrides) would see.
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)");
eprintln!("(using the global scan credentials; per-firmware overrides are not applied)");
} else {
eprintln!("(no saved credentials -- backends use their default auth)");
}
@@ -300,13 +305,15 @@ async fn msgs(ip_s: &str) {
println!(" fans(rpm)={fans:?} psu_fans={}", d.psu_fans.len());
for b in d.hashboards.iter() {
println!(
" board pos={} hr={:?}TH chips={:?}/{:?} board_temp={:?} outlet_temp={:?}",
" board pos={} hr={:?}TH chips={:?}/{:?} board_temp={:?} outlet_temp={:?} freq={:?}MHz volt={:?}V",
b.position,
th(&b.hashrate),
b.working_chips,
b.expected_chips,
b.board_temperature.as_ref().map(|t| t.as_celsius()),
b.outlet_chip_temperature.as_ref().map(|t| t.as_celsius()),
b.frequency.as_ref().map(|f| f.as_megahertz()),
b.voltage.as_ref().map(|v| v.as_volts()),
);
}
if d.messages.is_empty() {
@@ -598,6 +605,77 @@ async fn settune(ip_s: &str, kind: &str, value: f64) {
}
}
/// READ: list the firmware's selectable profiles/presets (roadmap G3).
async fn presets(ip_s: &str) {
let ip: std::net::IpAddr = match ip_s.parse() {
Ok(ip) => ip,
Err(e) => {
eprintln!("bad ip {ip_s}: {e}");
return;
}
};
let f = factory();
match f.scan_miner(ip).await {
Ok(Some(m)) => {
if !m.supports_presets() {
println!("{ip}: firmware does not expose named presets");
return;
}
let list = m.get_presets().await;
if list.is_empty() {
println!("{ip}: no presets reported");
return;
}
for p in list {
match (p.pretty, p.status) {
(Some(pretty), Some(status)) => println!("{}\t{pretty}\t[{status}]", p.name),
(Some(pretty), None) => println!("{}\t{pretty}", p.name),
(None, _) => println!("{}", p.name),
}
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// WRITE (reversible): select a named firmware profile/preset (roadmap G3).
/// `setpreset <ip> <name>`. Prints the prior target so it can be restored.
async fn setpreset(ip_s: &str, name: &str) {
use asic_rs::core::config::tuning::TuningConfig;
use asic_rs::core::data::miner::TuningTarget;
let ip: std::net::IpAddr = match ip_s.parse() {
Ok(ip) => ip,
Err(e) => {
eprintln!("bad ip {ip_s}: {e}");
return;
}
};
let f = factory();
match f.scan_miner(ip).await {
Ok(Some(m)) => {
let before = m.get_data().await;
eprintln!(
"target {ip}: {} {} {} (supports_presets={}); prior target = {:?}",
before.device_info.make,
before.device_info.firmware,
before.device_info.model,
m.supports_presets(),
before.tuning_target,
);
let cfg = TuningConfig::new(TuningTarget::Preset(name.to_string()));
match m.set_tuning_config(cfg, None).await {
Ok(v) => println!("set_tuning_config(preset {name}) -> Ok({v})"),
Err(e) => println!("set_tuning_config(preset {name}) -> Err: {e:#}"),
}
let after = m.get_data().await;
println!(" target now = {:?}", after.tuning_target);
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
fn main() {
let args: Vec<String> = std::env::args().collect();
let rt = match tokio::runtime::Builder::new_current_thread().enable_all().build() {
@@ -630,6 +708,8 @@ fn main() {
}
Some("msgs") if args.len() == 3 => rt.block_on(msgs(&args[2])),
Some("tune") if args.len() == 3 => rt.block_on(tune(&args[2])),
Some("presets") if args.len() == 3 => rt.block_on(presets(&args[2])),
Some("setpreset") if args.len() == 4 => rt.block_on(setpreset(&args[2], &args[3])),
Some("settune") if args.len() == 5 && matches!(args[3].as_str(), "power" | "hashrate") => {
let value: f64 = args[4].parse().unwrap_or(-1.0);
if value <= 0.0 {
@@ -651,6 +731,7 @@ fn main() {
\x20 hashrate <cidr> [<cidr>...] raw hashrate/algo dump\n\
\x20 msgs <ip> structured faults + per-board data\n\
\x20 tune <ip> structured-tuning support + capability envelope\n\
\x20 presets <ip> list selectable firmware profiles/presets\n\
\n\
WRITE (MUTATES the miner -- use the test-bed miners, not production):\n\
\x20 light <ip> <on|off> set the locate light\n\
@@ -660,6 +741,7 @@ fn main() {
\x20 restart <ip> restart/reboot\n\
\x20 setpl <ip> <watts> set power limit\n\
\x20 settune <ip> <power|hashrate> <v> set a structured tuning target (prints prior)\n\
\x20 setpreset <ip> <name> select a named firmware profile/preset (prints prior)\n\
\x20 setpools <ip> <url> <user> <pass> set the default pool group\n\
\x20 timezone <ip> [<IANA>] read (no arg) or set the timezone\n\
\x20 passwd <ip> <newpass> change the web/API password (DANGEROUS)\n\
+9 -3
View File
@@ -191,7 +191,12 @@ pub fn clear_firmware_credentials() -> std::io::Result<()> {
/// otherwise the backend falls back to its own default auth. With nothing saved
/// this is plain `MinerFactory::new()`.
pub fn configured_factory() -> MinerFactory {
let mut factory = MinerFactory::new();
// Apply the operator's configured identification timeout to every factory
// (round 18 #12: config actions / refresh / pools / flash previously used
// asic-rs's 10s default, so on a slow link they could fail to reach miners a
// longer-timeout scan had found). start_scan may still override it explicitly.
let mut factory =
MinerFactory::new().with_identification_timeout_secs(crate::scan::load_scan_timeout().max(1));
let global = load_credentials();
let per_fw = load_firmware_credentials();
if global.is_none() && per_fw.is_empty() {
@@ -216,8 +221,9 @@ mod tests {
#[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).
// process-global, so serialise against other HOME-mutating tests via the
// shared lock and restore HOME afterward (round 18 #12).
let _home = crate::model::HOME_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
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);
+13 -5
View File
@@ -9,13 +9,21 @@
use crate::model::{BoardHealth, MinerRow};
/// Escape one CSV field: quote it when it contains a comma, quote, CR or LF, and
/// double any embedded quotes.
/// Escape one CSV field: neutralise spreadsheet formula injection, then quote it
/// when it contains a comma, quote, CR or LF (doubling any embedded quotes).
///
/// Miner-supplied fields (hostname, worker, serial, ...) can start with a formula
/// trigger; prefixing a single quote makes Excel/Sheets treat the cell as text so
/// opening the export can't execute an injected formula (round 18 #12).
fn esc(s: &str) -> String {
if s.contains([',', '"', '\n', '\r']) {
format!("\"{}\"", s.replace('"', "\"\""))
let mut val = s.to_string();
if val.starts_with(['=', '+', '-', '@', '\t', '\r']) {
val.insert(0, '\'');
}
if val.contains([',', '"', '\n', '\r']) {
format!("\"{}\"", val.replace('"', "\"\""))
} else {
s.to_string()
val
}
}
+25 -7
View File
@@ -67,6 +67,12 @@ impl Board {
} else {
vec![]
};
// Per-board configured frequency/voltage for the G7 read-side tooltip demo.
let (board_frequencies, board_voltages) = if self.mining {
(vec![590.0, 590.0, 565.0], vec![13.50, 13.50, 13.35])
} else {
(vec![], 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).
@@ -104,6 +110,8 @@ impl Board {
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);
// Computed before `model` is moved into the struct literal below.
let pic_present = crate::scan::infer_pic(&model);
MinerRow {
ip: self.ip.to_string(),
selected: false,
@@ -117,6 +125,8 @@ impl Board {
hashrate_ths: self.hashrate,
expected_ths: self.expected,
board_hashrates,
board_voltages,
board_frequencies,
efficiency,
power_w: self.power,
chip_temp_c: self.temp,
@@ -173,6 +183,7 @@ impl Board {
power_limit: self.mining,
tuning: self.mining,
hashrate_target: self.mining,
supports_presets: self.mining,
firmware_flash,
pools: true,
timezone: self.mining,
@@ -183,13 +194,9 @@ impl Board {
// 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
},
// Use the same PIC inference the live scan uses (round 18 #12: the demo
// previously reimplemented a simplified version that disagreed with it).
pic_present,
// 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()),
@@ -203,6 +210,17 @@ impl Board {
} else {
Vec::new()
},
// Demo firmware presets (round 18 / G3) so the "Set profile..." dialog
// is exercisable offline on units that advertise preset support.
presets: if self.mining {
vec![
crate::model::MinerPreset { name: "default".into(), pretty: Some("2794 W ~ 121.8 TH @ 590 MHz".into()) },
crate::model::MinerPreset { name: "540MHz".into(), pretty: Some("2485 W ~ 111.5 TH @ 540 MHz".into()) },
crate::model::MinerPreset { name: "490MHz".into(), pretty: Some("2192 W ~ 101.1 TH @ 490 MHz".into()) },
]
} else {
Vec::new()
},
..Default::default()
}
}
+91 -41
View File
@@ -61,8 +61,14 @@ fn tail(s: &str, max: usize) -> String {
if s.len() <= max {
return s.to_string();
}
let start = s.len() - max;
// advance to the next line boundary so we don't cut a line in half
// Nudge the cut forward to a UTF-8 char boundary first: a raw byte offset can
// land inside a multi-byte character and slicing there would panic (round 18
// #12; miner logs are not guaranteed pure ASCII).
let mut start = s.len() - max;
while start < s.len() && !s.is_char_boundary(start) {
start += 1;
}
// then advance to the next line boundary so we don't cut a line in half
let start = s[start..]
.find('\n')
.map(|i| start + i + 1)
@@ -122,35 +128,45 @@ fn summarize_log(log: &str) -> Vec<String> {
/// VNish: unlock -> bearer -> the full miner log.
fn fetch_vnish_log(ip: &str, pass: &str) -> Result<String, String> {
let unlock = curl(&[
"-s",
"--connect-timeout",
"5",
"--max-time",
"9",
"-X",
"POST",
"-H",
"Content-Type: application/json",
"-d",
&format!("{{\"pw\":\"{pass}\"}}"),
&format!("http://{ip}/api/v1/unlock"),
])?;
// The password goes in the POST body read from stdin (-d @-), never on argv,
// and is JSON-encoded by serde so it is both un-leakable and correctly escaped
// (round 18 #12).
let body = serde_json::json!({ "pw": pass }).to_string();
let unlock = curl(
&[
"-s",
"--connect-timeout",
"5",
"--max-time",
"9",
"-X",
"POST",
"-H",
"Content-Type: application/json",
"-d",
"@-",
&format!("http://{ip}/api/v1/unlock"),
],
Some(body.as_bytes()),
)?;
let token = serde_json::from_str::<serde_json::Value>(&unlock)
.ok()
.and_then(|v| v.get("token").and_then(|t| t.as_str()).map(str::to_string))
.filter(|t| !t.is_empty())
.ok_or_else(|| "VNish unlock rejected (check the VNish password in scan credentials)".to_string())?;
let log = curl(&[
"-s",
"--connect-timeout",
"5",
"--max-time",
"12",
"-H",
&format!("Authorization: Bearer {token}"),
&format!("http://{ip}/api/v1/logs/miner"),
])?;
let log = curl(
&[
"-s",
"--connect-timeout",
"5",
"--max-time",
"12",
"-H",
&format!("Authorization: Bearer {token}"),
&format!("http://{ip}/api/v1/logs/miner"),
],
None,
)?;
if log.trim().is_empty() {
return Err("VNish returned an empty log".to_string());
}
@@ -159,17 +175,23 @@ fn fetch_vnish_log(ip: &str, pass: &str) -> Result<String, String> {
/// Stock Antminer web log (digest auth). Absent on older models (404).
fn fetch_antminer_log(ip: &str, user: &str, pass: &str) -> Result<String, String> {
let body = curl(&[
"-s",
"--digest",
"-u",
&format!("{user}:{pass}"),
"--connect-timeout",
"5",
"--max-time",
"12",
&format!("http://{ip}/cgi-bin/log.cgi"),
])?;
// Credentials go through a curl config on stdin (-K -), never on argv, so they
// can't be read from the process list (round 18 #12).
let config = format!("user = \"{}\"\n", curl_config_quote(&format!("{user}:{pass}")));
let body = curl(
&[
"-s",
"--digest",
"--connect-timeout",
"5",
"--max-time",
"12",
"-K",
"-",
&format!("http://{ip}/cgi-bin/log.cgi"),
],
Some(config.as_bytes()),
)?;
if body.contains("404 - Not Found") || body.trim().is_empty() {
return Err("this firmware does not expose a log over its web API".to_string());
}
@@ -186,17 +208,29 @@ fn fetch_whatsminer_errors(ip: &str) -> Result<String, String> {
/// Run curl and return stdout, with a hard wall-clock cap. stdout is drained on a
/// separate thread so a large log (hundreds of KB) never deadlocks on a full pipe
/// -- the reason a naive "wait then read" times out on the VNish log.
fn curl(args: &[&str]) -> Result<String, String> {
use std::io::Read;
fn curl(args: &[&str], stdin_data: Option<&[u8]>) -> Result<String, String> {
use std::io::{Read, Write};
let mut cmd = Command::new("curl");
cmd.args(args);
cmd.stdout(std::process::Stdio::piped());
cmd.stderr(std::process::Stdio::null());
if stdin_data.is_some() {
cmd.stdin(std::process::Stdio::piped());
}
let mut child = cmd.spawn().map_err(|e| format!("spawn curl: {e}"))?;
let mut stdout = child.stdout.take().ok_or("no curl stdout")?;
if let Some(data) = stdin_data {
if let Some(mut si) = child.stdin.take() {
let _ = si.write_all(data);
} // dropping `si` closes the pipe so curl stops reading the config/body
}
let stdout = child.stdout.take().ok_or("no curl stdout")?;
let reader = std::thread::spawn(move || {
// Bound the buffer: a miner-controlled response must not exhaust memory
// (round 18 #12). The viewer only keeps the last MAX_LOG_BYTES anyway, so
// read a small multiple of that and drop the rest.
const READ_CAP: u64 = (MAX_LOG_BYTES as u64) * 8; // 2 MiB
let mut buf = Vec::new();
let _ = stdout.read_to_end(&mut buf);
let _ = stdout.take(READ_CAP).read_to_end(&mut buf);
buf
});
let timeout = Duration::from_secs(20);
@@ -208,6 +242,7 @@ fn curl(args: &[&str]) -> Result<String, String> {
None => {
if start.elapsed() >= timeout {
let _ = child.kill();
let _ = child.wait(); // reap so we never leave a zombie (round 18 #12)
timed_out = true;
break;
}
@@ -222,10 +257,25 @@ fn curl(args: &[&str]) -> Result<String, String> {
Ok(String::from_utf8_lossy(&buf).into_owned())
}
/// Escape a value for a curl `--config` file (double-quoted string).
fn curl_config_quote(s: &str) -> String {
s.replace('\\', "\\\\").replace('"', "\\\"")
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn tail_does_not_panic_mid_multibyte_char() {
// A byte-offset cut can land inside a multi-byte character; tail must nudge
// to a char boundary rather than panic (round 18 #12).
let s = "\u{00e9}".repeat(200); // 400 bytes of 2-byte chars, no newlines
let out = tail(&s, 101); // cut at an odd offset -> inside a char
assert!(out.starts_with("[... earlier log trimmed ...]"));
assert!(out.len() < s.len());
}
#[test]
fn summarize_finds_pic_chains_and_errors() {
let log = "\
-1
View File
@@ -16,7 +16,6 @@ mod restore;
mod scan;
mod ui;
use wx_rs;
fn main() {
// Headless workflow self-test: render the bench-fleet fixtures through the
+256 -43
View File
@@ -2,6 +2,13 @@
use std::collections::{HashMap, HashSet};
/// Serialises tests that mutate the process-global `$HOME` (config paths read it),
/// so they never race each other under the parallel test harness (round 18 #12).
/// Lock it with `.lock().unwrap_or_else(|e| e.into_inner())` to shrug off a poison
/// from a panicking sibling test.
#[cfg(test)]
pub(crate) static HOME_TEST_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
/// A miner counts as "slow" when it is mining but running below this fraction
/// of its model's expected hashrate (UI-SPEC "Slow" band). A missing expected
/// hashrate (0.0) means the band is unknown, so the miner is never "slow".
@@ -75,6 +82,23 @@ pub fn format_hashrate_ths(ths: f64) -> Option<String> {
si_mantissa_and_prefix(ths * 1e12).map(|(num, prefix)| format!("{num}{prefix}"))
}
/// A hashrate number (no unit) for a given mining algorithm (round 18 #7). asic-rs
/// stores every hashrate normalised to "TH/s", but for Equihash the underlying
/// count is Sol/s that it reinterprets through the base H unit, so `ths * 1e12`
/// recovers the real Sol/s count. SHA256/Scrypt show the TH/s value directly
/// ("33.5"); Equihash shows the Sol/s count with an SI prefix ("167.8K"). Pair
/// with [`MinerRow::hashrate_unit`]. `None` for a non-positive reading.
pub fn hashrate_num_for(algo: &str, ths: f64) -> Option<String> {
if ths <= 0.0 {
return None;
}
if algo.eq_ignore_ascii_case("equihash") {
si_mantissa_and_prefix(ths * 1e12).map(|(num, prefix)| format!("{num}{prefix}"))
} else {
Some(format!("{ths:.1}"))
}
}
/// The actual/expected ratio, or `None` when the expected value is unknown
/// (<= 0.0) so a ratio-based color/warning never divides by zero or treats an
/// unknown expectation as a 0% shortfall.
@@ -106,12 +130,19 @@ fn combined_count(actual: Option<u32>, expected: Option<u32>) -> String {
}
}
/// An RGB colour (0-255 per channel) for a coloured text segment.
pub type Rgb = (u8, u8, u8);
/// One coloured text segment: an optional colour plus its text. Cells with
/// two-tone / multi-tone content (actual vs expected, per-fan colours) are built
/// as a `Vec<Segment>` and encoded via [`encode_segments`].
pub type Segment = (Option<Rgb>, String);
/// Encode colored text segments for a custom-rendered cell (see the wx-rs
/// `SegmentRenderer`): segments are joined by U+001F, and within a segment an
/// optional uppercase RRGGBB color is separated from its text by U+001E.
/// `decode_segments_plain` is the inverse for anything that just wants the
/// plain text (filtering, sorting, tests).
pub fn encode_segments(segs: &[(Option<(u8, u8, u8)>, String)]) -> String {
pub fn encode_segments(segs: &[Segment]) -> String {
segs.iter()
.map(|(color, text)| {
let hex = color.map(|(r, g, b)| format!("{r:02X}{g:02X}{b:02X}")).unwrap_or_default();
@@ -217,6 +248,10 @@ pub struct MinerCaps {
/// `set_tuning_config` (the firmware actively tunes by hashrate, e.g. ePIC).
/// Power targets are covered by `power_limit`.
pub hashrate_target: bool,
/// Round 18 / roadmap G3: supports selecting a named firmware preset/profile
/// via `set_tuning_config(TuningTarget::Preset)` (LuxOS profiles, VNish presets).
/// The available presets are read live into `MinerRow::presets` at scan time.
pub supports_presets: bool,
/// Whether this miner's asic-rs driver supports `upgrade_firmware`
/// (probed via `supports_upgrade_firmware()` at scan time).
pub firmware_flash: bool,
@@ -241,6 +276,7 @@ impl MinerCaps {
power_limit: self.power_limit && other.power_limit,
tuning: self.tuning && other.tuning,
hashrate_target: self.hashrate_target && other.hashrate_target,
supports_presets: self.supports_presets && other.supports_presets,
firmware_flash: self.firmware_flash && other.firmware_flash,
pools: self.pools && other.pools,
timezone: self.timezone && other.timezone,
@@ -274,6 +310,7 @@ impl MinerCaps {
|| self.power_limit
|| self.tuning
|| self.hashrate_target
|| self.supports_presets
|| self.firmware_flash
|| self.pools
|| self.timezone
@@ -365,6 +402,15 @@ pub enum HealthFacet {
Boards,
}
/// One selectable firmware preset/profile (round 18 / roadmap G3). `name` is the
/// identifier the firmware expects (e.g. LuxOS "540MHz", VNish "5560"); `pretty`
/// is an optional human summary (e.g. "2485 W ~ 111.5 TH @ 540 MHz").
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct MinerPreset {
pub name: String,
pub pretty: Option<String>,
}
/// One miner's telemetry snapshot, flattened from asic-rs `MinerData` into the
/// scalar fields the table can display. Absent metrics are `None` / empty /
/// 0.0 and render as a blank cell.
@@ -420,6 +466,15 @@ pub struct MinerRow {
/// = board 1). Drives the per-board Health tooltip (round 17 R2). Empty when
/// the firmware reports no per-board hashrate.
pub board_hashrates: Vec<f64>,
/// Per-hashboard EXPECTED hashrate in TH/s, index-aligned with the hashboards.
/// The per-board tooltip shows actual / expected (round 18 #3). Empty when the
/// firmware reports no per-board expected hashrate.
pub board_expected_hashrates: Vec<f64>,
/// Per-hashboard configured voltage (V) and frequency (MHz), index-aligned
/// with the hashboards (round 18 / roadmap G7 read side). Shown in the per-board
/// Health tooltip; 0.0 where the firmware reports no value.
pub board_voltages: Vec<f64>,
pub board_frequencies: Vec<f64>,
#[allow(dead_code)] // retained for the "slow" band; not shown as its own column
pub efficiency: f64,
pub power_w: f64,
@@ -436,6 +491,9 @@ pub struct MinerRow {
/// Current structured tuning target, rendered for display (e.g. "2832 W",
/// "96 TH/s", "preset 3550"), or None (round 17 C).
pub tuning_target_label: Option<String>,
/// The firmware's selectable named presets/profiles, read live at scan time
/// when `caps.supports_presets` (round 18 / roadmap G3). Empty otherwise.
pub presets: Vec<MinerPreset>,
/// Advertised power-target envelope in watts, when the firmware reports one
/// (round 17 C, e.g. Braiins 944-6435 W). Bounds + validate the power-target
/// prompt; `None` leaves it unbounded.
@@ -516,12 +574,17 @@ impl MinerRow {
/// live); grey (unknown) otherwise -- asic-rs has no direct PSU-fault flag, so
/// a missing wattage reading is treated as unknown, never a false "down".
pub fn power_health(&self) -> CompHealth {
// A reported power-supply fault (round 16 #2) is authoritative: red, even
// if a residual wattage is still being read.
// A miner drawing power / spinning its PSU fan / actively mining has a live
// PSU regardless of any warning flag.
let delivering = self.power_w > 0.0 || self.psu_fan_rpm > 0.0 || self.is_mining;
// A reported PSU fault while the miner is actually mining is a warning, not
// a failure -- yellow, not red (round 18 #2: some WhatsMiners flag a PSU
// error while running fine). A fault on a miner that is not mining is a real
// failure (red).
if self.faults_for(FaultComponent::Power).next().is_some() {
return CompHealth::Down;
return if self.is_mining { CompHealth::Degraded } else { CompHealth::Down };
}
if self.power_w > 0.0 || self.psu_fan_rpm > 0.0 || self.is_mining {
if delivering {
CompHealth::Ok
} else {
CompHealth::Unreachable
@@ -557,12 +620,6 @@ impl MinerRow {
.filter(|f| f.is_error && matches!(f.component, FaultComponent::Other))
}
/// True when the miner reports a power-supply fault, which means the
/// hashboards cannot be powered or evaluated (round 16 #2).
fn power_supply_faulted(&self) -> bool {
self.faults_for(FaultComponent::Power).next().is_some()
}
/// Per-fan health (round 13 #3), front-to-back / top-to-bottom in the order
/// the miner reports its fans. A spinning fan is green, unless it is running
/// well below its fastest sibling (< 50% of the max reported RPM), which is a
@@ -621,16 +678,28 @@ impl MinerRow {
if base.is_empty() {
return base;
}
// 3. A PSU fault means no board can be powered/tested -> all grey.
if self.power_supply_faulted() {
return vec![CompHealth::Unreachable; base.len()];
}
// 2. Board-specific faults are authoritative: red only the named boards,
// green the rest (overriding a stall-induced all-red).
// 2. Board-specific faults are authoritative: red the named boards. A board
// is grey ONLY when it is genuinely not detected (base Missing); a board
// that is running stays green and a faulted board is red, even when the
// PSU also reports a fault (round 18 #4b -- WhatsMiner codes 540/560 must
// show red, not grey, and boards still hashing during a PSU fault stay
// green). A whole-miner stall reds every board's base, so exonerate the
// boards the fault codes did NOT name back to healthy.
let board_faulted = |i: usize| self.faults_for(FaultComponent::Board(i)).next().is_some();
if (0..base.len()).any(board_faulted) {
for (i, h) in base.iter_mut().enumerate() {
*h = if board_faulted(i) { CompHealth::Down } else { ok };
if board_faulted(i) {
// A genuinely-undetected board stays grey ("not detected") even
// when a fault text names it: a message like "chain N not found"
// describes exactly that missing board, and grey-vs-red is the
// documented distinction (round 18 #12). Only detected boards go red.
if *h != CompHealth::Unreachable {
*h = CompHealth::Down;
}
} else if *h == CompHealth::Down {
*h = ok; // stall-reddened but not named by the fault codes
}
// else keep the base (green Ok / grey Missing).
}
}
base
@@ -736,24 +805,41 @@ impl MinerRow {
tips.push(t);
}
// Hashboards -- an operating board shows its number (counting DOWN, n-1..0,
// left to right) and hashrate; a faulted board shows its error+code; a
// board the failed PSU left untested shows "unpowered" (round 17 R2,
// round 16 #2/#3). No generic "Hashboard N: faulted" prose.
// left to right) and actual/expected hashrate; a faulted board shows its
// error+code; a board that is genuinely not detected shows "not detected"
// (round 17 R2, round 18 #3 actual/expected + #4b). No generic
// "Hashboard N: faulted" prose.
let boards = self.board_healths();
let psu_down = self.power_supply_faulted();
let n = self.hashboards.map(|v| v as usize).unwrap_or(boards.len());
let unit = self.hashrate_unit();
for i in 0..max_boards {
let fault = self.fault_texts_for(FaultComponent::Board(i));
let t = if !fault.is_empty() {
fault.join("\n")
} else if matches!(boards.get(i), Some(CompHealth::Unreachable)) && psu_down {
"unpowered (PSU fault)".to_string()
} else if matches!(boards.get(i), Some(CompHealth::Unreachable)) {
"not detected".to_string()
} else if i < n {
let num = n - 1 - i; // count down, left to right
match self.board_hashrates.get(i).copied() {
Some(hr) if hr > 0.0 => format!("{num} \u{00b7} {hr:.1} TH/s"),
let actual = self.board_hashrates.get(i).copied().unwrap_or(0.0);
let expected = self.board_expected_hashrates.get(i).copied().unwrap_or(0.0);
let a = hashrate_num_for(&self.algorithm, actual);
let e = hashrate_num_for(&self.algorithm, expected);
let mut s = match (a, e) {
(Some(a), Some(e)) => format!("{num} \u{00b7} {a} / {e} {unit}"),
(Some(a), None) => format!("{num} \u{00b7} {a} {unit}"),
_ => num.to_string(),
};
// Per-board configured frequency / voltage (round 18 / G7 read side),
// appended when the firmware reports them.
let freq = self.board_frequencies.get(i).copied().unwrap_or(0.0);
let volt = self.board_voltages.get(i).copied().unwrap_or(0.0);
if freq > 0.0 {
s.push_str(&format!(" \u{00b7} {freq:.0} MHz"));
}
if volt > 0.0 {
s.push_str(&format!(" \u{00b7} {volt:.2} V"));
}
s
} else {
String::new() // padding slot for fleet alignment
};
@@ -773,6 +859,17 @@ impl MinerRow {
}
}
/// The display unit for this miner's hashrate, by mining algorithm (round 18
/// #7). SHA256/Scrypt miners report TH/s; Equihash miners (Antminer Z15 /
/// Zcash) report in Sol/s and must not be labelled TH/s.
pub fn hashrate_unit(&self) -> &'static str {
if self.algorithm.eq_ignore_ascii_case("equihash") {
"Sol/s"
} else {
"TH/s"
}
}
/// Compact plain-text summary of component health (round 13 #3), used as the
/// Health column's filter/sort-fallback text and the base of its hover
/// tooltip. e.g. "power ok, fans 3/4, boards 3/3".
@@ -939,10 +1036,15 @@ pub enum Column {
/// Every column, in registry order. Ip first, then the default-visible set
/// (UI-SPEC order), then all remaining metrics.
pub const ALL_COLUMNS: [Column; 46] = [
pub const ALL_COLUMNS: [Column; 47] = [
Column::Ip,
Column::Hashrate,
Column::Health,
// The detailed per-board dot column (round 11 #10). Not in DEFAULT_VISIBLE
// (the Health column shows composite board health by default), but it belongs
// in ALL_COLUMNS so it is selectable in the column picker (round 18 #12: it
// was accidentally omitted, making the column unreachable).
Column::Hashboards,
Column::Power,
Column::ChipTemp,
Column::Cooling,
@@ -1154,6 +1256,12 @@ impl Column {
if !self.is_numeric() || self.cell(r).is_empty() {
return None;
}
// The Boards column's sort_key is a composite (online*100 + total) tuned
// for sorting; a numeric filter must compare the actual detected board
// count the cell shows, not that score (round 18 #12).
if let Column::Hashboards = self {
return r.hashboards.map(|v| v as f64);
}
match self.sort_key(r) {
SortKey::Num(v) if v.is_finite() => Some(v),
_ => None,
@@ -1258,7 +1366,12 @@ impl Column {
if r.board_temps.is_empty() {
if r.chip_temp_c > 0.0 { format!("{:.0}", r.chip_temp_c) } else { String::new() }
} else {
r.board_temps.iter().map(|&t| format!("{t:.0}")).collect::<Vec<_>>().join(" / ")
// 0.0 == a board with no reading; show "-" so positions align.
r.board_temps
.iter()
.map(|&t| if t > 0.0 { format!("{t:.0}") } else { "-".to_string() })
.collect::<Vec<_>>()
.join(" / ")
}
}
Column::FluidTemp => num(r.fluid_temp_c, 1, " C"),
@@ -1496,20 +1609,35 @@ impl ViewState {
/// into `order`, leaving hidden columns in their existing slots, so a
/// reorder while some column is hidden never drops or duplicates a column.
pub fn apply_visible_reorder(&mut self, new_visible: &[Column]) {
let disp = self.display_columns();
if new_visible.len() != disp.len() || new_visible.first() != Some(&Column::Ip) {
return;
if new_visible.first() != Some(&Column::Ip) {
return; // Ip is fixed first
}
let want: HashSet<Column> = disp.iter().copied().collect();
let got: HashSet<Column> = new_visible.iter().copied().collect();
if want != got {
return; // not a permutation of the visible columns: ignore
let shown: HashSet<Column> = new_visible.iter().copied().collect();
if shown.len() != new_visible.len() {
return; // duplicates: not a permutation
}
// `new_visible` is the set of columns the table actually SHOWS in their new
// order. That is `display_columns()` normally, but a SUBSET of it when
// auto-hide-empty is on (the widget omits the empty columns). Every shown
// column must be a real, currently-visible column; columns not in `shown`
// (hidden, or hidden-because-empty) keep their slot. Reordering just the
// shown subset is what lets drag-reorder work while a column is hidden
// (round 18 #12: the old code compared against display_columns() and so
// silently rejected every reorder whenever auto-hide-empty hid a column).
let reorderable: HashSet<Column> = self
.order
.iter()
.copied()
.filter(|c| *c == Column::Ip || self.visible.contains(c))
.collect();
if !shown.is_subset(&reorderable) {
return; // a non-visible column in the input: ignore
}
let mut next = new_visible.iter().copied();
self.order = self
.order
.iter()
.map(|&c| if want.contains(&c) { next.next().unwrap_or(c) } else { c })
.map(|&c| if shown.contains(&c) { next.next().unwrap_or(c) } else { c })
.collect();
}
@@ -1743,22 +1871,66 @@ mod tests {
assert!(board_tips[0].contains("Slot 0 error reading chip id."));
assert!(!board_tips[2].contains("Slot"), "board 3 has no fault text");
// Round 16 #2: a power-supply fault greys every board (they can't be
// powered/tested), turns the bolt red, and the PSU message shows on the
// power tooltip.
// Round 18 #2/#4b: a PSU fault while the miner is NOT mining is a real
// failure (red bolt), and boards keep their own reported state -- a PSU
// fault no longer greys them. Faulted boards stay red.
let psu = MinerRow {
power_w: 40.0,
board_status: vec![BoardHealth::Fault, BoardHealth::Fault, BoardHealth::Fault],
expected_fans: Some(2),
fan_rpms: vec![6000.0, 6000.0],
faults: vec![fault(FaultComponent::Power, "Power current error.")],
..Default::default()
..Default::default() // is_mining = false
};
assert_eq!(psu.power_health(), CompHealth::Down);
assert!(psu.board_healths().iter().all(|h| *h == CompHealth::Unreachable));
assert_eq!(psu.power_health(), CompHealth::Down); // fault + not mining -> red
assert!(psu.board_healths().iter().all(|h| *h == CompHealth::Down)); // faulted -> red, not grey
let ptips = psu.health_tooltips(2, 3);
assert!(ptips[0].contains("Power current error."));
assert!(ptips[2 + 2].contains("unpowered")); // first board tooltip
// Round 18 #2: the SAME PSU fault while the miner IS mining is a warning
// (yellow bolt), and running boards stay GREEN (not grey). Round 18 #4b:
// grey is reserved for genuinely-undetected boards.
let psu_running = MinerRow {
is_mining: true,
power_w: 3000.0,
board_status: vec![BoardHealth::Ok, BoardHealth::Ok, BoardHealth::Missing],
faults: vec![fault(FaultComponent::Power, "Power vout warning.")],
..Default::default()
};
assert_eq!(psu_running.power_health(), CompHealth::Degraded); // yellow, not red
let rb = psu_running.board_healths();
assert_eq!(rb[0], CompHealth::Ok); // running -> green despite PSU fault
assert_eq!(rb[1], CompHealth::Ok);
assert_eq!(rb[2], CompHealth::Unreachable); // only the undetected board is grey
// Round 18 #12: a genuinely-undetected board that is ALSO named by a board
// fault (e.g. a "chain 2 not found" message attributed to Board(2)) must
// stay grey ("not detected"), not turn red -- grey vs red is the
// detected/undetected distinction.
let missing_named = MinerRow {
is_mining: true,
board_status: vec![BoardHealth::Ok, BoardHealth::Ok, BoardHealth::Missing],
faults: vec![fault(FaultComponent::Board(2), "Chain 2 not found, check connection")],
..Default::default()
};
let mb = missing_named.board_healths();
assert_eq!(mb[0], CompHealth::Ok);
assert_eq!(mb[1], CompHealth::Ok);
assert_eq!(mb[2], CompHealth::Unreachable, "undetected board named by a fault stays grey");
}
#[test]
fn equihash_hashrate_units_round18() {
// SHA256 shows the TH/s value directly; Equihash shows the Sol/s count
// (ths * 1e12) with an SI prefix (round 18 #7).
assert_eq!(hashrate_num_for("SHA256", 80.5).as_deref(), Some("80.5"));
// 167,764 Sol/s -> SI mantissa+prefix ("168k"); paired with the "Sol/s" unit.
assert_eq!(hashrate_num_for("Equihash", 167_764.0 / 1e12).as_deref(), Some("168k"));
assert_eq!(hashrate_num_for("Equihash", 0.0), None);
let sha = MinerRow { algorithm: "SHA256".into(), ..Default::default() };
let equi = MinerRow { algorithm: "Equihash".into(), ..Default::default() };
assert_eq!(sha.hashrate_unit(), "TH/s");
assert_eq!(equi.hashrate_unit(), "Sol/s");
}
#[test]
@@ -2224,6 +2396,31 @@ mod tests {
assert_eq!(view.order, before, "a same-length non-permutation must be ignored");
}
#[test]
fn apply_visible_reorder_accepts_a_shown_subset() {
// Auto-hide-empty shows only a subset of the visible columns; dragging
// within that subset must be applied, not silently rejected (round 18 #12).
let mut view = ViewState::default();
let disp = view.display_columns();
assert!(disp.len() >= 4, "default view has several visible columns");
// Pretend disp[2] is empty and therefore hidden by the widget.
let dropped = disp[2];
let mut shown: Vec<Column> = disp.iter().copied().filter(|&c| c != dropped).collect();
shown.swap(1, 2); // reorder two columns of the shown subset
let before_set: HashSet<Column> = view.order.iter().copied().collect();
view.apply_visible_reorder(&shown);
assert_ne!(
view.display_columns().iter().copied().collect::<Vec<_>>(),
disp,
"a valid subset reorder must change the display order"
);
// No column lost or duplicated; Ip still first; the hidden column kept its slot.
assert_eq!(view.order.iter().copied().collect::<HashSet<_>>(), before_set);
assert_eq!(view.order.len(), before_set.len());
assert_eq!(view.display_columns().first(), Some(&Column::Ip));
assert_eq!(view.order.iter().filter(|&&c| c == dropped).count(), 1);
}
/// Microbenchmark: the DEFAULT view (Ip ascending) at 5000 rows. The existing
/// bench_view_pipeline overrides sort to Hashrate, so it never exercised the
/// default path (previously a lexical string sort).
@@ -2364,6 +2561,7 @@ mod tests {
power_limit: true,
tuning: true,
hashrate_target: true,
supports_presets: true,
firmware_flash: true,
pools: true,
timezone: true,
@@ -2483,6 +2681,21 @@ mod tests {
assert_eq!(Column::TotalChips.num_value(&both), Some(190.0));
}
#[test]
fn hashboards_num_value_is_board_count_with_per_board_health() {
// With per-board health present (the normal live-scan case), the Boards
// filter must still compare the detected board count, not the composite
// sort score online*100+total (round 18 #12). The `both` fixture above
// leaves board_status empty, so it never exercised this path.
let r = MinerRow {
hashboards: Some(3),
expected_hashboards: Some(3),
board_status: vec![BoardHealth::Ok, BoardHealth::Ok, BoardHealth::Ok],
..Default::default()
};
assert_eq!(Column::Hashboards.num_value(&r), Some(3.0), "filter sees the board count, not 303");
}
#[test]
fn cooling_column_joins_fan_rpms_and_sorts_by_min() {
let r = MinerRow { fan_rpms: vec![4200.0, 3990.0, 4500.0], ..Default::default() };
+27 -5
View File
@@ -135,10 +135,13 @@ 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
// `get(..9)` returns None (rather than panicking) when byte 9 is not a UTF-8
// char boundary, so a multibyte miner-supplied model string can't crash here
// (round 18 #12). The prefix is 9 ASCII bytes, so a real match implies a
// boundary at 9 and the following `id[9..]` is safe.
let id = match id.get(..9) {
Some(p) if p.eq_ignore_ascii_case("ANTMINER ") => id[9..].trim_start(),
_ => id,
};
let bytes = id.as_bytes();
// Base = leading letters then digits ("S19", "KS5", "L3", "Z15"). Without a
@@ -200,6 +203,7 @@ fn compact_upper(s: &str) -> String {
/// 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);
@@ -283,8 +287,26 @@ fn is_s17_era(clean_model: &str) -> bool {
/// 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 {
// Per the doc above: XP-class, the S19k Pro, and the S21 Pro -- NOT every S21
// (plain S21 / S21+ / S21e are the 120mm C76 board) (round 18 #12).
let m = clean_model.trim_start();
m.contains("XP") || m.starts_with("S19k") || m.starts_with("S21")
m.contains("XP") || m.starts_with("S19k") || m.contains("S21 Pro")
}
/// Nameplate expected hashrate in Sol/s for an Equihash (Zcash) miner model, when
/// the firmware itself does not report an expected hashrate (round 18 #6). Plain
/// Antminer Z15 firmware omits the cgminer `total_rateideal` field (the Z15j does
/// report it), so its actual-vs-expected column and colour would otherwise be
/// blank. The Z15 nameplate is 420 KSol/s. Returns `None` for models with no known
/// nameplate (the caller then leaves expected unknown).
pub fn equihash_expected_sols(clean_model: &str) -> Option<f64> {
let m = clean_model.to_ascii_lowercase();
// Match the Z15 family (z15, z15j); both share the 420 KSol/s nameplate.
if m.contains("z15") {
Some(420_000.0)
} else {
None
}
}
#[cfg(test)]
+69 -31
View File
@@ -1,8 +1,8 @@
//! Dropdown presets + user-saved values for the Configure-pools dialog (round 15
//! #1). Each pool field (address / account / worker / password) has a "+" menu
//! offering built-in presets (pool stratums, worker placeholders) plus values the
//! user has saved, and the user can add the current box value to the saved list.
//! Saved lists persist one-per-line under the config dir.
//! user has saved. "Add new..." opens a manager window that edits the whole saved
//! list at once (round 18 #8b). Saved lists persist one-per-line under the config dir.
use std::path::PathBuf;
@@ -72,42 +72,58 @@ pub fn load_saved(field: PoolField) -> Vec<String> {
.unwrap_or_default()
}
/// Add `value` to `field`'s saved list (deduplicated, no-op if empty/already
/// present or already a preset). Returns true if it was newly added.
pub fn add_saved(field: PoolField, value: &str) -> bool {
let value = value.trim();
if value.is_empty() {
return false;
}
if field.presets().iter().any(|p| *p == value) {
return false;
}
let mut saved = load_saved(field);
if saved.iter().any(|s| s == value) {
return false;
}
saved.push(value.to_string());
/// Replace `field`'s entire saved list with `values` (round 18 #8b: the preset
/// manager edits the whole list at once). Each value is trimmed; empties, exact
/// duplicates, and any value that is already a built-in preset are dropped.
/// Returns the number of values actually written.
pub fn save_all(field: PoolField, values: &[String]) -> std::io::Result<usize> {
let out = dedupe_saved(&field.presets(), values);
let p = config_path(field.saved_file());
if let Some(dir) = p.parent() {
let _ = std::fs::create_dir_all(dir);
}
let _ = std::fs::write(p, saved.join("\n"));
true
// The password list can hold a pool password, so write it owner-only from the
// moment it is created -- never briefly world-readable (round 18 #12).
write_private(&p, out.join("\n").as_bytes())?;
Ok(out.len())
}
/// Remove `value` from `field`'s saved list (round 16 #5). Returns true if it was
/// present and removed. Presets cannot be removed (they are not in the saved file).
pub fn remove_saved(field: PoolField, value: &str) -> bool {
let value = value.trim();
let mut saved = load_saved(field);
let before = saved.len();
saved.retain(|s| s != value);
if saved.len() == before {
return false;
/// Write `data` to `path` with owner-only (0600) permissions from creation on
/// Unix, so a secret is never momentarily world-readable between write and chmod.
/// `mode()` only takes effect when the file is created, so an already-existing
/// file is also re-tightened; elsewhere this is a plain write.
fn write_private(path: &std::path::Path, data: &[u8]) -> std::io::Result<()> {
#[cfg(unix)]
{
use std::io::Write;
use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
let mut f = std::fs::OpenOptions::new()
.write(true)
.create(true)
.truncate(true)
.mode(0o600)
.open(path)?;
let _ = std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o600));
f.write_all(data)
}
let p = config_path(field.saved_file());
let _ = std::fs::write(p, saved.join("\n"));
true
#[cfg(not(unix))]
{
std::fs::write(path, data)
}
}
/// Trim every value, then drop empties, values equal to a built-in preset, and
/// later exact duplicates (first occurrence wins). Order is otherwise preserved.
fn dedupe_saved(presets: &[&str], values: &[String]) -> Vec<String> {
let mut out: Vec<String> = Vec::new();
for v in values {
let v = v.trim();
if v.is_empty() || presets.contains(&v) || out.iter().any(|s| s == v) {
continue;
}
out.push(v.to_string());
}
out
}
/// The full dropdown list for a field: presets first, then the user's saved
@@ -129,3 +145,25 @@ pub fn dropdown_entries(field: PoolField) -> Vec<(String, String)> {
}
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn dedupe_saved_trims_drops_empties_presets_and_dupes() {
let presets = ["x", "{ip1}"];
let vals: Vec<String> = [" ", "myworker", "myworker", "x", " keep ", "{ip1}", "keep"]
.iter()
.map(|s| s.to_string())
.collect();
// " " (empty), the second "myworker", "x"/"{ip1}" (presets) and the second
// "keep" all drop; " keep " is trimmed and kept.
assert_eq!(dedupe_saved(&presets, &vals), vec!["myworker".to_string(), "keep".to_string()]);
}
#[test]
fn dedupe_saved_empty_input_is_empty() {
assert!(dedupe_saved(&[], &[]).is_empty());
}
}
+194 -51
View File
@@ -4,7 +4,7 @@
//! (the stock image is retained on-device at install time; no image is uploaded):
//! - VNish: POST /api/v1/unlock -> bearer -> POST /api/v1/firmware/remove
//! - LuxOS: luxminer :4028 {"command":"logon"} -> SessionID ->
//! {"command":"uninstallluxos","parameter":"<SessionID>"}
//! {"command":"uninstallluxos","parameter":"<SessionID>"}
//! - Braiins: SSH `uninstall.sh` (re-flashes the on-NAND stock backup)
//!
//! DESTRUCTIVE: this removes the running aftermarket firmware and reboots the
@@ -24,17 +24,21 @@ use std::time::Duration;
use crate::scan::fake_scan_enabled;
pub enum RestoreMsg {
Started { total: usize },
Started,
Result { ip: String, ok: bool, detail: String },
Done { total: usize },
Done,
}
pub struct RestoreHandle {
pub rx: Receiver<RestoreMsg>,
// The worker honours cancellation between miners (see `tc` below); a UI stop
// control is not wired yet, so the handle-side trigger is kept for when it is.
#[allow(dead_code)]
cancel: Arc<AtomicBool>,
}
impl RestoreHandle {
#[allow(dead_code)]
pub fn stop(&self) {
self.cancel.store(true, Ordering::Relaxed);
}
@@ -57,11 +61,10 @@ pub fn start_restore(
) -> RestoreHandle {
let (tx, rx) = channel();
let cancel = Arc::new(AtomicBool::new(false));
let total = targets.len();
if fake_scan_enabled() {
// Offline demo: report each target as restored without touching anything.
let _ = tx.send(RestoreMsg::Started { total });
let _ = tx.send(RestoreMsg::Started);
for t in targets {
let _ = tx.send(RestoreMsg::Result {
ip: t.ip,
@@ -69,15 +72,16 @@ pub fn start_restore(
detail: "restored to stock (demo)".into(),
});
}
let _ = tx.send(RestoreMsg::Done { total });
let _ = tx.send(RestoreMsg::Done);
return RestoreHandle { rx, cancel };
}
let tc = cancel.clone();
let _ = std::thread::Builder::new()
let err_tx = tx.clone();
let spawned = std::thread::Builder::new()
.name("restore-stock".into())
.spawn(move || {
let _ = tx.send(RestoreMsg::Started { total });
let _ = tx.send(RestoreMsg::Started);
for t in targets {
if tc.load(Ordering::Relaxed) {
break;
@@ -87,8 +91,18 @@ pub fn start_restore(
return;
}
}
let _ = tx.send(RestoreMsg::Done { total });
let _ = tx.send(RestoreMsg::Done);
});
if spawned.is_err() {
// Never leave the restore subsystem wedged (round 18 #12): if the worker
// thread can't start, emit a failure + Done so the drain clears the handle.
let _ = err_tx.send(RestoreMsg::Result {
ip: String::new(),
ok: false,
detail: "could not start the restore worker thread".into(),
});
let _ = err_tx.send(RestoreMsg::Done);
}
RestoreHandle { rx, cancel }
}
@@ -107,12 +121,19 @@ fn restore_one(t: &RestoreTarget, vnish_pass: &str, ssh_user: &str, ssh_pass: &s
/// VNish: unlock -> bearer -> firmware/remove (self-restores + reboots ~3 s).
fn restore_vnish(ip: &str, pass: &str) -> (bool, String) {
let unlock = match curl(&[
"-s", "--connect-timeout", "5", "--max-time", "9",
"-X", "POST", "-H", "Content-Type: application/json",
"-d", &format!("{{\"pw\":\"{pass}\"}}"),
&format!("http://{ip}/api/v1/unlock"),
]) {
// serde-encode the body so a password with a quote/backslash can't break the
// JSON, and send it via stdin (-d @-) so the password never appears on curl's
// argv / the process list (round 18 #12).
let body = serde_json::json!({ "pw": pass }).to_string();
let unlock = match curl(
&[
"-s", "--connect-timeout", "5", "--max-time", "9",
"-X", "POST", "-H", "Content-Type: application/json",
"-d", "@-",
&format!("http://{ip}/api/v1/unlock"),
],
Some(body.as_bytes()),
) {
Ok(s) => s,
Err(e) => return (false, format!("unlock request failed: {e}")),
};
@@ -123,11 +144,14 @@ fn restore_vnish(ip: &str, pass: &str) -> (bool, String) {
let Some(token) = token else {
return (false, "VNish unlock rejected (wrong web password?)".into());
};
match curl(&[
"-s", "--connect-timeout", "5", "--max-time", "12",
"-X", "POST", "-H", &format!("Authorization: Bearer {token}"),
&format!("http://{ip}/api/v1/firmware/remove"),
]) {
match curl(
&[
"-s", "--connect-timeout", "5", "--max-time", "12",
"-X", "POST", "-H", &format!("Authorization: Bearer {token}"),
&format!("http://{ip}/api/v1/firmware/remove"),
],
None,
) {
// The miner reverts + reboots after ~3 s; the response is {"after":N}.
Ok(resp) if resp.contains("after") => (true, "reverting to stock (~3 s)".into()),
Ok(resp) => (false, format!("firmware/remove returned: {}", resp.trim())),
@@ -152,13 +176,29 @@ fn restore_luxos(ip: &str) -> (bool, String) {
let Some(session) = session.filter(|s| !s.is_empty()) else {
return (false, format!("no SessionID in logon response: {}", logon.trim()));
};
let cmd = format!("{{\"command\":\"uninstallluxos\",\"parameter\":\"{session}\"}}");
// serde-encode so the miner-supplied SessionID can't break or inject into the
// JSON-RPC command (round 18 #12).
let cmd = serde_json::json!({ "command": "uninstallluxos", "parameter": session }).to_string();
match lux_rpc(ip, &cmd) {
// Code 350 "Uninstalling LuxOS"; the miner reboots + reverts in background.
Ok(resp) if resp.contains("350") || resp.to_lowercase().contains("uninstall") => {
(true, "uninstalling LuxOS (reboots to stock)".into())
}
// The miner reboots as it reverts, so the reply is often dropped/empty
// after the command is accepted. The logon above already proved the miner
// was reachable, so an empty reply or a dropped connection here is the
// expected reboot, not a failure (round 18 #12).
Ok(resp) if resp.trim().is_empty() => {
(true, "uninstall accepted (miner rebooting to stock)".into())
}
Ok(resp) => (false, format!("uninstallluxos returned: {}", resp.trim())),
Err(e)
if ["closed", "reset", "timed out", "broken pipe", "eof"]
.iter()
.any(|m| e.to_lowercase().contains(m)) =>
{
(true, "RPC dropped (miner rebooting to stock)".into())
}
Err(e) => (false, format!("uninstallluxos failed: {e}")),
}
}
@@ -169,28 +209,30 @@ fn restore_braiins(ip: &str, user: &str, pass: &str) -> (bool, String) {
return (false, "Braiins restore needs an SSH password (set the SSH login)".into());
}
let target = format!("{user}@{ip}");
// uninstall.sh is on Braiins OS+'s PATH; run it non-interactively.
// sshpass reads the password from $SSHPASS (-e) rather than argv (-p), so it
// never shows up in the process list (round 18 #12). Host-key checking is
// deliberately disabled: these are LAN miners whose SSH host key changes on
// every reflash, so pinning it would break the very revert this performs.
// BatchMode stops any interactive prompt from hanging out the 60 s cap.
let mut cmd = Command::new("sshpass");
cmd.arg("-p").arg(pass).arg("ssh");
cmd.env("SSHPASS", pass);
cmd.arg("-e").arg("ssh");
cmd.args([
"-o", "StrictHostKeyChecking=no",
"-o", "UserKnownHostsFile=/dev/null",
"-o", "BatchMode=yes",
"-o", "ConnectTimeout=8",
&target,
"uninstall.sh || /sbin/uninstall.sh",
]);
match run_with_timeout(cmd, Duration::from_secs(60)) {
Ok(out) => {
let s = String::from_utf8_lossy(&out).to_lowercase();
if s.contains("not found") || s.contains("no such") {
(false, "uninstall.sh not found on the miner".into())
} else {
(true, "ran uninstall.sh (reverts to stock + reboots)".into())
}
}
match run_with_timeout(cmd, Duration::from_secs(60), None) {
Ok(out) => classify_braiins(
&String::from_utf8_lossy(&out.stdout),
&String::from_utf8_lossy(&out.stderr),
out.code,
out.timed_out,
),
Err(e) => {
// A reboot mid-command commonly drops the SSH connection; treat a
// connection-closed error after the command as likely success.
if e.contains("closed") || e.contains("reset") || e.contains("timed out") {
(true, "SSH dropped (miner likely rebooting to stock)".into())
} else {
@@ -200,6 +242,42 @@ fn restore_braiins(ip: &str, user: &str, pass: &str) -> (bool, String) {
}
}
/// Decide a Braiins `uninstall.sh` outcome from its captured output. The critical
/// rule (round 18 #12): an SSH auth/connection failure -- which writes its
/// diagnostic to stderr, leaves stdout empty, and exits non-zero -- must be
/// reported as a FAILURE, never a false success. A dropped connection or a
/// timeout after the command started is the expected signature of the reboot.
fn classify_braiins(stdout: &str, stderr: &str, code: Option<i32>, timed_out: bool) -> (bool, String) {
let err = stderr.to_lowercase();
// ssh's own connection/auth failures (exit 255) never reach the remote command.
let conn_fail = [
"permission denied",
"connection refused",
"could not resolve",
"no route to host",
"connection timed out",
"operation timed out",
"host key verification failed",
"before authentication",
]
.iter()
.any(|m| err.contains(m));
if conn_fail {
let why = stderr.lines().map(str::trim).rfind(|l| !l.is_empty());
return (false, format!("SSH failed: {}", why.unwrap_or("connection/auth error")));
}
let out = stdout.to_lowercase();
if out.contains("not found") || out.contains("no such") || err.contains("not found") {
return (false, "uninstall.sh not found on the miner".into());
}
match code {
Some(0) => (true, "ran uninstall.sh (reverts to stock + reboots)".into()),
None => (true, "SSH dropped (miner likely rebooting to stock)".into()),
_ if timed_out => (true, "SSH timed out (miner likely rebooting to stock)".into()),
Some(c) => (false, format!("uninstall.sh exited {c}: {}", stderr.trim())),
}
}
/// One luxminer :4028 request/response (line-framed, socket closes after reply).
fn lux_rpc(ip: &str, payload: &str) -> Result<String, String> {
let addr: SocketAddr = format!("{ip}:4028").parse().map_err(|e| format!("bad addr: {e}"))?;
@@ -225,50 +303,115 @@ fn lux_rpc(ip: &str, payload: &str) -> Result<String, String> {
Ok(String::from_utf8_lossy(&buf).trim_matches('\u{0}').to_string())
}
/// curl with a wall-clock cap (small responses; no pipe-drain thread needed).
fn curl(args: &[&str]) -> Result<String, String> {
let mut cmd = Command::new("curl");
cmd.args(args);
run_with_timeout(cmd, Duration::from_secs(15)).map(|o| String::from_utf8_lossy(&o).into_owned())
/// The captured result of a timed subprocess run.
struct CmdOutput {
/// The process exit code, or `None` if it was killed / dropped / timed out.
code: Option<i32>,
stdout: Vec<u8>,
stderr: Vec<u8>,
timed_out: bool,
}
/// Run a command, capture stdout, with a hard wall-clock timeout.
fn run_with_timeout(mut cmd: Command, timeout: Duration) -> Result<Vec<u8>, String> {
/// curl with a wall-clock cap. Errors only when the run produced no output and
/// timed out (a black-holed host); otherwise returns stdout even on a non-zero
/// exit (curl prints useful bodies/status on failures).
fn curl(args: &[&str], stdin_data: Option<&[u8]>) -> Result<String, String> {
let mut cmd = Command::new("curl");
cmd.args(args);
let out = run_with_timeout(cmd, Duration::from_secs(15), stdin_data)?;
if out.timed_out && out.stdout.is_empty() {
return Err("timed out".into());
}
Ok(String::from_utf8_lossy(&out.stdout).into_owned())
}
/// Run a command with a hard wall-clock timeout, capturing stdout, stderr, and
/// the exit code. Both pipes are drained on their own threads so a child that
/// writes a lot to stderr can never deadlock against a full pipe (round 18 #12).
/// `stdin_data`, when set, is written to the child's stdin and the pipe closed
/// (used to feed a request body without putting a secret on argv).
fn run_with_timeout(
mut cmd: Command,
timeout: Duration,
stdin_data: Option<&[u8]>,
) -> Result<CmdOutput, String> {
cmd.stdout(std::process::Stdio::piped());
cmd.stderr(std::process::Stdio::piped());
if stdin_data.is_some() {
cmd.stdin(std::process::Stdio::piped());
}
let mut child = cmd.spawn().map_err(|e| format!("spawn: {e}"))?;
if let Some(data) = stdin_data {
if let Some(mut si) = child.stdin.take() {
let _ = si.write_all(data);
} // dropping `si` closes the pipe
}
let mut stdout = child.stdout.take().ok_or("no stdout")?;
let reader = std::thread::spawn(move || {
let mut stderr = child.stderr.take().ok_or("no stderr")?;
let out_reader = std::thread::spawn(move || {
let mut b = Vec::new();
let _ = stdout.read_to_end(&mut b);
b
});
let err_reader = std::thread::spawn(move || {
let mut b = Vec::new();
let _ = stderr.read_to_end(&mut b);
b
});
let start = std::time::Instant::now();
let mut timed_out = false;
loop {
let status = loop {
match child.try_wait().map_err(|e| e.to_string())? {
Some(_) => break,
Some(s) => break Some(s),
None => {
if start.elapsed() >= timeout {
let _ = child.kill();
let _ = child.wait(); // reap so we never leave a zombie
timed_out = true;
break;
break None;
}
std::thread::sleep(Duration::from_millis(50));
}
}
}
let out = reader.join().unwrap_or_default();
if timed_out && out.is_empty() {
return Err("timed out".into());
}
Ok(out)
};
Ok(CmdOutput {
code: status.and_then(|s| s.code()),
stdout: out_reader.join().unwrap_or_default(),
stderr: err_reader.join().unwrap_or_default(),
timed_out,
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn braiins_auth_or_connection_failure_is_not_a_false_success() {
// The critical regression guard (round 18 #12): a wrong password or an
// unreachable miner writes to stderr, leaves stdout empty, and exits
// non-zero -- it must report failure, never "restored".
let (ok, msg) = classify_braiins("", "Permission denied, please try again.", Some(255), false);
assert!(!ok, "wrong password must not report success");
assert!(msg.to_lowercase().contains("ssh failed"), "{msg}");
let (ok, _) = classify_braiins("", "ssh: connect to host 10.0.0.9 port 22: Connection refused", Some(255), false);
assert!(!ok, "unreachable miner must not report success");
let (ok, _) = classify_braiins("", "ssh: Could not resolve hostname miner: Name or service not known", Some(255), false);
assert!(!ok, "unresolvable host must not report success");
// Genuine outcomes.
let (ok, _) = classify_braiins("uninstalling...\n", "", Some(0), false);
assert!(ok, "clean exit 0 is success");
let (ok, _) = classify_braiins("", "Connection to 10.0.0.5 closed by remote host.", None, false);
assert!(ok, "connection dropped mid-command (reboot) is success");
let (ok, _) = classify_braiins("", "", None, true);
assert!(ok, "timeout after the command started (reboot) is success");
let (ok, _) = classify_braiins("bash: uninstall.sh: command not found\n", "", Some(127), false);
assert!(!ok, "missing uninstall.sh is a failure");
}
#[test]
fn firmware_selects_the_right_flow() {
// The dispatcher only recognises the three revertible aftermarket
+200 -32
View File
@@ -13,6 +13,11 @@ use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::{channel, Receiver};
use std::sync::Arc;
// `Row` is the common variant (one per miner) while `Started`/`Done` are sent
// once each, so boxing the large row to shrink the rare variants would add an
// allocation on the hot path for no real gain -- the message is moved straight
// through an mpsc channel and dropped.
#[allow(clippy::large_enum_variant)]
pub enum ScanMsg {
/// A new scan started: `total` addresses to probe, and the exact set of
/// target IPs (as strings) so the UI can drop miners no longer in range.
@@ -156,7 +161,7 @@ pub fn parse_line(line: &str) -> Result<Vec<Ipv4Addr>, String> {
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();
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}"));
}
@@ -403,31 +408,41 @@ pub fn start_scan(lines: Vec<String>, timeout_secs: u64) -> ScanHandle {
}
};
}
// scan_stream_with_ip yields one item per probed address, so we
// get accurate progress plus the responders.
let mut stream = factory.scan_stream_with_ip();
// scan_stream_with_ip yields one item per probed address (identification
// is already concurrent up to SCAN_CONCURRENCY_LIMIT). Each responder's
// telemetry (to_row -> get_data + presets: several REST calls) is then
// run concurrently via buffer_unordered instead of awaited one at a time
// -- otherwise the telemetry serialises and dominates the scan wall-clock
// (round 18 #12). buffer_unordered polls the underlying stream on its own,
// so identification concurrency is unaffected, and telemetry only ever
// targets responders (live miners), so the same cap is safe.
let mut done = 0usize;
// Emit progress per address for a smoothly-climbing counter; only a
// very large scan (> 5000 addresses) is throttled, to bound channel
// traffic. The UI coalesces these to one gauge update per refresh.
let step = (total / 5000).max(1);
while let Some((ip, miner)) = stream.next().await {
let mut results = factory
.scan_stream_with_ip()
.map(|(ip, miner)| async move {
match miner {
// Only surface a row for an address that actually has a miner
// behind it; a non-responding address is never a phantom row.
Some(m) => (ip, Some(to_row(&*m).await)),
None => (ip, None),
}
})
.buffer_unordered(SCAN_CONCURRENCY_LIMIT);
while let Some((ip, row)) = results.next().await {
if thread_cancel.load(Ordering::Relaxed) {
return; // Stop / re-scan requested
}
done += 1;
// 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 let Some(row) = row {
if tx.send(ScanMsg::Row(row)).is_err() {
return; // UI gone
}
}
if done % step == 0 || done == total {
if done.is_multiple_of(step) || done == total {
let _ = tx.send(ScanMsg::Progress { done, total, ip: ip.to_string() });
}
}
@@ -478,6 +493,37 @@ fn summarize_messages(messages: &[asic_rs::core::data::message::MinerMessage]) -
/// component (round 16 #1/#2/#3), so the Health column can colour and describe
/// each icon from the actual per-component faults. Info-severity messages are
/// dropped; Error and Warning are kept (only Error drives colour).
/// Best-effort hashboard index from a fault message that names a board (round 18
/// #5). Only WhatsMiner's asic-rs backends attribute a message to a specific
/// `HashBoard { idx }`; every Antminer-hardware firmware (stock, VNish, Braiins,
/// LuxOS) builds messages with no component, so a real per-board fault would
/// otherwise land on the control-board (brain) tooltip instead of the board it
/// names. The message text is self-describing (e.g. "Chain 2 ... temperature"),
/// so pull the first integer after a board keyword and attribute the fault to that
/// board. Returns None when no board keyword is present.
fn board_index_from_text(text: &str) -> Option<usize> {
let lower = text.to_ascii_lowercase();
// Longest/most-specific keywords first so "hashboard" wins over "board".
for kw in ["hashboard", "hash board", "chain", "slot", "board"] {
let mut from = 0;
while let Some(rel) = lower[from..].find(kw) {
let after = &lower[from + rel + kw.len()..];
// The number must IMMEDIATELY follow the keyword (after only separators
// like " #-:._="), so "Chain 2 ..." -> 2 but "hashboard error, temp 65"
// does not grab the temperature 65 far past the keyword (round 18 #12).
let rest = after.trim_start_matches(|c: char| {
c.is_whitespace() || matches!(c, ':' | '#' | '-' | '_' | '.' | '=' | '(')
});
let digits: String = rest.chars().take_while(|c| c.is_ascii_digit()).collect();
if let Ok(n) = digits.parse::<usize>() {
return Some(n);
}
from += rel + kw.len();
}
}
None
}
fn messages_to_faults(
messages: &[asic_rs::core::data::message::MinerMessage],
) -> Vec<crate::model::Fault> {
@@ -500,7 +546,12 @@ fn messages_to_faults(
Some(MinerComponent::ControlBoard {}) => FaultComponent::Control,
Some(MinerComponent::Fan { idx }) => FaultComponent::Fan(*idx as usize),
Some(MinerComponent::HashBoard { idx, .. }) => FaultComponent::Board(*idx as usize),
None => FaultComponent::Other,
// Unattributed (every Antminer-hardware firmware): recover a board
// index from the message text so hashboard faults show on the board
// they name, not the control-board tooltip (round 18 #5).
None => board_index_from_text(text)
.map(FaultComponent::Board)
.unwrap_or(FaultComponent::Other),
};
Some(Fault {
component,
@@ -512,6 +563,31 @@ fn messages_to_faults(
.collect()
}
#[cfg(test)]
mod board_index_tests {
use super::board_index_from_text;
#[test]
fn extracts_board_index_from_common_fault_texts() {
assert_eq!(board_index_from_text("Chain 2 temperature sensor error"), Some(2));
assert_eq!(board_index_from_text("hashboard 0 loss of balance"), Some(0));
assert_eq!(board_index_from_text("Slot 1 error reading chip id."), Some(1));
assert_eq!(board_index_from_text("Board #3 not responding"), Some(3));
// No board keyword -> not attributed to a board.
assert_eq!(board_index_from_text("Environment temperature is too high."), None);
assert_eq!(board_index_from_text("Power current error."), None);
}
#[test]
fn does_not_grab_an_unrelated_number_far_past_the_keyword() {
// The number must immediately follow the keyword: a later temperature/count
// must not be mistaken for the board index (round 18 #12).
assert_eq!(board_index_from_text("hashboard error, chip temp 65C"), None);
assert_eq!(board_index_from_text("board voltage low, 12 chips offline"), None);
// A real "board <n>" still resolves even with trailing numbers.
assert_eq!(board_index_from_text("Chain 2 has 3 dead chips"), Some(2));
}
}
/// Infer whether an Antminer's hashboards carry a per-board PIC MCU from the
/// model string (round 14 #2). No firmware (stock cgminer, Vnish, LuxOS, Braiins)
/// exposes a PIC flag over the network; PIC-vs-noPIC is fixed by the hashboard
@@ -520,9 +596,10 @@ fn messages_to_faults(
/// generation (S21 family, T21), where Bitmain dropped the per-board PIC.
/// - PIC: the rest of the S19 line (BM1362/BM1366, PIC16F1704/1542).
/// - unknown: everything else (older Antminers, non-Antminer makes).
///
/// The one genuinely ambiguous model is the plain "S19j Pro" (both PIC and noPIC
/// revisions exist); it is assumed PIC unless the model string says noPIC.
fn infer_pic(model: &str) -> Option<bool> {
pub(crate) fn infer_pic(model: &str) -> Option<bool> {
let m = model.to_lowercase();
if m.contains("nopic") {
return Some(false);
@@ -572,7 +649,7 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
.as_ref()
.map(|h| h.clone().as_unit(asic_rs::core::data::hashrate::HashRateUnit::TeraHash).value)
.unwrap_or(0.0);
let expected_ths = data
let mut expected_ths = data
.expected_hashrate
.as_ref()
.map(|h| h.clone().as_unit(asic_rs::core::data::hashrate::HashRateUnit::TeraHash).value)
@@ -589,17 +666,26 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
// 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();
// Index-aligned with the hashboards (index i == board i): a board with no
// reading is 0.0, NOT dropped, so a missing middle board can't shift the
// others left in the "77 / - / 74" Chip-temp cell (round 18 #12). Collapsed
// to empty when NO board reports a temperature, so the cell falls back to the
// fleet average instead of showing "- / - / -".
let board_temps: Vec<f64> = {
let v: Vec<f64> = data
.hashboards
.iter()
.map(|b| {
b.board_temperature
.as_ref()
.or(b.outlet_chip_temperature.as_ref())
.map(|t| t.as_celsius())
.filter(|&t| t > 0.0)
.unwrap_or(0.0)
})
.collect();
if v.iter().all(|&t| t <= 0.0) { Vec::new() } else { v }
};
// Per-board hashrate (TH/s), index-aligned with the hashboards, for the
// per-board Health tooltip (round 17 R2). Unlike board_temps this is NOT
// filtered/compacted -- index i must stay board i so the tooltip numbering
@@ -614,6 +700,30 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
.unwrap_or(0.0)
})
.collect();
// Per-board expected hashrate (TH/s), index-aligned, for the actual/expected
// per-board tooltip (round 18 #3).
let board_expected_hashrates: Vec<f64> = data
.hashboards
.iter()
.map(|b| {
b.expected_hashrate
.as_ref()
.map(|h| h.clone().as_unit(asic_rs::core::data::hashrate::HashRateUnit::TeraHash).value)
.unwrap_or(0.0)
})
.collect();
// Per-board configured voltage (V) and frequency (MHz), index-aligned, for the
// per-board tooltip (round 18 / roadmap G7 read side). 0.0 where unreported.
let board_voltages: Vec<f64> = data
.hashboards
.iter()
.map(|b| b.voltage.as_ref().map(|v| v.as_volts()).unwrap_or(0.0))
.collect();
let board_frequencies: Vec<f64> = data
.hashboards
.iter()
.map(|b| b.frequency.as_ref().map(|f| f.as_megahertz()).unwrap_or(0.0))
.collect();
let fan_rpms: Vec<f64> = data
.fans
.iter()
@@ -653,7 +763,11 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
// "Stock") and carry it into the version instead (round 11 #6).
let (mut firmware, mut fw_vendor) = crate::naming::firmware_family(&data.device_info.firmware);
// Bixbit/Hiveon masquerade as stock; relabel them from their cgminer signature
// so they get their own family + colour instead of "Stock" (round 17).
// so they get their own family + colour instead of "Stock" (round 17). This
// is one extra TCP probe per stock-labelled Antminer per scan (round 18 #12):
// deliberately re-run each scan rather than cached, because a miner's firmware
// can change under us between scans (a flash/restore), and the detection must
// stay current; it only fires for Antminers that still read as plain "Stock".
if data.device_info.make.eq_ignore_ascii_case("antminer") && firmware.eq_ignore_ascii_case("stock") {
if let Some(fam) = detect_aftermarket_antminer(data.ip).await {
firmware = fam.to_string();
@@ -699,6 +813,14 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
.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();
// Equihash (Z15) fallback: plain Z15 firmware omits the expected hashrate, so
// fill it from the model nameplate (Sol/s -> the ths-normalised value) so the
// actual/expected column + colour work like every other miner (round 18 #6).
if expected_ths <= 0.0 && algorithm.eq_ignore_ascii_case("equihash") {
if let Some(sols) = crate::naming::equihash_expected_sols(&model) {
expected_ths = sols / 1e12;
}
}
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();
@@ -759,12 +881,26 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
power_limit,
tuning: miner.supports_set_tuning_percent(),
hashrate_target,
supports_presets: miner.supports_presets(),
firmware_flash: miner.supports_upgrade_firmware(),
pools: miner.supports_pools_config(),
timezone: miner.supports_timezone_config(),
change_password: miner.supports_change_password(),
factory_reset: miner.supports_factory_reset(),
};
// The firmware's selectable named presets/profiles (round 18 / roadmap G3),
// read live only for miners that advertise them (LuxOS/VNish). One extra RPC
// at scan time for those miners; the default 300 s rescan makes it negligible.
let presets: Vec<crate::model::MinerPreset> = if caps.supports_presets {
miner
.get_presets()
.await
.into_iter()
.map(|p| crate::model::MinerPreset { name: p.name, pretty: p.pretty })
.collect()
} else {
Vec::new()
};
// PIC vs noPIC (round 14 #2 rework). No firmware exposes a PIC flag over the
// network -- it's a fixed hardware property of the hashboard type -- so infer
// it from the model, which every API reports. See `infer_pic`.
@@ -816,6 +952,7 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
model,
brand,
submodel,
presets,
mac: data.mac.map(|m| m.to_string()).unwrap_or_default(),
hostname: data.hostname.clone().unwrap_or_default(),
serial: {
@@ -843,6 +980,9 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
hashrate_ths,
expected_ths,
board_hashrates,
board_expected_hashrates,
board_voltages,
board_frequencies,
efficiency: data.efficiency.unwrap_or(0.0),
power_w,
// PSU info (round 17 R5/G15; ePIC exposes it today). A reported-but-zero
@@ -906,6 +1046,7 @@ pub enum ConfigAction {
Resume,
PowerLimit(f64), // watts
HashRateTarget(f64), // TH/s -- structured hashrate target (round 17 C)
Preset(String), // named firmware profile/preset (round 18 / G3)
TuningPercent(u8),
Timezone(String), // IANA zone, e.g. "America/Edmonton" (round 17 B / G10)
ChangePassword(String), // new web/API password (round 17 B / G11)
@@ -923,6 +1064,7 @@ impl ConfigAction {
ConfigAction::Resume => "resume".into(),
ConfigAction::PowerLimit(w) => format!("power target {w:.0} W"),
ConfigAction::HashRateTarget(t) => format!("hashrate target {t:.0} TH/s"),
ConfigAction::Preset(name) => format!("preset {name}"),
ConfigAction::TuningPercent(p) => format!("tuning {p}%"),
ConfigAction::Timezone(tz) => format!("timezone {tz}"),
ConfigAction::ChangePassword(_) => "change password".into(),
@@ -941,6 +1083,7 @@ impl ConfigAction {
ConfigAction::Resume => "resuming…".into(),
ConfigAction::PowerLimit(_) => "setting power…".into(),
ConfigAction::HashRateTarget(_) => "setting hashrate…".into(),
ConfigAction::Preset(_) => "setting preset…".into(),
ConfigAction::TuningPercent(_) => "tuning…".into(),
ConfigAction::Timezone(_) => "setting timezone…".into(),
ConfigAction::ChangePassword(_) => "changing password…".into(),
@@ -997,6 +1140,13 @@ async fn apply_action(miner: &dyn Miner, action: &ConfigAction) -> Result<bool,
let scaling = miner.get_scaling_config().await.ok();
miner.set_tuning_config(cfg, scaling).await
}
ConfigAction::Preset(name) => {
use asic_rs::core::config::tuning::TuningConfig;
use asic_rs::core::data::miner::TuningTarget;
miner
.set_tuning_config(TuningConfig::new(TuningTarget::Preset(name.clone())), None)
.await
}
ConfigAction::TuningPercent(p) => miner.set_tuning_percent(*p).await,
ConfigAction::Timezone(tz) => {
use asic_rs::core::config::timezone::{Tz, TimezoneConfig};
@@ -1084,7 +1234,7 @@ pub fn start_config_action(ips: Vec<String>, action: ConfigAction) -> ActionHand
match outcome {
Ok(true) => (true, "ok".to_string()),
Ok(false) => (false, "refused".to_string()),
Err(e) => (false, format!("{e}")),
Err(e) => (false, e.to_string()),
}
}
Ok(None) => (false, "no miner at IP".to_string()),
@@ -1136,16 +1286,24 @@ pub fn start_pools_action(targets: Vec<PoolTarget>) -> ActionHandle {
if fake_scan_enabled() {
let err_tx = tx.clone();
let thread_cancel = cancel.clone();
let res = std::thread::Builder::new().name("fake-pools".into()).spawn(move || {
let mut ok = 0usize;
for t in targets {
// Honour cancellation between miners, like every sibling background
// action's fake branch (round 18 #12).
if thread_cancel.load(Ordering::Relaxed) {
break;
}
let first = t.pools.first().map(|p| p.username.clone()).unwrap_or_default();
let _ = tx.send(ActionMsg::Result {
ip: t.ip,
ok: true,
detail: format!("simulated ({} pool(s), {first})", t.pools.len()),
});
ok += 1;
}
let _ = tx.send(ActionMsg::Done { ok: total, total });
let _ = tx.send(ActionMsg::Done { ok, total });
});
if res.is_err() {
let _ = err_tx.send(ActionMsg::Done { ok: 0, total });
@@ -1219,6 +1377,10 @@ pub fn start_pools_action(targets: Vec<PoolTarget>) -> ActionHandle {
/// 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).
// `Row` is the common variant; boxing it to shrink the rare Started/Done/Failed
// variants would add an allocation per refreshed miner for no real gain (see the
// note on ScanMsg).
#[allow(clippy::large_enum_variant)]
pub enum RefreshMsg {
Started { total: usize },
/// A miner's telemetry was re-read successfully.
@@ -1398,7 +1560,7 @@ pub fn start_firmware_flash_action(ips: Vec<String>, image: FirmwareImage) -> Ac
match flash_one(&*miner, &image).await {
Ok(true) => (true, "ok".to_string()),
Ok(false) => (false, "refused".to_string()),
Err(e) => (false, format!("{e}")),
Err(e) => (false, e.to_string()),
}
}
}
@@ -1434,10 +1596,14 @@ pub enum AccessProbeMsg {
/// A running access probe; `stop` cancels the remaining miners.
pub struct AccessProbeHandle {
pub rx: Receiver<AccessProbeMsg>,
// The worker honours cancellation between miners; a UI stop control is not
// wired yet, so the handle-side trigger is kept for when it is.
#[allow(dead_code)]
cancel: Arc<AtomicBool>,
}
impl AccessProbeHandle {
#[allow(dead_code)]
pub fn stop(&self) {
self.cancel.store(true, Ordering::Relaxed);
}
@@ -1679,7 +1845,9 @@ mod tests {
#[test]
fn auto_secs_round_trip_and_defaults() {
// config_path() reads $HOME; point it at a private temp dir. HOME is
// process-global, so this stays one test and restores HOME afterward.
// process-global, so serialise against other HOME-mutating tests and
// restore HOME afterward (round 18 #12).
let _home = crate::model::HOME_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
let prev = std::env::var_os("HOME");
let dir = std::env::temp_dir().join(format!("alkane-test-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
File diff suppressed because it is too large Load Diff
+43
View File
@@ -0,0 +1,43 @@
# cargo-deny configuration (https://embarkstudios.github.io/cargo-deny/).
#
# Run locally with `cargo deny check`. CI's security gate is cargo-audit (lighter,
# already wired); this file documents the dependency policy and lets anyone run a
# fuller license/advisory/source check. The whole dependency set is vendored under
# ./vendor and resolved offline (see .cargo/config.toml).
[advisories]
version = 2
# Accepted, documented advisories (build-time-only reqwest 0.11 subtree of the
# wx-rs build script -- never linked into the runtime binary). Mirrors
# .cargo/audit.toml; re-review when the vendored dependency set is refreshed.
ignore = [
"RUSTSEC-2026-0258", # h2 0.3 DATA-frame DoS (build-time HTTP client only)
"RUSTSEC-2025-0134", # rustls-pemfile 1.0.4 unmaintained (same subtree)
]
[licenses]
version = 2
# The project is MIT; only permissive licenses are allowed in the
# dependency tree.
allow = [
"MIT",
"Apache-2.0",
"Apache-2.0 WITH LLVM-exception",
"BSD-2-Clause",
"BSD-3-Clause",
"ISC",
"Zlib",
"Unicode-3.0",
"Unicode-DFS-2016",
"MPL-2.0",
"CC0-1.0",
]
confidence-threshold = 0.9
[bans]
multiple-versions = "warn"
wildcards = "allow"
[sources]
unknown-registry = "warn"
unknown-git = "warn"
@@ -0,0 +1,159 @@
Subject: [PATCH 0022] luxminer: named presets + set_tuning_config (roadmap G3)
LuxOS tunes by discrete named profiles. This exposes them as first-class
presets and wires the structured tuning-config setter, so the toolkit can list
and select a profile (not only map a watts number onto one via SetPowerLimit).
- SupportsPresets: supports_presets()=true and get_presets() reads the live
`profiles` RPC into PresetInfo{name, pretty="<W> W ~ <TH> TH @ <MHz> MHz",
status=IsTuned?tuned:untuned}. Never hardcoded -- the step list varies by
model and tune state. New helper parse_profiles_to_presets + unit test.
- SupportsTuningConfig: supports_tuning_config()=true and set_tuning_config
handles Preset(name) -> profileset(name) (the same privileged RPC set_power_limit
already uses, proven in patch 0017) and Power(w) -> set_power_limit; hashrate /
mining-mode / manual targets are refused with clear messages.
Verified live (read) on two production LuxOS S19j Pro (10.4.1.60 / .67): the
profile ladders and supports_tuning_config=true are reported correctly. The
write path reuses the already-proven profileset(name) call; per the parity
roadmap, LuxOS profile writes are bench-only (never on the .60/.67 production
units), so the setter is not exercised against them here.
diff --git a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
index a4db1e03..b5a5a73c 100644
--- a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
@@ -5,6 +5,8 @@ use asic_rs_core::{
config::{
collector::{ConfigCollector, ConfigExtractor, ConfigField, ConfigLocation},
pools::{PoolConfig, PoolGroupConfig},
+ preset::PresetInfo,
+ tuning::TuningConfig,
},
data::{
board::{BoardData, ChipData, MinerControlBoard},
@@ -1102,6 +1104,38 @@ fn parse_profile_watts(profiles: &Value) -> Vec<(String, f64)> {
.unwrap_or_default()
}
+/// Parse a LuxOS `profiles` RPC reply into the firmware's tunable presets, one
+/// per dynamic profile (round 18 / roadmap G3). The `Profile Name` is the
+/// identifier `profileset` expects; the pretty string summarises the profile's
+/// watt / hashrate / frequency operating point, and `status` reflects `IsTuned`.
+fn parse_profiles_to_presets(profiles: &Value) -> Vec<PresetInfo> {
+ profiles
+ .get("PROFILES")
+ .and_then(Value::as_array)
+ .map(|arr| {
+ arr.iter()
+ .filter_map(|p| {
+ let name = p.get("Profile Name").and_then(Value::as_str)?.to_string();
+ let watts = p.get("Watts").and_then(Value::as_f64);
+ let hashrate = p.get("Hashrate").and_then(Value::as_f64);
+ let freq = p.get("Frequency").and_then(Value::as_f64);
+ let pretty = match (watts, hashrate, freq) {
+ (Some(w), Some(h), Some(f)) => Some(format!("{w:.0} W ~ {h:.1} TH @ {f:.0} MHz")),
+ (Some(w), Some(h), None) => Some(format!("{w:.0} W ~ {h:.1} TH")),
+ (Some(w), None, _) => Some(format!("{w:.0} W")),
+ _ => None,
+ };
+ let status = p
+ .get("IsTuned")
+ .and_then(Value::as_bool)
+ .map(|t| if t { "tuned" } else { "untuned" }.to_string());
+ Some(PresetInfo { name, pretty, status })
+ })
+ .collect()
+ })
+ .unwrap_or_default()
+}
+
/// Choose the LuxOS profile name to satisfy a watts power limit: the highest-watt
/// profile that does not exceed `target_w`, or -- when the target is below every
/// profile -- the lowest-watt profile. Returns None only when there are no
@@ -1284,7 +1318,38 @@ impl Validate for LuxMinerV1 {
#[async_trait]
impl SupportsTuningConfig for LuxMinerV1 {
fn supports_tuning_config(&self) -> bool {
- false
+ true
+ }
+
+ /// LuxOS tunes by named profile (roadmap G3). A `Preset` target is applied
+ /// straight through `profileset`; a `Power` target reuses the watts->profile
+ /// mapping in `set_power_limit`. LuxOS has no hashrate/mining-mode targets and
+ /// per-board manual tuning is not wired, so those targets are refused.
+ async fn set_tuning_config(
+ &self,
+ config: TuningConfig,
+ _scaling_config: Option<asic_rs_core::config::scaling::ScalingConfig>,
+ ) -> anyhow::Result<bool> {
+ match config.target {
+ TuningTarget::Preset(name) => {
+ let resp = self.rpc.profileset(&name).await?;
+ Ok(resp
+ .pointer("/STATUS/0/STATUS")
+ .and_then(Value::as_str)
+ .map(|s| matches!(s, "S" | "I"))
+ .unwrap_or(true))
+ }
+ TuningTarget::Power(p) => self.set_power_limit(p).await,
+ TuningTarget::HashRate(_) => {
+ anyhow::bail!("LuxOS does not tune by hashrate target; select a named profile")
+ }
+ TuningTarget::MiningMode(_) => {
+ anyhow::bail!("LuxOS has no mining modes; select a named profile")
+ }
+ TuningTarget::Manual { .. } => {
+ anyhow::bail!("Per-board manual tuning is not wired for LuxOS")
+ }
+ }
}
}
@@ -1299,7 +1364,21 @@ impl SupportsTemperatureConfig for LuxMinerV1 {}
impl GetTuningPercent for LuxMinerV1 {}
impl SetTuningPercent for LuxMinerV1 {}
-impl SupportsPresets for LuxMinerV1 {}
+#[async_trait]
+impl SupportsPresets for LuxMinerV1 {
+ fn supports_presets(&self) -> bool {
+ true
+ }
+
+ /// The firmware's tunable profiles, read live from the `profiles` RPC (roadmap
+ /// G3). Never hardcoded -- the step list varies by model and tune state.
+ async fn get_presets(&self) -> Vec<PresetInfo> {
+ match self.rpc.profiles().await {
+ Ok(profiles) => parse_profiles_to_presets(&profiles),
+ Err(_) => Vec::new(),
+ }
+ }
+}
#[cfg(test)]
mod tests {
use std::sync::{Arc, Mutex};
@@ -1361,6 +1440,22 @@ mod tests {
assert!(select_profile_at_or_below(&parsed, 2500.0).is_some());
}
+ #[test]
+ fn profiles_parse_to_presets() {
+ // The `profiles` reply becomes one PresetInfo per profile (roadmap G3).
+ let profiles: Value = serde_json::from_str(PROFILES).unwrap();
+ let presets = parse_profiles_to_presets(&profiles);
+ assert_eq!(presets.len(), 25, "one preset per fixture profile");
+ // The factory point is named "default"; its pretty string carries the
+ // watt / hashrate / frequency operating point.
+ let default = presets.iter().find(|p| p.name == "default").unwrap();
+ assert_eq!(default.pretty.as_deref(), Some("2794 W ~ 121.8 TH @ 590 MHz"));
+ // IsTuned maps to the status string.
+ let tuned = presets.iter().find(|p| p.name == "290MHz").unwrap();
+ assert_eq!(tuned.status.as_deref(), Some("tuned"));
+ assert_eq!(default.status.as_deref(), Some("untuned"));
+ }
+
#[tokio::test]
async fn test_luxminer_v1() -> anyhow::Result<()> {
+5
View File
@@ -39,6 +39,11 @@ version = "1.0"
[build-dependencies.embed-resource]
version = "1.3"
# reqwest is only used by build.rs to download the wxWidgets source on
# Windows/macOS; on Linux download_dist() returns before touching it, and it is
# never linked into the runtime binary. Kept at the vendored 0.11 (the build tree
# is fully vendored / offline); the h2 0.3 advisory it pulls is build-time only
# and is documented as accepted in audit.toml (RUSTSEC-2026-0258).
[build-dependencies.reqwest]
version = "0.11"
features = ["blocking"]
@@ -776,6 +776,13 @@ void* wxbr_text_ctrl(void* parent, int multiline) {
wxDefaultPosition, wxSize(-1, -1), style);
}
// A single-line text control that masks its content (wxTE_PASSWORD), for secret
// entry so a saved password is never rendered in the clear (round 18 #12).
void* wxbr_text_ctrl_password(void* parent) {
return (void*)new wxTextCtrl((wxWindow*)parent, wxID_ANY, wxT(""),
wxDefaultPosition, wxSize(-1, -1), wxTE_PASSWORD);
}
int wxbr_text_ctrl_get(void* win, char* buf, int cap) {
wxTextCtrl* t = (wxTextCtrl*)win;
wxString v = t->GetValue();
@@ -983,6 +990,17 @@ static gboolean dvlc_query_tooltip(GtkWidget* tv, gint x, gint y, gboolean keybo
if (slot >= (int)iit->second.size()) slot = (int)iit->second.size() - 1;
const wxString& tip = iit->second[(size_t)slot];
if (tip.IsEmpty()) return FALSE;
// Scope the tooltip's "tip area" to just this icon's slot (round 18 #4a).
// Without a tip area GTK defaults it to the whole widget, so it never re-queries
// or moves the tooltip as the pointer crosses from one icon to the next -- the
// old tooltip just stays put with stale text. Setting a per-slot area makes GTK
// hide + re-show + reposition the tooltip for each icon.
GdkRectangle area;
area.x = crect.x + slot * adv;
area.y = crect.y;
area.width = adv;
area.height = crect.height;
gtk_tooltip_set_tip_area(tooltip, &area);
gtk_tooltip_set_text(tooltip, tip.utf8_str());
return TRUE;
}
@@ -1280,6 +1298,23 @@ void wxbr_dvlc_autosize_col(void* win, int pos) {
if (c) c->SetWidth(wxCOL_WIDTH_AUTOSIZE);
}
// Size a column to fit its content + header, then clamp to cap_px so the default
// width is min(reasonable cap, content-fit) -- a short column shrinks to its
// content, a long one is capped at the caller's sensible default (round 18 #10).
// A small floor keeps a column from collapsing to nothing.
void wxbr_dvlc_autosize_col_capped(void* win, int pos, int cap_px) {
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
if (pos < 0 || (unsigned)pos >= dv->GetColumnCount()) return;
wxDataViewColumn* c = dv->GetColumn((unsigned)pos);
if (!c) return;
c->SetWidth(wxCOL_WIDTH_AUTOSIZE);
int w = c->GetWidth();
const int floor_px = 24;
if (w < floor_px) w = floor_px;
if (cap_px > 0 && w > cap_px) w = cap_px;
c->SetWidth(w);
}
// Update a column's header text in place (creation index) without recreating
// the control -- used to refresh the ASCII sort marker on a sort click.
void wxbr_dvlc_set_col_title(void* win, int col, const char* title) {
+13
View File
@@ -36,6 +36,7 @@ mod notsafe {
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_password(parent: *mut c_void) -> *mut c_void;
pub fn wxbr_text_ctrl_get(win: *mut c_void, buf: *mut c_char, cap: c_int) -> c_int;
pub fn wxbr_text_ctrl_set(win: *mut c_void, value: *const c_char);
pub fn wxbr_text_ctrl_write(win: *mut c_void, value: *const c_char);
@@ -68,6 +69,7 @@ mod notsafe {
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_autosize_col_capped(win: *mut c_void, pos: c_int, cap_px: 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;
@@ -437,6 +439,11 @@ impl Widget {
Widget(unsafe { notsafe::wxbr_text_ctrl(parent.0, multiline as c_int) })
}
/// A single-line text control that masks its content (for password entry).
pub fn password_ctrl(parent: Widget) -> Widget {
Widget(unsafe { notsafe::wxbr_text_ctrl_password(parent.0) })
}
pub fn get_value(&self) -> String {
let mut buf = vec![0i8; 65536];
let n = unsafe { notsafe::wxbr_text_ctrl_get(self.0, buf.as_mut_ptr(), buf.len() as c_int) };
@@ -647,6 +654,12 @@ impl Widget {
unsafe { notsafe::wxbr_dvlc_autosize_col(self.0, pos as c_int) }
}
/// Size the column at display position `pos` to its content, then clamp to
/// `cap_px`: the width becomes min(cap, content-fit) (round 18 #10).
pub fn dvlc_autosize_col_capped(&self, pos: usize, cap_px: i32) {
unsafe { notsafe::wxbr_dvlc_autosize_col_capped(self.0, pos as c_int, cap_px) }
}
/// 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) };
+1 -1
View File
@@ -1 +1 @@
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"fe8effe2bfdda5d4c390656c016729f531a2b1c60033228557659c0befdde9f2","Cargo.lock":"a2b2cb45bb8b574e4f29ffdcdb5ebafd1dd87a0e6e11b47383973a99be367784","Cargo.toml":"503efa00123f8567f5fe40bf6a93e9e453d13094df0e0e1b7e98bdacdfbd2595","Cargo.toml.orig":"1c4ba0315fb491c086fc22a5c9bafaf7288c6b1fd48679c3d03dbd9df156a8b5","src/backends/mod.rs":"548d988b877410e330a55e275f64b2adad95ca5f1a0f085fe144957c96b8906f","src/backends/v1/mod.rs":"0c12f7714b8486372054261afd263b61f432a446cef8ae9e6cd72550a0cf4f8f","src/backends/v1/rpc.rs":"25b0b9d56fbf113d5b8c3d3bc8eb7a0d67967b1f90f6d855da0b9f6ff24ae335","src/firmware.rs":"d95345295ae5043dfc357e69ae56c564b261fdb3b19b5c0ad1765267ff05ab3f","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"24191681066d5cf6a3022ad59c1baa92b57e3ce7717bb78d6a682af9e19a38c4","src/test/json/v1/config.json":"6ca9e6217d853d4bf1e75d69159630e9c9184ede96751706b88dfb699b5d59ad","src/test/json/v1/devs.json":"8f746dc6a02953eee5ee96dcf53be8dc7880a8ffc2c6e303f0284bcf6a97f42d","src/test/json/v1/events.json":"913683ff97af3333018807e1cc6e43467ea8a55925e5964dc402616615e2a5e3","src/test/json/v1/fans.json":"f8a9a1234d651055c80f4ebb1380bbb4e6d19eb33012902c55fff1385e592447","src/test/json/v1/healthchipget_0.json":"10619460049333ca016b2beec59ecc514ed9077fb19bdf7d0ed697201f8cb96c","src/test/json/v1/healthchipget_1.json":"80927fb1480c95be7f3a4e155d63f68f97720530ff7cf5d5ade06f2a3e810bf0","src/test/json/v1/healthchipget_2.json":"1e93ee2ab472ee7af58add08b4251e3ce0ad4f986d4325abbf43fd4c9b3dd28f","src/test/json/v1/mod.rs":"5a050f07455e622e35ad79ab1c8a6daf2ea38c4198472e49c6bbfe80538a9e48","src/test/json/v1/pools.json":"0068745327e31853fec051172abb7337f18a4cf9972c51967113d63f4f31f504","src/test/json/v1/power.json":"80534bb4581de7c8b747bf33b5d629b909c6e16a531d18ecb4afd7ffad3f014f","src/test/json/v1/profiles.json":"1f00429036e270daa08f12cd2d7357135070c57acd7a899a3c0af6167fe82abb","src/test/json/v1/stats.json":"2b105f0eb927046c9d2389bde978a43e3d54d12a420dfbe400786bb2f0ae31ca","src/test/json/v1/summary.json":"aaea3378eb7040952037e2f1ef7bd5f20a1b242bf93d4ba0501c46104b0b31a0","src/test/json/v1/temps.json":"1ee781cd2be3ed6a6a07e23be930248735fb51348c160453ba10f6ef71fcb7f1","src/test/json/v1/version.json":"4beb6ca5c0ebf359cee0434fdcc4d0a1a0607436634e46be3fd951e2256595df","src/test/json/v1/voltageget_0.json":"c445fa8674c2542b2d296fbafdd3166c53008dfbd9da8095327217989d37f1da","src/test/json/v1/voltageget_1.json":"96b91c3447dd66e7f1f575ed3b99611062e8b1d516d31422b74e425c46b2f49c","src/test/json/v1/voltageget_2.json":"7d40544021b2e32401135ae333067b770d2d736ada9e60deaca8fd8f5a79a1e3","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"513792d93a2a21d5258d9e6ac0e6dc9e0a6365118934514b4e656792add78066"}
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"fe8effe2bfdda5d4c390656c016729f531a2b1c60033228557659c0befdde9f2","Cargo.lock":"a2b2cb45bb8b574e4f29ffdcdb5ebafd1dd87a0e6e11b47383973a99be367784","Cargo.toml":"503efa00123f8567f5fe40bf6a93e9e453d13094df0e0e1b7e98bdacdfbd2595","Cargo.toml.orig":"1c4ba0315fb491c086fc22a5c9bafaf7288c6b1fd48679c3d03dbd9df156a8b5","src/backends/mod.rs":"548d988b877410e330a55e275f64b2adad95ca5f1a0f085fe144957c96b8906f","src/backends/v1/mod.rs":"abcf1ffb8443efa70838489b026730ac19de774ba9e6f7c9a9800e3ba03c06a4","src/backends/v1/rpc.rs":"25b0b9d56fbf113d5b8c3d3bc8eb7a0d67967b1f90f6d855da0b9f6ff24ae335","src/firmware.rs":"d95345295ae5043dfc357e69ae56c564b261fdb3b19b5c0ad1765267ff05ab3f","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"24191681066d5cf6a3022ad59c1baa92b57e3ce7717bb78d6a682af9e19a38c4","src/test/json/v1/config.json":"6ca9e6217d853d4bf1e75d69159630e9c9184ede96751706b88dfb699b5d59ad","src/test/json/v1/devs.json":"8f746dc6a02953eee5ee96dcf53be8dc7880a8ffc2c6e303f0284bcf6a97f42d","src/test/json/v1/events.json":"913683ff97af3333018807e1cc6e43467ea8a55925e5964dc402616615e2a5e3","src/test/json/v1/fans.json":"f8a9a1234d651055c80f4ebb1380bbb4e6d19eb33012902c55fff1385e592447","src/test/json/v1/healthchipget_0.json":"10619460049333ca016b2beec59ecc514ed9077fb19bdf7d0ed697201f8cb96c","src/test/json/v1/healthchipget_1.json":"80927fb1480c95be7f3a4e155d63f68f97720530ff7cf5d5ade06f2a3e810bf0","src/test/json/v1/healthchipget_2.json":"1e93ee2ab472ee7af58add08b4251e3ce0ad4f986d4325abbf43fd4c9b3dd28f","src/test/json/v1/mod.rs":"5a050f07455e622e35ad79ab1c8a6daf2ea38c4198472e49c6bbfe80538a9e48","src/test/json/v1/pools.json":"0068745327e31853fec051172abb7337f18a4cf9972c51967113d63f4f31f504","src/test/json/v1/power.json":"80534bb4581de7c8b747bf33b5d629b909c6e16a531d18ecb4afd7ffad3f014f","src/test/json/v1/profiles.json":"1f00429036e270daa08f12cd2d7357135070c57acd7a899a3c0af6167fe82abb","src/test/json/v1/stats.json":"2b105f0eb927046c9d2389bde978a43e3d54d12a420dfbe400786bb2f0ae31ca","src/test/json/v1/summary.json":"aaea3378eb7040952037e2f1ef7bd5f20a1b242bf93d4ba0501c46104b0b31a0","src/test/json/v1/temps.json":"1ee781cd2be3ed6a6a07e23be930248735fb51348c160453ba10f6ef71fcb7f1","src/test/json/v1/version.json":"4beb6ca5c0ebf359cee0434fdcc4d0a1a0607436634e46be3fd951e2256595df","src/test/json/v1/voltageget_0.json":"c445fa8674c2542b2d296fbafdd3166c53008dfbd9da8095327217989d37f1da","src/test/json/v1/voltageget_1.json":"96b91c3447dd66e7f1f575ed3b99611062e8b1d516d31422b74e425c46b2f49c","src/test/json/v1/voltageget_2.json":"7d40544021b2e32401135ae333067b770d2d736ada9e60deaca8fd8f5a79a1e3","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"513792d93a2a21d5258d9e6ac0e6dc9e0a6365118934514b4e656792add78066"}
+97 -2
View File
@@ -5,6 +5,8 @@ use asic_rs_core::{
config::{
collector::{ConfigCollector, ConfigExtractor, ConfigField, ConfigLocation},
pools::{PoolConfig, PoolGroupConfig},
preset::PresetInfo,
tuning::TuningConfig,
},
data::{
board::{BoardData, ChipData, MinerControlBoard},
@@ -1102,6 +1104,38 @@ fn parse_profile_watts(profiles: &Value) -> Vec<(String, f64)> {
.unwrap_or_default()
}
/// Parse a LuxOS `profiles` RPC reply into the firmware's tunable presets, one
/// per dynamic profile (round 18 / roadmap G3). The `Profile Name` is the
/// identifier `profileset` expects; the pretty string summarises the profile's
/// watt / hashrate / frequency operating point, and `status` reflects `IsTuned`.
fn parse_profiles_to_presets(profiles: &Value) -> Vec<PresetInfo> {
profiles
.get("PROFILES")
.and_then(Value::as_array)
.map(|arr| {
arr.iter()
.filter_map(|p| {
let name = p.get("Profile Name").and_then(Value::as_str)?.to_string();
let watts = p.get("Watts").and_then(Value::as_f64);
let hashrate = p.get("Hashrate").and_then(Value::as_f64);
let freq = p.get("Frequency").and_then(Value::as_f64);
let pretty = match (watts, hashrate, freq) {
(Some(w), Some(h), Some(f)) => Some(format!("{w:.0} W ~ {h:.1} TH @ {f:.0} MHz")),
(Some(w), Some(h), None) => Some(format!("{w:.0} W ~ {h:.1} TH")),
(Some(w), None, _) => Some(format!("{w:.0} W")),
_ => None,
};
let status = p
.get("IsTuned")
.and_then(Value::as_bool)
.map(|t| if t { "tuned" } else { "untuned" }.to_string());
Some(PresetInfo { name, pretty, status })
})
.collect()
})
.unwrap_or_default()
}
/// Choose the LuxOS profile name to satisfy a watts power limit: the highest-watt
/// profile that does not exceed `target_w`, or -- when the target is below every
/// profile -- the lowest-watt profile. Returns None only when there are no
@@ -1284,7 +1318,38 @@ impl Validate for LuxMinerV1 {
#[async_trait]
impl SupportsTuningConfig for LuxMinerV1 {
fn supports_tuning_config(&self) -> bool {
false
true
}
/// LuxOS tunes by named profile (roadmap G3). A `Preset` target is applied
/// straight through `profileset`; a `Power` target reuses the watts->profile
/// mapping in `set_power_limit`. LuxOS has no hashrate/mining-mode targets and
/// per-board manual tuning is not wired, so those targets are refused.
async fn set_tuning_config(
&self,
config: TuningConfig,
_scaling_config: Option<asic_rs_core::config::scaling::ScalingConfig>,
) -> anyhow::Result<bool> {
match config.target {
TuningTarget::Preset(name) => {
let resp = self.rpc.profileset(&name).await?;
Ok(resp
.pointer("/STATUS/0/STATUS")
.and_then(Value::as_str)
.map(|s| matches!(s, "S" | "I"))
.unwrap_or(true))
}
TuningTarget::Power(p) => self.set_power_limit(p).await,
TuningTarget::HashRate(_) => {
anyhow::bail!("LuxOS does not tune by hashrate target; select a named profile")
}
TuningTarget::MiningMode(_) => {
anyhow::bail!("LuxOS has no mining modes; select a named profile")
}
TuningTarget::Manual { .. } => {
anyhow::bail!("Per-board manual tuning is not wired for LuxOS")
}
}
}
}
@@ -1299,7 +1364,21 @@ impl SupportsTemperatureConfig for LuxMinerV1 {}
impl GetTuningPercent for LuxMinerV1 {}
impl SetTuningPercent for LuxMinerV1 {}
impl SupportsPresets for LuxMinerV1 {}
#[async_trait]
impl SupportsPresets for LuxMinerV1 {
fn supports_presets(&self) -> bool {
true
}
/// The firmware's tunable profiles, read live from the `profiles` RPC (roadmap
/// G3). Never hardcoded -- the step list varies by model and tune state.
async fn get_presets(&self) -> Vec<PresetInfo> {
match self.rpc.profiles().await {
Ok(profiles) => parse_profiles_to_presets(&profiles),
Err(_) => Vec::new(),
}
}
}
#[cfg(test)]
mod tests {
use std::sync::{Arc, Mutex};
@@ -1361,6 +1440,22 @@ mod tests {
assert!(select_profile_at_or_below(&parsed, 2500.0).is_some());
}
#[test]
fn profiles_parse_to_presets() {
// The `profiles` reply becomes one PresetInfo per profile (roadmap G3).
let profiles: Value = serde_json::from_str(PROFILES).unwrap();
let presets = parse_profiles_to_presets(&profiles);
assert_eq!(presets.len(), 25, "one preset per fixture profile");
// The factory point is named "default"; its pretty string carries the
// watt / hashrate / frequency operating point.
let default = presets.iter().find(|p| p.name == "default").unwrap();
assert_eq!(default.pretty.as_deref(), Some("2794 W ~ 121.8 TH @ 590 MHz"));
// IsTuned maps to the status string.
let tuned = presets.iter().find(|p| p.name == "290MHz").unwrap();
assert_eq!(tuned.status.as_deref(), Some("tuned"));
assert_eq!(default.status.as_deref(), Some("untuned"));
}
#[tokio::test]
async fn test_luxminer_v1() -> anyhow::Result<()> {