Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
4154a50ed0 | ||
|
|
0ab822940e | ||
|
|
c1aa6db834 | ||
|
|
7feab6117b | ||
|
|
808fd4de1d | ||
|
|
63ada5bb99 | ||
|
|
52b7c3f2a1 | ||
|
|
571c2305aa | ||
|
|
79ecc100d3 | ||
|
|
51b4eb2556 | ||
|
|
3b18219e4e | ||
|
|
bcc0ba38b6 | ||
|
|
749cdc4eed | ||
|
|
19e469ebc4 | ||
|
|
6cd732dec5 | ||
|
|
95b8428c12 | ||
|
|
a7ed34b8e4 | ||
|
|
b839e9012d | ||
|
|
d378a484d6 | ||
|
|
64e084ddee | ||
|
|
93bd528430 | ||
|
|
e45e6eaf91 | ||
|
|
e5a6cc2b5e | ||
|
|
6fb73c9746 | ||
|
|
49985631d4 | ||
|
|
8fe61ec427 | ||
|
|
34a1a1f3b1 | ||
|
|
0db89d6c55 | ||
|
|
08b3d56864 | ||
|
|
4e825f3ee5 | ||
|
|
8e67c50fe0 | ||
|
|
da0d1582be | ||
|
|
7f802c568f |
@@ -0,0 +1,20 @@
|
||||
# cargo-audit configuration (read by `cargo audit` from the project root).
|
||||
#
|
||||
# The two entries below are accepted, documented exceptions -- both live only in
|
||||
# the wx-rs BUILD-dependency tree (reqwest 0.11, used by wx-rs's build.rs to
|
||||
# download the wxWidgets source on Windows/macOS). On Linux download_dist()
|
||||
# returns before ever constructing an HTTP client, and none of this is linked
|
||||
# into the runtime binary, which talks to miners over asic-rs's reqwest 0.13
|
||||
# (hyper 1.x / h2 0.4). The build tree is fully vendored and offline, so these
|
||||
# cannot be upgraded without re-vendoring a newer reqwest.
|
||||
#
|
||||
# Re-review whenever the vendored dependency set is refreshed.
|
||||
|
||||
[advisories]
|
||||
ignore = [
|
||||
# h2 0.3 unbounded empty DATA frames (DoS). Build-time only; our build-time
|
||||
# HTTP client only fetches a fixed HTTPS URL, and only on Windows/macOS.
|
||||
"RUSTSEC-2026-0258",
|
||||
# rustls-pemfile 1.0.4 unmaintained. Same build-only reqwest 0.11 subtree.
|
||||
"RUSTSEC-2025-0134",
|
||||
]
|
||||
@@ -11,6 +11,9 @@ jobs:
|
||||
runs-on: alkane-ci
|
||||
env:
|
||||
WX_PREFIX: /root/.cache/wx-3.3.3-linux
|
||||
# Set once for the whole job so build/clippy/test/bench steps don't each
|
||||
# re-export it (round 18 #12).
|
||||
WX_RS_WXCONFIG: /root/.cache/wx-3.3.3-linux/bin/wx-config
|
||||
steps:
|
||||
- name: Checkout (full history for tags)
|
||||
uses: actions/checkout@v4
|
||||
@@ -49,6 +52,12 @@ jobs:
|
||||
echo "wx prefix restored from cache"
|
||||
fi
|
||||
|
||||
- name: Clippy (our crate, warnings are errors)
|
||||
if: steps.ver.outputs.release == 'true'
|
||||
run: |
|
||||
rustup component add clippy >/dev/null 2>&1 || true
|
||||
cargo clippy -p alkane-gui --no-deps --release --bins --offline -- -D warnings
|
||||
|
||||
- name: Set crate version to ${{ steps.ver.outputs.version }}
|
||||
if: steps.ver.outputs.release == 'true'
|
||||
run: |
|
||||
@@ -58,19 +67,16 @@ jobs:
|
||||
- name: Build release
|
||||
if: steps.ver.outputs.release == 'true'
|
||||
run: |
|
||||
export WX_RS_WXCONFIG="$WX_PREFIX/bin/wx-config"
|
||||
cargo build --release -p alkane-gui --offline
|
||||
|
||||
- name: Unit tests
|
||||
if: steps.ver.outputs.release == 'true'
|
||||
run: |
|
||||
export WX_RS_WXCONFIG="$WX_PREFIX/bin/wx-config"
|
||||
cargo test -p alkane-gui --offline
|
||||
|
||||
- name: Microbenchmarks
|
||||
if: steps.ver.outputs.release == 'true'
|
||||
run: |
|
||||
export WX_RS_WXCONFIG="$WX_PREFIX/bin/wx-config"
|
||||
cargo test -p alkane-gui --release --offline -- --ignored --nocapture bench_
|
||||
|
||||
- name: Headless UI self-test
|
||||
@@ -81,6 +87,81 @@ jobs:
|
||||
BIN=target/release/alkane-toolkit
|
||||
xvfb-run -a env GDK_BACKEND=x11 ALKANE_SELFTEST=1 "$BIN"
|
||||
|
||||
- name: Dependency audit (best-effort)
|
||||
if: steps.ver.outputs.release == 'true'
|
||||
continue-on-error: true
|
||||
run: |
|
||||
if command -v cargo-audit >/dev/null 2>&1; then
|
||||
cargo audit || echo "cargo audit reported findings (accepted ones in .cargo/audit.toml)"
|
||||
else
|
||||
echo "cargo-audit not installed on this runner; skipping"
|
||||
fi
|
||||
|
||||
# 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
|
||||
# compute-version.sh), so it does not loop back into another release.
|
||||
- name: Refresh badges
|
||||
if: steps.ver.outputs.release == 'true'
|
||||
continue-on-error: true
|
||||
env:
|
||||
TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
run: |
|
||||
PASS=$(cargo test -p alkane-gui --offline 2>&1 \
|
||||
| grep -hoE '[0-9]+ passed' | grep -oE '[0-9]+' | awk '{s+=$1} END{print s+0}')
|
||||
# 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"
|
||||
python3 ci/gen-badges.py --tests "${PASS:-0}" $COV_ARG --bench "row-render + scan-parse"
|
||||
if [ -n "$(git status --porcelain badges)" ]; then
|
||||
git config user.name "alkane-ci"
|
||||
git config user.email "ci@bluefla.re"
|
||||
git add badges
|
||||
git commit -m "ci: refresh README badges [skip release]"
|
||||
API="${GITHUB_API_URL:-https://gitea.bluefla.re/api/v1}"
|
||||
HOST="${API%/api/v1}"
|
||||
git push "${HOST}/${GITHUB_REPOSITORY}.git" "HEAD:main" \
|
||||
-c http.extraheader="Authorization: token ${TOKEN}" || echo "badge push skipped"
|
||||
else
|
||||
echo "badges unchanged"
|
||||
fi
|
||||
|
||||
- name: Package artifact
|
||||
if: steps.ver.outputs.release == 'true'
|
||||
id: pkg
|
||||
|
||||
@@ -0,0 +1,74 @@
|
||||
name: verify
|
||||
|
||||
# Pre-merge quality gate: clippy + build + tests + microbenchmarks + the headless
|
||||
# UI self-test, plus a best-effort dependency audit. Runs on pull requests and on
|
||||
# pushes to any branch EXCEPT main (main is gated by release.yml, which repeats
|
||||
# these checks before it cuts a release -- so no work is duplicated on main).
|
||||
on:
|
||||
pull_request:
|
||||
push:
|
||||
branches-ignore: [main]
|
||||
|
||||
jobs:
|
||||
verify:
|
||||
runs-on: alkane-ci
|
||||
env:
|
||||
WX_PREFIX: /root/.cache/wx-3.3.3-linux
|
||||
WX_RS_WXCONFIG: /root/.cache/wx-3.3.3-linux/bin/wx-config
|
||||
steps:
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v4
|
||||
|
||||
- name: Install build dependencies
|
||||
run: |
|
||||
apt-get update -qq
|
||||
apt-get install -y -qq --no-install-recommends \
|
||||
libssl-dev pkg-config ca-certificates >/dev/null
|
||||
|
||||
- name: Cache vendored wxWidgets build
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
path: /root/.cache/wx-3.3.3-linux
|
||||
key: wx-3.3.3-${{ runner.os }}-${{ hashFiles('thirdparty/wx-rs/VERSION') }}
|
||||
|
||||
- name: Build wxWidgets (once, then cached)
|
||||
run: |
|
||||
if [ ! -x "$WX_PREFIX/bin/wx-config" ]; then
|
||||
bash scripts/build-wx-linux.sh
|
||||
else
|
||||
echo "wx prefix restored from cache"
|
||||
fi
|
||||
|
||||
- name: Clippy (our crate, warnings are errors)
|
||||
run: |
|
||||
rustup component add clippy >/dev/null 2>&1 || true
|
||||
cargo clippy -p alkane-gui --no-deps --release --bins --offline -- -D warnings
|
||||
|
||||
- name: Build
|
||||
run: cargo build --release -p alkane-gui --offline
|
||||
|
||||
- name: Unit tests
|
||||
run: cargo test -p alkane-gui --offline
|
||||
|
||||
- name: Microbenchmarks
|
||||
run: cargo test -p alkane-gui --release --offline -- --ignored --nocapture bench_
|
||||
|
||||
- name: Headless UI self-test
|
||||
run: |
|
||||
apt-get update -qq && apt-get install -y -qq --no-install-recommends \
|
||||
xvfb xauth dbus-x11 fonts-dejavu-core >/dev/null
|
||||
BIN=target/release/alkane-toolkit
|
||||
xvfb-run -a env GDK_BACKEND=x11 ALKANE_SELFTEST=1 "$BIN"
|
||||
|
||||
# Advisory audit is best-effort: it needs the RustSec DB over the network,
|
||||
# which the vendored/offline build otherwise never touches, so a locked-down
|
||||
# runner must not fail the gate on it. Accepted advisories live in
|
||||
# .cargo/audit.toml.
|
||||
- name: Dependency audit (best-effort)
|
||||
continue-on-error: true
|
||||
run: |
|
||||
if command -v cargo-audit >/dev/null 2>&1; then
|
||||
cargo audit || echo "cargo audit reported findings (see .cargo/audit.toml for accepted ones)"
|
||||
else
|
||||
echo "cargo-audit not installed on this runner; skipping"
|
||||
fi
|
||||
@@ -13,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
|
||||
|
||||
|
||||
@@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2026 Blueflare
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
@@ -1,38 +1,116 @@
|
||||
# alkane-toolkit
|
||||
|
||||
Cross-platform desktop toolkit (Rust core, native GUI) to install **stock** or
|
||||
**alkaneOS** firmware on ASIC miner control boards, whatever they currently run
|
||||
(stock, Vnish/AnthillOS, Braiins OS+, LuxOS, ePIC, BixBit, WardenOS).
|
||||
[](https://gitea.bluefla.re/blueflare/alkane-toolkit/actions)
|
||||

|
||||

|
||||

|
||||

|
||||

|
||||

|
||||

|
||||
|
||||
Sibling to [alkane-sdk](https://gitea.bluefla.re/blueflare/alkane-sdk): the SDK
|
||||
owns board knowledge and build outputs; this toolkit is the orchestration
|
||||
engine and operator UI that executes its install recipes safely.
|
||||
A cross-platform desktop toolkit for discovering, monitoring, and re-flashing
|
||||
ASIC miners. It scans a fleet over the network, shows live health and hashrate
|
||||
in a sortable table, and installs **stock** or **alkaneOS** firmware onto a
|
||||
control board whatever it currently runs (stock, VNish/AnthillOS, Braiins OS+,
|
||||
LuxOS, ePIC, HiveOn, BixBit, WardenOS).
|
||||
|
||||
## Status
|
||||
The core and UI are pure Rust; the native window is wxWidgets driven through a
|
||||
vendored, patched [wx-rs](thirdparty/wx-rs) bridge, so there is no Electron,
|
||||
no web view, and a single self-contained binary per platform.
|
||||
|
||||
M1 primary view ships: discovery (vendored asic-rs 0.8.1) + the UI-SPEC
|
||||
table (6 KPIs, sortable/drag-reorderable columns, row checkboxes, scan-range
|
||||
editor, Excel-style filter, columns panel). Pure-Rust GUI on wxWidgets via
|
||||
vendored + patched wx-rs (docs/adr/0002, 0003).
|
||||
## What it does
|
||||
|
||||
## Build + run (Debian)
|
||||
- **Discover** a fleet by CIDR or IP range and identify each miner's make,
|
||||
model, control board, and firmware (via a vendored [asic-rs](vendor/asic-rs)).
|
||||
- **Monitor** hashrate vs. expected, per-board health, chip temperatures, fans,
|
||||
PSU state, and pool workers, with an Excel-style filter and drag-reorderable
|
||||
columns.
|
||||
- **Operate** miners from a right-click menu: flash the locate light, pause /
|
||||
resume, restart, set a power or hashrate target, select a firmware profile
|
||||
(LuxOS/VNish presets), configure pools, set the timezone, and change the
|
||||
password -- each action offered only when every selected miner supports it.
|
||||
- **Install firmware**: push stock or aftermarket images, or revert an
|
||||
aftermarket miner to stock, behind a typed confirmation.
|
||||
|
||||
Discovery and telemetry are read-only and safe to run against any fleet; every
|
||||
mutating action is capability-gated and, where destructive, confirmed.
|
||||
|
||||
## Build and run (Debian/Ubuntu)
|
||||
|
||||
```sh
|
||||
scripts/build-wx-linux.sh # once: builds vendored wx 3.3.3 to ~/.cache
|
||||
scripts/build-wx-linux.sh # once: builds the vendored wxWidgets 3.3.3 into ~/.cache
|
||||
scripts/build-gui-linux.sh # cargo build --release -p alkane-gui
|
||||
~/.cache/alkane-tk-target/release/alkane-toolkit
|
||||
```
|
||||
|
||||
Windows/macOS: `scripts/build-gui-windows.sh` (needs a Windows/msys2
|
||||
toolchain) and `scripts/build-gui-macos.sh` (needs a Mac) - the GUI code is
|
||||
shared; only the C++ bridge + wx differ per platform.
|
||||
Runtime needs GTK 3: `sudo apt install libgtk-3-0`. To explore the UI with no
|
||||
hardware, run the offline demo fleet:
|
||||
|
||||
See `docs/IMPLEMENTATION-PLAN.md` for the roadmap.
|
||||
```sh
|
||||
ALKANE_FAKE_SCAN=1 alkane-toolkit
|
||||
```
|
||||
|
||||
## Hard rules (from alkane-sdk `docs/install-methods.md`, encoded in code)
|
||||
Windows and macOS share all GUI code; only the C++ bridge and wx build differ
|
||||
(`scripts/build-gui-windows.sh` needs an msys2 toolchain, `-macos.sh` needs a
|
||||
Mac).
|
||||
|
||||
1. Never write the bootloader/secure region.
|
||||
## Command-line probe
|
||||
|
||||
`miner_probe` is a headless companion for hardware checks that should not go
|
||||
through the window event loop -- discovery, telemetry, and each write action:
|
||||
|
||||
```sh
|
||||
miner_probe scan 10.0.0.0/24 # discover + telemetry (TSV)
|
||||
miner_probe presets 10.0.0.5 # list a firmware's selectable profiles
|
||||
miner_probe setpreset 10.0.0.5 540MHz
|
||||
```
|
||||
|
||||
Run `miner_probe` with no arguments for the full verb list.
|
||||
|
||||
## Development
|
||||
|
||||
```sh
|
||||
export WX_RS_WXCONFIG="$HOME/.cache/wx-3.3.3-linux/bin/wx-config"
|
||||
export CARGO_TARGET_DIR="$HOME/.cache/alkane-tk-target" # keep the target tree off the source share
|
||||
|
||||
cargo test -p alkane-gui # unit tests
|
||||
cargo test -p alkane-gui --release -- --ignored bench_ # microbenchmarks
|
||||
cargo clippy -p alkane-gui --no-deps --bins -- -D warnings # lint gate
|
||||
xvfb-run -a env ALKANE_SELFTEST=1 \
|
||||
"$CARGO_TARGET_DIR/release/alkane-toolkit" # headless UI self-test
|
||||
ci/coverage.sh --summary-only # coverage (tests + self-test)
|
||||
```
|
||||
|
||||
CI mirrors these: `verify.yml` runs the lint, tests, benchmarks, self-test, and
|
||||
a best-effort dependency audit on every pull request and branch push;
|
||||
`release.yml` repeats them on `main` and cuts an `X.Y.Z` release with the built
|
||||
binary attached when the change warrants it. Dependencies are vendored under
|
||||
`vendor/`, so builds never touch the network.
|
||||
|
||||
## Architecture
|
||||
|
||||
- `crates/alkane-gui` -- the application: scan engine, data model, wxWidgets UI,
|
||||
and the `miner_probe` CLI (the other `crates/alkane-*` are early scaffolding).
|
||||
- `vendor/asic-rs` -- the miner-discovery and control library, vendored and
|
||||
extended through numbered patches under `thirdparty/asic-rs/patches`.
|
||||
- `thirdparty/wx-rs` -- the patched wxWidgets bridge (see `docs/adr/0002`,
|
||||
`0003`).
|
||||
|
||||
See [`docs/IMPLEMENTATION-PLAN.md`](docs/IMPLEMENTATION-PLAN.md) for the roadmap
|
||||
and [`docs/aftermarket-parity-roadmap.md`](docs/aftermarket-parity-roadmap.md)
|
||||
for the firmware config/scan parity work.
|
||||
|
||||
## Firmware safety rules
|
||||
|
||||
Encoded in code, from alkane-sdk `docs/install-methods.md`:
|
||||
|
||||
1. Never write the bootloader or secure region.
|
||||
2. Verify on a channel the installer does not control.
|
||||
3. Reboot is root-only; a dropped SSH connection can be success.
|
||||
4. A packer is per board; never reuse across boards.
|
||||
3. Reboot is root-only; a dropped SSH connection can still be success.
|
||||
4. A packer is per board; never reuse one across boards.
|
||||
5. Boot-switch handling is an explicit, verified step.
|
||||
|
||||
## License
|
||||
|
||||
Licensed under the [MIT license](LICENSE).
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="206.0" height="20" role="img" aria-label="bench: row-render + scan-parse">
|
||||
<title>bench: row-render + scan-parse</title>
|
||||
<linearGradient id="s" x2="0" y2="100%">
|
||||
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
|
||||
<stop offset="1" stop-opacity=".1"/>
|
||||
</linearGradient>
|
||||
<clipPath id="r"><rect width="206.0" height="20" rx="3" fill="#fff"/></clipPath>
|
||||
<g clip-path="url(#r)">
|
||||
<rect width="44.5" height="20" fill="#555"/>
|
||||
<rect x="44.5" width="161.5" height="20" fill="#007ec6"/>
|
||||
<rect width="206.0" height="20" fill="url(#s)"/>
|
||||
</g>
|
||||
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
|
||||
<text x="22.2" y="15" fill="#010101" fill-opacity=".3">bench</text>
|
||||
<text x="22.2" y="14">bench</text>
|
||||
<text x="125.2" y="15" fill="#010101" fill-opacity=".3">row-render + scan-parse</text>
|
||||
<text x="125.2" y="14">row-render + scan-parse</text>
|
||||
</g>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 993 B |
@@ -0,0 +1,19 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="95.5" height="20" role="img" aria-label="coverage: 46%">
|
||||
<title>coverage: 46%</title>
|
||||
<linearGradient id="s" x2="0" y2="100%">
|
||||
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
|
||||
<stop offset="1" stop-opacity=".1"/>
|
||||
</linearGradient>
|
||||
<clipPath id="r"><rect width="95.5" height="20" rx="3" fill="#fff"/></clipPath>
|
||||
<g clip-path="url(#r)">
|
||||
<rect width="64.0" height="20" fill="#555"/>
|
||||
<rect x="64.0" width="31.5" height="20" fill="#dfb317"/>
|
||||
<rect width="95.5" height="20" fill="url(#s)"/>
|
||||
</g>
|
||||
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
|
||||
<text x="32.0" y="15" fill="#010101" fill-opacity=".3">coverage</text>
|
||||
<text x="32.0" y="14">coverage</text>
|
||||
<text x="79.8" y="15" fill="#010101" fill-opacity=".3">46%</text>
|
||||
<text x="79.8" y="14">46%</text>
|
||||
</g>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 919 B |
@@ -0,0 +1,19 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="121.5" height="20" role="img" aria-label="dependencies: 349">
|
||||
<title>dependencies: 349</title>
|
||||
<linearGradient id="s" x2="0" y2="100%">
|
||||
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
|
||||
<stop offset="1" stop-opacity=".1"/>
|
||||
</linearGradient>
|
||||
<clipPath id="r"><rect width="121.5" height="20" rx="3" fill="#fff"/></clipPath>
|
||||
<g clip-path="url(#r)">
|
||||
<rect width="90.0" height="20" fill="#555"/>
|
||||
<rect x="90.0" width="31.5" height="20" fill="#007ec6"/>
|
||||
<rect width="121.5" height="20" fill="url(#s)"/>
|
||||
</g>
|
||||
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
|
||||
<text x="45.0" y="15" fill="#010101" fill-opacity=".3">dependencies</text>
|
||||
<text x="45.0" y="14">dependencies</text>
|
||||
<text x="105.8" y="15" fill="#010101" fill-opacity=".3">349</text>
|
||||
<text x="105.8" y="14">349</text>
|
||||
</g>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 940 B |
@@ -0,0 +1,19 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="89.0" height="20" role="img" aria-label="license: MIT">
|
||||
<title>license: MIT</title>
|
||||
<linearGradient id="s" x2="0" y2="100%">
|
||||
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
|
||||
<stop offset="1" stop-opacity=".1"/>
|
||||
</linearGradient>
|
||||
<clipPath id="r"><rect width="89.0" height="20" rx="3" fill="#fff"/></clipPath>
|
||||
<g clip-path="url(#r)">
|
||||
<rect width="57.5" height="20" fill="#555"/>
|
||||
<rect x="57.5" width="31.5" height="20" fill="#007ec6"/>
|
||||
<rect width="89.0" height="20" fill="url(#s)"/>
|
||||
</g>
|
||||
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
|
||||
<text x="28.8" y="15" fill="#010101" fill-opacity=".3">license</text>
|
||||
<text x="28.8" y="14">license</text>
|
||||
<text x="73.2" y="15" fill="#010101" fill-opacity=".3">MIT</text>
|
||||
<text x="73.2" y="14">MIT</text>
|
||||
</g>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 915 B |
@@ -0,0 +1,19 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="141.0" height="20" role="img" aria-label="lines of code: 13.2k">
|
||||
<title>lines of code: 13.2k</title>
|
||||
<linearGradient id="s" x2="0" y2="100%">
|
||||
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
|
||||
<stop offset="1" stop-opacity=".1"/>
|
||||
</linearGradient>
|
||||
<clipPath id="r"><rect width="141.0" height="20" rx="3" fill="#fff"/></clipPath>
|
||||
<g clip-path="url(#r)">
|
||||
<rect width="96.5" height="20" fill="#555"/>
|
||||
<rect x="96.5" width="44.5" height="20" fill="#007ec6"/>
|
||||
<rect width="141.0" height="20" fill="url(#s)"/>
|
||||
</g>
|
||||
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
|
||||
<text x="48.2" y="15" fill="#010101" fill-opacity=".3">lines of code</text>
|
||||
<text x="48.2" y="14">lines of code</text>
|
||||
<text x="118.8" y="15" fill="#010101" fill-opacity=".3">13.2k</text>
|
||||
<text x="118.8" y="14">13.2k</text>
|
||||
</g>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 952 B |
@@ -0,0 +1,19 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="95.5" height="20" role="img" aria-label="clippy: clean">
|
||||
<title>clippy: clean</title>
|
||||
<linearGradient id="s" x2="0" y2="100%">
|
||||
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
|
||||
<stop offset="1" stop-opacity=".1"/>
|
||||
</linearGradient>
|
||||
<clipPath id="r"><rect width="95.5" height="20" rx="3" fill="#fff"/></clipPath>
|
||||
<g clip-path="url(#r)">
|
||||
<rect width="51.0" height="20" fill="#555"/>
|
||||
<rect x="51.0" width="44.5" height="20" fill="#4c1"/>
|
||||
<rect width="95.5" height="20" fill="url(#s)"/>
|
||||
</g>
|
||||
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
|
||||
<text x="25.5" y="15" fill="#010101" fill-opacity=".3">clippy</text>
|
||||
<text x="25.5" y="14">clippy</text>
|
||||
<text x="73.2" y="15" fill="#010101" fill-opacity=".3">clean</text>
|
||||
<text x="73.2" y="14">clean</text>
|
||||
</g>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 916 B |
@@ -0,0 +1,19 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="121.5" height="20" role="img" aria-label="tests: 99 passing">
|
||||
<title>tests: 99 passing</title>
|
||||
<linearGradient id="s" x2="0" y2="100%">
|
||||
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
|
||||
<stop offset="1" stop-opacity=".1"/>
|
||||
</linearGradient>
|
||||
<clipPath id="r"><rect width="121.5" height="20" rx="3" fill="#fff"/></clipPath>
|
||||
<g clip-path="url(#r)">
|
||||
<rect width="44.5" height="20" fill="#555"/>
|
||||
<rect x="44.5" width="77.0" height="20" fill="#4c1"/>
|
||||
<rect width="121.5" height="20" fill="url(#s)"/>
|
||||
</g>
|
||||
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
|
||||
<text x="22.2" y="15" fill="#010101" fill-opacity=".3">tests</text>
|
||||
<text x="22.2" y="14">tests</text>
|
||||
<text x="83.0" y="15" fill="#010101" fill-opacity=".3">99 passing</text>
|
||||
<text x="83.0" y="14">99 passing</text>
|
||||
</g>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 935 B |
@@ -2,9 +2,10 @@
|
||||
# Compute the next release version for alkane-toolkit from the latest release
|
||||
# tag and the paths changed since it. Version scheme X.Y.Z:
|
||||
# X - major, bumped manually (ci/version-x.txt); a bump resets Y.Z to 0.0
|
||||
# Y - backend-logic changes (core/discovery/access/flash/artifacts/cli,
|
||||
# scan+model+main in the GUI crate, build/CI config); resets Z to 0
|
||||
# Z - UI changes (the GUI view + fixtures + the wx-rs widget bridge)
|
||||
# Y - backend-logic changes (the alkane-* crates and any GUI crate source
|
||||
# other than the view files below, plus vendored deps and build/CI config);
|
||||
# resets Z to 0
|
||||
# Z - UI changes (the GUI view: ui.rs + fixtures.rs + bin/ + the wx-rs bridge)
|
||||
# When both backend and UI changed, backend wins (bump Y). Docs-only changes
|
||||
# produce no release.
|
||||
#
|
||||
@@ -35,9 +36,11 @@ crates/alkane-gui/src/bin/*)
|
||||
ui=true ;;
|
||||
crates/alkane-core/*|crates/alkane-discovery/*|crates/alkane-access/*|\
|
||||
crates/alkane-flash/*|crates/alkane-artifacts/*|crates/alkane-cli/*|\
|
||||
crates/alkane-gui/src/scan.rs|crates/alkane-gui/src/model.rs|\
|
||||
crates/alkane-gui/src/main.rs|Cargo.toml|Cargo.lock|.gitea/*|ci/*|scripts/*|\
|
||||
crates/alkane-gui/src/*|Cargo.toml|Cargo.lock|.gitea/*|ci/*|scripts/*|\
|
||||
vendor/*|thirdparty/asic-rs/*)
|
||||
# Any other GUI source file (naming, scan, model, pool_prefs, restore,
|
||||
# access_probe, credentials, ...) is backend logic. ui.rs/fixtures.rs/bin
|
||||
# match the UI arm above first, so they still bump Z, not Y.
|
||||
backend=true ;;
|
||||
*) : ;; # docs, HANDOFF, README, thirdparty/wxwidgets tree: no bump
|
||||
esac
|
||||
|
||||
@@ -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)/' "$@"
|
||||
@@ -0,0 +1,165 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Generate self-contained shields-style SVG badges into badges/.
|
||||
|
||||
Self-hosted Gitea renders a README's relative image links straight from the
|
||||
repo, so committing the SVGs (rather than depending on an external badge
|
||||
service that would have to reach a possibly-private Gitea) is the robust choice.
|
||||
CI regenerates them from live metrics and commits any changes back.
|
||||
|
||||
Usage:
|
||||
gen-badges.py --tests N --coverage PCT --bench "label" [--out badges]
|
||||
|
||||
Metrics not passed on the command line are computed here (LOC from the source
|
||||
tree, dependency count from Cargo.lock, license from Cargo.toml).
|
||||
"""
|
||||
import argparse
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
|
||||
# Approximate per-character width at 11px DejaVu Sans, in 1/10 px, matching the
|
||||
# shields "flat" look closely enough for a fixed-width monospace-ish render.
|
||||
CHAR_W = 6.5
|
||||
PAD = 6.0
|
||||
|
||||
COLORS = {
|
||||
"green": "#4c1",
|
||||
"brightgreen": "#4c1",
|
||||
"yellowgreen": "#a4a61d",
|
||||
"yellow": "#dfb317",
|
||||
"orange": "#fe7d37",
|
||||
"red": "#e05d44",
|
||||
"blue": "#007ec6",
|
||||
"lightgrey": "#9f9f9f",
|
||||
"grey": "#555",
|
||||
}
|
||||
|
||||
|
||||
def text_width(s: str) -> float:
|
||||
return len(s) * CHAR_W + 2 * PAD
|
||||
|
||||
|
||||
def badge_svg(label: str, message: str, color: str) -> str:
|
||||
color = COLORS.get(color, color)
|
||||
lw = round(text_width(label), 1)
|
||||
mw = round(text_width(message), 1)
|
||||
total = round(lw + mw, 1)
|
||||
lx = round(lw / 2, 1)
|
||||
mx = round(lw + mw / 2, 1)
|
||||
# Text is drawn twice (a dark shadow then the light glyphs) for the shields look.
|
||||
return f'''<svg xmlns="http://www.w3.org/2000/svg" width="{total}" height="20" role="img" aria-label="{label}: {message}">
|
||||
<title>{label}: {message}</title>
|
||||
<linearGradient id="s" x2="0" y2="100%">
|
||||
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
|
||||
<stop offset="1" stop-opacity=".1"/>
|
||||
</linearGradient>
|
||||
<clipPath id="r"><rect width="{total}" height="20" rx="3" fill="#fff"/></clipPath>
|
||||
<g clip-path="url(#r)">
|
||||
<rect width="{lw}" height="20" fill="#555"/>
|
||||
<rect x="{lw}" width="{mw}" height="20" fill="{color}"/>
|
||||
<rect width="{total}" height="20" fill="url(#s)"/>
|
||||
</g>
|
||||
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
|
||||
<text x="{lx}" y="15" fill="#010101" fill-opacity=".3">{label}</text>
|
||||
<text x="{lx}" y="14">{label}</text>
|
||||
<text x="{mx}" y="15" fill="#010101" fill-opacity=".3">{message}</text>
|
||||
<text x="{mx}" y="14">{message}</text>
|
||||
</g>
|
||||
</svg>
|
||||
'''
|
||||
|
||||
|
||||
def count_loc(root: str) -> int:
|
||||
total = 0
|
||||
for base in ("crates",):
|
||||
for dirpath, _dirs, files in os.walk(os.path.join(root, base)):
|
||||
for f in files:
|
||||
if f.endswith(".rs"):
|
||||
try:
|
||||
with open(os.path.join(dirpath, f), encoding="utf-8", errors="ignore") as fh:
|
||||
total += sum(1 for _ in fh)
|
||||
except OSError:
|
||||
pass
|
||||
return total
|
||||
|
||||
|
||||
def count_deps(root: str) -> int:
|
||||
lock = os.path.join(root, "Cargo.lock")
|
||||
try:
|
||||
with open(lock, encoding="utf-8") as fh:
|
||||
return sum(1 for line in fh if line.startswith("name = "))
|
||||
except OSError:
|
||||
return 0
|
||||
|
||||
|
||||
def read_license(root: str) -> str:
|
||||
try:
|
||||
with open(os.path.join(root, "Cargo.toml"), encoding="utf-8") as fh:
|
||||
for line in fh:
|
||||
m = re.match(r'\s*license\s*=\s*"([^"]+)"', line)
|
||||
if m:
|
||||
return m.group(1)
|
||||
except OSError:
|
||||
pass
|
||||
return "unknown"
|
||||
|
||||
|
||||
def loc_color(n: int) -> str:
|
||||
return "blue"
|
||||
|
||||
|
||||
def cov_color(pct: float) -> str:
|
||||
if pct >= 80:
|
||||
return "brightgreen"
|
||||
if pct >= 60:
|
||||
return "yellowgreen"
|
||||
if pct >= 40:
|
||||
return "yellow"
|
||||
if pct >= 20:
|
||||
return "orange"
|
||||
return "red"
|
||||
|
||||
|
||||
def human(n: int) -> str:
|
||||
if n >= 1000:
|
||||
return f"{n / 1000:.1f}k".replace(".0k", "k")
|
||||
return str(n)
|
||||
|
||||
|
||||
def main() -> int:
|
||||
ap = argparse.ArgumentParser()
|
||||
ap.add_argument("--out", default="badges")
|
||||
ap.add_argument("--root", default=".")
|
||||
ap.add_argument("--tests", type=int, default=None)
|
||||
ap.add_argument("--coverage", type=float, default=None)
|
||||
ap.add_argument("--bench", default=None)
|
||||
ap.add_argument("--clippy", default="clean")
|
||||
args = ap.parse_args()
|
||||
|
||||
os.makedirs(os.path.join(args.root, args.out), exist_ok=True)
|
||||
|
||||
def write(name, label, message, color):
|
||||
path = os.path.join(args.root, args.out, name + ".svg")
|
||||
with open(path, "w", encoding="utf-8") as fh:
|
||||
fh.write(badge_svg(label, message, color))
|
||||
print(f"wrote {path}: {label}={message}")
|
||||
|
||||
loc = count_loc(args.root)
|
||||
deps = count_deps(args.root)
|
||||
lic = read_license(args.root)
|
||||
|
||||
write("loc", "lines of code", human(loc), loc_color(loc))
|
||||
write("license", "license", lic, "blue")
|
||||
write("dependencies", "dependencies", str(deps), "blue")
|
||||
write("quality", "clippy", args.clippy, "brightgreen" if args.clippy == "clean" else "orange")
|
||||
if args.tests is not None:
|
||||
write("tests", "tests", f"{args.tests} passing", "brightgreen")
|
||||
if args.coverage is not None:
|
||||
write("coverage", "coverage", f"{args.coverage:.0f}%", cov_color(args.coverage))
|
||||
if args.bench is not None:
|
||||
write("bench", "bench", args.bench, "blue")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -61,10 +61,22 @@ fn endpoint(_firmware: &str) -> &'static str {
|
||||
/// could not run at all.
|
||||
pub fn probe_access(ip: &str, make: &str, user: &str, pass: &str) -> Result<Option<bool>, String> {
|
||||
if make.eq_ignore_ascii_case("whatsminer") {
|
||||
return Ok(probe_whatsminer_access(ip, &whatsminer_password_candidates()));
|
||||
// Try the caller's saved scan password first (round 18 #12: it was being
|
||||
// ignored for WhatsMiner, so a miner opened with the operator's real
|
||||
// password was mis-reported as locked), then the per-firmware override and
|
||||
// factory defaults. All attempts are non-mutating.
|
||||
let mut candidates = Vec::new();
|
||||
if !pass.is_empty() {
|
||||
candidates.push(pass.to_string());
|
||||
}
|
||||
for c in whatsminer_password_candidates() {
|
||||
if !candidates.contains(&c) {
|
||||
candidates.push(c);
|
||||
}
|
||||
}
|
||||
return Ok(probe_whatsminer_access(ip, &candidates));
|
||||
}
|
||||
let url = format!("http://{ip}{}", endpoint(make));
|
||||
let userpass = format!("{user}:{pass}");
|
||||
let mut cmd = Command::new("curl");
|
||||
cmd.args([
|
||||
"-s",
|
||||
@@ -73,15 +85,18 @@ pub fn probe_access(ip: &str, make: &str, user: &str, pass: &str) -> Result<Opti
|
||||
"-w",
|
||||
"%{http_code}",
|
||||
"--digest",
|
||||
"-u",
|
||||
&userpass,
|
||||
"--connect-timeout",
|
||||
"5",
|
||||
"--max-time",
|
||||
"9",
|
||||
"-K",
|
||||
"-", // read the rest of the config (the credentials) from stdin
|
||||
&url,
|
||||
]);
|
||||
let out = wait_with_timeout(cmd, Duration::from_secs(12))?;
|
||||
// The user:pass goes through a curl config on stdin, never argv, so it can't
|
||||
// be read from the process list (round 18 #12).
|
||||
let config = format!("user = \"{}\"\n", curl_config_quote(&format!("{user}:{pass}")));
|
||||
let out = wait_with_timeout(cmd, Duration::from_secs(12), Some(config.as_bytes()))?;
|
||||
// curl prints the status code to stdout regardless of exit status (000 on a
|
||||
// connection failure), so classify the code rather than the exit status.
|
||||
let code = String::from_utf8_lossy(&out.stdout);
|
||||
@@ -89,11 +104,25 @@ pub fn probe_access(ip: &str, make: &str, user: &str, pass: &str) -> Result<Opti
|
||||
}
|
||||
|
||||
/// Run a command with a wall-clock timeout (curl can hang past --max-time on a
|
||||
/// black-holed host).
|
||||
fn wait_with_timeout(mut cmd: Command, timeout: Duration) -> Result<std::process::Output, String> {
|
||||
use std::io::Read;
|
||||
/// black-holed host). `stdin_data`, when set, is written to the child's stdin and
|
||||
/// the pipe closed -- used to feed a curl config (with the credentials) instead
|
||||
/// of putting them on the command line (round 18 #12).
|
||||
fn wait_with_timeout(
|
||||
mut cmd: Command,
|
||||
timeout: Duration,
|
||||
stdin_data: Option<&[u8]>,
|
||||
) -> Result<std::process::Output, String> {
|
||||
use std::io::{Read, Write};
|
||||
cmd.stdout(std::process::Stdio::piped()).stderr(std::process::Stdio::piped());
|
||||
if stdin_data.is_some() {
|
||||
cmd.stdin(std::process::Stdio::piped());
|
||||
}
|
||||
let mut child = cmd.spawn().map_err(|e| format!("spawn curl: {e}"))?;
|
||||
if let Some(data) = stdin_data {
|
||||
if let Some(mut si) = child.stdin.take() {
|
||||
let _ = si.write_all(data);
|
||||
} // dropping `si` closes the pipe so curl stops reading the config
|
||||
}
|
||||
let start = std::time::Instant::now();
|
||||
loop {
|
||||
match child.try_wait().map_err(|e| e.to_string())? {
|
||||
@@ -111,6 +140,7 @@ fn wait_with_timeout(mut cmd: Command, timeout: Duration) -> Result<std::process
|
||||
None => {
|
||||
if start.elapsed() >= timeout {
|
||||
let _ = child.kill();
|
||||
let _ = child.wait(); // reap so we never leave a zombie (round 18 #12)
|
||||
return Err("curl timed out".into());
|
||||
}
|
||||
std::thread::sleep(Duration::from_millis(100));
|
||||
@@ -119,6 +149,11 @@ fn wait_with_timeout(mut cmd: Command, timeout: Duration) -> Result<std::process
|
||||
}
|
||||
}
|
||||
|
||||
/// Escape a value for a curl `--config` file (double-quoted string).
|
||||
fn curl_config_quote(s: &str) -> String {
|
||||
s.replace('\\', "\\\\").replace('"', "\\\"")
|
||||
}
|
||||
|
||||
/// Passwords to try for a WhatsMiner access check: a user-set per-firmware
|
||||
/// override (round 12 #13) wins; otherwise the two factory defaults ("admin" for
|
||||
/// V1/V2, "super" for V3). All attempts are non-mutating, so trying both is safe.
|
||||
@@ -205,23 +240,39 @@ fn wm_aes_ecb_enc(pwd_md5: &str, data: &str) -> Option<String> {
|
||||
fn probe_whatsminer_access(ip: &str, passwords: &[String]) -> Option<bool> {
|
||||
let timeout = Duration::from_secs(6);
|
||||
let mut reachable = false;
|
||||
// A transient error on one candidate must not abandon the others (round 18 #12):
|
||||
// skip to the next candidate, but remember it happened so we never report a
|
||||
// confident "locked" when the answer was really indeterminate.
|
||||
let mut errored = false;
|
||||
for pass in passwords {
|
||||
// 1. get_token (no auth) -> salt / newsalt / time.
|
||||
let tok_resp = match wm_rpc(ip, "{\"command\":\"get_token\"}", timeout) {
|
||||
Ok(s) => s,
|
||||
Err(_) => return None,
|
||||
Err(_) => {
|
||||
errored = true;
|
||||
continue;
|
||||
}
|
||||
};
|
||||
let v: serde_json::Value = match serde_json::from_str(&tok_resp) {
|
||||
Ok(v) => v,
|
||||
Err(_) => return None,
|
||||
Err(_) => {
|
||||
errored = true;
|
||||
continue;
|
||||
}
|
||||
};
|
||||
let Some(msg) = v.get("Msg") else { return None };
|
||||
let (Some(salt), Some(newsalt), Some(time)) = (
|
||||
msg.get("salt").and_then(|s| s.as_str()),
|
||||
msg.get("newsalt").and_then(|s| s.as_str()),
|
||||
msg.get("time").and_then(|s| s.as_str()),
|
||||
) else {
|
||||
return None;
|
||||
let (Some(salt), Some(newsalt), Some(time)) = v
|
||||
.get("Msg")
|
||||
.map(|msg| {
|
||||
(
|
||||
msg.get("salt").and_then(|s| s.as_str()),
|
||||
msg.get("newsalt").and_then(|s| s.as_str()),
|
||||
msg.get("time").and_then(|s| s.as_str()),
|
||||
)
|
||||
})
|
||||
.unwrap_or((None, None, None))
|
||||
else {
|
||||
errored = true;
|
||||
continue;
|
||||
};
|
||||
reachable = true;
|
||||
// 2. Derive the md5crypt password hash + write-token from the password.
|
||||
@@ -239,15 +290,19 @@ fn probe_whatsminer_access(ip: &str, passwords: &[String]) -> Option<bool> {
|
||||
let payload = format!("{{\"enc\":1,\"data\":\"{enc}\"}}");
|
||||
let resp = match wm_rpc(ip, &payload, timeout) {
|
||||
Ok(s) => s,
|
||||
Err(_) => return None,
|
||||
Err(_) => {
|
||||
errored = true;
|
||||
continue;
|
||||
}
|
||||
};
|
||||
if resp.contains("\"enc\"") {
|
||||
return Some(false); // accepted -> unlocked/writable
|
||||
}
|
||||
// rejected -> try the next candidate password
|
||||
}
|
||||
// Reached the miner and every candidate password was rejected -> locked.
|
||||
if reachable { Some(true) } else { None }
|
||||
// Only report "locked" when we cleanly reached the miner and every candidate
|
||||
// was rejected with no transient errors; otherwise the result is indeterminate.
|
||||
if reachable && !errored { Some(true) } else { None }
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
//! miner_probe -- a read-only (by default) asic-rs diagnostic for live-hardware
|
||||
//! verification of the round-9 power-limit work. It reuses the same MinerFactory
|
||||
//! + saved-credential setup the GUI uses (see crate::credentials), but as a
|
||||
//! and saved-credential setup the GUI uses (see crate::credentials), but as a
|
||||
//! standalone CLI so hardware checks don't go through the wx event loop.
|
||||
//!
|
||||
//! Usage:
|
||||
@@ -39,12 +39,17 @@ fn load_creds() -> Option<(String, String)> {
|
||||
}
|
||||
|
||||
fn factory() -> MinerFactory {
|
||||
// This diagnostic CLI is a separate binary from the GUI, so it cannot share
|
||||
// the GUI's credentials::configured_factory. It applies only the global scan
|
||||
// credentials to every firmware; the GUI's per-firmware credential overrides
|
||||
// are NOT read here (round 18 #12), which the message below makes explicit so a
|
||||
// probe result is never mistaken for what the GUI (with overrides) would see.
|
||||
let mut f = MinerFactory::new();
|
||||
if let Some((u, pw)) = load_creds() {
|
||||
for fw in asic_rs::factory::default_firmware_registry() {
|
||||
f = f.with_firmware_discovery_auth(fw.as_ref(), MinerAuth::new(u.clone(), pw.clone()));
|
||||
}
|
||||
eprintln!("(using saved scan credentials for discovery auth)");
|
||||
eprintln!("(using the global scan credentials; per-firmware overrides are not applied)");
|
||||
} else {
|
||||
eprintln!("(no saved credentials -- backends use their default auth)");
|
||||
}
|
||||
@@ -62,6 +67,18 @@ async fn scan(cidrs: &[String]) {
|
||||
}
|
||||
};
|
||||
}
|
||||
// Cap identification concurrency to match the GUI (see
|
||||
// scan::SCAN_CONCURRENCY_LIMIT). asic-rs defaults to 1000, which over a real
|
||||
// link starves the per-responder get_data -- Braiins miners drop most values
|
||||
// (watts=0, no best-share) and some responders are missed entirely. 128 is the
|
||||
// highest cap that stayed fully reliable on the live fleet. ALKANE_PROBE_CONCURRENCY
|
||||
// overrides it for diagnostics.
|
||||
let concurrency = std::env::var("ALKANE_PROBE_CONCURRENCY")
|
||||
.ok()
|
||||
.and_then(|c| c.parse::<usize>().ok())
|
||||
.unwrap_or(128);
|
||||
eprintln!("(scan concurrency = {concurrency})");
|
||||
f = f.with_concurrent_limit(concurrency);
|
||||
println!("ip\tmake\tfirmware\tfw_version\tmodel_id\tcontrol_board\twatts\tsupports_power_limit\tsupports_tuning\tbest_share\tsession_best_share");
|
||||
let mut stream = f.scan_stream_with_ip();
|
||||
let mut found = 0usize;
|
||||
@@ -263,6 +280,9 @@ async fn msgs(ip_s: &str) {
|
||||
match f.scan_miner(ip).await {
|
||||
Ok(Some(m)) => {
|
||||
let d = m.get_data().await;
|
||||
let th = |h: &Option<asic_rs::core::data::hashrate::HashRate>| {
|
||||
h.clone().map(|x| x.as_unit(asic_rs::core::data::hashrate::HashRateUnit::TeraHash).value)
|
||||
};
|
||||
println!(
|
||||
"{ip}: {} {} hashboards={:?} expected={:?}",
|
||||
d.device_info.firmware,
|
||||
@@ -270,13 +290,30 @@ async fn msgs(ip_s: &str) {
|
||||
d.hashboards.len(),
|
||||
d.expected_hashboards,
|
||||
);
|
||||
println!(
|
||||
" TOTAL hashrate={:?} TH wattage={:?} W fluid/env_temp={:?} best_share={:?}",
|
||||
th(&d.hashrate),
|
||||
d.wattage.as_ref().map(|p| p.as_watts()),
|
||||
d.fluid_temperature.as_ref().map(|t| t.as_celsius()),
|
||||
d.best_share,
|
||||
);
|
||||
let fans: Vec<i64> = d
|
||||
.fans
|
||||
.iter()
|
||||
.map(|f| f.rpm.as_ref().map(|r| r.as_rpm() as i64).unwrap_or(-1))
|
||||
.collect();
|
||||
println!(" fans(rpm)={fans:?} psu_fans={}", d.psu_fans.len());
|
||||
for b in d.hashboards.iter() {
|
||||
println!(
|
||||
" board position={} hashrate={:?} chips={:?}/{:?}",
|
||||
" board pos={} hr={:?}TH chips={:?}/{:?} board_temp={:?} outlet_temp={:?} freq={:?}MHz volt={:?}V",
|
||||
b.position,
|
||||
b.hashrate.clone().map(|h| h.as_unit(asic_rs::core::data::hashrate::HashRateUnit::TeraHash).value),
|
||||
th(&b.hashrate),
|
||||
b.working_chips,
|
||||
b.expected_chips,
|
||||
b.board_temperature.as_ref().map(|t| t.as_celsius()),
|
||||
b.outlet_chip_temperature.as_ref().map(|t| t.as_celsius()),
|
||||
b.frequency.as_ref().map(|f| f.as_megahertz()),
|
||||
b.voltage.as_ref().map(|v| v.as_volts()),
|
||||
);
|
||||
}
|
||||
if d.messages.is_empty() {
|
||||
@@ -436,6 +473,209 @@ async fn factoryreset(ip_s: &str) {
|
||||
}
|
||||
}
|
||||
|
||||
/// READ-ONLY: dump a miner's structured-tuning surface -- what it supports, its
|
||||
/// current target, and the capability envelope (power/hashrate min-max, or the
|
||||
/// preset/mode list) the firmware advertises. Drives the round-17 C tuning work:
|
||||
/// it shows what each live firmware actually offers before any write is wired up.
|
||||
async fn tune(ip_s: &str) {
|
||||
let ip: std::net::IpAddr = match ip_s.parse() {
|
||||
Ok(ip) => ip,
|
||||
Err(e) => {
|
||||
eprintln!("bad ip {ip_s}: {e}");
|
||||
return;
|
||||
}
|
||||
};
|
||||
let f = factory();
|
||||
match f.scan_miner(ip).await {
|
||||
Ok(Some(m)) => {
|
||||
let data = m.get_data().await;
|
||||
println!(
|
||||
"{ip}: {} {} {}",
|
||||
data.device_info.make, data.device_info.firmware, data.device_info.model
|
||||
);
|
||||
println!(
|
||||
" supports: power_limit={} tuning_percent={} tuning_config={}",
|
||||
m.supports_set_power_limit(),
|
||||
m.supports_set_tuning_percent(),
|
||||
m.supports_tuning_config(),
|
||||
);
|
||||
println!(" psu={:?}", data.psu);
|
||||
println!(" tuning_percent={:?}", data.tuning_percent);
|
||||
println!(" tuning_target={:?}", data.tuning_target);
|
||||
match &data.tuning_capabilities {
|
||||
Some(c) => {
|
||||
println!(" caps.power={:?}", c.power);
|
||||
println!(" caps.hashrate={:?}", c.hashrate);
|
||||
match &c.presets {
|
||||
Some(p) => {
|
||||
println!(" caps.presets.default={:?}", p.default);
|
||||
println!(" caps.presets[{}]:", p.presets.len());
|
||||
for t in &p.presets {
|
||||
println!(" - {t:?}");
|
||||
}
|
||||
}
|
||||
None => println!(" caps.presets=None"),
|
||||
}
|
||||
}
|
||||
None => println!(" tuning_capabilities=None"),
|
||||
}
|
||||
}
|
||||
Ok(None) => eprintln!("no miner at {ip}"),
|
||||
Err(e) => eprintln!("scan_miner {ip}: {e}"),
|
||||
}
|
||||
}
|
||||
|
||||
/// WRITE (reversible): apply a structured tuning target via set_tuning_config.
|
||||
/// `settune <ip> power <watts>` or `settune <ip> hashrate <ths>`. Prints the
|
||||
/// prior target so the caller can restore it. Used to verify the set_tuning_config
|
||||
/// path on live corpus hardware (round 17 C) before wiring it into the GUI.
|
||||
async fn settune(ip_s: &str, kind: &str, value: f64) {
|
||||
use asic_rs::core::config::tuning::TuningConfig;
|
||||
use asic_rs::core::data::hashrate::HashRateUnit;
|
||||
use asic_rs::core::data::miner::TuningTarget;
|
||||
let ip: std::net::IpAddr = match ip_s.parse() {
|
||||
Ok(ip) => ip,
|
||||
Err(e) => {
|
||||
eprintln!("bad ip {ip_s}: {e}");
|
||||
return;
|
||||
}
|
||||
};
|
||||
let f = factory();
|
||||
match f.scan_miner(ip).await {
|
||||
Ok(Some(m)) => {
|
||||
let before = m.get_data().await;
|
||||
eprintln!(
|
||||
"target {ip}: {} {} {} (supports_tuning_config={}); prior target = {:?}",
|
||||
before.device_info.make,
|
||||
before.device_info.firmware,
|
||||
before.device_info.model,
|
||||
m.supports_tuning_config(),
|
||||
before.tuning_target,
|
||||
);
|
||||
let target = match kind {
|
||||
"power" => TuningTarget::Power(Power::from_watts(value)),
|
||||
// Clone the miner's current HashRate to inherit its algorithm
|
||||
// (HashAlgorithm is not publicly re-exported, so it cannot be named
|
||||
// directly), overriding just the value and unit.
|
||||
"hashrate" => match before.hashrate.clone() {
|
||||
Some(mut hr) => {
|
||||
hr.value = value;
|
||||
hr.unit = HashRateUnit::TeraHash;
|
||||
TuningTarget::HashRate(hr)
|
||||
}
|
||||
None => {
|
||||
eprintln!("miner reports no current hashrate; cannot build a hashrate target");
|
||||
return;
|
||||
}
|
||||
},
|
||||
_ => {
|
||||
eprintln!("kind must be 'power' or 'hashrate'");
|
||||
return;
|
||||
}
|
||||
};
|
||||
// Route by what the firmware actually supports: structured
|
||||
// set_tuning_config where available (ePIC/VNish/WM), else the plain
|
||||
// power-limit setter for a power target (LuxOS/Braiins tune by power
|
||||
// and expose no set_tuning_config).
|
||||
if m.supports_tuning_config() {
|
||||
// Mirror the GUI apply path: preserve the firmware's current tuning
|
||||
// algorithm + scaling (ePIC requires both for set_tuning_config).
|
||||
let mut cfg = TuningConfig::new(target);
|
||||
if let Some(algo) = m.get_tuning_config().await.ok().and_then(|c| c.algorithm) {
|
||||
cfg = cfg.with_algorithm(algo);
|
||||
}
|
||||
let scaling = m.get_scaling_config().await.ok();
|
||||
match m.set_tuning_config(cfg, scaling).await {
|
||||
Ok(v) => println!("set_tuning_config({kind} {value}) -> Ok({v})"),
|
||||
Err(e) => println!("set_tuning_config({kind} {value}) -> Err: {e:#}"),
|
||||
}
|
||||
} else if kind == "power" && m.supports_set_power_limit() {
|
||||
match m.set_power_limit(Power::from_watts(value)).await {
|
||||
Ok(v) => println!("set_power_limit({value} W) -> Ok({v}) [tuning_config unsupported]"),
|
||||
Err(e) => println!("set_power_limit({value} W) -> Err: {e:#}"),
|
||||
}
|
||||
} else {
|
||||
println!("no structured-tuning path for {kind} on this firmware");
|
||||
}
|
||||
let after = m.get_data().await;
|
||||
println!(" target now = {:?}", after.tuning_target);
|
||||
}
|
||||
Ok(None) => eprintln!("no miner at {ip}"),
|
||||
Err(e) => eprintln!("scan_miner {ip}: {e}"),
|
||||
}
|
||||
}
|
||||
|
||||
/// READ: list the firmware's selectable profiles/presets (roadmap G3).
|
||||
async fn presets(ip_s: &str) {
|
||||
let ip: std::net::IpAddr = match ip_s.parse() {
|
||||
Ok(ip) => ip,
|
||||
Err(e) => {
|
||||
eprintln!("bad ip {ip_s}: {e}");
|
||||
return;
|
||||
}
|
||||
};
|
||||
let f = factory();
|
||||
match f.scan_miner(ip).await {
|
||||
Ok(Some(m)) => {
|
||||
if !m.supports_presets() {
|
||||
println!("{ip}: firmware does not expose named presets");
|
||||
return;
|
||||
}
|
||||
let list = m.get_presets().await;
|
||||
if list.is_empty() {
|
||||
println!("{ip}: no presets reported");
|
||||
return;
|
||||
}
|
||||
for p in list {
|
||||
match (p.pretty, p.status) {
|
||||
(Some(pretty), Some(status)) => println!("{}\t{pretty}\t[{status}]", p.name),
|
||||
(Some(pretty), None) => println!("{}\t{pretty}", p.name),
|
||||
(None, _) => println!("{}", p.name),
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(None) => eprintln!("no miner at {ip}"),
|
||||
Err(e) => eprintln!("scan_miner {ip}: {e}"),
|
||||
}
|
||||
}
|
||||
|
||||
/// WRITE (reversible): select a named firmware profile/preset (roadmap G3).
|
||||
/// `setpreset <ip> <name>`. Prints the prior target so it can be restored.
|
||||
async fn setpreset(ip_s: &str, name: &str) {
|
||||
use asic_rs::core::config::tuning::TuningConfig;
|
||||
use asic_rs::core::data::miner::TuningTarget;
|
||||
let ip: std::net::IpAddr = match ip_s.parse() {
|
||||
Ok(ip) => ip,
|
||||
Err(e) => {
|
||||
eprintln!("bad ip {ip_s}: {e}");
|
||||
return;
|
||||
}
|
||||
};
|
||||
let f = factory();
|
||||
match f.scan_miner(ip).await {
|
||||
Ok(Some(m)) => {
|
||||
let before = m.get_data().await;
|
||||
eprintln!(
|
||||
"target {ip}: {} {} {} (supports_presets={}); prior target = {:?}",
|
||||
before.device_info.make,
|
||||
before.device_info.firmware,
|
||||
before.device_info.model,
|
||||
m.supports_presets(),
|
||||
before.tuning_target,
|
||||
);
|
||||
let cfg = TuningConfig::new(TuningTarget::Preset(name.to_string()));
|
||||
match m.set_tuning_config(cfg, None).await {
|
||||
Ok(v) => println!("set_tuning_config(preset {name}) -> Ok({v})"),
|
||||
Err(e) => println!("set_tuning_config(preset {name}) -> Err: {e:#}"),
|
||||
}
|
||||
let after = m.get_data().await;
|
||||
println!(" target now = {:?}", after.tuning_target);
|
||||
}
|
||||
Ok(None) => eprintln!("no miner at {ip}"),
|
||||
Err(e) => eprintln!("scan_miner {ip}: {e}"),
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let args: Vec<String> = std::env::args().collect();
|
||||
let rt = match tokio::runtime::Builder::new_current_thread().enable_all().build() {
|
||||
@@ -467,6 +707,17 @@ fn main() {
|
||||
rt.block_on(setpools(&args[2], &args[3], &args[4], &args[5]))
|
||||
}
|
||||
Some("msgs") if args.len() == 3 => rt.block_on(msgs(&args[2])),
|
||||
Some("tune") if args.len() == 3 => rt.block_on(tune(&args[2])),
|
||||
Some("presets") if args.len() == 3 => rt.block_on(presets(&args[2])),
|
||||
Some("setpreset") if args.len() == 4 => rt.block_on(setpreset(&args[2], &args[3])),
|
||||
Some("settune") if args.len() == 5 && matches!(args[3].as_str(), "power" | "hashrate") => {
|
||||
let value: f64 = args[4].parse().unwrap_or(-1.0);
|
||||
if value <= 0.0 {
|
||||
eprintln!("value must be a positive number");
|
||||
std::process::exit(2);
|
||||
}
|
||||
rt.block_on(settune(&args[2], &args[3], value));
|
||||
}
|
||||
Some("timezone") if args.len() == 3 => rt.block_on(timezone(&args[2], None)),
|
||||
Some("timezone") if args.len() == 4 => rt.block_on(timezone(&args[2], Some(&args[3]))),
|
||||
Some("passwd") if args.len() == 4 => rt.block_on(passwd(&args[2], &args[3])),
|
||||
@@ -479,6 +730,8 @@ fn main() {
|
||||
\x20 scan <cidr> [<cidr>...] discover + telemetry (TSV)\n\
|
||||
\x20 hashrate <cidr> [<cidr>...] raw hashrate/algo dump\n\
|
||||
\x20 msgs <ip> structured faults + per-board data\n\
|
||||
\x20 tune <ip> structured-tuning support + capability envelope\n\
|
||||
\x20 presets <ip> list selectable firmware profiles/presets\n\
|
||||
\n\
|
||||
WRITE (MUTATES the miner -- use the test-bed miners, not production):\n\
|
||||
\x20 light <ip> <on|off> set the locate light\n\
|
||||
@@ -487,6 +740,8 @@ fn main() {
|
||||
\x20 resume <ip> resume mining\n\
|
||||
\x20 restart <ip> restart/reboot\n\
|
||||
\x20 setpl <ip> <watts> set power limit\n\
|
||||
\x20 settune <ip> <power|hashrate> <v> set a structured tuning target (prints prior)\n\
|
||||
\x20 setpreset <ip> <name> select a named firmware profile/preset (prints prior)\n\
|
||||
\x20 setpools <ip> <url> <user> <pass> set the default pool group\n\
|
||||
\x20 timezone <ip> [<IANA>] read (no arg) or set the timezone\n\
|
||||
\x20 passwd <ip> <newpass> change the web/API password (DANGEROUS)\n\
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -9,13 +9,21 @@
|
||||
|
||||
use crate::model::{BoardHealth, MinerRow};
|
||||
|
||||
/// Escape one CSV field: quote it when it contains a comma, quote, CR or LF, and
|
||||
/// double any embedded quotes.
|
||||
/// Escape one CSV field: neutralise spreadsheet formula injection, then quote it
|
||||
/// when it contains a comma, quote, CR or LF (doubling any embedded quotes).
|
||||
///
|
||||
/// Miner-supplied fields (hostname, worker, serial, ...) can start with a formula
|
||||
/// trigger; prefixing a single quote makes Excel/Sheets treat the cell as text so
|
||||
/// opening the export can't execute an injected formula (round 18 #12).
|
||||
fn esc(s: &str) -> String {
|
||||
if s.contains([',', '"', '\n', '\r']) {
|
||||
format!("\"{}\"", s.replace('"', "\"\""))
|
||||
let mut val = s.to_string();
|
||||
if val.starts_with(['=', '+', '-', '@', '\t', '\r']) {
|
||||
val.insert(0, '\'');
|
||||
}
|
||||
if val.contains([',', '"', '\n', '\r']) {
|
||||
format!("\"{}\"", val.replace('"', "\"\""))
|
||||
} else {
|
||||
s.to_string()
|
||||
val
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -60,6 +60,19 @@ impl Board {
|
||||
} else {
|
||||
vec![]
|
||||
};
|
||||
// Per-board hashrate for the R2 Health tooltip demo: split the total three
|
||||
// ways with a little variety (index-aligned with the 3 boards).
|
||||
let board_hashrates = if self.mining && self.hashrate > 0.0 {
|
||||
vec![self.hashrate * 0.34, self.hashrate * 0.35, self.hashrate * 0.31]
|
||||
} else {
|
||||
vec![]
|
||||
};
|
||||
// Per-board configured frequency/voltage for the G7 read-side tooltip demo.
|
||||
let (board_frequencies, board_voltages) = if self.mining {
|
||||
(vec![590.0, 590.0, 565.0], vec![13.50, 13.50, 13.35])
|
||||
} else {
|
||||
(vec![], vec![])
|
||||
};
|
||||
// Air-cooled WhatsMiners report an ambient reading (asic-rs surfaces it in
|
||||
// its fluid_temperature field); the scan routes it to env_temp for
|
||||
// air-cooled models, so the demo mirrors that (round 11 #17).
|
||||
@@ -97,6 +110,8 @@ impl Board {
|
||||
let control_board = crate::naming::control_board_code(self.make, self.board, &model);
|
||||
let cpu = crate::naming::control_board_cpu(self.make, self.board, &model);
|
||||
let board_code = crate::naming::control_board_board(self.make, self.board, &model);
|
||||
// Computed before `model` is moved into the struct literal below.
|
||||
let pic_present = crate::scan::infer_pic(&model);
|
||||
MinerRow {
|
||||
ip: self.ip.to_string(),
|
||||
selected: false,
|
||||
@@ -109,6 +124,9 @@ impl Board {
|
||||
board_code,
|
||||
hashrate_ths: self.hashrate,
|
||||
expected_ths: self.expected,
|
||||
board_hashrates,
|
||||
board_voltages,
|
||||
board_frequencies,
|
||||
efficiency,
|
||||
power_w: self.power,
|
||||
chip_temp_c: self.temp,
|
||||
@@ -127,6 +145,13 @@ impl Board {
|
||||
board_status,
|
||||
total_chips: chips,
|
||||
psu_fan_rpm: if self.mining { self.fan * 0.9 } else { 0.0 },
|
||||
// PSU info demo (round 17 R5): mining units show a version + rated
|
||||
// envelope + live output, so the columns and the R2 PSU tooltip render.
|
||||
psu_version: if self.mining { "22 (117)".to_string() } else { String::new() },
|
||||
psu_voltage_min_v: self.mining.then_some(11.88),
|
||||
psu_voltage_max_v: self.mining.then_some(15.18),
|
||||
psu_out_voltage_v: self.mining.then_some(13.2),
|
||||
psu_out_current_a: self.mining.then_some(210.0),
|
||||
uptime_secs: if self.mining { 3600 * 24 * 2 + 3600 * 5 } else { 0 },
|
||||
// One unit is "being located" so the Light column's yellow dot is
|
||||
// demonstrable offline (round 11 #10).
|
||||
@@ -157,6 +182,8 @@ impl Board {
|
||||
resume: self.mining,
|
||||
power_limit: self.mining,
|
||||
tuning: self.mining,
|
||||
hashrate_target: self.mining,
|
||||
supports_presets: self.mining,
|
||||
firmware_flash,
|
||||
pools: true,
|
||||
timezone: self.mining,
|
||||
@@ -167,13 +194,9 @@ impl Board {
|
||||
// show variety offline). control_board is derived above via naming.
|
||||
algorithm: "SHA256".to_string(),
|
||||
control_board,
|
||||
pic_present: if self.model_id.contains("S21") {
|
||||
Some(false) // noPIC example
|
||||
} else if self.make.eq_ignore_ascii_case("antminer") {
|
||||
Some(true)
|
||||
} else {
|
||||
None // WhatsMiner: unknown over the network
|
||||
},
|
||||
// Use the same PIC inference the live scan uses (round 18 #12: the demo
|
||||
// previously reimplemented a simplified version that disagreed with it).
|
||||
pic_present,
|
||||
// Access: idle/view-only units (no worker) shown locked; the rest
|
||||
// unlocked. (Live rows infer this from control capabilities.)
|
||||
write_locked: Some(self.worker.is_empty()),
|
||||
@@ -187,6 +210,17 @@ impl Board {
|
||||
} else {
|
||||
Vec::new()
|
||||
},
|
||||
// Demo firmware presets (round 18 / G3) so the "Set profile..." dialog
|
||||
// is exercisable offline on units that advertise preset support.
|
||||
presets: if self.mining {
|
||||
vec![
|
||||
crate::model::MinerPreset { name: "default".into(), pretty: Some("2794 W ~ 121.8 TH @ 590 MHz".into()) },
|
||||
crate::model::MinerPreset { name: "540MHz".into(), pretty: Some("2485 W ~ 111.5 TH @ 540 MHz".into()) },
|
||||
crate::model::MinerPreset { name: "490MHz".into(), pretty: Some("2192 W ~ 101.1 TH @ 490 MHz".into()) },
|
||||
]
|
||||
} else {
|
||||
Vec::new()
|
||||
},
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
@@ -222,10 +256,10 @@ pub fn bench_fleet() -> Vec<MinerRow> {
|
||||
Board { ip: "10.255.1.126", make: "Whatsminer", model_id: "M30SVE40", board: "H3", firmware: "Stock", fw_version: "H3.0.1",
|
||||
hashrate: 92.0, expected: 96.0, power: 3400.0, temp: 70.0, fan: 4800.0,
|
||||
worker: "blueflare.h3", mining: true, paused: false },
|
||||
Board { ip: "10.255.1.131", make: "Whatsminer", model_id: "M30SPlusVE40", board: "H616", firmware: "Hive", fw_version: "1.0",
|
||||
Board { ip: "10.255.1.131", make: "Whatsminer", model_id: "M30SPlusVE40", board: "H616", firmware: "Hiveon", fw_version: "1.05",
|
||||
hashrate: 100.0, expected: 100.0, power: 3450.0, temp: 71.0, fan: 4900.0,
|
||||
worker: "blueflare.h616", mining: true, paused: false },
|
||||
Board { ip: "10.255.1.148", make: "Whatsminer", model_id: "M50VH50", board: "H6", firmware: "BixBit", fw_version: "2.1",
|
||||
Board { ip: "10.255.1.148", make: "Whatsminer", model_id: "M50VH50", board: "H6", firmware: "Bixbit", fw_version: "0.9.9.4",
|
||||
hashrate: 118.0, expected: 122.0, power: 3300.0, temp: 66.0, fan: 4600.0,
|
||||
worker: "blueflare.m50", mining: true, paused: false },
|
||||
// Rebucketed from idle/not-hashing to paused so the "paused"
|
||||
|
||||
@@ -61,8 +61,14 @@ fn tail(s: &str, max: usize) -> String {
|
||||
if s.len() <= max {
|
||||
return s.to_string();
|
||||
}
|
||||
let start = s.len() - max;
|
||||
// advance to the next line boundary so we don't cut a line in half
|
||||
// Nudge the cut forward to a UTF-8 char boundary first: a raw byte offset can
|
||||
// land inside a multi-byte character and slicing there would panic (round 18
|
||||
// #12; miner logs are not guaranteed pure ASCII).
|
||||
let mut start = s.len() - max;
|
||||
while start < s.len() && !s.is_char_boundary(start) {
|
||||
start += 1;
|
||||
}
|
||||
// then advance to the next line boundary so we don't cut a line in half
|
||||
let start = s[start..]
|
||||
.find('\n')
|
||||
.map(|i| start + i + 1)
|
||||
@@ -122,35 +128,45 @@ fn summarize_log(log: &str) -> Vec<String> {
|
||||
|
||||
/// VNish: unlock -> bearer -> the full miner log.
|
||||
fn fetch_vnish_log(ip: &str, pass: &str) -> Result<String, String> {
|
||||
let unlock = curl(&[
|
||||
"-s",
|
||||
"--connect-timeout",
|
||||
"5",
|
||||
"--max-time",
|
||||
"9",
|
||||
"-X",
|
||||
"POST",
|
||||
"-H",
|
||||
"Content-Type: application/json",
|
||||
"-d",
|
||||
&format!("{{\"pw\":\"{pass}\"}}"),
|
||||
&format!("http://{ip}/api/v1/unlock"),
|
||||
])?;
|
||||
// The password goes in the POST body read from stdin (-d @-), never on argv,
|
||||
// and is JSON-encoded by serde so it is both un-leakable and correctly escaped
|
||||
// (round 18 #12).
|
||||
let body = serde_json::json!({ "pw": pass }).to_string();
|
||||
let unlock = curl(
|
||||
&[
|
||||
"-s",
|
||||
"--connect-timeout",
|
||||
"5",
|
||||
"--max-time",
|
||||
"9",
|
||||
"-X",
|
||||
"POST",
|
||||
"-H",
|
||||
"Content-Type: application/json",
|
||||
"-d",
|
||||
"@-",
|
||||
&format!("http://{ip}/api/v1/unlock"),
|
||||
],
|
||||
Some(body.as_bytes()),
|
||||
)?;
|
||||
let token = serde_json::from_str::<serde_json::Value>(&unlock)
|
||||
.ok()
|
||||
.and_then(|v| v.get("token").and_then(|t| t.as_str()).map(str::to_string))
|
||||
.filter(|t| !t.is_empty())
|
||||
.ok_or_else(|| "VNish unlock rejected (check the VNish password in scan credentials)".to_string())?;
|
||||
let log = curl(&[
|
||||
"-s",
|
||||
"--connect-timeout",
|
||||
"5",
|
||||
"--max-time",
|
||||
"12",
|
||||
"-H",
|
||||
&format!("Authorization: Bearer {token}"),
|
||||
&format!("http://{ip}/api/v1/logs/miner"),
|
||||
])?;
|
||||
let log = curl(
|
||||
&[
|
||||
"-s",
|
||||
"--connect-timeout",
|
||||
"5",
|
||||
"--max-time",
|
||||
"12",
|
||||
"-H",
|
||||
&format!("Authorization: Bearer {token}"),
|
||||
&format!("http://{ip}/api/v1/logs/miner"),
|
||||
],
|
||||
None,
|
||||
)?;
|
||||
if log.trim().is_empty() {
|
||||
return Err("VNish returned an empty log".to_string());
|
||||
}
|
||||
@@ -159,17 +175,23 @@ fn fetch_vnish_log(ip: &str, pass: &str) -> Result<String, String> {
|
||||
|
||||
/// Stock Antminer web log (digest auth). Absent on older models (404).
|
||||
fn fetch_antminer_log(ip: &str, user: &str, pass: &str) -> Result<String, String> {
|
||||
let body = curl(&[
|
||||
"-s",
|
||||
"--digest",
|
||||
"-u",
|
||||
&format!("{user}:{pass}"),
|
||||
"--connect-timeout",
|
||||
"5",
|
||||
"--max-time",
|
||||
"12",
|
||||
&format!("http://{ip}/cgi-bin/log.cgi"),
|
||||
])?;
|
||||
// Credentials go through a curl config on stdin (-K -), never on argv, so they
|
||||
// can't be read from the process list (round 18 #12).
|
||||
let config = format!("user = \"{}\"\n", curl_config_quote(&format!("{user}:{pass}")));
|
||||
let body = curl(
|
||||
&[
|
||||
"-s",
|
||||
"--digest",
|
||||
"--connect-timeout",
|
||||
"5",
|
||||
"--max-time",
|
||||
"12",
|
||||
"-K",
|
||||
"-",
|
||||
&format!("http://{ip}/cgi-bin/log.cgi"),
|
||||
],
|
||||
Some(config.as_bytes()),
|
||||
)?;
|
||||
if body.contains("404 - Not Found") || body.trim().is_empty() {
|
||||
return Err("this firmware does not expose a log over its web API".to_string());
|
||||
}
|
||||
@@ -186,17 +208,29 @@ fn fetch_whatsminer_errors(ip: &str) -> Result<String, String> {
|
||||
/// Run curl and return stdout, with a hard wall-clock cap. stdout is drained on a
|
||||
/// separate thread so a large log (hundreds of KB) never deadlocks on a full pipe
|
||||
/// -- the reason a naive "wait then read" times out on the VNish log.
|
||||
fn curl(args: &[&str]) -> Result<String, String> {
|
||||
use std::io::Read;
|
||||
fn curl(args: &[&str], stdin_data: Option<&[u8]>) -> Result<String, String> {
|
||||
use std::io::{Read, Write};
|
||||
let mut cmd = Command::new("curl");
|
||||
cmd.args(args);
|
||||
cmd.stdout(std::process::Stdio::piped());
|
||||
cmd.stderr(std::process::Stdio::null());
|
||||
if stdin_data.is_some() {
|
||||
cmd.stdin(std::process::Stdio::piped());
|
||||
}
|
||||
let mut child = cmd.spawn().map_err(|e| format!("spawn curl: {e}"))?;
|
||||
let mut stdout = child.stdout.take().ok_or("no curl stdout")?;
|
||||
if let Some(data) = stdin_data {
|
||||
if let Some(mut si) = child.stdin.take() {
|
||||
let _ = si.write_all(data);
|
||||
} // dropping `si` closes the pipe so curl stops reading the config/body
|
||||
}
|
||||
let stdout = child.stdout.take().ok_or("no curl stdout")?;
|
||||
let reader = std::thread::spawn(move || {
|
||||
// Bound the buffer: a miner-controlled response must not exhaust memory
|
||||
// (round 18 #12). The viewer only keeps the last MAX_LOG_BYTES anyway, so
|
||||
// read a small multiple of that and drop the rest.
|
||||
const READ_CAP: u64 = (MAX_LOG_BYTES as u64) * 8; // 2 MiB
|
||||
let mut buf = Vec::new();
|
||||
let _ = stdout.read_to_end(&mut buf);
|
||||
let _ = stdout.take(READ_CAP).read_to_end(&mut buf);
|
||||
buf
|
||||
});
|
||||
let timeout = Duration::from_secs(20);
|
||||
@@ -208,6 +242,7 @@ fn curl(args: &[&str]) -> Result<String, String> {
|
||||
None => {
|
||||
if start.elapsed() >= timeout {
|
||||
let _ = child.kill();
|
||||
let _ = child.wait(); // reap so we never leave a zombie (round 18 #12)
|
||||
timed_out = true;
|
||||
break;
|
||||
}
|
||||
@@ -222,10 +257,25 @@ fn curl(args: &[&str]) -> Result<String, String> {
|
||||
Ok(String::from_utf8_lossy(&buf).into_owned())
|
||||
}
|
||||
|
||||
/// Escape a value for a curl `--config` file (double-quoted string).
|
||||
fn curl_config_quote(s: &str) -> String {
|
||||
s.replace('\\', "\\\\").replace('"', "\\\"")
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn tail_does_not_panic_mid_multibyte_char() {
|
||||
// A byte-offset cut can land inside a multi-byte character; tail must nudge
|
||||
// to a char boundary rather than panic (round 18 #12).
|
||||
let s = "\u{00e9}".repeat(200); // 400 bytes of 2-byte chars, no newlines
|
||||
let out = tail(&s, 101); // cut at an odd offset -> inside a char
|
||||
assert!(out.starts_with("[... earlier log trimmed ...]"));
|
||||
assert!(out.len() < s.len());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn summarize_finds_pic_chains_and_errors() {
|
||||
let log = "\
|
||||
|
||||
@@ -16,7 +16,6 @@ mod restore;
|
||||
mod scan;
|
||||
mod ui;
|
||||
|
||||
use wx_rs;
|
||||
|
||||
fn main() {
|
||||
// Headless workflow self-test: render the bench-fleet fixtures through the
|
||||
|
||||
@@ -2,6 +2,13 @@
|
||||
|
||||
use std::collections::{HashMap, HashSet};
|
||||
|
||||
/// Serialises tests that mutate the process-global `$HOME` (config paths read it),
|
||||
/// so they never race each other under the parallel test harness (round 18 #12).
|
||||
/// Lock it with `.lock().unwrap_or_else(|e| e.into_inner())` to shrug off a poison
|
||||
/// from a panicking sibling test.
|
||||
#[cfg(test)]
|
||||
pub(crate) static HOME_TEST_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
|
||||
|
||||
/// A miner counts as "slow" when it is mining but running below this fraction
|
||||
/// of its model's expected hashrate (UI-SPEC "Slow" band). A missing expected
|
||||
/// hashrate (0.0) means the band is unknown, so the miner is never "slow".
|
||||
@@ -75,6 +82,23 @@ pub fn format_hashrate_ths(ths: f64) -> Option<String> {
|
||||
si_mantissa_and_prefix(ths * 1e12).map(|(num, prefix)| format!("{num}{prefix}"))
|
||||
}
|
||||
|
||||
/// A hashrate number (no unit) for a given mining algorithm (round 18 #7). asic-rs
|
||||
/// stores every hashrate normalised to "TH/s", but for Equihash the underlying
|
||||
/// count is Sol/s that it reinterprets through the base H unit, so `ths * 1e12`
|
||||
/// recovers the real Sol/s count. SHA256/Scrypt show the TH/s value directly
|
||||
/// ("33.5"); Equihash shows the Sol/s count with an SI prefix ("167.8K"). Pair
|
||||
/// with [`MinerRow::hashrate_unit`]. `None` for a non-positive reading.
|
||||
pub fn hashrate_num_for(algo: &str, ths: f64) -> Option<String> {
|
||||
if ths <= 0.0 {
|
||||
return None;
|
||||
}
|
||||
if algo.eq_ignore_ascii_case("equihash") {
|
||||
si_mantissa_and_prefix(ths * 1e12).map(|(num, prefix)| format!("{num}{prefix}"))
|
||||
} else {
|
||||
Some(format!("{ths:.1}"))
|
||||
}
|
||||
}
|
||||
|
||||
/// The actual/expected ratio, or `None` when the expected value is unknown
|
||||
/// (<= 0.0) so a ratio-based color/warning never divides by zero or treats an
|
||||
/// unknown expectation as a 0% shortfall.
|
||||
@@ -106,12 +130,19 @@ fn combined_count(actual: Option<u32>, expected: Option<u32>) -> String {
|
||||
}
|
||||
}
|
||||
|
||||
/// An RGB colour (0-255 per channel) for a coloured text segment.
|
||||
pub type Rgb = (u8, u8, u8);
|
||||
/// One coloured text segment: an optional colour plus its text. Cells with
|
||||
/// two-tone / multi-tone content (actual vs expected, per-fan colours) are built
|
||||
/// as a `Vec<Segment>` and encoded via [`encode_segments`].
|
||||
pub type Segment = (Option<Rgb>, String);
|
||||
|
||||
/// Encode colored text segments for a custom-rendered cell (see the wx-rs
|
||||
/// `SegmentRenderer`): segments are joined by U+001F, and within a segment an
|
||||
/// optional uppercase RRGGBB color is separated from its text by U+001E.
|
||||
/// `decode_segments_plain` is the inverse for anything that just wants the
|
||||
/// plain text (filtering, sorting, tests).
|
||||
pub fn encode_segments(segs: &[(Option<(u8, u8, u8)>, String)]) -> String {
|
||||
pub fn encode_segments(segs: &[Segment]) -> String {
|
||||
segs.iter()
|
||||
.map(|(color, text)| {
|
||||
let hex = color.map(|(r, g, b)| format!("{r:02X}{g:02X}{b:02X}")).unwrap_or_default();
|
||||
@@ -213,6 +244,14 @@ pub struct MinerCaps {
|
||||
pub resume: bool,
|
||||
pub power_limit: bool,
|
||||
pub tuning: bool,
|
||||
/// Round 17 C: supports setting a structured hashrate target via
|
||||
/// `set_tuning_config` (the firmware actively tunes by hashrate, e.g. ePIC).
|
||||
/// Power targets are covered by `power_limit`.
|
||||
pub hashrate_target: bool,
|
||||
/// Round 18 / roadmap G3: supports selecting a named firmware preset/profile
|
||||
/// via `set_tuning_config(TuningTarget::Preset)` (LuxOS profiles, VNish presets).
|
||||
/// The available presets are read live into `MinerRow::presets` at scan time.
|
||||
pub supports_presets: bool,
|
||||
/// Whether this miner's asic-rs driver supports `upgrade_firmware`
|
||||
/// (probed via `supports_upgrade_firmware()` at scan time).
|
||||
pub firmware_flash: bool,
|
||||
@@ -236,6 +275,8 @@ impl MinerCaps {
|
||||
resume: self.resume && other.resume,
|
||||
power_limit: self.power_limit && other.power_limit,
|
||||
tuning: self.tuning && other.tuning,
|
||||
hashrate_target: self.hashrate_target && other.hashrate_target,
|
||||
supports_presets: self.supports_presets && other.supports_presets,
|
||||
firmware_flash: self.firmware_flash && other.firmware_flash,
|
||||
pools: self.pools && other.pools,
|
||||
timezone: self.timezone && other.timezone,
|
||||
@@ -268,6 +309,8 @@ impl MinerCaps {
|
||||
|| self.resume
|
||||
|| self.power_limit
|
||||
|| self.tuning
|
||||
|| self.hashrate_target
|
||||
|| self.supports_presets
|
||||
|| self.firmware_flash
|
||||
|| self.pools
|
||||
|| self.timezone
|
||||
@@ -306,10 +349,26 @@ pub enum FaultComponent {
|
||||
pub struct Fault {
|
||||
pub component: FaultComponent,
|
||||
pub message: String,
|
||||
/// Firmware's numeric error code for this message, or 0 when none. Shown in
|
||||
/// the tooltip alongside the text (round 17 R2) so an operator can look the
|
||||
/// code up.
|
||||
pub code: u64,
|
||||
/// True for Error severity; false for Warning. (Info is dropped upstream.)
|
||||
pub is_error: bool,
|
||||
}
|
||||
|
||||
impl Fault {
|
||||
/// The tooltip line for this fault: the message, with the firmware error code
|
||||
/// appended when there is one (round 17 R2).
|
||||
pub fn display_line(&self) -> String {
|
||||
if self.code != 0 {
|
||||
format!("{} (code {})", self.message, self.code)
|
||||
} else {
|
||||
self.message.clone()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// One component's health for the Health icon column (round 13 #3). Rendered as a
|
||||
/// coloured icon: grey = unreachable / not detected, red = detected but not
|
||||
/// functioning, yellow = functioning sub-optimally, green = fully functioning.
|
||||
@@ -343,6 +402,15 @@ pub enum HealthFacet {
|
||||
Boards,
|
||||
}
|
||||
|
||||
/// One selectable firmware preset/profile (round 18 / roadmap G3). `name` is the
|
||||
/// identifier the firmware expects (e.g. LuxOS "540MHz", VNish "5560"); `pretty`
|
||||
/// is an optional human summary (e.g. "2485 W ~ 111.5 TH @ 540 MHz").
|
||||
#[derive(Debug, Clone, Default, PartialEq, Eq)]
|
||||
pub struct MinerPreset {
|
||||
pub name: String,
|
||||
pub pretty: Option<String>,
|
||||
}
|
||||
|
||||
/// One miner's telemetry snapshot, flattened from asic-rs `MinerData` into the
|
||||
/// scalar fields the table can display. Absent metrics are `None` / empty /
|
||||
/// 0.0 and render as a blank cell.
|
||||
@@ -394,9 +462,46 @@ pub struct MinerRow {
|
||||
// performance
|
||||
pub hashrate_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
|
||||
/// the firmware reports no per-board hashrate.
|
||||
pub board_hashrates: Vec<f64>,
|
||||
/// Per-hashboard EXPECTED hashrate in TH/s, index-aligned with the hashboards.
|
||||
/// The per-board tooltip shows actual / expected (round 18 #3). Empty when the
|
||||
/// firmware reports no per-board expected hashrate.
|
||||
pub board_expected_hashrates: Vec<f64>,
|
||||
/// Per-hashboard configured voltage (V) and frequency (MHz), index-aligned
|
||||
/// with the hashboards (round 18 / roadmap G7 read side). Shown in the per-board
|
||||
/// Health tooltip; 0.0 where the firmware reports no value.
|
||||
pub board_voltages: Vec<f64>,
|
||||
pub board_frequencies: Vec<f64>,
|
||||
#[allow(dead_code)] // retained for the "slow" band; not shown as its own column
|
||||
pub efficiency: f64,
|
||||
pub power_w: f64,
|
||||
/// PSU output voltage/current, when the firmware reports them (round 17 R2 /
|
||||
/// roadmap G15). `None` until the PSU-info scan lands; the power tooltip then
|
||||
/// shows "V / A" for a healthy PSU instead of a bare "PSU OK".
|
||||
pub psu_out_voltage_v: Option<f64>,
|
||||
pub psu_out_current_a: Option<f64>,
|
||||
/// 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,
|
||||
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",
|
||||
/// "96 TH/s", "preset 3550"), or None (round 17 C).
|
||||
pub tuning_target_label: Option<String>,
|
||||
/// The firmware's selectable named presets/profiles, read live at scan time
|
||||
/// when `caps.supports_presets` (round 18 / roadmap G3). Empty otherwise.
|
||||
pub presets: Vec<MinerPreset>,
|
||||
/// Advertised power-target envelope in watts, when the firmware reports one
|
||||
/// (round 17 C, e.g. Braiins 944-6435 W). Bounds + validate the power-target
|
||||
/// prompt; `None` leaves it unbounded.
|
||||
pub power_target_min_w: Option<f64>,
|
||||
pub power_target_max_w: Option<f64>,
|
||||
/// Advertised hashrate-target envelope in TH/s, when reported (round 17 C).
|
||||
pub hashrate_target_min_ths: Option<f64>,
|
||||
pub hashrate_target_max_ths: Option<f64>,
|
||||
pub tuning_percent: Option<u8>,
|
||||
// thermal / cooling
|
||||
/// Average chip temperature (used for sorting/colour banding of the
|
||||
@@ -469,12 +574,17 @@ impl MinerRow {
|
||||
/// live); grey (unknown) otherwise -- asic-rs has no direct PSU-fault flag, so
|
||||
/// a missing wattage reading is treated as unknown, never a false "down".
|
||||
pub fn power_health(&self) -> CompHealth {
|
||||
// A reported power-supply fault (round 16 #2) is authoritative: red, even
|
||||
// if a residual wattage is still being read.
|
||||
// A miner drawing power / spinning its PSU fan / actively mining has a live
|
||||
// PSU regardless of any warning flag.
|
||||
let delivering = self.power_w > 0.0 || self.psu_fan_rpm > 0.0 || self.is_mining;
|
||||
// A reported PSU fault while the miner is actually mining is a warning, not
|
||||
// a failure -- yellow, not red (round 18 #2: some WhatsMiners flag a PSU
|
||||
// error while running fine). A fault on a miner that is not mining is a real
|
||||
// failure (red).
|
||||
if self.faults_for(FaultComponent::Power).next().is_some() {
|
||||
return CompHealth::Down;
|
||||
return if self.is_mining { CompHealth::Degraded } else { CompHealth::Down };
|
||||
}
|
||||
if self.power_w > 0.0 || self.psu_fan_rpm > 0.0 || self.is_mining {
|
||||
if delivering {
|
||||
CompHealth::Ok
|
||||
} else {
|
||||
CompHealth::Unreachable
|
||||
@@ -510,12 +620,6 @@ impl MinerRow {
|
||||
.filter(|f| f.is_error && matches!(f.component, FaultComponent::Other))
|
||||
}
|
||||
|
||||
/// True when the miner reports a power-supply fault, which means the
|
||||
/// hashboards cannot be powered or evaluated (round 16 #2).
|
||||
fn power_supply_faulted(&self) -> bool {
|
||||
self.faults_for(FaultComponent::Power).next().is_some()
|
||||
}
|
||||
|
||||
/// Per-fan health (round 13 #3), front-to-back / top-to-bottom in the order
|
||||
/// the miner reports its fans. A spinning fan is green, unless it is running
|
||||
/// well below its fastest sibling (< 50% of the max reported RPM), which is a
|
||||
@@ -574,16 +678,28 @@ impl MinerRow {
|
||||
if base.is_empty() {
|
||||
return base;
|
||||
}
|
||||
// 3. A PSU fault means no board can be powered/tested -> all grey.
|
||||
if self.power_supply_faulted() {
|
||||
return vec![CompHealth::Unreachable; base.len()];
|
||||
}
|
||||
// 2. Board-specific faults are authoritative: red only the named boards,
|
||||
// green the rest (overriding a stall-induced all-red).
|
||||
// 2. Board-specific faults are authoritative: red the named boards. A board
|
||||
// is grey ONLY when it is genuinely not detected (base Missing); a board
|
||||
// that is running stays green and a faulted board is red, even when the
|
||||
// PSU also reports a fault (round 18 #4b -- WhatsMiner codes 540/560 must
|
||||
// show red, not grey, and boards still hashing during a PSU fault stay
|
||||
// green). A whole-miner stall reds every board's base, so exonerate the
|
||||
// boards the fault codes did NOT name back to healthy.
|
||||
let board_faulted = |i: usize| self.faults_for(FaultComponent::Board(i)).next().is_some();
|
||||
if (0..base.len()).any(board_faulted) {
|
||||
for (i, h) in base.iter_mut().enumerate() {
|
||||
*h = if board_faulted(i) { CompHealth::Down } else { ok };
|
||||
if board_faulted(i) {
|
||||
// A genuinely-undetected board stays grey ("not detected") even
|
||||
// when a fault text names it: a message like "chain N not found"
|
||||
// describes exactly that missing board, and grey-vs-red is the
|
||||
// documented distinction (round 18 #12). Only detected boards go red.
|
||||
if *h != CompHealth::Unreachable {
|
||||
*h = CompHealth::Down;
|
||||
}
|
||||
} else if *h == CompHealth::Down {
|
||||
*h = ok; // stall-reddened but not named by the fault codes
|
||||
}
|
||||
// else keep the base (green Ok / grey Missing).
|
||||
}
|
||||
}
|
||||
base
|
||||
@@ -625,7 +741,7 @@ impl MinerRow {
|
||||
self.faults
|
||||
.iter()
|
||||
.filter(|f| f.component == component)
|
||||
.map(|f| f.message.clone())
|
||||
.map(|f| f.display_line())
|
||||
.collect()
|
||||
}
|
||||
|
||||
@@ -635,7 +751,7 @@ impl MinerRow {
|
||||
self.faults
|
||||
.iter()
|
||||
.filter(|f| matches!(f.component, FaultComponent::Other | FaultComponent::Control))
|
||||
.map(|f| f.message.clone())
|
||||
.map(|f| f.display_line())
|
||||
.collect()
|
||||
}
|
||||
|
||||
@@ -646,84 +762,114 @@ impl MinerRow {
|
||||
/// reports for that component.
|
||||
pub fn health_tooltips(&self, max_fans: usize, max_boards: usize) -> Vec<String> {
|
||||
let mut tips: Vec<String> = Vec::with_capacity(2 + max_fans + max_boards);
|
||||
// Power -- the bolt icon carries any power-supply faults (round 16 #2).
|
||||
// Power (bolt). A working PSU shows its output voltage + amperage when the
|
||||
// firmware reports them (else a short OK); a faulted one shows the error
|
||||
// and code instead (round 17 R2). asic-rs does not yet surface PSU output
|
||||
// V/A (roadmap G15), so `psu_output` is None until that lands and the OK
|
||||
// branch shows just the status.
|
||||
let power_faults = self.fault_texts_for(FaultComponent::Power);
|
||||
let mut power = format!(
|
||||
"Power supply: {}",
|
||||
match self.power_health() {
|
||||
CompHealth::Ok => "OK (drawing power)",
|
||||
CompHealth::Down if !power_faults.is_empty() => "fault reported",
|
||||
CompHealth::Down => "detected but not delivering",
|
||||
CompHealth::Degraded => "sub-optimal",
|
||||
CompHealth::Unreachable => "unknown (no wattage/PSU-fan reported)",
|
||||
}
|
||||
);
|
||||
for e in &power_faults {
|
||||
power.push('\n');
|
||||
power.push_str(e);
|
||||
if !power_faults.is_empty() {
|
||||
tips.push(power_faults.join("\n"));
|
||||
} else {
|
||||
tips.push(match (self.power_health(), self.psu_output_label()) {
|
||||
(CompHealth::Ok, Some(va)) => va,
|
||||
(CompHealth::Ok, None) => "PSU OK".to_string(),
|
||||
(CompHealth::Degraded, _) => "PSU sub-optimal".to_string(),
|
||||
(CompHealth::Down, _) => "PSU not delivering".to_string(),
|
||||
(CompHealth::Unreachable, _) => "PSU unknown".to_string(),
|
||||
});
|
||||
}
|
||||
tips.push(power);
|
||||
// Control board -- also carries the miner's un-attributed / control faults.
|
||||
let mut ctl = format!(
|
||||
"Control board: {}",
|
||||
match self.control_health() {
|
||||
CompHealth::Ok => "OK (miner reachable)",
|
||||
CompHealth::Degraded => "miner-level fault",
|
||||
CompHealth::Down => "fault reported",
|
||||
CompHealth::Unreachable => "unknown",
|
||||
}
|
||||
);
|
||||
for e in self.general_fault_texts() {
|
||||
ctl.push('\n');
|
||||
ctl.push_str(&e);
|
||||
// Control board (brain) -- its own and the miner's un-attributed faults
|
||||
// with codes; a short OK when clean.
|
||||
let ctl_faults = self.general_fault_texts();
|
||||
if !ctl_faults.is_empty() {
|
||||
tips.push(ctl_faults.join("\n"));
|
||||
} else {
|
||||
tips.push(match self.control_health() {
|
||||
CompHealth::Ok => "Control board OK".to_string(),
|
||||
_ => "Control board fault".to_string(),
|
||||
});
|
||||
}
|
||||
tips.push(ctl);
|
||||
// Fans.
|
||||
// Fans -- just the RPM, unless the fan has a fault (then the error+code).
|
||||
let fans = self.fan_healths();
|
||||
for i in 0..max_fans {
|
||||
let s = match fans.get(i) {
|
||||
Some(CompHealth::Ok) => {
|
||||
let rpm = self.fan_rpms.get(i).map(|r| format!(" ({:.0} rpm)", r)).unwrap_or_default();
|
||||
format!("spinning{rpm}")
|
||||
let fault = self.fault_texts_for(FaultComponent::Fan(i));
|
||||
let t = if !fault.is_empty() {
|
||||
fault.join("\n")
|
||||
} else {
|
||||
match fans.get(i) {
|
||||
Some(_) => format!("{:.0} rpm", self.fan_rpms.get(i).copied().unwrap_or(0.0)),
|
||||
None => String::new(), // padding slot for fleet alignment
|
||||
}
|
||||
Some(CompHealth::Degraded) => {
|
||||
let rpm = self.fan_rpms.get(i).map(|r| format!(" ({:.0} rpm)", r)).unwrap_or_default();
|
||||
format!("slow{rpm}")
|
||||
}
|
||||
Some(CompHealth::Down) => "stopped (0 rpm)".to_string(),
|
||||
Some(CompHealth::Unreachable) => "expected but not detected".to_string(),
|
||||
None => "not present".to_string(),
|
||||
};
|
||||
let mut t = format!("Fan {}: {s}", i + 1);
|
||||
for e in self.fault_texts_for(FaultComponent::Fan(i)) {
|
||||
t.push('\n');
|
||||
t.push_str(&e);
|
||||
}
|
||||
tips.push(t);
|
||||
}
|
||||
// Hashboards. When the PSU has failed the boards can't be tested, so they
|
||||
// read "unpowered" (grey) rather than "faulted" (round 16 #2/#3).
|
||||
// Hashboards -- an operating board shows its number (counting DOWN, n-1..0,
|
||||
// left to right) and actual/expected hashrate; a faulted board shows its
|
||||
// error+code; a board that is genuinely not detected shows "not detected"
|
||||
// (round 17 R2, round 18 #3 actual/expected + #4b). No generic
|
||||
// "Hashboard N: faulted" prose.
|
||||
let boards = self.board_healths();
|
||||
let psu_down = self.power_supply_faulted();
|
||||
let n = self.hashboards.map(|v| v as usize).unwrap_or(boards.len());
|
||||
let unit = self.hashrate_unit();
|
||||
for i in 0..max_boards {
|
||||
let s = match boards.get(i) {
|
||||
Some(CompHealth::Ok) => "hashing".to_string(),
|
||||
Some(CompHealth::Degraded) => "hashing sub-optimally".to_string(),
|
||||
Some(CompHealth::Down) => "faulted".to_string(),
|
||||
Some(CompHealth::Unreachable) if psu_down => "unpowered (PSU fault)".to_string(),
|
||||
Some(CompHealth::Unreachable) => "expected but not detected".to_string(),
|
||||
None => "not present".to_string(),
|
||||
let fault = self.fault_texts_for(FaultComponent::Board(i));
|
||||
let t = if !fault.is_empty() {
|
||||
fault.join("\n")
|
||||
} else if matches!(boards.get(i), Some(CompHealth::Unreachable)) {
|
||||
"not detected".to_string()
|
||||
} else if i < n {
|
||||
let num = n - 1 - i; // count down, left to right
|
||||
let actual = self.board_hashrates.get(i).copied().unwrap_or(0.0);
|
||||
let expected = self.board_expected_hashrates.get(i).copied().unwrap_or(0.0);
|
||||
let a = hashrate_num_for(&self.algorithm, actual);
|
||||
let e = hashrate_num_for(&self.algorithm, expected);
|
||||
let mut s = match (a, e) {
|
||||
(Some(a), Some(e)) => format!("{num} \u{00b7} {a} / {e} {unit}"),
|
||||
(Some(a), None) => format!("{num} \u{00b7} {a} {unit}"),
|
||||
_ => num.to_string(),
|
||||
};
|
||||
// Per-board configured frequency / voltage (round 18 / G7 read side),
|
||||
// appended when the firmware reports them.
|
||||
let freq = self.board_frequencies.get(i).copied().unwrap_or(0.0);
|
||||
let volt = self.board_voltages.get(i).copied().unwrap_or(0.0);
|
||||
if freq > 0.0 {
|
||||
s.push_str(&format!(" \u{00b7} {freq:.0} MHz"));
|
||||
}
|
||||
if volt > 0.0 {
|
||||
s.push_str(&format!(" \u{00b7} {volt:.2} V"));
|
||||
}
|
||||
s
|
||||
} else {
|
||||
String::new() // padding slot for fleet alignment
|
||||
};
|
||||
let mut t = format!("Hashboard {}: {s}", i + 1);
|
||||
for e in self.fault_texts_for(FaultComponent::Board(i)) {
|
||||
t.push('\n');
|
||||
t.push_str(&e);
|
||||
}
|
||||
tips.push(t);
|
||||
}
|
||||
tips
|
||||
}
|
||||
|
||||
/// The PSU output "V / A" tooltip label when the firmware reports it, else
|
||||
/// None. asic-rs does not yet expose PSU output voltage/current (roadmap G15),
|
||||
/// so this is a forward-compatible hook that stays None for now (round 17 R2).
|
||||
fn psu_output_label(&self) -> Option<String> {
|
||||
match (self.psu_out_voltage_v, self.psu_out_current_a) {
|
||||
(Some(v), Some(a)) if v > 0.0 => Some(format!("{v:.1} V \u{00b7} {a:.1} A")),
|
||||
(Some(v), None) if v > 0.0 => Some(format!("{v:.1} V")),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// The display unit for this miner's hashrate, by mining algorithm (round 18
|
||||
/// #7). SHA256/Scrypt miners report TH/s; Equihash miners (Antminer Z15 /
|
||||
/// Zcash) report in Sol/s and must not be labelled TH/s.
|
||||
pub fn hashrate_unit(&self) -> &'static str {
|
||||
if self.algorithm.eq_ignore_ascii_case("equihash") {
|
||||
"Sol/s"
|
||||
} else {
|
||||
"TH/s"
|
||||
}
|
||||
}
|
||||
|
||||
/// Compact plain-text summary of component health (round 13 #3), used as the
|
||||
/// Health column's filter/sort-fallback text and the base of its hover
|
||||
/// tooltip. e.g. "power ok, fans 3/4, boards 3/3".
|
||||
@@ -854,6 +1000,11 @@ pub enum Column {
|
||||
EnvTemp,
|
||||
OutletTemp,
|
||||
PsuFan,
|
||||
/// PSU identity + rated voltage envelope (round 17 R5). Populated where the
|
||||
/// firmware exposes PSU info (ePIC today).
|
||||
PsuVersion,
|
||||
PsuVMin,
|
||||
PsuVMax,
|
||||
FanCount,
|
||||
ExpectedFans,
|
||||
TotalChips,
|
||||
@@ -885,10 +1036,15 @@ pub enum Column {
|
||||
|
||||
/// Every column, in registry order. Ip first, then the default-visible set
|
||||
/// (UI-SPEC order), then all remaining metrics.
|
||||
pub const ALL_COLUMNS: [Column; 43] = [
|
||||
pub const ALL_COLUMNS: [Column; 47] = [
|
||||
Column::Ip,
|
||||
Column::Hashrate,
|
||||
Column::Health,
|
||||
// The detailed per-board dot column (round 11 #10). Not in DEFAULT_VISIBLE
|
||||
// (the Health column shows composite board health by default), but it belongs
|
||||
// in ALL_COLUMNS so it is selectable in the column picker (round 18 #12: it
|
||||
// was accidentally omitted, making the column unreachable).
|
||||
Column::Hashboards,
|
||||
Column::Power,
|
||||
Column::ChipTemp,
|
||||
Column::Cooling,
|
||||
@@ -904,6 +1060,9 @@ pub const ALL_COLUMNS: [Column; 43] = [
|
||||
Column::EnvTemp,
|
||||
Column::OutletTemp,
|
||||
Column::PsuFan,
|
||||
Column::PsuVersion,
|
||||
Column::PsuVMin,
|
||||
Column::PsuVMax,
|
||||
Column::FanCount,
|
||||
Column::ExpectedFans,
|
||||
Column::TotalChips,
|
||||
@@ -974,6 +1133,9 @@ impl Column {
|
||||
Column::EnvTemp => "Env temp",
|
||||
Column::OutletTemp => "Outlet temp",
|
||||
Column::PsuFan => "PSU fan (RPM)",
|
||||
Column::PsuVersion => "PSU version",
|
||||
Column::PsuVMin => "PSU Vmin",
|
||||
Column::PsuVMax => "PSU Vmax",
|
||||
Column::FanCount => "Fans",
|
||||
Column::ExpectedFans => "Fans (exp)",
|
||||
Column::TotalChips => "Chips",
|
||||
@@ -1012,6 +1174,8 @@ impl Column {
|
||||
Column::Power => 90,
|
||||
Column::ChipTemp | Column::FluidTemp | Column::EnvTemp | Column::OutletTemp => 95,
|
||||
Column::Cooling | Column::PsuFan => 100,
|
||||
Column::PsuVersion => 100,
|
||||
Column::PsuVMin | Column::PsuVMax => 90,
|
||||
Column::Firmware => 110,
|
||||
Column::FwVersion => 130,
|
||||
Column::Worker => 130,
|
||||
@@ -1059,6 +1223,8 @@ impl Column {
|
||||
| Column::OutletTemp
|
||||
| Column::Cooling
|
||||
| Column::PsuFan
|
||||
| Column::PsuVMin
|
||||
| Column::PsuVMax
|
||||
| Column::FanCount
|
||||
| Column::ExpectedFans
|
||||
| Column::TotalChips
|
||||
@@ -1090,6 +1256,12 @@ impl Column {
|
||||
if !self.is_numeric() || self.cell(r).is_empty() {
|
||||
return None;
|
||||
}
|
||||
// The Boards column's sort_key is a composite (online*100 + total) tuned
|
||||
// for sorting; a numeric filter must compare the actual detected board
|
||||
// count the cell shows, not that score (round 18 #12).
|
||||
if let Column::Hashboards = self {
|
||||
return r.hashboards.map(|v| v as f64);
|
||||
}
|
||||
match self.sort_key(r) {
|
||||
SortKey::Num(v) if v.is_finite() => Some(v),
|
||||
_ => None,
|
||||
@@ -1120,6 +1292,8 @@ impl Column {
|
||||
r.fan_rpms.iter().cloned().fold(f64::INFINITY, f64::min)
|
||||
}),
|
||||
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)),
|
||||
@@ -1192,7 +1366,12 @@ impl Column {
|
||||
if r.board_temps.is_empty() {
|
||||
if r.chip_temp_c > 0.0 { format!("{:.0}", r.chip_temp_c) } else { String::new() }
|
||||
} else {
|
||||
r.board_temps.iter().map(|&t| format!("{t:.0}")).collect::<Vec<_>>().join(" / ")
|
||||
// 0.0 == a board with no reading; show "-" so positions align.
|
||||
r.board_temps
|
||||
.iter()
|
||||
.map(|&t| if t > 0.0 { format!("{t:.0}") } else { "-".to_string() })
|
||||
.collect::<Vec<_>>()
|
||||
.join(" / ")
|
||||
}
|
||||
}
|
||||
Column::FluidTemp => num(r.fluid_temp_c, 1, " C"),
|
||||
@@ -1202,6 +1381,9 @@ impl Column {
|
||||
r.fan_rpms.iter().map(|&v| format_fan_rpm(v)).collect::<Vec<_>>().join("/")
|
||||
}
|
||||
Column::PsuFan => num(r.psu_fan_rpm, 0, ""),
|
||||
Column::PsuVersion => r.psu_version.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),
|
||||
@@ -1222,9 +1404,12 @@ impl Column {
|
||||
Column::BoardCode => r.board_code.clone(),
|
||||
Column::Algorithm => r.algorithm.clone(),
|
||||
Column::Pic => match r.pic_present {
|
||||
// A per-board PIC MCU is a known Antminer-hashboard property. Show
|
||||
// it only when known; anything unknown (non-Antminer makes, or an
|
||||
// Antminer model we can't classify) is blank, never "?" (round 18 #11).
|
||||
Some(true) => "PIC".to_string(),
|
||||
Some(false) => "noPIC".to_string(),
|
||||
None => "?".to_string(),
|
||||
None => String::new(),
|
||||
},
|
||||
Column::Locked => match r.write_locked {
|
||||
Some(true) => "locked".to_string(),
|
||||
@@ -1286,7 +1471,8 @@ impl Column {
|
||||
Column::Cooling | Column::PsuFan | Column::FanCount | Column::ExpectedFans => {
|
||||
(5, "Cooling")
|
||||
}
|
||||
Column::TotalChips | Column::Hashboards => (6, "Hardware"),
|
||||
Column::TotalChips | Column::Hashboards | Column::PsuVersion | 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"),
|
||||
@@ -1423,20 +1609,35 @@ impl ViewState {
|
||||
/// into `order`, leaving hidden columns in their existing slots, so a
|
||||
/// reorder while some column is hidden never drops or duplicates a column.
|
||||
pub fn apply_visible_reorder(&mut self, new_visible: &[Column]) {
|
||||
let disp = self.display_columns();
|
||||
if new_visible.len() != disp.len() || new_visible.first() != Some(&Column::Ip) {
|
||||
return;
|
||||
if new_visible.first() != Some(&Column::Ip) {
|
||||
return; // Ip is fixed first
|
||||
}
|
||||
let want: HashSet<Column> = disp.iter().copied().collect();
|
||||
let got: HashSet<Column> = new_visible.iter().copied().collect();
|
||||
if want != got {
|
||||
return; // not a permutation of the visible columns: ignore
|
||||
let shown: HashSet<Column> = new_visible.iter().copied().collect();
|
||||
if shown.len() != new_visible.len() {
|
||||
return; // duplicates: not a permutation
|
||||
}
|
||||
// `new_visible` is the set of columns the table actually SHOWS in their new
|
||||
// order. That is `display_columns()` normally, but a SUBSET of it when
|
||||
// auto-hide-empty is on (the widget omits the empty columns). Every shown
|
||||
// column must be a real, currently-visible column; columns not in `shown`
|
||||
// (hidden, or hidden-because-empty) keep their slot. Reordering just the
|
||||
// shown subset is what lets drag-reorder work while a column is hidden
|
||||
// (round 18 #12: the old code compared against display_columns() and so
|
||||
// silently rejected every reorder whenever auto-hide-empty hid a column).
|
||||
let reorderable: HashSet<Column> = self
|
||||
.order
|
||||
.iter()
|
||||
.copied()
|
||||
.filter(|c| *c == Column::Ip || self.visible.contains(c))
|
||||
.collect();
|
||||
if !shown.is_subset(&reorderable) {
|
||||
return; // a non-visible column in the input: ignore
|
||||
}
|
||||
let mut next = new_visible.iter().copied();
|
||||
self.order = self
|
||||
.order
|
||||
.iter()
|
||||
.map(|&c| if want.contains(&c) { next.next().unwrap_or(c) } else { c })
|
||||
.map(|&c| if shown.contains(&c) { next.next().unwrap_or(c) } else { c })
|
||||
.collect();
|
||||
}
|
||||
|
||||
@@ -1645,6 +1846,7 @@ mod tests {
|
||||
let fault = |c: FaultComponent, m: &str| Fault {
|
||||
component: c,
|
||||
message: m.to_string(),
|
||||
code: 0,
|
||||
is_error: true,
|
||||
};
|
||||
let r = MinerRow {
|
||||
@@ -1669,22 +1871,101 @@ mod tests {
|
||||
assert!(board_tips[0].contains("Slot 0 error reading chip id."));
|
||||
assert!(!board_tips[2].contains("Slot"), "board 3 has no fault text");
|
||||
|
||||
// Round 16 #2: a power-supply fault greys every board (they can't be
|
||||
// powered/tested), turns the bolt red, and the PSU message shows on the
|
||||
// power tooltip.
|
||||
// Round 18 #2/#4b: a PSU fault while the miner is NOT mining is a real
|
||||
// failure (red bolt), and boards keep their own reported state -- a PSU
|
||||
// fault no longer greys them. Faulted boards stay red.
|
||||
let psu = MinerRow {
|
||||
power_w: 40.0,
|
||||
board_status: vec![BoardHealth::Fault, BoardHealth::Fault, BoardHealth::Fault],
|
||||
expected_fans: Some(2),
|
||||
fan_rpms: vec![6000.0, 6000.0],
|
||||
faults: vec![fault(FaultComponent::Power, "Power current error.")],
|
||||
..Default::default()
|
||||
..Default::default() // is_mining = false
|
||||
};
|
||||
assert_eq!(psu.power_health(), CompHealth::Down);
|
||||
assert!(psu.board_healths().iter().all(|h| *h == CompHealth::Unreachable));
|
||||
assert_eq!(psu.power_health(), CompHealth::Down); // fault + not mining -> red
|
||||
assert!(psu.board_healths().iter().all(|h| *h == CompHealth::Down)); // faulted -> red, not grey
|
||||
let ptips = psu.health_tooltips(2, 3);
|
||||
assert!(ptips[0].contains("Power current error."));
|
||||
assert!(ptips[2 + 2].contains("unpowered")); // first board tooltip
|
||||
|
||||
// Round 18 #2: the SAME PSU fault while the miner IS mining is a warning
|
||||
// (yellow bolt), and running boards stay GREEN (not grey). Round 18 #4b:
|
||||
// grey is reserved for genuinely-undetected boards.
|
||||
let psu_running = MinerRow {
|
||||
is_mining: true,
|
||||
power_w: 3000.0,
|
||||
board_status: vec![BoardHealth::Ok, BoardHealth::Ok, BoardHealth::Missing],
|
||||
faults: vec![fault(FaultComponent::Power, "Power vout warning.")],
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(psu_running.power_health(), CompHealth::Degraded); // yellow, not red
|
||||
let rb = psu_running.board_healths();
|
||||
assert_eq!(rb[0], CompHealth::Ok); // running -> green despite PSU fault
|
||||
assert_eq!(rb[1], CompHealth::Ok);
|
||||
assert_eq!(rb[2], CompHealth::Unreachable); // only the undetected board is grey
|
||||
|
||||
// Round 18 #12: a genuinely-undetected board that is ALSO named by a board
|
||||
// fault (e.g. a "chain 2 not found" message attributed to Board(2)) must
|
||||
// stay grey ("not detected"), not turn red -- grey vs red is the
|
||||
// detected/undetected distinction.
|
||||
let missing_named = MinerRow {
|
||||
is_mining: true,
|
||||
board_status: vec![BoardHealth::Ok, BoardHealth::Ok, BoardHealth::Missing],
|
||||
faults: vec![fault(FaultComponent::Board(2), "Chain 2 not found, check connection")],
|
||||
..Default::default()
|
||||
};
|
||||
let mb = missing_named.board_healths();
|
||||
assert_eq!(mb[0], CompHealth::Ok);
|
||||
assert_eq!(mb[1], CompHealth::Ok);
|
||||
assert_eq!(mb[2], CompHealth::Unreachable, "undetected board named by a fault stays grey");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn equihash_hashrate_units_round18() {
|
||||
// SHA256 shows the TH/s value directly; Equihash shows the Sol/s count
|
||||
// (ths * 1e12) with an SI prefix (round 18 #7).
|
||||
assert_eq!(hashrate_num_for("SHA256", 80.5).as_deref(), Some("80.5"));
|
||||
// 167,764 Sol/s -> SI mantissa+prefix ("168k"); paired with the "Sol/s" unit.
|
||||
assert_eq!(hashrate_num_for("Equihash", 167_764.0 / 1e12).as_deref(), Some("168k"));
|
||||
assert_eq!(hashrate_num_for("Equihash", 0.0), None);
|
||||
let sha = MinerRow { algorithm: "SHA256".into(), ..Default::default() };
|
||||
let equi = MinerRow { algorithm: "Equihash".into(), ..Default::default() };
|
||||
assert_eq!(sha.hashrate_unit(), "TH/s");
|
||||
assert_eq!(equi.hashrate_unit(), "Sol/s");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn health_tooltips_are_bare_data_round17_r2() {
|
||||
// R2: operating boards show their number counting DOWN (n-1..0) left to
|
||||
// right plus hashrate; fans show just RPM; a fault shows the message with
|
||||
// its code; no "Hashboard N: faulted" prose.
|
||||
let r = MinerRow {
|
||||
is_mining: true,
|
||||
hashboards: Some(3),
|
||||
board_status: vec![BoardHealth::Ok, BoardHealth::Ok, BoardHealth::Fault],
|
||||
board_hashrates: vec![33.5, 34.6, 0.0],
|
||||
expected_fans: Some(2),
|
||||
fan_rpms: vec![4700.0, 4650.0],
|
||||
power_w: 3000.0,
|
||||
faults: vec![Fault {
|
||||
component: FaultComponent::Board(2),
|
||||
message: "Slot 2 chip failure.".to_string(),
|
||||
code: 540,
|
||||
is_error: true,
|
||||
}],
|
||||
..Default::default()
|
||||
};
|
||||
let tips = r.health_tooltips(2, 3);
|
||||
// power OK (no V/A yet), control OK, 2 fans, 3 boards.
|
||||
assert_eq!(tips[0], "PSU OK");
|
||||
assert_eq!(tips[1], "Control board OK");
|
||||
assert_eq!(tips[2], "4700 rpm");
|
||||
assert_eq!(tips[3], "4650 rpm");
|
||||
// Boards count DOWN left->right: leftmost = 2, then 1, then 0.
|
||||
assert!(tips[4].starts_with("2") && tips[4].contains("33.5 TH/s"), "{}", tips[4]);
|
||||
assert!(tips[5].starts_with("1") && tips[5].contains("34.6 TH/s"), "{}", tips[5]);
|
||||
// The faulted board shows its error WITH the code, no "Hashboard" prose.
|
||||
assert!(tips[6].contains("Slot 2 chip failure.") && tips[6].contains("540"), "{}", tips[6]);
|
||||
assert!(!tips[6].to_lowercase().contains("hashboard"), "{}", tips[6]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -1984,13 +2265,14 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn pic_locked_error_columns_render() {
|
||||
// PIC (best-effort): known -> PIC/noPIC, unknown -> "?".
|
||||
let pic = MinerRow { pic_present: Some(true), ..Default::default() };
|
||||
let nopic = MinerRow { pic_present: Some(false), ..Default::default() };
|
||||
let pic_unknown = MinerRow { pic_present: None, ..Default::default() };
|
||||
assert_eq!(Column::Pic.cell(&pic), "PIC");
|
||||
assert_eq!(Column::Pic.cell(&nopic), "noPIC");
|
||||
assert_eq!(Column::Pic.cell(&pic_unknown), "?");
|
||||
// PIC: known -> PIC/noPIC; anything unknown -> blank, never "?" (round 18 #11).
|
||||
let am = |pic| MinerRow { brand: "Antminer".into(), pic_present: pic, ..Default::default() };
|
||||
assert_eq!(Column::Pic.cell(&am(Some(true))), "PIC");
|
||||
assert_eq!(Column::Pic.cell(&am(Some(false))), "noPIC");
|
||||
assert_eq!(Column::Pic.cell(&am(None)), ""); // unknown Antminer model -> blank
|
||||
// Non-Antminer makes: PIC has no meaning -> blank.
|
||||
let wm = MinerRow { brand: "WhatsMiner".into(), pic_present: None, ..Default::default() };
|
||||
assert_eq!(Column::Pic.cell(&wm), "");
|
||||
|
||||
// Access column.
|
||||
let locked = MinerRow { write_locked: Some(true), ..Default::default() };
|
||||
@@ -2114,6 +2396,31 @@ mod tests {
|
||||
assert_eq!(view.order, before, "a same-length non-permutation must be ignored");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn apply_visible_reorder_accepts_a_shown_subset() {
|
||||
// Auto-hide-empty shows only a subset of the visible columns; dragging
|
||||
// within that subset must be applied, not silently rejected (round 18 #12).
|
||||
let mut view = ViewState::default();
|
||||
let disp = view.display_columns();
|
||||
assert!(disp.len() >= 4, "default view has several visible columns");
|
||||
// Pretend disp[2] is empty and therefore hidden by the widget.
|
||||
let dropped = disp[2];
|
||||
let mut shown: Vec<Column> = disp.iter().copied().filter(|&c| c != dropped).collect();
|
||||
shown.swap(1, 2); // reorder two columns of the shown subset
|
||||
let before_set: HashSet<Column> = view.order.iter().copied().collect();
|
||||
view.apply_visible_reorder(&shown);
|
||||
assert_ne!(
|
||||
view.display_columns().iter().copied().collect::<Vec<_>>(),
|
||||
disp,
|
||||
"a valid subset reorder must change the display order"
|
||||
);
|
||||
// No column lost or duplicated; Ip still first; the hidden column kept its slot.
|
||||
assert_eq!(view.order.iter().copied().collect::<HashSet<_>>(), before_set);
|
||||
assert_eq!(view.order.len(), before_set.len());
|
||||
assert_eq!(view.display_columns().first(), Some(&Column::Ip));
|
||||
assert_eq!(view.order.iter().filter(|&&c| c == dropped).count(), 1);
|
||||
}
|
||||
|
||||
/// Microbenchmark: the DEFAULT view (Ip ascending) at 5000 rows. The existing
|
||||
/// bench_view_pipeline overrides sort to Hashrate, so it never exercised the
|
||||
/// default path (previously a lexical string sort).
|
||||
@@ -2253,6 +2560,8 @@ mod tests {
|
||||
resume: true,
|
||||
power_limit: true,
|
||||
tuning: true,
|
||||
hashrate_target: true,
|
||||
supports_presets: true,
|
||||
firmware_flash: true,
|
||||
pools: true,
|
||||
timezone: true,
|
||||
@@ -2372,6 +2681,21 @@ mod tests {
|
||||
assert_eq!(Column::TotalChips.num_value(&both), Some(190.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hashboards_num_value_is_board_count_with_per_board_health() {
|
||||
// With per-board health present (the normal live-scan case), the Boards
|
||||
// filter must still compare the detected board count, not the composite
|
||||
// sort score online*100+total (round 18 #12). The `both` fixture above
|
||||
// leaves board_status empty, so it never exercised this path.
|
||||
let r = MinerRow {
|
||||
hashboards: Some(3),
|
||||
expected_hashboards: Some(3),
|
||||
board_status: vec![BoardHealth::Ok, BoardHealth::Ok, BoardHealth::Ok],
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(Column::Hashboards.num_value(&r), Some(3.0), "filter sees the board count, not 303");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cooling_column_joins_fan_rpms_and_sorts_by_min() {
|
||||
let r = MinerRow { fan_rpms: vec![4200.0, 3990.0, 4500.0], ..Default::default() };
|
||||
|
||||
@@ -135,10 +135,13 @@ fn clean_antminer(id: &str) -> String {
|
||||
// asic-rs "Unknown" models pass the raw vendor string through with the brand
|
||||
// still in it (e.g. "ANTMINER S19 (88)", a NoPIC S19); drop a redundant
|
||||
// leading brand word so the Model column never repeats the Brand column.
|
||||
let id = if id.len() >= 9 && id[..9].eq_ignore_ascii_case("ANTMINER ") {
|
||||
id[9..].trim_start()
|
||||
} else {
|
||||
id
|
||||
// `get(..9)` returns None (rather than panicking) when byte 9 is not a UTF-8
|
||||
// char boundary, so a multibyte miner-supplied model string can't crash here
|
||||
// (round 18 #12). The prefix is 9 ASCII bytes, so a real match implies a
|
||||
// boundary at 9 and the following `id[9..]` is safe.
|
||||
let id = match id.get(..9) {
|
||||
Some(p) if p.eq_ignore_ascii_case("ANTMINER ") => id[9..].trim_start(),
|
||||
_ => id,
|
||||
};
|
||||
let bytes = id.as_bytes();
|
||||
// Base = leading letters then digits ("S19", "KS5", "L3", "Z15"). Without a
|
||||
@@ -200,6 +203,7 @@ fn compact_upper(s: &str) -> String {
|
||||
/// model era/class (best-effort, since the network data can't distinguish them):
|
||||
/// - Xilinx: S17/T17-era -> C49, otherwise (S19-era) -> C55.
|
||||
/// - AMLogic: XP-class / S19k (140mm fans) -> CBE, otherwise (120mm) -> C76.
|
||||
///
|
||||
/// `clean_model` is the already-cleaned model name (used for the era/class test).
|
||||
pub fn control_board_code(make: &str, board_name: &str, clean_model: &str) -> String {
|
||||
let (cpu, code) = control_board_split(make, board_name, clean_model);
|
||||
@@ -283,8 +287,26 @@ fn is_s17_era(clean_model: &str) -> bool {
|
||||
/// S19k Pro, and the S21 Pro; everything else AMLogic is the 120mm C76. asic-rs
|
||||
/// cannot tell these apart, so this is a model-family heuristic, not a read.
|
||||
fn is_aml_140mm(clean_model: &str) -> bool {
|
||||
// Per the doc above: XP-class, the S19k Pro, and the S21 Pro -- NOT every S21
|
||||
// (plain S21 / S21+ / S21e are the 120mm C76 board) (round 18 #12).
|
||||
let m = clean_model.trim_start();
|
||||
m.contains("XP") || m.starts_with("S19k") || m.starts_with("S21")
|
||||
m.contains("XP") || m.starts_with("S19k") || m.contains("S21 Pro")
|
||||
}
|
||||
|
||||
/// Nameplate expected hashrate in Sol/s for an Equihash (Zcash) miner model, when
|
||||
/// the firmware itself does not report an expected hashrate (round 18 #6). Plain
|
||||
/// Antminer Z15 firmware omits the cgminer `total_rateideal` field (the Z15j does
|
||||
/// report it), so its actual-vs-expected column and colour would otherwise be
|
||||
/// blank. The Z15 nameplate is 420 KSol/s. Returns `None` for models with no known
|
||||
/// nameplate (the caller then leaves expected unknown).
|
||||
pub fn equihash_expected_sols(clean_model: &str) -> Option<f64> {
|
||||
let m = clean_model.to_ascii_lowercase();
|
||||
// Match the Z15 family (z15, z15j); both share the 420 KSol/s nameplate.
|
||||
if m.contains("z15") {
|
||||
Some(420_000.0)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
//! Dropdown presets + user-saved values for the Configure-pools dialog (round 15
|
||||
//! #1). Each pool field (address / account / worker / password) has a "+" menu
|
||||
//! offering built-in presets (pool stratums, worker placeholders) plus values the
|
||||
//! user has saved, and the user can add the current box value to the saved list.
|
||||
//! Saved lists persist one-per-line under the config dir.
|
||||
//! user has saved. "Add new..." opens a manager window that edits the whole saved
|
||||
//! list at once (round 18 #8b). Saved lists persist one-per-line under the config dir.
|
||||
|
||||
use std::path::PathBuf;
|
||||
|
||||
@@ -72,42 +72,58 @@ pub fn load_saved(field: PoolField) -> Vec<String> {
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
/// Add `value` to `field`'s saved list (deduplicated, no-op if empty/already
|
||||
/// present or already a preset). Returns true if it was newly added.
|
||||
pub fn add_saved(field: PoolField, value: &str) -> bool {
|
||||
let value = value.trim();
|
||||
if value.is_empty() {
|
||||
return false;
|
||||
}
|
||||
if field.presets().iter().any(|p| *p == value) {
|
||||
return false;
|
||||
}
|
||||
let mut saved = load_saved(field);
|
||||
if saved.iter().any(|s| s == value) {
|
||||
return false;
|
||||
}
|
||||
saved.push(value.to_string());
|
||||
/// Replace `field`'s entire saved list with `values` (round 18 #8b: the preset
|
||||
/// manager edits the whole list at once). Each value is trimmed; empties, exact
|
||||
/// duplicates, and any value that is already a built-in preset are dropped.
|
||||
/// Returns the number of values actually written.
|
||||
pub fn save_all(field: PoolField, values: &[String]) -> std::io::Result<usize> {
|
||||
let out = dedupe_saved(&field.presets(), values);
|
||||
let p = config_path(field.saved_file());
|
||||
if let Some(dir) = p.parent() {
|
||||
let _ = std::fs::create_dir_all(dir);
|
||||
}
|
||||
let _ = std::fs::write(p, saved.join("\n"));
|
||||
true
|
||||
// The password list can hold a pool password, so write it owner-only from the
|
||||
// moment it is created -- never briefly world-readable (round 18 #12).
|
||||
write_private(&p, out.join("\n").as_bytes())?;
|
||||
Ok(out.len())
|
||||
}
|
||||
|
||||
/// Remove `value` from `field`'s saved list (round 16 #5). Returns true if it was
|
||||
/// present and removed. Presets cannot be removed (they are not in the saved file).
|
||||
pub fn remove_saved(field: PoolField, value: &str) -> bool {
|
||||
let value = value.trim();
|
||||
let mut saved = load_saved(field);
|
||||
let before = saved.len();
|
||||
saved.retain(|s| s != value);
|
||||
if saved.len() == before {
|
||||
return false;
|
||||
/// Write `data` to `path` with owner-only (0600) permissions from creation on
|
||||
/// Unix, so a secret is never momentarily world-readable between write and chmod.
|
||||
/// `mode()` only takes effect when the file is created, so an already-existing
|
||||
/// file is also re-tightened; elsewhere this is a plain write.
|
||||
fn write_private(path: &std::path::Path, data: &[u8]) -> std::io::Result<()> {
|
||||
#[cfg(unix)]
|
||||
{
|
||||
use std::io::Write;
|
||||
use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
|
||||
let mut f = std::fs::OpenOptions::new()
|
||||
.write(true)
|
||||
.create(true)
|
||||
.truncate(true)
|
||||
.mode(0o600)
|
||||
.open(path)?;
|
||||
let _ = std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o600));
|
||||
f.write_all(data)
|
||||
}
|
||||
let p = config_path(field.saved_file());
|
||||
let _ = std::fs::write(p, saved.join("\n"));
|
||||
true
|
||||
#[cfg(not(unix))]
|
||||
{
|
||||
std::fs::write(path, data)
|
||||
}
|
||||
}
|
||||
|
||||
/// Trim every value, then drop empties, values equal to a built-in preset, and
|
||||
/// later exact duplicates (first occurrence wins). Order is otherwise preserved.
|
||||
fn dedupe_saved(presets: &[&str], values: &[String]) -> Vec<String> {
|
||||
let mut out: Vec<String> = Vec::new();
|
||||
for v in values {
|
||||
let v = v.trim();
|
||||
if v.is_empty() || presets.contains(&v) || out.iter().any(|s| s == v) {
|
||||
continue;
|
||||
}
|
||||
out.push(v.to_string());
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The full dropdown list for a field: presets first, then the user's saved
|
||||
@@ -129,3 +145,25 @@ pub fn dropdown_entries(field: PoolField) -> Vec<(String, String)> {
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn dedupe_saved_trims_drops_empties_presets_and_dupes() {
|
||||
let presets = ["x", "{ip1}"];
|
||||
let vals: Vec<String> = [" ", "myworker", "myworker", "x", " keep ", "{ip1}", "keep"]
|
||||
.iter()
|
||||
.map(|s| s.to_string())
|
||||
.collect();
|
||||
// " " (empty), the second "myworker", "x"/"{ip1}" (presets) and the second
|
||||
// "keep" all drop; " keep " is trimmed and kept.
|
||||
assert_eq!(dedupe_saved(&presets, &vals), vec!["myworker".to_string(), "keep".to_string()]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dedupe_saved_empty_input_is_empty() {
|
||||
assert!(dedupe_saved(&[], &[]).is_empty());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
//! (the stock image is retained on-device at install time; no image is uploaded):
|
||||
//! - VNish: POST /api/v1/unlock -> bearer -> POST /api/v1/firmware/remove
|
||||
//! - LuxOS: luxminer :4028 {"command":"logon"} -> SessionID ->
|
||||
//! {"command":"uninstallluxos","parameter":"<SessionID>"}
|
||||
//! {"command":"uninstallluxos","parameter":"<SessionID>"}
|
||||
//! - Braiins: SSH `uninstall.sh` (re-flashes the on-NAND stock backup)
|
||||
//!
|
||||
//! DESTRUCTIVE: this removes the running aftermarket firmware and reboots the
|
||||
@@ -24,17 +24,21 @@ use std::time::Duration;
|
||||
use crate::scan::fake_scan_enabled;
|
||||
|
||||
pub enum RestoreMsg {
|
||||
Started { total: usize },
|
||||
Started,
|
||||
Result { ip: String, ok: bool, detail: String },
|
||||
Done { total: usize },
|
||||
Done,
|
||||
}
|
||||
|
||||
pub struct RestoreHandle {
|
||||
pub rx: Receiver<RestoreMsg>,
|
||||
// The worker honours cancellation between miners (see `tc` below); a UI stop
|
||||
// control is not wired yet, so the handle-side trigger is kept for when it is.
|
||||
#[allow(dead_code)]
|
||||
cancel: Arc<AtomicBool>,
|
||||
}
|
||||
|
||||
impl RestoreHandle {
|
||||
#[allow(dead_code)]
|
||||
pub fn stop(&self) {
|
||||
self.cancel.store(true, Ordering::Relaxed);
|
||||
}
|
||||
@@ -57,11 +61,10 @@ pub fn start_restore(
|
||||
) -> RestoreHandle {
|
||||
let (tx, rx) = channel();
|
||||
let cancel = Arc::new(AtomicBool::new(false));
|
||||
let total = targets.len();
|
||||
|
||||
if fake_scan_enabled() {
|
||||
// Offline demo: report each target as restored without touching anything.
|
||||
let _ = tx.send(RestoreMsg::Started { total });
|
||||
let _ = tx.send(RestoreMsg::Started);
|
||||
for t in targets {
|
||||
let _ = tx.send(RestoreMsg::Result {
|
||||
ip: t.ip,
|
||||
@@ -69,15 +72,16 @@ pub fn start_restore(
|
||||
detail: "restored to stock (demo)".into(),
|
||||
});
|
||||
}
|
||||
let _ = tx.send(RestoreMsg::Done { total });
|
||||
let _ = tx.send(RestoreMsg::Done);
|
||||
return RestoreHandle { rx, cancel };
|
||||
}
|
||||
|
||||
let tc = cancel.clone();
|
||||
let _ = std::thread::Builder::new()
|
||||
let err_tx = tx.clone();
|
||||
let spawned = std::thread::Builder::new()
|
||||
.name("restore-stock".into())
|
||||
.spawn(move || {
|
||||
let _ = tx.send(RestoreMsg::Started { total });
|
||||
let _ = tx.send(RestoreMsg::Started);
|
||||
for t in targets {
|
||||
if tc.load(Ordering::Relaxed) {
|
||||
break;
|
||||
@@ -87,8 +91,18 @@ pub fn start_restore(
|
||||
return;
|
||||
}
|
||||
}
|
||||
let _ = tx.send(RestoreMsg::Done { total });
|
||||
let _ = tx.send(RestoreMsg::Done);
|
||||
});
|
||||
if spawned.is_err() {
|
||||
// Never leave the restore subsystem wedged (round 18 #12): if the worker
|
||||
// thread can't start, emit a failure + Done so the drain clears the handle.
|
||||
let _ = err_tx.send(RestoreMsg::Result {
|
||||
ip: String::new(),
|
||||
ok: false,
|
||||
detail: "could not start the restore worker thread".into(),
|
||||
});
|
||||
let _ = err_tx.send(RestoreMsg::Done);
|
||||
}
|
||||
RestoreHandle { rx, cancel }
|
||||
}
|
||||
|
||||
@@ -107,12 +121,19 @@ fn restore_one(t: &RestoreTarget, vnish_pass: &str, ssh_user: &str, ssh_pass: &s
|
||||
|
||||
/// VNish: unlock -> bearer -> firmware/remove (self-restores + reboots ~3 s).
|
||||
fn restore_vnish(ip: &str, pass: &str) -> (bool, String) {
|
||||
let unlock = match curl(&[
|
||||
"-s", "--connect-timeout", "5", "--max-time", "9",
|
||||
"-X", "POST", "-H", "Content-Type: application/json",
|
||||
"-d", &format!("{{\"pw\":\"{pass}\"}}"),
|
||||
&format!("http://{ip}/api/v1/unlock"),
|
||||
]) {
|
||||
// serde-encode the body so a password with a quote/backslash can't break the
|
||||
// JSON, and send it via stdin (-d @-) so the password never appears on curl's
|
||||
// argv / the process list (round 18 #12).
|
||||
let body = serde_json::json!({ "pw": pass }).to_string();
|
||||
let unlock = match curl(
|
||||
&[
|
||||
"-s", "--connect-timeout", "5", "--max-time", "9",
|
||||
"-X", "POST", "-H", "Content-Type: application/json",
|
||||
"-d", "@-",
|
||||
&format!("http://{ip}/api/v1/unlock"),
|
||||
],
|
||||
Some(body.as_bytes()),
|
||||
) {
|
||||
Ok(s) => s,
|
||||
Err(e) => return (false, format!("unlock request failed: {e}")),
|
||||
};
|
||||
@@ -123,11 +144,14 @@ fn restore_vnish(ip: &str, pass: &str) -> (bool, String) {
|
||||
let Some(token) = token else {
|
||||
return (false, "VNish unlock rejected (wrong web password?)".into());
|
||||
};
|
||||
match curl(&[
|
||||
"-s", "--connect-timeout", "5", "--max-time", "12",
|
||||
"-X", "POST", "-H", &format!("Authorization: Bearer {token}"),
|
||||
&format!("http://{ip}/api/v1/firmware/remove"),
|
||||
]) {
|
||||
match curl(
|
||||
&[
|
||||
"-s", "--connect-timeout", "5", "--max-time", "12",
|
||||
"-X", "POST", "-H", &format!("Authorization: Bearer {token}"),
|
||||
&format!("http://{ip}/api/v1/firmware/remove"),
|
||||
],
|
||||
None,
|
||||
) {
|
||||
// The miner reverts + reboots after ~3 s; the response is {"after":N}.
|
||||
Ok(resp) if resp.contains("after") => (true, "reverting to stock (~3 s)".into()),
|
||||
Ok(resp) => (false, format!("firmware/remove returned: {}", resp.trim())),
|
||||
@@ -152,13 +176,29 @@ fn restore_luxos(ip: &str) -> (bool, String) {
|
||||
let Some(session) = session.filter(|s| !s.is_empty()) else {
|
||||
return (false, format!("no SessionID in logon response: {}", logon.trim()));
|
||||
};
|
||||
let cmd = format!("{{\"command\":\"uninstallluxos\",\"parameter\":\"{session}\"}}");
|
||||
// serde-encode so the miner-supplied SessionID can't break or inject into the
|
||||
// JSON-RPC command (round 18 #12).
|
||||
let cmd = serde_json::json!({ "command": "uninstallluxos", "parameter": session }).to_string();
|
||||
match lux_rpc(ip, &cmd) {
|
||||
// Code 350 "Uninstalling LuxOS"; the miner reboots + reverts in background.
|
||||
Ok(resp) if resp.contains("350") || resp.to_lowercase().contains("uninstall") => {
|
||||
(true, "uninstalling LuxOS (reboots to stock)".into())
|
||||
}
|
||||
// The miner reboots as it reverts, so the reply is often dropped/empty
|
||||
// after the command is accepted. The logon above already proved the miner
|
||||
// was reachable, so an empty reply or a dropped connection here is the
|
||||
// expected reboot, not a failure (round 18 #12).
|
||||
Ok(resp) if resp.trim().is_empty() => {
|
||||
(true, "uninstall accepted (miner rebooting to stock)".into())
|
||||
}
|
||||
Ok(resp) => (false, format!("uninstallluxos returned: {}", resp.trim())),
|
||||
Err(e)
|
||||
if ["closed", "reset", "timed out", "broken pipe", "eof"]
|
||||
.iter()
|
||||
.any(|m| e.to_lowercase().contains(m)) =>
|
||||
{
|
||||
(true, "RPC dropped (miner rebooting to stock)".into())
|
||||
}
|
||||
Err(e) => (false, format!("uninstallluxos failed: {e}")),
|
||||
}
|
||||
}
|
||||
@@ -169,28 +209,30 @@ fn restore_braiins(ip: &str, user: &str, pass: &str) -> (bool, String) {
|
||||
return (false, "Braiins restore needs an SSH password (set the SSH login)".into());
|
||||
}
|
||||
let target = format!("{user}@{ip}");
|
||||
// uninstall.sh is on Braiins OS+'s PATH; run it non-interactively.
|
||||
// sshpass reads the password from $SSHPASS (-e) rather than argv (-p), so it
|
||||
// never shows up in the process list (round 18 #12). Host-key checking is
|
||||
// deliberately disabled: these are LAN miners whose SSH host key changes on
|
||||
// every reflash, so pinning it would break the very revert this performs.
|
||||
// BatchMode stops any interactive prompt from hanging out the 60 s cap.
|
||||
let mut cmd = Command::new("sshpass");
|
||||
cmd.arg("-p").arg(pass).arg("ssh");
|
||||
cmd.env("SSHPASS", pass);
|
||||
cmd.arg("-e").arg("ssh");
|
||||
cmd.args([
|
||||
"-o", "StrictHostKeyChecking=no",
|
||||
"-o", "UserKnownHostsFile=/dev/null",
|
||||
"-o", "BatchMode=yes",
|
||||
"-o", "ConnectTimeout=8",
|
||||
&target,
|
||||
"uninstall.sh || /sbin/uninstall.sh",
|
||||
]);
|
||||
match run_with_timeout(cmd, Duration::from_secs(60)) {
|
||||
Ok(out) => {
|
||||
let s = String::from_utf8_lossy(&out).to_lowercase();
|
||||
if s.contains("not found") || s.contains("no such") {
|
||||
(false, "uninstall.sh not found on the miner".into())
|
||||
} else {
|
||||
(true, "ran uninstall.sh (reverts to stock + reboots)".into())
|
||||
}
|
||||
}
|
||||
match run_with_timeout(cmd, Duration::from_secs(60), None) {
|
||||
Ok(out) => classify_braiins(
|
||||
&String::from_utf8_lossy(&out.stdout),
|
||||
&String::from_utf8_lossy(&out.stderr),
|
||||
out.code,
|
||||
out.timed_out,
|
||||
),
|
||||
Err(e) => {
|
||||
// A reboot mid-command commonly drops the SSH connection; treat a
|
||||
// connection-closed error after the command as likely success.
|
||||
if e.contains("closed") || e.contains("reset") || e.contains("timed out") {
|
||||
(true, "SSH dropped (miner likely rebooting to stock)".into())
|
||||
} else {
|
||||
@@ -200,6 +242,42 @@ fn restore_braiins(ip: &str, user: &str, pass: &str) -> (bool, String) {
|
||||
}
|
||||
}
|
||||
|
||||
/// Decide a Braiins `uninstall.sh` outcome from its captured output. The critical
|
||||
/// rule (round 18 #12): an SSH auth/connection failure -- which writes its
|
||||
/// diagnostic to stderr, leaves stdout empty, and exits non-zero -- must be
|
||||
/// reported as a FAILURE, never a false success. A dropped connection or a
|
||||
/// timeout after the command started is the expected signature of the reboot.
|
||||
fn classify_braiins(stdout: &str, stderr: &str, code: Option<i32>, timed_out: bool) -> (bool, String) {
|
||||
let err = stderr.to_lowercase();
|
||||
// ssh's own connection/auth failures (exit 255) never reach the remote command.
|
||||
let conn_fail = [
|
||||
"permission denied",
|
||||
"connection refused",
|
||||
"could not resolve",
|
||||
"no route to host",
|
||||
"connection timed out",
|
||||
"operation timed out",
|
||||
"host key verification failed",
|
||||
"before authentication",
|
||||
]
|
||||
.iter()
|
||||
.any(|m| err.contains(m));
|
||||
if conn_fail {
|
||||
let why = stderr.lines().map(str::trim).rfind(|l| !l.is_empty());
|
||||
return (false, format!("SSH failed: {}", why.unwrap_or("connection/auth error")));
|
||||
}
|
||||
let out = stdout.to_lowercase();
|
||||
if out.contains("not found") || out.contains("no such") || err.contains("not found") {
|
||||
return (false, "uninstall.sh not found on the miner".into());
|
||||
}
|
||||
match code {
|
||||
Some(0) => (true, "ran uninstall.sh (reverts to stock + reboots)".into()),
|
||||
None => (true, "SSH dropped (miner likely rebooting to stock)".into()),
|
||||
_ if timed_out => (true, "SSH timed out (miner likely rebooting to stock)".into()),
|
||||
Some(c) => (false, format!("uninstall.sh exited {c}: {}", stderr.trim())),
|
||||
}
|
||||
}
|
||||
|
||||
/// One luxminer :4028 request/response (line-framed, socket closes after reply).
|
||||
fn lux_rpc(ip: &str, payload: &str) -> Result<String, String> {
|
||||
let addr: SocketAddr = format!("{ip}:4028").parse().map_err(|e| format!("bad addr: {e}"))?;
|
||||
@@ -225,50 +303,115 @@ fn lux_rpc(ip: &str, payload: &str) -> Result<String, String> {
|
||||
Ok(String::from_utf8_lossy(&buf).trim_matches('\u{0}').to_string())
|
||||
}
|
||||
|
||||
/// curl with a wall-clock cap (small responses; no pipe-drain thread needed).
|
||||
fn curl(args: &[&str]) -> Result<String, String> {
|
||||
let mut cmd = Command::new("curl");
|
||||
cmd.args(args);
|
||||
run_with_timeout(cmd, Duration::from_secs(15)).map(|o| String::from_utf8_lossy(&o).into_owned())
|
||||
/// The captured result of a timed subprocess run.
|
||||
struct CmdOutput {
|
||||
/// The process exit code, or `None` if it was killed / dropped / timed out.
|
||||
code: Option<i32>,
|
||||
stdout: Vec<u8>,
|
||||
stderr: Vec<u8>,
|
||||
timed_out: bool,
|
||||
}
|
||||
|
||||
/// Run a command, capture stdout, with a hard wall-clock timeout.
|
||||
fn run_with_timeout(mut cmd: Command, timeout: Duration) -> Result<Vec<u8>, String> {
|
||||
/// curl with a wall-clock cap. Errors only when the run produced no output and
|
||||
/// timed out (a black-holed host); otherwise returns stdout even on a non-zero
|
||||
/// exit (curl prints useful bodies/status on failures).
|
||||
fn curl(args: &[&str], stdin_data: Option<&[u8]>) -> Result<String, String> {
|
||||
let mut cmd = Command::new("curl");
|
||||
cmd.args(args);
|
||||
let out = run_with_timeout(cmd, Duration::from_secs(15), stdin_data)?;
|
||||
if out.timed_out && out.stdout.is_empty() {
|
||||
return Err("timed out".into());
|
||||
}
|
||||
Ok(String::from_utf8_lossy(&out.stdout).into_owned())
|
||||
}
|
||||
|
||||
/// Run a command with a hard wall-clock timeout, capturing stdout, stderr, and
|
||||
/// the exit code. Both pipes are drained on their own threads so a child that
|
||||
/// writes a lot to stderr can never deadlock against a full pipe (round 18 #12).
|
||||
/// `stdin_data`, when set, is written to the child's stdin and the pipe closed
|
||||
/// (used to feed a request body without putting a secret on argv).
|
||||
fn run_with_timeout(
|
||||
mut cmd: Command,
|
||||
timeout: Duration,
|
||||
stdin_data: Option<&[u8]>,
|
||||
) -> Result<CmdOutput, String> {
|
||||
cmd.stdout(std::process::Stdio::piped());
|
||||
cmd.stderr(std::process::Stdio::piped());
|
||||
if stdin_data.is_some() {
|
||||
cmd.stdin(std::process::Stdio::piped());
|
||||
}
|
||||
let mut child = cmd.spawn().map_err(|e| format!("spawn: {e}"))?;
|
||||
if let Some(data) = stdin_data {
|
||||
if let Some(mut si) = child.stdin.take() {
|
||||
let _ = si.write_all(data);
|
||||
} // dropping `si` closes the pipe
|
||||
}
|
||||
let mut stdout = child.stdout.take().ok_or("no stdout")?;
|
||||
let reader = std::thread::spawn(move || {
|
||||
let mut stderr = child.stderr.take().ok_or("no stderr")?;
|
||||
let out_reader = std::thread::spawn(move || {
|
||||
let mut b = Vec::new();
|
||||
let _ = stdout.read_to_end(&mut b);
|
||||
b
|
||||
});
|
||||
let err_reader = std::thread::spawn(move || {
|
||||
let mut b = Vec::new();
|
||||
let _ = stderr.read_to_end(&mut b);
|
||||
b
|
||||
});
|
||||
let start = std::time::Instant::now();
|
||||
let mut timed_out = false;
|
||||
loop {
|
||||
let status = loop {
|
||||
match child.try_wait().map_err(|e| e.to_string())? {
|
||||
Some(_) => break,
|
||||
Some(s) => break Some(s),
|
||||
None => {
|
||||
if start.elapsed() >= timeout {
|
||||
let _ = child.kill();
|
||||
let _ = child.wait(); // reap so we never leave a zombie
|
||||
timed_out = true;
|
||||
break;
|
||||
break None;
|
||||
}
|
||||
std::thread::sleep(Duration::from_millis(50));
|
||||
}
|
||||
}
|
||||
}
|
||||
let out = reader.join().unwrap_or_default();
|
||||
if timed_out && out.is_empty() {
|
||||
return Err("timed out".into());
|
||||
}
|
||||
Ok(out)
|
||||
};
|
||||
Ok(CmdOutput {
|
||||
code: status.and_then(|s| s.code()),
|
||||
stdout: out_reader.join().unwrap_or_default(),
|
||||
stderr: err_reader.join().unwrap_or_default(),
|
||||
timed_out,
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn braiins_auth_or_connection_failure_is_not_a_false_success() {
|
||||
// The critical regression guard (round 18 #12): a wrong password or an
|
||||
// unreachable miner writes to stderr, leaves stdout empty, and exits
|
||||
// non-zero -- it must report failure, never "restored".
|
||||
let (ok, msg) = classify_braiins("", "Permission denied, please try again.", Some(255), false);
|
||||
assert!(!ok, "wrong password must not report success");
|
||||
assert!(msg.to_lowercase().contains("ssh failed"), "{msg}");
|
||||
|
||||
let (ok, _) = classify_braiins("", "ssh: connect to host 10.0.0.9 port 22: Connection refused", Some(255), false);
|
||||
assert!(!ok, "unreachable miner must not report success");
|
||||
|
||||
let (ok, _) = classify_braiins("", "ssh: Could not resolve hostname miner: Name or service not known", Some(255), false);
|
||||
assert!(!ok, "unresolvable host must not report success");
|
||||
|
||||
// Genuine outcomes.
|
||||
let (ok, _) = classify_braiins("uninstalling...\n", "", Some(0), false);
|
||||
assert!(ok, "clean exit 0 is success");
|
||||
let (ok, _) = classify_braiins("", "Connection to 10.0.0.5 closed by remote host.", None, false);
|
||||
assert!(ok, "connection dropped mid-command (reboot) is success");
|
||||
let (ok, _) = classify_braiins("", "", None, true);
|
||||
assert!(ok, "timeout after the command started (reboot) is success");
|
||||
let (ok, _) = classify_braiins("bash: uninstall.sh: command not found\n", "", Some(127), false);
|
||||
assert!(!ok, "missing uninstall.sh is a failure");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn firmware_selects_the_right_flow() {
|
||||
// The dispatcher only recognises the three revertible aftermarket
|
||||
|
||||
@@ -13,6 +13,11 @@ use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::mpsc::{channel, Receiver};
|
||||
use std::sync::Arc;
|
||||
|
||||
// `Row` is the common variant (one per miner) while `Started`/`Done` are sent
|
||||
// once each, so boxing the large row to shrink the rare variants would add an
|
||||
// allocation on the hot path for no real gain -- the message is moved straight
|
||||
// through an mpsc channel and dropped.
|
||||
#[allow(clippy::large_enum_variant)]
|
||||
pub enum ScanMsg {
|
||||
/// A new scan started: `total` addresses to probe, and the exact set of
|
||||
/// target IPs (as strings) so the UI can drop miners no longer in range.
|
||||
@@ -34,6 +39,11 @@ 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
|
||||
/// 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.
|
||||
pub const SCAN_CONCURRENCY_LIMIT: usize = 128;
|
||||
pub const DEFAULT_RANGE: &str = "10.255.1.0/24";
|
||||
/// Default seconds between automatic rescans.
|
||||
pub const DEFAULT_AUTO_SECS: u64 = 300;
|
||||
@@ -151,7 +161,7 @@ pub fn parse_line(line: &str) -> Result<Vec<Ipv4Addr>, String> {
|
||||
if parts.len() == 4 && parts.iter().all(|p| is_octet_spec(p)) {
|
||||
let r: Vec<(u8, u8)> =
|
||||
parts.iter().map(|p| parse_octet_spec(p)).collect::<Result<_, String>>()?;
|
||||
let count: u64 = r.iter().map(|(lo, hi)| (*hi as u64 - *lo as u64 + 1)).product();
|
||||
let count: u64 = r.iter().map(|(lo, hi)| *hi as u64 - *lo as u64 + 1).product();
|
||||
if count > MAX_ADDRS {
|
||||
return Err(format!("range too large (> {MAX_ADDRS} addresses): {line}"));
|
||||
}
|
||||
@@ -377,7 +387,18 @@ pub fn start_scan(lines: Vec<String>, timeout_secs: u64) -> ScanHandle {
|
||||
};
|
||||
rt.block_on(async move {
|
||||
let mut factory = crate::credentials::configured_factory()
|
||||
.with_identification_timeout_secs(timeout_secs.max(1));
|
||||
.with_identification_timeout_secs(timeout_secs.max(1))
|
||||
// Cap identification concurrency. asic-rs defaults to 1000 for any
|
||||
// range up to /22, so a /24 fires all 254 probes at once. Over a
|
||||
// real link (VPN, or a subnet full of dead IPs whose TCP connects
|
||||
// sit open for the whole identification timeout) that burst starves
|
||||
// the per-responder get_data -- a Braiins miner fans out ~12
|
||||
// authenticated REST calls and drops most of its values (watts=0,
|
||||
// no best-share/temps), and some responders are missed entirely.
|
||||
// 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);
|
||||
for (ip, prefix) in &cidrs {
|
||||
factory = match factory.with_subnet(&format!("{ip}/{prefix}")) {
|
||||
Ok(f) => f,
|
||||
@@ -387,28 +408,41 @@ pub fn start_scan(lines: Vec<String>, timeout_secs: u64) -> ScanHandle {
|
||||
}
|
||||
};
|
||||
}
|
||||
// scan_stream_with_ip yields one item per probed address, so we
|
||||
// get accurate progress plus the responders.
|
||||
let mut stream = factory.scan_stream_with_ip();
|
||||
// scan_stream_with_ip yields one item per probed address (identification
|
||||
// is already concurrent up to SCAN_CONCURRENCY_LIMIT). Each responder's
|
||||
// telemetry (to_row -> get_data + presets: several REST calls) is then
|
||||
// run concurrently via buffer_unordered instead of awaited one at a time
|
||||
// -- otherwise the telemetry serialises and dominates the scan wall-clock
|
||||
// (round 18 #12). buffer_unordered polls the underlying stream on its own,
|
||||
// so identification concurrency is unaffected, and telemetry only ever
|
||||
// targets responders (live miners), so the same cap is safe.
|
||||
let mut done = 0usize;
|
||||
let step = (total / 100).max(1); // throttle progress messages
|
||||
while let Some((ip, miner)) = stream.next().await {
|
||||
// Emit progress per address for a smoothly-climbing counter; only a
|
||||
// very large scan (> 5000 addresses) is throttled, to bound channel
|
||||
// traffic. The UI coalesces these to one gauge update per refresh.
|
||||
let step = (total / 5000).max(1);
|
||||
let mut results = factory
|
||||
.scan_stream_with_ip()
|
||||
.map(|(ip, miner)| async move {
|
||||
match miner {
|
||||
// Only surface a row for an address that actually has a miner
|
||||
// behind it; a non-responding address is never a phantom row.
|
||||
Some(m) => (ip, Some(to_row(&*m).await)),
|
||||
None => (ip, None),
|
||||
}
|
||||
})
|
||||
.buffer_unordered(SCAN_CONCURRENCY_LIMIT);
|
||||
while let Some((ip, row)) = results.next().await {
|
||||
if thread_cancel.load(Ordering::Relaxed) {
|
||||
return; // Stop / re-scan requested
|
||||
}
|
||||
done += 1;
|
||||
// Only surface a row for an address that actually has a miner
|
||||
// behind it. A non-responding address is not shown -- we never
|
||||
// fabricate a phantom "offline" row for an empty IP; a miner is
|
||||
// reported as "not hashing" only when it responds and we can see
|
||||
// it is not mining.
|
||||
if let Some(m) = miner {
|
||||
let row = to_row(&*m).await;
|
||||
if let Some(row) = row {
|
||||
if tx.send(ScanMsg::Row(row)).is_err() {
|
||||
return; // UI gone
|
||||
}
|
||||
}
|
||||
if done % step == 0 || done == total {
|
||||
if done.is_multiple_of(step) || done == total {
|
||||
let _ = tx.send(ScanMsg::Progress { done, total, ip: ip.to_string() });
|
||||
}
|
||||
}
|
||||
@@ -459,6 +493,37 @@ fn summarize_messages(messages: &[asic_rs::core::data::message::MinerMessage]) -
|
||||
/// component (round 16 #1/#2/#3), so the Health column can colour and describe
|
||||
/// each icon from the actual per-component faults. Info-severity messages are
|
||||
/// dropped; Error and Warning are kept (only Error drives colour).
|
||||
/// Best-effort hashboard index from a fault message that names a board (round 18
|
||||
/// #5). Only WhatsMiner's asic-rs backends attribute a message to a specific
|
||||
/// `HashBoard { idx }`; every Antminer-hardware firmware (stock, VNish, Braiins,
|
||||
/// LuxOS) builds messages with no component, so a real per-board fault would
|
||||
/// otherwise land on the control-board (brain) tooltip instead of the board it
|
||||
/// names. The message text is self-describing (e.g. "Chain 2 ... temperature"),
|
||||
/// so pull the first integer after a board keyword and attribute the fault to that
|
||||
/// board. Returns None when no board keyword is present.
|
||||
fn board_index_from_text(text: &str) -> Option<usize> {
|
||||
let lower = text.to_ascii_lowercase();
|
||||
// Longest/most-specific keywords first so "hashboard" wins over "board".
|
||||
for kw in ["hashboard", "hash board", "chain", "slot", "board"] {
|
||||
let mut from = 0;
|
||||
while let Some(rel) = lower[from..].find(kw) {
|
||||
let after = &lower[from + rel + kw.len()..];
|
||||
// The number must IMMEDIATELY follow the keyword (after only separators
|
||||
// like " #-:._="), so "Chain 2 ..." -> 2 but "hashboard error, temp 65"
|
||||
// does not grab the temperature 65 far past the keyword (round 18 #12).
|
||||
let rest = after.trim_start_matches(|c: char| {
|
||||
c.is_whitespace() || matches!(c, ':' | '#' | '-' | '_' | '.' | '=' | '(')
|
||||
});
|
||||
let digits: String = rest.chars().take_while(|c| c.is_ascii_digit()).collect();
|
||||
if let Ok(n) = digits.parse::<usize>() {
|
||||
return Some(n);
|
||||
}
|
||||
from += rel + kw.len();
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
fn messages_to_faults(
|
||||
messages: &[asic_rs::core::data::message::MinerMessage],
|
||||
) -> Vec<crate::model::Fault> {
|
||||
@@ -481,17 +546,48 @@ fn messages_to_faults(
|
||||
Some(MinerComponent::ControlBoard {}) => FaultComponent::Control,
|
||||
Some(MinerComponent::Fan { idx }) => FaultComponent::Fan(*idx as usize),
|
||||
Some(MinerComponent::HashBoard { idx, .. }) => FaultComponent::Board(*idx as usize),
|
||||
None => FaultComponent::Other,
|
||||
// Unattributed (every Antminer-hardware firmware): recover a board
|
||||
// index from the message text so hashboard faults show on the board
|
||||
// they name, not the control-board tooltip (round 18 #5).
|
||||
None => board_index_from_text(text)
|
||||
.map(FaultComponent::Board)
|
||||
.unwrap_or(FaultComponent::Other),
|
||||
};
|
||||
Some(Fault {
|
||||
component,
|
||||
message: text.to_string(),
|
||||
code: m.code,
|
||||
is_error,
|
||||
})
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod board_index_tests {
|
||||
use super::board_index_from_text;
|
||||
#[test]
|
||||
fn extracts_board_index_from_common_fault_texts() {
|
||||
assert_eq!(board_index_from_text("Chain 2 temperature sensor error"), Some(2));
|
||||
assert_eq!(board_index_from_text("hashboard 0 loss of balance"), Some(0));
|
||||
assert_eq!(board_index_from_text("Slot 1 error reading chip id."), Some(1));
|
||||
assert_eq!(board_index_from_text("Board #3 not responding"), Some(3));
|
||||
// No board keyword -> not attributed to a board.
|
||||
assert_eq!(board_index_from_text("Environment temperature is too high."), None);
|
||||
assert_eq!(board_index_from_text("Power current error."), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn does_not_grab_an_unrelated_number_far_past_the_keyword() {
|
||||
// The number must immediately follow the keyword: a later temperature/count
|
||||
// must not be mistaken for the board index (round 18 #12).
|
||||
assert_eq!(board_index_from_text("hashboard error, chip temp 65C"), None);
|
||||
assert_eq!(board_index_from_text("board voltage low, 12 chips offline"), None);
|
||||
// A real "board <n>" still resolves even with trailing numbers.
|
||||
assert_eq!(board_index_from_text("Chain 2 has 3 dead chips"), Some(2));
|
||||
}
|
||||
}
|
||||
|
||||
/// Infer whether an Antminer's hashboards carry a per-board PIC MCU from the
|
||||
/// model string (round 14 #2). No firmware (stock cgminer, Vnish, LuxOS, Braiins)
|
||||
/// exposes a PIC flag over the network; PIC-vs-noPIC is fixed by the hashboard
|
||||
@@ -500,9 +596,10 @@ fn messages_to_faults(
|
||||
/// generation (S21 family, T21), where Bitmain dropped the per-board PIC.
|
||||
/// - PIC: the rest of the S19 line (BM1362/BM1366, PIC16F1704/1542).
|
||||
/// - unknown: everything else (older Antminers, non-Antminer makes).
|
||||
///
|
||||
/// The one genuinely ambiguous model is the plain "S19j Pro" (both PIC and noPIC
|
||||
/// revisions exist); it is assumed PIC unless the model string says noPIC.
|
||||
fn infer_pic(model: &str) -> Option<bool> {
|
||||
pub(crate) fn infer_pic(model: &str) -> Option<bool> {
|
||||
let m = model.to_lowercase();
|
||||
if m.contains("nopic") {
|
||||
return Some(false);
|
||||
@@ -519,6 +616,32 @@ fn infer_pic(model: &str) -> Option<bool> {
|
||||
None
|
||||
}
|
||||
|
||||
/// Bixbit and Hiveon are aftermarket firmwares that keep the stock Antminer web
|
||||
/// API, so asic-rs identifies them as "AntMiner Stock". Distinguish them from real
|
||||
/// stock via the cgminer `version` reply (port 4028): Bixbit tags it with
|
||||
/// `BixFirmware`/`BixMiner`; Hiveon carries a "hiveon" marker. Returns the display
|
||||
/// family to relabel with, or None (round 17). Best-effort + fast: a short probe
|
||||
/// only run for Antminer miners that first identified as stock.
|
||||
async fn detect_aftermarket_antminer(ip: std::net::IpAddr) -> Option<&'static str> {
|
||||
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
||||
let connect = tokio::net::TcpStream::connect((ip, 4028));
|
||||
let mut stream = tokio::time::timeout(std::time::Duration::from_secs(3), connect)
|
||||
.await
|
||||
.ok()?
|
||||
.ok()?;
|
||||
stream.write_all(b"{\"command\":\"version\"}").await.ok()?;
|
||||
let mut buf = Vec::new();
|
||||
let _ = tokio::time::timeout(std::time::Duration::from_secs(3), stream.read_to_end(&mut buf)).await;
|
||||
let text = String::from_utf8_lossy(&buf);
|
||||
if text.contains("BixFirmware") || text.contains("BixMiner") || text.contains("BixAPIVersion") {
|
||||
Some("Bixbit")
|
||||
} else if text.to_ascii_lowercase().contains("hiveon") {
|
||||
Some("Hiveon")
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
let data = miner.get_data().await;
|
||||
let hashrate_ths = data
|
||||
@@ -526,7 +649,7 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
.as_ref()
|
||||
.map(|h| h.clone().as_unit(asic_rs::core::data::hashrate::HashRateUnit::TeraHash).value)
|
||||
.unwrap_or(0.0);
|
||||
let expected_ths = data
|
||||
let mut expected_ths = data
|
||||
.expected_hashrate
|
||||
.as_ref()
|
||||
.map(|h| h.clone().as_unit(asic_rs::core::data::hashrate::HashRateUnit::TeraHash).value)
|
||||
@@ -543,16 +666,63 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
// alarmingly high and didn't match the temperature the miner itself reports;
|
||||
// the board temperature (~60-79C) is the figure the miner's own UI shows
|
||||
// (round 12 #3). Falls back to the chip temp when no board temp is reported.
|
||||
let board_temps: Vec<f64> = data
|
||||
// Index-aligned with the hashboards (index i == board i): a board with no
|
||||
// reading is 0.0, NOT dropped, so a missing middle board can't shift the
|
||||
// others left in the "77 / - / 74" Chip-temp cell (round 18 #12). Collapsed
|
||||
// to empty when NO board reports a temperature, so the cell falls back to the
|
||||
// fleet average instead of showing "- / - / -".
|
||||
let board_temps: Vec<f64> = {
|
||||
let v: Vec<f64> = data
|
||||
.hashboards
|
||||
.iter()
|
||||
.map(|b| {
|
||||
b.board_temperature
|
||||
.as_ref()
|
||||
.or(b.outlet_chip_temperature.as_ref())
|
||||
.map(|t| t.as_celsius())
|
||||
.filter(|&t| t > 0.0)
|
||||
.unwrap_or(0.0)
|
||||
})
|
||||
.collect();
|
||||
if v.iter().all(|&t| t <= 0.0) { Vec::new() } else { v }
|
||||
};
|
||||
// Per-board hashrate (TH/s), index-aligned with the hashboards, for the
|
||||
// per-board Health tooltip (round 17 R2). Unlike board_temps this is NOT
|
||||
// filtered/compacted -- index i must stay board i so the tooltip numbering
|
||||
// lines up.
|
||||
let board_hashrates: Vec<f64> = data
|
||||
.hashboards
|
||||
.iter()
|
||||
.filter_map(|b| {
|
||||
b.board_temperature
|
||||
.map(|b| {
|
||||
b.hashrate
|
||||
.as_ref()
|
||||
.or(b.outlet_chip_temperature.as_ref())
|
||||
.map(|t| t.as_celsius())
|
||||
.map(|h| h.clone().as_unit(asic_rs::core::data::hashrate::HashRateUnit::TeraHash).value)
|
||||
.unwrap_or(0.0)
|
||||
})
|
||||
.filter(|&t| t > 0.0)
|
||||
.collect();
|
||||
// Per-board expected hashrate (TH/s), index-aligned, for the actual/expected
|
||||
// per-board tooltip (round 18 #3).
|
||||
let board_expected_hashrates: Vec<f64> = data
|
||||
.hashboards
|
||||
.iter()
|
||||
.map(|b| {
|
||||
b.expected_hashrate
|
||||
.as_ref()
|
||||
.map(|h| h.clone().as_unit(asic_rs::core::data::hashrate::HashRateUnit::TeraHash).value)
|
||||
.unwrap_or(0.0)
|
||||
})
|
||||
.collect();
|
||||
// Per-board configured voltage (V) and frequency (MHz), index-aligned, for the
|
||||
// per-board tooltip (round 18 / roadmap G7 read side). 0.0 where unreported.
|
||||
let board_voltages: Vec<f64> = data
|
||||
.hashboards
|
||||
.iter()
|
||||
.map(|b| b.voltage.as_ref().map(|v| v.as_volts()).unwrap_or(0.0))
|
||||
.collect();
|
||||
let board_frequencies: Vec<f64> = data
|
||||
.hashboards
|
||||
.iter()
|
||||
.map(|b| b.frequency.as_ref().map(|f| f.as_megahertz()).unwrap_or(0.0))
|
||||
.collect();
|
||||
let fan_rpms: Vec<f64> = data
|
||||
.fans
|
||||
@@ -591,7 +761,19 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
// Firmware family (coloured column) and version go in separate columns. Strip
|
||||
// the vendor word asic-rs prepends on stock firmware ("AntMiner Stock" ->
|
||||
// "Stock") and carry it into the version instead (round 11 #6).
|
||||
let (firmware, fw_vendor) = crate::naming::firmware_family(&data.device_info.firmware);
|
||||
let (mut firmware, mut fw_vendor) = crate::naming::firmware_family(&data.device_info.firmware);
|
||||
// Bixbit/Hiveon masquerade as stock; relabel them from their cgminer signature
|
||||
// so they get their own family + colour instead of "Stock" (round 17). This
|
||||
// is one extra TCP probe per stock-labelled Antminer per scan (round 18 #12):
|
||||
// deliberately re-run each scan rather than cached, because a miner's firmware
|
||||
// can change under us between scans (a flash/restore), and the detection must
|
||||
// stay current; it only fires for Antminers that still read as plain "Stock".
|
||||
if data.device_info.make.eq_ignore_ascii_case("antminer") && firmware.eq_ignore_ascii_case("stock") {
|
||||
if let Some(fam) = detect_aftermarket_antminer(data.ip).await {
|
||||
firmware = fam.to_string();
|
||||
fw_vendor = None; // the aftermarket version stands alone, no "AntMiner" prefix
|
||||
}
|
||||
}
|
||||
let raw_fw_version = data.firmware_version.clone().unwrap_or_default();
|
||||
let fw_version = match (fw_vendor, raw_fw_version.is_empty()) {
|
||||
(Some(vendor), false) => format!("{vendor} {raw_fw_version}"),
|
||||
@@ -631,6 +813,14 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
.filter_map(|f| f.rpm.as_ref().map(|r| r.as_rpm()))
|
||||
.fold(0.0f64, f64::max);
|
||||
let algorithm = data.hashrate.as_ref().map(|h| h.algo.to_string()).unwrap_or_default();
|
||||
// Equihash (Z15) fallback: plain Z15 firmware omits the expected hashrate, so
|
||||
// fill it from the model nameplate (Sol/s -> the ths-normalised value) so the
|
||||
// actual/expected column + colour work like every other miner (round 18 #6).
|
||||
if expected_ths <= 0.0 && algorithm.eq_ignore_ascii_case("equihash") {
|
||||
if let Some(sols) = crate::naming::equihash_expected_sols(&model) {
|
||||
expected_ths = sols / 1e12;
|
||||
}
|
||||
}
|
||||
let is_mining = data.is_mining;
|
||||
let slow = crate::model::is_slow(is_mining, hashrate_ths, expected_ths);
|
||||
let operating_state = data.operating_state.as_ref().map(|s| s.to_string()).unwrap_or_default();
|
||||
@@ -641,6 +831,47 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
// VNish; Braiins and the rest keep asic-rs's answer.
|
||||
let power_limit = miner.supports_set_power_limit()
|
||||
&& !data.device_info.firmware.eq_ignore_ascii_case("VNish");
|
||||
// Structured tuning (round 17 C). Extract the current target + the advertised
|
||||
// envelope so the "Set performance target" prompt can show/validate bounds.
|
||||
use asic_rs::core::data::miner::TuningTarget;
|
||||
let target_watts = |t: &TuningTarget| match t {
|
||||
TuningTarget::Power(p) => Some(p.as_watts()),
|
||||
_ => None,
|
||||
};
|
||||
let target_ths = |t: &TuningTarget| match t {
|
||||
TuningTarget::HashRate(h) => Some(
|
||||
h.clone()
|
||||
.as_unit(asic_rs::core::data::hashrate::HashRateUnit::TeraHash)
|
||||
.value,
|
||||
),
|
||||
_ => None,
|
||||
};
|
||||
let (power_target_min_w, power_target_max_w, hashrate_target_min_ths, hashrate_target_max_ths) =
|
||||
match &data.tuning_capabilities {
|
||||
Some(c) => (
|
||||
c.power.as_ref().and_then(|p| p.minimum.as_ref()).and_then(&target_watts),
|
||||
c.power.as_ref().and_then(|p| p.maximum.as_ref()).and_then(&target_watts),
|
||||
c.hashrate.as_ref().and_then(|h| h.minimum.as_ref()).and_then(&target_ths),
|
||||
c.hashrate.as_ref().and_then(|h| h.maximum.as_ref()).and_then(&target_ths),
|
||||
),
|
||||
None => (None, None, None, None),
|
||||
};
|
||||
let tuning_target_label = data.tuning_target.as_ref().map(|t| match t {
|
||||
TuningTarget::Power(p) => format!("{:.0} W", p.as_watts()),
|
||||
TuningTarget::HashRate(h) => format!(
|
||||
"{:.0} TH/s",
|
||||
h.clone().as_unit(asic_rs::core::data::hashrate::HashRateUnit::TeraHash).value
|
||||
),
|
||||
TuningTarget::MiningMode(m) => format!("mode {m}"),
|
||||
TuningTarget::Preset(s) => format!("preset {s}"),
|
||||
TuningTarget::Manual { .. } => "manual".to_string(),
|
||||
});
|
||||
// A hashrate target is offerable only where the firmware actively tunes by
|
||||
// hashrate through set_tuning_config (ePIC); Braiins advertises a hashrate
|
||||
// envelope but has no set_tuning_config wired, so it is excluded.
|
||||
let tunes_by_hashrate = matches!(data.tuning_target, Some(TuningTarget::HashRate(_)))
|
||||
|| data.tuning_capabilities.as_ref().map(|c| c.hashrate.is_some()).unwrap_or(false);
|
||||
let hashrate_target = miner.supports_tuning_config() && tunes_by_hashrate;
|
||||
// Probe what this miner supports being told to do (sync, no extra I/O).
|
||||
let caps = MinerCaps {
|
||||
fault_light: miner.supports_set_fault_light(),
|
||||
@@ -649,12 +880,27 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
resume: miner.supports_resume(),
|
||||
power_limit,
|
||||
tuning: miner.supports_set_tuning_percent(),
|
||||
hashrate_target,
|
||||
supports_presets: miner.supports_presets(),
|
||||
firmware_flash: miner.supports_upgrade_firmware(),
|
||||
pools: miner.supports_pools_config(),
|
||||
timezone: miner.supports_timezone_config(),
|
||||
change_password: miner.supports_change_password(),
|
||||
factory_reset: miner.supports_factory_reset(),
|
||||
};
|
||||
// The firmware's selectable named presets/profiles (round 18 / roadmap G3),
|
||||
// read live only for miners that advertise them (LuxOS/VNish). One extra RPC
|
||||
// at scan time for those miners; the default 300 s rescan makes it negligible.
|
||||
let presets: Vec<crate::model::MinerPreset> = if caps.supports_presets {
|
||||
miner
|
||||
.get_presets()
|
||||
.await
|
||||
.into_iter()
|
||||
.map(|p| crate::model::MinerPreset { name: p.name, pretty: p.pretty })
|
||||
.collect()
|
||||
} else {
|
||||
Vec::new()
|
||||
};
|
||||
// PIC vs noPIC (round 14 #2 rework). No firmware exposes a PIC flag over the
|
||||
// network -- it's a fixed hardware property of the hashboard type -- so infer
|
||||
// it from the model, which every API reports. See `infer_pic`.
|
||||
@@ -706,6 +952,7 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
model,
|
||||
brand,
|
||||
submodel,
|
||||
presets,
|
||||
mac: data.mac.map(|m| m.to_string()).unwrap_or_default(),
|
||||
hostname: data.hostname.clone().unwrap_or_default(),
|
||||
serial: {
|
||||
@@ -732,8 +979,34 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
board_code,
|
||||
hashrate_ths,
|
||||
expected_ths,
|
||||
board_hashrates,
|
||||
board_expected_hashrates,
|
||||
board_voltages,
|
||||
board_frequencies,
|
||||
efficiency: data.efficiency.unwrap_or(0.0),
|
||||
power_w,
|
||||
// PSU info (round 17 R5/G15; ePIC exposes it today). A reported-but-zero
|
||||
// output current (ePIC leaves it 0) is treated as absent so the R2 tooltip
|
||||
// shows just the voltage.
|
||||
psu_out_voltage_v: data.psu.as_ref().and_then(|p| p.output_voltage).filter(|&v| v > 0.0),
|
||||
psu_out_current_a: data.psu.as_ref().and_then(|p| p.output_current).filter(|&a| a > 0.0),
|
||||
psu_version: data
|
||||
.psu
|
||||
.as_ref()
|
||||
.map(|p| match (&p.model, &p.version) {
|
||||
(Some(m), Some(v)) => format!("{v} ({m})"),
|
||||
(None, Some(v)) => v.clone(),
|
||||
(Some(m), None) => m.clone(),
|
||||
(None, None) => String::new(),
|
||||
})
|
||||
.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,
|
||||
power_target_min_w,
|
||||
power_target_max_w,
|
||||
hashrate_target_min_ths,
|
||||
hashrate_target_max_ths,
|
||||
tuning_percent: data.tuning_percent,
|
||||
chip_temp_c,
|
||||
board_temps,
|
||||
@@ -771,7 +1044,9 @@ pub enum ConfigAction {
|
||||
Restart,
|
||||
Pause,
|
||||
Resume,
|
||||
PowerLimit(f64), // watts
|
||||
PowerLimit(f64), // watts
|
||||
HashRateTarget(f64), // TH/s -- structured hashrate target (round 17 C)
|
||||
Preset(String), // named firmware profile/preset (round 18 / G3)
|
||||
TuningPercent(u8),
|
||||
Timezone(String), // IANA zone, e.g. "America/Edmonton" (round 17 B / G10)
|
||||
ChangePassword(String), // new web/API password (round 17 B / G11)
|
||||
@@ -787,7 +1062,9 @@ impl ConfigAction {
|
||||
ConfigAction::Restart => "restart".into(),
|
||||
ConfigAction::Pause => "pause".into(),
|
||||
ConfigAction::Resume => "resume".into(),
|
||||
ConfigAction::PowerLimit(w) => format!("power limit {w:.0} W"),
|
||||
ConfigAction::PowerLimit(w) => format!("power target {w:.0} W"),
|
||||
ConfigAction::HashRateTarget(t) => format!("hashrate target {t:.0} TH/s"),
|
||||
ConfigAction::Preset(name) => format!("preset {name}"),
|
||||
ConfigAction::TuningPercent(p) => format!("tuning {p}%"),
|
||||
ConfigAction::Timezone(tz) => format!("timezone {tz}"),
|
||||
ConfigAction::ChangePassword(_) => "change password".into(),
|
||||
@@ -805,6 +1082,8 @@ impl ConfigAction {
|
||||
ConfigAction::Pause => "pausing…".into(),
|
||||
ConfigAction::Resume => "resuming…".into(),
|
||||
ConfigAction::PowerLimit(_) => "setting power…".into(),
|
||||
ConfigAction::HashRateTarget(_) => "setting hashrate…".into(),
|
||||
ConfigAction::Preset(_) => "setting preset…".into(),
|
||||
ConfigAction::TuningPercent(_) => "tuning…".into(),
|
||||
ConfigAction::Timezone(_) => "setting timezone…".into(),
|
||||
ConfigAction::ChangePassword(_) => "changing password…".into(),
|
||||
@@ -839,6 +1118,35 @@ async fn apply_action(miner: &dyn Miner, action: &ConfigAction) -> Result<bool,
|
||||
ConfigAction::Pause => miner.pause(None).await,
|
||||
ConfigAction::Resume => miner.resume(None).await,
|
||||
ConfigAction::PowerLimit(w) => miner.set_power_limit(Power::from_watts(*w)).await,
|
||||
ConfigAction::HashRateTarget(ths) => {
|
||||
use asic_rs::core::config::tuning::TuningConfig;
|
||||
use asic_rs::core::data::hashrate::HashRateUnit;
|
||||
use asic_rs::core::data::miner::TuningTarget;
|
||||
// Build a HashRate target by cloning the miner's current hashrate to
|
||||
// inherit its algorithm (HashAlgorithm is not publicly nameable),
|
||||
// overriding value + unit.
|
||||
let data = miner.get_data().await;
|
||||
let Some(mut hr) = data.hashrate.clone() else {
|
||||
return Err("miner reports no current hashrate; cannot set a hashrate target".into());
|
||||
};
|
||||
hr.value = *ths;
|
||||
hr.unit = HashRateUnit::TeraHash;
|
||||
let mut cfg = TuningConfig::new(TuningTarget::HashRate(hr));
|
||||
// Preserve the firmware's current tuning algorithm + scaling (ePIC
|
||||
// requires both for set_tuning_config; other firmware ignore them).
|
||||
if let Some(algo) = miner.get_tuning_config().await.ok().and_then(|c| c.algorithm) {
|
||||
cfg = cfg.with_algorithm(algo);
|
||||
}
|
||||
let scaling = miner.get_scaling_config().await.ok();
|
||||
miner.set_tuning_config(cfg, scaling).await
|
||||
}
|
||||
ConfigAction::Preset(name) => {
|
||||
use asic_rs::core::config::tuning::TuningConfig;
|
||||
use asic_rs::core::data::miner::TuningTarget;
|
||||
miner
|
||||
.set_tuning_config(TuningConfig::new(TuningTarget::Preset(name.clone())), None)
|
||||
.await
|
||||
}
|
||||
ConfigAction::TuningPercent(p) => miner.set_tuning_percent(*p).await,
|
||||
ConfigAction::Timezone(tz) => {
|
||||
use asic_rs::core::config::timezone::{Tz, TimezoneConfig};
|
||||
@@ -926,7 +1234,7 @@ pub fn start_config_action(ips: Vec<String>, action: ConfigAction) -> ActionHand
|
||||
match outcome {
|
||||
Ok(true) => (true, "ok".to_string()),
|
||||
Ok(false) => (false, "refused".to_string()),
|
||||
Err(e) => (false, format!("{e}")),
|
||||
Err(e) => (false, e.to_string()),
|
||||
}
|
||||
}
|
||||
Ok(None) => (false, "no miner at IP".to_string()),
|
||||
@@ -978,16 +1286,24 @@ pub fn start_pools_action(targets: Vec<PoolTarget>) -> ActionHandle {
|
||||
|
||||
if fake_scan_enabled() {
|
||||
let err_tx = tx.clone();
|
||||
let thread_cancel = cancel.clone();
|
||||
let res = std::thread::Builder::new().name("fake-pools".into()).spawn(move || {
|
||||
let mut ok = 0usize;
|
||||
for t in targets {
|
||||
// Honour cancellation between miners, like every sibling background
|
||||
// action's fake branch (round 18 #12).
|
||||
if thread_cancel.load(Ordering::Relaxed) {
|
||||
break;
|
||||
}
|
||||
let first = t.pools.first().map(|p| p.username.clone()).unwrap_or_default();
|
||||
let _ = tx.send(ActionMsg::Result {
|
||||
ip: t.ip,
|
||||
ok: true,
|
||||
detail: format!("simulated ({} pool(s), {first})", t.pools.len()),
|
||||
});
|
||||
ok += 1;
|
||||
}
|
||||
let _ = tx.send(ActionMsg::Done { ok: total, total });
|
||||
let _ = tx.send(ActionMsg::Done { ok, total });
|
||||
});
|
||||
if res.is_err() {
|
||||
let _ = err_tx.send(ActionMsg::Done { ok: 0, total });
|
||||
@@ -1061,6 +1377,10 @@ pub fn start_pools_action(targets: Vec<PoolTarget>) -> ActionHandle {
|
||||
/// Progress/results from a background refresh of a specific, already-known
|
||||
/// set of miners (re-poll on a timer or after a right-click "Refresh" action,
|
||||
/// as opposed to `start_scan`'s full subnet sweep).
|
||||
// `Row` is the common variant; boxing it to shrink the rare Started/Done/Failed
|
||||
// variants would add an allocation per refreshed miner for no real gain (see the
|
||||
// note on ScanMsg).
|
||||
#[allow(clippy::large_enum_variant)]
|
||||
pub enum RefreshMsg {
|
||||
Started { total: usize },
|
||||
/// A miner's telemetry was re-read successfully.
|
||||
@@ -1240,7 +1560,7 @@ pub fn start_firmware_flash_action(ips: Vec<String>, image: FirmwareImage) -> Ac
|
||||
match flash_one(&*miner, &image).await {
|
||||
Ok(true) => (true, "ok".to_string()),
|
||||
Ok(false) => (false, "refused".to_string()),
|
||||
Err(e) => (false, format!("{e}")),
|
||||
Err(e) => (false, e.to_string()),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1276,10 +1596,14 @@ pub enum AccessProbeMsg {
|
||||
/// A running access probe; `stop` cancels the remaining miners.
|
||||
pub struct AccessProbeHandle {
|
||||
pub rx: Receiver<AccessProbeMsg>,
|
||||
// The worker honours cancellation between miners; a UI stop control is not
|
||||
// wired yet, so the handle-side trigger is kept for when it is.
|
||||
#[allow(dead_code)]
|
||||
cancel: Arc<AtomicBool>,
|
||||
}
|
||||
|
||||
impl AccessProbeHandle {
|
||||
#[allow(dead_code)]
|
||||
pub fn stop(&self) {
|
||||
self.cancel.store(true, Ordering::Relaxed);
|
||||
}
|
||||
@@ -1521,7 +1845,9 @@ mod tests {
|
||||
#[test]
|
||||
fn auto_secs_round_trip_and_defaults() {
|
||||
// config_path() reads $HOME; point it at a private temp dir. HOME is
|
||||
// process-global, so this stays one test and restores HOME afterward.
|
||||
// process-global, so serialise against other HOME-mutating tests and
|
||||
// restore HOME afterward (round 18 #12).
|
||||
let _home = crate::model::HOME_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let prev = std::env::var_os("HOME");
|
||||
let dir = std::env::temp_dir().join(format!("alkane-test-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
|
||||
@@ -0,0 +1,43 @@
|
||||
# cargo-deny configuration (https://embarkstudios.github.io/cargo-deny/).
|
||||
#
|
||||
# Run locally with `cargo deny check`. CI's security gate is cargo-audit (lighter,
|
||||
# already wired); this file documents the dependency policy and lets anyone run a
|
||||
# fuller license/advisory/source check. The whole dependency set is vendored under
|
||||
# ./vendor and resolved offline (see .cargo/config.toml).
|
||||
|
||||
[advisories]
|
||||
version = 2
|
||||
# Accepted, documented advisories (build-time-only reqwest 0.11 subtree of the
|
||||
# wx-rs build script -- never linked into the runtime binary). Mirrors
|
||||
# .cargo/audit.toml; re-review when the vendored dependency set is refreshed.
|
||||
ignore = [
|
||||
"RUSTSEC-2026-0258", # h2 0.3 DATA-frame DoS (build-time HTTP client only)
|
||||
"RUSTSEC-2025-0134", # rustls-pemfile 1.0.4 unmaintained (same subtree)
|
||||
]
|
||||
|
||||
[licenses]
|
||||
version = 2
|
||||
# The project is MIT; only permissive licenses are allowed in the
|
||||
# dependency tree.
|
||||
allow = [
|
||||
"MIT",
|
||||
"Apache-2.0",
|
||||
"Apache-2.0 WITH LLVM-exception",
|
||||
"BSD-2-Clause",
|
||||
"BSD-3-Clause",
|
||||
"ISC",
|
||||
"Zlib",
|
||||
"Unicode-3.0",
|
||||
"Unicode-DFS-2016",
|
||||
"MPL-2.0",
|
||||
"CC0-1.0",
|
||||
]
|
||||
confidence-threshold = 0.9
|
||||
|
||||
[bans]
|
||||
multiple-versions = "warn"
|
||||
wildcards = "allow"
|
||||
|
||||
[sources]
|
||||
unknown-registry = "warn"
|
||||
unknown-git = "warn"
|
||||
@@ -0,0 +1,51 @@
|
||||
#!/usr/bin/env bash
|
||||
#
|
||||
# Reclaim disk from the local cargo build directory.
|
||||
#
|
||||
# The app and the miner_probe CLI ship as release builds, and the unit tests run
|
||||
# under --release too (see the build notes), so the dev/debug profile tree, any
|
||||
# cross-compile target trees, and the coverage tree are all disposable: they only
|
||||
# ever reappear if something explicitly rebuilds them, and left alone they grow
|
||||
# without bound (a stray `cargo check`/`cargo test` can push the debug tree past
|
||||
# 30 GiB on its own). The release tree is kept warm so the next iteration is still
|
||||
# incremental; only its throwaway bits are pruned.
|
||||
#
|
||||
# Run it right after a release push -- the pushed commit is what CI builds and
|
||||
# ships, so the local intermediates are spare from that point. Safe to run any
|
||||
# time; it never deletes the release build itself.
|
||||
#
|
||||
# Honours CARGO_TARGET_DIR (the build sets it to ~/.cache/alkane-tk-target).
|
||||
set -uo pipefail
|
||||
|
||||
TARGET="${CARGO_TARGET_DIR:-$HOME/.cache/alkane-tk-target}"
|
||||
if [ ! -d "$TARGET" ]; then
|
||||
echo "clean-old-builds: no target dir at $TARGET (nothing to do)"
|
||||
exit 0
|
||||
fi
|
||||
|
||||
human() { du -sh "$1" 2>/dev/null | cut -f1; }
|
||||
before=$(human "$TARGET")
|
||||
|
||||
# Disposable profile/aux trees -- regenerated on demand, never shipped.
|
||||
rm -rf "$TARGET"/debug "$TARGET"/llvm-cov-target "$TARGET"/doc 2>/dev/null
|
||||
|
||||
# Cross-compile target trees (e.g. armv7-unknown-linux-musleabihf). Rust target
|
||||
# triples all carry "-unknown-"; the host release/debug trees do not, so this
|
||||
# never touches the warm release build.
|
||||
for d in "$TARGET"/*-unknown-*; do
|
||||
[ -d "$d" ] && rm -rf "$d"
|
||||
done
|
||||
|
||||
# The incremental caches are rebuild accelerators, not build output -- dropping
|
||||
# them costs one slightly-slower rebuild and can free a few GiB.
|
||||
rm -rf "$TARGET"/release/incremental 2>/dev/null
|
||||
|
||||
# If cargo-sweep is installed, additionally drop release artifacts not touched in
|
||||
# the last few days (old dependency versions left by past rebuilds), keeping the
|
||||
# current build. Optional: install with `cargo install cargo-sweep`.
|
||||
if command -v cargo-sweep >/dev/null 2>&1; then
|
||||
cargo sweep --time 3 "$TARGET" >/dev/null 2>&1 || true
|
||||
fi
|
||||
|
||||
after=$(human "$TARGET")
|
||||
echo "clean-old-builds: $TARGET $before -> $after"
|
||||
@@ -0,0 +1,62 @@
|
||||
Subject: [PATCH 0016] braiins v26_04: single-flight auth + defensive get_data timeout
|
||||
|
||||
Round 17 R4 support. Braiins get_data fans out to ~12 authenticated REST calls
|
||||
concurrently. Two hardening changes so a Braiins miner survives a busy scan:
|
||||
|
||||
- ensure_authenticated single-flights the login. Previously all ~12 concurrent
|
||||
commands could see no token and each POST /auth/login -- a thundering herd that
|
||||
doubled the connection load. Now the write lock is held across the login with a
|
||||
double-check, so exactly one call authenticates and the rest reuse the token.
|
||||
- The per-call timeout goes 5s -> 15s as defensive headroom (a healthy miner still
|
||||
answers well under a second) so a call queued behind a scan burst completes
|
||||
instead of dropping miner/stats.
|
||||
|
||||
Neither is the primary fix for the fleet-scan value dropout -- that is the
|
||||
app-side scan concurrency cap (scan::SCAN_CONCURRENCY_LIMIT = 128), which keeps
|
||||
the identification burst from starving these calls. These are the belt to that
|
||||
suspenders. Verified live: a 10.4.1.0/24 scan now populates both Braiins corpus
|
||||
miners (.27, .83) fully (watts, best-share, fw/control-board) and misses no
|
||||
responders.
|
||||
diff --git a/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/web.rs b/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/web.rs
|
||||
index 3e06b682..ae433d98 100644
|
||||
--- a/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/web.rs
|
||||
+++ b/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/web.rs
|
||||
@@ -87,7 +87,13 @@ impl BraiinsWebAPI {
|
||||
client: OnceCell::new(),
|
||||
ip,
|
||||
port: 80,
|
||||
- timeout: Duration::from_secs(5),
|
||||
+ // Braiins get_data fans out to ~12 authenticated REST calls that run
|
||||
+ // concurrently. A healthy miner answers well under a second; the extra
|
||||
+ // headroom over the old 5 s is defensive so a call that queues behind a
|
||||
+ // scan burst still completes instead of dropping miner/stats
|
||||
+ // (hashrate/watts/best-share). The real fix for the fleet-scan dropout
|
||||
+ // is the app-side scan concurrency cap (see scan::SCAN_CONCURRENCY_LIMIT).
|
||||
+ timeout: Duration::from_secs(15),
|
||||
bearer_token: RwLock::new(None),
|
||||
auth,
|
||||
}
|
||||
@@ -122,13 +128,22 @@ impl BraiinsWebAPI {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
+ // Single-flight the login: get_data fires ~12 commands concurrently, and
|
||||
+ // without this they would ALL see no token and each POST /auth/login (a
|
||||
+ // thundering herd that doubles the connection load and races under a
|
||||
+ // high-concurrency fleet scan, dropping most values). Hold the write lock
|
||||
+ // across the login so exactly one call authenticates and the rest reuse it.
|
||||
+ let mut guard = self.bearer_token.write().await;
|
||||
+ if guard.is_some() {
|
||||
+ return Ok(());
|
||||
+ }
|
||||
let token = match &self.auth {
|
||||
MinerAuth::TokenAuth(token) => token.expose_secret().to_string(),
|
||||
MinerAuth::UserAndPass(creds) => {
|
||||
self.authenticate(creds.password.expose_secret()).await?
|
||||
}
|
||||
};
|
||||
- *self.bearer_token.write().await = Some(token);
|
||||
+ *guard = Some(token);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,103 @@
|
||||
Subject: [PATCH 0017] luxminer v1: select power-limit profile by name, not step
|
||||
|
||||
Round 17 C (found via live tuning verification). set_power_limit mapped a watts
|
||||
target to a LuxOS profile and applied it with `profileset`, but keyed on the
|
||||
profile's `Step` field. The top/factory profile is named "default" and its Step
|
||||
is "0"; LuxOS's profileset reads the parameter "0" as empty and answers
|
||||
"Missing profile parameter" (Code 400). So the setter could never select the
|
||||
default profile -- and a miner nudged off default by a watts limit could not be
|
||||
returned to it via the power-limit control, stranding it below its factory point.
|
||||
|
||||
parse_profile_watts now keys on `Profile Name` (e.g. "480MHz", "default"), which
|
||||
profileset accepts for every profile including the default. Verified live on a
|
||||
LuxOS S19j Pro (10.4.1.60): set_power_limit(2700) -> 480MHz/2632W, and
|
||||
set_power_limit(2900) -> default/2794W (previously errored), restoring the miner
|
||||
to its factory profile. Unit test updated to key on names and to cover the
|
||||
top-profile-is-"default" case.
|
||||
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 2d1331bf..a4db1e03 100644
|
||||
--- a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
|
||||
@@ -1078,8 +1078,14 @@ impl SetFaultLight for LuxMinerV1 {
|
||||
}
|
||||
}
|
||||
|
||||
-/// Parse a LuxOS `profiles` RPC reply into (step name, watts) pairs, keeping only
|
||||
-/// profiles that report both a `Step` and a `Watts` value.
|
||||
+/// Parse a LuxOS `profiles` RPC reply into (profile name, watts) pairs, keeping
|
||||
+/// only profiles that report both a `Profile Name` and a `Watts` value.
|
||||
+///
|
||||
+/// The identifier is the `Profile Name` (e.g. "480MHz", "default"), NOT the
|
||||
+/// `Step`: `profileset` takes the name, and the default profile's step is "0",
|
||||
+/// which LuxOS reads as an empty parameter ("Missing profile parameter"), so a
|
||||
+/// step-keyed setter can never select the default profile and could strand a
|
||||
+/// miner off its factory point.
|
||||
fn parse_profile_watts(profiles: &Value) -> Vec<(String, f64)> {
|
||||
profiles
|
||||
.get("PROFILES")
|
||||
@@ -1087,16 +1093,16 @@ fn parse_profile_watts(profiles: &Value) -> Vec<(String, f64)> {
|
||||
.map(|arr| {
|
||||
arr.iter()
|
||||
.filter_map(|p| {
|
||||
- let step = p.get("Step").and_then(Value::as_str)?.to_string();
|
||||
+ let name = p.get("Profile Name").and_then(Value::as_str)?.to_string();
|
||||
let watts = p.get("Watts").and_then(Value::as_f64)?;
|
||||
- Some((step, watts))
|
||||
+ Some((name, watts))
|
||||
})
|
||||
.collect()
|
||||
})
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
-/// Choose the LuxOS profile step to satisfy a watts power limit: the highest-watt
|
||||
+/// Choose the LuxOS profile name to satisfy a watts power limit: the highest-watt
|
||||
/// profile that does not exceed `target_w`, or -- when the target is below every
|
||||
/// profile -- the lowest-watt profile. Returns None only when there are no
|
||||
/// profiles to choose from.
|
||||
@@ -1315,32 +1321,34 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn power_limit_profile_selection() {
|
||||
- // LuxOS reports a ladder of profiles, each with a Step name and Watts.
|
||||
+ // LuxOS reports a ladder of profiles, each with a Profile Name and Watts.
|
||||
+ // The top profile is named "default" (its Step is "0", which profileset
|
||||
+ // rejects -- so selection must key on the name, not the step).
|
||||
let steps = vec![
|
||||
- ("-16".to_string(), 865.0),
|
||||
- ("-4".to_string(), 2385.0),
|
||||
- ("-2".to_string(), 2790.0),
|
||||
- ("0".to_string(), 3100.0),
|
||||
+ ("190MHz".to_string(), 865.0),
|
||||
+ ("405MHz".to_string(), 2385.0),
|
||||
+ ("455MHz".to_string(), 2790.0),
|
||||
+ ("default".to_string(), 3100.0),
|
||||
];
|
||||
// The highest profile at or below the requested watts limit.
|
||||
assert_eq!(
|
||||
select_profile_at_or_below(&steps, 2500.0).as_deref(),
|
||||
- Some("-4")
|
||||
+ Some("405MHz")
|
||||
);
|
||||
assert_eq!(
|
||||
select_profile_at_or_below(&steps, 2790.0).as_deref(),
|
||||
- Some("-2")
|
||||
+ Some("455MHz")
|
||||
);
|
||||
- // Above every profile -> the maximum profile (a limit can't exceed the
|
||||
- // hardware's top profile).
|
||||
+ // Above every profile -> the maximum profile, selected by NAME ("default")
|
||||
+ // rather than its step "0" (which profileset would reject).
|
||||
assert_eq!(
|
||||
select_profile_at_or_below(&steps, 9000.0).as_deref(),
|
||||
- Some("0")
|
||||
+ Some("default")
|
||||
);
|
||||
// Below every profile -> the minimum profile.
|
||||
assert_eq!(
|
||||
select_profile_at_or_below(&steps, 100.0).as_deref(),
|
||||
- Some("-16")
|
||||
+ Some("190MHz")
|
||||
);
|
||||
// No profiles -> nothing to choose.
|
||||
assert_eq!(select_profile_at_or_below(&[], 2500.0), None);
|
||||
@@ -0,0 +1,202 @@
|
||||
Subject: [PATCH 0018] core + epic: PSU info scan (identity, rated envelope, output V/A)
|
||||
|
||||
Round 17 R5/G15. asic-rs had no PSU telemetry. Adds a PsuInfo type (model,
|
||||
version, rated voltage min/max, live output voltage/current) as an optional
|
||||
MinerData.psu field, a DataField::Psu, and a default parse_psu(&data) -> None
|
||||
that backends override.
|
||||
|
||||
ePIC (PowerPlay v1) populates it: DataField::Psu merges the summary "Power Supply
|
||||
Stats" (tag "stats") and the capabilities "Psu Info" (tag "info"); parse_psu reads
|
||||
model/FW + Min/Max Vout (millivolts -> volts) + live Output Voltage/Current.
|
||||
|
||||
Verified live on ePIC S19j Pro (10.4.1.6/.10): model 117, fw 22, Vmin 11.877 V,
|
||||
Vmax 15.182 V, output ~13.2-13.4 V. Feeds the new PSU version/Vmin/Vmax columns
|
||||
and the R2 power tooltip (output V/A). Other backends leave psu None until they
|
||||
add their own parse_psu.
|
||||
diff --git a/vendor/asic-rs-core/src/data/collector.rs b/vendor/asic-rs-core/src/data/collector.rs
|
||||
index 93a0111a..d1456548 100644
|
||||
--- a/vendor/asic-rs-core/src/data/collector.rs
|
||||
+++ b/vendor/asic-rs-core/src/data/collector.rs
|
||||
@@ -74,6 +74,9 @@ pub enum DataField {
|
||||
/// Current power consumption in watts.
|
||||
#[cfg_attr(feature = "python", pydantic(value = "Wattage"))]
|
||||
Wattage,
|
||||
+ /// Power-supply info (identity, rated voltage envelope, live output V/A).
|
||||
+ #[cfg_attr(feature = "python", pydantic(value = "Psu"))]
|
||||
+ Psu,
|
||||
/// manual tuning percent of full power (100 = unthrottled).
|
||||
#[cfg_attr(feature = "python", pydantic(value = "TuningPercent"))]
|
||||
TuningPercent,
|
||||
diff --git a/vendor/asic-rs-core/src/data/miner.rs b/vendor/asic-rs-core/src/data/miner.rs
|
||||
index be6f4c8f..b2b8a578 100644
|
||||
--- a/vendor/asic-rs-core/src/data/miner.rs
|
||||
+++ b/vendor/asic-rs-core/src/data/miner.rs
|
||||
@@ -16,6 +16,7 @@ use super::{
|
||||
message::MinerMessage,
|
||||
operating_state::OperatingState,
|
||||
pool::PoolGroupData,
|
||||
+ psu::PsuInfo,
|
||||
};
|
||||
use crate::data::{
|
||||
deserialize::deserialize_macaddr,
|
||||
@@ -192,6 +193,9 @@ pub struct MinerData {
|
||||
#[serde(serialize_with = "serialize_power")]
|
||||
#[ts(type = "number | null")]
|
||||
pub wattage: Option<Power>,
|
||||
+ /// Power-supply info (identity, rated voltage envelope, live output V/A),
|
||||
+ /// when the firmware reports it.
|
||||
+ pub psu: Option<PsuInfo>,
|
||||
/// The current manual tuning percent of full power (100 = unthrottled), where supported
|
||||
pub tuning_percent: Option<u8>,
|
||||
/// The current tuning target of the miner, such as power target or hashrate target
|
||||
diff --git a/vendor/asic-rs-core/src/data/mod.rs b/vendor/asic-rs-core/src/data/mod.rs
|
||||
index c69c43eb..3b7f98c0 100644
|
||||
--- a/vendor/asic-rs-core/src/data/mod.rs
|
||||
+++ b/vendor/asic-rs-core/src/data/mod.rs
|
||||
@@ -15,5 +15,6 @@ pub mod message;
|
||||
pub mod miner;
|
||||
pub mod operating_state;
|
||||
pub mod pool;
|
||||
+pub mod psu;
|
||||
pub(crate) mod serialize;
|
||||
pub mod share;
|
||||
diff --git a/vendor/asic-rs-core/src/data/psu.rs b/vendor/asic-rs-core/src/data/psu.rs
|
||||
new file mode 100644
|
||||
index 00000000..810ba47c
|
||||
--- /dev/null
|
||||
+++ b/vendor/asic-rs-core/src/data/psu.rs
|
||||
@@ -0,0 +1,30 @@
|
||||
+//! Power-supply (PSU) information reported by a miner's firmware.
|
||||
+//!
|
||||
+//! A backend fills in only what its firmware actually exposes; every field is
|
||||
+//! optional. Some firmware reports the PSU's identity and rated voltage envelope
|
||||
+//! (min/max output voltage), others also report the live output voltage and
|
||||
+//! current. Voltages are in volts and currents in amps.
|
||||
+
|
||||
+#[cfg(feature = "python")]
|
||||
+use pyo3::pyclass;
|
||||
+use serde::{Deserialize, Serialize};
|
||||
+use ts_rs::TS;
|
||||
+
|
||||
+/// Power-supply identity and voltage telemetry for one miner.
|
||||
+#[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 PsuInfo {
|
||||
+ /// PSU model / type identifier, when reported.
|
||||
+ pub model: Option<String>,
|
||||
+ /// PSU firmware/hardware version, when reported.
|
||||
+ pub version: Option<String>,
|
||||
+ /// Minimum rated output voltage in volts, when reported.
|
||||
+ pub voltage_min: Option<f64>,
|
||||
+ /// Maximum rated output voltage in volts, when reported.
|
||||
+ pub voltage_max: Option<f64>,
|
||||
+ /// Live output voltage in volts, when reported.
|
||||
+ pub output_voltage: Option<f64>,
|
||||
+ /// Live output current in amps, when reported.
|
||||
+ pub output_current: Option<f64>,
|
||||
+}
|
||||
diff --git a/vendor/asic-rs-core/src/traits/miner.rs b/vendor/asic-rs-core/src/traits/miner.rs
|
||||
index d08b1b5a..db1ba653 100644
|
||||
--- a/vendor/asic-rs-core/src/traits/miner.rs
|
||||
+++ b/vendor/asic-rs-core/src/traits/miner.rs
|
||||
@@ -33,6 +33,7 @@ use crate::{
|
||||
miner::{MinerData, TuningTarget},
|
||||
operating_state::OperatingState,
|
||||
pool::PoolGroupData,
|
||||
+ psu::PsuInfo,
|
||||
},
|
||||
traits::firmware::MinerFirmware,
|
||||
traits::model::MinerModel,
|
||||
@@ -272,6 +273,7 @@ impl<
|
||||
let hashrate = self.parse_hashrate(&data);
|
||||
let expected_hashrate = self.parse_expected_hashrate(&data);
|
||||
let wattage = self.parse_wattage(&data);
|
||||
+ let psu = self.parse_psu(&data);
|
||||
let tuning_percent = self.parse_tuning_percent(&data);
|
||||
let tuning_target = self.parse_tuning_target(&data);
|
||||
let scaled_tuning_target = self.parse_scaled_tuning_target(&data);
|
||||
@@ -367,6 +369,7 @@ impl<
|
||||
|
||||
// Power information
|
||||
wattage,
|
||||
+ psu,
|
||||
tuning_percent,
|
||||
tuning_target,
|
||||
scaled_tuning_target,
|
||||
@@ -720,6 +723,10 @@ pub trait GetWattage: CollectData {
|
||||
fn parse_wattage(&self, data: &HashMap<DataField, Value>) -> Option<Power> {
|
||||
None
|
||||
}
|
||||
+ #[allow(unused_variables)]
|
||||
+ fn parse_psu(&self, data: &HashMap<DataField, Value>) -> Option<PsuInfo> {
|
||||
+ None
|
||||
+ }
|
||||
}
|
||||
|
||||
// Tuning Percent
|
||||
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 c21e05b1..3365824d 100644
|
||||
--- a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
|
||||
@@ -24,6 +24,7 @@ use asic_rs_core::{
|
||||
miner::TuningTarget,
|
||||
operating_state::OperatingState,
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
+ psu::PsuInfo,
|
||||
},
|
||||
traits::{miner::*, model::MinerModel},
|
||||
util::unix_timestamp_secs,
|
||||
@@ -436,6 +437,26 @@ impl GetDataLocations for PowerPlayV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // PSU: live stats from summary + rated envelope/identity from
|
||||
+ // capabilities, tagged so parse_psu can read both (round 17 R5/G15).
|
||||
+ DataField::Psu => vec![
|
||||
+ (
|
||||
+ WEB_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/Power Supply Stats"),
|
||||
+ tag: Some("stats"),
|
||||
+ },
|
||||
+ ),
|
||||
+ (
|
||||
+ WEB_CAPABILITIES,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/Psu Info"),
|
||||
+ tag: Some("info"),
|
||||
+ },
|
||||
+ ),
|
||||
+ ],
|
||||
DataField::TuningTarget => vec![(
|
||||
WEB_SUMMARY,
|
||||
DataExtractor {
|
||||
@@ -1095,6 +1116,25 @@ impl GetWattage for PowerPlayV1 {
|
||||
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> {
|
||||
+ // DataField::Psu is the merged {stats: Power Supply Stats, info: Psu Info}
|
||||
+ // (see get_locations). capabilities Vout + summary Target Voltage are in
|
||||
+ // millivolts; summary Output Voltage/Current are already volts/amps.
|
||||
+ let d = data.get(&DataField::Psu)?;
|
||||
+ let stats = d.pointer("/stats");
|
||||
+ let info = d.pointer("/info");
|
||||
+ let f = |v: Option<&Value>, key: &str| v.and_then(|o| o.pointer(key)).and_then(tuning_value_as_f64);
|
||||
+ let psu = PsuInfo {
|
||||
+ model: f(info, "/PSU Type").map(|n| format!("{n:.0}")),
|
||||
+ version: f(info, "/FW").map(|n| format!("{n:.0}")),
|
||||
+ 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"),
|
||||
+ output_current: f(stats, "/Output Current"),
|
||||
+ };
|
||||
+ (psu != PsuInfo::default()).then_some(psu)
|
||||
+ }
|
||||
}
|
||||
|
||||
fn tuning_value_as_f64(value: &Value) -> Option<f64> {
|
||||
@@ -0,0 +1,128 @@
|
||||
Subject: [PATCH 0019] antminer v2023_07: best-share + Bixbit "Power Estimated" wattage
|
||||
|
||||
Round 17 R7 (found by flashing Bixbit onto fleet units). The v2023_07 stock
|
||||
backend scanned hashrate/boards/temps/fans fine but reported no best-share for the
|
||||
WHOLE Antminer fleet (DataField::BestShare had no get_locations entry, so it was
|
||||
never fetched) and no wattage for Bixbit-based firmware (it reads the cgminer
|
||||
stats power, which Bixbit leaves 0, putting the real figure in the summary as
|
||||
"Power Estimated").
|
||||
|
||||
- Map DataField::BestShare / SessionBestShare to the cgminer summary
|
||||
("Best Share" / "Best Session Share") and implement GetBestShare /
|
||||
GetSessionBestShare (guard 0 -> None).
|
||||
- Add the summary to DataField::Wattage under a "summary" tag and fall back to
|
||||
"Power Estimated" in parse_wattage when the stats power is 0/absent. Stock
|
||||
behaviour is preserved (a non-zero stats power still wins; a present-but-zero
|
||||
power still reads 0 W).
|
||||
|
||||
Verified live: Bixbit S19j Pro (10.4.1.70) now reads wattage 2615 W + best-share
|
||||
178930671 (was both blank); stock S21 Pro (10.4.1.90) now reads best-share
|
||||
299464394 (was blank). 36 antminer backend tests pass; no wattage regression.
|
||||
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 6d6dc593..1ac2bad1 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
|
||||
@@ -521,8 +521,40 @@ impl GetDataLocations for AntMinerV202307 {
|
||||
tag: None,
|
||||
},
|
||||
),
|
||||
+ // Bixbit-based firmware reports Power=0 in stats but the real
|
||||
+ // figure as "Power Estimated" in the cgminer summary; carry it
|
||||
+ // under a "summary" tag so parse_wattage can fall back to it
|
||||
+ // without colliding with the stats keys (round 17 R7).
|
||||
+ (
|
||||
+ RPC_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/SUMMARY/0"),
|
||||
+ tag: Some("summary"),
|
||||
+ },
|
||||
+ ),
|
||||
]
|
||||
}
|
||||
+ // Best share (all-time / session) from the cgminer summary. Antminer
|
||||
+ // stock, Bixbit, and other cgminer-based firmware all report it here;
|
||||
+ // it was previously unmapped, so best-share was blank fleet-wide
|
||||
+ // (round 17 R7).
|
||||
+ DataField::BestShare => vec![(
|
||||
+ RPC_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/SUMMARY/0/Best Share"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
+ DataField::SessionBestShare => vec![(
|
||||
+ RPC_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/SUMMARY/0/Best Session Share"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::SerialNumber => vec![
|
||||
(
|
||||
WEB_SYSTEM_INFO,
|
||||
@@ -778,8 +810,6 @@ impl GetUptime for AntMinerV202307 {
|
||||
}
|
||||
}
|
||||
|
||||
-impl GetBestShare for AntMinerV202307 {}
|
||||
-impl GetSessionBestShare for AntMinerV202307 {}
|
||||
|
||||
impl GetOperatingState for AntMinerV202307 {}
|
||||
|
||||
@@ -888,14 +918,30 @@ impl GetWattage for AntMinerV202307 {
|
||||
}
|
||||
}
|
||||
|
||||
- if let Some(power) = stats_data
|
||||
+ let primary = stats_data
|
||||
.get("power")
|
||||
.or_else(|| stats_data.get("Power"))
|
||||
// Same firmware version spells this differently per model: the
|
||||
// L9 reports `power`, the L11 `watt`.
|
||||
.or_else(|| stats_data.get("watt"))
|
||||
+ .and_then(|v| v.as_f64());
|
||||
+ if let Some(power) = primary
|
||||
+ && power > 0.0
|
||||
+ {
|
||||
+ return Some(Power::from_watts(power));
|
||||
+ }
|
||||
+ // Bixbit-based firmware leaves the stats power at 0 and reports the
|
||||
+ // real draw as "Power Estimated" in the summary (round 17 R7).
|
||||
+ if let Some(est) = stats_data
|
||||
+ .pointer("/summary/Power Estimated")
|
||||
.and_then(|v| v.as_f64())
|
||||
+ && est > 0.0
|
||||
{
|
||||
+ return Some(Power::from_watts(est));
|
||||
+ }
|
||||
+ // Preserve the prior behaviour: a present-but-zero stats power still
|
||||
+ // reads as 0 W rather than blank.
|
||||
+ if let Some(power) = primary {
|
||||
return Some(Power::from_watts(power));
|
||||
}
|
||||
}
|
||||
@@ -903,6 +949,21 @@ impl GetWattage for AntMinerV202307 {
|
||||
}
|
||||
}
|
||||
|
||||
+impl GetBestShare for AntMinerV202307 {
|
||||
+ fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
+ // cgminer summary "Best Share" (all-time). Guard against a firmware that
|
||||
+ // reports 0 when it has never found a share (round 17 R7).
|
||||
+ data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
|
||||
+ }
|
||||
+}
|
||||
+
|
||||
+impl GetSessionBestShare for AntMinerV202307 {
|
||||
+ fn parse_session_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
+ data.extract::<f64>(DataField::SessionBestShare)
|
||||
+ .filter(|&v| v > 0.0)
|
||||
+ }
|
||||
+}
|
||||
+
|
||||
impl GetTuningTarget for AntMinerV202307 {
|
||||
fn parse_tuning_target(&self, data: &HashMap<DataField, Value>) -> Option<TuningTarget> {
|
||||
data.get(&DataField::TuningTarget)
|
||||
@@ -0,0 +1,59 @@
|
||||
Subject: [PATCH 0020] braiins v26_04: PSU info (type + rated voltage envelope)
|
||||
|
||||
Round 17 R5/G15 extension. BOS reports PSU info at miner/details -> psu_info
|
||||
{version, min_voltage.volt, max_voltage.volt}. Map DataField::Psu to it and parse
|
||||
model (the "version" type code, 117 = the same APW12 ePIC reports) + voltage
|
||||
min/max. Verified live on Braiins S19j Pro (10.4.1.83/.27): model 117, Vmin
|
||||
11.96 V, Vmax 15.2 V.
|
||||
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 e65fb201..9b72ed94 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
|
||||
@@ -22,6 +22,7 @@ use asic_rs_core::{
|
||||
miner::TuningTarget,
|
||||
operating_state::OperatingState,
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
+ psu::PsuInfo,
|
||||
},
|
||||
traits::{miner::*, model::MinerModel},
|
||||
};
|
||||
@@ -294,6 +295,16 @@ impl GetDataLocations for BraiinsV2604 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // PSU identity + rated voltage envelope (round 17 R5/G15). BOS reports
|
||||
+ // it at miner/details -> psu_info {version, min_voltage, max_voltage}.
|
||||
+ DataField::Psu => vec![(
|
||||
+ WEB_MINER_DETAILS,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/psu_info"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::TuningTarget => vec![
|
||||
(
|
||||
WEB_MINER_CONFIGURATION,
|
||||
@@ -663,6 +674,22 @@ impl GetWattage for BraiinsV2604 {
|
||||
fn parse_wattage(&self, data: &HashMap<DataField, Value>) -> Option<Power> {
|
||||
data.extract_map::<i64, _>(DataField::Wattage, |w| Power::from_watts(w as f64))
|
||||
}
|
||||
+
|
||||
+ 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.
|
||||
+ 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,
|
||||
+ 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,
|
||||
+ output_current: None,
|
||||
+ };
|
||||
+ (psu != PsuInfo::default()).then_some(psu)
|
||||
+ }
|
||||
}
|
||||
|
||||
impl GetTuningTarget for BraiinsV2604 {
|
||||
@@ -0,0 +1,173 @@
|
||||
Subject: [PATCH 0021] whatsminer v1/v2: PSU info + fix pre-existing parse_messages test
|
||||
|
||||
Round 17 R5/G15 extension. get_psu /Msg exposes the PSU model + hw/sw version
|
||||
(no DC output voltage or rated envelope). Map DataField::Psu to it in v1 and v2
|
||||
and parse model + version. Verified live on a WhatsMiner M30S+ (10.8.1.214, v2):
|
||||
model P221C, version H20201205. (v3 uses a different /msg/power shape and no v3
|
||||
unit was available to verify, so it is left for a follow-up.)
|
||||
|
||||
Also fixes a pre-existing test bug: test_whatsminer_v1_parse_messages asserted 2
|
||||
messages but never mocked get_error_code (its only source since patch 0012), so it
|
||||
returned 0 and failed whenever the vendored backend tests were run (CI runs only
|
||||
the GUI selftest, so it went unnoticed). Adds a get_error_code.json mock. v1 tests
|
||||
now 41/41.
|
||||
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 67907049..3c8512ad 100644
|
||||
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
|
||||
@@ -18,6 +18,7 @@ use asic_rs_core::{
|
||||
message::{MessageSeverity, MinerMessage},
|
||||
miner::TuningTarget,
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
+ psu::PsuInfo,
|
||||
},
|
||||
traits::{miner::*, model::MinerModel},
|
||||
};
|
||||
@@ -193,6 +194,16 @@ impl GetDataLocations for WhatsMinerV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // PSU identity from get_psu (round 17 R5/G15). WhatsMiner exposes the
|
||||
+ // model + hw/sw version but not a DC output voltage or rated envelope.
|
||||
+ DataField::Psu => vec![(
|
||||
+ RPC_GET_PSU,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/Msg"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::Hashboards => vec![(
|
||||
RPC_DEVS,
|
||||
DataExtractor {
|
||||
@@ -463,6 +474,22 @@ impl GetWattage for WhatsMinerV1 {
|
||||
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_psu /Msg -> {model, hw_version, sw_version, ...} (values are strings).
|
||||
+ // No DC output voltage or rated envelope is exposed, so only identity is set.
|
||||
+ 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("/name")),
|
||||
+ version: s("/hw_version").or_else(|| s("/sw_version")),
|
||||
+ voltage_min: None,
|
||||
+ voltage_max: None,
|
||||
+ output_voltage: None,
|
||||
+ output_current: None,
|
||||
+ };
|
||||
+ (psu != PsuInfo::default()).then_some(psu)
|
||||
+ }
|
||||
}
|
||||
impl GetTuningTarget for WhatsMinerV1 {
|
||||
fn parse_tuning_target(&self, data: &HashMap<DataField, Value>) -> Option<TuningTarget> {
|
||||
@@ -805,8 +832,8 @@ mod integration_tests {
|
||||
|
||||
use super::*;
|
||||
use crate::test::json::v1::{
|
||||
- DEVS_COMMAND, GET_PSU_COMMAND, GET_VERSION_COMMAND, POOLS_COMMAND, STATUS_COMMAND,
|
||||
- SUMMARY_COMMAND, SUMMARY_WITH_ERRORS_COMMAND,
|
||||
+ DEVS_COMMAND, GET_ERROR_CODE_COMMAND, GET_PSU_COMMAND, GET_VERSION_COMMAND, POOLS_COMMAND,
|
||||
+ STATUS_COMMAND, SUMMARY_COMMAND, SUMMARY_WITH_ERRORS_COMMAND,
|
||||
};
|
||||
|
||||
#[tokio::test]
|
||||
@@ -943,6 +970,13 @@ mod integration_tests {
|
||||
},
|
||||
Value::from_str(GET_PSU_COMMAND)?,
|
||||
);
|
||||
+ results.insert(
|
||||
+ MinerCommand::RPC {
|
||||
+ command: "get_error_code",
|
||||
+ parameters: None,
|
||||
+ },
|
||||
+ Value::from_str(GET_ERROR_CODE_COMMAND)?,
|
||||
+ );
|
||||
|
||||
let mock_api = MockAPIClient::new(results);
|
||||
|
||||
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 096b2fcb..de36a126 100644
|
||||
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
|
||||
@@ -20,6 +20,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,
|
||||
@@ -205,6 +206,15 @@ impl GetDataLocations for WhatsMinerV2 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // PSU identity from get_psu (round 17 R5/G15): model + hw/sw version.
|
||||
+ DataField::Psu => vec![(
|
||||
+ RPC_GET_PSU,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/Msg"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::Hashboards => vec![(
|
||||
RPC_DEVS,
|
||||
DataExtractor {
|
||||
@@ -471,6 +481,22 @@ impl GetWattage for WhatsMinerV2 {
|
||||
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_psu /Msg -> {model, hw_version, sw_version} (string values). No DC
|
||||
+ // output voltage or rated envelope is exposed, so only identity is set.
|
||||
+ 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("/name")),
|
||||
+ version: s("/hw_version").or_else(|| s("/sw_version")),
|
||||
+ voltage_min: None,
|
||||
+ voltage_max: None,
|
||||
+ output_voltage: None,
|
||||
+ output_current: None,
|
||||
+ };
|
||||
+ (psu != PsuInfo::default()).then_some(psu)
|
||||
+ }
|
||||
}
|
||||
/// Parses tuning target from V2 summary data.
|
||||
/// Low/High → MiningMode, Normal/unknown/empty → Power(limit).
|
||||
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/test/json/v1/get_error_code.json b/vendor/asic-rs-firmwares-whatsminer/src/test/json/v1/get_error_code.json
|
||||
new file mode 100644
|
||||
index 00000000..1d87b18b
|
||||
--- /dev/null
|
||||
+++ b/vendor/asic-rs-firmwares-whatsminer/src/test/json/v1/get_error_code.json
|
||||
@@ -0,0 +1,16 @@
|
||||
+{
|
||||
+ "Code": 131,
|
||||
+ "Description": "",
|
||||
+ "Msg": {
|
||||
+ "error_code": [
|
||||
+ {
|
||||
+ "110": "2024-06-15 09:15:00"
|
||||
+ },
|
||||
+ {
|
||||
+ "600": "2024-06-15 10:30:00"
|
||||
+ }
|
||||
+ ]
|
||||
+ },
|
||||
+ "STATUS": "S",
|
||||
+ "When": 1773871985
|
||||
+}
|
||||
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/test/json/v1/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/test/json/v1/mod.rs
|
||||
index 0b3442db..c94c354f 100644
|
||||
--- a/vendor/asic-rs-firmwares-whatsminer/src/test/json/v1/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-whatsminer/src/test/json/v1/mod.rs
|
||||
@@ -6,4 +6,5 @@ pub(crate) const POOLS_COMMAND: &str = include_str!("pools.json");
|
||||
pub(crate) const DEVS_COMMAND: &str = include_str!("devs.json");
|
||||
pub(crate) const GET_VERSION_COMMAND: &str = include_str!("get_version.json");
|
||||
pub(crate) const GET_PSU_COMMAND: &str = include_str!("get_psu.json");
|
||||
+pub(crate) const GET_ERROR_CODE_COMMAND: &str = include_str!("get_error_code.json");
|
||||
pub(crate) const SUMMARY_WITH_ERRORS_COMMAND: &str = include_str!("summary_with_errors.json");
|
||||
@@ -0,0 +1,159 @@
|
||||
Subject: [PATCH 0022] luxminer: named presets + set_tuning_config (roadmap G3)
|
||||
|
||||
LuxOS tunes by discrete named profiles. This exposes them as first-class
|
||||
presets and wires the structured tuning-config setter, so the toolkit can list
|
||||
and select a profile (not only map a watts number onto one via SetPowerLimit).
|
||||
|
||||
- SupportsPresets: supports_presets()=true and get_presets() reads the live
|
||||
`profiles` RPC into PresetInfo{name, pretty="<W> W ~ <TH> TH @ <MHz> MHz",
|
||||
status=IsTuned?tuned:untuned}. Never hardcoded -- the step list varies by
|
||||
model and tune state. New helper parse_profiles_to_presets + unit test.
|
||||
- SupportsTuningConfig: supports_tuning_config()=true and set_tuning_config
|
||||
handles Preset(name) -> profileset(name) (the same privileged RPC set_power_limit
|
||||
already uses, proven in patch 0017) and Power(w) -> set_power_limit; hashrate /
|
||||
mining-mode / manual targets are refused with clear messages.
|
||||
|
||||
Verified live (read) on two production LuxOS S19j Pro (10.4.1.60 / .67): the
|
||||
profile ladders and supports_tuning_config=true are reported correctly. The
|
||||
write path reuses the already-proven profileset(name) call; per the parity
|
||||
roadmap, LuxOS profile writes are bench-only (never on the .60/.67 production
|
||||
units), so the setter is not exercised against them here.
|
||||
|
||||
diff --git a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
|
||||
index a4db1e03..b5a5a73c 100644
|
||||
--- a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
|
||||
@@ -5,6 +5,8 @@ use asic_rs_core::{
|
||||
config::{
|
||||
collector::{ConfigCollector, ConfigExtractor, ConfigField, ConfigLocation},
|
||||
pools::{PoolConfig, PoolGroupConfig},
|
||||
+ preset::PresetInfo,
|
||||
+ tuning::TuningConfig,
|
||||
},
|
||||
data::{
|
||||
board::{BoardData, ChipData, MinerControlBoard},
|
||||
@@ -1102,6 +1104,38 @@ fn parse_profile_watts(profiles: &Value) -> Vec<(String, f64)> {
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
+/// Parse a LuxOS `profiles` RPC reply into the firmware's tunable presets, one
|
||||
+/// per dynamic profile (round 18 / roadmap G3). The `Profile Name` is the
|
||||
+/// identifier `profileset` expects; the pretty string summarises the profile's
|
||||
+/// watt / hashrate / frequency operating point, and `status` reflects `IsTuned`.
|
||||
+fn parse_profiles_to_presets(profiles: &Value) -> Vec<PresetInfo> {
|
||||
+ profiles
|
||||
+ .get("PROFILES")
|
||||
+ .and_then(Value::as_array)
|
||||
+ .map(|arr| {
|
||||
+ arr.iter()
|
||||
+ .filter_map(|p| {
|
||||
+ let name = p.get("Profile Name").and_then(Value::as_str)?.to_string();
|
||||
+ let watts = p.get("Watts").and_then(Value::as_f64);
|
||||
+ let hashrate = p.get("Hashrate").and_then(Value::as_f64);
|
||||
+ let freq = p.get("Frequency").and_then(Value::as_f64);
|
||||
+ let pretty = match (watts, hashrate, freq) {
|
||||
+ (Some(w), Some(h), Some(f)) => Some(format!("{w:.0} W ~ {h:.1} TH @ {f:.0} MHz")),
|
||||
+ (Some(w), Some(h), None) => Some(format!("{w:.0} W ~ {h:.1} TH")),
|
||||
+ (Some(w), None, _) => Some(format!("{w:.0} W")),
|
||||
+ _ => None,
|
||||
+ };
|
||||
+ let status = p
|
||||
+ .get("IsTuned")
|
||||
+ .and_then(Value::as_bool)
|
||||
+ .map(|t| if t { "tuned" } else { "untuned" }.to_string());
|
||||
+ Some(PresetInfo { name, pretty, status })
|
||||
+ })
|
||||
+ .collect()
|
||||
+ })
|
||||
+ .unwrap_or_default()
|
||||
+}
|
||||
+
|
||||
/// Choose the LuxOS profile name to satisfy a watts power limit: the highest-watt
|
||||
/// profile that does not exceed `target_w`, or -- when the target is below every
|
||||
/// profile -- the lowest-watt profile. Returns None only when there are no
|
||||
@@ -1284,7 +1318,38 @@ impl Validate for LuxMinerV1 {
|
||||
#[async_trait]
|
||||
impl SupportsTuningConfig for LuxMinerV1 {
|
||||
fn supports_tuning_config(&self) -> bool {
|
||||
- false
|
||||
+ true
|
||||
+ }
|
||||
+
|
||||
+ /// LuxOS tunes by named profile (roadmap G3). A `Preset` target is applied
|
||||
+ /// straight through `profileset`; a `Power` target reuses the watts->profile
|
||||
+ /// mapping in `set_power_limit`. LuxOS has no hashrate/mining-mode targets and
|
||||
+ /// per-board manual tuning is not wired, so those targets are refused.
|
||||
+ async fn set_tuning_config(
|
||||
+ &self,
|
||||
+ config: TuningConfig,
|
||||
+ _scaling_config: Option<asic_rs_core::config::scaling::ScalingConfig>,
|
||||
+ ) -> anyhow::Result<bool> {
|
||||
+ match config.target {
|
||||
+ TuningTarget::Preset(name) => {
|
||||
+ let resp = self.rpc.profileset(&name).await?;
|
||||
+ Ok(resp
|
||||
+ .pointer("/STATUS/0/STATUS")
|
||||
+ .and_then(Value::as_str)
|
||||
+ .map(|s| matches!(s, "S" | "I"))
|
||||
+ .unwrap_or(true))
|
||||
+ }
|
||||
+ TuningTarget::Power(p) => self.set_power_limit(p).await,
|
||||
+ TuningTarget::HashRate(_) => {
|
||||
+ anyhow::bail!("LuxOS does not tune by hashrate target; select a named profile")
|
||||
+ }
|
||||
+ TuningTarget::MiningMode(_) => {
|
||||
+ anyhow::bail!("LuxOS has no mining modes; select a named profile")
|
||||
+ }
|
||||
+ TuningTarget::Manual { .. } => {
|
||||
+ anyhow::bail!("Per-board manual tuning is not wired for LuxOS")
|
||||
+ }
|
||||
+ }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1299,7 +1364,21 @@ impl SupportsTemperatureConfig for LuxMinerV1 {}
|
||||
impl GetTuningPercent for LuxMinerV1 {}
|
||||
impl SetTuningPercent for LuxMinerV1 {}
|
||||
|
||||
-impl SupportsPresets for LuxMinerV1 {}
|
||||
+#[async_trait]
|
||||
+impl SupportsPresets for LuxMinerV1 {
|
||||
+ fn supports_presets(&self) -> bool {
|
||||
+ true
|
||||
+ }
|
||||
+
|
||||
+ /// The firmware's tunable profiles, read live from the `profiles` RPC (roadmap
|
||||
+ /// G3). Never hardcoded -- the step list varies by model and tune state.
|
||||
+ async fn get_presets(&self) -> Vec<PresetInfo> {
|
||||
+ match self.rpc.profiles().await {
|
||||
+ Ok(profiles) => parse_profiles_to_presets(&profiles),
|
||||
+ Err(_) => Vec::new(),
|
||||
+ }
|
||||
+ }
|
||||
+}
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::sync::{Arc, Mutex};
|
||||
@@ -1361,6 +1440,22 @@ mod tests {
|
||||
assert!(select_profile_at_or_below(&parsed, 2500.0).is_some());
|
||||
}
|
||||
|
||||
+ #[test]
|
||||
+ fn profiles_parse_to_presets() {
|
||||
+ // The `profiles` reply becomes one PresetInfo per profile (roadmap G3).
|
||||
+ let profiles: Value = serde_json::from_str(PROFILES).unwrap();
|
||||
+ let presets = parse_profiles_to_presets(&profiles);
|
||||
+ assert_eq!(presets.len(), 25, "one preset per fixture profile");
|
||||
+ // The factory point is named "default"; its pretty string carries the
|
||||
+ // watt / hashrate / frequency operating point.
|
||||
+ let default = presets.iter().find(|p| p.name == "default").unwrap();
|
||||
+ assert_eq!(default.pretty.as_deref(), Some("2794 W ~ 121.8 TH @ 590 MHz"));
|
||||
+ // IsTuned maps to the status string.
|
||||
+ let tuned = presets.iter().find(|p| p.name == "290MHz").unwrap();
|
||||
+ assert_eq!(tuned.status.as_deref(), Some("tuned"));
|
||||
+ assert_eq!(default.status.as_deref(), Some("untuned"));
|
||||
+ }
|
||||
+
|
||||
#[tokio::test]
|
||||
|
||||
async fn test_luxminer_v1() -> anyhow::Result<()> {
|
||||
@@ -39,6 +39,11 @@ version = "1.0"
|
||||
[build-dependencies.embed-resource]
|
||||
version = "1.3"
|
||||
|
||||
# reqwest is only used by build.rs to download the wxWidgets source on
|
||||
# Windows/macOS; on Linux download_dist() returns before touching it, and it is
|
||||
# never linked into the runtime binary. Kept at the vendored 0.11 (the build tree
|
||||
# is fully vendored / offline); the h2 0.3 advisory it pulls is build-time only
|
||||
# and is documented as accepted in audit.toml (RUSTSEC-2026-0258).
|
||||
[build-dependencies.reqwest]
|
||||
version = "0.11"
|
||||
features = ["blocking"]
|
||||
|
||||
@@ -335,13 +335,27 @@ int DrawShape(wxDC* dc, wxUniChar shape, wxCoord x, const wxRect& cell,
|
||||
if (h < 8) h = 8;
|
||||
int w = (sv->vbh > 0) ? (int)((double)h * sv->vbw / sv->vbh + 0.5) : h;
|
||||
if (w < 1) w = 1;
|
||||
const wxBitmap& bmp = ShapeBitmap(shape, *sv, colour, w, h);
|
||||
// The Font Awesome fan and brain glyphs fill their square box more than the
|
||||
// other health icons (chip/bolt), so at the shared size they read as oversized.
|
||||
// Draw them a bit smaller, centred in their full-size slot, so the slot advance
|
||||
// and the per-icon tooltip hit-test (both keyed to the full width) are
|
||||
// unchanged (round 17 R1; round 18 #1 brain).
|
||||
int dw = w, dh = h;
|
||||
double glyph_scale = (shape == SHAPE_FAN) ? 0.80 : (shape == SHAPE_BRAIN) ? 0.82 : 1.0;
|
||||
if (glyph_scale < 1.0) {
|
||||
dh = (int)(h * glyph_scale + 0.5);
|
||||
if (dh < 8) dh = 8;
|
||||
dw = (sv->vbh > 0) ? (int)((double)dh * sv->vbw / sv->vbh + 0.5) : dh;
|
||||
if (dw < 1) dw = 1;
|
||||
}
|
||||
const wxBitmap& bmp = ShapeBitmap(shape, *sv, colour, dw, dh);
|
||||
if (bmp.IsOk()) {
|
||||
if (health) {
|
||||
// Left-align and advance by less than the 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, cy - h / 2, true);
|
||||
// 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;
|
||||
}
|
||||
@@ -762,6 +776,13 @@ void* wxbr_text_ctrl(void* parent, int multiline) {
|
||||
wxDefaultPosition, wxSize(-1, -1), style);
|
||||
}
|
||||
|
||||
// A single-line text control that masks its content (wxTE_PASSWORD), for secret
|
||||
// entry so a saved password is never rendered in the clear (round 18 #12).
|
||||
void* wxbr_text_ctrl_password(void* parent) {
|
||||
return (void*)new wxTextCtrl((wxWindow*)parent, wxID_ANY, wxT(""),
|
||||
wxDefaultPosition, wxSize(-1, -1), wxTE_PASSWORD);
|
||||
}
|
||||
|
||||
int wxbr_text_ctrl_get(void* win, char* buf, int cap) {
|
||||
wxTextCtrl* t = (wxTextCtrl*)win;
|
||||
wxString v = t->GetValue();
|
||||
@@ -969,6 +990,17 @@ static gboolean dvlc_query_tooltip(GtkWidget* tv, gint x, gint y, gboolean keybo
|
||||
if (slot >= (int)iit->second.size()) slot = (int)iit->second.size() - 1;
|
||||
const wxString& tip = iit->second[(size_t)slot];
|
||||
if (tip.IsEmpty()) return FALSE;
|
||||
// Scope the tooltip's "tip area" to just this icon's slot (round 18 #4a).
|
||||
// Without a tip area GTK defaults it to the whole widget, so it never re-queries
|
||||
// or moves the tooltip as the pointer crosses from one icon to the next -- the
|
||||
// old tooltip just stays put with stale text. Setting a per-slot area makes GTK
|
||||
// hide + re-show + reposition the tooltip for each icon.
|
||||
GdkRectangle area;
|
||||
area.x = crect.x + slot * adv;
|
||||
area.y = crect.y;
|
||||
area.width = adv;
|
||||
area.height = crect.height;
|
||||
gtk_tooltip_set_tip_area(tooltip, &area);
|
||||
gtk_tooltip_set_text(tooltip, tip.utf8_str());
|
||||
return TRUE;
|
||||
}
|
||||
@@ -1266,6 +1298,23 @@ void wxbr_dvlc_autosize_col(void* win, int pos) {
|
||||
if (c) c->SetWidth(wxCOL_WIDTH_AUTOSIZE);
|
||||
}
|
||||
|
||||
// Size a column to fit its content + header, then clamp to cap_px so the default
|
||||
// width is min(reasonable cap, content-fit) -- a short column shrinks to its
|
||||
// content, a long one is capped at the caller's sensible default (round 18 #10).
|
||||
// A small floor keeps a column from collapsing to nothing.
|
||||
void wxbr_dvlc_autosize_col_capped(void* win, int pos, int cap_px) {
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
if (pos < 0 || (unsigned)pos >= dv->GetColumnCount()) return;
|
||||
wxDataViewColumn* c = dv->GetColumn((unsigned)pos);
|
||||
if (!c) return;
|
||||
c->SetWidth(wxCOL_WIDTH_AUTOSIZE);
|
||||
int w = c->GetWidth();
|
||||
const int floor_px = 24;
|
||||
if (w < floor_px) w = floor_px;
|
||||
if (cap_px > 0 && w > cap_px) w = cap_px;
|
||||
c->SetWidth(w);
|
||||
}
|
||||
|
||||
// Update a column's header text in place (creation index) without recreating
|
||||
// the control -- used to refresh the ASCII sort marker on a sort click.
|
||||
void wxbr_dvlc_set_col_title(void* win, int col, const char* title) {
|
||||
|
||||
@@ -36,6 +36,7 @@ mod notsafe {
|
||||
pub fn wxbr_button(parent: *mut c_void, label: *const c_char, id: c_int) -> *mut c_void;
|
||||
pub fn wxbr_bind_click(win: *mut c_void, id: c_int);
|
||||
pub fn wxbr_text_ctrl(parent: *mut c_void, multiline: c_int) -> *mut c_void;
|
||||
pub fn wxbr_text_ctrl_password(parent: *mut c_void) -> *mut c_void;
|
||||
pub fn wxbr_text_ctrl_get(win: *mut c_void, buf: *mut c_char, cap: c_int) -> c_int;
|
||||
pub fn wxbr_text_ctrl_set(win: *mut c_void, value: *const c_char);
|
||||
pub fn wxbr_text_ctrl_write(win: *mut c_void, value: *const c_char);
|
||||
@@ -68,6 +69,7 @@ mod notsafe {
|
||||
pub fn wxbr_dvlc_get_cell(win: *mut c_void, row: usize, col: usize, buf: *mut c_char, cap: c_int) -> c_int;
|
||||
pub fn wxbr_dvlc_col_count(win: *mut c_void) -> c_int;
|
||||
pub fn wxbr_dvlc_autosize_col(win: *mut c_void, pos: c_int);
|
||||
pub fn wxbr_dvlc_autosize_col_capped(win: *mut c_void, pos: c_int, cap_px: c_int);
|
||||
pub fn wxbr_dvlc_set_col_title(win: *mut c_void, col: c_int, title: *const c_char);
|
||||
pub fn wxbr_dvlc_set_sort_indicator(win: *mut c_void, col: c_int, active: c_int, ascending: c_int);
|
||||
pub fn wxbr_dvlc_col_at_pos(win: *mut c_void, pos: c_int) -> c_int;
|
||||
@@ -437,6 +439,11 @@ impl Widget {
|
||||
Widget(unsafe { notsafe::wxbr_text_ctrl(parent.0, multiline as c_int) })
|
||||
}
|
||||
|
||||
/// A single-line text control that masks its content (for password entry).
|
||||
pub fn password_ctrl(parent: Widget) -> Widget {
|
||||
Widget(unsafe { notsafe::wxbr_text_ctrl_password(parent.0) })
|
||||
}
|
||||
|
||||
pub fn get_value(&self) -> String {
|
||||
let mut buf = vec![0i8; 65536];
|
||||
let n = unsafe { notsafe::wxbr_text_ctrl_get(self.0, buf.as_mut_ptr(), buf.len() as c_int) };
|
||||
@@ -647,6 +654,12 @@ impl Widget {
|
||||
unsafe { notsafe::wxbr_dvlc_autosize_col(self.0, pos as c_int) }
|
||||
}
|
||||
|
||||
/// Size the column at display position `pos` to its content, then clamp to
|
||||
/// `cap_px`: the width becomes min(cap, content-fit) (round 18 #10).
|
||||
pub fn dvlc_autosize_col_capped(&self, pos: usize, cap_px: i32) {
|
||||
unsafe { notsafe::wxbr_dvlc_autosize_col_capped(self.0, pos as c_int, cap_px) }
|
||||
}
|
||||
|
||||
/// Model column index shown at display position `pos` (after drag reorder).
|
||||
pub fn dvlc_col_at_pos(&self, pos: usize) -> Option<usize> {
|
||||
let v = unsafe { notsafe::wxbr_dvlc_col_at_pos(self.0, pos as c_int) };
|
||||
|
||||
@@ -1 +1 @@
|
||||
{"$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":"792489f8292863a7d57b9867096349d3257ddaf5bb0b5317e7a4366aa1b9dec9","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":"641ed29589112fdecf96a2065b05a1878af2a08bb60bff5e624bf56cc08e4a3a","src/data/mod.rs":"620b6876d0c88ad80c4aad1ed8ce8f8c4a76641c1e1c61e02cff115b1ab1da55","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":"b198869b22a5e56366014a4090946cb44e9cddda32e77c62e57a90ceec8f1348","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":"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"}
|
||||
@@ -74,6 +74,9 @@ pub enum DataField {
|
||||
/// Current power consumption in watts.
|
||||
#[cfg_attr(feature = "python", pydantic(value = "Wattage"))]
|
||||
Wattage,
|
||||
/// Power-supply info (identity, rated voltage envelope, live output V/A).
|
||||
#[cfg_attr(feature = "python", pydantic(value = "Psu"))]
|
||||
Psu,
|
||||
/// manual tuning percent of full power (100 = unthrottled).
|
||||
#[cfg_attr(feature = "python", pydantic(value = "TuningPercent"))]
|
||||
TuningPercent,
|
||||
|
||||
@@ -16,6 +16,7 @@ use super::{
|
||||
message::MinerMessage,
|
||||
operating_state::OperatingState,
|
||||
pool::PoolGroupData,
|
||||
psu::PsuInfo,
|
||||
};
|
||||
use crate::data::{
|
||||
deserialize::deserialize_macaddr,
|
||||
@@ -192,6 +193,9 @@ pub struct MinerData {
|
||||
#[serde(serialize_with = "serialize_power")]
|
||||
#[ts(type = "number | null")]
|
||||
pub wattage: Option<Power>,
|
||||
/// Power-supply info (identity, rated voltage envelope, live output V/A),
|
||||
/// when the firmware reports it.
|
||||
pub psu: Option<PsuInfo>,
|
||||
/// The current manual tuning percent of full power (100 = unthrottled), where supported
|
||||
pub tuning_percent: Option<u8>,
|
||||
/// The current tuning target of the miner, such as power target or hashrate target
|
||||
|
||||
@@ -15,5 +15,6 @@ pub mod message;
|
||||
pub mod miner;
|
||||
pub mod operating_state;
|
||||
pub mod pool;
|
||||
pub mod psu;
|
||||
pub(crate) mod serialize;
|
||||
pub mod share;
|
||||
|
||||
@@ -0,0 +1,30 @@
|
||||
//! Power-supply (PSU) information reported by a miner's firmware.
|
||||
//!
|
||||
//! A backend fills in only what its firmware actually exposes; every field is
|
||||
//! optional. Some firmware reports the PSU's identity and rated voltage envelope
|
||||
//! (min/max output voltage), others also report the live output voltage and
|
||||
//! current. Voltages are in volts and currents in amps.
|
||||
|
||||
#[cfg(feature = "python")]
|
||||
use pyo3::pyclass;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use ts_rs::TS;
|
||||
|
||||
/// Power-supply identity and voltage telemetry for one miner.
|
||||
#[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 PsuInfo {
|
||||
/// PSU model / type identifier, when reported.
|
||||
pub model: Option<String>,
|
||||
/// PSU firmware/hardware version, when reported.
|
||||
pub version: Option<String>,
|
||||
/// Minimum rated output voltage in volts, when reported.
|
||||
pub voltage_min: Option<f64>,
|
||||
/// Maximum rated output voltage in volts, when reported.
|
||||
pub voltage_max: Option<f64>,
|
||||
/// Live output voltage in volts, when reported.
|
||||
pub output_voltage: Option<f64>,
|
||||
/// Live output current in amps, when reported.
|
||||
pub output_current: Option<f64>,
|
||||
}
|
||||
@@ -33,6 +33,7 @@ use crate::{
|
||||
miner::{MinerData, TuningTarget},
|
||||
operating_state::OperatingState,
|
||||
pool::PoolGroupData,
|
||||
psu::PsuInfo,
|
||||
},
|
||||
traits::firmware::MinerFirmware,
|
||||
traits::model::MinerModel,
|
||||
@@ -272,6 +273,7 @@ impl<
|
||||
let hashrate = self.parse_hashrate(&data);
|
||||
let expected_hashrate = self.parse_expected_hashrate(&data);
|
||||
let wattage = self.parse_wattage(&data);
|
||||
let psu = self.parse_psu(&data);
|
||||
let tuning_percent = self.parse_tuning_percent(&data);
|
||||
let tuning_target = self.parse_tuning_target(&data);
|
||||
let scaled_tuning_target = self.parse_scaled_tuning_target(&data);
|
||||
@@ -367,6 +369,7 @@ impl<
|
||||
|
||||
// Power information
|
||||
wattage,
|
||||
psu,
|
||||
tuning_percent,
|
||||
tuning_target,
|
||||
scaled_tuning_target,
|
||||
@@ -720,6 +723,10 @@ pub trait GetWattage: CollectData {
|
||||
fn parse_wattage(&self, data: &HashMap<DataField, Value>) -> Option<Power> {
|
||||
None
|
||||
}
|
||||
#[allow(unused_variables)]
|
||||
fn parse_psu(&self, data: &HashMap<DataField, Value>) -> Option<PsuInfo> {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
// Tuning Percent
|
||||
|
||||
@@ -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":"278e4dd04a753858e12df96ead3522aef0616ebf6f27b3da4f1a12b064c19ee6","src/backends/v2023_07/rpc.rs":"2b24bbb432b302dd15f7a354054fc96c6a75cac2c8e75b8bcc11da37255a05a3","src/backends/v2023_07/web.rs":"d39b67ed83781b2c4fa84a445b9ffe785ae3001941f800ad9860e050c61c6506","src/firmware.rs":"e75c21d63218204b61bfab067599402e5c0b20452beaf0b16bfa79bf8afb6b35","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"a3ef4d6805bb4f8ea087e3a9b875e5a1664580e1ff3e3cd2015bb0c5c18ae7bb","src/test/json/v2020/devs.json":"df17cdfc9522e23450702b93f70ff701892db54c6ce6d986300453ad5e0d22db","src/test/json/v2020/mod.rs":"4c2512d36af834d400a865a94c2e8b1919f9d8dcbf54ab2530c73861c51af67d","src/test/json/v2020/pools.json":"4c4d19ad3ef0de84bfb18daaa48428b5f7917d23287c0196eacf3a6e389e7634","src/test/json/v2020/stats.json":"6d3cb463abb7539ae77aa44ef38e62a5dc0db54670aeacf3bbd01e83f49aa1fd","src/test/json/v2020/summary.json":"2f18c81f989b7c5f70dcb0ddac0520e56ec98b6da25c24e59354a6126c965dae","src/test/json/v2020/system_info.json":"51d1ce922e39a254518a24be56ca86ef1b5843582fb26c1ff0ec4ff6f8f91ccf","src/test/json/v2020/version.json":"ae898c4c9ea3462c3e79f9de755f1fccb4ef122b94a4a512e61aa74491c1a8e9","src/test/json/v2023_07/l11_stats.json":"2eab324f253ced9a0ea4e46466691e0e71fc6fde7558fec86bd5acf6bb9c717d","src/test/json/v2023_07/l11_summary.json":"1e0fdb61b968005d0ec5393d9dc889b09efb1398ffa427629bcc0a98d1b67c22","src/test/json/v2023_07/l11_version.json":"d116921a71731c6e492aed109731c39561e34a24c7df2a88d11ac52b80f6100a","src/test/json/v2023_07/l9_stats.json":"731ee545f16dafd356d22703248b91a37f74585ad73cc27441eb3461ce53dca0","src/test/json/v2023_07/l9_summary.json":"b32b5131ad46859b270d2dbb6bdba3c4e5d7301298daee4ce56332c98faaf81d","src/test/json/v2023_07/l9_version.json":"82f03ca6ea8873f12c4d9455f21b98c547801b58fbff1dcd83c837c0f337a129","src/test/json/v2023_07/mod.rs":"1360a8b155b120f2e755ede0736bcc0d76a9d1d693b984a1b51a16e6c0413791","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"0c06e3ecbf95ae3fe5e30aacae55cf6e7ad3d965f4a93b2f85c7b64f61fc75e2"}
|
||||
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"6e42d50107b1a43fd7cf4a4c4f538468a337ed219ad8d6b23bd9abdabd123bd5","Cargo.lock":"7f984c7231c91f2def8f3e2e923a85c2e0b3239492f5ce23400881ea4de1aa16","Cargo.toml":"8a447efc18cd97d019a9771fb258b06f694499500561564eec75480e46bcc554","Cargo.toml.orig":"6c9e7b86804255debe03545c6358eb975d3d470810a19e6c40c680299a686b1f","src/backends/mod.rs":"65cdc60cdf38968f5a7e197338f4cf6173406ce69a4f0aaa96a9e29f4f581b6e","src/backends/v2020/firmware.rs":"5a41bfb8f42f17523e68f8702e87d75bcdb268bd4950bb66227f6966ef3576a9","src/backends/v2020/mod.rs":"efcaa6b186c8b6e79e9799a647291b895c5ff59f058722e98455ef68bc97c548","src/backends/v2020/rpc.rs":"b517f88b9125fe1d8a20d5167f5d0d105b1339fce3d1a9fad5592e00470f46fb","src/backends/v2020/web.rs":"a6a3ad3eb77551b098b0092553b02cee43d165476d8c92164e12a1e765753b0d","src/backends/v2023_07/firmware.rs":"c07668e351d48dab3e24511b1aa9ab5e408bbcb5a438fdb0542a1377f94b9bbb","src/backends/v2023_07/mod.rs":"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"}
|
||||
@@ -521,8 +521,40 @@ impl GetDataLocations for AntMinerV202307 {
|
||||
tag: None,
|
||||
},
|
||||
),
|
||||
// Bixbit-based firmware reports Power=0 in stats but the real
|
||||
// figure as "Power Estimated" in the cgminer summary; carry it
|
||||
// under a "summary" tag so parse_wattage can fall back to it
|
||||
// without colliding with the stats keys (round 17 R7).
|
||||
(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/SUMMARY/0"),
|
||||
tag: Some("summary"),
|
||||
},
|
||||
),
|
||||
]
|
||||
}
|
||||
// Best share (all-time / session) from the cgminer summary. Antminer
|
||||
// stock, Bixbit, and other cgminer-based firmware all report it here;
|
||||
// it was previously unmapped, so best-share was blank fleet-wide
|
||||
// (round 17 R7).
|
||||
DataField::BestShare => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/SUMMARY/0/Best Share"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::SessionBestShare => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/SUMMARY/0/Best Session Share"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::SerialNumber => vec![
|
||||
(
|
||||
WEB_SYSTEM_INFO,
|
||||
@@ -778,8 +810,6 @@ impl GetUptime for AntMinerV202307 {
|
||||
}
|
||||
}
|
||||
|
||||
impl GetBestShare for AntMinerV202307 {}
|
||||
impl GetSessionBestShare for AntMinerV202307 {}
|
||||
|
||||
impl GetOperatingState for AntMinerV202307 {}
|
||||
|
||||
@@ -888,21 +918,52 @@ impl GetWattage for AntMinerV202307 {
|
||||
}
|
||||
}
|
||||
|
||||
if let Some(power) = stats_data
|
||||
let primary = stats_data
|
||||
.get("power")
|
||||
.or_else(|| stats_data.get("Power"))
|
||||
// Same firmware version spells this differently per model: the
|
||||
// L9 reports `power`, the L11 `watt`.
|
||||
.or_else(|| stats_data.get("watt"))
|
||||
.and_then(|v| v.as_f64())
|
||||
.and_then(|v| v.as_f64());
|
||||
if let Some(power) = primary
|
||||
&& power > 0.0
|
||||
{
|
||||
return Some(Power::from_watts(power));
|
||||
}
|
||||
// Bixbit-based firmware leaves the stats power at 0 and reports the
|
||||
// real draw as "Power Estimated" in the summary (round 17 R7).
|
||||
if let Some(est) = stats_data
|
||||
.pointer("/summary/Power Estimated")
|
||||
.and_then(|v| v.as_f64())
|
||||
&& est > 0.0
|
||||
{
|
||||
return Some(Power::from_watts(est));
|
||||
}
|
||||
// Preserve the prior behaviour: a present-but-zero stats power still
|
||||
// reads as 0 W rather than blank.
|
||||
if let Some(power) = primary {
|
||||
return Some(Power::from_watts(power));
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
impl GetBestShare for AntMinerV202307 {
|
||||
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
// cgminer summary "Best Share" (all-time). Guard against a firmware that
|
||||
// reports 0 when it has never found a share (round 17 R7).
|
||||
data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl GetSessionBestShare for AntMinerV202307 {
|
||||
fn parse_session_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
data.extract::<f64>(DataField::SessionBestShare)
|
||||
.filter(|&v| v > 0.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl GetTuningTarget for AntMinerV202307 {
|
||||
fn parse_tuning_target(&self, data: &HashMap<DataField, Value>) -> Option<TuningTarget> {
|
||||
data.get(&DataField::TuningTarget)
|
||||
|
||||
@@ -22,6 +22,7 @@ use asic_rs_core::{
|
||||
miner::TuningTarget,
|
||||
operating_state::OperatingState,
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
psu::PsuInfo,
|
||||
},
|
||||
traits::{miner::*, model::MinerModel},
|
||||
};
|
||||
@@ -294,6 +295,16 @@ impl GetDataLocations for BraiinsV2604 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// PSU identity + rated voltage envelope (round 17 R5/G15). BOS reports
|
||||
// it at miner/details -> psu_info {version, min_voltage, max_voltage}.
|
||||
DataField::Psu => vec![(
|
||||
WEB_MINER_DETAILS,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/psu_info"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::TuningTarget => vec![
|
||||
(
|
||||
WEB_MINER_CONFIGURATION,
|
||||
@@ -663,6 +674,22 @@ impl GetWattage for BraiinsV2604 {
|
||||
fn parse_wattage(&self, data: &HashMap<DataField, Value>) -> Option<Power> {
|
||||
data.extract_map::<i64, _>(DataField::Wattage, |w| Power::from_watts(w as f64))
|
||||
}
|
||||
|
||||
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.
|
||||
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,
|
||||
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,
|
||||
output_current: None,
|
||||
};
|
||||
(psu != PsuInfo::default()).then_some(psu)
|
||||
}
|
||||
}
|
||||
|
||||
impl GetTuningTarget for BraiinsV2604 {
|
||||
|
||||
@@ -87,7 +87,13 @@ impl BraiinsWebAPI {
|
||||
client: OnceCell::new(),
|
||||
ip,
|
||||
port: 80,
|
||||
timeout: Duration::from_secs(5),
|
||||
// Braiins get_data fans out to ~12 authenticated REST calls that run
|
||||
// concurrently. A healthy miner answers well under a second; the extra
|
||||
// headroom over the old 5 s is defensive so a call that queues behind a
|
||||
// scan burst still completes instead of dropping miner/stats
|
||||
// (hashrate/watts/best-share). The real fix for the fleet-scan dropout
|
||||
// is the app-side scan concurrency cap (see scan::SCAN_CONCURRENCY_LIMIT).
|
||||
timeout: Duration::from_secs(15),
|
||||
bearer_token: RwLock::new(None),
|
||||
auth,
|
||||
}
|
||||
@@ -122,13 +128,22 @@ impl BraiinsWebAPI {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// Single-flight the login: get_data fires ~12 commands concurrently, and
|
||||
// without this they would ALL see no token and each POST /auth/login (a
|
||||
// thundering herd that doubles the connection load and races under a
|
||||
// high-concurrency fleet scan, dropping most values). Hold the write lock
|
||||
// across the login so exactly one call authenticates and the rest reuse it.
|
||||
let mut guard = self.bearer_token.write().await;
|
||||
if guard.is_some() {
|
||||
return Ok(());
|
||||
}
|
||||
let token = match &self.auth {
|
||||
MinerAuth::TokenAuth(token) => token.expose_secret().to_string(),
|
||||
MinerAuth::UserAndPass(creds) => {
|
||||
self.authenticate(creds.password.expose_secret()).await?
|
||||
}
|
||||
};
|
||||
*self.bearer_token.write().await = Some(token);
|
||||
*guard = Some(token);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -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":"fff17902f8fa033d5b67c6131ea2ff01b80f9a9c8e02dd0511e1e87521d23e47","src/backends/v1/web.rs":"3a567a4f581baa5d9d2d4e59d8acc754eec51d49b0a4f5434d87614b037a4a55","src/firmware.rs":"fb88124a51089756cc3271f3d4a234d73add61ab919c4710ef26a52dc8b5ef80","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"24191681066d5cf6a3022ad59c1baa92b57e3ce7717bb78d6a682af9e19a38c4","src/test/json/v1/capabilities.json":"d2b3dae7aa2a1e2977e0ddf62cf2d730de64cf12bf62388c12fd23dc5278bbcb","src/test/json/v1/chip_clocks.json":"d1f46d3aad6ad55ec1c02d0b26aa4c5034c1ccaefb130d7b0e46efe48bb122a0","src/test/json/v1/chip_hashrates.json":"9601a1289f93fe4e27c722d51b3a31daa71aec71f2c29e71f6d1eefe01edf7f2","src/test/json/v1/chip_temps.json":"cb7390e424af57f55f0c974ddfe0c98c4d5b4dbcd85887e38ff8caf7b19f62fe","src/test/json/v1/chip_voltages.json":"cb7390e424af57f55f0c974ddfe0c98c4d5b4dbcd85887e38ff8caf7b19f62fe","src/test/json/v1/mod.rs":"5671105221b84b0b6edb2df34b25bfc9e33459da285d4316be0db23ddb630e8d","src/test/json/v1/network.json":"3374b419fa2f0bc19544c670e08118bbc45bd4d121a577c5a6403c8c8100f628","src/test/json/v1/summary.json":"ac8ac018da9d619b5884f283b730bad2bf0a7e8f2032a7119193c9e5d87d6a7c","src/test/json/v1/temps.json":"794edf870985ed4398ead96670b8f5d01deb4d825fb14a8325087a29cd939fa8","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"268dc7c8b3289fccd3230ff87f7bfc727a3e7e2f6f72ae56ab9d27c63eabc5cf"}
|
||||
{"$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"}
|
||||
@@ -24,6 +24,7 @@ use asic_rs_core::{
|
||||
miner::TuningTarget,
|
||||
operating_state::OperatingState,
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
psu::PsuInfo,
|
||||
},
|
||||
traits::{miner::*, model::MinerModel},
|
||||
util::unix_timestamp_secs,
|
||||
@@ -436,6 +437,26 @@ impl GetDataLocations for PowerPlayV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// PSU: live stats from summary + rated envelope/identity from
|
||||
// capabilities, tagged so parse_psu can read both (round 17 R5/G15).
|
||||
DataField::Psu => vec![
|
||||
(
|
||||
WEB_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/Power Supply Stats"),
|
||||
tag: Some("stats"),
|
||||
},
|
||||
),
|
||||
(
|
||||
WEB_CAPABILITIES,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/Psu Info"),
|
||||
tag: Some("info"),
|
||||
},
|
||||
),
|
||||
],
|
||||
DataField::TuningTarget => vec![(
|
||||
WEB_SUMMARY,
|
||||
DataExtractor {
|
||||
@@ -1095,6 +1116,25 @@ impl GetWattage for PowerPlayV1 {
|
||||
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> {
|
||||
// DataField::Psu is the merged {stats: Power Supply Stats, info: Psu Info}
|
||||
// (see get_locations). capabilities Vout + summary Target Voltage are in
|
||||
// millivolts; summary Output Voltage/Current are already volts/amps.
|
||||
let d = data.get(&DataField::Psu)?;
|
||||
let stats = d.pointer("/stats");
|
||||
let info = d.pointer("/info");
|
||||
let f = |v: Option<&Value>, key: &str| v.and_then(|o| o.pointer(key)).and_then(tuning_value_as_f64);
|
||||
let psu = PsuInfo {
|
||||
model: f(info, "/PSU Type").map(|n| format!("{n:.0}")),
|
||||
version: f(info, "/FW").map(|n| format!("{n:.0}")),
|
||||
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"),
|
||||
output_current: f(stats, "/Output Current"),
|
||||
};
|
||||
(psu != PsuInfo::default()).then_some(psu)
|
||||
}
|
||||
}
|
||||
|
||||
fn tuning_value_as_f64(value: &Value) -> Option<f64> {
|
||||
|
||||
@@ -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":"3e57d2c72d1d48c0b86f5438202633fcd9c1ebf375bd87ffe53ea5298ae936ad","src/backends/v1/rpc.rs":"25b0b9d56fbf113d5b8c3d3bc8eb7a0d67967b1f90f6d855da0b9f6ff24ae335","src/firmware.rs":"d95345295ae5043dfc357e69ae56c564b261fdb3b19b5c0ad1765267ff05ab3f","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"24191681066d5cf6a3022ad59c1baa92b57e3ce7717bb78d6a682af9e19a38c4","src/test/json/v1/config.json":"6ca9e6217d853d4bf1e75d69159630e9c9184ede96751706b88dfb699b5d59ad","src/test/json/v1/devs.json":"8f746dc6a02953eee5ee96dcf53be8dc7880a8ffc2c6e303f0284bcf6a97f42d","src/test/json/v1/events.json":"913683ff97af3333018807e1cc6e43467ea8a55925e5964dc402616615e2a5e3","src/test/json/v1/fans.json":"f8a9a1234d651055c80f4ebb1380bbb4e6d19eb33012902c55fff1385e592447","src/test/json/v1/healthchipget_0.json":"10619460049333ca016b2beec59ecc514ed9077fb19bdf7d0ed697201f8cb96c","src/test/json/v1/healthchipget_1.json":"80927fb1480c95be7f3a4e155d63f68f97720530ff7cf5d5ade06f2a3e810bf0","src/test/json/v1/healthchipget_2.json":"1e93ee2ab472ee7af58add08b4251e3ce0ad4f986d4325abbf43fd4c9b3dd28f","src/test/json/v1/mod.rs":"5a050f07455e622e35ad79ab1c8a6daf2ea38c4198472e49c6bbfe80538a9e48","src/test/json/v1/pools.json":"0068745327e31853fec051172abb7337f18a4cf9972c51967113d63f4f31f504","src/test/json/v1/power.json":"80534bb4581de7c8b747bf33b5d629b909c6e16a531d18ecb4afd7ffad3f014f","src/test/json/v1/profiles.json":"1f00429036e270daa08f12cd2d7357135070c57acd7a899a3c0af6167fe82abb","src/test/json/v1/stats.json":"2b105f0eb927046c9d2389bde978a43e3d54d12a420dfbe400786bb2f0ae31ca","src/test/json/v1/summary.json":"aaea3378eb7040952037e2f1ef7bd5f20a1b242bf93d4ba0501c46104b0b31a0","src/test/json/v1/temps.json":"1ee781cd2be3ed6a6a07e23be930248735fb51348c160453ba10f6ef71fcb7f1","src/test/json/v1/version.json":"4beb6ca5c0ebf359cee0434fdcc4d0a1a0607436634e46be3fd951e2256595df","src/test/json/v1/voltageget_0.json":"c445fa8674c2542b2d296fbafdd3166c53008dfbd9da8095327217989d37f1da","src/test/json/v1/voltageget_1.json":"96b91c3447dd66e7f1f575ed3b99611062e8b1d516d31422b74e425c46b2f49c","src/test/json/v1/voltageget_2.json":"7d40544021b2e32401135ae333067b770d2d736ada9e60deaca8fd8f5a79a1e3","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"513792d93a2a21d5258d9e6ac0e6dc9e0a6365118934514b4e656792add78066"}
|
||||
{"$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"}
|
||||
@@ -5,6 +5,8 @@ use asic_rs_core::{
|
||||
config::{
|
||||
collector::{ConfigCollector, ConfigExtractor, ConfigField, ConfigLocation},
|
||||
pools::{PoolConfig, PoolGroupConfig},
|
||||
preset::PresetInfo,
|
||||
tuning::TuningConfig,
|
||||
},
|
||||
data::{
|
||||
board::{BoardData, ChipData, MinerControlBoard},
|
||||
@@ -1078,8 +1080,14 @@ impl SetFaultLight for LuxMinerV1 {
|
||||
}
|
||||
}
|
||||
|
||||
/// Parse a LuxOS `profiles` RPC reply into (step name, watts) pairs, keeping only
|
||||
/// profiles that report both a `Step` and a `Watts` value.
|
||||
/// Parse a LuxOS `profiles` RPC reply into (profile name, watts) pairs, keeping
|
||||
/// only profiles that report both a `Profile Name` and a `Watts` value.
|
||||
///
|
||||
/// The identifier is the `Profile Name` (e.g. "480MHz", "default"), NOT the
|
||||
/// `Step`: `profileset` takes the name, and the default profile's step is "0",
|
||||
/// which LuxOS reads as an empty parameter ("Missing profile parameter"), so a
|
||||
/// step-keyed setter can never select the default profile and could strand a
|
||||
/// miner off its factory point.
|
||||
fn parse_profile_watts(profiles: &Value) -> Vec<(String, f64)> {
|
||||
profiles
|
||||
.get("PROFILES")
|
||||
@@ -1087,16 +1095,48 @@ fn parse_profile_watts(profiles: &Value) -> Vec<(String, f64)> {
|
||||
.map(|arr| {
|
||||
arr.iter()
|
||||
.filter_map(|p| {
|
||||
let step = p.get("Step").and_then(Value::as_str)?.to_string();
|
||||
let name = p.get("Profile Name").and_then(Value::as_str)?.to_string();
|
||||
let watts = p.get("Watts").and_then(Value::as_f64)?;
|
||||
Some((step, watts))
|
||||
Some((name, watts))
|
||||
})
|
||||
.collect()
|
||||
})
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
/// Choose the LuxOS profile step to satisfy a watts power limit: the highest-watt
|
||||
/// Parse a LuxOS `profiles` RPC reply into the firmware's tunable presets, one
|
||||
/// per dynamic profile (round 18 / roadmap G3). The `Profile Name` is the
|
||||
/// identifier `profileset` expects; the pretty string summarises the profile's
|
||||
/// watt / hashrate / frequency operating point, and `status` reflects `IsTuned`.
|
||||
fn parse_profiles_to_presets(profiles: &Value) -> Vec<PresetInfo> {
|
||||
profiles
|
||||
.get("PROFILES")
|
||||
.and_then(Value::as_array)
|
||||
.map(|arr| {
|
||||
arr.iter()
|
||||
.filter_map(|p| {
|
||||
let name = p.get("Profile Name").and_then(Value::as_str)?.to_string();
|
||||
let watts = p.get("Watts").and_then(Value::as_f64);
|
||||
let hashrate = p.get("Hashrate").and_then(Value::as_f64);
|
||||
let freq = p.get("Frequency").and_then(Value::as_f64);
|
||||
let pretty = match (watts, hashrate, freq) {
|
||||
(Some(w), Some(h), Some(f)) => Some(format!("{w:.0} W ~ {h:.1} TH @ {f:.0} MHz")),
|
||||
(Some(w), Some(h), None) => Some(format!("{w:.0} W ~ {h:.1} TH")),
|
||||
(Some(w), None, _) => Some(format!("{w:.0} W")),
|
||||
_ => None,
|
||||
};
|
||||
let status = p
|
||||
.get("IsTuned")
|
||||
.and_then(Value::as_bool)
|
||||
.map(|t| if t { "tuned" } else { "untuned" }.to_string());
|
||||
Some(PresetInfo { name, pretty, status })
|
||||
})
|
||||
.collect()
|
||||
})
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
/// Choose the LuxOS profile name to satisfy a watts power limit: the highest-watt
|
||||
/// profile that does not exceed `target_w`, or -- when the target is below every
|
||||
/// profile -- the lowest-watt profile. Returns None only when there are no
|
||||
/// profiles to choose from.
|
||||
@@ -1278,7 +1318,38 @@ impl Validate for LuxMinerV1 {
|
||||
#[async_trait]
|
||||
impl SupportsTuningConfig for LuxMinerV1 {
|
||||
fn supports_tuning_config(&self) -> bool {
|
||||
false
|
||||
true
|
||||
}
|
||||
|
||||
/// LuxOS tunes by named profile (roadmap G3). A `Preset` target is applied
|
||||
/// straight through `profileset`; a `Power` target reuses the watts->profile
|
||||
/// mapping in `set_power_limit`. LuxOS has no hashrate/mining-mode targets and
|
||||
/// per-board manual tuning is not wired, so those targets are refused.
|
||||
async fn set_tuning_config(
|
||||
&self,
|
||||
config: TuningConfig,
|
||||
_scaling_config: Option<asic_rs_core::config::scaling::ScalingConfig>,
|
||||
) -> anyhow::Result<bool> {
|
||||
match config.target {
|
||||
TuningTarget::Preset(name) => {
|
||||
let resp = self.rpc.profileset(&name).await?;
|
||||
Ok(resp
|
||||
.pointer("/STATUS/0/STATUS")
|
||||
.and_then(Value::as_str)
|
||||
.map(|s| matches!(s, "S" | "I"))
|
||||
.unwrap_or(true))
|
||||
}
|
||||
TuningTarget::Power(p) => self.set_power_limit(p).await,
|
||||
TuningTarget::HashRate(_) => {
|
||||
anyhow::bail!("LuxOS does not tune by hashrate target; select a named profile")
|
||||
}
|
||||
TuningTarget::MiningMode(_) => {
|
||||
anyhow::bail!("LuxOS has no mining modes; select a named profile")
|
||||
}
|
||||
TuningTarget::Manual { .. } => {
|
||||
anyhow::bail!("Per-board manual tuning is not wired for LuxOS")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1293,7 +1364,21 @@ impl SupportsTemperatureConfig for LuxMinerV1 {}
|
||||
impl GetTuningPercent for LuxMinerV1 {}
|
||||
impl SetTuningPercent for LuxMinerV1 {}
|
||||
|
||||
impl SupportsPresets for LuxMinerV1 {}
|
||||
#[async_trait]
|
||||
impl SupportsPresets for LuxMinerV1 {
|
||||
fn supports_presets(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// The firmware's tunable profiles, read live from the `profiles` RPC (roadmap
|
||||
/// G3). Never hardcoded -- the step list varies by model and tune state.
|
||||
async fn get_presets(&self) -> Vec<PresetInfo> {
|
||||
match self.rpc.profiles().await {
|
||||
Ok(profiles) => parse_profiles_to_presets(&profiles),
|
||||
Err(_) => Vec::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::sync::{Arc, Mutex};
|
||||
@@ -1315,32 +1400,34 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn power_limit_profile_selection() {
|
||||
// LuxOS reports a ladder of profiles, each with a Step name and Watts.
|
||||
// LuxOS reports a ladder of profiles, each with a Profile Name and Watts.
|
||||
// The top profile is named "default" (its Step is "0", which profileset
|
||||
// rejects -- so selection must key on the name, not the step).
|
||||
let steps = vec![
|
||||
("-16".to_string(), 865.0),
|
||||
("-4".to_string(), 2385.0),
|
||||
("-2".to_string(), 2790.0),
|
||||
("0".to_string(), 3100.0),
|
||||
("190MHz".to_string(), 865.0),
|
||||
("405MHz".to_string(), 2385.0),
|
||||
("455MHz".to_string(), 2790.0),
|
||||
("default".to_string(), 3100.0),
|
||||
];
|
||||
// The highest profile at or below the requested watts limit.
|
||||
assert_eq!(
|
||||
select_profile_at_or_below(&steps, 2500.0).as_deref(),
|
||||
Some("-4")
|
||||
Some("405MHz")
|
||||
);
|
||||
assert_eq!(
|
||||
select_profile_at_or_below(&steps, 2790.0).as_deref(),
|
||||
Some("-2")
|
||||
Some("455MHz")
|
||||
);
|
||||
// Above every profile -> the maximum profile (a limit can't exceed the
|
||||
// hardware's top profile).
|
||||
// Above every profile -> the maximum profile, selected by NAME ("default")
|
||||
// rather than its step "0" (which profileset would reject).
|
||||
assert_eq!(
|
||||
select_profile_at_or_below(&steps, 9000.0).as_deref(),
|
||||
Some("0")
|
||||
Some("default")
|
||||
);
|
||||
// Below every profile -> the minimum profile.
|
||||
assert_eq!(
|
||||
select_profile_at_or_below(&steps, 100.0).as_deref(),
|
||||
Some("-16")
|
||||
Some("190MHz")
|
||||
);
|
||||
// No profiles -> nothing to choose.
|
||||
assert_eq!(select_profile_at_or_below(&[], 2500.0), None);
|
||||
@@ -1353,6 +1440,22 @@ mod tests {
|
||||
assert!(select_profile_at_or_below(&parsed, 2500.0).is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn profiles_parse_to_presets() {
|
||||
// The `profiles` reply becomes one PresetInfo per profile (roadmap G3).
|
||||
let profiles: Value = serde_json::from_str(PROFILES).unwrap();
|
||||
let presets = parse_profiles_to_presets(&profiles);
|
||||
assert_eq!(presets.len(), 25, "one preset per fixture profile");
|
||||
// The factory point is named "default"; its pretty string carries the
|
||||
// watt / hashrate / frequency operating point.
|
||||
let default = presets.iter().find(|p| p.name == "default").unwrap();
|
||||
assert_eq!(default.pretty.as_deref(), Some("2794 W ~ 121.8 TH @ 590 MHz"));
|
||||
// IsTuned maps to the status string.
|
||||
let tuned = presets.iter().find(|p| p.name == "290MHz").unwrap();
|
||||
assert_eq!(tuned.status.as_deref(), Some("tuned"));
|
||||
assert_eq!(default.status.as_deref(), Some("untuned"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
|
||||
async fn test_luxminer_v1() -> anyhow::Result<()> {
|
||||
|
||||
@@ -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":"3a8bdecd1eb271de474b2aca85b5f8e598ba64fe5defc9c8dd9b8c66444a2ed4","src/backends/v1/rpc.rs":"72f9b67c2389ab6e9968e0eb340bd2b6aad9aaf059f4429eb31398863bb87f42","src/backends/v2/mod.rs":"68fd8c1762b424a7785174fdb3ae4fede1d599632657808d4b7c76bcfbfb202c","src/backends/v2/rpc.rs":"52f8d504c236009b020bf33b5550236e36d07b2c73a15bdcfcafa5188e4e1cb6","src/backends/v3/mod.rs":"f19e673c47c2cc366e2ff7782bca93daf750563d62221a12a043b3ee79a15251","src/backends/v3/rpc.rs":"7a5f80aec4af1bcaa0d36e67345aa9acbbd8ead73c0be474f06305358b38e81b","src/error_codes.rs":"b2af610880fb400a9e6297662371a6b3b55077b72cf11115b77fd4d2df44e6a1","src/firmware.rs":"6d002e481ce0a897c0485b9393b0382fcb25811164e893eb8eb67b2ff392ca0d","src/lib.rs":"710b46c9d934f26f900e1366ca1df5f872896e7d8da03569c0f159859e899cc9","src/test/json/mod.rs":"99760925ccfefc40d2455d3567fb1ecfc99e9e55e70478190ef372a954825909","src/test/json/v1/devs.json":"b4fd010f0bae3584efde93387cf2dab5933b499cc30a2dd7635fdc994b56c3b8","src/test/json/v1/get_psu.json":"8c11b6495e0bd5da496dd5c10ca53ec53b2d8fe9a3737f470ec9ce2c1aaf9d99","src/test/json/v1/get_version.json":"c43e947e654792ab191210d50c6f793ee0dd7af41e8cb59f0722b70f32a203bc","src/test/json/v1/mod.rs":"e79509eee78a1fef63735afe385299813726822c8259a02d1dcf5e8b4db9d04e","src/test/json/v1/pools.json":"b570808a3428a0773d7d2ee322150d8fd0794a33804af970300a7fef128a8a01","src/test/json/v1/status.json":"00ec38dd9f980b7ac0ffd6f815374afdbbed98d601bd8ef18bcf0f76ae0aa853","src/test/json/v1/summary.json":"d6e3e75654eb4019e1f479b3d9cf3097130f1afb85dd3338682c094fd4ab498a","src/test/json/v1/summary_with_errors.json":"1ba682f6ad5c43e41ae22a4069d0f52f04da3f07a18031bf4c07e07b3c59cc97","src/test/json/v2/devs.json":"2d203e41ef6ef337c0c81456b73d08730882c3167403c557c3c9776022a972d1","src/test/json/v2/get_error_code.json":"e90b702fd97bceb4f62dcb8228f75ff5ce930290355dca94eefd7192f7f57009","src/test/json/v2/get_error_code_with_errors.json":"6cb6038366eb3835684421c41be0b2b30ae8ce79a7ed51a85f4f52f70da9df16","src/test/json/v2/get_miner_info.json":"55d2af984833a692f502188ae4df4e41bdc10386b47f921c896a452ef1de9062","src/test/json/v2/get_psu.json":"b43086b65897061521d1f6611e200ef372a1724f9ea1876e347c03d5fb19b8f2","src/test/json/v2/get_version.json":"b17e3a81603b43186b2e15745e6822b6c82b3c6f5928b22f84e683d7728dbfcd","src/test/json/v2/mod.rs":"c847205d076323bbd9698e393d241b08f3cf75d32aae86f7058cf8748266b935","src/test/json/v2/pools.json":"926d34e8dae774473ebfec83d4a38e77ca73231708f07683763e212be7af0580","src/test/json/v2/status.json":"fc268cd23864ef99e84813dbf8eb916b2e6f339351a0ee5dab217cbe02569fc3","src/test/json/v2/summary.json":"4e4c01b986e2960893f58d0f1ea4dce23b8ef88db4985348f7f0183eb4818478","src/test/json/v3/get_device_info.json":"83ac22ea9a11adbceb4c963db80aa62d9a2aa50d019a372394dece817d924cda","src/test/json/v3/get_device_info_with_errors.json":"24cee4b7840e87e12147cbfddf6c361f3b378a15bb85330b339d3be9e17cdbd5","src/test/json/v3/get_miner_status_edevs.json":"2d831c06113f555e0988df994c2e602a053a4aea603dded0db8f0f80e191ca5a","src/test/json/v3/get_miner_status_pools.json":"cd65c2efd3a5ce80b57aae46c420298a34ca06df7ac7f8c36fd556217703d242","src/test/json/v3/get_miner_status_summary.json":"799a94ba13ef54aed0f81a3d041d6c1fa263d4183754b384c69ca12d85a8d3ba","src/test/json/v3/mod.rs":"7ea3a8ff1b81c7a5b0f44f7c12dda880a9aeac5b0e6b56ac4fff4f4a7cbfe451","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"c85da6325b62f061327dc5f7605dd3721c823a9e8a2cfd6a356363dfbc84d66e"}
|
||||
{"$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"}
|
||||
@@ -18,6 +18,7 @@ use asic_rs_core::{
|
||||
message::{MessageSeverity, MinerMessage},
|
||||
miner::TuningTarget,
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
psu::PsuInfo,
|
||||
},
|
||||
traits::{miner::*, model::MinerModel},
|
||||
};
|
||||
@@ -193,6 +194,16 @@ impl GetDataLocations for WhatsMinerV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// PSU identity from get_psu (round 17 R5/G15). WhatsMiner exposes the
|
||||
// model + hw/sw version but not a DC output voltage or rated envelope.
|
||||
DataField::Psu => vec![(
|
||||
RPC_GET_PSU,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/Msg"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::Hashboards => vec![(
|
||||
RPC_DEVS,
|
||||
DataExtractor {
|
||||
@@ -463,6 +474,22 @@ impl GetWattage for WhatsMinerV1 {
|
||||
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_psu /Msg -> {model, hw_version, sw_version, ...} (values are strings).
|
||||
// No DC output voltage or rated envelope is exposed, so only identity is set.
|
||||
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("/name")),
|
||||
version: s("/hw_version").or_else(|| s("/sw_version")),
|
||||
voltage_min: None,
|
||||
voltage_max: None,
|
||||
output_voltage: None,
|
||||
output_current: None,
|
||||
};
|
||||
(psu != PsuInfo::default()).then_some(psu)
|
||||
}
|
||||
}
|
||||
impl GetTuningTarget for WhatsMinerV1 {
|
||||
fn parse_tuning_target(&self, data: &HashMap<DataField, Value>) -> Option<TuningTarget> {
|
||||
@@ -805,8 +832,8 @@ mod integration_tests {
|
||||
|
||||
use super::*;
|
||||
use crate::test::json::v1::{
|
||||
DEVS_COMMAND, GET_PSU_COMMAND, GET_VERSION_COMMAND, POOLS_COMMAND, STATUS_COMMAND,
|
||||
SUMMARY_COMMAND, SUMMARY_WITH_ERRORS_COMMAND,
|
||||
DEVS_COMMAND, GET_ERROR_CODE_COMMAND, GET_PSU_COMMAND, GET_VERSION_COMMAND, POOLS_COMMAND,
|
||||
STATUS_COMMAND, SUMMARY_COMMAND, SUMMARY_WITH_ERRORS_COMMAND,
|
||||
};
|
||||
|
||||
#[tokio::test]
|
||||
@@ -943,6 +970,13 @@ mod integration_tests {
|
||||
},
|
||||
Value::from_str(GET_PSU_COMMAND)?,
|
||||
);
|
||||
results.insert(
|
||||
MinerCommand::RPC {
|
||||
command: "get_error_code",
|
||||
parameters: None,
|
||||
},
|
||||
Value::from_str(GET_ERROR_CODE_COMMAND)?,
|
||||
);
|
||||
|
||||
let mock_api = MockAPIClient::new(results);
|
||||
|
||||
|
||||
@@ -20,6 +20,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,
|
||||
@@ -205,6 +206,15 @@ impl GetDataLocations for WhatsMinerV2 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// PSU identity from get_psu (round 17 R5/G15): model + hw/sw version.
|
||||
DataField::Psu => vec![(
|
||||
RPC_GET_PSU,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/Msg"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::Hashboards => vec![(
|
||||
RPC_DEVS,
|
||||
DataExtractor {
|
||||
@@ -471,6 +481,22 @@ impl GetWattage for WhatsMinerV2 {
|
||||
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_psu /Msg -> {model, hw_version, sw_version} (string values). No DC
|
||||
// output voltage or rated envelope is exposed, so only identity is set.
|
||||
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("/name")),
|
||||
version: s("/hw_version").or_else(|| s("/sw_version")),
|
||||
voltage_min: None,
|
||||
voltage_max: None,
|
||||
output_voltage: None,
|
||||
output_current: None,
|
||||
};
|
||||
(psu != PsuInfo::default()).then_some(psu)
|
||||
}
|
||||
}
|
||||
/// Parses tuning target from V2 summary data.
|
||||
/// Low/High → MiningMode, Normal/unknown/empty → Power(limit).
|
||||
|
||||
@@ -0,0 +1,16 @@
|
||||
{
|
||||
"Code": 131,
|
||||
"Description": "",
|
||||
"Msg": {
|
||||
"error_code": [
|
||||
{
|
||||
"110": "2024-06-15 09:15:00"
|
||||
},
|
||||
{
|
||||
"600": "2024-06-15 10:30:00"
|
||||
}
|
||||
]
|
||||
},
|
||||
"STATUS": "S",
|
||||
"When": 1773871985
|
||||
}
|
||||
@@ -6,4 +6,5 @@ pub(crate) const POOLS_COMMAND: &str = include_str!("pools.json");
|
||||
pub(crate) const DEVS_COMMAND: &str = include_str!("devs.json");
|
||||
pub(crate) const GET_VERSION_COMMAND: &str = include_str!("get_version.json");
|
||||
pub(crate) const GET_PSU_COMMAND: &str = include_str!("get_psu.json");
|
||||
pub(crate) const GET_ERROR_CODE_COMMAND: &str = include_str!("get_error_code.json");
|
||||
pub(crate) const SUMMARY_WITH_ERRORS_COMMAND: &str = include_str!("summary_with_errors.json");
|
||||
|
||||