Compare commits

...
23 Commits
Author SHA1 Message Date
noahandClaude Opus 4.8 45d9632590 asic-rs telemetry T3-temps: board temperature thresholds (critical / shutdown)
Round 19 #10 telemetry extension. Adds the board temperature safety thresholds
("board dangerous temp" from item #10).

Core (asic-rs-core):
- New DataField::TemperatureLimits; MinerData gains temp_critical and temp_shutdown
  (Celsius).
- Rides the existing GetFluidTemperature trait via a defaulted parse_temperature_limits
  method returning (critical, shutdown) -- no supertrait blast radius; parse_data
  wires both fields in.

Backend:
- ePIC: summary /Misc Critical Temp + Shutdown Temp (already-fetched summary).
- Antminer/WhatsMiner expose no thresholds; LuxOS needs an unwired tempctrl command
  (no fixture) and VNish/Braiins need live verification -> left for a live-verified
  pass, all inherit (None, None).

GUI: two new columns (Critical temp / Shutdown temp), right-aligned, Temperature
category, auto-hidden when empty. MinerRow gains temp_critical_c / temp_shutdown_c;
to_row reads them. ALL_COLUMNS 68 -> 70.

Fixture test for epic asserts the parsed thresholds. Patch 0028.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 16:53:57 -06:00
alkane-ci 0265370be2 ci: refresh README badges [skip release] 2026-09-23 22:43:35 +00:00
noahandClaude Opus 4.8 fadd851e04 asic-rs telemetry T3-fan: miner-level fan duty cycle (fan speed %)
Round 19 #10 / #8 telemetry extension. Adds the fan duty cycle as a miner-level
percentage -- the normalized fan-load indicator the GUI wanted alongside per-fan
RPMs. No firmware exposes a maximum fan RPM, so a true actual/maximum pair is not
possible; the duty cycle is the closest normalized signal.

Core (asic-rs-core):
- New DataField::FanSpeedPercent; MinerData gains fan_speed_percent (Option<f64>).
- Modeled as a top-level miner-level value (most firmwares report a single duty),
  so FanData is untouched -- no Eq removal / literal churn across its 17 crates.
- Rides the existing GetFans trait via a defaulted parse_fan_speed_percent method
  (no supertrait blast radius); parse_data wires it in.

Backends (read already-fetched commands, no extra round-trips):
- ePIC: summary /Fans/Fans Speed (single %).
- LuxOS: max of FANS[].Speed.
- Braiins v25_07 + v26_04: max of cooling fans[].target_speed_ratio x 100.
- Antminer (pwm via config) and VNish (fan_duty) have no data fixtures -> left for a
  live-verified pass; WhatsMiner is firmware-locked -> None.

GUI: new "Fan %" column (right-aligned, Cooling category, auto-hidden when empty).
MinerRow gains fan_speed_percent; to_row reads it. ALL_COLUMNS 67 -> 68.

Fixture tests: epic, luxminer, braiins v26_04 assert the parsed percentage. Patch 0027.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 16:28:14 -06:00
alkane-ci 24f9d9682d ci: refresh README badges [skip release] 2026-09-23 22:10:04 +00:00
noahandClaude Opus 4.8 3f9fc4a24b asic-rs telemetry T2b: cumulative share stats (difficulty acc/rej, stale, blocks)
Round 19 #10 telemetry extension, tier 2b. Adds the cumulative share statistics
from item #10 end to end: difficulty-weighted accepted/rejected work, raw stale
share count, and blocks found.

Core (asic-rs-core):
- New ShareSummary sub-struct (data/share.rs) with a parse_cgminer_share_summary
  helper reading a cgminer/btminer SUMMARY[0] object.
- New DataField::ShareSummary; MinerData gains share_summary.
- Rides the existing GetBestShare trait via a defaulted parse_share_summary method
  (no new supertrait bound, no per-backend empty impl); parse_data wires it in.

Backends (read the already-fetched SUMMARY, so no extra round-trips; these are
miner-level aggregates -> top-level MinerData fields, not per-pool PoolData):
- Antminer v2020 + v2023_07, LuxOS, WhatsMiner V1 + V2 override parse_share_summary.
- Braiins (no cumulative difficulty), ePIC (current difficulty only), WhatsMiner V3
  and VNish expose none and inherit None -- fixtures confirm.

GUI: four new columns (Diff acc / Diff rej / Stale / Blocks), right-aligned, in the
Pools category, auto-hidden when empty. MinerRow gains the four fields; to_row reads
them from share_summary. ALL_COLUMNS 63 -> 67.

Fixture tests: whatsminer v1 and antminer v2020 assert the parsed values. Patch 0026.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 15:51:57 -06:00
alkane-ci 8ab607de6c ci: refresh README badges [skip release] 2026-09-23 21:30:23 +00:00
noahandClaude Opus 4.8 a60bb34e64 asic-rs telemetry T2a: rolling average hashrate windows (1m/5m/15m/24h)
Round 19 #10 telemetry extension, tier 2. Adds the rolling average hashrate
windows the GUI asked for (1M/5M/15M/24H) end to end.

Core (asic-rs-core):
- New HashrateAverages sub-struct (data/hashrate.rs): avg_1m/5m/15m/24h, each an
  Option<HashRate> carrying the same unit and algorithm as the current hashrate.
- New DataField::HashrateAverages; MinerData gains hashrate_averages.
- The windows ride the EXISTING GetHashrate trait via a new defaulted
  parse_hashrate_averages method (default None), so no new supertrait bound and no
  empty impl in every backend -- only the backends that expose the data override
  it. parse_data wires it in.

Backends (all read a command the collector already fetches -> no extra round-trips;
each window is filtered to > 0 and the whole struct is dropped when every window is
absent, so a firmware that reports nothing keeps hashrate_averages = None):
- WhatsMiner V1: btminer summary MHS 1m/5m/15m (MegaHash); no 24h.
- WhatsMiner V3: get.miner.status summary hash-1min / hash-15min (TeraHash) only.
- LuxOS: summary GHS 1m/5m/15m/24h (GigaHash) -- full window set.
- Braiins v25_07 + v26_04: miner_stats real_hashrate last_1m/5m/15m/24h (GigaHash).
- Antminer (5s/30m/av only), WhatsMiner V2 (av only), ePIC/VNish (session average
  only), sealminer: no standard 1/5/15 window -> inherit None. This is honest: the
  fixtures confirm those firmwares do not expose the standard windows.

GUI: four new columns (HR 1m/5m/15m/24h), single TH/s value each, right-aligned,
blank when the window is not reported, auto-hidden when empty across the fleet.
MinerRow gains the four ths fields; to_row populates them from hashrate_averages.

Fixture tests: whatsminer v1 and braiins v26_04 gain assertions on the parsed
windows (value, unit, and the expected present/absent pattern). Patch 0025.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 15:08:27 -06:00
alkane-ci c944897807 ci: refresh README badges [skip release] 2026-09-23 20:45:46 +00:00
noahandClaude Opus 4.8 a6e22581d7 asic-rs telemetry T1b: WhatsMiner V3 PSU serial + ePIC chip/HB type
Round 19 #10 telemetry extension, tier 1 sub-batch B. Both ride existing
DataFields (Psu/Hashboards) on already-fetched commands (no extra round-trips)
and reuse the PsuInfo.serial / BoardData.chip_type+hashboard_model fields added
in T1a, so no core or GUI change -- the existing columns just populate for more
firmwares. Patch 0024; fixture tests pass.

- WhatsMiner V3: add a DataField::Psu location (get.device.info /msg/power) and a
  parse_psu that reads model/type, sw/hwversion, and the serial (sn). V3 had no
  PSU parse at all (default None) despite the data being fetched for PsuFans.
- ePIC: parse_hashboards now reads capabilities "Chip Type" (e.g. "BM1366") and
  "Model Subtype" (e.g. "BHB56801"), applied to every board (capabilities reports
  them miner-wide). The capabilities command is already fetched for Hashboards.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 14:31:36 -06:00
alkane-ci b15de7f747 ci: refresh README badges [skip release] 2026-09-23 20:18:33 +00:00
noahandClaude Opus 4.8 f887affd6d asic-rs telemetry T1a: PSU serial + chip/HB type + best-share
Extend vendored asic-rs to scan more per-firmware telemetry (round 19 #10
follow-up, tier 1 sub-batch A). All new values ride on existing DataFields
(Psu/Hashboards/BestShare) and commands already fetched, so no new core
DataField plumbing and no extra network round-trips. Patch 0023.

Vendored (asic-rs):
- PsuInfo gains `serial`. Braiins v26_04 parse_psu corrected to read model_name
  + fw_version (it used the numeric type code as the model and dropped the fw
  version) and to capture serial_number. ePIC / WhatsMiner v1/v2 report no serial.
- BoardData gains `chip_type` (e.g. "BM1370") + `hashboard_model` (e.g.
  "A3HB70601"); Braiins miner/hw/hashboards populates both.
- best_share (all-time) wired for Antminer v2020 and WhatsMiner v1/v2 from the
  already-fetched summary "Best Share" (those backends had the empty default).
- refresh-checksums --all; existing braiins/antminer/whatsminer fixture tests pass.

GUI:
- MinerRow gains chip_type, hashboard_model, psu_serial; populated in to_row.
- New columns: Chip, HB model, PSU serial. Best share now populates for Antminer
  and WhatsMiner (column already existed).

Feasibility analysis (5-agent, all firmwares) recorded in memory; further tiers
(fan %, rolling hashrate averages, difficulty/shares, temp thresholds, WhatsMiner
V3 / VNish PSU serial) follow. Confirmed genuinely-unavailable: fan max RPM,
WhatsMiner/LuxOS real logs, chip type on Antminer/LuxOS.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 14:01:33 -06:00
alkane-ci e5e6b0f1e1 ci: refresh README badges [skip release] 2026-09-23 18:40:11 +00:00
noahandClaude Opus 4.8 ad28dab542 round 19 review fixes + Health-column alignment + badge-push fix
Health column (operator-reported): give every component-health icon a UNIFORM
fixed-width slot in the SegmentRenderer (GetSize + DrawShape), so power/control/
fan/board icons line up in fixed columns across rows regardless of glyph aspect,
and left-align the icon columns (Health/Access/Light) so the block anchors at a
consistent left edge. The per-icon tooltip hit-test uses the same uniform slot.

Code-review-harness fixes:
- High: isolate per-miner telemetry with catch_unwind so one miner's get_data
  panic can't abort the whole scan (and strand the fast-path partial rows).
- Medium: fill the zebra stripe across the full cell for right-aligned colored
  columns (was anchored at the content's left edge, leaving the left unstriped).
- Medium: lower the scan-concurrency ceiling 512 -> 256 (128 is fully reliable,
  192 already dropped responders on the live fleet).
- Medium: board voltage/frequency sort key skips placeholder-zero boards
  (avg_positive), matching how the cell renders them as "-".
- Low: saturating_add for accepted/rejected share sums; moved an orphaned doc
  comment; corrected a stale comment.

CI: fix the README-badge push-back -- `git push -c http.extraheader` is invalid
(`-c` must precede the subcommand), so the badge/coverage/bench-baseline commit
never actually reached main; now `git -c http.extraheader=... push`. This also
lets the bench-delta baseline persist so the delta can compute.

Demo: the offline-demo paused miner now has detected (idle) hashboards so the
paused-blue Health icons (round 19 #19) are exercised.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 12:21:03 -06:00
noahandClaude Opus 4.8 42e3bf8f5b round 19: columns, scan speed, per-firmware logs, more scanned fields
Table/columns:
- Fix the "columns shrink to tiny" bug on language change / add / hide (#3, #24):
  the rebuild-time capped autosize read column widths before GTK's measurement
  landed. Columns keep their default widths; autosize is on-demand only.
- Right-align every column except IP (#21): new alignment param on the bridge
  append calls; the SegmentRenderer and the tooltip hit-test honour it.
- "Auto-size all columns" header menu item; Ctrl+A selects all rows (#4).
- Remove the Boards (dots) column (#7).
- Split the slash-joined Fan column into per-fan columns Fan 1-4 (#8).
- Efficiency: unit moved into the value and made algorithm-aware (J/TH for
  SHA256 families, J/kSol for Equihash), fixing the blank/garbage figure on
  non-SHA256 miners (#9, #23).
- Pool account column before Worker by default (#22).

Scan:
- Fast scan (#18): emit a lightweight identity row the instant a miner is
  identified, then upsert the full telemetry row when get_data completes.
- User-adjustable scan concurrency with a bounded max (#25).
- Surface more scanned values as columns (#10): current tuning target, accepted
  / rejected shares + reject %, and per-hashboard hashrate / voltage / frequency.

Logs (#11-16): fetch the miner log through asic-rs's per-backend read_logs()
instead of the narrow curl paths, fixing Braiins / LuxOS / Z15 / BixBit / stock
Antminer; WhatsMiner keeps the fault-code fallback (no API log). Removed the
summary tidbits from the log viewer (#13).

Misc: fix per-icon health tooltips (advance math matched to the renderer) (#2);
paused miners show blue hashboard icons, healthy stays green (#19); state-aware
Pause/Resume in the right-click menu (#20); export opens a column-picker dialog
(#6) and the default filename carries a UTC timestamp (#5); the scan status bar
says "Scan Paused" / "Scan Stopped" and no longer overwrites Stop with paused
(#17); the bench badge shows the weighted-average microbench delta vs the
previous release (#1).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 11:40:21 -06:00
noahandClaude Opus 4.8 4154a50ed0 ci: measure coverage in the release job and auto-update the badge
Add a best-effort Coverage step to release.yml: it adds the llvm-tools-preview
rustup component, fetches cargo-llvm-cov as a prebuilt binary (the vendored
.cargo/config blocks `cargo install` from crates.io), runs ci/coverage.sh to
merge unit-test and headless self-test line coverage, and feeds the TOTAL
line-coverage percent to the badge refresh so badges/coverage.svg tracks the
real number on every release. The step is gated on a release and marked
continue-on-error, so coverage tooling can never block a release.

coverage.sh now runs its instrumented builds --offline by default (the
dependency tree is fully vendored), overridable via CARGO_LLVM_COV_FLAGS.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 09:32:41 -06:00
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
62 changed files with 3932 additions and 870 deletions
+57 -9
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
@@ -52,7 +55,6 @@ jobs:
- name: Clippy (our crate, warnings are errors)
if: steps.ver.outputs.release == 'true'
run: |
export WX_RS_WXCONFIG="$WX_PREFIX/bin/wx-config"
rustup component add clippy >/dev/null 2>&1 || true
cargo clippy -p alkane-gui --no-deps --release --bins --offline -- -D warnings
@@ -65,20 +67,22 @@ 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_
# Capture the bench stdout for the weighted-average delta badge (round 19
# #1) while keeping the step a hard gate: pipefail preserves cargo's exit
# code (each bench asserts its own absolute ceiling) even through tee.
set -o pipefail
cargo test -p alkane-gui --release --offline -- --ignored --nocapture bench_ \
| tee bench-current.txt
- name: Headless UI self-test
if: steps.ver.outputs.release == 'true'
@@ -98,6 +102,40 @@ jobs:
echo "cargo-audit not installed on this runner; skipping"
fi
# Merge coverage from the unit tests AND the headless self-test (ci/coverage.sh)
# so the committed badge reflects real coverage, not the tests-only number a
# plain `cargo llvm-cov` reports. Best-effort: cargo-llvm-cov is fetched as a
# prebuilt binary because the vendored .cargo/config blocks `cargo install`,
# and the instrumented rebuild is slow, so a failure here never blocks a
# release. Feeds steps.cov.outputs.pct to the badge refresh below. xvfb is
# already installed by the self-test step above.
- name: Coverage (best-effort)
id: cov
if: steps.ver.outputs.release == 'true'
continue-on-error: true
run: |
rustup component add llvm-tools-preview >/dev/null 2>&1 || true
if ! command -v cargo-llvm-cov >/dev/null 2>&1; then
V=0.8.7
URL="https://github.com/taiki-e/cargo-llvm-cov/releases/download/v${V}/cargo-llvm-cov-x86_64-unknown-linux-gnu.tar.gz"
DEST="${CARGO_HOME:-$HOME/.cargo}/bin"
mkdir -p "$DEST"
curl -fsSL "$URL" | tar -xz -C "$DEST" && export PATH="$DEST:$PATH" \
|| echo "cargo-llvm-cov download failed"
fi
if command -v cargo-llvm-cov >/dev/null 2>&1; then
PCT=$(bash ci/coverage.sh --summary-only 2>/dev/null \
| awk '/^TOTAL/{gsub(/%/,"",$10); print $10}')
if [ -n "$PCT" ]; then
echo "pct=${PCT}" >> "$GITHUB_OUTPUT"
echo "line coverage (tests + self-test): ${PCT}%"
else
echo "coverage report produced no TOTAL line; badge left as committed"
fi
else
echo "cargo-llvm-cov unavailable; coverage badge left as committed"
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
@@ -108,10 +146,20 @@ jobs:
env:
TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
export WX_RS_WXCONFIG="$WX_PREFIX/bin/wx-config"
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"
# Update the coverage badge only when the coverage step produced a number;
# otherwise leave the committed coverage.svg untouched.
COV="${{ steps.cov.outputs.pct }}"
COV_ARG=""
[ -n "$COV" ] && COV_ARG="--coverage $COV"
# Weighted-average microbench delta vs the previous release (round 19 #1).
# bench-badge.py also rewrites badges/bench-baseline.json, which is
# committed below with the SVGs (badges/* does not trip a release bump).
BENCH_DELTA=$(python3 ci/bench-badge.py --current bench-current.txt \
--baseline badges/bench-baseline.json 2>/dev/null || echo NEW)
python3 ci/gen-badges.py --tests "${PASS:-0}" $COV_ARG \
--bench-delta "${BENCH_DELTA:-NEW}" --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"
@@ -119,8 +167,8 @@ jobs:
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"
git -c http.extraheader="Authorization: token ${TOKEN}" \
push "${HOST}/${GITHUB_REPOSITORY}.git" "HEAD:main" || echo "badge push skipped"
else
echo "badges unchanged"
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
View File
-201
View File
@@ -1,201 +0,0 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but not
limited to compiled object code, generated documentation, and
conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or Derivative
Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and do
not modify the License. You may add Your own attribution notices
within Derivative Works that You distribute, alongside or as an
addendum to the NOTICE text from the Work, provided that such
additional attribution notices cannot be construed as modifying
the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright 2026 Blueflare
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
+2 -2
View File
@@ -79,6 +79,7 @@ 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
@@ -112,5 +113,4 @@ Encoded in code, from alkane-sdk `docs/install-methods.md`:
## License
Dual-licensed under either of [Apache-2.0](LICENSE-APACHE) or
[MIT](LICENSE-MIT) at your option.
Licensed under the [MIT license](LICENSE).
+11
View File
@@ -0,0 +1,11 @@
{
"bench_parse_line_near_max_addrs": 2909519.0,
"bench_parse_targets_many_ranges_near_cap": 231595485.0,
"bench_render_cells": 23139168.0,
"bench_sort_by_each_column": 4481425.0,
"bench_targets_to_cidrs_large_range": 3358390.0,
"bench_upsert_cold_start_population": 32181374.0,
"bench_view_pipeline": 1038940.0,
"bench_view_pipeline_default_sort": 1858357.0,
"bench_view_pipeline_with_filter": 1450722.0
}
+7 -7
View File
@@ -1,19 +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>
<svg xmlns="http://www.w3.org/2000/svg" width="147.5" height="20" role="img" aria-label="bench: +21.6% vs prev">
<title>bench: +21.6% vs prev</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>
<clipPath id="r"><rect width="147.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="161.5" height="20" fill="#007ec6"/>
<rect width="206.0" height="20" fill="url(#s)"/>
<rect x="44.5" width="103.0" height="20" fill="#fe7d37"/>
<rect width="147.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">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>
<text x="96.0" y="15" fill="#010101" fill-opacity=".3">+21.6% vs prev</text>
<text x="96.0" y="14">+21.6% vs prev</text>
</g>
</svg>

Before

Width:  |  Height:  |  Size: 993 B

After

Width:  |  Height:  |  Size: 955 B

+5 -5
View File
@@ -1,5 +1,5 @@
<svg xmlns="http://www.w3.org/2000/svg" width="95.5" height="20" role="img" aria-label="coverage: 36%">
<title>coverage: 36%</title>
<svg xmlns="http://www.w3.org/2000/svg" width="95.5" height="20" role="img" aria-label="coverage: 44%">
<title>coverage: 44%</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
@@ -7,13 +7,13 @@
<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="#fe7d37"/>
<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">36%</text>
<text x="79.8" y="14">36%</text>
<text x="79.8" y="15" fill="#010101" fill-opacity=".3">44%</text>
<text x="79.8" y="14">44%</text>
</g>
</svg>

Before

Width:  |  Height:  |  Size: 919 B

After

Width:  |  Height:  |  Size: 919 B

+7 -7
View File
@@ -1,19 +1,19 @@
<svg xmlns="http://www.w3.org/2000/svg" width="180.0" height="20" role="img" aria-label="license: MIT OR Apache-2.0">
<title>license: MIT OR Apache-2.0</title>
<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="180.0" height="20" rx="3" fill="#fff"/></clipPath>
<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="122.5" height="20" fill="#007ec6"/>
<rect width="180.0" height="20" fill="url(#s)"/>
<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="118.8" y="15" fill="#010101" fill-opacity=".3">MIT OR Apache-2.0</text>
<text x="118.8" y="14">MIT OR Apache-2.0</text>
<text x="73.2" y="15" fill="#010101" fill-opacity=".3">MIT</text>
<text x="73.2" y="14">MIT</text>
</g>
</svg>

Before

Width:  |  Height:  |  Size: 977 B

After

Width:  |  Height:  |  Size: 915 B

+4 -4
View File
@@ -1,5 +1,5 @@
<svg xmlns="http://www.w3.org/2000/svg" width="141.0" height="20" role="img" aria-label="lines of code: 12.5k">
<title>lines of code: 12.5k</title>
<svg xmlns="http://www.w3.org/2000/svg" width="141.0" height="20" role="img" aria-label="lines of code: 13.5k">
<title>lines of code: 13.5k</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
@@ -13,7 +13,7 @@
<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">12.5k</text>
<text x="118.8" y="14">12.5k</text>
<text x="118.8" y="15" fill="#010101" fill-opacity=".3">13.5k</text>
<text x="118.8" y="14">13.5k</text>
</g>
</svg>

Before

Width:  |  Height:  |  Size: 952 B

After

Width:  |  Height:  |  Size: 952 B

+4 -4
View File
@@ -1,5 +1,5 @@
<svg xmlns="http://www.w3.org/2000/svg" width="121.5" height="20" role="img" aria-label="tests: 94 passing">
<title>tests: 94 passing</title>
<svg xmlns="http://www.w3.org/2000/svg" width="121.5" height="20" role="img" aria-label="tests: 93 passing">
<title>tests: 93 passing</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
@@ -13,7 +13,7 @@
<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">94 passing</text>
<text x="83.0" y="14">94 passing</text>
<text x="83.0" y="15" fill="#010101" fill-opacity=".3">93 passing</text>
<text x="83.0" y="14">93 passing</text>
</g>
</svg>

Before

Width:  |  Height:  |  Size: 935 B

After

Width:  |  Height:  |  Size: 935 B

+98
View File
@@ -0,0 +1,98 @@
#!/usr/bin/env python3
"""Compute the weighted-average microbenchmark delta versus the previous release.
Reads the captured stdout of `cargo test ... --ignored --nocapture bench_` (whose
timings are Rust `Duration` Debug strings: "12.3ms", "512us"/"512µs", "840ns",
"1.2s"), compares each bench to a committed baseline of the previous release's
numbers, and prints the time-weighted average change as a signed percentage:
(sum(current) / sum(baseline) - 1) * 100 over benches present in both
Weighting by duration means the slow benches dominate, so the number tracks
overall wall-time change rather than giving a tiny bench equal say. Then the
baseline is rewritten with the current numbers, so the next release compares
against this one ("the previous commit").
Usage:
bench-badge.py --current bench-current.txt --baseline badges/bench-baseline.json
Prints the delta as a plain number (e.g. "-3.2", or "NEW" when there is no
usable baseline) to stdout. The baseline JSON lives under badges/ so committing
it back does not trip compute-version.sh's path-based release bump.
"""
import argparse
import json
import os
import re
import sys
# A Duration Debug token: a number immediately followed by a time unit, with the
# multi-char units listed before the bare "s" so alternation prefers them. The
# trailing (?![a-zA-Z]) stops "s" in words like "rows"/"cidrs" from matching.
_DUR = re.compile(r"([0-9]+(?:\.[0-9]+)?)\s*(ns|µs|us|ms|s)(?![a-zA-Z])")
_UNIT_NS = {"ns": 1.0, "us": 1e3, "µs": 1e3, "ms": 1e6, "s": 1e9}
_NAME = re.compile(r"^(bench_[A-Za-z0-9_]+)\s*:")
def parse_bench(text: str) -> dict:
"""Map each bench name to its timing in nanoseconds (the last Duration on the
line, since every bench prints its timing last)."""
out = {}
for line in text.splitlines():
m = _NAME.match(line.strip())
if not m:
continue
durs = _DUR.findall(line)
if not durs:
continue
val, unit = durs[-1]
out[m.group(1)] = float(val) * _UNIT_NS[unit]
return out
def main() -> int:
ap = argparse.ArgumentParser()
ap.add_argument("--current", required=True, help="captured bench stdout")
ap.add_argument("--baseline", required=True, help="baseline JSON (read + rewrite)")
ap.add_argument("--no-write", action="store_true", help="do not update the baseline")
args = ap.parse_args()
try:
with open(args.current, encoding="utf-8") as fh:
current = parse_bench(fh.read())
except OSError as e:
print(f"bench-badge: cannot read current results: {e}", file=sys.stderr)
print("NEW")
return 0
if not current:
print("bench-badge: no bench lines parsed from current results", file=sys.stderr)
print("NEW")
return 0
baseline = {}
try:
with open(args.baseline, encoding="utf-8") as fh:
baseline = {k: float(v) for k, v in json.load(fh).items()}
except (OSError, ValueError):
baseline = {}
common = [k for k in current if k in baseline and baseline[k] > 0]
if common:
sum_new = sum(current[k] for k in common)
sum_old = sum(baseline[k] for k in common)
delta = (sum_new / sum_old - 1.0) * 100.0 if sum_old > 0 else 0.0
print(f"{delta:.1f}")
else:
print("NEW")
if not args.no_write:
os.makedirs(os.path.dirname(args.baseline) or ".", exist_ok=True)
with open(args.baseline, "w", encoding="utf-8") as fh:
json.dump({k: round(v, 1) for k, v in sorted(current.items())}, fh, indent=2)
fh.write("\n")
return 0
if __name__ == "__main__":
sys.exit(main())
+4 -3
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.
#
+37
View File
@@ -0,0 +1,37 @@
#!/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}"
# The dependency tree is fully vendored, so the instrumented builds run offline by
# default; override with CARGO_LLVM_COV_FLAGS if you need something else.
read -ra CARGO_FLAGS <<<"${CARGO_LLVM_COV_FLAGS:---offline}"
# 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 "${CARGO_FLAGS[@]}" -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 "${CARGO_FLAGS[@]}" --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)/' "$@"
+31 -1
View File
@@ -108,6 +108,18 @@ def loc_color(n: int) -> str:
return "blue"
def bench_color(delta_pct: float) -> str:
# Negative delta = faster than the previous release. A +/-2% dead band absorbs
# the run-to-run jitter of microbenchmarks on a shared CI runner.
if delta_pct <= -2.0:
return "brightgreen"
if delta_pct < 2.0:
return "blue"
if delta_pct < 10.0:
return "yellow"
return "orange"
def cov_color(pct: float) -> str:
if pct >= 80:
return "brightgreen"
@@ -133,6 +145,10 @@ def main() -> int:
ap.add_argument("--tests", type=int, default=None)
ap.add_argument("--coverage", type=float, default=None)
ap.add_argument("--bench", default=None)
# Weighted-average microbench delta vs the previous release, as a signed
# percentage string (e.g. "-3.2"), or "NEW"/"" when there is no baseline yet
# (round 19 #1). Takes precedence over --bench for the bench badge.
ap.add_argument("--bench-delta", default=None)
ap.add_argument("--clippy", default="clean")
args = ap.parse_args()
@@ -156,7 +172,21 @@ def main() -> int:
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:
# Bench badge: prefer the weighted-average delta vs the previous release; fall
# back to the static label (first run, or when the delta could not be computed).
delta = None
if args.bench_delta not in (None, "", "NEW"):
try:
delta = float(args.bench_delta)
except ValueError:
delta = None
if delta is not None:
# Negative = faster than the previous release (good).
msg = f"{'+' if delta > 0 else ''}{delta:.1f}% vs prev"
write("bench", "bench", msg, bench_color(delta))
elif args.bench_delta == "NEW":
write("bench", "bench", "baseline set", "blue")
elif args.bench is not None:
write("bench", "bench", args.bench, "blue")
return 0
+46 -13
View File
@@ -61,7 +61,20 @@ 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 mut cmd = Command::new("curl");
@@ -227,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 msg = v.get("Msg")?;
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.
@@ -261,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)]
+6 -1
View File
@@ -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)");
}
+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);
+73 -14
View File
@@ -9,13 +9,43 @@
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.
/// A compact UTC timestamp "YYYYMMDD-HHMMSS" for a default export filename
/// (round 19 #5). UTC keeps this dependency-free (no chrono) and unambiguous.
pub fn timestamp_utc() -> String {
let secs = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
let sod = secs % 86_400;
let (h, mi, s) = (sod / 3600, (sod % 3600) / 60, sod % 60);
// Civil date from days since 1970-01-01 (Howard Hinnant's civil_from_days).
let z = (secs / 86_400) as i64 + 719_468;
let era = if z >= 0 { z } else { z - 146_096 } / 146_097;
let doe = z - era * 146_097; // [0, 146096]
let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365; // [0, 399]
let doy = doe - (365 * yoe + yoe / 4 - yoe / 100); // [0, 365]
let mp = (5 * doy + 2) / 153; // [0, 11]
let d = doy - (153 * mp + 2) / 5 + 1; // [1, 31]
let m = if mp < 10 { mp + 3 } else { mp - 9 }; // [1, 12]
let y = yoe + era * 400 + i64::from(m <= 2);
format!("{y:04}{m:02}{d:02}-{h:02}{mi:02}{s:02}")
}
/// 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
}
}
@@ -97,14 +127,42 @@ fn scalar_columns() -> Vec<Col> {
]
}
/// Build the full CSV for `rows`. Empty rows still emit a header line.
pub fn rows_to_csv(rows: &[MinerRow]) -> String {
let cols = scalar_columns();
// Widest variable-length fields across the set.
let max_board_temps = rows.iter().map(|r| r.board_temps.len()).max().unwrap_or(0);
let max_fans = rows.iter().map(|r| r.fan_rpms.len()).max().unwrap_or(0);
let max_boards = rows.iter().map(|r| r.board_status.len()).max().unwrap_or(0);
let max_pools = rows.iter().map(|r| r.pools.len()).max().unwrap_or(0);
// Group keys for the four variable-length field families (each expands to
// per-index columns). Shown as single checkboxes in the export picker (round 19 #6).
pub const GROUP_BOARD_TEMPS: &str = "board temps";
pub const GROUP_FANS: &str = "fan rpms";
pub const GROUP_BOARD_STATUS: &str = "board status";
pub const GROUP_POOLS: &str = "pools";
/// Every selectable export field, in output order: each scalar column header,
/// then the four variable-length group keys.
pub fn export_field_names() -> Vec<String> {
let mut v: Vec<String> = scalar_columns().iter().map(|(h, _)| (*h).to_string()).collect();
v.push(GROUP_BOARD_TEMPS.to_string());
v.push(GROUP_FANS.to_string());
v.push(GROUP_BOARD_STATUS.to_string());
v.push(GROUP_POOLS.to_string());
v
}
/// Build the CSV for `rows` including only the selected fields (scalar column
/// headers and/or the group keys above), in the fixed output order (round 19 #6).
/// Empty rows still emit a header line.
pub fn rows_to_csv_selected(
rows: &[MinerRow],
selected: &std::collections::HashSet<String>,
) -> String {
let cols: Vec<Col> =
scalar_columns().into_iter().filter(|(h, _)| selected.contains(*h)).collect();
// A group's columns appear only when it is selected; an unselected group's
// width stays 0, so the header/value loops below emit nothing for it.
let width = |want: bool, f: &dyn Fn(&MinerRow) -> usize| -> usize {
if want { rows.iter().map(f).max().unwrap_or(0) } else { 0 }
};
let max_board_temps = width(selected.contains(GROUP_BOARD_TEMPS), &|r| r.board_temps.len());
let max_fans = width(selected.contains(GROUP_FANS), &|r| r.fan_rpms.len());
let max_boards = width(selected.contains(GROUP_BOARD_STATUS), &|r| r.board_status.len());
let max_pools = width(selected.contains(GROUP_POOLS), &|r| r.pools.len());
// Header.
let mut headers: Vec<String> = cols.iter().map(|(h, _)| (*h).to_string()).collect();
@@ -166,7 +224,8 @@ mod tests {
},
MinerRow { ip: "10.0.0.2".into(), model: "M30S".into(), ..Default::default() },
];
let csv = rows_to_csv(&rows);
let all: std::collections::HashSet<String> = export_field_names().into_iter().collect();
let csv = rows_to_csv_selected(&rows, &all);
let lines: Vec<&str> = csv.lines().collect();
assert_eq!(lines.len(), 3, "header + 2 rows");
assert!(lines[0].starts_with("ip,model,brand,"));
+10 -7
View File
@@ -92,6 +92,11 @@ impl Board {
"10.255.1.166" => vec![Ok, Ok, Missing],
_ => vec![Ok, Ok, Ok],
}
} else if self.paused {
// A paused miner's boards are physically present but idle (asic-rs
// reports active=false -> Fault), so the Health column shows them blue
// rather than red (round 19 #19); the offline demo mirrors that.
vec![Fault, Fault, Fault]
} else {
vec![]
};
@@ -110,6 +115,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,
@@ -192,13 +199,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()),
+48 -229
View File
@@ -1,58 +1,44 @@
//! Fetch a miner's log over its firmware API and regex-scan it for useful
//! signals (round 12 #12). This is the "logs through API" path the operator
//! asked for: where a firmware exposes its log we can read board/PIC lines and
//! other metrics without SSH.
//! Fetch a miner's log for the "View log (API)" viewer (round 12 #12, reworked
//! round 19 #11-16).
//!
//! Per firmware:
//! - VNish (aftermarket Antminer): POST /api/v1/unlock to get a bearer token,
//! then GET /api/v1/logs/miner -- the full miner log (PSU init, per-chain
//! chip detection, tuning, errors).
//! - Stock Antminer: GET /cgi-bin/log.cgi behind digest auth (older models
//! such as the Z15 do not serve it -> reported as unavailable).
//! - WhatsMiner: the btminer log is not exposed on :4028, but get_error_code
//! (unauthenticated) returns the active fault codes, which we format as the
//! log view.
//! The log is fetched through asic-rs's per-backend `read_logs()` API, which
//! knows each firmware's real transport (Antminer/Z15 + BixBit stock web,
//! Braiins gRPC/journal, VNish and ePIC HTTP, ...). This replaced the GUI's
//! narrow three-way curl fetch, whose stock `/cgi-bin/log.cgi` `else` branch
//! failed on every firmware that does not serve that CGI (Braiins, LuxOS, Z15,
//! BixBit).
//!
//! We shell out to `curl` (already a dependency of the access probe) so the
//! offline/vendored build gains no new crate, and cap the fetched text so a huge
//! log never bloats the viewer.
//! WhatsMiner is the exception: its btminer log is not exposed over the API, and
//! asic-rs has no `read_logs` for it, so the viewer falls back to the active
//! fault codes (get_error_code on :4028, unauthenticated). LuxOS likewise has no
//! asic-rs log API and reports the log as unavailable.
use std::process::Command;
use std::time::Duration;
/// Cap on the log text we keep for display (bytes); the regex summary is still
/// computed over everything fetched.
/// Cap on the log text we keep for display (bytes); a miner's freshest lines are
/// at the tail, so we keep the tail.
const MAX_LOG_BYTES: usize = 256 * 1024;
/// A fetched log plus the signals a regex pass pulled out of it.
/// A fetched log for the viewer.
pub struct LogScan {
/// The (possibly tail-trimmed) log text for the viewer.
/// The (possibly tail-trimmed) log text.
pub text: String,
/// One-line-per-finding summary shown above the log.
pub summary: Vec<String>,
}
/// Fetch and scan one miner's log. `brand` is the make ("Antminer"/"Whatsminer"),
/// `firmware` the family ("VNish"/"Stock"/...). `vnish_pass`/`wm` creds are used
/// where that firmware needs auth. Returns `Err` only when no log could be read.
pub fn scan_log(
ip: &str,
brand: &str,
firmware: &str,
vnish_pass: &str,
antminer_user: &str,
antminer_pass: &str,
) -> Result<LogScan, String> {
let raw = if firmware.eq_ignore_ascii_case("vnish") {
fetch_vnish_log(ip, vnish_pass)?
} else if brand.eq_ignore_ascii_case("whatsminer") {
fetch_whatsminer_errors(ip)?
} else {
// Stock / other Antminer-family web firmware.
fetch_antminer_log(ip, antminer_user, antminer_pass)?
};
let summary = summarize_log(&raw);
Ok(LogScan { text: tail(&raw, MAX_LOG_BYTES), summary })
/// Fetch one miner's log. `brand` is the make ("Antminer"/"Whatsminer"/...);
/// `timeout_secs` is the per-miner identification timeout. Returns `Err` only
/// when no log could be read.
pub fn scan_log(ip: &str, brand: &str, timeout_secs: u64) -> Result<LogScan, String> {
// WhatsMiner's real log is not exposed over its API and asic-rs has no
// read_logs for it, so show the active fault codes instead of failing.
if brand.eq_ignore_ascii_case("whatsminer") {
let resp = crate::access_probe::whatsminer_get_error_code(ip)
.ok_or_else(|| "WhatsMiner did not answer get_error_code on :4028".to_string())?;
return Ok(LogScan { text: tail(&resp, MAX_LOG_BYTES) });
}
let text = crate::scan::fetch_log(ip, timeout_secs)?;
if text.trim().is_empty() {
return Err("the miner returned an empty log".to_string());
}
Ok(LogScan { text: tail(&text, MAX_LOG_BYTES) })
}
/// Keep the last `max` bytes of `s` (a log's tail is the freshest), on a line
@@ -61,197 +47,30 @@ 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
let start = s[start..]
.find('\n')
.map(|i| start + i + 1)
.unwrap_or(start);
// 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).unwrap_or(start);
format!("[... earlier log trimmed ...]\n{}", &s[start..])
}
/// Regex-free scan for the high-value signals in a miner log: PIC / hashboard
/// firmware lines, per-chain chip detection, and the most recent errors.
fn summarize_log(log: &str) -> Vec<String> {
let mut out = Vec::new();
let lc_has = |line: &str, needle: &str| line.to_ascii_lowercase().contains(needle);
// PIC / hashboard-controller status from the log. Aftermarket firmwares state
// it explicitly ("no-PIC miner"); stock boot logs print a PIC version. This
// is the log-regex PIC scan the operator asked for (round 12 #12).
let pic_lines: Vec<&str> = log.lines().filter(|l| lc_has(l, "pic")).collect();
if pic_lines.iter().any(|l| lc_has(l, "no-pic") || lc_has(l, "no pic")) {
out.push("PIC: not present (log reports a no-PIC miner)".to_string());
} else if let Some(l) = pic_lines
.iter()
.find(|l| lc_has(l, "version") || lc_has(l, "fw") || lc_has(l, "found"))
{
out.push(format!("PIC: present -- {}", l.trim()));
} else if !pic_lines.is_empty() {
out.push(format!("PIC: {} log line(s) mention PIC", pic_lines.len()));
for l in pic_lines.iter().take(3) {
out.push(format!(" {}", l.trim()));
}
} else {
out.push("PIC: no PIC lines in the log".to_string());
}
// Latest per-chain chip-detection line (the most recent board bring-up).
if let Some(l) = log.lines().rev().find(|l| lc_has(l, "chips detected")) {
out.push(format!("Chains: {}", l.trim()));
}
// Recent errors (log history, beyond asic-rs's current-message snapshot).
// Skip the get_error_code header line (it contains "error" but is not one).
let errors: Vec<&str> = log
.lines()
.rev()
.filter(|l| (lc_has(l, "error") || lc_has(l, "fail")) && !lc_has(l, "get_error_code"))
.take(3)
.collect();
if errors.is_empty() {
out.push("Errors: none in the log".to_string());
} else {
out.push(format!("Errors: {} recent", errors.len()));
for l in errors {
out.push(format!(" {}", l.trim()));
}
}
out
}
/// 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"),
])?;
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"),
])?;
if log.trim().is_empty() {
return Err("VNish returned an empty log".to_string());
}
Ok(log)
}
/// 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"),
])?;
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());
}
Ok(body)
}
/// WhatsMiner: format the active error codes (get_error_code, unauthenticated).
fn fetch_whatsminer_errors(ip: &str) -> Result<String, String> {
let resp = crate::access_probe::whatsminer_get_error_code(ip)
.ok_or_else(|| "WhatsMiner did not answer get_error_code on :4028".to_string())?;
Ok(resp)
}
/// 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;
let mut cmd = Command::new("curl");
cmd.args(args);
cmd.stdout(std::process::Stdio::piped());
cmd.stderr(std::process::Stdio::null());
let mut child = cmd.spawn().map_err(|e| format!("spawn curl: {e}"))?;
let mut stdout = child.stdout.take().ok_or("no curl stdout")?;
let reader = std::thread::spawn(move || {
let mut buf = Vec::new();
let _ = stdout.read_to_end(&mut buf);
buf
});
let timeout = Duration::from_secs(20);
let start = std::time::Instant::now();
let mut timed_out = false;
loop {
match child.try_wait().map_err(|e| e.to_string())? {
Some(_) => break,
None => {
if start.elapsed() >= timeout {
let _ = child.kill();
timed_out = true;
break;
}
std::thread::sleep(Duration::from_millis(50));
}
}
}
let buf = reader.join().unwrap_or_default();
if timed_out && buf.is_empty() {
return Err("log fetch timed out".into());
}
Ok(String::from_utf8_lossy(&buf).into_owned())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn summarize_finds_pic_chains_and_errors() {
let log = "\
[t] INFO: Initializing PSU
[t] INFO: chain#1 - 126 chips detected
[t] INFO: check PIC on chain 1: version 0x03
[t] ERROR: Failed load miner config
[t] INFO: chain#2 - 126 chips detected";
let s = summarize_log(log);
assert!(s.iter().any(|l| l.contains("PIC: present")), "PIC present: {s:?}");
assert!(s.iter().any(|l| l.contains("chips detected")), "chains: {s:?}");
assert!(s.iter().any(|l| l.contains("Errors: 1")), "errors: {s:?}");
}
#[test]
fn summarize_detects_no_pic_miner() {
let log = "[t] ERROR: This is a no-PIC miner, so all connected chains ...\n[t] INFO: mining";
let s = summarize_log(log);
assert!(s.iter().any(|l| l.contains("PIC: not present")), "{s:?}");
}
#[test]
fn summarize_handles_no_pic_lines() {
let log = "[t] INFO: chain#1 - 126 chips detected\n[t] INFO: mining";
let s = summarize_log(log);
assert!(s.iter().any(|l| l.contains("no PIC lines")), "{s:?}");
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]
+6 -16
View File
@@ -43,27 +43,17 @@ fn main() {
std::process::exit(0);
}
// Headless log-scan check: `ALKANE_LOG_SCAN="<ip> <brand> <firmware>"` fetches
// the miner's log over its firmware API and prints the regex summary (round
// 12 #12), so the VNish/Antminer/WhatsMiner log paths can be verified without
// the GUI.
// Headless log-scan check: `ALKANE_LOG_SCAN="<ip> <brand>"` fetches the miner's
// log through asic-rs's per-backend read_logs() (round 19 #11-16), so the log
// paths can be verified without the GUI. WhatsMiner falls back to fault codes.
if let Some(spec) = std::env::var_os("ALKANE_LOG_SCAN") {
let spec = spec.to_string_lossy();
let mut it = spec.split_whitespace();
let ip = it.next().unwrap_or("");
let brand = it.next().unwrap_or("");
let firmware = it.next().unwrap_or("");
let (au, ap) = credentials::load_credentials().unwrap_or_else(|| ("root".into(), "root".into()));
let vp = credentials::firmware_default_for("VNish").1;
let vp = if vp.is_empty() { "admin".to_string() } else { vp };
match log_scan::scan_log(ip, brand, firmware, &vp, &au, &ap) {
Ok(s) => {
println!("LOGSCAN {ip} ({brand}/{firmware}): {} log bytes", s.text.len());
for line in &s.summary {
println!(" {line}");
}
}
Err(e) => println!("LOGSCAN {ip} ({brand}/{firmware}): ERROR {e}"),
match log_scan::scan_log(ip, brand, scan::load_scan_timeout()) {
Ok(s) => println!("LOGSCAN {ip} ({brand}): {} log bytes", s.text.len()),
Err(e) => println!("LOGSCAN {ip} ({brand}): ERROR {e}"),
}
std::process::exit(0);
}
+374 -70
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".
@@ -59,8 +66,8 @@ pub fn format_si(value_base: f64, unit: &str) -> String {
}
/// Like `format_si` but for a cooling-fan RPM reading: no unit/space suffix,
/// and "-" (rather than "0") for an absent/non-positive reading, since a fan
/// column packs several of these per cell (see `Column::Cooling`).
/// and "-" (rather than "0") for an absent/non-positive reading (see the per-fan
/// `Column::Fan1`..`Fan4` columns).
pub fn format_fan_rpm(rpm: f64) -> String {
match si_mantissa_and_prefix(rpm) {
Some((num, prefix)) => format!("{num}{prefix}"),
@@ -99,6 +106,36 @@ pub fn actual_expected_ratio(actual: f64, expected: f64) -> Option<f64> {
if expected > 0.0 { Some(actual / expected) } else { None }
}
/// Mean of `vals`, or `default` when empty -- a scalar sort key for the
/// slash-joined per-board columns (round 19 #10).
fn avg_or(vals: &[f64], default: f64) -> f64 {
if vals.is_empty() {
default
} else {
vals.iter().sum::<f64>() / vals.len() as f64
}
}
/// Mean of the POSITIVE entries in `vals`, or `default` when none are positive.
/// Board voltage/frequency store 0.0 for a board that reports no value (rendered
/// "-"), so a plain average would drag the sort/filter key toward zero and
/// mis-rank the miner (round 19 review); this skips those placeholders.
fn avg_positive(vals: &[f64], default: f64) -> f64 {
let (sum, n) = vals.iter().filter(|&&v| v > 0.0).fold((0.0, 0usize), |(s, n), &v| (s + v, n + 1));
if n == 0 { default } else { sum / n as f64 }
}
/// Render a per-board vector as one slash-joined cell (blank when empty), each
/// value formatted by `f` -- the shared shape of the Board HR/V/freq columns
/// (round 19 #10).
fn join_board(vals: &[f64], f: impl Fn(f64) -> String) -> String {
if vals.is_empty() {
String::new()
} else {
vals.iter().map(|&v| f(v)).collect::<Vec<_>>().join(" / ")
}
}
/// Render the combined Hashrate cell "actual/expected" (no spaces around the
/// slash, prefix-only unit): blank when neither is known, the bare actual when
/// only it is known, "-/<expected>" when only the expected is known, and
@@ -436,6 +473,11 @@ pub struct MinerRow {
pub board_code: String,
/// Mining algorithm (e.g. "SHA256", "Scrypt", "Equihash"), from asic-rs.
pub algorithm: String,
/// ASIC chip type/model (e.g. "BM1370") and hashboard model/part
/// (e.g. "A3HB70601"), where the firmware reports them (round 19 #10:
/// WhatsMiner, Braiins, ePIC; not exposed by Antminer/LuxOS). Empty = unknown.
pub chip_type: String,
pub hashboard_model: String,
/// Whether the hashboards carry a PIC MCU. asic-rs does not report this over
/// the network, so it is a best-effort inference (model-string heuristic):
/// `None` = unknown, `Some(true)` = PIC, `Some(false)` = noPIC. True
@@ -454,6 +496,12 @@ pub struct MinerRow {
pub faults: Vec<Fault>,
// performance
pub hashrate_ths: f64,
/// Rolling average hashrate windows in TH/s (round 19 #10, T2): 1m/5m/15m/24h.
/// 0.0 means the firmware does not report that window.
pub hashrate_1m_ths: f64,
pub hashrate_5m_ths: f64,
pub hashrate_15m_ths: f64,
pub hashrate_24h_ths: f64,
pub expected_ths: f64,
/// Per-hashboard hashrate in TH/s, index-aligned with the hashboards (index 0
/// = board 1). Drives the per-board Health tooltip (round 17 R2). Empty when
@@ -479,6 +527,9 @@ pub struct MinerRow {
/// PSU identity + rated voltage envelope, when the firmware reports it (round
/// 17 R5 / G15; ePIC today). `psu_version` is blank when unknown.
pub psu_version: String,
/// PSU serial number where the firmware reports it (round 19 #10: Braiins,
/// WhatsMiner V3, VNish). Empty = unknown.
pub psu_serial: String,
pub psu_voltage_min_v: Option<f64>,
pub psu_voltage_max_v: Option<f64>,
/// Current structured tuning target, rendered for display (e.g. "2832 W",
@@ -512,9 +563,16 @@ pub struct MinerRow {
/// (round 11 #17).
pub env_temp_c: f64,
pub outlet_temp_c: f64,
/// Board temperature safety thresholds in Celsius (round 19 #10, T3); `None`
/// when the firmware does not report them (ePIC today).
pub temp_critical_c: Option<f64>,
pub temp_shutdown_c: Option<f64>,
/// Individual cooling-fan RPMs (empty if unknown). PSU fan is tracked
/// separately below since it is not part of the cooling-fan set.
pub fan_rpms: Vec<f64>,
/// Miner-level fan duty cycle as a percentage (round 19 #10, T3); `None` when
/// the firmware does not report it (no firmware exposes a maximum RPM).
pub fan_speed_percent: Option<f64>,
pub psu_fan_rpm: f64,
pub fan_count: Option<u32>,
pub expected_fans: Option<u32>,
@@ -535,6 +593,17 @@ pub struct MinerRow {
// shares
pub best_share: Option<f64>,
pub session_best_share: Option<f64>,
/// Accepted / rejected share counts, summed across all configured pools
/// (round 19 #10). `None` when the firmware reports neither.
pub accepted_shares: Option<u64>,
pub rejected_shares: Option<u64>,
/// Cumulative share statistics from the miner summary (round 19 #10, T2):
/// difficulty-weighted accepted / rejected work, raw stale count, and blocks
/// found. `None` where the firmware does not report the value.
pub difficulty_accepted: Option<f64>,
pub difficulty_rejected: Option<f64>,
pub stale_shares: Option<u64>,
pub found_blocks: Option<u64>,
// state
pub uptime_secs: u64,
pub light_flashing: Option<bool>,
@@ -682,7 +751,13 @@ impl MinerRow {
if (0..base.len()).any(board_faulted) {
for (i, h) in base.iter_mut().enumerate() {
if board_faulted(i) {
*h = CompHealth::Down;
// 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
}
@@ -857,6 +932,39 @@ impl MinerRow {
}
}
/// Rejected-share percentage of all submitted shares (round 19 #10), or
/// `None` when the firmware reports neither count.
pub fn reject_ratio(&self) -> Option<f64> {
match (self.accepted_shares, self.rejected_shares) {
(Some(a), Some(r)) => {
let total = a.saturating_add(r);
Some(if total > 0 { r as f64 / total as f64 * 100.0 } else { 0.0 })
}
_ => None,
}
}
/// Efficiency as (value, unit) for display, computed per algorithm (round 19
/// #9/#23). asic-rs stores efficiency as watts-per-TH for EVERY algorithm,
/// which is meaningless for Equihash (whose rate is really Sol/s reinterpreted
/// through the base H unit), so recompute J-per-thousand-Sol there from the
/// real Sol/s count. SHA256/Scrypt families reuse asic-rs's J/TH value.
/// `None` when power or hashrate is unknown, so the cell stays blank rather
/// than showing a garbage or zero figure.
pub fn efficiency_display(&self) -> Option<(f64, &'static str)> {
if self.algorithm.eq_ignore_ascii_case("equihash") {
if self.power_w <= 0.0 || self.hashrate_ths <= 0.0 {
return None;
}
let sol_per_s = self.hashrate_ths * 1e12;
Some((self.power_w / sol_per_s * 1000.0, "J/kSol"))
} else if self.efficiency > 0.0 {
Some((self.efficiency, "J/TH"))
} else {
None
}
}
/// 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".
@@ -959,9 +1067,28 @@ pub enum Column {
/// column picker or the display order; it exists only as a `sort` target the
/// Hashrate header cycles into.
HashrateRel,
/// Rolling average hashrate windows (round 19 #10, T2): 1m/5m/15m/24h, each a
/// single TH/s value. Populated per firmware where the API exposes the window
/// (LuxOS and Braiins report all four; WhatsMiner V1 1m/5m/15m, V3 1m/15m;
/// Antminer/ePIC/VNish report none). Auto-hidden when empty across the fleet.
Hashrate1m,
Hashrate5m,
Hashrate15m,
Hashrate24h,
Power,
ChipTemp,
Cooling,
// Per-fan RPM columns (round 19 #8): the old single "Fan (RPM)" column packed
// every fan into one slash-joined cell; these split it into one column per fan
// (fans 1-4), auto-hidden when a miner has fewer. asic-rs exposes no maximum /
// target RPM, so each shows the actual RPM only.
Fan1,
Fan2,
Fan3,
Fan4,
/// Miner-level fan duty cycle % (round 19 #10, T3). No firmware exposes a
/// maximum RPM, so this normalized duty cycle is the fan-load indicator.
/// Populated on ePIC, LuxOS, and Braiins; others leave it empty (auto-hidden).
FanSpeedPercent,
Firmware,
FwVersion,
Worker,
@@ -986,22 +1113,28 @@ pub enum Column {
FluidTemp,
EnvTemp,
OutletTemp,
/// Board temperature safety thresholds (round 19 #10, T3). Populated where the
/// firmware reports them (ePIC today); auto-hidden when empty.
CriticalTemp,
ShutdownTemp,
PsuFan,
/// PSU identity + rated voltage envelope (round 17 R5). Populated where the
/// firmware exposes PSU info (ePIC today).
PsuVersion,
PsuSerial,
PsuVMin,
PsuVMax,
FanCount,
ExpectedFans,
TotalChips,
Hashboards,
Mac,
Hostname,
Serial,
ApiVersion,
Cpu,
BoardCode,
ChipType,
HbType,
Algorithm,
Pic,
Locked,
@@ -1012,6 +1145,25 @@ pub enum Column {
BestShare,
SessionBestShare,
TuningPercent,
// Round 19 #10: more scanned values surfaced as columns.
/// Current tuning target (power or hashrate), e.g. "3200 W" or "100 TH".
Target,
/// Accepted / rejected share counts and the rejection ratio.
Accepted,
Rejected,
RejectRatio,
/// Cumulative share statistics (round 19 #10, T2): difficulty-weighted
/// accepted / rejected work, raw stale count, and blocks found. Populated on
/// the cgminer family (Antminer, LuxOS, WhatsMiner V1/V2); other firmwares
/// leave them empty (auto-hidden).
DiffAccepted,
DiffRejected,
StaleShares,
Blocks,
/// Per-hashboard hashrate / voltage / frequency, slash-joined like Chip temp.
BoardHashrate,
BoardVoltage,
BoardFrequency,
PoolUrl,
Pool1Url,
Pool1Worker,
@@ -1023,17 +1175,27 @@ 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; 70] = [
Column::Ip,
Column::Hashrate,
Column::Hashrate1m,
Column::Hashrate5m,
Column::Hashrate15m,
Column::Hashrate24h,
Column::Health,
Column::Power,
Column::ChipTemp,
Column::Cooling,
Column::Fan1,
Column::Fan2,
Column::Fan3,
Column::Fan4,
Column::FanSpeedPercent,
Column::Firmware,
Column::FwVersion,
Column::Worker,
// Pool account (the part before the dot) before Worker (the rig part after
// it), per round 19 #22.
Column::PoolAccount,
Column::Worker,
Column::Model,
Column::Brand,
Column::Submodel,
@@ -1041,8 +1203,11 @@ pub const ALL_COLUMNS: [Column; 46] = [
Column::FluidTemp,
Column::EnvTemp,
Column::OutletTemp,
Column::CriticalTemp,
Column::ShutdownTemp,
Column::PsuFan,
Column::PsuVersion,
Column::PsuSerial,
Column::PsuVMin,
Column::PsuVMax,
Column::FanCount,
@@ -1054,6 +1219,8 @@ pub const ALL_COLUMNS: [Column; 46] = [
Column::ApiVersion,
Column::Cpu,
Column::BoardCode,
Column::ChipType,
Column::HbType,
Column::Algorithm,
Column::Pic,
Column::Locked,
@@ -1063,6 +1230,17 @@ pub const ALL_COLUMNS: [Column; 46] = [
Column::BestShare,
Column::SessionBestShare,
Column::TuningPercent,
Column::Target,
Column::Accepted,
Column::Rejected,
Column::RejectRatio,
Column::DiffAccepted,
Column::DiffRejected,
Column::StaleShares,
Column::Blocks,
Column::BoardHashrate,
Column::BoardVoltage,
Column::BoardFrequency,
Column::PoolUrl,
Column::Pool1Url,
Column::Pool1Worker,
@@ -1095,9 +1273,28 @@ impl Column {
Column::Ip => "IP",
Column::Hashrate => "Hashrate",
Column::HashrateRel => "Rel. hashrate",
Column::Hashrate1m => "HR 1m",
Column::Hashrate5m => "HR 5m",
Column::Hashrate15m => "HR 15m",
Column::Hashrate24h => "HR 24h",
Column::Power => "Power",
Column::ChipTemp => "Chip temp",
Column::Cooling => "Fan (RPM)",
Column::Fan1 => "Fan 1 (RPM)",
Column::Fan2 => "Fan 2 (RPM)",
Column::Fan3 => "Fan 3 (RPM)",
Column::Fan4 => "Fan 4 (RPM)",
Column::FanSpeedPercent => "Fan %",
Column::Target => "Target",
Column::Accepted => "Accepted",
Column::Rejected => "Rejected",
Column::RejectRatio => "Reject %",
Column::DiffAccepted => "Diff acc",
Column::DiffRejected => "Diff rej",
Column::StaleShares => "Stale",
Column::Blocks => "Blocks",
Column::BoardHashrate => "Board HR",
Column::BoardVoltage => "Board V",
Column::BoardFrequency => "Board freq",
Column::Firmware => "Firmware",
Column::FwVersion => "FW Version",
Column::Worker => "Worker",
@@ -1110,24 +1307,28 @@ impl Column {
Column::HealthFans => "Health (fans)",
Column::HealthBoards => "Health (boards)",
Column::Status => "Status",
Column::Efficiency => "Efficiency (J/TH)",
Column::Efficiency => "Efficiency",
Column::FluidTemp => "Fluid temp",
Column::EnvTemp => "Env temp",
Column::OutletTemp => "Outlet temp",
Column::CriticalTemp => "Critical temp",
Column::ShutdownTemp => "Shutdown temp",
Column::PsuFan => "PSU fan (RPM)",
Column::PsuVersion => "PSU version",
Column::PsuSerial => "PSU serial",
Column::PsuVMin => "PSU Vmin",
Column::PsuVMax => "PSU Vmax",
Column::FanCount => "Fans",
Column::ExpectedFans => "Fans (exp)",
Column::TotalChips => "Chips",
Column::Hashboards => "Boards",
Column::Mac => "MAC",
Column::Hostname => "Hostname",
Column::Serial => "Serial",
Column::ApiVersion => "API ver",
Column::Cpu => "CPU",
Column::BoardCode => "Control Board",
Column::ChipType => "Chip",
Column::HbType => "HB model",
Column::Algorithm => "Algorithm",
Column::Pic => "PIC",
Column::Locked => "Access",
@@ -1153,10 +1354,22 @@ impl Column {
Column::Ip => 130,
Column::Hashrate => 110,
Column::HashrateRel => 110,
Column::Hashrate1m | Column::Hashrate5m | Column::Hashrate15m | Column::Hashrate24h => {
95
}
Column::Power => 90,
Column::ChipTemp | Column::FluidTemp | Column::EnvTemp | Column::OutletTemp => 95,
Column::Cooling | Column::PsuFan => 100,
Column::CriticalTemp | Column::ShutdownTemp => 105,
Column::Fan1 | Column::Fan2 | Column::Fan3 | Column::Fan4 | Column::PsuFan => 90,
Column::FanSpeedPercent => 80,
Column::Target => 110,
Column::Accepted | Column::Rejected => 100,
Column::RejectRatio => 90,
Column::DiffAccepted | Column::DiffRejected => 110,
Column::StaleShares | Column::Blocks => 80,
Column::BoardHashrate | Column::BoardVoltage | Column::BoardFrequency => 130,
Column::PsuVersion => 100,
Column::PsuSerial => 150,
Column::PsuVMin | Column::PsuVMax => 90,
Column::Firmware => 110,
Column::FwVersion => 130,
@@ -1171,12 +1384,14 @@ impl Column {
Column::HealthPower | Column::HealthFans | Column::HealthBoards => 170,
Column::Status => 95,
Column::Efficiency => 120,
Column::FanCount | Column::TotalChips | Column::Hashboards => 70,
Column::FanCount | Column::TotalChips => 70,
Column::ExpectedFans | Column::TuningPercent => 90,
Column::Mac | Column::Hostname | Column::Serial => 150,
Column::ApiVersion | Column::Light => 90,
Column::Cpu => 70,
Column::BoardCode => 70,
Column::ChipType => 90,
Column::HbType => 110,
Column::Algorithm => 100,
Column::Pic => 70,
Column::Locked => 90,
@@ -1197,20 +1412,39 @@ impl Column {
self,
Column::Hashrate
| Column::HashrateRel
| Column::Hashrate1m
| Column::Hashrate5m
| Column::Hashrate15m
| Column::Hashrate24h
| Column::Power
| Column::Efficiency
| Column::ChipTemp
| Column::FluidTemp
| Column::EnvTemp
| Column::OutletTemp
| Column::Cooling
| Column::CriticalTemp
| Column::ShutdownTemp
| Column::Fan1
| Column::Fan2
| Column::Fan3
| Column::Fan4
| Column::FanSpeedPercent
| Column::Accepted
| Column::Rejected
| Column::RejectRatio
| Column::DiffAccepted
| Column::DiffRejected
| Column::StaleShares
| Column::Blocks
| Column::BoardHashrate
| Column::BoardVoltage
| Column::BoardFrequency
| Column::PsuFan
| Column::PsuVMin
| Column::PsuVMax
| Column::FanCount
| Column::ExpectedFans
| Column::TotalChips
| Column::Hashboards
| Column::Uptime
| Column::BestShare
| Column::SessionBestShare
@@ -1225,13 +1459,12 @@ impl Column {
/// here so a filter like "ChipTemp <= 50" cannot match a miner with no
/// temperature reading.
pub fn num_value(&self, r: &MinerRow) -> Option<f64> {
// The 3 combined (actual/expected) columns must never let a numeric
// filter match a row that only has an expected value: their cell()
// The combined (actual/expected) columns (Hashrate, TotalChips) must never
// let a numeric filter match a row that only has an expected value: their cell()
// renders "- / <expected>" (non-empty) in that case, so the generic
// blank check below is not enough on its own.
match self {
Column::Hashrate if r.hashrate_ths <= 0.0 => return None,
Column::Hashboards if r.hashboards.is_none() => return None,
Column::TotalChips if r.total_chips.is_none() => return None,
_ => {}
}
@@ -1251,43 +1484,58 @@ impl Column {
let none = f64::NEG_INFINITY;
match self {
Column::Hashrate => SortKey::Num(r.hashrate_ths),
// Rolling average windows; a 0.0 (window not reported) sorts to the
// bottom (round 19 #10, T2).
Column::Hashrate1m => {
SortKey::Num(if r.hashrate_1m_ths > 0.0 { r.hashrate_1m_ths } else { none })
}
Column::Hashrate5m => {
SortKey::Num(if r.hashrate_5m_ths > 0.0 { r.hashrate_5m_ths } else { none })
}
Column::Hashrate15m => {
SortKey::Num(if r.hashrate_15m_ths > 0.0 { r.hashrate_15m_ths } else { none })
}
Column::Hashrate24h => {
SortKey::Num(if r.hashrate_24h_ths > 0.0 { r.hashrate_24h_ths } else { none })
}
// Relative hashrate = actual/expected; unknown expectation sorts to
// the bottom (round 11 #16).
Column::HashrateRel => {
SortKey::Num(actual_expected_ratio(r.hashrate_ths, r.expected_ths).unwrap_or(none))
}
Column::Power => SortKey::Num(r.power_w),
Column::Efficiency => SortKey::Num(if r.efficiency > 0.0 { r.efficiency } else { none }),
Column::Efficiency => {
SortKey::Num(r.efficiency_display().map(|(v, _)| v).unwrap_or(none))
}
Column::ChipTemp => SortKey::Num(r.chip_temp_c),
Column::FluidTemp => SortKey::Num(r.fluid_temp_c),
Column::EnvTemp => SortKey::Num(r.env_temp_c),
Column::OutletTemp => SortKey::Num(r.outlet_temp_c),
Column::Cooling => SortKey::Num(if r.fan_rpms.is_empty() {
none
} else {
r.fan_rpms.iter().cloned().fold(f64::INFINITY, f64::min)
}),
Column::CriticalTemp => SortKey::Num(r.temp_critical_c.unwrap_or(none)),
Column::ShutdownTemp => SortKey::Num(r.temp_shutdown_c.unwrap_or(none)),
Column::Fan1 => SortKey::Num(r.fan_rpms.first().copied().unwrap_or(none)),
Column::Fan2 => SortKey::Num(r.fan_rpms.get(1).copied().unwrap_or(none)),
Column::Fan3 => SortKey::Num(r.fan_rpms.get(2).copied().unwrap_or(none)),
Column::Fan4 => SortKey::Num(r.fan_rpms.get(3).copied().unwrap_or(none)),
Column::FanSpeedPercent => SortKey::Num(r.fan_speed_percent.unwrap_or(none)),
Column::Accepted => SortKey::Num(r.accepted_shares.map(|v| v as f64).unwrap_or(none)),
Column::Rejected => SortKey::Num(r.rejected_shares.map(|v| v as f64).unwrap_or(none)),
Column::RejectRatio => SortKey::Num(r.reject_ratio().unwrap_or(none)),
Column::DiffAccepted => SortKey::Num(r.difficulty_accepted.unwrap_or(none)),
Column::DiffRejected => SortKey::Num(r.difficulty_rejected.unwrap_or(none)),
Column::StaleShares => {
SortKey::Num(r.stale_shares.map(|v| v as f64).unwrap_or(none))
}
Column::Blocks => SortKey::Num(r.found_blocks.map(|v| v as f64).unwrap_or(none)),
Column::BoardHashrate => SortKey::Num(avg_or(&r.board_hashrates, none)),
Column::BoardVoltage => SortKey::Num(avg_positive(&r.board_voltages, none)),
Column::BoardFrequency => SortKey::Num(avg_positive(&r.board_frequencies, none)),
Column::PsuFan => SortKey::Num(r.psu_fan_rpm),
Column::PsuVMin => SortKey::Num(r.psu_voltage_min_v.unwrap_or(none)),
Column::PsuVMax => SortKey::Num(r.psu_voltage_max_v.unwrap_or(none)),
Column::FanCount => SortKey::Num(r.fan_count.map(|v| v as f64).unwrap_or(none)),
Column::ExpectedFans => SortKey::Num(r.expected_fans.map(|v| v as f64).unwrap_or(none)),
Column::TotalChips => SortKey::Num(r.total_chips.map(|v| v as f64).unwrap_or(none)),
// The Boards column shows per-hashboard health dots, so sort by the
// number of ONLINE (green) boards -- surfacing units with dead/missing
// boards -- with the total board count as a tiebreaker (so full-health
// units still order by how many boards they have). Falls back to the
// reported board count when no per-board health is available (round 11).
Column::Hashboards => {
if r.board_status.is_empty() {
SortKey::Num(r.hashboards.map(|v| v as f64).unwrap_or(none))
} else {
let online =
r.board_status.iter().filter(|h| matches!(h, BoardHealth::Ok)).count();
let total = r.board_status.len();
SortKey::Num((online * 100 + total) as f64)
}
}
Column::Uptime => SortKey::Num(if r.uptime_secs > 0 { r.uptime_secs as f64 } else { none }),
Column::BestShare => SortKey::Num(r.best_share.unwrap_or(none)),
Column::SessionBestShare => SortKey::Num(r.session_best_share.unwrap_or(none)),
@@ -1323,6 +1571,12 @@ impl Column {
match self {
Column::Ip => r.ip.clone(),
Column::Hashrate => combined_si(r.hashrate_ths, r.expected_ths),
// Rolling average windows: a single TH/s value, blank when not reported
// (round 19 #10, T2).
Column::Hashrate1m => format_hashrate_ths(r.hashrate_1m_ths).unwrap_or_default(),
Column::Hashrate5m => format_hashrate_ths(r.hashrate_5m_ths).unwrap_or_default(),
Column::Hashrate15m => format_hashrate_ths(r.hashrate_15m_ths).unwrap_or_default(),
Column::Hashrate24h => format_hashrate_ths(r.hashrate_24h_ths).unwrap_or_default(),
// Never displayed as its own column; rendered as a percentage only for
// completeness (e.g. a debug/self-test read of the cell).
Column::HashrateRel => actual_expected_ratio(r.hashrate_ths, r.expected_ths)
@@ -1335,7 +1589,12 @@ impl Column {
String::new()
}
}
Column::Efficiency => num(r.efficiency, 1, ""),
// The unit lives in the value now, not the header (round 19 #9), and
// is algorithm-aware (J/TH for SHA256 families, J/kSol for Equihash).
Column::Efficiency => r
.efficiency_display()
.map(|(v, u)| format!("{v:.1} {u}"))
.unwrap_or_default(),
// Per-hashboard chip temps as integers ("77 / 64 / 74"); fall back to
// the average (integer) when per-board readings aren't available.
Column::ChipTemp => {
@@ -1353,17 +1612,47 @@ impl Column {
Column::FluidTemp => num(r.fluid_temp_c, 1, " C"),
Column::EnvTemp => num(r.env_temp_c, 1, " C"),
Column::OutletTemp => num(r.outlet_temp_c, 1, " C"),
Column::Cooling => {
r.fan_rpms.iter().map(|&v| format_fan_rpm(v)).collect::<Vec<_>>().join("/")
Column::CriticalTemp => r.temp_critical_c.map(|v| num(v, 0, " C")).unwrap_or_default(),
Column::ShutdownTemp => r.temp_shutdown_c.map(|v| num(v, 0, " C")).unwrap_or_default(),
// Per-fan RPM: blank (not "-") when the fan index is absent, so a miner
// with fewer fans leaves the extra Fan columns empty and auto-hide can
// drop them (round 19 #8).
Column::Fan1 => r.fan_rpms.first().map(|&v| format_fan_rpm(v)).unwrap_or_default(),
Column::Fan2 => r.fan_rpms.get(1).map(|&v| format_fan_rpm(v)).unwrap_or_default(),
Column::Fan3 => r.fan_rpms.get(2).map(|&v| format_fan_rpm(v)).unwrap_or_default(),
Column::Fan4 => r.fan_rpms.get(3).map(|&v| format_fan_rpm(v)).unwrap_or_default(),
Column::FanSpeedPercent => {
r.fan_speed_percent.map(|v| format!("{v:.0}%")).unwrap_or_default()
}
Column::Target => r.tuning_target_label.clone().unwrap_or_default(),
Column::Accepted => r.accepted_shares.map(|v| v.to_string()).unwrap_or_default(),
Column::Rejected => r.rejected_shares.map(|v| v.to_string()).unwrap_or_default(),
Column::RejectRatio => r.reject_ratio().map(|v| format!("{v:.2}%")).unwrap_or_default(),
// Difficulty-weighted work (SI-formatted like Best share); raw stale /
// block counts as plain integers (round 19 #10, T2).
Column::DiffAccepted => r.difficulty_accepted.map(|v| format_si(v, "")).unwrap_or_default(),
Column::DiffRejected => r.difficulty_rejected.map(|v| format_si(v, "")).unwrap_or_default(),
Column::StaleShares => r.stale_shares.map(|v| v.to_string()).unwrap_or_default(),
Column::Blocks => r.found_blocks.map(|v| v.to_string()).unwrap_or_default(),
// Per-hashboard hashrate / voltage / frequency, slash-joined like Chip
// temp; "-" for a board with no reading, blank when none at all.
Column::BoardHashrate => join_board(&r.board_hashrates, |v| {
format_hashrate_ths(v).unwrap_or_else(|| "-".to_string())
}),
Column::BoardVoltage => {
join_board(&r.board_voltages, |v| if v > 0.0 { format!("{v:.2}") } else { "-".into() })
}
Column::BoardFrequency => {
join_board(&r.board_frequencies, |v| if v > 0.0 { format!("{v:.0}") } else { "-".into() })
}
Column::PsuFan => num(r.psu_fan_rpm, 0, ""),
Column::PsuVersion => r.psu_version.clone(),
Column::PsuSerial => r.psu_serial.clone(),
Column::PsuVMin => r.psu_voltage_min_v.map(|v| format!("{v:.2} V")).unwrap_or_default(),
Column::PsuVMax => r.psu_voltage_max_v.map(|v| format!("{v:.2} V")).unwrap_or_default(),
Column::FanCount => count(r.fan_count),
Column::ExpectedFans => count(r.expected_fans),
Column::TotalChips => combined_count(r.total_chips, r.expected_chips),
Column::Hashboards => combined_count(r.hashboards, r.expected_hashboards),
Column::Firmware => r.firmware.clone(),
Column::FwVersion => r.fw_version.clone(),
Column::Worker => split_worker(&r.worker).1.to_string(),
@@ -1378,6 +1667,8 @@ impl Column {
Column::ApiVersion => r.api_version.clone(),
Column::Cpu => r.cpu.clone(),
Column::BoardCode => r.board_code.clone(),
Column::ChipType => r.chip_type.clone(),
Column::HbType => r.hashboard_model.clone(),
Column::Algorithm => r.algorithm.clone(),
Column::Pic => match r.pic_present {
// A per-board PIC MCU is a known Antminer-hashboard property. Show
@@ -1434,24 +1725,29 @@ impl Column {
Column::Ip | Column::Model | Column::Brand | Column::Submodel | Column::Mac
| Column::Hostname | Column::Serial => (0, "Identity"),
Column::Firmware | Column::FwVersion | Column::ApiVersion | Column::Algorithm
| Column::Pic | Column::Cpu | Column::BoardCode => (1, "Firmware & board"),
| Column::Pic | Column::Cpu | Column::BoardCode | Column::ChipType
| Column::HbType => (1, "Firmware & board"),
Column::Health | Column::HealthPower | Column::HealthFans | Column::HealthBoards
| Column::Status | Column::Error | Column::Locked | Column::Light
| Column::OperatingState => (2, "Health & status"),
Column::Hashrate | Column::HashrateRel | Column::Power | Column::Efficiency
Column::Hashrate | Column::HashrateRel | Column::Hashrate1m | Column::Hashrate5m
| Column::Hashrate15m | Column::Hashrate24h | Column::Power | Column::Efficiency
| Column::TuningPercent | Column::BestShare | Column::SessionBestShare
| Column::Uptime => (3, "Performance"),
Column::ChipTemp | Column::FluidTemp | Column::EnvTemp | Column::OutletTemp => {
| Column::Uptime | Column::Target | Column::BoardHashrate | Column::BoardVoltage
| Column::BoardFrequency => (3, "Performance"),
Column::ChipTemp | Column::FluidTemp | Column::EnvTemp | Column::OutletTemp
| Column::CriticalTemp | Column::ShutdownTemp => {
(4, "Temperature")
}
Column::Cooling | Column::PsuFan | Column::FanCount | Column::ExpectedFans => {
(5, "Cooling")
}
Column::TotalChips | Column::Hashboards | Column::PsuVersion | Column::PsuVMin
Column::Fan1 | Column::Fan2 | Column::Fan3 | Column::Fan4 | Column::PsuFan
| Column::FanCount | Column::ExpectedFans | Column::FanSpeedPercent => (5, "Cooling"),
Column::TotalChips | Column::PsuVersion | Column::PsuSerial | Column::PsuVMin
| Column::PsuVMax => (6, "Hardware"),
Column::Worker | Column::PoolAccount | Column::PoolUrl | Column::Pool1Url
| Column::Pool1Worker | Column::Pool2Url | Column::Pool2Worker | Column::Pool3Url
| Column::Pool3Worker => (7, "Pools"),
| Column::Pool3Worker | Column::Accepted | Column::Rejected
| Column::RejectRatio | Column::DiffAccepted | Column::DiffRejected
| Column::StaleShares | Column::Blocks => (7, "Pools"),
}
}
}
@@ -1878,6 +2174,21 @@ mod tests {
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]
@@ -2577,40 +2888,32 @@ mod tests {
fn combined_cell_all_four_cases() {
let neither = MinerRow::default();
assert_eq!(Column::Hashrate.cell(&neither), "", "both unknown -> blank");
assert_eq!(Column::Hashboards.cell(&neither), "");
assert_eq!(Column::TotalChips.cell(&neither), "");
let actual_only = MinerRow {
hashrate_ths: 60.0,
hashboards: Some(3),
total_chips: Some(210),
..Default::default()
};
assert_eq!(Column::Hashrate.cell(&actual_only), "60.0T", "only actual -> bare actual");
assert_eq!(Column::Hashboards.cell(&actual_only), "3");
assert_eq!(Column::TotalChips.cell(&actual_only), "210");
let expected_only = MinerRow {
expected_ths: 200.0,
expected_hashboards: Some(3),
expected_chips: Some(228),
..Default::default()
};
assert_eq!(Column::Hashrate.cell(&expected_only), "-/200T", "only expected -> '-/<expected>'");
assert_eq!(Column::Hashboards.cell(&expected_only), "- / 3");
assert_eq!(Column::TotalChips.cell(&expected_only), "- / 228");
let both = MinerRow {
hashrate_ths: 60.0,
expected_ths: 200.0,
hashboards: Some(3),
expected_hashboards: Some(3),
total_chips: Some(190),
expected_chips: Some(228),
..Default::default()
};
assert_eq!(Column::Hashrate.cell(&both), "60.0T/200T", "both known -> '<actual>/<expected>'");
assert_eq!(Column::Hashboards.cell(&both), "3 / 3");
assert_eq!(Column::TotalChips.cell(&both), "190 / 228");
}
@@ -2620,37 +2923,38 @@ mod tests {
// value -- there is no actual reading to compare.
let expected_only = MinerRow {
expected_ths: 200.0,
expected_hashboards: Some(3),
expected_chips: Some(228),
..Default::default()
};
assert_eq!(Column::Hashrate.num_value(&expected_only), None);
assert_eq!(Column::Hashboards.num_value(&expected_only), None);
assert_eq!(Column::TotalChips.num_value(&expected_only), None);
let both = MinerRow {
hashrate_ths: 60.0,
expected_ths: 200.0,
hashboards: Some(3),
expected_hashboards: Some(3),
total_chips: Some(190),
expected_chips: Some(228),
..Default::default()
};
assert_eq!(Column::Hashrate.num_value(&both), Some(60.0));
assert_eq!(Column::Hashboards.num_value(&both), Some(3.0));
assert_eq!(Column::TotalChips.num_value(&both), Some(190.0));
}
#[test]
fn cooling_column_joins_fan_rpms_and_sorts_by_min() {
fn per_fan_columns_show_each_fan_and_hide_when_absent() {
// Round 19 #8: the old slash-joined Cooling column is now one column per fan.
let r = MinerRow { fan_rpms: vec![4200.0, 3990.0, 4500.0], ..Default::default() };
assert_eq!(Column::Cooling.cell(&r), "4.2k/4.0k/4.5k");
assert_eq!(Column::Cooling.num_value(&r), Some(3990.0));
assert_eq!(Column::Fan1.cell(&r), "4.2k");
assert_eq!(Column::Fan2.cell(&r), "4.0k");
assert_eq!(Column::Fan3.cell(&r), "4.5k");
// A miner with only 3 fans leaves Fan 4 blank (so auto-hide can drop it).
assert_eq!(Column::Fan4.cell(&r), "");
assert_eq!(Column::Fan1.num_value(&r), Some(4200.0));
assert_eq!(Column::Fan4.num_value(&r), None);
let none = MinerRow::default();
assert_eq!(Column::Cooling.cell(&none), "");
assert_eq!(Column::Cooling.num_value(&none), None);
assert_eq!(Column::Fan1.cell(&none), "");
assert_eq!(Column::Fan1.num_value(&none), None);
}
#[test]
+10 -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
@@ -284,8 +287,10 @@ 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
+20 -9
View File
@@ -82,23 +82,34 @@ pub fn save_all(field: PoolField, values: &[String]) -> std::io::Result<usize> {
if let Some(dir) = p.parent() {
let _ = std::fs::create_dir_all(dir);
}
std::fs::write(&p, out.join("\n"))?;
// The password list can hold a pool password; keep every saved list owner-only
// (round 18 #12).
restrict_permissions(&p);
// 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())
}
/// Best-effort tighten a config file to owner-only (0600) on Unix. A no-op
/// elsewhere; a failure is ignored (the file still exists, just not restricted).
fn restrict_permissions(path: &std::path::Path) {
/// 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::os::unix::fs::PermissionsExt;
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)
}
#[cfg(not(unix))]
let _ = path;
{
std::fs::write(path, data)
}
}
/// Trim every value, then drop empties, values equal to a built-in preset, and
+1 -2
View File
@@ -133,10 +133,9 @@ mod tests {
assert!(view.visible.contains(&Column::Locked));
// The Health column (round 13 #3) replaced these in the default profile.
assert!(!view.visible.contains(&Column::Error));
assert!(!view.visible.contains(&Column::Hashboards));
// Columns dropped from the default profile in round 11.
assert!(!view.visible.contains(&Column::BoardCode), "not in the default profile");
assert!(!view.visible.contains(&Column::Cooling), "not in the default profile");
assert!(!view.visible.contains(&Column::Fan1), "not in the default profile");
// to_view covers every column in `order`.
assert_eq!(view.order.len(), ALL_COLUMNS.len());
// Round-trip a snapshot back out.
+68 -17
View File
@@ -77,7 +77,8 @@ pub fn start_restore(
}
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);
@@ -92,6 +93,16 @@ pub fn start_restore(
}
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 }
}
@@ -110,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}")),
};
@@ -126,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())),
@@ -155,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}")),
}
}
@@ -188,7 +225,7 @@ fn restore_braiins(ip: &str, user: &str, pass: &str) -> (bool, String) {
&target,
"uninstall.sh || /sbin/uninstall.sh",
]);
match run_with_timeout(cmd, Duration::from_secs(60)) {
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),
@@ -278,10 +315,10 @@ struct CmdOutput {
/// 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]) -> Result<String, String> {
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))?;
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());
}
@@ -291,10 +328,24 @@ fn curl(args: &[&str]) -> Result<String, String> {
/// 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).
fn run_with_timeout(mut cmd: Command, timeout: Duration) -> Result<CmdOutput, String> {
/// `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 mut stderr = child.stderr.take().ok_or("no stderr")?;
let out_reader = std::thread::spawn(move || {
+233 -18
View File
@@ -4,7 +4,7 @@
use crate::model::{MinerCaps, MinerRow};
use asic_rs::core::data::firmware::FirmwareImage;
use asic_rs::core::traits::miner::Miner;
use futures_util::StreamExt;
use futures_util::{FutureExt, StreamExt};
use measurements::Power;
use std::collections::HashSet;
use std::net::Ipv4Addr;
@@ -39,11 +39,43 @@ pub const AUTO_FILE: &str = "auto-rescan-secs.txt";
pub const SCAN_TIMEOUT_FILE: &str = "scan-timeout-secs.txt";
/// Default per-miner scan timeout (matches asic-rs' identification timeout).
pub const DEFAULT_SCAN_TIMEOUT_SECS: u64 = 10;
/// Maximum in-flight address probes during a scan. asic-rs would otherwise use
/// Default in-flight address probes during a scan. asic-rs would otherwise use
/// 1000 for any range up to /22, saturating a real link and starving the
/// per-responder get_data (Braiins miners drop most values under that burst).
/// 128 was the highest cap that stayed fully reliable on the live fleet.
/// 128 was the highest cap that stayed fully reliable on the live fleet; it is
/// now the default of a user-adjustable setting (round 19 #25).
pub const SCAN_CONCURRENCY_LIMIT: usize = 128;
/// The user-configurable scan concurrency is clamped to this range: a floor so a
/// scan is never effectively serial, and a ceiling so a large range can't open
/// hundreds of connections and saturate the network (round 19 #25). Higher
/// values scan faster but can starve per-responder telemetry (see above).
pub const MIN_SCAN_CONCURRENCY: usize = 8;
// Ceiling kept at 256: the code below documents that 128 is fully reliable and 192
// already dropped responders, and identification + telemetry run concurrently so
// the peak socket count is ~2x this. 256 gives headroom for a fast sweep without
// inviting the mass value-drops (which read as phantom faults) that higher caps
// caused on the live fleet (round 19 review).
pub const MAX_SCAN_CONCURRENCY: usize = 256;
pub const SCAN_CONCURRENCY_FILE: &str = "scan-concurrency.txt";
/// Load the saved scan concurrency (in-flight probes), clamped to
/// [MIN_SCAN_CONCURRENCY, MAX_SCAN_CONCURRENCY].
pub fn load_scan_concurrency() -> usize {
std::fs::read_to_string(config_path(SCAN_CONCURRENCY_FILE))
.ok()
.and_then(|s| s.trim().parse::<usize>().ok())
.map(|n| n.clamp(MIN_SCAN_CONCURRENCY, MAX_SCAN_CONCURRENCY))
.unwrap_or(SCAN_CONCURRENCY_LIMIT)
}
/// Save the scan concurrency, clamped to the allowed range.
pub fn save_scan_concurrency(n: usize) -> std::io::Result<()> {
let p = config_path(SCAN_CONCURRENCY_FILE);
if let Some(dir) = p.parent() {
std::fs::create_dir_all(dir)?;
}
std::fs::write(p, n.clamp(MIN_SCAN_CONCURRENCY, MAX_SCAN_CONCURRENCY).to_string())
}
pub const DEFAULT_RANGE: &str = "10.255.1.0/24";
/// Default seconds between automatic rescans.
pub const DEFAULT_AUTO_SECS: u64 = 300;
@@ -374,6 +406,8 @@ pub fn start_scan(lines: Vec<String>, timeout_secs: u64) -> ScanHandle {
let target_set: HashSet<String> = targets.iter().map(|ip| ip.to_string()).collect();
let _ = tx.send(ScanMsg::Started { total, targets: target_set });
let cidrs = targets_to_cidrs(&targets);
// User-adjustable in-flight probe cap (round 19 #25).
let concurrency = load_scan_concurrency();
let thread_cancel = cancel.clone();
let err_tx = tx.clone();
@@ -398,7 +432,8 @@ pub fn start_scan(lines: Vec<String>, timeout_secs: u64) -> ScanHandle {
// 128 is the highest cap that stayed fully reliable on the live
// fleet (192 already dropped responders); a /24 still finishes in
// ~35s. Larger ranges just take proportionally longer, still correct.
.with_concurrent_limit(SCAN_CONCURRENCY_LIMIT);
// The cap is now user-adjustable (round 19 #25); the default is 128.
.with_concurrent_limit(concurrency);
for (ip, prefix) in &cidrs {
factory = match factory.with_subnet(&format!("{ip}/{prefix}")) {
Ok(f) => f,
@@ -421,17 +456,41 @@ pub fn start_scan(lines: Vec<String>, timeout_secs: u64) -> ScanHandle {
// 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);
let ptx = tx.clone();
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),
.map(|(ip, miner)| {
let ptx = ptx.clone();
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) => {
// Fast path (round 19 #18): emit a lightweight identity
// row from identification alone the instant the miner
// is found, so it shows immediately; the full telemetry
// row (get_data) upserts over it when it completes. The
// ordering holds because the partial is sent before this
// future awaits get_data and returns the full row.
let _ = ptx.send(ScanMsg::Row(partial_row(&*m, ip)));
// Isolate one miner's telemetry: asic-rs backends
// parse miner-controlled data, so a panic (a stray
// unwrap/index on a malformed field) must not unwind
// the whole sweep and abort every other miner (round
// 19 review). On panic the miner keeps its partial
// identity row and the scan continues.
let row = std::panic::AssertUnwindSafe(to_row(&*m))
.catch_unwind()
.await
.ok();
(ip, row)
}
None => (ip, None),
}
}
})
.buffer_unordered(SCAN_CONCURRENCY_LIMIT);
.buffer_unordered(concurrency);
while let Some((ip, row)) = results.next().await {
if thread_cancel.load(Ordering::Relaxed) {
return; // Stop / re-scan requested
@@ -508,11 +567,13 @@ fn board_index_from_text(text: &str) -> Option<usize> {
let mut from = 0;
while let Some(rel) = lower[from..].find(kw) {
let after = &lower[from + rel + kw.len()..];
let digits: String = after
.trim_start_matches(|c: char| !c.is_ascii_digit())
.chars()
.take_while(|c| c.is_ascii_digit())
.collect();
// 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);
}
@@ -574,6 +635,16 @@ mod board_index_tests {
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
@@ -587,7 +658,7 @@ mod board_index_tests {
///
/// 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);
@@ -630,6 +701,50 @@ async fn detect_aftermarket_antminer(ip: std::net::IpAddr) -> Option<&'static st
}
}
/// A lightweight row built from identification alone (no `get_data`), emitted the
/// instant a miner is identified so it appears in the fleet immediately; the full
/// telemetry row upserts over it when `get_data` completes (round 19 #18). Only
/// the cheap, synchronous identity + capability accessors are read here -- no
/// network I/O beyond what identification already did.
fn partial_row(miner: &dyn Miner, ip: std::net::IpAddr) -> MinerRow {
let di = miner.get_device_info();
let (firmware, _fw_vendor) = crate::naming::firmware_family(&di.firmware);
let brand = crate::naming::brand(&di.make);
let model = crate::naming::clean_model(&di.make, &di.model);
let submodel = crate::naming::submodel(&di.make, &di.model);
// Same VNish power-limit masking as the full row (round 9 #3).
let power_limit =
miner.supports_set_power_limit() && !di.firmware.eq_ignore_ascii_case("VNish");
let caps = MinerCaps {
fault_light: miner.supports_set_fault_light(),
restart: miner.supports_restart(),
pause: miner.supports_pause(),
resume: miner.supports_resume(),
power_limit,
tuning: miner.supports_set_tuning_percent(),
// hashrate_target needs the tuning envelope from get_data; the full row
// fills it in a moment later.
hashrate_target: false,
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(),
};
MinerRow {
ip: ip.to_string(),
brand,
model,
submodel,
firmware,
algorithm: di.algo.to_string(),
write_locked: Some(!caps.any_control()),
caps,
..Default::default()
}
}
async fn to_row(miner: &dyn Miner) -> MinerRow {
let data = miner.get_data().await;
let hashrate_ths = data
@@ -637,6 +752,27 @@ 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);
// Rolling average windows in TH/s (round 19 #10, T2); 0.0 = window not reported.
let (hashrate_1m_ths, hashrate_5m_ths, hashrate_15m_ths, hashrate_24h_ths) = {
let to_ths = |h: &Option<asic_rs::core::data::hashrate::HashRate>| {
h.as_ref()
.map(|h| {
h.clone()
.as_unit(asic_rs::core::data::hashrate::HashRateUnit::TeraHash)
.value
})
.unwrap_or(0.0)
};
match data.hashrate_averages.as_ref() {
Some(a) => (
to_ths(&a.avg_1m),
to_ths(&a.avg_5m),
to_ths(&a.avg_15m),
to_ths(&a.avg_24h),
),
None => (0.0, 0.0, 0.0, 0.0),
}
};
let mut expected_ths = data
.expected_hashrate
.as_ref()
@@ -933,6 +1069,15 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
selected: false,
caps,
algorithm,
// ASIC chip type + hashboard model, from the first board that reports them
// (uniform across boards); empty where the firmware doesn't expose them
// (round 19 #10).
chip_type: data.hashboards.iter().find_map(|b| b.chip_type.clone()).unwrap_or_default(),
hashboard_model: data
.hashboards
.iter()
.find_map(|b| b.hashboard_model.clone())
.unwrap_or_default(),
pic_present,
write_locked,
errors,
@@ -966,6 +1111,10 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
cpu,
board_code,
hashrate_ths,
hashrate_1m_ths,
hashrate_5m_ths,
hashrate_15m_ths,
hashrate_24h_ths,
expected_ths,
board_hashrates,
board_expected_hashrates,
@@ -988,6 +1137,7 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
(None, None) => String::new(),
})
.unwrap_or_default(),
psu_serial: data.psu.as_ref().and_then(|p| p.serial.clone()).unwrap_or_default(),
psu_voltage_min_v: data.psu.as_ref().and_then(|p| p.voltage_min),
psu_voltage_max_v: data.psu.as_ref().and_then(|p| p.voltage_max),
tuning_target_label,
@@ -1001,7 +1151,10 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
fluid_temp_c,
env_temp_c,
outlet_temp_c,
temp_critical_c: data.temp_critical,
temp_shutdown_c: data.temp_shutdown,
fan_rpms,
fan_speed_percent: data.fan_speed_percent,
psu_fan_rpm,
fan_count: (!data.fans.is_empty()).then_some(data.fans.len() as u32),
expected_fans: data.expected_fans.map(|v| v as u32),
@@ -1015,6 +1168,35 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
pools,
best_share: data.best_share,
session_best_share: data.session_best_share,
// Accepted / rejected shares summed across every configured pool (round 19
// #10); None when no pool reports the count.
accepted_shares: {
let mut total = 0u64;
let mut any = false;
for p in data.pools.iter().flat_map(|g| g.pools.iter()) {
if let Some(v) = p.accepted_shares {
total = total.saturating_add(v);
any = true;
}
}
any.then_some(total)
},
rejected_shares: {
let mut total = 0u64;
let mut any = false;
for p in data.pools.iter().flat_map(|g| g.pools.iter()) {
if let Some(v) = p.rejected_shares {
total = total.saturating_add(v);
any = true;
}
}
any.then_some(total)
},
// Cumulative share stats from the miner summary (round 19 #10, T2).
difficulty_accepted: data.share_summary.as_ref().and_then(|s| s.difficulty_accepted),
difficulty_rejected: data.share_summary.as_ref().and_then(|s| s.difficulty_rejected),
stale_shares: data.share_summary.as_ref().and_then(|s| s.stale_shares),
found_blocks: data.share_summary.as_ref().and_then(|s| s.found_blocks),
uptime_secs: data.uptime.map(|d| d.as_secs()).unwrap_or(0),
light_flashing: data.light_flashing,
operating_state,
@@ -1159,6 +1341,37 @@ async fn apply_action(miner: &dyn Miner, action: &ConfigAction) -> Result<bool,
result.map_err(|e| e.to_string())
}
/// Fetch one miner's log via asic-rs's per-backend `read_logs()` (round 19
/// #11-16). Runs synchronously on the caller's thread in a short-lived
/// current-thread runtime (mirroring `start_config_action`), so the GUI's
/// existing "log-fetch" worker thread can call it directly. `Err` when the IP is
/// unparseable, no miner answers, the backend has no log API (e.g. LuxOS,
/// WhatsMiner), or the fetch fails/times out.
pub fn fetch_log(ip: &str, timeout_secs: u64) -> Result<String, String> {
let addr: std::net::IpAddr = ip.parse().map_err(|_| "bad IP".to_string())?;
let rt = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.map_err(|e| format!("runtime: {e}"))?;
rt.block_on(async move {
let factory =
crate::credentials::configured_factory().with_identification_timeout_secs(timeout_secs.max(1));
let miner = match factory.scan_miner(addr).await {
Ok(Some(m)) => m,
Ok(None) => return Err("no miner answered at this IP".to_string()),
Err(e) => return Err(format!("{e}")),
};
if !miner.supports_read_logs() {
return Err("this firmware's backend does not expose logs over its API".to_string());
}
match tokio::time::timeout(std::time::Duration::from_secs(25), miner.read_logs()).await {
Ok(Ok(text)) => Ok(text),
Ok(Err(e)) => Err(format!("read logs: {e}")),
Err(_) => Err("log fetch timed out".to_string()),
}
})
}
/// Apply `action` to each miner in `ips` on a background thread: re-discover the
/// miner (asic-rs `scan_miner`), run the setter, and report per-IP results. In
/// fake-scan mode it reports simulated successes so the flow works offline.
@@ -1833,7 +2046,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);
+366 -175
View File
@@ -22,7 +22,7 @@ pub const ID_PRESETS: i32 = 108;
pub const ID_EXPORT: i32 = 109;
// Settings menu (round 15 #13): the toolbar button + its menu items.
pub const ID_SETTINGS: i32 = 110;
const ID_LANG_BASE: i32 = 790; // one id per language (790 + index)
const ID_LANG_BASE: i32 = 790; // one id per language (790 + Lang index); reserves 790..790+Lang::all().len()
const ID_LOGS_OPEN: i32 = 796; // open the Logs page
const ID_LOGS_REFRESH: i32 = 797;
const ID_LOGS_CLEAR: i32 = 798;
@@ -43,6 +43,11 @@ const ID_COLS_CATEGORIES: i32 = 232;
const ID_FILTER_OK: i32 = 205;
const ID_FILTER_CANCEL: i32 = 206;
const ID_FILTER_RESET: i32 = 210;
// Export column-picker dialog (round 19 #6).
const ID_EXPORT_OK: i32 = 207;
const ID_EXPORT_CANCEL: i32 = 208;
const ID_EXPORT_ALL: i32 = 209;
const ID_EXPORT_NONE: i32 = 211;
// Per-column "All"/"None" buttons in the filter panel are ID_FILTER_ALL_BASE +
// column index (and the None equivalent). 100 columns of headroom each.
const ID_FILTER_ALL_BASE: i32 = 300;
@@ -86,12 +91,14 @@ const ID_CTX_POOLS: i32 = 736;
const ID_POOLS_OK: i32 = 788;
const ID_POOLS_CANCEL: i32 = 789;
// Pool-preset manager dialog (round 18 #8b): edit the whole saved list at once.
const ID_POOL_PRESETS_SAVE: i32 = 790;
const ID_POOL_PRESETS_CANCEL: i32 = 791;
// NB: 790-795 belong to the language menu (ID_LANG_BASE + Lang index), so these
// live in a separate high block to avoid an id collision (round 18 #12).
const ID_POOL_PRESETS_SAVE: i32 = 1001;
const ID_POOL_PRESETS_CANCEL: i32 = 1002;
// Firmware profile/preset selector dialog (round 18 / roadmap G3).
const ID_FWPRESET_OK: i32 = 792;
const ID_FWPRESET_CANCEL: i32 = 793;
const ID_FWPRESET_CHOICE: i32 = 794;
const ID_FWPRESET_OK: i32 = 1003;
const ID_FWPRESET_CANCEL: i32 = 1004;
const ID_FWPRESET_CHOICE: i32 = 1005;
// Pool-field "+" dropdown buttons (round 15 #1): 12 buttons (3 rows x 4 fields),
// id = base + row*4 + field. The dropdown menu items use their own id range.
const ID_POOL_PLUS_BASE: i32 = 800;
@@ -131,6 +138,8 @@ const ID_HDR_COLUMNS: i32 = 764;
// (round 11 #16).
const ID_HDR_SORT_REL_ASC: i32 = 765;
const ID_HDR_SORT_REL_DESC: i32 = 766;
// Auto-size every column at once (round 19 #4).
const ID_HDR_AUTOSIZE_ALL: i32 = 767;
// Ticks (~seconds) to keep an action's result on the status bar before the
// idle/countdown status takes over again.
// Filter dialog: the column-selector dropdown + the comparator dropdown.
@@ -187,8 +196,8 @@ fn tint_toward(base: (u8, u8, u8), target: (u8, u8, u8), f: f64) -> (u8, u8, u8)
(lerp(base.0, target.0), lerp(base.1, target.1), lerp(base.2, target.2))
}
/// Colour for a combined actual/expected ratio (Hashrate/Hashboards/
/// TotalChips): full red at 50% (or below), amber at 75%, green at 100%+,
/// Colour for a combined actual/expected ratio (Hashrate/TotalChips):
/// full red at 50% (or below), amber at 75%, green at 100%+,
/// interpolated linearly -- calibrated so a miner running at half its expected
/// output reads as clearly bad, and 100% reads green.
fn ratio_color(pal: &Palette, ratio: f64) -> (u8, u8, u8) {
@@ -236,15 +245,9 @@ fn temp_color(pal: &Palette, temp_c: f64) -> (u8, u8, u8) {
tint_toward(pal.accent, pal.red, ((temp_c - 40.0) / 50.0).clamp(0.0, 1.0))
}
/// Colour for one cooling-fan RPM: muted grey (stopped/unknown) fading to
/// accent blue as the RPM approaches 6000 (comfortably above a healthy fan's
/// typical ceiling, so a spinning fan reads as a clear, saturated blue).
fn fan_color(pal: &Palette, rpm: f64) -> (u8, u8, u8) {
tint_toward(pal.label, pal.accent, (rpm / 6000.0).clamp(0.0, 1.0))
}
/// Build the segment-encoded cell for a combined actual/expected column
/// (Hashrate/Hashboards/TotalChips) from its already-formatted parts: the
/// (Hashrate/TotalChips) from its already-formatted parts: the
/// actual half is coloured by `ratio` when both halves are known, the separator
/// `sep` and the expected half stay the default text colour, and an unknown
/// actual shows "-". Round-trips (via decode_segments_plain) to the same plain
@@ -311,7 +314,6 @@ fn encode_flag_cell(plain: &str, color: Option<(u8, u8, u8)>) -> String {
/// Shape-sentinel strings the SegmentRenderer draws as small vector icons rather
/// than text (round 11 #10/#13). These byte values MUST match the SHAPE_* set in
/// widgets_bridge.cpp. They are control characters, never emoji/pictographs.
const SHAPE_DOT: &str = "\u{0007}";
const SHAPE_LOCK: &str = "\u{0002}";
const SHAPE_UNLOCK: &str = "\u{0003}";
// Status-column KPI icons (round 12 #11): one sentinel per status, each drawn
@@ -374,28 +376,6 @@ fn svg_viewbox(svg: &str) -> (i32, i32) {
.unwrap_or((1, 1))
}
/// Boards column: one status dot per hashboard (round 11 #10). Board 1 is the
/// rightmost dot, so boards render high-position-first (left to right). green =
/// present and hashing, red = present but idle/faulty, grey = not detected.
fn encode_board_dots(pal: &Palette, status: &[crate::model::BoardHealth]) -> String {
use crate::model::BoardHealth;
if status.is_empty() {
return encode_segments(&[(None, String::new())]);
}
let segs: Vec<Segment> = status
.iter()
.rev()
.map(|h| {
let color = match h {
BoardHealth::Ok => pal.green,
BoardHealth::Fault => pal.red,
BoardHealth::Missing => pal.label,
};
(Some(color), SHAPE_DOT.to_string())
})
.collect();
encode_segments(&segs)
}
/// Access column: a green open padlock (writable) or red closed padlock
/// (view-only); blank when the lock state is unknown (round 11 #13).
@@ -470,7 +450,16 @@ fn encode_component_health(
}
let boards = r.board_healths();
for h in &boards {
segs.push((Some(health_color(pal, *h)), SHAPE_CHIP.to_string()));
// A paused miner's boards are intentionally idle, not faulty: show every
// detected board blue instead of its (red) health colour, while every
// other component keeps its normal colour. A genuinely undetected board
// stays grey (round 19 #19).
let color = if r.paused && *h != crate::model::CompHealth::Unreachable {
pal.accent
} else {
health_color(pal, *h)
};
segs.push((Some(color), SHAPE_CHIP.to_string()));
}
for _ in boards.len()..max_boards {
segs.push((None, SHAPE_GAP.to_string()));
@@ -531,23 +520,6 @@ fn svg_width_for_height(svg: &str, h: i32) -> i32 {
.max(1)
}
/// Build the segment-encoded cell text for the Cooling column: each fan's RPM
/// gets its own grey-to-blue colour by speed, and the "/" separators between
/// them stay in the default text colour.
fn encode_cooling_cell(pal: &Palette, fans: &[f64]) -> String {
if fans.is_empty() {
return encode_segments(&[(None, String::new())]);
}
let mut segs: Vec<Segment> = Vec::with_capacity(fans.len() * 2 - 1);
for (i, &rpm) in fans.iter().enumerate() {
if i > 0 {
segs.push((None, "/".to_string()));
}
segs.push((Some(fan_color(pal, rpm)), format_fan_rpm(rpm)));
}
encode_segments(&segs)
}
/// Format a filter's numeric bound without a trailing ".0" for whole numbers.
fn fmt_num(v: f64) -> String {
if v.is_finite() && v == v.trunc() && v.abs() < 1e15 {
@@ -640,11 +612,10 @@ pub struct App {
kpi_power: Widget,
progress: Widget,
pub table: Option<Widget>,
// Whether the columns have had their one-time content-fit autosize applied
// since the table was last (re)built (round 18 #10). Reset on rebuild; set
// the first time fill_rows runs with rows present, so the default widths fit
// their contents (capped) once and manual resizes afterwards are preserved.
columns_autosized: bool,
// Set when a scan streamed new rows this drain; flushed by tick() at most once
// per second (or immediately once the scan ends) so the full table refill runs
// ~1 Hz during a scan instead of every fast tick (round 18 #12).
rows_dirty: bool,
// The columns the wxDataViewCtrl was actually built with, in creation order.
// fill_rows/header_click/reorder index the widget through table_columns() and
// assume it stays in lockstep; with auto-hide-empty on, a scan can change which
@@ -662,6 +633,10 @@ pub struct App {
refresh: Option<scan::RefreshHandle>,
// scan loop (play/pause/stop + auto-rescan)
playing: bool,
// True when the user explicitly Stopped the scan (as opposed to Paused the
// auto-rescan loop). Distinguishes the idle status line "Scan Stopped" from
// "Scan Paused"; cleared when a scan starts (round 19 #17).
scan_stopped: bool,
auto_secs: u64,
// Per-miner scan timeout in seconds (round 14 #2).
scan_timeout_secs: u64,
@@ -707,6 +682,10 @@ pub struct App {
// IPs the current config action targets, re-probed after it completes so the
// table reflects the change (e.g. the identify light toggling).
action_targets: Vec<String>,
// A new password from an in-flight ChangePassword action, applied to the saved
// credentials once the action succeeds so the toolkit keeps reaching the miners
// it just changed (round 18 #12).
pending_password_update: Option<String>,
// Per-miner in-flight operation label (round 14 #4): while a miner has an
// operation running (refresh, config action, light, firmware, restore, access
// check), its Health cell shows this text instead of the component icons.
@@ -783,10 +762,15 @@ pub struct App {
ranges_edit: Widget,
ranges_auto: Widget,
ranges_timeout: Widget,
/// Scan-concurrency (in-flight probes) input in the ranges dialog (round 19 #25).
ranges_concurrency: Widget,
columns_dialog: Widget,
columns_list: Widget,
/// The columns-dialog "hide empty columns" checkbox, read at Apply.
columns_hide_empty_cb: Widget,
/// Export column-picker dialog + its checklist (round 19 #6).
export_dialog: Widget,
export_list: Widget,
/// When set, columns with no scanned value in any row are hidden from the
/// table (non-destructively -- clearing it restores them) (round 11 #9).
auto_hide_empty: bool,
@@ -1019,7 +1003,7 @@ pub fn build(frame: Widget) -> App {
kpi_power,
progress,
table: None,
columns_autosized: false,
rows_dirty: false,
built_columns: Vec::new(),
table_parent,
root_sizer: root,
@@ -1029,6 +1013,7 @@ pub fn build(frame: Widget) -> App {
target_ips: HashSet::new(),
refresh: None,
playing: true,
scan_stopped: false,
auto_secs: scan::load_auto_secs(),
scan_timeout_secs: scan::load_scan_timeout(),
countdown: 0,
@@ -1051,6 +1036,7 @@ pub fn build(frame: Widget) -> App {
action_total: 0,
action_done: 0,
action_targets: Vec::new(),
pending_password_update: None,
op_status: std::collections::HashMap::new(),
confirm_dialog: frame,
pending_confirm: None,
@@ -1091,9 +1077,12 @@ pub fn build(frame: Widget) -> App {
ranges_edit: frame,
ranges_auto: frame,
ranges_timeout: frame,
ranges_concurrency: frame,
columns_dialog: frame,
columns_list: frame,
columns_hide_empty_cb: frame,
export_dialog: frame,
export_list: frame,
auto_hide_empty: false,
filter_dialog: frame,
filter_col_choice: frame,
@@ -1199,13 +1188,22 @@ impl App {
Some((sc, false)) if sc == c => title.push_str(" v"),
_ => {}
}
if matches!(c, Column::Hashrate | Column::Health | Column::Hashboards | Column::TotalChips | Column::ChipTemp | Column::Cooling | Column::Locked | Column::Light | Column::Error | Column::Status | Column::Firmware) {
// These columns show two-tone / multi-tone text (actual vs.
// expected, or one colour per fan) via a custom renderer that
// parses the segment-encoded cell value fill_rows writes.
t.dvlc_append_colored_col(&title, c.width(), !fixed);
// Data/text columns are right-aligned (round 19 #21). IP and the
// icon columns (Health/Access/Light) stay left-aligned so their
// fixed-width icon slots anchor at a consistent left edge and line up
// across rows (round 19 Health-column follow-up).
let align = if matches!(c, Column::Ip | Column::Health | Column::Locked | Column::Light) {
wx_rs::ALIGN_LEFT
} else {
t.dvlc_append_text_col(&title, c.width(), !fixed);
wx_rs::ALIGN_RIGHT
};
if matches!(c, Column::Hashrate | Column::Health | Column::TotalChips | Column::ChipTemp | Column::Locked | Column::Light | Column::Error | Column::Status | Column::Firmware) {
// These columns show two-tone / multi-tone text (actual vs.
// expected) via a custom renderer that parses the segment-encoded
// cell value fill_rows writes.
t.dvlc_append_colored_col(&title, c.width(), !fixed, align);
} else {
t.dvlc_append_text_col(&title, c.width(), !fixed, align);
}
}
// Add the table to the root sizer (proportion 1 => fills the area under
@@ -1221,20 +1219,21 @@ impl App {
// detect an auto-hide-empty set change and rebuild rather than render
// against stale columns (round 18 #12).
self.built_columns = self.table_columns();
// Fresh columns come back at their configured default widths; let the
// next fill_rows shrink them to fit their contents (round 18 #10).
self.columns_autosized = false;
self.fill_rows();
}
pub fn fill_rows(&mut self) {
let Some(t) = self.table else { return };
// Compute the shown columns once and reuse it everywhere below (with
// auto-hide-empty on, table_columns() scans every cell of every row, so it
// must not be called per section of this function -- round 18 #12).
let cols = self.table_columns();
// If the set of shown columns has changed since the widget was built (only
// possible with auto-hide-empty on, when a scan makes a column non-empty),
// the widget's columns are stale: rendering now would misalign cells and
// header clicks. Rebuild instead -- deferred, because rebuild_table
// destroys this control (round 18 #12).
if self.table_columns() != self.built_columns {
if cols != self.built_columns {
wx_rs::call_after(DEFER_TABLE);
return;
}
@@ -1243,7 +1242,6 @@ impl App {
let top = t.dvlc_get_top_row();
t.dvlc_clear();
self.view_idx = self.view.view(&self.rows);
let cols = self.table_columns();
for &ri in &self.view_idx {
let r = &self.rows[ri];
let cells: Vec<String> = cols.iter().map(|c| c.cell(r)).collect();
@@ -1285,8 +1283,6 @@ impl App {
Some(op) => encode_segments(&[(Some(self.pal.amber), op.clone())]),
None => encode_component_health(&self.pal, r, max_fans, max_boards),
},
// Boards column: per-hashboard health dots (round 11 #10).
Column::Hashboards => encode_board_dots(&self.pal, &r.board_status),
Column::TotalChips => {
let actual = r.total_chips.map(|v| v.to_string());
let expected = r.expected_chips.map(|v| v.to_string());
@@ -1299,7 +1295,6 @@ impl App {
encode_combined_cell(&self.pal, actual, expected, " / ", ratio)
}
Column::ChipTemp => encode_board_temps_cell(&self.pal, &r.board_temps, r.chip_temp_c),
Column::Cooling => encode_cooling_cell(&self.pal, &r.fan_rpms),
// Access column: a padlock icon, green open (writable) / red
// closed (view-only) (round 11 #13).
Column::Locked => encode_access_icon(&self.pal, r.write_locked),
@@ -1338,17 +1333,14 @@ impl App {
}
}
}
// Item 10: the first time we have rows to measure after a (re)build, set
// each column's width to the smaller of its content-fit width and its
// configured default (the cap), so columns are no wider than needed. Done
// once per rebuild; the user's later manual resizes are then preserved
// because subsequent fill_rows calls (scan updates) skip this.
if !self.columns_autosized && !self.view_idx.is_empty() {
for (pos, c) in cols.iter().enumerate() {
t.dvlc_autosize_col_capped(pos, c.width());
}
self.columns_autosized = true;
}
// Columns keep their configured default widths (scaled by the table zoom
// via table_zoom_reapply). A previous build re-ran a content-fit autosize
// on every rebuild, but on GTK reading a column's width immediately after
// SetWidth(AUTOSIZE) returns a value from before the native measurement
// lands, so a rebuild (language change, hide/show, reorder) collapsed every
// column to the floor (round 19 #3/#24). Autosize is now on-demand only
// (the header menu's "Auto-size" items), where the columns are realised so
// the measurement is valid.
if let Some(row) = top {
t.dvlc_ensure_visible(row.min(self.view_idx.len().saturating_sub(1)));
}
@@ -1557,10 +1549,14 @@ impl App {
menu.menu_append(ID_CTX_LIGHT_ON, &format!("Flash lights{sfx}"));
}
}
if caps.pause {
// State-aware (round 19 #20): only offer Pause when at least one
// selected miner is actually running, and Resume only when at least
// one is paused, so a paused miner never shows "Pause" and a running
// one never shows "Resume". On a mixed selection both can appear.
if caps.pause && selected.iter().any(|r| !r.paused) {
menu.menu_append(ID_CTX_PAUSE, &format!("Pause mining{sfx}"));
}
if caps.resume {
if caps.resume && selected.iter().any(|r| r.paused) {
menu.menu_append(ID_CTX_RESUME, &format!("Resume mining{sfx}"));
}
if caps.tuning {
@@ -1831,6 +1827,17 @@ impl App {
wx_rs::set_status_text("firmware flash in progress -- wait for it to finish");
return;
}
// This path sets self.action directly, so it needs start_action's full
// exclusivity guard: don't write pools during a restore or a live scan
// (round 18 #12).
if self.restore.is_some() {
wx_rs::set_status_text("restore-to-stock in progress -- wait for it to finish");
return;
}
if self.scanning {
wx_rs::set_status_text("scan in progress -- wait for it to finish");
return;
}
// Collect the raw rows: (address, account, worker_template, password).
let mut rows: Vec<(String, String, String, String)> = Vec::new();
for row in 0..3usize {
@@ -1878,6 +1885,12 @@ impl App {
let ips: Vec<String> = targets.iter().map(|t| t.ip.clone()).collect();
if let Some(old) = self.action.take() {
old.stop();
// Clear the superseded action's in-flight status so its Health cells
// don't stay frozen on the old label (round 18 #12).
let stale = std::mem::take(&mut self.action_targets);
for ip in stale {
self.op_status.remove(&ip);
}
}
self.pools_dialog.close(1);
self.action_targets = ips.clone();
@@ -1896,13 +1909,41 @@ impl App {
wx_rs::set_status_text("firmware flash in progress -- wait for it to finish");
return;
}
// A restore-to-stock is reverting + rebooting miners; a config action mid-
// revert could hit a unit in an undefined state (round 18 #12).
if self.restore.is_some() {
wx_rs::set_status_text("restore-to-stock in progress -- wait for it to finish");
return;
}
// A scan is opening its own connections to these same miners; a mutating
// action racing the scan's probe traffic can be dropped or interleaved, so
// hold it until the scan finishes (round 18 #12 -- matches the flash/restore
// invariant).
if self.scanning {
wx_rs::set_status_text("scan in progress -- wait for it to finish");
return;
}
if let Some(old) = self.action.take() {
old.stop();
// The superseded action's drain will never run again, so clear its
// miners' in-flight status or their Health cells stay frozen on the old
// "…ing" label forever (round 18 #12).
let stale = std::mem::take(&mut self.action_targets);
for ip in stale {
self.op_status.remove(&ip);
}
}
// Progress shows in each miner's Health cell (round 15 #8), not the scan
// line; the bottom-right indicator still surfaces failures at the end.
crate::logs::log(format!("apply {} to {} miner(s)", action.label(), ips.len()));
self.action_targets = ips.clone();
// Remember a password change so we can update our own saved credentials
// once it succeeds -- otherwise the toolkit keeps using the old password
// and locks itself out of the miners it just changed (round 18 #12).
self.pending_password_update = match &action {
scan::ConfigAction::ChangePassword(p) => Some(p.clone()),
_ => None,
};
self.set_op_status(&ips, &action.progress_label());
self.action = Some(scan::start_config_action(ips, action));
// Clear any stale error/warning from a previous operation; the new
@@ -1941,24 +1982,16 @@ impl App {
}
let rows = self.selected_rows();
let Some(r) = rows.first() else { return };
let (ip, brand, firmware) = (r.ip.clone(), r.brand.clone(), r.firmware.clone());
// VNish unlock password + Antminer web login: a per-firmware override
// (round 12 #13) wins, else the shipped default / saved global creds.
let vnish_pass = credentials::load_firmware_credentials()
.get("VNish")
.map(|(_, p)| p.clone())
.filter(|p| !p.is_empty())
.unwrap_or_else(|| credentials::firmware_default_for("VNish").1);
let vnish_pass = if vnish_pass.is_empty() { "admin".to_string() } else { vnish_pass };
let (am_user, am_pass) =
credentials::load_credentials().unwrap_or_else(|| ("root".into(), "root".into()));
let (ip, brand) = (r.ip.clone(), r.brand.clone());
// asic-rs read_logs() authenticates through configured_factory() (the saved
// scan credentials), so no per-firmware creds are threaded here (round 19
// #11-16). WhatsMiner's fault-code fallback is unauthenticated.
let timeout = self.scan_timeout_secs;
wx_rs::set_status_text(&format!("fetching log from {ip}..."));
let (tx, rx) = std::sync::mpsc::channel();
let ip_thread = ip.clone();
let spawned = std::thread::Builder::new().name("log-fetch".into()).spawn(move || {
let res = crate::log_scan::scan_log(
&ip_thread, &brand, &firmware, &vnish_pass, &am_user, &am_pass,
);
let res = crate::log_scan::scan_log(&ip_thread, &brand, timeout);
let _ = tx.send(res);
});
if spawned.is_err() {
@@ -2004,12 +2037,6 @@ impl App {
let frame = Widget::main_frame();
let dlg = Widget::dialog(frame, &format!("Miner log (API) -- {ip}"));
let root = Widget::box_sizer(true);
let summary = if scan.summary.is_empty() {
"(no summary)".to_string()
} else {
scan.summary.join("\n")
};
root.add(Widget::static_text(dlg, &summary), 0, sf::BORDER_ALL, 8);
let text = Widget::text_ctrl(dlg, true);
text.set_min_size(760, 420);
text.set_value(&scan.text);
@@ -2120,10 +2147,10 @@ impl App {
let mut oks = 0usize;
let mut fails: Vec<String> = Vec::new();
let mut op_clear: Vec<String> = Vec::new();
while let Ok(msg) = h.rx.try_recv() {
match msg {
restore::RestoreMsg::Started => {}
restore::RestoreMsg::Result { ip, ok, detail } => {
loop {
match h.rx.try_recv() {
Ok(restore::RestoreMsg::Started) => {}
Ok(restore::RestoreMsg::Result { ip, ok, detail }) => {
op_clear.push(ip.clone());
if ok {
oks += 1;
@@ -2131,7 +2158,17 @@ impl App {
fails.push(format!("{ip}: {detail}"));
}
}
restore::RestoreMsg::Done => done = true,
Ok(restore::RestoreMsg::Done) => {
done = true;
break;
}
Err(std::sync::mpsc::TryRecvError::Empty) => break,
// The worker thread ended without a Done (e.g. it never started):
// finalise so the restore subsystem can't wedge (round 18 #12).
Err(std::sync::mpsc::TryRecvError::Disconnected) => {
done = true;
break;
}
}
}
for ip in &op_clear {
@@ -2188,6 +2225,7 @@ impl App {
let mut done = false;
let mut changed = false;
let mut op_clear: Vec<String> = Vec::new();
let mut errors: Vec<String> = Vec::new();
loop {
match h.rx.try_recv() {
Ok(scan::AccessProbeMsg::Started { total }) => {
@@ -2196,11 +2234,17 @@ impl App {
Ok(scan::AccessProbeMsg::Result { ip, locked, error }) => {
op_clear.push(ip.clone());
if let Some(r) = self.rows.iter_mut().find(|r| r.ip == ip) {
if error.is_none() {
// Only a definitive answer updates the cell; an indeterminate
// probe (locked = None) must not blank a previously-known
// locked/unlocked state (round 18 #12).
if error.is_none() && locked.is_some() {
r.write_locked = locked;
changed = true;
}
}
if let Some(e) = &error {
errors.push(format!("{ip}: {e}"));
}
status = Some(match (&locked, &error) {
(_, Some(e)) => format!("access {ip}: {e}"),
(Some(true), _) => format!("access {ip}: locked"),
@@ -2231,6 +2275,12 @@ impl App {
}
if done {
self.access_probe = None;
// Probe errors (a miner the check could not run against) were being
// dropped entirely; surface them in the failure indicator (round 18 #12).
if !errors.is_empty() {
self.set_error_indicator(&format!("access check: {} failed", errors.len()));
crate::logs::log(format!("access check errors: {}", errors.join("; ")));
}
}
// Operation progress stays out of the bottom-left scan line (round 15 #8);
// per-miner status shows in the Health column.
@@ -2250,7 +2300,7 @@ impl App {
return None;
}
// Settings menu Language items (round 15 #13).
if (ID_LANG_BASE..ID_LANG_BASE + 6).contains(&id) {
if (ID_LANG_BASE..ID_LANG_BASE + crate::i18n::Lang::all().len() as i32).contains(&id) {
self.set_language((id - ID_LANG_BASE) as usize);
return None;
}
@@ -2259,7 +2309,9 @@ impl App {
ID_SCAN_CREDS => return Some(self.build_firmware_creds_dialog()),
ID_LOGS_OPEN => return Some(self.build_logs_dialog()),
ID_HDR_SORT_ASC | ID_HDR_SORT_DESC | ID_HDR_SORT_REL_ASC | ID_HDR_SORT_REL_DESC
| ID_HDR_HIDE | ID_HDR_AUTOSIZE | ID_HDR_COLUMNS => return self.on_header_menu(id),
| ID_HDR_HIDE | ID_HDR_AUTOSIZE | ID_HDR_AUTOSIZE_ALL | ID_HDR_COLUMNS => {
return self.on_header_menu(id)
}
ID_CTX_OPEN => {
for ip in self.selected_ip_list() {
wx_rs::launch_browser(&format!("http://{ip}"));
@@ -2272,8 +2324,8 @@ impl App {
ID_CTX_POOLS => return self.build_pools_dialog(),
ID_CTX_FLASH => {
// A flash needs exclusive hardware access; don't even prompt if
// any scan / refresh / action is running (re-checked at confirm).
if self.flashing || self.scanning || self.action.is_some() || self.refresh.is_some() {
// any scan / refresh / action / restore is running (re-checked at confirm).
if self.flashing || self.scanning || self.action.is_some() || self.refresh.is_some() || self.restore.is_some() {
wx_rs::set_status_text("busy (scan/action in progress) -- try again once it finishes");
return None;
}
@@ -2437,7 +2489,14 @@ impl App {
PromptKind::Password => format!("New web/API password for {n} miner(s):"),
};
root.add(Widget::static_text(dlg, &lbl), 0, sf::BORDER_ALL, 8);
let input = Widget::text_ctrl(dlg, false);
// The change-password prompt masks its field so the new fleet password is
// never shown in the clear (round 18 #12); the numeric/timezone prompts use
// a normal field.
let input = if matches!(kind, PromptKind::Password) {
Widget::password_ctrl(dlg)
} else {
Widget::text_ctrl(dlg, false)
};
input.set_min_size(200, -1);
root.add(input, 0, sf::EXPAND | sf::BORDER_LEFT | sf::BORDER_RIGHT, 8);
let btns = Widget::box_sizer(false);
@@ -2680,7 +2739,7 @@ impl App {
// started while the dialog was open. A flash must never race another
// network operation on the same miner, so refuse rather than run the
// prior handle's `stop()` (which does not join the in-flight upload).
if self.flashing || self.scanning || self.action.is_some() || self.refresh.is_some() {
if self.flashing || self.scanning || self.action.is_some() || self.refresh.is_some() || self.restore.is_some() {
wx_rs::set_status_text("busy (scan/action started) -- flash cancelled, try again");
return;
}
@@ -2808,6 +2867,13 @@ impl App {
for (name, user_ctrl, pass_ctrl) in &self.fwcreds_rows {
let user = user_ctrl.get_value();
let pass = pass_ctrl.get_value();
// A fully-blank row means "no override, use the shipped default" -- the
// natural way to clear one firmware's override. Without this, a blanked
// row was saved as an explicit ("","") override that then broke auth
// fleet-wide for that firmware (round 18 #12).
if user.trim().is_empty() && pass.trim().is_empty() {
continue;
}
let default = credentials::firmware_default_for(name);
if (user.clone(), pass.clone()) != default {
map.insert(name.clone(), (user, pass));
@@ -2884,6 +2950,34 @@ impl App {
} else {
Some((false, format!("apply: {}/{total} miner(s) failed", total - ok)))
});
// A password change succeeded on every target: update our own
// saved global credential so the toolkit keeps reaching them. On
// a partial change we leave saved creds alone (we can't tell which
// password now works for which miner) and warn (round 18 #12).
// (self.pending_password_update is a different field than self.action,
// so this disjoint borrow is fine while `h` still holds self.action.)
if let Some(newpass) = self.pending_password_update.take() {
if ok == total && total > 0 {
let user = credentials::load_credentials()
.map(|(u, _)| u)
.unwrap_or_else(|| "root".into());
match credentials::save_credentials(&user, &newpass) {
Ok(()) => crate::logs::log(
"saved credentials updated to the new password".to_string(),
),
Err(e) => crate::logs::log(format!(
"could not update saved credentials after password change: {e}"
)),
}
} else {
crate::logs::log(
"password change was partial -- saved credentials left unchanged; \
update Settings > Credentials manually so the toolkit can reach \
the changed miners"
.to_string(),
);
}
}
finished = true;
break;
}
@@ -3005,6 +3099,7 @@ impl App {
self.selected_ips = keep.into_iter().filter(|ip| self.target_ips.contains(ip)).collect();
self.scan_total = total;
self.scanning = true;
self.scan_stopped = false;
self.progress.gauge_set_range(total.max(1) as i32);
self.progress.gauge_set_value(0);
self.progress.show(true);
@@ -3069,7 +3164,15 @@ impl App {
}
}
if changed {
self.fill_rows();
if self.scanning {
// Still scanning: defer the whole-table refill to tick()'s ~1 Hz
// flush so streaming rows don't trigger a refill on every fast tick
// (round 18 #12).
self.rows_dirty = true;
} else {
// The scan just ended (or wasn't running): show the final state now.
self.fill_rows();
}
}
}
@@ -3089,6 +3192,13 @@ impl App {
// auto-rescan scheduler + idle status only need ~1 Hz, so run them once
// per second.
self.tick_accum = self.tick_accum.wrapping_add(1);
// Flush a scan's batched row updates at most once per second (or right away
// once the scan has ended), so the whole-table refill runs ~1 Hz during a
// scan rather than on every fast tick (round 18 #12).
if self.rows_dirty && (!self.scanning || self.tick_accum.is_multiple_of(TICKS_PER_SEC)) {
self.rows_dirty = false;
self.fill_rows();
}
if !self.tick_accum.is_multiple_of(TICKS_PER_SEC) {
return to_show;
}
@@ -3110,11 +3220,16 @@ impl App {
self.start_new_scan();
}
} else {
wx_rs::set_status_text(&format!(
"{} miners - {}",
self.rows.len(),
if self.playing { "auto-rescan off" } else { "paused" }
));
// Distinguish an explicit Stop from a Pause so the idle tick doesn't
// overwrite "Scan Stopped" with "paused" (round 19 #17).
let tail = if self.playing {
"auto-rescan off"
} else if self.scan_stopped {
"Scan Stopped"
} else {
"Scan Paused"
};
wx_rs::set_status_text(&format!("{} miners - {}", self.rows.len(), tail));
}
to_show
}
@@ -3126,12 +3241,22 @@ impl App {
/// overlap rather than block the UI by joining the old scan thread (which
/// could freeze it for up to the per-miner scan timeout); the probes target
/// live miners, so a momentary overlap is harmless.
fn begin_scan(&mut self, lines: Vec<String>) {
/// Returns whether a scan actually started (false if deferred, e.g. mid-flash),
/// so callers don't overwrite the real status with a bogus "scanning..."
/// (round 18 #12).
fn begin_scan(&mut self, lines: Vec<String>) -> bool {
// Never probe the network while a firmware flash is uploading: a stray
// scan connection to a miner mid-write can interrupt/corrupt the flash.
if self.flashing {
wx_rs::set_status_text("firmware flash in progress -- scan deferred");
return;
return false;
}
// Symmetric to start_action's scan guard: don't start a scan (including an
// auto-rescan) while a config action or restore is writing to miners, so
// the two never race on the same unit (round 18 #12).
if self.action.is_some() || self.restore.is_some() {
wx_rs::set_status_text("operation in progress -- scan deferred");
return false;
}
if let Some(old) = self.scan.take() {
old.stop();
@@ -3139,12 +3264,14 @@ impl App {
self.scan = Some(scan::start_scan(lines, self.scan_timeout_secs));
self.scanning = true;
self.countdown = 0;
true
}
/// Start a fresh scan of the saved ranges.
fn start_new_scan(&mut self) {
self.begin_scan(scan::load_ranges());
wx_rs::set_status_text("scanning...");
if self.begin_scan(scan::load_ranges()) {
wx_rs::set_status_text("scanning...");
}
}
/// The table's selection changed (ctrl/shift-click). Mirror it into the
@@ -3241,6 +3368,7 @@ impl App {
}
menu.menu_append_separator();
menu.menu_append(ID_HDR_AUTOSIZE, "Auto-size this column");
menu.menu_append(ID_HDR_AUTOSIZE_ALL, "Auto-size all columns");
// The fixed IP column can't be hidden.
if !self.view.is_fixed(col) {
menu.menu_append(ID_HDR_HIDE, &format!("Hide {}", col.title()));
@@ -3285,6 +3413,17 @@ impl App {
t.dvlc_autosize_col(pos);
}
}
// Auto-size every column to its content (round 19 #4). Done on demand
// (the columns are realised here, so the measurement is valid, unlike a
// rebuild-time autosize -- see rebuild_table). Ctrl+A selects all rows
// natively on the GtkTreeView, so this is the "resize all" companion.
ID_HDR_AUTOSIZE_ALL => {
if let Some(t) = self.table {
for pos in 0..t.dvlc_col_count() {
t.dvlc_autosize_col(pos);
}
}
}
ID_HDR_COLUMNS => return Some(self.build_columns_dialog()),
_ => {}
}
@@ -3378,6 +3517,19 @@ impl App {
to_edit.set_value(&self.scan_timeout_secs.to_string());
to_edit.set_min_size(60, -1);
auto_row.add(to_edit, 0, sf::ALIGN_CENTRE_VERTICAL | sf::BORDER_ALL, 6);
// Scan concurrency (in-flight probes): higher scans faster but can starve
// per-miner telemetry; clamped to [MIN, MAX] on apply (round 19 #25).
auto_row.add_stretch(1);
let cc_lbl = Widget::static_text(dlg, "Concurrency:");
auto_row.add(cc_lbl, 0, sf::ALIGN_CENTRE_VERTICAL | sf::BORDER_ALL, 6);
let cc_edit = Widget::text_ctrl(dlg, false);
cc_edit.set_value(&scan::load_scan_concurrency().to_string());
cc_edit.set_min_size(60, -1);
cc_edit.set_tool_tip(&format!(
"In-flight probes per scan ({}-{}). Higher is faster but can drop values on slow miners; default {}.",
scan::MIN_SCAN_CONCURRENCY, scan::MAX_SCAN_CONCURRENCY, scan::SCAN_CONCURRENCY_LIMIT
));
auto_row.add(cc_edit, 0, sf::ALIGN_CENTRE_VERTICAL | sf::BORDER_ALL, 6);
root.add_sizer(auto_row, 0, sf::EXPAND | sf::BORDER_LEFT | sf::BORDER_RIGHT, 6);
let btns = Widget::box_sizer(false);
let apply = Widget::button(dlg, "Apply", ID_RANGES_APPLY);
@@ -3390,6 +3542,7 @@ impl App {
self.ranges_edit = edit;
self.ranges_auto = auto_edit;
self.ranges_timeout = to_edit;
self.ranges_concurrency = cc_edit;
dlg
}
@@ -3420,6 +3573,10 @@ impl App {
self.scan_timeout_secs = secs.max(1);
let _ = scan::save_scan_timeout(self.scan_timeout_secs);
}
// Save the scan concurrency (round 19 #25), clamped in save_scan_concurrency.
if let Ok(n) = self.ranges_concurrency.get_value().trim().parse::<usize>() {
let _ = scan::save_scan_concurrency(n);
}
let _ = scan::save_ranges(&lines);
self.begin_scan(lines);
wx_rs::set_status_text("scanning...");
@@ -3547,20 +3704,81 @@ impl App {
/// Export the full scan data to a CSV the user picks (round 15 #14). Every
/// scanned data point is exported, one value per cell -- more complete and
/// machine-readable than the on-screen table.
fn apply_export(&mut self) {
/// Export toolbar button: open the column-picker dialog (round 19 #6), unless
/// there is nothing to export yet. Returns the dialog to show modally.
fn open_export_dialog(&mut self) -> Option<Widget> {
if self.rows.is_empty() {
wx_rs::set_status_text("nothing to export yet -- run a scan first");
return None;
}
Some(self.build_export_dialog())
}
/// A checklist of every export field (all on by default), with All/None and
/// Export/Cancel. OK -> do_export (round 19 #6).
fn build_export_dialog(&mut self) -> Widget {
let frame = Widget::main_frame();
let dlg = Widget::dialog(frame, "Export columns");
let root = Widget::box_sizer(true);
root.add(Widget::static_text(dlg, "Choose the columns to export:"), 0, sf::BORDER_ALL, 8);
let clb = Widget::check_list_box(dlg);
for name in crate::export::export_field_names() {
clb.clb_append(&name);
clb.clb_set_checked(clb.clb_count() - 1, true);
}
root.add(clb, 1, sf::EXPAND | sf::BORDER_ALL, 8);
let sel = Widget::box_sizer(false);
sel.add(Widget::button(dlg, "All", ID_EXPORT_ALL), 0, sf::BORDER_ALL, 4);
sel.add(Widget::button(dlg, "None", ID_EXPORT_NONE), 0, sf::BORDER_ALL, 4);
root.add_sizer(sel, 0, sf::BORDER_LEFT | sf::BORDER_RIGHT, 4);
let btns = Widget::box_sizer(false);
btns.add_stretch(1);
btns.add(Widget::button(dlg, "Export", ID_EXPORT_OK), 0, sf::BORDER_ALL, 6);
btns.add(Widget::button(dlg, "Cancel", ID_EXPORT_CANCEL), 0, sf::BORDER_ALL, 6);
root.add_sizer(btns, 0, sf::EXPAND | sf::BORDER_ALL, 6);
root.set_sizer_on(dlg);
dlg.set_min_size(360, 480);
dlg.fit(dlg);
self.export_dialog = dlg;
self.export_list = clb;
dlg
}
fn export_check_all(&self, checked: bool) {
let clb = self.export_list;
for i in 0..clb.clb_count() {
clb.clb_set_checked(i, checked);
}
}
/// Read the checked export fields, then save the filtered CSV. Default filename
/// carries a UTC date+time so successive exports don't collide (round 19 #5).
fn do_export(&mut self) {
let names = crate::export::export_field_names();
let clb = self.export_list;
let mut selected: HashSet<String> = HashSet::new();
for i in 0..clb.clb_count() {
if clb.clb_checked(i) {
if let Some(n) = names.get(i) {
selected.insert(n.clone());
}
}
}
self.export_dialog.close(1);
if selected.is_empty() {
wx_rs::set_status_text("no columns selected -- export cancelled");
return;
}
let default_name = format!("alkane-export-{}.csv", crate::export::timestamp_utc());
let Some(path) = Widget::save_file_dialog(
Widget::main_frame(),
"Export scan data",
"alkane-export.csv",
&default_name,
"CSV files (*.csv)|*.csv|All files (*.*)|*.*",
) else {
return; // cancelled
};
let csv = crate::export::rows_to_csv(&self.rows);
let csv = crate::export::rows_to_csv_selected(&self.rows, &selected);
match std::fs::write(&path, csv) {
Ok(()) => {
crate::logs::log(format!("exported {} miner(s) to {path}", self.rows.len()));
@@ -4072,7 +4290,11 @@ impl App {
ID_RANGES => return Some(self.build_ranges_dialog()),
ID_RANGES_APPLY => self.apply_ranges(),
ID_RANGES_CANCEL => self.ranges_dialog.close(0),
ID_EXPORT => self.apply_export(),
ID_EXPORT => return self.open_export_dialog(),
ID_EXPORT_OK => self.do_export(),
ID_EXPORT_CANCEL => self.export_dialog.close(0),
ID_EXPORT_ALL => self.export_check_all(true),
ID_EXPORT_NONE => self.export_check_all(false),
ID_SETTINGS => self.open_settings_menu(),
ID_LOGS_REFRESH => self.logs_text.set_value(&crate::logs::dump()),
ID_LOGS_CLEAR => {
@@ -4142,6 +4364,7 @@ impl App {
// Resume/start the scan loop: scan now (unless one is
// already running) + auto-rescan on.
self.playing = true;
self.scan_stopped = false;
if !self.scanning {
self.start_new_scan();
}
@@ -4149,12 +4372,14 @@ impl App {
ID_PAUSE => {
// Stop the auto-rescan loop (a scan in flight finishes).
self.playing = false;
wx_rs::set_status_text(&format!("{} miners - paused", self.rows.len()));
self.scan_stopped = false;
wx_rs::set_status_text(&format!("{} miners - Scan Paused", self.rows.len()));
}
ID_STOP => {
// Halt the loop and cancel any in-flight scan (dropping
// the receiver alone would leave the thread probing).
self.playing = false;
self.scan_stopped = true;
self.countdown = 0;
self.scanning = false;
if let Some(old) = self.scan.take() {
@@ -4162,7 +4387,7 @@ impl App {
}
self.progress.show(false);
self.table_parent.layout();
wx_rs::set_status_text(&format!("{} miners - stopped", self.rows.len()));
wx_rs::set_status_text(&format!("{} miners - Scan Stopped", self.rows.len()));
}
ID_FILTER_ALL_BASE => self.filter_check_all(true),
ID_FILTER_NONE_BASE => self.filter_check_all(false),
@@ -4193,7 +4418,7 @@ impl App {
pub fn run_fixture_selftest(&mut self) -> bool {
self.rows = crate::fixtures::bench_fleet();
self.view = ViewState::default();
self.fill_rows();
self.rebuild_table();
let mut ok = true;
let mut check = |name: &str, pass: bool, detail: String| {
@@ -4241,12 +4466,12 @@ impl App {
// Icon/dot columns (round 11 #10/#13) render shape sentinels, not
// text, so they don't round-trip to c.cell(r); they're verified
// structurally in the icon-column spot-check below.
if matches!(c, Column::Health | Column::Hashboards | Column::Locked | Column::Light | Column::Status) {
if matches!(c, Column::Health | Column::Locked | Column::Light | Column::Status) {
continue;
}
let want = c.cell(r);
let raw = t.dvlc_get_cell(disp_row, j).unwrap_or_default();
let got = if matches!(c, Column::Hashrate | Column::TotalChips | Column::ChipTemp | Column::Cooling | Column::Error | Column::Firmware) {
let got = if matches!(c, Column::Hashrate | Column::TotalChips | Column::ChipTemp | Column::Error | Column::Firmware) {
decode_segments_plain(&raw)
} else {
raw
@@ -4281,15 +4506,9 @@ impl App {
// displayed cell.
let status_of = |row: usize| -> &'static str { self.rows[self.view_idx[row]].status() };
// Icon columns (round 11 #10/#13): the store carries shape sentinels
// (dots / padlock), not text -- verify they are present.
let boards_col = cols.iter().position(|c| *c == Column::Hashboards);
// (padlock), not text -- verify they are present.
let access_col = cols.iter().position(|c| *c == Column::Locked);
let health_col = cols.iter().position(|c| *c == Column::Health);
if let (Some(bc), Some(row)) = (boards_col, find("10.255.1.166")) {
let raw = t.dvlc_get_cell(row, bc).unwrap_or_default();
check("Boards column renders dot sentinels for a mining miner",
raw.contains('\u{0007}'), format!("cell={raw:?}"));
}
// Health column (round 13 #3): the power (bolt) and control-board (brain)
// icons are always emitted, plus a chip icon per hashboard for a mining
// miner; verify the sentinels are present.
@@ -4475,15 +4694,6 @@ mod tests {
assert_eq!(temp_color(&p, 65.0), tint_toward(p.accent, p.red, 0.5), "midpoint blend");
}
#[test]
fn fan_color_grey_to_blue_scale() {
let p = test_pal();
assert_eq!(fan_color(&p, 0.0), p.label, "stopped fan -> grey label colour");
assert_eq!(fan_color(&p, 6000.0), p.accent, "at/above ceiling -> saturated accent blue");
assert_eq!(fan_color(&p, 12000.0), p.accent, "clamped above the ceiling");
assert_eq!(fan_color(&p, 3000.0), tint_toward(p.label, p.accent, 0.5), "halfway blend");
}
#[test]
fn combined_cell_unknown_actual_is_not_coloured_red() {
let p = test_pal();
@@ -4512,23 +4722,4 @@ mod tests {
let actual_only = encode_combined_cell(&p, Some("95.0T".to_string()), None, "/", None);
assert_eq!(decode_segments_plain(&actual_only), "95.0T");
}
#[test]
fn cooling_cell_colours_each_fan_with_black_slashes() {
let p = test_pal();
assert_eq!(
decode_segments_plain(&encode_cooling_cell(&p, &[4800.0, 4600.0])),
"4.8k/4.6k",
);
// Slash segments carry no colour (they render in the default text colour).
let encoded = encode_cooling_cell(&p, &[4800.0, 4600.0]);
let expected = encode_segments(&[
(Some(fan_color(&p, 4800.0)), format_fan_rpm(4800.0)),
(None, "/".to_string()),
(Some(fan_color(&p, 4600.0)), format_fan_rpm(4600.0)),
]);
assert_eq!(encoded, expected);
// No fans -> a single empty segment that decodes to "".
assert_eq!(decode_segments_plain(&encode_cooling_cell(&p, &[])), "");
}
}
+1 -1
View File
@@ -17,7 +17,7 @@ ignore = [
[licenses]
version = 2
# The project is MIT OR Apache-2.0; only permissive licenses are allowed in the
# The project is MIT; only permissive licenses are allowed in the
# dependency tree.
allow = [
"MIT",
@@ -0,0 +1,233 @@
Subject: [PATCH 0023] telemetry: PSU serial + chip/hashboard type + best-share
Round 19 #10 telemetry extension (tier 1 -- struct-only, no new DataField, and
every command read is already fetched so there are no extra round-trips):
- PsuInfo gains a `serial` field. Braiins v26_04 parse_psu is corrected to read
the human model_name and the firmware fw_version (it had used the numeric type
code as the model and dropped fw_version entirely) and to capture serial_number.
ePIC and WhatsMiner v1/v2 report no PSU serial (left None).
- BoardData gains `chip_type` (ASIC model, e.g. "BM1370") and `hashboard_model`
(e.g. "A3HB70601"). Braiins miner/hw/hashboards populates both.
- best_share (all-time) wired for Antminer v2020 and WhatsMiner v1/v2 from the
already-fetched cgminer/btminer `summary` "Best Share"; those backends had the
empty default GetBestShare (v2023_07 already had it).
Existing fixture tests for braiins/antminer/whatsminer pass unchanged.
diff --git a/vendor/asic-rs-core/src/data/board.rs b/vendor/asic-rs-core/src/data/board.rs
index 1a2c5ead..32ce4e6a 100644
--- a/vendor/asic-rs-core/src/data/board.rs
+++ b/vendor/asic-rs-core/src/data/board.rs
@@ -90,6 +90,12 @@ pub struct BoardData {
pub tuned: Option<bool>,
/// Whether this board is enabled and actively mining
pub active: Option<bool>,
+ /// The ASIC chip type/model on this board (e.g. "BM1370"), when reported.
+ /// Not exposed by Antminer/LuxOS (their network API reports only the control
+ /// board type).
+ pub chip_type: Option<String>,
+ /// The hashboard model / part identifier (e.g. "A3HB70601"), when reported.
+ pub hashboard_model: Option<String>,
}
impl BoardData {
diff --git a/vendor/asic-rs-core/src/data/psu.rs b/vendor/asic-rs-core/src/data/psu.rs
index 810ba47c..cb73b23e 100644
--- a/vendor/asic-rs-core/src/data/psu.rs
+++ b/vendor/asic-rs-core/src/data/psu.rs
@@ -19,6 +19,8 @@ pub struct PsuInfo {
pub model: Option<String>,
/// PSU firmware/hardware version, when reported.
pub version: Option<String>,
+ /// PSU serial number, when reported (Braiins, WhatsMiner V3, VNish).
+ pub serial: Option<String>,
/// Minimum rated output voltage in volts, when reported.
pub voltage_min: Option<f64>,
/// Maximum rated output voltage in volts, when reported.
diff --git a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
index bd8662b1..63f819f8 100644
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
@@ -499,6 +499,16 @@ impl GetDataLocations for AntMinerV2020 {
tag: None,
},
)],
+ // cgminer summary "Best Share" (all-time). RPC_SUMMARY is already
+ // fetched, so this adds no round-trip (round 19 #10).
+ DataField::BestShare => vec![(
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0/Best Share"),
+ tag: None,
+ },
+ )],
// `total_rateideal`, by contrast, says nothing about its own
// scale, so carry STATS' `rate_unit` alongside it.
DataField::ExpectedHashrate => vec![
@@ -873,7 +883,13 @@ impl GetUptime for AntMinerV2020 {
}
}
-impl GetBestShare for AntMinerV2020 {}
+impl GetBestShare for AntMinerV2020 {
+ fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ // cgminer summary "Best Share" (all-time); guard against a 0 placeholder
+ // (round 19 #10).
+ data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
+ }
+}
impl GetSessionBestShare for AntMinerV2020 {}
impl GetOperatingState for AntMinerV2020 {}
diff --git a/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs b/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs
index 9b72ed94..22e34b0b 100644
--- a/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs
+++ b/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs
@@ -498,6 +498,16 @@ impl GetHashboards for BraiinsV2604 {
.and_then(|v| v.as_f64())
.map(Frequency::from_hertz);
board.active = chain.pointer("/enabled").and_then(|v| v.as_bool());
+ // ASIC chip model + hashboard model/part (round 19 #10 telemetry
+ // extension). BOS+ miner/hw/hashboards reports chip_type ("BM1370")
+ // and model ("A3HB70601"); board_name is the human label if present.
+ board.chip_type =
+ chain.pointer("/chip_type").and_then(|v| v.as_str()).map(str::to_string);
+ board.hashboard_model = chain
+ .pointer("/model")
+ .or_else(|| chain.pointer("/board_name"))
+ .and_then(|v| v.as_str())
+ .map(str::to_string);
}
hashboards
@@ -676,13 +686,15 @@ impl GetWattage for BraiinsV2604 {
}
fn parse_psu(&self, data: &HashMap<DataField, Value>) -> Option<PsuInfo> {
- // BOS miner/details -> psu_info {version, min_voltage.volt, max_voltage.volt}.
- // "version" is the PSU type code (117 = the APW12 ePIC also reports as model
- // 117), so expose it as the model for consistency across firmwares.
+ // BOS miner/details -> psu_info { model_name, fw_version, serial_number,
+ // version (numeric type code), min_voltage.volt, max_voltage.volt }. Read
+ // the human model_name and the firmware version (the old code used the
+ // numeric "version" type code as the model and dropped fw_version entirely).
let d = data.get(&DataField::Psu)?;
let psu = PsuInfo {
- model: d.pointer("/version").and_then(|v| v.as_i64()).map(|n| n.to_string()),
- version: None,
+ model: d.pointer("/model_name").and_then(|v| v.as_str()).map(str::to_string),
+ version: d.pointer("/fw_version").and_then(|v| v.as_i64()).map(|n| n.to_string()),
+ serial: d.pointer("/serial_number").and_then(|v| v.as_str()).map(str::to_string),
voltage_min: d.pointer("/min_voltage/volt").and_then(|v| v.as_f64()),
voltage_max: d.pointer("/max_voltage/volt").and_then(|v| v.as_f64()),
output_voltage: None,
diff --git a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
index 3365824d..7238dc27 100644
--- a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
@@ -1128,6 +1128,7 @@ impl GetWattage for PowerPlayV1 {
let psu = PsuInfo {
model: f(info, "/PSU Type").map(|n| format!("{n:.0}")),
version: f(info, "/FW").map(|n| format!("{n:.0}")),
+ serial: None, // ePIC capabilities does not report a PSU serial
voltage_min: f(info, "/Min Vout").map(|mv| mv / 1000.0),
voltage_max: f(info, "/Max Vout").map(|mv| mv / 1000.0),
output_voltage: f(stats, "/Output Voltage"),
diff --git a/vendor/asic-rs-firmwares-sealminer/src/backends/v2025/mod.rs b/vendor/asic-rs-firmwares-sealminer/src/backends/v2025/mod.rs
index 9617da70..f71750e1 100644
--- a/vendor/asic-rs-firmwares-sealminer/src/backends/v2025/mod.rs
+++ b/vendor/asic-rs-firmwares-sealminer/src/backends/v2025/mod.rs
@@ -474,6 +474,7 @@ impl GetHashboards for SealMinerV2025 {
frequency: freq,
tuned,
active: Some(online),
+ ..Default::default()
}
})
.collect()
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
index 3c8512ad..eb2bdad8 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
@@ -244,6 +244,16 @@ impl GetDataLocations for WhatsMinerV1 {
tag: None,
},
)],
+ // btminer summary "Best Share" (all-time); RPC_SUMMARY already fetched
+ // (round 19 #10).
+ DataField::BestShare => vec![(
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0/Best Share"),
+ tag: None,
+ },
+ )],
DataField::ExpectedHashrate => vec![(
RPC_SUMMARY,
DataExtractor {
@@ -483,6 +493,7 @@ impl GetWattage for WhatsMinerV1 {
let psu = PsuInfo {
model: s("/model").or_else(|| s("/name")),
version: s("/hw_version").or_else(|| s("/sw_version")),
+ serial: None, // v1/v2 get_psu does not report a serial (V3 does)
voltage_min: None,
voltage_max: None,
output_voltage: None,
@@ -548,7 +559,11 @@ impl GetUptime for WhatsMinerV1 {
}
}
-impl GetBestShare for WhatsMinerV1 {}
+impl GetBestShare for WhatsMinerV1 {
+ fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
+ }
+}
impl GetSessionBestShare for WhatsMinerV1 {}
impl GetOperatingState for WhatsMinerV1 {}
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
index de36a126..5de37579 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
@@ -255,6 +255,16 @@ impl GetDataLocations for WhatsMinerV2 {
tag: None,
},
)],
+ // btminer summary "Best Share" (all-time); RPC_SUMMARY already fetched
+ // (round 19 #10).
+ DataField::BestShare => vec![(
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0/Best Share"),
+ tag: None,
+ },
+ )],
DataField::ExpectedHashrate => vec![(
RPC_SUMMARY,
DataExtractor {
@@ -490,6 +500,7 @@ impl GetWattage for WhatsMinerV2 {
let psu = PsuInfo {
model: s("/model").or_else(|| s("/name")),
version: s("/hw_version").or_else(|| s("/sw_version")),
+ serial: None, // v1/v2 get_psu does not report a serial (V3 does)
voltage_min: None,
voltage_max: None,
output_voltage: None,
@@ -577,7 +588,11 @@ impl GetUptime for WhatsMinerV2 {
}
}
-impl GetBestShare for WhatsMinerV2 {}
+impl GetBestShare for WhatsMinerV2 {
+ fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
+ }
+}
impl GetSessionBestShare for WhatsMinerV2 {}
impl GetOperatingState for WhatsMinerV2 {}
@@ -0,0 +1,93 @@
Subject: [PATCH 0024] whatsminer v3 PSU serial + epic chip/hashboard type
Round 19 #10 telemetry extension, tier 1 sub-batch B. Both fields ride existing
DataFields (Psu / Hashboards) on commands the collector already fetches, so there
are no extra round-trips, and both reuse the PsuInfo.serial and
BoardData.chip_type/hashboard_model fields added in patch 0023 -- no core or GUI
change, the existing columns just populate for more firmwares.
- WhatsMiner V3: add a DataField::Psu location (get.device.info /msg/power) and a
parse_psu that reads model/type, sw/hwversion and the serial (sn). V3 carried
no PSU parse at all (default None) even though /msg/power is already fetched for
the PSU fan.
- ePIC: parse_hashboards now reads capabilities "Chip Type" (e.g. "BM1366") and
"Model Subtype" (e.g. "BHB56801") and applies them to every board (capabilities
reports them miner-wide). The capabilities command is already fetched for
hashboards.
Existing fixture tests for whatsminer/epic pass unchanged.
diff --git a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
index 7238dc27..2abb0706 100644
--- a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
@@ -797,6 +797,21 @@ impl GetHashboards for PowerPlayV1 {
.pointer("/Capabilities/Performance Estimator/Hashes Per Second Per Chip")
.and_then(|v| v.as_f64());
+ // ASIC chip type + hashboard model from capabilities (round 19 #10);
+ // capabilities reports them miner-wide, so apply to every board.
+ let chip_type =
+ api_data.pointer("/Capabilities/Chip Type").and_then(|v| v.as_str()).map(str::to_string);
+ let hashboard_model = api_data
+ .pointer("/Capabilities/Model Subtype")
+ .and_then(|v| v.as_str())
+ .map(str::to_string);
+ if chip_type.is_some() || hashboard_model.is_some() {
+ for board in &mut hashboards {
+ board.chip_type = chip_type.clone();
+ board.hashboard_model = hashboard_model.clone();
+ }
+ }
+
// Active status
if let Some(boards) = api_data
.pointer("/Summary/HBStatus")
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
index c00c6d44..930abe38 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
@@ -21,6 +21,7 @@ use asic_rs_core::{
message::{MessageSeverity, MinerMessage},
miner::{MiningMode, TuningTarget},
pool::{PoolData, PoolGroupData, PoolURL},
+ psu::PsuInfo,
},
traits::{miner::*, model::MinerModel},
util::is_expected_write_error,
@@ -235,6 +236,16 @@ impl GetDataLocations for WhatsMinerV3 {
tag: None,
},
)],
+ // PSU identity block (round 19 #10): get.device.info /msg/power carries
+ // model/type, sw/hwversion and the serial (sn). Already fetched.
+ DataField::Psu => vec![(
+ RPC_GET_DEVICE_INFO,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/msg/power"),
+ tag: None,
+ },
+ )],
DataField::Hashboards => vec![
(
RPC_GET_DEVICE_INFO,
@@ -509,6 +520,18 @@ impl GetWattage for WhatsMinerV3 {
fn parse_wattage(&self, data: &HashMap<DataField, Value>) -> Option<Power> {
data.extract_map::<f64, _>(DataField::Wattage, Power::from_watts)
}
+ fn parse_psu(&self, data: &HashMap<DataField, Value>) -> Option<PsuInfo> {
+ // get.device.info /msg/power: model/type, sw/hwversion, sn (round 19 #10).
+ let d = data.get(&DataField::Psu)?;
+ let s = |k: &str| d.pointer(k).and_then(|v| v.as_str()).filter(|s| !s.is_empty()).map(str::to_string);
+ let psu = PsuInfo {
+ model: s("/model").or_else(|| s("/type")),
+ version: s("/swversion").or_else(|| s("/hwversion")),
+ serial: s("/sn"),
+ ..Default::default()
+ };
+ (psu != PsuInfo::default()).then_some(psu)
+ }
}
/// Parses tuning target from V3 tagged data (mode from get.device.info, limit from summary).
/// Mode "0" (Low) / "2" (High) → MiningMode, "1" (Normal) / unknown → Power(limit).
@@ -0,0 +1,491 @@
Subject: [PATCH 0025] telemetry: rolling average hashrate windows (1m/5m/15m/24h)
Round 19 #10 telemetry extension, tier 2. Exposes the rolling average hashrate
windows the GUI wanted (1m/5m/15m/24h).
- New HashrateAverages sub-struct (data/hashrate.rs): avg_1m/5m/15m/24h, each an
Option<HashRate> carrying the same unit and algorithm as the current hashrate.
- New DataField::HashrateAverages; MinerData gains hashrate_averages.
- The windows ride the EXISTING GetHashrate trait via a defaulted
parse_hashrate_averages method (default None), so no new supertrait bound and no
empty impl per backend; only backends that expose the data override it, and
parse_data wires it in.
- Backends (each reads a command the collector already fetches, so no extra
round-trips; each window is filtered to > 0 and the struct is dropped when every
window is absent):
- WhatsMiner V1: btminer summary MHS 1m/5m/15m (MegaHash); no 24h.
- WhatsMiner V3: get.miner.status summary hash-1min / hash-15min (TeraHash).
- LuxOS: summary GHS 1m/5m/15m/24h (GigaHash) -- full window set.
- Braiins v25_07 + v26_04: miner_stats real_hashrate last_1m/5m/15m/24h.
- Antminer, WhatsMiner V2, ePIC, VNish, sealminer expose no standard 1/5/15
window (fixtures confirm) and inherit None.
Fixture tests for whatsminer v1 and braiins v26_04 assert the parsed windows.
diff --git a/vendor/asic-rs-core/src/data/collector.rs b/vendor/asic-rs-core/src/data/collector.rs
index d1456548..5899c039 100644
--- a/vendor/asic-rs-core/src/data/collector.rs
+++ b/vendor/asic-rs-core/src/data/collector.rs
@@ -56,6 +56,9 @@ pub enum DataField {
/// Expected hashrate for the miner.
#[cfg_attr(feature = "python", pydantic(value = "ExpectedHashrate"))]
ExpectedHashrate,
+ /// Rolling average hashrate windows (1m/5m/15m/24h) reported by the miner.
+ #[cfg_attr(feature = "python", pydantic(value = "HashrateAverages"))]
+ HashrateAverages,
/// Fan speed or fan configuration.
#[cfg_attr(feature = "python", pydantic(value = "Fans"))]
Fans,
diff --git a/vendor/asic-rs-core/src/data/hashrate.rs b/vendor/asic-rs-core/src/data/hashrate.rs
index 3e3ff9ab..6107745d 100644
--- a/vendor/asic-rs-core/src/data/hashrate.rs
+++ b/vendor/asic-rs-core/src/data/hashrate.rs
@@ -318,3 +318,32 @@ impl Div<HashRate> for Power {
self.as_watts() / hash_rate.value
}
}
+
+/// Rolling average hashrate over standard time windows, as reported by firmware.
+///
+/// Each window is optional; a backend fills in only the windows its firmware
+/// exposes. The 24h window is reported by Braiins only. Every value carries the
+/// same unit and mining algorithm as the miner's current hashrate.
+#[cfg_attr(feature = "python", pyclass(from_py_object, module = "asic_rs"))]
+#[cfg_attr(feature = "python", asic_rs_pydantic::py_pydantic_model(getters))]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default, TS)]
+pub struct HashrateAverages {
+ /// Average hashrate over the last minute, when reported.
+ pub avg_1m: Option<HashRate>,
+ /// Average hashrate over the last 5 minutes, when reported.
+ pub avg_5m: Option<HashRate>,
+ /// Average hashrate over the last 15 minutes, when reported.
+ pub avg_15m: Option<HashRate>,
+ /// Average hashrate over the last 24 hours, when reported (Braiins only).
+ pub avg_24h: Option<HashRate>,
+}
+
+impl HashrateAverages {
+ /// True when no window is populated.
+ pub fn is_empty(&self) -> bool {
+ self.avg_1m.is_none()
+ && self.avg_5m.is_none()
+ && self.avg_15m.is_none()
+ && self.avg_24h.is_none()
+ }
+}
diff --git a/vendor/asic-rs-core/src/data/miner.rs b/vendor/asic-rs-core/src/data/miner.rs
index b2b8a578..38c7f3be 100644
--- a/vendor/asic-rs-core/src/data/miner.rs
+++ b/vendor/asic-rs-core/src/data/miner.rs
@@ -12,7 +12,7 @@ use super::{
capabilities::TuningCapabilities,
device::DeviceInfo,
fan::FanData,
- hashrate::HashRate,
+ hashrate::{HashRate, HashrateAverages},
message::MinerMessage,
operating_state::OperatingState,
pool::PoolGroupData,
@@ -165,6 +165,8 @@ pub struct MinerData {
pub hashboards: Vec<BoardData>,
/// The current hashrate of the miner
pub hashrate: Option<HashRate>,
+ /// Rolling average hashrate windows (1m/5m/15m/24h), when reported
+ pub hashrate_averages: Option<HashrateAverages>,
/// The expected hashrate of the miner
pub expected_hashrate: Option<HashRate>,
/// The total expected number of chips across all boards on this miner
diff --git a/vendor/asic-rs-core/src/traits/miner.rs b/vendor/asic-rs-core/src/traits/miner.rs
index db1ba653..cfabb624 100644
--- a/vendor/asic-rs-core/src/traits/miner.rs
+++ b/vendor/asic-rs-core/src/traits/miner.rs
@@ -28,7 +28,7 @@ use crate::{
device::DeviceInfo,
fan::FanData,
firmware::{FirmwareImage, FirmwareStats},
- hashrate::{HashRate, HashRateUnit},
+ hashrate::{HashRate, HashRateUnit, HashrateAverages},
message::MinerMessage,
miner::{MinerData, TuningTarget},
operating_state::OperatingState,
@@ -271,6 +271,7 @@ impl<
let control_board_version = self.parse_control_board_version(&data);
let uptime = self.parse_uptime(&data);
let hashrate = self.parse_hashrate(&data);
+ let hashrate_averages = self.parse_hashrate_averages(&data);
let expected_hashrate = self.parse_expected_hashrate(&data);
let wattage = self.parse_wattage(&data);
let psu = self.parse_psu(&data);
@@ -353,6 +354,7 @@ impl<
expected_hashboards: device_info.hardware.board_count(),
hashboards,
hashrate,
+ hashrate_averages,
expected_hashrate,
// Chip information
@@ -632,6 +634,20 @@ pub trait GetHashrate: CollectData {
fn parse_hashrate(&self, data: &HashMap<DataField, Value>) -> Option<HashRate> {
None
}
+ #[tracing::instrument(level = "debug")]
+ async fn get_hashrate_averages(&self) -> Option<HashrateAverages> {
+ let mut collector = self.get_collector();
+ let data = collector
+ .collect(&[DataField::HashrateAverages, DataField::Hashrate])
+ .await;
+ self.parse_hashrate_averages(&data)
+ }
+ /// Rolling average hashrate windows. Backends that expose them override this;
+ /// the values carry the same unit and algorithm as the current hashrate.
+ #[allow(unused_variables)]
+ fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
+ None
+ }
}
// Expected Hashrate
diff --git a/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs b/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs
index 57c0c2c7..7e07967f 100644
--- a/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs
+++ b/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs
@@ -16,7 +16,7 @@ use asic_rs_core::{
command::MinerCommand,
device::{DeviceInfo, HashAlgorithm},
fan::FanData,
- hashrate::{HashRate, HashRateUnit},
+ hashrate::{HashRate, HashRateUnit, HashrateAverages},
message::{MessageSeverity, MinerMessage},
miner::TuningTarget,
operating_state::OperatingState,
@@ -204,6 +204,16 @@ impl GetDataLocations for BraiinsV2507 {
tag: None,
},
)],
+ // Rolling averages from miner_stats real_hashrate (round 19 #10, T2);
+ // command already fetched. Braiins reports the full 1m/5m/15m/24h set.
+ DataField::HashrateAverages => vec![(
+ WEB_MINER_STATS,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/miner_stats/real_hashrate"),
+ tag: None,
+ },
+ )],
DataField::ExpectedHashrate => vec![(
WEB_MINER_DETAILS,
DataExtractor {
@@ -494,6 +504,31 @@ impl GetHashrate for BraiinsV2507 {
.as_unit(HashRateUnit::default())
})
}
+ fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
+ // miner_stats real_hashrate last_1m/5m/15m/24h (GigaHash); full window set
+ // (round 19 #10).
+ let d = data.get(&DataField::HashrateAverages)?;
+ let ghs = |k: &str| {
+ d.pointer(&format!("/{k}/gigahash_per_second"))
+ .and_then(|v| v.as_f64())
+ .filter(|&f| f > 0.0)
+ .map(|f| {
+ HashRate {
+ value: f,
+ unit: HashRateUnit::GigaHash,
+ algo: self.device_info.algo,
+ }
+ .as_unit(HashRateUnit::default())
+ })
+ };
+ let avgs = HashrateAverages {
+ avg_1m: ghs("last_1m"),
+ avg_5m: ghs("last_5m"),
+ avg_15m: ghs("last_15m"),
+ avg_24h: ghs("last_24h"),
+ };
+ (!avgs.is_empty()).then_some(avgs)
+ }
}
impl GetExpectedHashrate for BraiinsV2507 {
diff --git a/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs b/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs
index 22e34b0b..2f5be88c 100644
--- a/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs
+++ b/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs
@@ -17,7 +17,7 @@ use asic_rs_core::{
device::{DeviceInfo, HashAlgorithm},
fan::FanData,
firmware::{FirmwareStats, FirmwareUpdate},
- hashrate::{HashRate, HashRateUnit},
+ hashrate::{HashRate, HashRateUnit, HashrateAverages},
message::{MessageSeverity, MinerMessage},
miner::TuningTarget,
operating_state::OperatingState,
@@ -207,6 +207,16 @@ impl GetDataLocations for BraiinsV2604 {
tag: None,
},
)],
+ // Rolling averages from miner_stats real_hashrate (round 19 #10, T2);
+ // command already fetched. Braiins reports the full 1m/5m/15m/24h set.
+ DataField::HashrateAverages => vec![(
+ WEB_MINER_STATS,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/miner_stats/real_hashrate"),
+ tag: None,
+ },
+ )],
DataField::ExpectedHashrate => vec![(
WEB_MINER_DETAILS,
DataExtractor {
@@ -525,6 +535,31 @@ impl GetHashrate for BraiinsV2604 {
.as_unit(HashRateUnit::default())
})
}
+ fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
+ // miner_stats real_hashrate last_1m/5m/15m/24h (GigaHash); full window set
+ // (round 19 #10).
+ let d = data.get(&DataField::HashrateAverages)?;
+ let ghs = |k: &str| {
+ d.pointer(&format!("/{k}/gigahash_per_second"))
+ .and_then(|v| v.as_f64())
+ .filter(|&f| f > 0.0)
+ .map(|f| {
+ HashRate {
+ value: f,
+ unit: HashRateUnit::GigaHash,
+ algo: self.device_info.algo,
+ }
+ .as_unit(HashRateUnit::default())
+ })
+ };
+ let avgs = HashrateAverages {
+ avg_1m: ghs("last_1m"),
+ avg_5m: ghs("last_5m"),
+ avg_15m: ghs("last_15m"),
+ avg_24h: ghs("last_24h"),
+ };
+ (!avgs.is_empty()).then_some(avgs)
+ }
}
impl GetExpectedHashrate for BraiinsV2604 {
@@ -1241,6 +1276,17 @@ mod tests {
assert_eq!(miner_data.pools[0].len(), 2);
assert!(miner_data.hashrate.is_some());
assert!(miner_data.expected_hashrate.is_some());
+ // Rolling averages: miner_stats real_hashrate last_1m/5m/15m/24h (GigaHash);
+ // Braiins reports the full window set (round 19 #10, T2).
+ let avgs = miner_data
+ .hashrate_averages
+ .expect("braiins exposes rolling averages");
+ assert!(avgs.avg_1m.is_some() && avgs.avg_5m.is_some());
+ assert!(avgs.avg_15m.is_some() && avgs.avg_24h.is_some());
+ if let Some(hr) = &avgs.avg_1m {
+ assert_eq!(hr.unit, HashRateUnit::TeraHash);
+ assert!((hr.value - 247.3507543407177).abs() < 1e-3);
+ }
}
#[test]
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 b5a5a73c..a75a3f97 100644
--- a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
@@ -16,7 +16,7 @@ use asic_rs_core::{
command::MinerCommand,
device::{DeviceInfo, HashAlgorithm},
fan::FanData,
- hashrate::{HashRate, HashRateUnit},
+ hashrate::{HashRate, HashRateUnit, HashrateAverages},
message::{MessageSeverity, MinerMessage},
miner::TuningTarget,
pool::{PoolData, PoolGroupData, PoolURL},
@@ -537,6 +537,16 @@ impl GetDataLocations for LuxMinerV1 {
tag: None,
},
)],
+ // LuxOS summary exposes full rolling windows GHS 1m/5m/15m/24h
+ // (GigaHash); RPC_SUMMARY is already fetched (round 19 #10, T2).
+ DataField::HashrateAverages => vec![(
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0"),
+ tag: None,
+ },
+ )],
DataField::ExpectedHashrate => vec![(
RPC_DEVS,
DataExtractor {
@@ -843,6 +853,30 @@ impl GetHashrate for LuxMinerV1 {
.as_unit(HashRateUnit::default())
})
}
+ fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
+ // LuxOS summary GHS 1m/5m/15m/24h (GigaHash); full window set (round 19 #10).
+ let d = data.get(&DataField::HashrateAverages)?;
+ let ghs = |k: &str| {
+ d.pointer(k)
+ .and_then(|v| v.as_f64())
+ .filter(|&f| f > 0.0)
+ .map(|f| {
+ HashRate {
+ value: f,
+ unit: HashRateUnit::GigaHash,
+ algo: self.device_info.algo,
+ }
+ .as_unit(HashRateUnit::default())
+ })
+ };
+ let avgs = HashrateAverages {
+ avg_1m: ghs("/GHS 1m"),
+ avg_5m: ghs("/GHS 5m"),
+ avg_15m: ghs("/GHS 15m"),
+ avg_24h: ghs("/GHS 24h"),
+ };
+ (!avgs.is_empty()).then_some(avgs)
+ }
}
impl GetExpectedHashrate for LuxMinerV1 {
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
index eb2bdad8..584ae8d1 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
@@ -14,7 +14,7 @@ use asic_rs_core::{
command::MinerCommand,
device::{DeviceInfo, HashAlgorithm},
fan::FanData,
- hashrate::{HashRate, HashRateUnit},
+ hashrate::{HashRate, HashRateUnit, HashrateAverages},
message::{MessageSeverity, MinerMessage},
miner::TuningTarget,
pool::{PoolData, PoolGroupData, PoolURL},
@@ -244,6 +244,16 @@ impl GetDataLocations for WhatsMinerV1 {
tag: None,
},
)],
+ // Rolling average windows from btminer summary (round 19 #10, T2);
+ // RPC_SUMMARY is already fetched.
+ DataField::HashrateAverages => vec![(
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0"),
+ tag: None,
+ },
+ )],
// btminer summary "Best Share" (all-time); RPC_SUMMARY already fetched
// (round 19 #10).
DataField::BestShare => vec![(
@@ -429,6 +439,30 @@ impl GetHashrate for WhatsMinerV1 {
.as_unit(HashRateUnit::default())
})
}
+ fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
+ // btminer summary MHS 1m/5m/15m (MegaHash); no 24h window (round 19 #10).
+ let d = data.get(&DataField::HashrateAverages)?;
+ let mhs = |k: &str| {
+ d.pointer(k)
+ .and_then(|v| v.as_f64())
+ .filter(|&f| f > 0.0)
+ .map(|f| {
+ HashRate {
+ value: f,
+ unit: HashRateUnit::MegaHash,
+ algo: self.device_info.algo,
+ }
+ .as_unit(HashRateUnit::default())
+ })
+ };
+ let avgs = HashrateAverages {
+ avg_1m: mhs("/MHS 1m"),
+ avg_5m: mhs("/MHS 5m"),
+ avg_15m: mhs("/MHS 15m"),
+ avg_24h: None,
+ };
+ (!avgs.is_empty()).then_some(avgs)
+ }
}
impl GetExpectedHashrate for WhatsMinerV1 {
fn parse_expected_hashrate(&self, data: &HashMap<DataField, Value>) -> Option<HashRate> {
@@ -924,6 +958,17 @@ mod integration_tests {
algo: HashAlgorithm::SHA256,
})
);
+ // Rolling averages: btminer summary MHS 1m/5m/15m (MegaHash), no 24h window
+ // (round 19 #10, T2).
+ let avgs = miner_data
+ .hashrate_averages
+ .ok_or_else(|| anyhow::anyhow!("v1 should expose rolling averages"))?;
+ assert!(avgs.avg_1m.is_some() && avgs.avg_5m.is_some() && avgs.avg_15m.is_some());
+ assert!(avgs.avg_24h.is_none());
+ if let Some(hr) = &avgs.avg_1m {
+ assert_eq!(hr.unit, HashRateUnit::TeraHash);
+ assert!((hr.value - 67.43935249).abs() < 1e-6);
+ }
assert_eq!(miner_data.wattage, Some(Power::from_watts(3417f64)));
assert_eq!(
miner_data.tuning_target,
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
index 930abe38..04608936 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
@@ -17,7 +17,7 @@ use asic_rs_core::{
command::MinerCommand,
device::{DeviceInfo, HashAlgorithm},
fan::FanData,
- hashrate::{HashRate, HashRateUnit},
+ hashrate::{HashRate, HashRateUnit, HashrateAverages},
message::{MessageSeverity, MinerMessage},
miner::{MiningMode, TuningTarget},
pool::{PoolData, PoolGroupData, PoolURL},
@@ -296,6 +296,16 @@ impl GetDataLocations for WhatsMinerV3 {
tag: None,
},
)],
+ // Rolling averages from get.miner.status summary (round 19 #10, T2);
+ // command already fetched. V3 exposes 1min and 15min only.
+ DataField::HashrateAverages => vec![(
+ rpc_get_miner_status_summary,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/msg/summary"),
+ tag: None,
+ },
+ )],
DataField::ExpectedHashrate => vec![(
rpc_get_miner_status_summary,
DataExtractor {
@@ -465,6 +475,31 @@ impl GetHashrate for WhatsMinerV3 {
.as_unit(HashRateUnit::default())
})
}
+ fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
+ // get.miner.status summary hash-1min / hash-15min (TeraHash); V3 reports
+ // no 5m or 24h window (round 19 #10).
+ let d = data.get(&DataField::HashrateAverages)?;
+ let ths = |k: &str| {
+ d.pointer(k)
+ .and_then(|v| v.as_f64())
+ .filter(|&f| f > 0.0)
+ .map(|f| {
+ HashRate {
+ value: f,
+ unit: HashRateUnit::TeraHash,
+ algo: self.device_info.algo,
+ }
+ .as_unit(HashRateUnit::default())
+ })
+ };
+ let avgs = HashrateAverages {
+ avg_1m: ths("/hash-1min"),
+ avg_5m: None,
+ avg_15m: ths("/hash-15min"),
+ avg_24h: None,
+ };
+ (!avgs.is_empty()).then_some(avgs)
+ }
}
impl GetExpectedHashrate for WhatsMinerV3 {
fn parse_expected_hashrate(&self, data: &HashMap<DataField, Value>) -> Option<HashRate> {
@@ -0,0 +1,399 @@
Subject: [PATCH 0026] telemetry: cumulative share stats (difficulty acc/rej, stale, blocks)
Round 19 #10 telemetry extension, tier 2b. Exposes the cumulative share
statistics the GUI wanted: difficulty-weighted accepted/rejected work, raw stale
share count, and blocks found.
- New ShareSummary sub-struct (data/share.rs) + parse_cgminer_share_summary helper
that reads a cgminer/btminer SUMMARY[0] object ("Difficulty Accepted",
"Difficulty Rejected", "Stale", "Found Blocks").
- New DataField::ShareSummary; MinerData gains share_summary.
- Rides the EXISTING GetBestShare trait via a defaulted parse_share_summary method
(default None), so no new supertrait bound and no empty impl per backend; only
the cgminer-family backends override it. parse_data wires it in.
- Backends (each reads the SUMMARY the collector already fetches, so no extra
round-trips): Antminer v2020 + v2023_07, LuxOS, WhatsMiner V1 + V2. These are
miner-level aggregates, not per-pool, so they are top-level MinerData fields (the
per-pool accepted/rejected share counts stay on PoolData). Braiins does not
expose cumulative difficulty; ePIC reports only the current difficulty target;
WhatsMiner V3 and VNish expose none -> all inherit None.
Fixture tests for whatsminer v1 and antminer v2020 assert the parsed values.
diff --git a/vendor/asic-rs-core/src/data/collector.rs b/vendor/asic-rs-core/src/data/collector.rs
index 5899c039..942b39f6 100644
--- a/vendor/asic-rs-core/src/data/collector.rs
+++ b/vendor/asic-rs-core/src/data/collector.rs
@@ -111,6 +111,9 @@ pub enum DataField {
/// Difficulty of the best share found over the miner's lifetime, when reported.
#[cfg_attr(feature = "python", pydantic(value = "BestShare"))]
BestShare,
+ /// Cumulative share statistics (difficulty accepted/rejected, stale, blocks).
+ #[cfg_attr(feature = "python", pydantic(value = "ShareSummary"))]
+ ShareSummary,
/// Difficulty of the best share found since the last boot or hashing start, when reported.
#[cfg_attr(feature = "python", pydantic(value = "SessionBestShare"))]
SessionBestShare,
diff --git a/vendor/asic-rs-core/src/data/miner.rs b/vendor/asic-rs-core/src/data/miner.rs
index 38c7f3be..660850f4 100644
--- a/vendor/asic-rs-core/src/data/miner.rs
+++ b/vendor/asic-rs-core/src/data/miner.rs
@@ -17,6 +17,7 @@ use super::{
operating_state::OperatingState,
pool::PoolGroupData,
psu::PsuInfo,
+ share::ShareSummary,
};
use crate::data::{
deserialize::deserialize_macaddr,
@@ -237,6 +238,9 @@ pub struct MinerData {
/// Difficulty of the best share found since the last boot or hashing start,
/// when the firmware distinguishes session from all-time.
pub session_best_share: Option<f64>,
+ /// Cumulative share statistics (difficulty accepted/rejected, stale, blocks),
+ /// when reported. Miner-level aggregate from the cgminer/btminer summary.
+ pub share_summary: Option<ShareSummary>,
}
#[cfg(feature = "python")]
diff --git a/vendor/asic-rs-core/src/data/share.rs b/vendor/asic-rs-core/src/data/share.rs
index 3cc50651..73b0a0a8 100644
--- a/vendor/asic-rs-core/src/data/share.rs
+++ b/vendor/asic-rs-core/src/data/share.rs
@@ -3,7 +3,61 @@
//! Firmwares report best-share difficulty as a JSON number, a decimal string,
//! or an AxeOS-style suffix string (`"483k"`, `"1.2M"`).
+#[cfg(feature = "python")]
+use pyo3::pyclass;
+use serde::{Deserialize, Serialize};
use serde_json::Value;
+use ts_rs::TS;
+
+/// Cumulative share statistics reported by a miner (round 19 #10, T2).
+///
+/// These are miner-level aggregates from the cgminer/btminer summary. Difficulty
+/// values are difficulty-weighted sums (not raw share counts, which live on
+/// [`PoolData`][`super::pool::PoolData`]). Every field is optional; a backend
+/// fills in only what its firmware exposes.
+#[cfg_attr(feature = "python", pyclass(from_py_object, module = "asic_rs"))]
+#[cfg_attr(feature = "python", asic_rs_pydantic::py_pydantic_model(getters))]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default, TS)]
+pub struct ShareSummary {
+ /// Difficulty-weighted accepted work, when reported.
+ pub difficulty_accepted: Option<f64>,
+ /// Difficulty-weighted rejected work, when reported.
+ pub difficulty_rejected: Option<f64>,
+ /// Raw stale share count, when reported.
+ pub stale_shares: Option<u64>,
+ /// Number of blocks found by this miner, when reported.
+ pub found_blocks: Option<u64>,
+}
+
+impl ShareSummary {
+ /// True when no field is populated.
+ pub fn is_empty(&self) -> bool {
+ self.difficulty_accepted.is_none()
+ && self.difficulty_rejected.is_none()
+ && self.stale_shares.is_none()
+ && self.found_blocks.is_none()
+ }
+}
+
+/// Parse a [`ShareSummary`] from a cgminer/btminer `SUMMARY[0]` object (the value
+/// extracted at `/SUMMARY/0`). Reads "Difficulty Accepted", "Difficulty Rejected",
+/// "Stale", and "Found Blocks". Returns `None` when none are present.
+pub fn parse_cgminer_share_summary(summary: &Value) -> Option<ShareSummary> {
+ let f = |k: &str| {
+ summary
+ .get(k)
+ .and_then(|v| v.as_f64())
+ .filter(|v| v.is_finite() && *v >= 0.0)
+ };
+ let u = |k: &str| summary.get(k).and_then(|v| v.as_u64());
+ let s = ShareSummary {
+ difficulty_accepted: f("Difficulty Accepted"),
+ difficulty_rejected: f("Difficulty Rejected"),
+ stale_shares: u("Stale"),
+ found_blocks: u("Found Blocks"),
+ };
+ (!s.is_empty()).then_some(s)
+}
/// Parse a share difficulty from a JSON value.
///
diff --git a/vendor/asic-rs-core/src/traits/miner.rs b/vendor/asic-rs-core/src/traits/miner.rs
index cfabb624..76344342 100644
--- a/vendor/asic-rs-core/src/traits/miner.rs
+++ b/vendor/asic-rs-core/src/traits/miner.rs
@@ -34,6 +34,7 @@ use crate::{
operating_state::OperatingState,
pool::PoolGroupData,
psu::PsuInfo,
+ share::ShareSummary,
},
traits::firmware::MinerFirmware,
traits::model::MinerModel,
@@ -291,6 +292,7 @@ impl<
let pools = self.parse_pools(&data);
let best_share = self.parse_best_share(&data);
let session_best_share = self.parse_session_best_share(&data);
+ let share_summary = self.parse_share_summary(&data);
let device_info = self.get_device_info();
// computed fields
@@ -388,6 +390,7 @@ impl<
pools,
best_share,
session_best_share,
+ share_summary,
}
}
}
@@ -914,6 +917,18 @@ pub trait GetBestShare: CollectData {
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
None
}
+ #[tracing::instrument(level = "debug")]
+ async fn get_share_summary(&self) -> Option<ShareSummary> {
+ let mut collector = self.get_collector();
+ let data = collector.collect(&[DataField::ShareSummary]).await;
+ self.parse_share_summary(&data)
+ }
+ /// Cumulative share statistics (difficulty accepted/rejected, stale, blocks).
+ /// Backends that expose them override this; others return None.
+ #[allow(unused_variables)]
+ fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
+ None
+ }
}
// Best share difficulty (this session / since boot)
diff --git a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
index 63f819f8..71195737 100644
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
@@ -21,6 +21,7 @@ use asic_rs_core::{
message::{MessageSeverity, MinerMessage},
miner::{MiningMode, TuningTarget},
pool::{PoolData, PoolGroupData, PoolURL},
+ share::{ShareSummary, parse_cgminer_share_summary},
},
traits::{miner::*, model::MinerModel},
};
@@ -509,6 +510,16 @@ impl GetDataLocations for AntMinerV2020 {
tag: None,
},
)],
+ // Cumulative share stats from cgminer summary (round 19 #10, T2);
+ // RPC_SUMMARY already fetched.
+ DataField::ShareSummary => vec![(
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0"),
+ tag: None,
+ },
+ )],
// `total_rateideal`, by contrast, says nothing about its own
// scale, so carry STATS' `rate_unit` alongside it.
DataField::ExpectedHashrate => vec![
@@ -889,6 +900,10 @@ impl GetBestShare for AntMinerV2020 {
// (round 19 #10).
data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
}
+ fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
+ data.get(&DataField::ShareSummary)
+ .and_then(parse_cgminer_share_summary)
+ }
}
impl GetSessionBestShare for AntMinerV2020 {}
@@ -1679,6 +1694,12 @@ mod tests {
algo: HashAlgorithm::SHA256,
}
);
+ // Cumulative share stats from cgminer summary (round 19 #10, T2).
+ let shares = miner_data.share_summary.expect("share summary");
+ assert_eq!(shares.difficulty_accepted, Some(1305083904.0));
+ assert_eq!(shares.difficulty_rejected, Some(2490368.0));
+ assert_eq!(shares.stale_shares, Some(1));
+ assert_eq!(shares.found_blocks, Some(0));
}
#[tokio::test]
diff --git a/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs b/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs
index 1ac2bad1..58e8a5c2 100644
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs
@@ -23,6 +23,7 @@ use asic_rs_core::{
message::{MessageSeverity, MinerMessage},
miner::{MiningMode, TuningTarget},
pool::{PoolData, PoolGroupData, PoolURL},
+ share::{ShareSummary, parse_cgminer_share_summary},
},
traits::{miner::*, model::MinerModel},
};
@@ -547,6 +548,16 @@ impl GetDataLocations for AntMinerV202307 {
tag: None,
},
)],
+ // Cumulative share stats from cgminer summary (round 19 #10, T2);
+ // RPC_SUMMARY already fetched.
+ DataField::ShareSummary => vec![(
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0"),
+ tag: None,
+ },
+ )],
DataField::SessionBestShare => vec![(
RPC_SUMMARY,
DataExtractor {
@@ -955,6 +966,10 @@ impl GetBestShare for AntMinerV202307 {
// reports 0 when it has never found a share (round 17 R7).
data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
}
+ fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
+ data.get(&DataField::ShareSummary)
+ .and_then(parse_cgminer_share_summary)
+ }
}
impl GetSessionBestShare for AntMinerV202307 {
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 a75a3f97..413f237a 100644
--- a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
@@ -20,6 +20,7 @@ use asic_rs_core::{
message::{MessageSeverity, MinerMessage},
miner::TuningTarget,
pool::{PoolData, PoolGroupData, PoolURL},
+ share::{ShareSummary, parse_cgminer_share_summary},
},
traits::{miner::*, model::MinerModel},
};
@@ -455,6 +456,16 @@ impl GetDataLocations for LuxMinerV1 {
tag: None,
},
)],
+ // Cumulative share stats from LuxOS summary (round 19 #10, T2);
+ // RPC_SUMMARY already fetched.
+ DataField::ShareSummary => vec![(
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0"),
+ tag: None,
+ },
+ )],
DataField::SessionBestShare => vec![(
RPC_SUMMARY,
DataExtractor {
@@ -945,6 +956,10 @@ impl GetBestShare for LuxMinerV1 {
// LuxOS summary -> "Best Share" (all-time), round 16 / G9.
data.extract::<f64>(DataField::BestShare)
}
+ fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
+ data.get(&DataField::ShareSummary)
+ .and_then(parse_cgminer_share_summary)
+ }
}
impl GetSessionBestShare for LuxMinerV1 {
fn parse_session_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
index 584ae8d1..aacd1077 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
@@ -19,6 +19,7 @@ use asic_rs_core::{
miner::TuningTarget,
pool::{PoolData, PoolGroupData, PoolURL},
psu::PsuInfo,
+ share::{ShareSummary, parse_cgminer_share_summary},
},
traits::{miner::*, model::MinerModel},
};
@@ -264,6 +265,16 @@ impl GetDataLocations for WhatsMinerV1 {
tag: None,
},
)],
+ // Cumulative share stats from btminer summary (round 19 #10, T2);
+ // RPC_SUMMARY already fetched.
+ DataField::ShareSummary => vec![(
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0"),
+ tag: None,
+ },
+ )],
DataField::ExpectedHashrate => vec![(
RPC_SUMMARY,
DataExtractor {
@@ -597,6 +608,10 @@ impl GetBestShare for WhatsMinerV1 {
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
}
+ fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
+ data.get(&DataField::ShareSummary)
+ .and_then(parse_cgminer_share_summary)
+ }
}
impl GetSessionBestShare for WhatsMinerV1 {}
impl GetOperatingState for WhatsMinerV1 {}
@@ -969,6 +984,14 @@ mod integration_tests {
assert_eq!(hr.unit, HashRateUnit::TeraHash);
assert!((hr.value - 67.43935249).abs() < 1e-6);
}
+ // Cumulative share stats from summary (round 19 #10, T2).
+ let shares = miner_data
+ .share_summary
+ .ok_or_else(|| anyhow::anyhow!("v1 should expose share summary"))?;
+ assert_eq!(shares.difficulty_accepted, Some(158334976.0));
+ assert_eq!(shares.difficulty_rejected, Some(0.0));
+ assert_eq!(shares.stale_shares, Some(0));
+ assert_eq!(shares.found_blocks, Some(0));
assert_eq!(miner_data.wattage, Some(Power::from_watts(3417f64)));
assert_eq!(
miner_data.tuning_target,
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
index 5de37579..4cfcee19 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
@@ -21,6 +21,7 @@ use asic_rs_core::{
miner::{MiningMode, TuningTarget},
pool::{PoolData, PoolGroupData, PoolURL},
psu::PsuInfo,
+ share::{ShareSummary, parse_cgminer_share_summary},
},
traits::{miner::*, model::MinerModel},
util::is_expected_write_error,
@@ -265,6 +266,16 @@ impl GetDataLocations for WhatsMinerV2 {
tag: None,
},
)],
+ // Cumulative share stats from btminer summary (round 19 #10, T2);
+ // RPC_SUMMARY already fetched.
+ DataField::ShareSummary => vec![(
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0"),
+ tag: None,
+ },
+ )],
DataField::ExpectedHashrate => vec![(
RPC_SUMMARY,
DataExtractor {
@@ -592,6 +603,10 @@ impl GetBestShare for WhatsMinerV2 {
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
}
+ fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
+ data.get(&DataField::ShareSummary)
+ .and_then(parse_cgminer_share_summary)
+ }
}
impl GetSessionBestShare for WhatsMinerV2 {}
impl GetOperatingState for WhatsMinerV2 {}
@@ -0,0 +1,267 @@
Subject: [PATCH 0027] telemetry: miner-level fan duty cycle (fan speed %)
Round 19 #10 / #8 telemetry extension, tier 3. Exposes the fan duty cycle as a
miner-level percentage. No firmware exposes a maximum fan RPM, so this normalized
duty cycle is the fan-load indicator the GUI wanted alongside the per-fan RPMs.
- New DataField::FanSpeedPercent; MinerData gains fan_speed_percent (Option<f64>,
0-100). Modeled as a top-level miner-level value (most firmwares report a single
duty), so FanData is untouched (no Eq/literal churn across 17 crates).
- Rides the EXISTING GetFans trait via a defaulted parse_fan_speed_percent method
(default None), so no new supertrait bound; only backends that expose it override.
- Backends (each reads a command the collector already fetches, so no extra
round-trips): ePIC (summary /Fans/Fans Speed, single %), LuxOS (max of FANS[].Speed),
Braiins v25_07 + v26_04 (max of cooling fans[].target_speed_ratio x 100). Antminer
(pwm via config command) and VNish (fan_duty) have no data fixtures and are left
for a live-verified pass; WhatsMiner is fw-locked -> None.
Fixture tests for epic, luxminer, and braiins v26_04 assert the parsed percentage.
diff --git a/vendor/asic-rs-core/src/data/collector.rs b/vendor/asic-rs-core/src/data/collector.rs
index 942b39f6..07d9d571 100644
--- a/vendor/asic-rs-core/src/data/collector.rs
+++ b/vendor/asic-rs-core/src/data/collector.rs
@@ -62,6 +62,9 @@ pub enum DataField {
/// Fan speed or fan configuration.
#[cfg_attr(feature = "python", pydantic(value = "Fans"))]
Fans,
+ /// Miner-level fan duty cycle as a percentage (0-100).
+ #[cfg_attr(feature = "python", pydantic(value = "FanSpeedPercent"))]
+ FanSpeedPercent,
/// PSU fan speed or configuration.
#[cfg_attr(feature = "python", pydantic(value = "PsuFans"))]
PsuFans,
diff --git a/vendor/asic-rs-core/src/data/miner.rs b/vendor/asic-rs-core/src/data/miner.rs
index 660850f4..6dc73d26 100644
--- a/vendor/asic-rs-core/src/data/miner.rs
+++ b/vendor/asic-rs-core/src/data/miner.rs
@@ -178,6 +178,9 @@ pub struct MinerData {
pub expected_fans: Option<u8>,
/// The current fan information for the miner
pub fans: Vec<FanData>,
+ /// Miner-level fan duty cycle as a percentage (0-100), when reported. Firmware
+ /// exposes no maximum RPM, so this duty cycle is the normalized fan indicator.
+ pub fan_speed_percent: Option<f64>,
/// The current PDU fan information for the miner
pub psu_fans: Vec<FanData>,
/// The average temperature across all chips in the miner
diff --git a/vendor/asic-rs-core/src/traits/miner.rs b/vendor/asic-rs-core/src/traits/miner.rs
index 76344342..baac9387 100644
--- a/vendor/asic-rs-core/src/traits/miner.rs
+++ b/vendor/asic-rs-core/src/traits/miner.rs
@@ -283,6 +283,7 @@ impl<
let fluid_temperature = self.parse_fluid_temperature(&data);
let outlet_fluid_temperature = self.parse_outlet_fluid_temperature(&data);
let fans = self.parse_fans(&data);
+ let fan_speed_percent = self.parse_fan_speed_percent(&data);
let psu_fans = self.parse_psu_fans(&data);
let hashboards = self.parse_hashboards(&data);
let light_flashing = self.parse_light_flashing(&data);
@@ -366,6 +367,7 @@ impl<
// Cooling information
expected_fans: device_info.hardware.fans,
fans,
+ fan_speed_percent,
psu_fans,
average_temperature,
fluid_temperature,
@@ -682,6 +684,18 @@ pub trait GetFans: CollectData {
fn parse_fans(&self, data: &HashMap<DataField, Value>) -> Vec<FanData> {
vec![]
}
+ #[tracing::instrument(level = "debug")]
+ async fn get_fan_speed_percent(&self) -> Option<f64> {
+ let mut collector = self.get_collector();
+ let data = collector.collect(&[DataField::FanSpeedPercent]).await;
+ self.parse_fan_speed_percent(&data)
+ }
+ /// Miner-level fan duty cycle as a percentage (0-100). Backends that expose it
+ /// override this; others return None.
+ #[allow(unused_variables)]
+ fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ None
+ }
}
// PSU Fans
diff --git a/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs b/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs
index 7e07967f..86e84d8c 100644
--- a/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs
+++ b/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs
@@ -230,6 +230,16 @@ impl GetDataLocations for BraiinsV2507 {
tag: None,
},
)],
+ // Miner-level fan duty cycle (round 19 #10, T3): max target_speed_ratio;
+ // cooling state already fetched.
+ DataField::FanSpeedPercent => vec![(
+ WEB_COOLING_STATE,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/fans"),
+ tag: None,
+ },
+ )],
DataField::Hashboards => vec![(
WEB_HASHBOARDS,
DataExtractor {
@@ -567,6 +577,18 @@ impl GetFans for BraiinsV2507 {
fans
}
+ fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ // Braiins fans[].target_speed_ratio is a 0-1 duty ratio; report the max as
+ // a percentage (round 19 #10, T3).
+ data.get(&DataField::FanSpeedPercent)
+ .and_then(|v| v.as_array())
+ .into_iter()
+ .flatten()
+ .filter_map(|f| f.pointer("/target_speed_ratio").and_then(|v| v.as_f64()))
+ .filter(|v| v.is_finite() && *v >= 0.0)
+ .map(|v| v * 100.0)
+ .max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
+ }
}
impl GetLightFlashing for BraiinsV2507 {
diff --git a/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs b/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs
index 2f5be88c..303fca49 100644
--- a/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs
+++ b/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs
@@ -233,6 +233,16 @@ impl GetDataLocations for BraiinsV2604 {
tag: None,
},
)],
+ // Miner-level fan duty cycle (round 19 #10, T3): max target_speed_ratio;
+ // cooling state already fetched.
+ DataField::FanSpeedPercent => vec![(
+ WEB_COOLING_STATE,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/fans"),
+ tag: None,
+ },
+ )],
DataField::Hashboards => vec![(
WEB_HASHBOARDS,
DataExtractor {
@@ -598,6 +608,18 @@ impl GetFans for BraiinsV2604 {
fans
}
+ fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ // Braiins fans[].target_speed_ratio is a 0-1 duty ratio; report the max as
+ // a percentage (round 19 #10, T3).
+ data.get(&DataField::FanSpeedPercent)
+ .and_then(|v| v.as_array())
+ .into_iter()
+ .flatten()
+ .filter_map(|f| f.pointer("/target_speed_ratio").and_then(|v| v.as_f64()))
+ .filter(|v| v.is_finite() && *v >= 0.0)
+ .map(|v| v * 100.0)
+ .max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
+ }
}
impl GetLightFlashing for BraiinsV2604 {
@@ -1287,6 +1309,10 @@ mod tests {
assert_eq!(hr.unit, HashRateUnit::TeraHash);
assert!((hr.value - 247.3507543407177).abs() < 1e-3);
}
+ // Miner-level fan duty cycle = max target_speed_ratio (0.92) x 100 (round
+ // 19 #10, T3).
+ let fan_pct = miner_data.fan_speed_percent.expect("braiins fan duty");
+ assert!((fan_pct - 92.0).abs() < 1e-6);
}
#[test]
diff --git a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
index 2abb0706..16c7872b 100644
--- a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
@@ -473,6 +473,15 @@ impl GetDataLocations for PowerPlayV1 {
tag: None,
},
)],
+ // Miner-level fan duty cycle (round 19 #10, T3); summary already fetched.
+ DataField::FanSpeedPercent => vec![(
+ WEB_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/Fans/Fans Speed"),
+ tag: None,
+ },
+ )],
DataField::Hashboards => vec![
(
WEB_TEMPS,
@@ -1120,6 +1129,11 @@ impl GetFans for PowerPlayV1 {
fans
}
+ fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ // ePIC summary /Fans/Fans Speed is a single miner-level duty % (round 19 #10).
+ data.extract::<f64>(DataField::FanSpeedPercent)
+ .filter(|v| v.is_finite() && *v >= 0.0)
+ }
}
impl GetPsuFans for PowerPlayV1 {}
@@ -2189,6 +2203,8 @@ mod tests {
assert_eq!(miner_data.uptime, Some(Duration::from_secs(23170)));
assert_eq!(miner_data.wattage, Some(Power::from_watts(2166.6174)));
+ // Miner-level fan duty cycle from summary /Fans/Fans Speed (round 19 #10, T3).
+ assert_eq!(miner_data.fan_speed_percent, Some(100.0));
assert_eq!(miner_data.hashboards.len(), 3);
assert_eq!(miner_data.hashboards[0].active, Some(false));
assert_eq!(miner_data.hashboards[1].chips.len(), 110);
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 413f237a..edab7c4c 100644
--- a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
@@ -295,6 +295,16 @@ impl GetDataLocations for LuxMinerV1 {
tag: None,
},
)],
+ // Miner-level fan duty cycle (round 19 #10, T3): max of per-fan Speed;
+ // RPC_FANS already fetched.
+ DataField::FanSpeedPercent => vec![(
+ RPC_FANS,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/FANS"),
+ tag: None,
+ },
+ )],
DataField::ApiVersion => vec![(
RPC_VERSION,
DataExtractor {
@@ -936,6 +946,17 @@ impl GetFans for LuxMinerV1 {
})
.collect()
}
+ fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ // LuxOS FANS[].Speed is per-fan duty %; report the fleet-facing maximum
+ // (round 19 #10, T3).
+ data.get(&DataField::FanSpeedPercent)
+ .and_then(|v| v.as_array())
+ .into_iter()
+ .flatten()
+ .filter_map(|f| f.get("Speed").and_then(|v| v.as_f64()))
+ .filter(|v| v.is_finite() && *v >= 0.0)
+ .max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
+ }
}
impl GetLightFlashing for LuxMinerV1 {
@@ -1680,6 +1701,9 @@ mod tests {
Some(TuningTarget::Power(Power::from_watts(1188f64)))
);
assert_eq!(miner_data.fans.len(), 4);
+ // Miner-level fan duty cycle = max of per-fan Speed (all 20 here); round 19
+ // #10, T3.
+ assert_eq!(miner_data.fan_speed_percent, Some(20.0));
assert_eq!(miner_data.hashboards[0].chips.len(), 77);
assert_eq!(miner_data.pools.len(), 2);
assert_eq!(miner_data.pools[0].len(), 2);
@@ -0,0 +1,136 @@
Subject: [PATCH 0028] telemetry: board temperature thresholds (critical / shutdown)
Round 19 #10 telemetry extension, tier 3. Exposes the board temperature safety
thresholds ("board dangerous temp" from item #10).
- New DataField::TemperatureLimits; MinerData gains temp_critical and temp_shutdown
(Celsius). Rides the EXISTING GetFluidTemperature trait via a defaulted
parse_temperature_limits method returning (critical, shutdown), so no new
supertrait bound; only backends that expose the thresholds override it.
- ePIC: summary /Misc Critical Temp + Shutdown Temp (already-fetched summary).
Antminer/WhatsMiner do not expose thresholds; LuxOS needs an unwired tempctrl
command (no fixture) and VNish/Braiins need live verification -> left for a
live-verified pass, all inherit (None, None).
Fixture test for epic asserts the parsed thresholds.
diff --git a/vendor/asic-rs-core/src/data/collector.rs b/vendor/asic-rs-core/src/data/collector.rs
index 07d9d571..1e6e7e9d 100644
--- a/vendor/asic-rs-core/src/data/collector.rs
+++ b/vendor/asic-rs-core/src/data/collector.rs
@@ -65,6 +65,9 @@ pub enum DataField {
/// Miner-level fan duty cycle as a percentage (0-100).
#[cfg_attr(feature = "python", pydantic(value = "FanSpeedPercent"))]
FanSpeedPercent,
+ /// Board temperature safety thresholds (critical / shutdown), in Celsius.
+ #[cfg_attr(feature = "python", pydantic(value = "TemperatureLimits"))]
+ TemperatureLimits,
/// PSU fan speed or configuration.
#[cfg_attr(feature = "python", pydantic(value = "PsuFans"))]
PsuFans,
diff --git a/vendor/asic-rs-core/src/data/miner.rs b/vendor/asic-rs-core/src/data/miner.rs
index 6dc73d26..08782856 100644
--- a/vendor/asic-rs-core/src/data/miner.rs
+++ b/vendor/asic-rs-core/src/data/miner.rs
@@ -181,6 +181,10 @@ pub struct MinerData {
/// Miner-level fan duty cycle as a percentage (0-100), when reported. Firmware
/// exposes no maximum RPM, so this duty cycle is the normalized fan indicator.
pub fan_speed_percent: Option<f64>,
+ /// Board critical temperature threshold in Celsius, when reported (round 19 #10).
+ pub temp_critical: Option<f64>,
+ /// Board shutdown temperature threshold in Celsius, when reported (round 19 #10).
+ pub temp_shutdown: Option<f64>,
/// The current PDU fan information for the miner
pub psu_fans: Vec<FanData>,
/// The average temperature across all chips in the miner
diff --git a/vendor/asic-rs-core/src/traits/miner.rs b/vendor/asic-rs-core/src/traits/miner.rs
index baac9387..9de51761 100644
--- a/vendor/asic-rs-core/src/traits/miner.rs
+++ b/vendor/asic-rs-core/src/traits/miner.rs
@@ -282,6 +282,7 @@ impl<
let tuning_capabilities = self.parse_tuning_capabilities(&data);
let fluid_temperature = self.parse_fluid_temperature(&data);
let outlet_fluid_temperature = self.parse_outlet_fluid_temperature(&data);
+ let (temp_critical, temp_shutdown) = self.parse_temperature_limits(&data);
let fans = self.parse_fans(&data);
let fan_speed_percent = self.parse_fan_speed_percent(&data);
let psu_fans = self.parse_psu_fans(&data);
@@ -368,6 +369,8 @@ impl<
expected_fans: device_info.hardware.fans,
fans,
fan_speed_percent,
+ temp_critical,
+ temp_shutdown,
psu_fans,
average_temperature,
fluid_temperature,
@@ -741,6 +744,15 @@ pub trait GetFluidTemperature: CollectData {
) -> Option<Temperature> {
None
}
+ /// Board temperature safety thresholds as (critical, shutdown) in Celsius.
+ /// Backends that expose them override this; others return (None, None).
+ #[allow(unused_variables)]
+ fn parse_temperature_limits(
+ &self,
+ data: &HashMap<DataField, Value>,
+ ) -> (Option<f64>, Option<f64>) {
+ (None, None)
+ }
}
// Wattage
diff --git a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
index 16c7872b..0c9a851b 100644
--- a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
@@ -482,6 +482,16 @@ impl GetDataLocations for PowerPlayV1 {
tag: None,
},
)],
+ // Board temperature thresholds (round 19 #10, T3); summary /Misc carries
+ // Critical Temp and Shutdown Temp. Already fetched.
+ DataField::TemperatureLimits => vec![(
+ WEB_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/Misc"),
+ tag: None,
+ },
+ )],
DataField::Hashboards => vec![
(
WEB_TEMPS,
@@ -1139,7 +1149,21 @@ impl GetFans for PowerPlayV1 {
impl GetPsuFans for PowerPlayV1 {}
impl GetTuningCapabilities for PowerPlayV1 {}
-impl GetFluidTemperature for PowerPlayV1 {}
+impl GetFluidTemperature for PowerPlayV1 {
+ fn parse_temperature_limits(
+ &self,
+ data: &HashMap<DataField, Value>,
+ ) -> (Option<f64>, Option<f64>) {
+ // ePIC summary /Misc: Critical Temp + Shutdown Temp (round 19 #10, T3).
+ let d = data.get(&DataField::TemperatureLimits);
+ let f = |k: &str| {
+ d.and_then(|v| v.pointer(k))
+ .and_then(|v| v.as_f64())
+ .filter(|v| v.is_finite() && *v > 0.0)
+ };
+ (f("/Critical Temp"), f("/Shutdown Temp"))
+ }
+}
impl GetWattage for PowerPlayV1 {
fn parse_wattage(&self, data: &HashMap<DataField, Value>) -> Option<Power> {
@@ -2205,6 +2229,9 @@ mod tests {
assert_eq!(miner_data.wattage, Some(Power::from_watts(2166.6174)));
// Miner-level fan duty cycle from summary /Fans/Fans Speed (round 19 #10, T3).
assert_eq!(miner_data.fan_speed_percent, Some(100.0));
+ // Board temp thresholds from summary /Misc (round 19 #10, T3).
+ assert_eq!(miner_data.temp_critical, Some(100.0));
+ assert_eq!(miner_data.temp_shutdown, Some(85.0));
assert_eq!(miner_data.hashboards.len(), 3);
assert_eq!(miner_data.hashboards[0].active, Some(false));
assert_eq!(miner_data.hashboards[1].chips.len(), 110);
@@ -351,13 +351,16 @@ int DrawShape(wxDC* dc, wxUniChar shape, wxCoord x, const wxRect& cell,
const wxBitmap& bmp = ShapeBitmap(shape, *sv, colour, dw, dh);
if (bmp.IsOk()) {
if (health) {
// Left-align in the full slot (a shrunk fan is centred within it) and
// advance by less than the full icon width so adjacent health icons sit
// close together (the Font Awesome glyphs carry inner margin, so a small
// bounding-box overlap does not visually collide).
dc->DrawBitmap(bmp, x + (w - dw) / 2, cy - dh / 2, true);
int adv = w - 3;
return adv < 1 ? 1 : adv;
// UNIFORM fixed-width slot (round 19): every health icon (and the
// alignment gap) advances by the same amount -- the square (h - 3) -- so
// power/control/fan/board icons line up in fixed columns across rows
// regardless of each glyph's aspect ratio (a narrow bolt or a shrunk fan
// no longer shifts the icons after it). Each glyph is centred in its slot.
// This matches SHAPE_GAP's advance and the per-icon tooltip hit-test.
int adv = h - 3;
if (adv < 1) adv = 1;
dc->DrawBitmap(bmp, x + (adv - dw) / 2, cy - dh / 2, true);
return adv;
}
int slot = (w > SHAPE_ADVANCE) ? w : SHAPE_ADVANCE;
dc->DrawBitmap(bmp, x + (slot - w) / 2, cy - h / 2, true);
@@ -452,7 +455,13 @@ class SegmentRenderer : public wxDataViewCustomRenderer {
wxRect bg = cell;
if (wxDataViewColumn* owner = const_cast<SegmentRenderer*>(this)->GetOwner()) {
int cw = owner->GetWidth();
if (cw > bg.width) bg.width = cw;
// Extend BOTH directions by the column width. For a right-aligned column
// (round 19 #21) wx anchors `cell` at the content's left edge (near the
// column's right side), so extending only rightward left the column's left
// portion unstriped; over-spanning both sides and letting the cell-DC clip
// trim it fills the whole cell regardless of alignment (round 19 review M1).
bg.x -= cw;
bg.width += 2 * cw;
}
bg.y -= 40;
bg.height += 80;
@@ -535,7 +544,10 @@ class SegmentRenderer : public wxDataViewCustomRenderer {
} else if (const ShapeSvg* sv = LookupShapeSvg(shape)) {
int ww = (sv->vbh > 0) ? (int)((double)hh * sv->vbw / sv->vbh + 0.5) : hh;
if (health) {
adv = ww - 3;
// UNIFORM fixed-width slot (round 19), matching DrawShape + the gap, so
// every health icon lines up in fixed columns across rows regardless of
// its glyph aspect. Width is measured square (hh - 3), not per-glyph.
adv = hh - 3;
if (adv < 1) adv = 1;
} else if (ww > adv) {
adv = ww;
@@ -975,7 +987,10 @@ static gboolean dvlc_query_tooltip(GtkWidget* tv, gint x, gint y, gboolean keybo
GdkRectangle crect;
gtk_tree_view_get_cell_area(GTK_TREE_VIEW(tv), path, gcol, &crect);
gtk_tree_path_free(path);
// Icon advance matches DrawShape's health-icon width (square icons: h - 3).
// Icon advance must match DrawShape's now-UNIFORM health-icon slot, which is
// (row height - 1, capped at 28*zoom) - 3 for every glyph and gap alike. The
// earlier per-glyph advance (w-3) shifted the hit slots so tooltips landed on
// the wrong icon (round 19 #2); with the uniform slot the hit-test lines up.
int h = crect.height - 1;
int cap = (int)(28 * g_table_zoom + 0.5);
if (cap < 8) cap = 8;
@@ -983,11 +998,20 @@ static gboolean dvlc_query_tooltip(GtkWidget* tv, gint x, gint y, gboolean keybo
if (h < 8) h = 8;
int adv = h - 3;
if (adv < 1) adv = 1;
int off = bx - crect.x;
int n = (int)iit->second.size();
// A right-aligned column (round 19 #21) draws the icon block flush to the
// cell's right edge, so measure the pointer from the block's left, not the
// cell's left.
int block_left = crect.x;
if (wxcol->GetAlignment() == wxALIGN_RIGHT) {
int content_w = n * adv;
if (content_w < crect.width) block_left = crect.x + (crect.width - content_w);
}
int off = bx - block_left;
if (off < 0) off = 0;
int slot = off / adv;
if (slot < 0) slot = 0;
if (slot >= (int)iit->second.size()) slot = (int)iit->second.size() - 1;
if (slot >= n) slot = n - 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).
@@ -996,7 +1020,7 @@ static gboolean dvlc_query_tooltip(GtkWidget* tv, gint x, gint y, gboolean keybo
// 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.x = block_left + slot * adv;
area.y = crect.y;
area.width = adv;
area.height = crect.height;
@@ -1126,14 +1150,23 @@ void* wxbr_dvlc(void* parent) {
return (void*)dv;
}
void wxbr_dvlc_append_text_col(void* win, const char* title, int width, int reorderable) {
// Map the bridge alignment code (0 left, 1 right, 2 centre) to a wxAlignment.
static wxAlignment dvlc_wx_align(int align) {
switch (align) {
case 1: return wxALIGN_RIGHT;
case 2: return wxALIGN_CENTER;
default: return wxALIGN_NOT;
}
}
void wxbr_dvlc_append_text_col(void* win, const char* title, int width, int reorderable, int align) {
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
int flags = wxDATAVIEW_COL_RESIZABLE;
if (reorderable) flags |= wxDATAVIEW_COL_REORDERABLE;
unsigned col = dv->GetColumnCount(); // next model column index
dvlc_store(win)->AppendColumn("string");
dv->AppendTextColumn(wxString::FromUTF8(title), col, wxDATAVIEW_CELL_INERT,
width, wxALIGN_NOT, flags);
width, dvlc_wx_align(align), flags);
// Record the 100% column width for the zoom (round 14 #3); the first column of
// a (re)built table resets the list.
if (col == 0) g_zoom_base_w.clear();
@@ -1144,15 +1177,17 @@ void wxbr_dvlc_append_text_col(void* win, const char* title, int width, int reor
// SegmentRenderer so its cell values can carry the '\x1f'/'\x1e' colour-run
// encoding produced by alkane_gui::model::encode_segments. An ordinary string
// with no encoding in it still renders fine (single default-coloured run).
void* wxbr_dvlc_append_colored_col(void* win, const char* title, int width, int reorderable) {
void* wxbr_dvlc_append_colored_col(void* win, const char* title, int width, int reorderable, int align) {
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
int flags = wxDATAVIEW_COL_RESIZABLE;
if (reorderable) flags |= wxDATAVIEW_COL_REORDERABLE;
unsigned col = dv->GetColumnCount(); // next model column index
dvlc_store(win)->AppendColumn("string");
SegmentRenderer* renderer = new SegmentRenderer();
wxAlignment al = dvlc_wx_align(align);
renderer->SetAlignment(al);
wxDataViewColumn* c = new wxDataViewColumn(wxString::FromUTF8(title), renderer, col,
width, wxALIGN_NOT, flags);
width, al, flags);
dv->AppendColumn(c);
// Record the 100% column width for the zoom (round 14 #3).
if (col == 0) g_zoom_base_w.clear();
+17 -6
View File
@@ -7,6 +7,11 @@
use std::ffi::CString;
use std::os::raw::{c_char, c_int, c_long, c_void};
/// Column alignment for `dvlc_append_text_col` / `dvlc_append_colored_col`.
pub const ALIGN_LEFT: i32 = 0;
pub const ALIGN_RIGHT: i32 = 1;
pub const ALIGN_CENTER: i32 = 2;
mod notsafe {
use std::os::raw::{c_char, c_int, c_long, c_void};
@@ -56,8 +61,8 @@ mod notsafe {
pub fn wxbr_file_dialog(parent: *mut c_void, title: *const c_char, buf: *mut c_char, cap: c_int) -> c_int;
pub fn wxbr_save_file_dialog(parent: *mut c_void, title: *const c_char, default_name: *const c_char, wildcard: *const c_char, buf: *mut c_char, cap: c_int) -> c_int;
pub fn wxbr_dvlc(parent: *mut c_void) -> *mut c_void;
pub fn wxbr_dvlc_append_text_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int);
pub fn wxbr_dvlc_append_colored_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int) -> *mut c_void;
pub fn wxbr_dvlc_append_text_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int, align: c_int);
pub fn wxbr_dvlc_append_colored_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int, align: c_int) -> *mut c_void;
pub fn wxbr_dvlc_append_toggle_col(win: *mut c_void, width: c_int);
pub fn wxbr_dvlc_append_row(win: *mut c_void, nvals: c_int, vals: *const *const c_char);
pub fn wxbr_dvlc_delete_row(win: *mut c_void, row: usize);
@@ -577,17 +582,23 @@ impl Widget {
Widget(unsafe { notsafe::wxbr_dvlc(parent.0) })
}
pub fn dvlc_append_text_col(&self, title: &str, width: i32, reorderable: bool) {
/// Append a text column. `align` is the cell + header alignment:
/// [`ALIGN_LEFT`] (0), [`ALIGN_RIGHT`] (1) or [`ALIGN_CENTER`] (2).
pub fn dvlc_append_text_col(&self, title: &str, width: i32, reorderable: bool, align: i32) {
let c = CString::new(title).unwrap_or_default();
unsafe { notsafe::wxbr_dvlc_append_text_col(self.0, c.as_ptr(), width, reorderable as c_int) }
unsafe {
notsafe::wxbr_dvlc_append_text_col(self.0, c.as_ptr(), width, reorderable as c_int, align)
}
}
/// Like `dvlc_append_text_col`, but the column renders cell values through
/// the SegmentRenderer, so a value built with `model::encode_segments` is
/// drawn as coloured text runs (a plain string still renders normally).
pub fn dvlc_append_colored_col(&self, title: &str, width: i32, reorderable: bool) {
pub fn dvlc_append_colored_col(&self, title: &str, width: i32, reorderable: bool, align: i32) {
let c = CString::new(title).unwrap_or_default();
unsafe { notsafe::wxbr_dvlc_append_colored_col(self.0, c.as_ptr(), width, reorderable as c_int) };
unsafe {
notsafe::wxbr_dvlc_append_colored_col(self.0, c.as_ptr(), width, reorderable as c_int, align)
};
}
pub fn dvlc_append_toggle_col(&self, width: i32) {
+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":"20173e90df24055f67bf03e2b3bb3bc396168f39aa45b36828b1963749d7838a","Cargo.lock":"2f4e619eefd164b57242e6bae57ddf3f73053f6af308a1dea181936d6a41a291","Cargo.toml":"2310d9df1678c138cc82922659ba19d00a92fd2f107a21047890e53fd79c492d","Cargo.toml.orig":"6c6d97588811d1b3b4c0839aa016d6133745b96f7620d390d093d60a8e29d501","src/config/collector.rs":"8c79ac6d3a04f93efc78b176ef7f6b1dc44e50d2bc95d813439b47422d6bb28f","src/config/fan.rs":"80c305261643542f11368342c3dcea29bbd3b016fb6f2962fdad6489dac2734a","src/config/mod.rs":"0d14701319d84ded3cd2f6ba6f92bff18c8e5cff90a2229592d97baae3ed4de3","src/config/pools.rs":"a74ab648053eb51305c4e1bbb6c05db57575ff2542b4fd53d28d33687a62eee3","src/config/preset.rs":"e68d694d3cf537c67ecb3b535a77904e25cc3b206a6ec214fc904011229b8a7c","src/config/scaling.rs":"f402e00c75ef796068765ab1a82ce6a3a0eb88f484c4a67f574ede90a3abaeeb","src/config/temperature.rs":"c6fd6f9cc8e565f27b58fb571fd33b58dcf2112a50b570f6b54a3c11c13d1fbe","src/config/timezone.rs":"4470fd704885e62e3bc8da8087dce6b002dd3fa92cec54d96ce88a06f03e1cbe","src/config/tuning.rs":"31a0826419d4690315f6eecc03250bfb4e5342431ff261015a9f9f3d87e69b6c","src/data/board.rs":"d6816919357d770f9ae6dedea66bbfdec9ab0f4c8391f9928b90039b668ee026","src/data/capabilities.rs":"29cbab6262fb8888b30b4674a30ef03983e005b4e18eefddfbbf9c568e1e1e17","src/data/collector.rs":"dea53811c7c4f6dc2ba0ae5aab3b7bae9a06dfc9df0eef79117074845a0bf91f","src/data/command.rs":"53cd7e5e87888a76ba866b33b6d87400112bc3eeb4b5e331a381dfbb2c04579e","src/data/deserialize.rs":"461a84defd6f2fb53c8b3c059463c2bfcf69df80db0f5aa2d30b47e710163992","src/data/device.rs":"813b0d41834b217da9f2d51fc7d9cb0f12db6aa7501dd43b6c3f992f29e7827f","src/data/fan.rs":"9307626335008c04d5e5c742bdd7ff5c6e9055dbd84d0e7a655e6e656da3df78","src/data/firmware.rs":"648acace3b289f623cf678f36fb854ff5ddafb8e2f651ae4a15128ae719f87ba","src/data/hashrate.rs":"9d9e47a33753956fcfef7a5fb2a8eb315464aed41fe25be41acb36dd223a0880","src/data/message.rs":"7b399ab1a0b6e43e61a5461d29a2752beed2d1fd7b214eb891572f8994d47c11","src/data/miner.rs":"b07fc087b56cdaba6202a0dd23a1bf14d82f1907a7e3a5424aa98113b73c4fe5","src/data/mod.rs":"f63a6bd20fb2389e434257ccfe646321b25449993c937ece0d29850e0ab2279f","src/data/operating_state.rs":"7dccbfcc3eada16d0f890772323d4626fa9f298f7fc1882675ae3672d94f6da3","src/data/pool.rs":"a6bff9e56239915a095c4f99187a2d5f4631c3641332071c5134128cacaecceb","src/data/serialize.rs":"347f8cdf619156ac73aa0d89ed41555bd7332ef60cc92f945bc0f16f4ad29137","src/data/share.rs":"46c927b83eddaec7a01c6e0d8cc3af1d163d724421ecc94d4484db158fa27f4f","src/discovery.rs":"efc236592941e72609bd3be18551834f648b608caaf73b9555f75b9838692f6b","src/errors.rs":"0238c8cb6585d05cdd01aec031895e5240e3883f44f3fa22a7398027a360ef1a","src/lib.rs":"e2c8ecde3cf8edda920470f8b938056b60448184a5c81672f04a8e0235c3cf22","src/test/api.rs":"5defa33709c14cadfa7390981c3c7d3f324ef1878e4ee56c089dbf85665b57ae","src/test/mod.rs":"0b44b178ea8950b75fe09047797085f03e5c0eb17d62ca1f3e62a8f643fda87c","src/test/util.rs":"c6f5a3cccb40f1d6a7c316b52c70c59f8dda24a6ad83cb5aeac0b5d970debd0e","src/traits/auth.rs":"dffa58542ac9e57175f5dcad261f80b3efeba76ef3a039b0d9c6f9eb14a19893","src/traits/discovery.rs":"b232ea113c675178ae62c9f5ee35d0329e3a4465388133992c0db8d697113e34","src/traits/entry.rs":"03cf30045be6ba92a414d36990d316d572be21e6c66039ed8193da9a3c27cf53","src/traits/firmware.rs":"94831620bb8c8c4ce2ad69f8fd7b9679ee1de63b1f99529559e24f2118710638","src/traits/identification.rs":"67866931aa28c2e5b0e07dbacae47c1d82b53addea333f75033c451bbd2c9a77","src/traits/make.rs":"1d099cd51ecb354d20acef4cc1d2b3f75b682b6d6c887553861e185602d465f4","src/traits/miner.rs":"7ed55e9b085ea156357d0519c42e2b622e89fa2f81458bc73c42b6cfc6a94819","src/traits/mod.rs":"61406c4d2603299e4bad57c6f90115cadf93cee50a857bbfbb00d99f3a6873ac","src/traits/model.rs":"efde2b5cae4c4f018436bb68b236f354b5a733f7dafdeaf3f1c534b469a22d64","src/util.rs":"53255c65e85b97236cb34b452e2cb522edf377f49d2232645e0e0e33c447bb23"},"package":"1f25e625fc4c645ce995c5609a9fdff6f047d6a5e4d6be9dc167999a43197f58"}
{"$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":"20173e90df24055f67bf03e2b3bb3bc396168f39aa45b36828b1963749d7838a","Cargo.lock":"2f4e619eefd164b57242e6bae57ddf3f73053f6af308a1dea181936d6a41a291","Cargo.toml":"2310d9df1678c138cc82922659ba19d00a92fd2f107a21047890e53fd79c492d","Cargo.toml.orig":"6c6d97588811d1b3b4c0839aa016d6133745b96f7620d390d093d60a8e29d501","src/config/collector.rs":"8c79ac6d3a04f93efc78b176ef7f6b1dc44e50d2bc95d813439b47422d6bb28f","src/config/fan.rs":"80c305261643542f11368342c3dcea29bbd3b016fb6f2962fdad6489dac2734a","src/config/mod.rs":"0d14701319d84ded3cd2f6ba6f92bff18c8e5cff90a2229592d97baae3ed4de3","src/config/pools.rs":"a74ab648053eb51305c4e1bbb6c05db57575ff2542b4fd53d28d33687a62eee3","src/config/preset.rs":"e68d694d3cf537c67ecb3b535a77904e25cc3b206a6ec214fc904011229b8a7c","src/config/scaling.rs":"f402e00c75ef796068765ab1a82ce6a3a0eb88f484c4a67f574ede90a3abaeeb","src/config/temperature.rs":"c6fd6f9cc8e565f27b58fb571fd33b58dcf2112a50b570f6b54a3c11c13d1fbe","src/config/timezone.rs":"4470fd704885e62e3bc8da8087dce6b002dd3fa92cec54d96ce88a06f03e1cbe","src/config/tuning.rs":"31a0826419d4690315f6eecc03250bfb4e5342431ff261015a9f9f3d87e69b6c","src/data/board.rs":"0f2547d5763225a3c5387da695de52b65c38eeb7942d14ecef36a72388c7a451","src/data/capabilities.rs":"29cbab6262fb8888b30b4674a30ef03983e005b4e18eefddfbbf9c568e1e1e17","src/data/collector.rs":"84632f4f2c47834b49e2c785f6237432864fa618ad98601f1ddb1366581ee80a","src/data/command.rs":"53cd7e5e87888a76ba866b33b6d87400112bc3eeb4b5e331a381dfbb2c04579e","src/data/deserialize.rs":"461a84defd6f2fb53c8b3c059463c2bfcf69df80db0f5aa2d30b47e710163992","src/data/device.rs":"813b0d41834b217da9f2d51fc7d9cb0f12db6aa7501dd43b6c3f992f29e7827f","src/data/fan.rs":"9307626335008c04d5e5c742bdd7ff5c6e9055dbd84d0e7a655e6e656da3df78","src/data/firmware.rs":"648acace3b289f623cf678f36fb854ff5ddafb8e2f651ae4a15128ae719f87ba","src/data/hashrate.rs":"037a4cce611c9dafb03eb18c4d088c42df5a9bf23f376c0436aded7a3d657b0d","src/data/message.rs":"7b399ab1a0b6e43e61a5461d29a2752beed2d1fd7b214eb891572f8994d47c11","src/data/miner.rs":"5f188064a412c74a6242c410806186ac50b8642f5a1d67b1994bf25b2da0bd0a","src/data/mod.rs":"f63a6bd20fb2389e434257ccfe646321b25449993c937ece0d29850e0ab2279f","src/data/operating_state.rs":"7dccbfcc3eada16d0f890772323d4626fa9f298f7fc1882675ae3672d94f6da3","src/data/pool.rs":"a6bff9e56239915a095c4f99187a2d5f4631c3641332071c5134128cacaecceb","src/data/serialize.rs":"347f8cdf619156ac73aa0d89ed41555bd7332ef60cc92f945bc0f16f4ad29137","src/data/share.rs":"99adfa10cfc59e245f41f77c70951e7aac5b3422e48abd270c56c3db122bbb6d","src/discovery.rs":"efc236592941e72609bd3be18551834f648b608caaf73b9555f75b9838692f6b","src/errors.rs":"0238c8cb6585d05cdd01aec031895e5240e3883f44f3fa22a7398027a360ef1a","src/lib.rs":"e2c8ecde3cf8edda920470f8b938056b60448184a5c81672f04a8e0235c3cf22","src/test/api.rs":"5defa33709c14cadfa7390981c3c7d3f324ef1878e4ee56c089dbf85665b57ae","src/test/mod.rs":"0b44b178ea8950b75fe09047797085f03e5c0eb17d62ca1f3e62a8f643fda87c","src/test/util.rs":"c6f5a3cccb40f1d6a7c316b52c70c59f8dda24a6ad83cb5aeac0b5d970debd0e","src/traits/auth.rs":"dffa58542ac9e57175f5dcad261f80b3efeba76ef3a039b0d9c6f9eb14a19893","src/traits/discovery.rs":"b232ea113c675178ae62c9f5ee35d0329e3a4465388133992c0db8d697113e34","src/traits/entry.rs":"03cf30045be6ba92a414d36990d316d572be21e6c66039ed8193da9a3c27cf53","src/traits/firmware.rs":"94831620bb8c8c4ce2ad69f8fd7b9679ee1de63b1f99529559e24f2118710638","src/traits/identification.rs":"67866931aa28c2e5b0e07dbacae47c1d82b53addea333f75033c451bbd2c9a77","src/traits/make.rs":"1d099cd51ecb354d20acef4cc1d2b3f75b682b6d6c887553861e185602d465f4","src/traits/miner.rs":"da2fe3a9621124d2606d6673be75f9478a4d53d4892b0f64e64484ccd85483db","src/traits/mod.rs":"61406c4d2603299e4bad57c6f90115cadf93cee50a857bbfbb00d99f3a6873ac","src/traits/model.rs":"efde2b5cae4c4f018436bb68b236f354b5a733f7dafdeaf3f1c534b469a22d64","src/util.rs":"53255c65e85b97236cb34b452e2cb522edf377f49d2232645e0e0e33c447bb23"},"package":"1f25e625fc4c645ce995c5609a9fdff6f047d6a5e4d6be9dc167999a43197f58"}
+6
View File
@@ -90,6 +90,12 @@ pub struct BoardData {
pub tuned: Option<bool>,
/// Whether this board is enabled and actively mining
pub active: Option<bool>,
/// The ASIC chip type/model on this board (e.g. "BM1370"), when reported.
/// Not exposed by Antminer/LuxOS (their network API reports only the control
/// board type).
pub chip_type: Option<String>,
/// The hashboard model / part identifier (e.g. "A3HB70601"), when reported.
pub hashboard_model: Option<String>,
}
impl BoardData {
+12
View File
@@ -56,9 +56,18 @@ pub enum DataField {
/// Expected hashrate for the miner.
#[cfg_attr(feature = "python", pydantic(value = "ExpectedHashrate"))]
ExpectedHashrate,
/// Rolling average hashrate windows (1m/5m/15m/24h) reported by the miner.
#[cfg_attr(feature = "python", pydantic(value = "HashrateAverages"))]
HashrateAverages,
/// Fan speed or fan configuration.
#[cfg_attr(feature = "python", pydantic(value = "Fans"))]
Fans,
/// Miner-level fan duty cycle as a percentage (0-100).
#[cfg_attr(feature = "python", pydantic(value = "FanSpeedPercent"))]
FanSpeedPercent,
/// Board temperature safety thresholds (critical / shutdown), in Celsius.
#[cfg_attr(feature = "python", pydantic(value = "TemperatureLimits"))]
TemperatureLimits,
/// PSU fan speed or configuration.
#[cfg_attr(feature = "python", pydantic(value = "PsuFans"))]
PsuFans,
@@ -108,6 +117,9 @@ pub enum DataField {
/// Difficulty of the best share found over the miner's lifetime, when reported.
#[cfg_attr(feature = "python", pydantic(value = "BestShare"))]
BestShare,
/// Cumulative share statistics (difficulty accepted/rejected, stale, blocks).
#[cfg_attr(feature = "python", pydantic(value = "ShareSummary"))]
ShareSummary,
/// Difficulty of the best share found since the last boot or hashing start, when reported.
#[cfg_attr(feature = "python", pydantic(value = "SessionBestShare"))]
SessionBestShare,
+29
View File
@@ -318,3 +318,32 @@ impl Div<HashRate> for Power {
self.as_watts() / hash_rate.value
}
}
/// Rolling average hashrate over standard time windows, as reported by firmware.
///
/// Each window is optional; a backend fills in only the windows its firmware
/// exposes. The 24h window is reported by Braiins only. Every value carries the
/// same unit and mining algorithm as the miner's current hashrate.
#[cfg_attr(feature = "python", pyclass(from_py_object, module = "asic_rs"))]
#[cfg_attr(feature = "python", asic_rs_pydantic::py_pydantic_model(getters))]
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default, TS)]
pub struct HashrateAverages {
/// Average hashrate over the last minute, when reported.
pub avg_1m: Option<HashRate>,
/// Average hashrate over the last 5 minutes, when reported.
pub avg_5m: Option<HashRate>,
/// Average hashrate over the last 15 minutes, when reported.
pub avg_15m: Option<HashRate>,
/// Average hashrate over the last 24 hours, when reported (Braiins only).
pub avg_24h: Option<HashRate>,
}
impl HashrateAverages {
/// True when no window is populated.
pub fn is_empty(&self) -> bool {
self.avg_1m.is_none()
&& self.avg_5m.is_none()
&& self.avg_15m.is_none()
&& self.avg_24h.is_none()
}
}
+14 -1
View File
@@ -12,11 +12,12 @@ use super::{
capabilities::TuningCapabilities,
device::DeviceInfo,
fan::FanData,
hashrate::HashRate,
hashrate::{HashRate, HashrateAverages},
message::MinerMessage,
operating_state::OperatingState,
pool::PoolGroupData,
psu::PsuInfo,
share::ShareSummary,
};
use crate::data::{
deserialize::deserialize_macaddr,
@@ -165,6 +166,8 @@ pub struct MinerData {
pub hashboards: Vec<BoardData>,
/// The current hashrate of the miner
pub hashrate: Option<HashRate>,
/// Rolling average hashrate windows (1m/5m/15m/24h), when reported
pub hashrate_averages: Option<HashrateAverages>,
/// The expected hashrate of the miner
pub expected_hashrate: Option<HashRate>,
/// The total expected number of chips across all boards on this miner
@@ -175,6 +178,13 @@ pub struct MinerData {
pub expected_fans: Option<u8>,
/// The current fan information for the miner
pub fans: Vec<FanData>,
/// Miner-level fan duty cycle as a percentage (0-100), when reported. Firmware
/// exposes no maximum RPM, so this duty cycle is the normalized fan indicator.
pub fan_speed_percent: Option<f64>,
/// Board critical temperature threshold in Celsius, when reported (round 19 #10).
pub temp_critical: Option<f64>,
/// Board shutdown temperature threshold in Celsius, when reported (round 19 #10).
pub temp_shutdown: Option<f64>,
/// The current PDU fan information for the miner
pub psu_fans: Vec<FanData>,
/// The average temperature across all chips in the miner
@@ -235,6 +245,9 @@ pub struct MinerData {
/// Difficulty of the best share found since the last boot or hashing start,
/// when the firmware distinguishes session from all-time.
pub session_best_share: Option<f64>,
/// Cumulative share statistics (difficulty accepted/rejected, stale, blocks),
/// when reported. Miner-level aggregate from the cgminer/btminer summary.
pub share_summary: Option<ShareSummary>,
}
#[cfg(feature = "python")]
+2
View File
@@ -19,6 +19,8 @@ pub struct PsuInfo {
pub model: Option<String>,
/// PSU firmware/hardware version, when reported.
pub version: Option<String>,
/// PSU serial number, when reported (Braiins, WhatsMiner V3, VNish).
pub serial: Option<String>,
/// Minimum rated output voltage in volts, when reported.
pub voltage_min: Option<f64>,
/// Maximum rated output voltage in volts, when reported.
+54
View File
@@ -3,7 +3,61 @@
//! Firmwares report best-share difficulty as a JSON number, a decimal string,
//! or an AxeOS-style suffix string (`"483k"`, `"1.2M"`).
#[cfg(feature = "python")]
use pyo3::pyclass;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use ts_rs::TS;
/// Cumulative share statistics reported by a miner (round 19 #10, T2).
///
/// These are miner-level aggregates from the cgminer/btminer summary. Difficulty
/// values are difficulty-weighted sums (not raw share counts, which live on
/// [`PoolData`][`super::pool::PoolData`]). Every field is optional; a backend
/// fills in only what its firmware exposes.
#[cfg_attr(feature = "python", pyclass(from_py_object, module = "asic_rs"))]
#[cfg_attr(feature = "python", asic_rs_pydantic::py_pydantic_model(getters))]
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default, TS)]
pub struct ShareSummary {
/// Difficulty-weighted accepted work, when reported.
pub difficulty_accepted: Option<f64>,
/// Difficulty-weighted rejected work, when reported.
pub difficulty_rejected: Option<f64>,
/// Raw stale share count, when reported.
pub stale_shares: Option<u64>,
/// Number of blocks found by this miner, when reported.
pub found_blocks: Option<u64>,
}
impl ShareSummary {
/// True when no field is populated.
pub fn is_empty(&self) -> bool {
self.difficulty_accepted.is_none()
&& self.difficulty_rejected.is_none()
&& self.stale_shares.is_none()
&& self.found_blocks.is_none()
}
}
/// Parse a [`ShareSummary`] from a cgminer/btminer `SUMMARY[0]` object (the value
/// extracted at `/SUMMARY/0`). Reads "Difficulty Accepted", "Difficulty Rejected",
/// "Stale", and "Found Blocks". Returns `None` when none are present.
pub fn parse_cgminer_share_summary(summary: &Value) -> Option<ShareSummary> {
let f = |k: &str| {
summary
.get(k)
.and_then(|v| v.as_f64())
.filter(|v| v.is_finite() && *v >= 0.0)
};
let u = |k: &str| summary.get(k).and_then(|v| v.as_u64());
let s = ShareSummary {
difficulty_accepted: f("Difficulty Accepted"),
difficulty_rejected: f("Difficulty Rejected"),
stale_shares: u("Stale"),
found_blocks: u("Found Blocks"),
};
(!s.is_empty()).then_some(s)
}
/// Parse a share difficulty from a JSON value.
///
+58 -1
View File
@@ -28,12 +28,13 @@ use crate::{
device::DeviceInfo,
fan::FanData,
firmware::{FirmwareImage, FirmwareStats},
hashrate::{HashRate, HashRateUnit},
hashrate::{HashRate, HashRateUnit, HashrateAverages},
message::MinerMessage,
miner::{MinerData, TuningTarget},
operating_state::OperatingState,
pool::PoolGroupData,
psu::PsuInfo,
share::ShareSummary,
},
traits::firmware::MinerFirmware,
traits::model::MinerModel,
@@ -271,6 +272,7 @@ impl<
let control_board_version = self.parse_control_board_version(&data);
let uptime = self.parse_uptime(&data);
let hashrate = self.parse_hashrate(&data);
let hashrate_averages = self.parse_hashrate_averages(&data);
let expected_hashrate = self.parse_expected_hashrate(&data);
let wattage = self.parse_wattage(&data);
let psu = self.parse_psu(&data);
@@ -280,7 +282,9 @@ impl<
let tuning_capabilities = self.parse_tuning_capabilities(&data);
let fluid_temperature = self.parse_fluid_temperature(&data);
let outlet_fluid_temperature = self.parse_outlet_fluid_temperature(&data);
let (temp_critical, temp_shutdown) = self.parse_temperature_limits(&data);
let fans = self.parse_fans(&data);
let fan_speed_percent = self.parse_fan_speed_percent(&data);
let psu_fans = self.parse_psu_fans(&data);
let hashboards = self.parse_hashboards(&data);
let light_flashing = self.parse_light_flashing(&data);
@@ -290,6 +294,7 @@ impl<
let pools = self.parse_pools(&data);
let best_share = self.parse_best_share(&data);
let session_best_share = self.parse_session_best_share(&data);
let share_summary = self.parse_share_summary(&data);
let device_info = self.get_device_info();
// computed fields
@@ -353,6 +358,7 @@ impl<
expected_hashboards: device_info.hardware.board_count(),
hashboards,
hashrate,
hashrate_averages,
expected_hashrate,
// Chip information
@@ -362,6 +368,9 @@ impl<
// Cooling information
expected_fans: device_info.hardware.fans,
fans,
fan_speed_percent,
temp_critical,
temp_shutdown,
psu_fans,
average_temperature,
fluid_temperature,
@@ -386,6 +395,7 @@ impl<
pools,
best_share,
session_best_share,
share_summary,
}
}
}
@@ -632,6 +642,20 @@ pub trait GetHashrate: CollectData {
fn parse_hashrate(&self, data: &HashMap<DataField, Value>) -> Option<HashRate> {
None
}
#[tracing::instrument(level = "debug")]
async fn get_hashrate_averages(&self) -> Option<HashrateAverages> {
let mut collector = self.get_collector();
let data = collector
.collect(&[DataField::HashrateAverages, DataField::Hashrate])
.await;
self.parse_hashrate_averages(&data)
}
/// Rolling average hashrate windows. Backends that expose them override this;
/// the values carry the same unit and algorithm as the current hashrate.
#[allow(unused_variables)]
fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
None
}
}
// Expected Hashrate
@@ -663,6 +687,18 @@ pub trait GetFans: CollectData {
fn parse_fans(&self, data: &HashMap<DataField, Value>) -> Vec<FanData> {
vec![]
}
#[tracing::instrument(level = "debug")]
async fn get_fan_speed_percent(&self) -> Option<f64> {
let mut collector = self.get_collector();
let data = collector.collect(&[DataField::FanSpeedPercent]).await;
self.parse_fan_speed_percent(&data)
}
/// Miner-level fan duty cycle as a percentage (0-100). Backends that expose it
/// override this; others return None.
#[allow(unused_variables)]
fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
None
}
}
// PSU Fans
@@ -708,6 +744,15 @@ pub trait GetFluidTemperature: CollectData {
) -> Option<Temperature> {
None
}
/// Board temperature safety thresholds as (critical, shutdown) in Celsius.
/// Backends that expose them override this; others return (None, None).
#[allow(unused_variables)]
fn parse_temperature_limits(
&self,
data: &HashMap<DataField, Value>,
) -> (Option<f64>, Option<f64>) {
(None, None)
}
}
// Wattage
@@ -898,6 +943,18 @@ pub trait GetBestShare: CollectData {
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
None
}
#[tracing::instrument(level = "debug")]
async fn get_share_summary(&self) -> Option<ShareSummary> {
let mut collector = self.get_collector();
let data = collector.collect(&[DataField::ShareSummary]).await;
self.parse_share_summary(&data)
}
/// Cumulative share statistics (difficulty accepted/rejected, stale, blocks).
/// Backends that expose them override this; others return None.
#[allow(unused_variables)]
fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
None
}
}
// Best share difficulty (this session / since boot)
+1 -1
View File
@@ -1 +1 @@
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"6e42d50107b1a43fd7cf4a4c4f538468a337ed219ad8d6b23bd9abdabd123bd5","Cargo.lock":"7f984c7231c91f2def8f3e2e923a85c2e0b3239492f5ce23400881ea4de1aa16","Cargo.toml":"8a447efc18cd97d019a9771fb258b06f694499500561564eec75480e46bcc554","Cargo.toml.orig":"6c9e7b86804255debe03545c6358eb975d3d470810a19e6c40c680299a686b1f","src/backends/mod.rs":"65cdc60cdf38968f5a7e197338f4cf6173406ce69a4f0aaa96a9e29f4f581b6e","src/backends/v2020/firmware.rs":"5a41bfb8f42f17523e68f8702e87d75bcdb268bd4950bb66227f6966ef3576a9","src/backends/v2020/mod.rs":"efcaa6b186c8b6e79e9799a647291b895c5ff59f058722e98455ef68bc97c548","src/backends/v2020/rpc.rs":"b517f88b9125fe1d8a20d5167f5d0d105b1339fce3d1a9fad5592e00470f46fb","src/backends/v2020/web.rs":"a6a3ad3eb77551b098b0092553b02cee43d165476d8c92164e12a1e765753b0d","src/backends/v2023_07/firmware.rs":"c07668e351d48dab3e24511b1aa9ab5e408bbcb5a438fdb0542a1377f94b9bbb","src/backends/v2023_07/mod.rs":"0c294d8515c56149571d2a504d68352bdaa206d0b996056f560c2ec60d9927f4","src/backends/v2023_07/rpc.rs":"2b24bbb432b302dd15f7a354054fc96c6a75cac2c8e75b8bcc11da37255a05a3","src/backends/v2023_07/web.rs":"d39b67ed83781b2c4fa84a445b9ffe785ae3001941f800ad9860e050c61c6506","src/firmware.rs":"e75c21d63218204b61bfab067599402e5c0b20452beaf0b16bfa79bf8afb6b35","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"a3ef4d6805bb4f8ea087e3a9b875e5a1664580e1ff3e3cd2015bb0c5c18ae7bb","src/test/json/v2020/devs.json":"df17cdfc9522e23450702b93f70ff701892db54c6ce6d986300453ad5e0d22db","src/test/json/v2020/mod.rs":"4c2512d36af834d400a865a94c2e8b1919f9d8dcbf54ab2530c73861c51af67d","src/test/json/v2020/pools.json":"4c4d19ad3ef0de84bfb18daaa48428b5f7917d23287c0196eacf3a6e389e7634","src/test/json/v2020/stats.json":"6d3cb463abb7539ae77aa44ef38e62a5dc0db54670aeacf3bbd01e83f49aa1fd","src/test/json/v2020/summary.json":"2f18c81f989b7c5f70dcb0ddac0520e56ec98b6da25c24e59354a6126c965dae","src/test/json/v2020/system_info.json":"51d1ce922e39a254518a24be56ca86ef1b5843582fb26c1ff0ec4ff6f8f91ccf","src/test/json/v2020/version.json":"ae898c4c9ea3462c3e79f9de755f1fccb4ef122b94a4a512e61aa74491c1a8e9","src/test/json/v2023_07/l11_stats.json":"2eab324f253ced9a0ea4e46466691e0e71fc6fde7558fec86bd5acf6bb9c717d","src/test/json/v2023_07/l11_summary.json":"1e0fdb61b968005d0ec5393d9dc889b09efb1398ffa427629bcc0a98d1b67c22","src/test/json/v2023_07/l11_version.json":"d116921a71731c6e492aed109731c39561e34a24c7df2a88d11ac52b80f6100a","src/test/json/v2023_07/l9_stats.json":"731ee545f16dafd356d22703248b91a37f74585ad73cc27441eb3461ce53dca0","src/test/json/v2023_07/l9_summary.json":"b32b5131ad46859b270d2dbb6bdba3c4e5d7301298daee4ce56332c98faaf81d","src/test/json/v2023_07/l9_version.json":"82f03ca6ea8873f12c4d9455f21b98c547801b58fbff1dcd83c837c0f337a129","src/test/json/v2023_07/mod.rs":"1360a8b155b120f2e755ede0736bcc0d76a9d1d693b984a1b51a16e6c0413791","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"0c06e3ecbf95ae3fe5e30aacae55cf6e7ad3d965f4a93b2f85c7b64f61fc75e2"}
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"6e42d50107b1a43fd7cf4a4c4f538468a337ed219ad8d6b23bd9abdabd123bd5","Cargo.lock":"7f984c7231c91f2def8f3e2e923a85c2e0b3239492f5ce23400881ea4de1aa16","Cargo.toml":"8a447efc18cd97d019a9771fb258b06f694499500561564eec75480e46bcc554","Cargo.toml.orig":"6c9e7b86804255debe03545c6358eb975d3d470810a19e6c40c680299a686b1f","src/backends/mod.rs":"65cdc60cdf38968f5a7e197338f4cf6173406ce69a4f0aaa96a9e29f4f581b6e","src/backends/v2020/firmware.rs":"5a41bfb8f42f17523e68f8702e87d75bcdb268bd4950bb66227f6966ef3576a9","src/backends/v2020/mod.rs":"b2dbba5377a739bc8be3380cfbd09aa80893841c15c305bfd25f900ba7b6a0c9","src/backends/v2020/rpc.rs":"b517f88b9125fe1d8a20d5167f5d0d105b1339fce3d1a9fad5592e00470f46fb","src/backends/v2020/web.rs":"a6a3ad3eb77551b098b0092553b02cee43d165476d8c92164e12a1e765753b0d","src/backends/v2023_07/firmware.rs":"c07668e351d48dab3e24511b1aa9ab5e408bbcb5a438fdb0542a1377f94b9bbb","src/backends/v2023_07/mod.rs":"0906bff13eb51bd47fb0e06cc2c1955fe459c601cb467efc917801ead825dd61","src/backends/v2023_07/rpc.rs":"2b24bbb432b302dd15f7a354054fc96c6a75cac2c8e75b8bcc11da37255a05a3","src/backends/v2023_07/web.rs":"d39b67ed83781b2c4fa84a445b9ffe785ae3001941f800ad9860e050c61c6506","src/firmware.rs":"e75c21d63218204b61bfab067599402e5c0b20452beaf0b16bfa79bf8afb6b35","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"a3ef4d6805bb4f8ea087e3a9b875e5a1664580e1ff3e3cd2015bb0c5c18ae7bb","src/test/json/v2020/devs.json":"df17cdfc9522e23450702b93f70ff701892db54c6ce6d986300453ad5e0d22db","src/test/json/v2020/mod.rs":"4c2512d36af834d400a865a94c2e8b1919f9d8dcbf54ab2530c73861c51af67d","src/test/json/v2020/pools.json":"4c4d19ad3ef0de84bfb18daaa48428b5f7917d23287c0196eacf3a6e389e7634","src/test/json/v2020/stats.json":"6d3cb463abb7539ae77aa44ef38e62a5dc0db54670aeacf3bbd01e83f49aa1fd","src/test/json/v2020/summary.json":"2f18c81f989b7c5f70dcb0ddac0520e56ec98b6da25c24e59354a6126c965dae","src/test/json/v2020/system_info.json":"51d1ce922e39a254518a24be56ca86ef1b5843582fb26c1ff0ec4ff6f8f91ccf","src/test/json/v2020/version.json":"ae898c4c9ea3462c3e79f9de755f1fccb4ef122b94a4a512e61aa74491c1a8e9","src/test/json/v2023_07/l11_stats.json":"2eab324f253ced9a0ea4e46466691e0e71fc6fde7558fec86bd5acf6bb9c717d","src/test/json/v2023_07/l11_summary.json":"1e0fdb61b968005d0ec5393d9dc889b09efb1398ffa427629bcc0a98d1b67c22","src/test/json/v2023_07/l11_version.json":"d116921a71731c6e492aed109731c39561e34a24c7df2a88d11ac52b80f6100a","src/test/json/v2023_07/l9_stats.json":"731ee545f16dafd356d22703248b91a37f74585ad73cc27441eb3461ce53dca0","src/test/json/v2023_07/l9_summary.json":"b32b5131ad46859b270d2dbb6bdba3c4e5d7301298daee4ce56332c98faaf81d","src/test/json/v2023_07/l9_version.json":"82f03ca6ea8873f12c4d9455f21b98c547801b58fbff1dcd83c837c0f337a129","src/test/json/v2023_07/mod.rs":"1360a8b155b120f2e755ede0736bcc0d76a9d1d693b984a1b51a16e6c0413791","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"0c06e3ecbf95ae3fe5e30aacae55cf6e7ad3d965f4a93b2f85c7b64f61fc75e2"}
+38 -1
View File
@@ -21,6 +21,7 @@ use asic_rs_core::{
message::{MessageSeverity, MinerMessage},
miner::{MiningMode, TuningTarget},
pool::{PoolData, PoolGroupData, PoolURL},
share::{ShareSummary, parse_cgminer_share_summary},
},
traits::{miner::*, model::MinerModel},
};
@@ -499,6 +500,26 @@ impl GetDataLocations for AntMinerV2020 {
tag: None,
},
)],
// cgminer summary "Best Share" (all-time). RPC_SUMMARY is already
// fetched, so this adds no round-trip (round 19 #10).
DataField::BestShare => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0/Best Share"),
tag: None,
},
)],
// Cumulative share stats from cgminer summary (round 19 #10, T2);
// RPC_SUMMARY already fetched.
DataField::ShareSummary => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0"),
tag: None,
},
)],
// `total_rateideal`, by contrast, says nothing about its own
// scale, so carry STATS' `rate_unit` alongside it.
DataField::ExpectedHashrate => vec![
@@ -873,7 +894,17 @@ impl GetUptime for AntMinerV2020 {
}
}
impl GetBestShare for AntMinerV2020 {}
impl GetBestShare for AntMinerV2020 {
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
// cgminer summary "Best Share" (all-time); guard against a 0 placeholder
// (round 19 #10).
data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
}
fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
data.get(&DataField::ShareSummary)
.and_then(parse_cgminer_share_summary)
}
}
impl GetSessionBestShare for AntMinerV2020 {}
impl GetOperatingState for AntMinerV2020 {}
@@ -1663,6 +1694,12 @@ mod tests {
algo: HashAlgorithm::SHA256,
}
);
// Cumulative share stats from cgminer summary (round 19 #10, T2).
let shares = miner_data.share_summary.expect("share summary");
assert_eq!(shares.difficulty_accepted, Some(1305083904.0));
assert_eq!(shares.difficulty_rejected, Some(2490368.0));
assert_eq!(shares.stale_shares, Some(1));
assert_eq!(shares.found_blocks, Some(0));
}
#[tokio::test]
@@ -23,6 +23,7 @@ use asic_rs_core::{
message::{MessageSeverity, MinerMessage},
miner::{MiningMode, TuningTarget},
pool::{PoolData, PoolGroupData, PoolURL},
share::{ShareSummary, parse_cgminer_share_summary},
},
traits::{miner::*, model::MinerModel},
};
@@ -547,6 +548,16 @@ impl GetDataLocations for AntMinerV202307 {
tag: None,
},
)],
// Cumulative share stats from cgminer summary (round 19 #10, T2);
// RPC_SUMMARY already fetched.
DataField::ShareSummary => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0"),
tag: None,
},
)],
DataField::SessionBestShare => vec![(
RPC_SUMMARY,
DataExtractor {
@@ -955,6 +966,10 @@ impl GetBestShare for AntMinerV202307 {
// reports 0 when it has never found a share (round 17 R7).
data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
}
fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
data.get(&DataField::ShareSummary)
.and_then(parse_cgminer_share_summary)
}
}
impl GetSessionBestShare for AntMinerV202307 {
File diff suppressed because one or more lines are too long
+58 -1
View File
@@ -16,7 +16,7 @@ use asic_rs_core::{
command::MinerCommand,
device::{DeviceInfo, HashAlgorithm},
fan::FanData,
hashrate::{HashRate, HashRateUnit},
hashrate::{HashRate, HashRateUnit, HashrateAverages},
message::{MessageSeverity, MinerMessage},
miner::TuningTarget,
operating_state::OperatingState,
@@ -204,6 +204,16 @@ impl GetDataLocations for BraiinsV2507 {
tag: None,
},
)],
// Rolling averages from miner_stats real_hashrate (round 19 #10, T2);
// command already fetched. Braiins reports the full 1m/5m/15m/24h set.
DataField::HashrateAverages => vec![(
WEB_MINER_STATS,
DataExtractor {
func: get_by_pointer,
key: Some("/miner_stats/real_hashrate"),
tag: None,
},
)],
DataField::ExpectedHashrate => vec![(
WEB_MINER_DETAILS,
DataExtractor {
@@ -220,6 +230,16 @@ impl GetDataLocations for BraiinsV2507 {
tag: None,
},
)],
// Miner-level fan duty cycle (round 19 #10, T3): max target_speed_ratio;
// cooling state already fetched.
DataField::FanSpeedPercent => vec![(
WEB_COOLING_STATE,
DataExtractor {
func: get_by_pointer,
key: Some("/fans"),
tag: None,
},
)],
DataField::Hashboards => vec![(
WEB_HASHBOARDS,
DataExtractor {
@@ -494,6 +514,31 @@ impl GetHashrate for BraiinsV2507 {
.as_unit(HashRateUnit::default())
})
}
fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
// miner_stats real_hashrate last_1m/5m/15m/24h (GigaHash); full window set
// (round 19 #10).
let d = data.get(&DataField::HashrateAverages)?;
let ghs = |k: &str| {
d.pointer(&format!("/{k}/gigahash_per_second"))
.and_then(|v| v.as_f64())
.filter(|&f| f > 0.0)
.map(|f| {
HashRate {
value: f,
unit: HashRateUnit::GigaHash,
algo: self.device_info.algo,
}
.as_unit(HashRateUnit::default())
})
};
let avgs = HashrateAverages {
avg_1m: ghs("last_1m"),
avg_5m: ghs("last_5m"),
avg_15m: ghs("last_15m"),
avg_24h: ghs("last_24h"),
};
(!avgs.is_empty()).then_some(avgs)
}
}
impl GetExpectedHashrate for BraiinsV2507 {
@@ -532,6 +577,18 @@ impl GetFans for BraiinsV2507 {
fans
}
fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
// Braiins fans[].target_speed_ratio is a 0-1 duty ratio; report the max as
// a percentage (round 19 #10, T3).
data.get(&DataField::FanSpeedPercent)
.and_then(|v| v.as_array())
.into_iter()
.flatten()
.filter_map(|f| f.pointer("/target_speed_ratio").and_then(|v| v.as_f64()))
.filter(|v| v.is_finite() && *v >= 0.0)
.map(|v| v * 100.0)
.max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
}
}
impl GetLightFlashing for BraiinsV2507 {
+90 -6
View File
@@ -17,7 +17,7 @@ use asic_rs_core::{
device::{DeviceInfo, HashAlgorithm},
fan::FanData,
firmware::{FirmwareStats, FirmwareUpdate},
hashrate::{HashRate, HashRateUnit},
hashrate::{HashRate, HashRateUnit, HashrateAverages},
message::{MessageSeverity, MinerMessage},
miner::TuningTarget,
operating_state::OperatingState,
@@ -207,6 +207,16 @@ impl GetDataLocations for BraiinsV2604 {
tag: None,
},
)],
// Rolling averages from miner_stats real_hashrate (round 19 #10, T2);
// command already fetched. Braiins reports the full 1m/5m/15m/24h set.
DataField::HashrateAverages => vec![(
WEB_MINER_STATS,
DataExtractor {
func: get_by_pointer,
key: Some("/miner_stats/real_hashrate"),
tag: None,
},
)],
DataField::ExpectedHashrate => vec![(
WEB_MINER_DETAILS,
DataExtractor {
@@ -223,6 +233,16 @@ impl GetDataLocations for BraiinsV2604 {
tag: None,
},
)],
// Miner-level fan duty cycle (round 19 #10, T3): max target_speed_ratio;
// cooling state already fetched.
DataField::FanSpeedPercent => vec![(
WEB_COOLING_STATE,
DataExtractor {
func: get_by_pointer,
key: Some("/fans"),
tag: None,
},
)],
DataField::Hashboards => vec![(
WEB_HASHBOARDS,
DataExtractor {
@@ -498,6 +518,16 @@ impl GetHashboards for BraiinsV2604 {
.and_then(|v| v.as_f64())
.map(Frequency::from_hertz);
board.active = chain.pointer("/enabled").and_then(|v| v.as_bool());
// ASIC chip model + hashboard model/part (round 19 #10 telemetry
// extension). BOS+ miner/hw/hashboards reports chip_type ("BM1370")
// and model ("A3HB70601"); board_name is the human label if present.
board.chip_type =
chain.pointer("/chip_type").and_then(|v| v.as_str()).map(str::to_string);
board.hashboard_model = chain
.pointer("/model")
.or_else(|| chain.pointer("/board_name"))
.and_then(|v| v.as_str())
.map(str::to_string);
}
hashboards
@@ -515,6 +545,31 @@ impl GetHashrate for BraiinsV2604 {
.as_unit(HashRateUnit::default())
})
}
fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
// miner_stats real_hashrate last_1m/5m/15m/24h (GigaHash); full window set
// (round 19 #10).
let d = data.get(&DataField::HashrateAverages)?;
let ghs = |k: &str| {
d.pointer(&format!("/{k}/gigahash_per_second"))
.and_then(|v| v.as_f64())
.filter(|&f| f > 0.0)
.map(|f| {
HashRate {
value: f,
unit: HashRateUnit::GigaHash,
algo: self.device_info.algo,
}
.as_unit(HashRateUnit::default())
})
};
let avgs = HashrateAverages {
avg_1m: ghs("last_1m"),
avg_5m: ghs("last_5m"),
avg_15m: ghs("last_15m"),
avg_24h: ghs("last_24h"),
};
(!avgs.is_empty()).then_some(avgs)
}
}
impl GetExpectedHashrate for BraiinsV2604 {
@@ -553,6 +608,18 @@ impl GetFans for BraiinsV2604 {
fans
}
fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
// Braiins fans[].target_speed_ratio is a 0-1 duty ratio; report the max as
// a percentage (round 19 #10, T3).
data.get(&DataField::FanSpeedPercent)
.and_then(|v| v.as_array())
.into_iter()
.flatten()
.filter_map(|f| f.pointer("/target_speed_ratio").and_then(|v| v.as_f64()))
.filter(|v| v.is_finite() && *v >= 0.0)
.map(|v| v * 100.0)
.max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
}
}
impl GetLightFlashing for BraiinsV2604 {
@@ -676,13 +743,15 @@ impl GetWattage for BraiinsV2604 {
}
fn parse_psu(&self, data: &HashMap<DataField, Value>) -> Option<PsuInfo> {
// BOS miner/details -> psu_info {version, min_voltage.volt, max_voltage.volt}.
// "version" is the PSU type code (117 = the APW12 ePIC also reports as model
// 117), so expose it as the model for consistency across firmwares.
// BOS miner/details -> psu_info { model_name, fw_version, serial_number,
// version (numeric type code), min_voltage.volt, max_voltage.volt }. Read
// the human model_name and the firmware version (the old code used the
// numeric "version" type code as the model and dropped fw_version entirely).
let d = data.get(&DataField::Psu)?;
let psu = PsuInfo {
model: d.pointer("/version").and_then(|v| v.as_i64()).map(|n| n.to_string()),
version: None,
model: d.pointer("/model_name").and_then(|v| v.as_str()).map(str::to_string),
version: d.pointer("/fw_version").and_then(|v| v.as_i64()).map(|n| n.to_string()),
serial: d.pointer("/serial_number").and_then(|v| v.as_str()).map(str::to_string),
voltage_min: d.pointer("/min_voltage/volt").and_then(|v| v.as_f64()),
voltage_max: d.pointer("/max_voltage/volt").and_then(|v| v.as_f64()),
output_voltage: None,
@@ -1229,6 +1298,21 @@ mod tests {
assert_eq!(miner_data.pools[0].len(), 2);
assert!(miner_data.hashrate.is_some());
assert!(miner_data.expected_hashrate.is_some());
// Rolling averages: miner_stats real_hashrate last_1m/5m/15m/24h (GigaHash);
// Braiins reports the full window set (round 19 #10, T2).
let avgs = miner_data
.hashrate_averages
.expect("braiins exposes rolling averages");
assert!(avgs.avg_1m.is_some() && avgs.avg_5m.is_some());
assert!(avgs.avg_15m.is_some() && avgs.avg_24h.is_some());
if let Some(hr) = &avgs.avg_1m {
assert_eq!(hr.unit, HashRateUnit::TeraHash);
assert!((hr.value - 247.3507543407177).abs() < 1e-3);
}
// Miner-level fan duty cycle = max target_speed_ratio (0.92) x 100 (round
// 19 #10, T3).
let fan_pct = miner_data.fan_speed_percent.expect("braiins fan duty");
assert!((fan_pct - 92.0).abs() < 1e-6);
}
#[test]
+1 -1
View File
@@ -1 +1 @@
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"4c9489c1f9b5f16e3fd8ab777da35bb120ccd0ca05f780cf94853c89fb5c8946","Cargo.lock":"69db8793725d6071e21b4353fb89537912096d7eccebd6ee597367330141f613","Cargo.toml":"df82261a9c3187bee15a7d6092d54ad2e9c7e4d1f127cd577c457d913f6881cf","Cargo.toml.orig":"e7c4ef90bc86763dad35d1a4da1c17c7e2f59eaac79e2f011647ae31c43d5e2b","src/backends/mod.rs":"1362c4d3805dccb7a78ef6b45d6a81b8f63b2be75fcf80329b6c2b0dd9e2d5c5","src/backends/v1/mod.rs":"dff1b68393fd0a065dc67a16219654f279cbfb9adad2eaea35caedea26df989f","src/backends/v1/web.rs":"3a567a4f581baa5d9d2d4e59d8acc754eec51d49b0a4f5434d87614b037a4a55","src/firmware.rs":"fb88124a51089756cc3271f3d4a234d73add61ab919c4710ef26a52dc8b5ef80","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"24191681066d5cf6a3022ad59c1baa92b57e3ce7717bb78d6a682af9e19a38c4","src/test/json/v1/capabilities.json":"d2b3dae7aa2a1e2977e0ddf62cf2d730de64cf12bf62388c12fd23dc5278bbcb","src/test/json/v1/chip_clocks.json":"d1f46d3aad6ad55ec1c02d0b26aa4c5034c1ccaefb130d7b0e46efe48bb122a0","src/test/json/v1/chip_hashrates.json":"9601a1289f93fe4e27c722d51b3a31daa71aec71f2c29e71f6d1eefe01edf7f2","src/test/json/v1/chip_temps.json":"cb7390e424af57f55f0c974ddfe0c98c4d5b4dbcd85887e38ff8caf7b19f62fe","src/test/json/v1/chip_voltages.json":"cb7390e424af57f55f0c974ddfe0c98c4d5b4dbcd85887e38ff8caf7b19f62fe","src/test/json/v1/mod.rs":"5671105221b84b0b6edb2df34b25bfc9e33459da285d4316be0db23ddb630e8d","src/test/json/v1/network.json":"3374b419fa2f0bc19544c670e08118bbc45bd4d121a577c5a6403c8c8100f628","src/test/json/v1/summary.json":"ac8ac018da9d619b5884f283b730bad2bf0a7e8f2032a7119193c9e5d87d6a7c","src/test/json/v1/temps.json":"794edf870985ed4398ead96670b8f5d01deb4d825fb14a8325087a29cd939fa8","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"268dc7c8b3289fccd3230ff87f7bfc727a3e7e2f6f72ae56ab9d27c63eabc5cf"}
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"4c9489c1f9b5f16e3fd8ab777da35bb120ccd0ca05f780cf94853c89fb5c8946","Cargo.lock":"69db8793725d6071e21b4353fb89537912096d7eccebd6ee597367330141f613","Cargo.toml":"df82261a9c3187bee15a7d6092d54ad2e9c7e4d1f127cd577c457d913f6881cf","Cargo.toml.orig":"e7c4ef90bc86763dad35d1a4da1c17c7e2f59eaac79e2f011647ae31c43d5e2b","src/backends/mod.rs":"1362c4d3805dccb7a78ef6b45d6a81b8f63b2be75fcf80329b6c2b0dd9e2d5c5","src/backends/v1/mod.rs":"b2b4155236fae7cc3e112f892b64ea1d476e90ec591f3ad9fec26fe3ce03bb35","src/backends/v1/web.rs":"3a567a4f581baa5d9d2d4e59d8acc754eec51d49b0a4f5434d87614b037a4a55","src/firmware.rs":"fb88124a51089756cc3271f3d4a234d73add61ab919c4710ef26a52dc8b5ef80","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"24191681066d5cf6a3022ad59c1baa92b57e3ce7717bb78d6a682af9e19a38c4","src/test/json/v1/capabilities.json":"d2b3dae7aa2a1e2977e0ddf62cf2d730de64cf12bf62388c12fd23dc5278bbcb","src/test/json/v1/chip_clocks.json":"d1f46d3aad6ad55ec1c02d0b26aa4c5034c1ccaefb130d7b0e46efe48bb122a0","src/test/json/v1/chip_hashrates.json":"9601a1289f93fe4e27c722d51b3a31daa71aec71f2c29e71f6d1eefe01edf7f2","src/test/json/v1/chip_temps.json":"cb7390e424af57f55f0c974ddfe0c98c4d5b4dbcd85887e38ff8caf7b19f62fe","src/test/json/v1/chip_voltages.json":"cb7390e424af57f55f0c974ddfe0c98c4d5b4dbcd85887e38ff8caf7b19f62fe","src/test/json/v1/mod.rs":"5671105221b84b0b6edb2df34b25bfc9e33459da285d4316be0db23ddb630e8d","src/test/json/v1/network.json":"3374b419fa2f0bc19544c670e08118bbc45bd4d121a577c5a6403c8c8100f628","src/test/json/v1/summary.json":"ac8ac018da9d619b5884f283b730bad2bf0a7e8f2032a7119193c9e5d87d6a7c","src/test/json/v1/temps.json":"794edf870985ed4398ead96670b8f5d01deb4d825fb14a8325087a29cd939fa8","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"268dc7c8b3289fccd3230ff87f7bfc727a3e7e2f6f72ae56ab9d27c63eabc5cf"}
+60 -1
View File
@@ -473,6 +473,25 @@ impl GetDataLocations for PowerPlayV1 {
tag: None,
},
)],
// Miner-level fan duty cycle (round 19 #10, T3); summary already fetched.
DataField::FanSpeedPercent => vec![(
WEB_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/Fans/Fans Speed"),
tag: None,
},
)],
// Board temperature thresholds (round 19 #10, T3); summary /Misc carries
// Critical Temp and Shutdown Temp. Already fetched.
DataField::TemperatureLimits => vec![(
WEB_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/Misc"),
tag: None,
},
)],
DataField::Hashboards => vec![
(
WEB_TEMPS,
@@ -797,6 +816,21 @@ impl GetHashboards for PowerPlayV1 {
.pointer("/Capabilities/Performance Estimator/Hashes Per Second Per Chip")
.and_then(|v| v.as_f64());
// ASIC chip type + hashboard model from capabilities (round 19 #10);
// capabilities reports them miner-wide, so apply to every board.
let chip_type =
api_data.pointer("/Capabilities/Chip Type").and_then(|v| v.as_str()).map(str::to_string);
let hashboard_model = api_data
.pointer("/Capabilities/Model Subtype")
.and_then(|v| v.as_str())
.map(str::to_string);
if chip_type.is_some() || hashboard_model.is_some() {
for board in &mut hashboards {
board.chip_type = chip_type.clone();
board.hashboard_model = hashboard_model.clone();
}
}
// Active status
if let Some(boards) = api_data
.pointer("/Summary/HBStatus")
@@ -1105,12 +1139,31 @@ impl GetFans for PowerPlayV1 {
fans
}
fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
// ePIC summary /Fans/Fans Speed is a single miner-level duty % (round 19 #10).
data.extract::<f64>(DataField::FanSpeedPercent)
.filter(|v| v.is_finite() && *v >= 0.0)
}
}
impl GetPsuFans for PowerPlayV1 {}
impl GetTuningCapabilities for PowerPlayV1 {}
impl GetFluidTemperature for PowerPlayV1 {}
impl GetFluidTemperature for PowerPlayV1 {
fn parse_temperature_limits(
&self,
data: &HashMap<DataField, Value>,
) -> (Option<f64>, Option<f64>) {
// ePIC summary /Misc: Critical Temp + Shutdown Temp (round 19 #10, T3).
let d = data.get(&DataField::TemperatureLimits);
let f = |k: &str| {
d.and_then(|v| v.pointer(k))
.and_then(|v| v.as_f64())
.filter(|v| v.is_finite() && *v > 0.0)
};
(f("/Critical Temp"), f("/Shutdown Temp"))
}
}
impl GetWattage for PowerPlayV1 {
fn parse_wattage(&self, data: &HashMap<DataField, Value>) -> Option<Power> {
@@ -1128,6 +1181,7 @@ impl GetWattage for PowerPlayV1 {
let psu = PsuInfo {
model: f(info, "/PSU Type").map(|n| format!("{n:.0}")),
version: f(info, "/FW").map(|n| format!("{n:.0}")),
serial: None, // ePIC capabilities does not report a PSU serial
voltage_min: f(info, "/Min Vout").map(|mv| mv / 1000.0),
voltage_max: f(info, "/Max Vout").map(|mv| mv / 1000.0),
output_voltage: f(stats, "/Output Voltage"),
@@ -2173,6 +2227,11 @@ mod tests {
assert_eq!(miner_data.uptime, Some(Duration::from_secs(23170)));
assert_eq!(miner_data.wattage, Some(Power::from_watts(2166.6174)));
// Miner-level fan duty cycle from summary /Fans/Fans Speed (round 19 #10, T3).
assert_eq!(miner_data.fan_speed_percent, Some(100.0));
// Board temp thresholds from summary /Misc (round 19 #10, T3).
assert_eq!(miner_data.temp_critical, Some(100.0));
assert_eq!(miner_data.temp_shutdown, Some(85.0));
assert_eq!(miner_data.hashboards.len(), 3);
assert_eq!(miner_data.hashboards[0].active, Some(false));
assert_eq!(miner_data.hashboards[1].chips.len(), 110);
+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":"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"}
{"$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":"2c04560cd60492adf42bc33549247f70601056a0355aebbf8b5638be881b5627","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"}
+74 -1
View File
@@ -16,10 +16,11 @@ use asic_rs_core::{
command::MinerCommand,
device::{DeviceInfo, HashAlgorithm},
fan::FanData,
hashrate::{HashRate, HashRateUnit},
hashrate::{HashRate, HashRateUnit, HashrateAverages},
message::{MessageSeverity, MinerMessage},
miner::TuningTarget,
pool::{PoolData, PoolGroupData, PoolURL},
share::{ShareSummary, parse_cgminer_share_summary},
},
traits::{miner::*, model::MinerModel},
};
@@ -294,6 +295,16 @@ impl GetDataLocations for LuxMinerV1 {
tag: None,
},
)],
// Miner-level fan duty cycle (round 19 #10, T3): max of per-fan Speed;
// RPC_FANS already fetched.
DataField::FanSpeedPercent => vec![(
RPC_FANS,
DataExtractor {
func: get_by_pointer,
key: Some("/FANS"),
tag: None,
},
)],
DataField::ApiVersion => vec![(
RPC_VERSION,
DataExtractor {
@@ -455,6 +466,16 @@ impl GetDataLocations for LuxMinerV1 {
tag: None,
},
)],
// Cumulative share stats from LuxOS summary (round 19 #10, T2);
// RPC_SUMMARY already fetched.
DataField::ShareSummary => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0"),
tag: None,
},
)],
DataField::SessionBestShare => vec![(
RPC_SUMMARY,
DataExtractor {
@@ -537,6 +558,16 @@ impl GetDataLocations for LuxMinerV1 {
tag: None,
},
)],
// LuxOS summary exposes full rolling windows GHS 1m/5m/15m/24h
// (GigaHash); RPC_SUMMARY is already fetched (round 19 #10, T2).
DataField::HashrateAverages => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0"),
tag: None,
},
)],
DataField::ExpectedHashrate => vec![(
RPC_DEVS,
DataExtractor {
@@ -843,6 +874,30 @@ impl GetHashrate for LuxMinerV1 {
.as_unit(HashRateUnit::default())
})
}
fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
// LuxOS summary GHS 1m/5m/15m/24h (GigaHash); full window set (round 19 #10).
let d = data.get(&DataField::HashrateAverages)?;
let ghs = |k: &str| {
d.pointer(k)
.and_then(|v| v.as_f64())
.filter(|&f| f > 0.0)
.map(|f| {
HashRate {
value: f,
unit: HashRateUnit::GigaHash,
algo: self.device_info.algo,
}
.as_unit(HashRateUnit::default())
})
};
let avgs = HashrateAverages {
avg_1m: ghs("/GHS 1m"),
avg_5m: ghs("/GHS 5m"),
avg_15m: ghs("/GHS 15m"),
avg_24h: ghs("/GHS 24h"),
};
(!avgs.is_empty()).then_some(avgs)
}
}
impl GetExpectedHashrate for LuxMinerV1 {
@@ -891,6 +946,17 @@ impl GetFans for LuxMinerV1 {
})
.collect()
}
fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
// LuxOS FANS[].Speed is per-fan duty %; report the fleet-facing maximum
// (round 19 #10, T3).
data.get(&DataField::FanSpeedPercent)
.and_then(|v| v.as_array())
.into_iter()
.flatten()
.filter_map(|f| f.get("Speed").and_then(|v| v.as_f64()))
.filter(|v| v.is_finite() && *v >= 0.0)
.max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
}
}
impl GetLightFlashing for LuxMinerV1 {
@@ -911,6 +977,10 @@ impl GetBestShare for LuxMinerV1 {
// LuxOS summary -> "Best Share" (all-time), round 16 / G9.
data.extract::<f64>(DataField::BestShare)
}
fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
data.get(&DataField::ShareSummary)
.and_then(parse_cgminer_share_summary)
}
}
impl GetSessionBestShare for LuxMinerV1 {
fn parse_session_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
@@ -1631,6 +1701,9 @@ mod tests {
Some(TuningTarget::Power(Power::from_watts(1188f64)))
);
assert_eq!(miner_data.fans.len(), 4);
// Miner-level fan duty cycle = max of per-fan Speed (all 20 here); round 19
// #10, T3.
assert_eq!(miner_data.fan_speed_percent, Some(20.0));
assert_eq!(miner_data.hashboards[0].chips.len(), 77);
assert_eq!(miner_data.pools.len(), 2);
assert_eq!(miner_data.pools[0].len(), 2);
+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":"12ece361e797e765d9a8d0d233ae045a68f3473faa5da14ada40fdb691abf3a0","Cargo.lock":"b527674a090d313c33a0a22c4d0a81936d5e9c13c2dc4e0d5f468d0d4421f1b8","Cargo.toml":"2ab1a2951b599aa549512faaeadf0d386d291fe6505dc29bf164b234be40869b","Cargo.toml.orig":"8436254854a45004b0cbb2d518fa4b59832cac91de1e5600de32f5baa4300a8c","src/backends/mod.rs":"947a81f33fa6ec8c3a801ad127f59ad78d96de927c3e86bee4587e2aace2914d","src/backends/v2025/mod.rs":"4c7fbda80d5a4717a655538b043f9fe55bd24b676a14ac97f32a53f51a0be40d","src/backends/v2025/rpc.rs":"2ed396bfed1e5d39cd20f90629b10acbde98d8e5c6d35e42ab5309343c90aa8c","src/backends/v2025/web.rs":"07ceefc9813f9c12df4312b249ac9cd49eebaf8466478cf5cfb6c13cc85eee65","src/firmware.rs":"69a62f81a6e7e94b75c1f952f77403451da6945b0683d2e5edfcbd585cc6921e","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"53e0a575ba942b132519c759b328a9ca8fcd67aca3fbfa93b5266ee9661f3579","src/test/json/v2025/get_system_info.json":"d394dd5a4874846c7ab019723e7a6e6c64800ad90fb913bf4ab97af0d806c5ce","src/test/json/v2025/miner_psu_status.json":"d62162f8eb00c4494f9ea421f5f47be13cf89091b9416de38d18fadb33458372","src/test/json/v2025/mod.rs":"8bb0fd3c0af51ece34903a79085e285e99c6dd0f2d11f3e020515d399fc78696","src/test/json/v2025/pools.json":"6ab4894d5b6c6d6359a3d21189be3bffd17f7bd820816a12293e2e8911dbeb6f","src/test/json/v2025/stats.json":"4d54226c4396aba5151a6195744a78c3e60f2807af918849196e76d180ae55c6","src/test/json/v2025/summary.json":"f794595e7068ebc7ace7176f4381b61464057aaa3170d5307971e5fc1a2a37be","src/test/json/v2025/version.json":"177606e67c34a59867b320cb0fe8bf2d1d743ee1e8f14a24b7c588910f9ad22c","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"ff5e051802299683f94b3a3771f065071551c85a1cd21dc09a5f05efce0e90d5"}
{"$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":"12ece361e797e765d9a8d0d233ae045a68f3473faa5da14ada40fdb691abf3a0","Cargo.lock":"b527674a090d313c33a0a22c4d0a81936d5e9c13c2dc4e0d5f468d0d4421f1b8","Cargo.toml":"2ab1a2951b599aa549512faaeadf0d386d291fe6505dc29bf164b234be40869b","Cargo.toml.orig":"8436254854a45004b0cbb2d518fa4b59832cac91de1e5600de32f5baa4300a8c","src/backends/mod.rs":"947a81f33fa6ec8c3a801ad127f59ad78d96de927c3e86bee4587e2aace2914d","src/backends/v2025/mod.rs":"db8ee27c551ae6b5e312e0975823839e3b465ccfdbecc190da2c4e40fa0db1ad","src/backends/v2025/rpc.rs":"2ed396bfed1e5d39cd20f90629b10acbde98d8e5c6d35e42ab5309343c90aa8c","src/backends/v2025/web.rs":"07ceefc9813f9c12df4312b249ac9cd49eebaf8466478cf5cfb6c13cc85eee65","src/firmware.rs":"69a62f81a6e7e94b75c1f952f77403451da6945b0683d2e5edfcbd585cc6921e","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"53e0a575ba942b132519c759b328a9ca8fcd67aca3fbfa93b5266ee9661f3579","src/test/json/v2025/get_system_info.json":"d394dd5a4874846c7ab019723e7a6e6c64800ad90fb913bf4ab97af0d806c5ce","src/test/json/v2025/miner_psu_status.json":"d62162f8eb00c4494f9ea421f5f47be13cf89091b9416de38d18fadb33458372","src/test/json/v2025/mod.rs":"8bb0fd3c0af51ece34903a79085e285e99c6dd0f2d11f3e020515d399fc78696","src/test/json/v2025/pools.json":"6ab4894d5b6c6d6359a3d21189be3bffd17f7bd820816a12293e2e8911dbeb6f","src/test/json/v2025/stats.json":"4d54226c4396aba5151a6195744a78c3e60f2807af918849196e76d180ae55c6","src/test/json/v2025/summary.json":"f794595e7068ebc7ace7176f4381b61464057aaa3170d5307971e5fc1a2a37be","src/test/json/v2025/version.json":"177606e67c34a59867b320cb0fe8bf2d1d743ee1e8f14a24b7c588910f9ad22c","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"ff5e051802299683f94b3a3771f065071551c85a1cd21dc09a5f05efce0e90d5"}
@@ -474,6 +474,7 @@ impl GetHashboards for SealMinerV2025 {
frequency: freq,
tuned,
active: Some(online),
..Default::default()
}
})
.collect()
+1 -1
View File
@@ -1 +1 @@
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"30f09ad063df45fdf223aff235fe2da15cb1a7e79e86d7012074153b91662fc4","Cargo.lock":"9d0886791db53421d3218ab72d964145b86cfbe9738eaf09aac5d3c89a1c0190","Cargo.toml":"8c2e9938436850f2e250e8268ed7b385fce903e2077923b207a0560ca3e3242c","Cargo.toml.orig":"891fcfa45e79d6bc4d838c4f3075618f791bd013c99231da48e752b987f409d5","src/backends/mod.rs":"0f5a0ae31d5443d0d0f41a2540def806196238c92d22761b3ad9843cb2e77f45","src/backends/v1/mod.rs":"1ada5892a5758e97d315b7e6550623bd1cf7062c84e701a7145fe4e9b84068a3","src/backends/v1/rpc.rs":"72f9b67c2389ab6e9968e0eb340bd2b6aad9aaf059f4429eb31398863bb87f42","src/backends/v2/mod.rs":"b9c23ad19f8921052b909d4f98e989ee0d0cecc4bd738f47e80404eb3d762656","src/backends/v2/rpc.rs":"52f8d504c236009b020bf33b5550236e36d07b2c73a15bdcfcafa5188e4e1cb6","src/backends/v3/mod.rs":"f19e673c47c2cc366e2ff7782bca93daf750563d62221a12a043b3ee79a15251","src/backends/v3/rpc.rs":"7a5f80aec4af1bcaa0d36e67345aa9acbbd8ead73c0be474f06305358b38e81b","src/error_codes.rs":"b2af610880fb400a9e6297662371a6b3b55077b72cf11115b77fd4d2df44e6a1","src/firmware.rs":"6d002e481ce0a897c0485b9393b0382fcb25811164e893eb8eb67b2ff392ca0d","src/lib.rs":"710b46c9d934f26f900e1366ca1df5f872896e7d8da03569c0f159859e899cc9","src/test/json/mod.rs":"99760925ccfefc40d2455d3567fb1ecfc99e9e55e70478190ef372a954825909","src/test/json/v1/devs.json":"b4fd010f0bae3584efde93387cf2dab5933b499cc30a2dd7635fdc994b56c3b8","src/test/json/v1/get_psu.json":"8c11b6495e0bd5da496dd5c10ca53ec53b2d8fe9a3737f470ec9ce2c1aaf9d99","src/test/json/v1/get_version.json":"c43e947e654792ab191210d50c6f793ee0dd7af41e8cb59f0722b70f32a203bc","src/test/json/v1/mod.rs":"a12ec375a02238d5e26b64e2f7aeb0fc336747d86ae012dc154265ee5afaabbf","src/test/json/v1/pools.json":"b570808a3428a0773d7d2ee322150d8fd0794a33804af970300a7fef128a8a01","src/test/json/v1/status.json":"00ec38dd9f980b7ac0ffd6f815374afdbbed98d601bd8ef18bcf0f76ae0aa853","src/test/json/v1/summary.json":"d6e3e75654eb4019e1f479b3d9cf3097130f1afb85dd3338682c094fd4ab498a","src/test/json/v1/summary_with_errors.json":"1ba682f6ad5c43e41ae22a4069d0f52f04da3f07a18031bf4c07e07b3c59cc97","src/test/json/v2/devs.json":"2d203e41ef6ef337c0c81456b73d08730882c3167403c557c3c9776022a972d1","src/test/json/v2/get_error_code.json":"e90b702fd97bceb4f62dcb8228f75ff5ce930290355dca94eefd7192f7f57009","src/test/json/v2/get_error_code_with_errors.json":"6cb6038366eb3835684421c41be0b2b30ae8ce79a7ed51a85f4f52f70da9df16","src/test/json/v2/get_miner_info.json":"55d2af984833a692f502188ae4df4e41bdc10386b47f921c896a452ef1de9062","src/test/json/v2/get_psu.json":"b43086b65897061521d1f6611e200ef372a1724f9ea1876e347c03d5fb19b8f2","src/test/json/v2/get_version.json":"b17e3a81603b43186b2e15745e6822b6c82b3c6f5928b22f84e683d7728dbfcd","src/test/json/v2/mod.rs":"c847205d076323bbd9698e393d241b08f3cf75d32aae86f7058cf8748266b935","src/test/json/v2/pools.json":"926d34e8dae774473ebfec83d4a38e77ca73231708f07683763e212be7af0580","src/test/json/v2/status.json":"fc268cd23864ef99e84813dbf8eb916b2e6f339351a0ee5dab217cbe02569fc3","src/test/json/v2/summary.json":"4e4c01b986e2960893f58d0f1ea4dce23b8ef88db4985348f7f0183eb4818478","src/test/json/v3/get_device_info.json":"83ac22ea9a11adbceb4c963db80aa62d9a2aa50d019a372394dece817d924cda","src/test/json/v3/get_device_info_with_errors.json":"24cee4b7840e87e12147cbfddf6c361f3b378a15bb85330b339d3be9e17cdbd5","src/test/json/v3/get_miner_status_edevs.json":"2d831c06113f555e0988df994c2e602a053a4aea603dded0db8f0f80e191ca5a","src/test/json/v3/get_miner_status_pools.json":"cd65c2efd3a5ce80b57aae46c420298a34ca06df7ac7f8c36fd556217703d242","src/test/json/v3/get_miner_status_summary.json":"799a94ba13ef54aed0f81a3d041d6c1fa263d4183754b384c69ca12d85a8d3ba","src/test/json/v3/mod.rs":"7ea3a8ff1b81c7a5b0f44f7c12dda880a9aeac5b0e6b56ac4fff4f4a7cbfe451","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"c85da6325b62f061327dc5f7605dd3721c823a9e8a2cfd6a356363dfbc84d66e"}
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"30f09ad063df45fdf223aff235fe2da15cb1a7e79e86d7012074153b91662fc4","Cargo.lock":"9d0886791db53421d3218ab72d964145b86cfbe9738eaf09aac5d3c89a1c0190","Cargo.toml":"8c2e9938436850f2e250e8268ed7b385fce903e2077923b207a0560ca3e3242c","Cargo.toml.orig":"891fcfa45e79d6bc4d838c4f3075618f791bd013c99231da48e752b987f409d5","src/backends/mod.rs":"0f5a0ae31d5443d0d0f41a2540def806196238c92d22761b3ad9843cb2e77f45","src/backends/v1/mod.rs":"2622d7b51dab7f749d20fc04dda371320271b8078fed0c352515becc7daebc47","src/backends/v1/rpc.rs":"72f9b67c2389ab6e9968e0eb340bd2b6aad9aaf059f4429eb31398863bb87f42","src/backends/v2/mod.rs":"9bab68108a178f6a1e2c32481c94e0dcd38c3123e633bf89773b62a9c529290b","src/backends/v2/rpc.rs":"52f8d504c236009b020bf33b5550236e36d07b2c73a15bdcfcafa5188e4e1cb6","src/backends/v3/mod.rs":"2cf0311d1dba5d175ad7501917e7b9b3abdc3f1f5ef8993d9d3f453cecd3c09f","src/backends/v3/rpc.rs":"7a5f80aec4af1bcaa0d36e67345aa9acbbd8ead73c0be474f06305358b38e81b","src/error_codes.rs":"b2af610880fb400a9e6297662371a6b3b55077b72cf11115b77fd4d2df44e6a1","src/firmware.rs":"6d002e481ce0a897c0485b9393b0382fcb25811164e893eb8eb67b2ff392ca0d","src/lib.rs":"710b46c9d934f26f900e1366ca1df5f872896e7d8da03569c0f159859e899cc9","src/test/json/mod.rs":"99760925ccfefc40d2455d3567fb1ecfc99e9e55e70478190ef372a954825909","src/test/json/v1/devs.json":"b4fd010f0bae3584efde93387cf2dab5933b499cc30a2dd7635fdc994b56c3b8","src/test/json/v1/get_psu.json":"8c11b6495e0bd5da496dd5c10ca53ec53b2d8fe9a3737f470ec9ce2c1aaf9d99","src/test/json/v1/get_version.json":"c43e947e654792ab191210d50c6f793ee0dd7af41e8cb59f0722b70f32a203bc","src/test/json/v1/mod.rs":"a12ec375a02238d5e26b64e2f7aeb0fc336747d86ae012dc154265ee5afaabbf","src/test/json/v1/pools.json":"b570808a3428a0773d7d2ee322150d8fd0794a33804af970300a7fef128a8a01","src/test/json/v1/status.json":"00ec38dd9f980b7ac0ffd6f815374afdbbed98d601bd8ef18bcf0f76ae0aa853","src/test/json/v1/summary.json":"d6e3e75654eb4019e1f479b3d9cf3097130f1afb85dd3338682c094fd4ab498a","src/test/json/v1/summary_with_errors.json":"1ba682f6ad5c43e41ae22a4069d0f52f04da3f07a18031bf4c07e07b3c59cc97","src/test/json/v2/devs.json":"2d203e41ef6ef337c0c81456b73d08730882c3167403c557c3c9776022a972d1","src/test/json/v2/get_error_code.json":"e90b702fd97bceb4f62dcb8228f75ff5ce930290355dca94eefd7192f7f57009","src/test/json/v2/get_error_code_with_errors.json":"6cb6038366eb3835684421c41be0b2b30ae8ce79a7ed51a85f4f52f70da9df16","src/test/json/v2/get_miner_info.json":"55d2af984833a692f502188ae4df4e41bdc10386b47f921c896a452ef1de9062","src/test/json/v2/get_psu.json":"b43086b65897061521d1f6611e200ef372a1724f9ea1876e347c03d5fb19b8f2","src/test/json/v2/get_version.json":"b17e3a81603b43186b2e15745e6822b6c82b3c6f5928b22f84e683d7728dbfcd","src/test/json/v2/mod.rs":"c847205d076323bbd9698e393d241b08f3cf75d32aae86f7058cf8748266b935","src/test/json/v2/pools.json":"926d34e8dae774473ebfec83d4a38e77ca73231708f07683763e212be7af0580","src/test/json/v2/status.json":"fc268cd23864ef99e84813dbf8eb916b2e6f339351a0ee5dab217cbe02569fc3","src/test/json/v2/summary.json":"4e4c01b986e2960893f58d0f1ea4dce23b8ef88db4985348f7f0183eb4818478","src/test/json/v3/get_device_info.json":"83ac22ea9a11adbceb4c963db80aa62d9a2aa50d019a372394dece817d924cda","src/test/json/v3/get_device_info_with_errors.json":"24cee4b7840e87e12147cbfddf6c361f3b378a15bb85330b339d3be9e17cdbd5","src/test/json/v3/get_miner_status_edevs.json":"2d831c06113f555e0988df994c2e602a053a4aea603dded0db8f0f80e191ca5a","src/test/json/v3/get_miner_status_pools.json":"cd65c2efd3a5ce80b57aae46c420298a34ca06df7ac7f8c36fd556217703d242","src/test/json/v3/get_miner_status_summary.json":"799a94ba13ef54aed0f81a3d041d6c1fa263d4183754b384c69ca12d85a8d3ba","src/test/json/v3/mod.rs":"7ea3a8ff1b81c7a5b0f44f7c12dda880a9aeac5b0e6b56ac4fff4f4a7cbfe451","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"c85da6325b62f061327dc5f7605dd3721c823a9e8a2cfd6a356363dfbc84d66e"}
+85 -2
View File
@@ -14,11 +14,12 @@ use asic_rs_core::{
command::MinerCommand,
device::{DeviceInfo, HashAlgorithm},
fan::FanData,
hashrate::{HashRate, HashRateUnit},
hashrate::{HashRate, HashRateUnit, HashrateAverages},
message::{MessageSeverity, MinerMessage},
miner::TuningTarget,
pool::{PoolData, PoolGroupData, PoolURL},
psu::PsuInfo,
share::{ShareSummary, parse_cgminer_share_summary},
},
traits::{miner::*, model::MinerModel},
};
@@ -244,6 +245,36 @@ impl GetDataLocations for WhatsMinerV1 {
tag: None,
},
)],
// Rolling average windows from btminer summary (round 19 #10, T2);
// RPC_SUMMARY is already fetched.
DataField::HashrateAverages => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0"),
tag: None,
},
)],
// btminer summary "Best Share" (all-time); RPC_SUMMARY already fetched
// (round 19 #10).
DataField::BestShare => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0/Best Share"),
tag: None,
},
)],
// Cumulative share stats from btminer summary (round 19 #10, T2);
// RPC_SUMMARY already fetched.
DataField::ShareSummary => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0"),
tag: None,
},
)],
DataField::ExpectedHashrate => vec![(
RPC_SUMMARY,
DataExtractor {
@@ -419,6 +450,30 @@ impl GetHashrate for WhatsMinerV1 {
.as_unit(HashRateUnit::default())
})
}
fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
// btminer summary MHS 1m/5m/15m (MegaHash); no 24h window (round 19 #10).
let d = data.get(&DataField::HashrateAverages)?;
let mhs = |k: &str| {
d.pointer(k)
.and_then(|v| v.as_f64())
.filter(|&f| f > 0.0)
.map(|f| {
HashRate {
value: f,
unit: HashRateUnit::MegaHash,
algo: self.device_info.algo,
}
.as_unit(HashRateUnit::default())
})
};
let avgs = HashrateAverages {
avg_1m: mhs("/MHS 1m"),
avg_5m: mhs("/MHS 5m"),
avg_15m: mhs("/MHS 15m"),
avg_24h: None,
};
(!avgs.is_empty()).then_some(avgs)
}
}
impl GetExpectedHashrate for WhatsMinerV1 {
fn parse_expected_hashrate(&self, data: &HashMap<DataField, Value>) -> Option<HashRate> {
@@ -483,6 +538,7 @@ impl GetWattage for WhatsMinerV1 {
let psu = PsuInfo {
model: s("/model").or_else(|| s("/name")),
version: s("/hw_version").or_else(|| s("/sw_version")),
serial: None, // v1/v2 get_psu does not report a serial (V3 does)
voltage_min: None,
voltage_max: None,
output_voltage: None,
@@ -548,7 +604,15 @@ impl GetUptime for WhatsMinerV1 {
}
}
impl GetBestShare for WhatsMinerV1 {}
impl GetBestShare for WhatsMinerV1 {
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
}
fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
data.get(&DataField::ShareSummary)
.and_then(parse_cgminer_share_summary)
}
}
impl GetSessionBestShare for WhatsMinerV1 {}
impl GetOperatingState for WhatsMinerV1 {}
@@ -909,6 +973,25 @@ mod integration_tests {
algo: HashAlgorithm::SHA256,
})
);
// Rolling averages: btminer summary MHS 1m/5m/15m (MegaHash), no 24h window
// (round 19 #10, T2).
let avgs = miner_data
.hashrate_averages
.ok_or_else(|| anyhow::anyhow!("v1 should expose rolling averages"))?;
assert!(avgs.avg_1m.is_some() && avgs.avg_5m.is_some() && avgs.avg_15m.is_some());
assert!(avgs.avg_24h.is_none());
if let Some(hr) = &avgs.avg_1m {
assert_eq!(hr.unit, HashRateUnit::TeraHash);
assert!((hr.value - 67.43935249).abs() < 1e-6);
}
// Cumulative share stats from summary (round 19 #10, T2).
let shares = miner_data
.share_summary
.ok_or_else(|| anyhow::anyhow!("v1 should expose share summary"))?;
assert_eq!(shares.difficulty_accepted, Some(158334976.0));
assert_eq!(shares.difficulty_rejected, Some(0.0));
assert_eq!(shares.stale_shares, Some(0));
assert_eq!(shares.found_blocks, Some(0));
assert_eq!(miner_data.wattage, Some(Power::from_watts(3417f64)));
assert_eq!(
miner_data.tuning_target,
+31 -1
View File
@@ -21,6 +21,7 @@ use asic_rs_core::{
miner::{MiningMode, TuningTarget},
pool::{PoolData, PoolGroupData, PoolURL},
psu::PsuInfo,
share::{ShareSummary, parse_cgminer_share_summary},
},
traits::{miner::*, model::MinerModel},
util::is_expected_write_error,
@@ -255,6 +256,26 @@ impl GetDataLocations for WhatsMinerV2 {
tag: None,
},
)],
// btminer summary "Best Share" (all-time); RPC_SUMMARY already fetched
// (round 19 #10).
DataField::BestShare => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0/Best Share"),
tag: None,
},
)],
// Cumulative share stats from btminer summary (round 19 #10, T2);
// RPC_SUMMARY already fetched.
DataField::ShareSummary => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0"),
tag: None,
},
)],
DataField::ExpectedHashrate => vec![(
RPC_SUMMARY,
DataExtractor {
@@ -490,6 +511,7 @@ impl GetWattage for WhatsMinerV2 {
let psu = PsuInfo {
model: s("/model").or_else(|| s("/name")),
version: s("/hw_version").or_else(|| s("/sw_version")),
serial: None, // v1/v2 get_psu does not report a serial (V3 does)
voltage_min: None,
voltage_max: None,
output_voltage: None,
@@ -577,7 +599,15 @@ impl GetUptime for WhatsMinerV2 {
}
}
impl GetBestShare for WhatsMinerV2 {}
impl GetBestShare for WhatsMinerV2 {
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
}
fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
data.get(&DataField::ShareSummary)
.and_then(parse_cgminer_share_summary)
}
}
impl GetSessionBestShare for WhatsMinerV2 {}
impl GetOperatingState for WhatsMinerV2 {}
+59 -1
View File
@@ -17,10 +17,11 @@ use asic_rs_core::{
command::MinerCommand,
device::{DeviceInfo, HashAlgorithm},
fan::FanData,
hashrate::{HashRate, HashRateUnit},
hashrate::{HashRate, HashRateUnit, HashrateAverages},
message::{MessageSeverity, MinerMessage},
miner::{MiningMode, TuningTarget},
pool::{PoolData, PoolGroupData, PoolURL},
psu::PsuInfo,
},
traits::{miner::*, model::MinerModel},
util::is_expected_write_error,
@@ -235,6 +236,16 @@ impl GetDataLocations for WhatsMinerV3 {
tag: None,
},
)],
// PSU identity block (round 19 #10): get.device.info /msg/power carries
// model/type, sw/hwversion and the serial (sn). Already fetched.
DataField::Psu => vec![(
RPC_GET_DEVICE_INFO,
DataExtractor {
func: get_by_pointer,
key: Some("/msg/power"),
tag: None,
},
)],
DataField::Hashboards => vec![
(
RPC_GET_DEVICE_INFO,
@@ -285,6 +296,16 @@ impl GetDataLocations for WhatsMinerV3 {
tag: None,
},
)],
// Rolling averages from get.miner.status summary (round 19 #10, T2);
// command already fetched. V3 exposes 1min and 15min only.
DataField::HashrateAverages => vec![(
rpc_get_miner_status_summary,
DataExtractor {
func: get_by_pointer,
key: Some("/msg/summary"),
tag: None,
},
)],
DataField::ExpectedHashrate => vec![(
rpc_get_miner_status_summary,
DataExtractor {
@@ -454,6 +475,31 @@ impl GetHashrate for WhatsMinerV3 {
.as_unit(HashRateUnit::default())
})
}
fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
// get.miner.status summary hash-1min / hash-15min (TeraHash); V3 reports
// no 5m or 24h window (round 19 #10).
let d = data.get(&DataField::HashrateAverages)?;
let ths = |k: &str| {
d.pointer(k)
.and_then(|v| v.as_f64())
.filter(|&f| f > 0.0)
.map(|f| {
HashRate {
value: f,
unit: HashRateUnit::TeraHash,
algo: self.device_info.algo,
}
.as_unit(HashRateUnit::default())
})
};
let avgs = HashrateAverages {
avg_1m: ths("/hash-1min"),
avg_5m: None,
avg_15m: ths("/hash-15min"),
avg_24h: None,
};
(!avgs.is_empty()).then_some(avgs)
}
}
impl GetExpectedHashrate for WhatsMinerV3 {
fn parse_expected_hashrate(&self, data: &HashMap<DataField, Value>) -> Option<HashRate> {
@@ -509,6 +555,18 @@ impl GetWattage for WhatsMinerV3 {
fn parse_wattage(&self, data: &HashMap<DataField, Value>) -> Option<Power> {
data.extract_map::<f64, _>(DataField::Wattage, Power::from_watts)
}
fn parse_psu(&self, data: &HashMap<DataField, Value>) -> Option<PsuInfo> {
// get.device.info /msg/power: model/type, sw/hwversion, sn (round 19 #10).
let d = data.get(&DataField::Psu)?;
let s = |k: &str| d.pointer(k).and_then(|v| v.as_str()).filter(|s| !s.is_empty()).map(str::to_string);
let psu = PsuInfo {
model: s("/model").or_else(|| s("/type")),
version: s("/swversion").or_else(|| s("/hwversion")),
serial: s("/sn"),
..Default::default()
};
(psu != PsuInfo::default()).then_some(psu)
}
}
/// Parses tuning target from V3 tagged data (mode from get.device.info, limit from summary).
/// Mode "0" (Low) / "2" (High) → MiningMode, "1" (Normal) / unknown → Power(limit).