Compare commits
124
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
997771ab5e | ||
|
|
ad31cfbafa | ||
|
|
67a33b8221 | ||
|
|
13b1787e1a | ||
|
|
5a6b895113 | ||
|
|
93c47d90ef | ||
|
|
f6af71138c | ||
|
|
8564ced65d | ||
|
|
78baeb8c31 | ||
|
|
a16a4385f8 | ||
|
|
79f492e5e8 | ||
|
|
b0d81b5d0e | ||
|
|
dccbefc8b7 | ||
|
|
894b22277f | ||
|
|
64e1a9ae2b | ||
|
|
2b07d27c67 | ||
|
|
42509a6383 | ||
|
|
5048156b74 | ||
|
|
5a1a7948b1 | ||
|
|
2c6535f948 | ||
|
|
e3e0dab0ec | ||
|
|
97ea7a4f65 | ||
|
|
b25d6b2a71 | ||
|
|
914fb8bef7 | ||
|
|
6ab645e731 | ||
|
|
b62d64adfb | ||
|
|
fe0c2d43ce | ||
|
|
96f84dc283 | ||
|
|
5aa6349e27 | ||
|
|
724b3da478 | ||
|
|
ef399d0ca5 | ||
|
|
4139576155 | ||
|
|
c616429669 | ||
|
|
9ed94bd01f | ||
|
|
3028ef29fb | ||
|
|
99fb12d725 | ||
|
|
367f07d956 | ||
|
|
29749fee4a | ||
|
|
1f558ef596 | ||
|
|
576f834169 | ||
|
|
093cb62212 | ||
|
|
2e42bedb84 | ||
|
|
0b785eebb5 | ||
|
|
885a71b6fe | ||
|
|
8672507fa4 | ||
|
|
37f1f8433b | ||
|
|
b703c757e4 | ||
|
|
98d891fc67 | ||
|
|
d6e043d79f | ||
|
|
ba286758c7 | ||
|
|
b65e6bc9f1 | ||
|
|
f7aeeaa2eb | ||
|
|
1b0607cbd8 | ||
|
|
7c361aecd9 | ||
|
|
212c9198eb | ||
|
|
be0a57a1d9 | ||
|
|
8bdcd8fb83 | ||
|
|
885a4571ff | ||
|
|
e746efcb94 | ||
|
|
16c9d4962a | ||
|
|
283287f74f | ||
|
|
98f3eb75c0 | ||
|
|
853cb845ff | ||
|
|
e9a3c3a669 | ||
|
|
895081e509 | ||
|
|
b76b74cb63 | ||
|
|
289ad40d86 | ||
|
|
f0c9d4d904 | ||
|
|
f6b5df831e | ||
|
|
d1d7c576cf | ||
|
|
8d19cdeae6 | ||
|
|
52e6093011 | ||
|
|
7fd9c8eee3 | ||
|
|
f302bbbb24 | ||
|
|
b22b494ede | ||
|
|
6c23ce847d | ||
|
|
6a466a611f | ||
|
|
1300d7e372 | ||
|
|
66e4f3d47a | ||
|
|
37028cc3eb | ||
|
|
0e6fd9269b | ||
|
|
3d63bbb3eb | ||
|
|
5d8f14c992 | ||
|
|
6f87f48dca | ||
|
|
7d398caa66 | ||
|
|
96dd7bf6d2 | ||
|
|
59249d44d3 | ||
|
|
f011557cd5 | ||
|
|
d52996c02a | ||
|
|
b59aa8d9c1 | ||
|
|
523ec5fd0b | ||
|
|
a1d8e34390 | ||
|
|
2d6233cdc7 | ||
|
|
eb9dcf830b | ||
|
|
af49d4905d | ||
|
|
8fa9e5d9e6 | ||
|
|
492fe68c9e | ||
|
|
f215cb3196 | ||
|
|
6e3b798273 | ||
|
|
16b55b58e3 | ||
|
|
90a2fe12d5 | ||
|
|
bc38a4a787 | ||
|
|
654b205e00 | ||
|
|
ece32ef55f | ||
|
|
5cd77eb5de | ||
|
|
e7a23faa5a | ||
|
|
e0f9b1ab50 | ||
|
|
323e45ab0e | ||
|
|
6fd329e047 | ||
|
|
7d602d2f03 | ||
|
|
78b9416985 | ||
|
|
d2afef19a9 | ||
|
|
e67ffcd204 | ||
|
|
6cf9ed1620 | ||
|
|
4f21677ae5 | ||
|
|
9f7d8ebb51 | ||
|
|
81d726cca2 | ||
|
|
74ba049b5c | ||
|
|
46a4f58019 | ||
|
|
e9d7200a05 | ||
|
|
544711885e | ||
|
|
7d3cebea79 | ||
|
|
1ce22d9d9f | ||
|
|
4eef88b5df |
@@ -1,9 +1,8 @@
|
||||
name: public-benchmark-pages
|
||||
|
||||
on:
|
||||
workflow_run:
|
||||
workflows: [main-release-gate]
|
||||
types: [completed]
|
||||
schedule:
|
||||
- cron: '*/15 * * * *'
|
||||
workflow_dispatch:
|
||||
|
||||
concurrency:
|
||||
@@ -12,17 +11,17 @@ concurrency:
|
||||
|
||||
jobs:
|
||||
publish:
|
||||
runs-on: alkane-pages
|
||||
runs-on: alkane-verify
|
||||
container:
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:9d2a992bbcb91014af3c85d2e1ec8c5990701cecf83fd06c8d46f9ef13dbd948
|
||||
permissions:
|
||||
contents: read
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Install SSH client
|
||||
run: |
|
||||
if ! command -v ssh >/dev/null 2>&1; then
|
||||
apt-get update -qq
|
||||
apt-get install -y -qq --no-install-recommends openssh-client
|
||||
fi
|
||||
apt-get update -qq
|
||||
apt-get install -y -qq --no-install-recommends openssh-client
|
||||
- name: Render measured benchmark history
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
|
||||
|
||||
@@ -1,9 +1,8 @@
|
||||
name: completed-ci-badge
|
||||
|
||||
on:
|
||||
workflow_run:
|
||||
workflows: [main-release-gate, next-build]
|
||||
types: [completed]
|
||||
schedule:
|
||||
- cron: '*/15 * * * *'
|
||||
workflow_dispatch:
|
||||
|
||||
concurrency:
|
||||
@@ -12,7 +11,7 @@ concurrency:
|
||||
|
||||
jobs:
|
||||
publish:
|
||||
runs-on: alkane-fast
|
||||
runs-on: alkane-ci
|
||||
permissions:
|
||||
actions: read
|
||||
contents: write
|
||||
|
||||
@@ -1,54 +0,0 @@
|
||||
name: source-pr
|
||||
|
||||
on:
|
||||
pull_request:
|
||||
branches: [main, next]
|
||||
workflow_dispatch:
|
||||
|
||||
concurrency:
|
||||
group: alkane-os-source-pr-${{ github.ref }}
|
||||
cancel-in-progress: true
|
||||
|
||||
jobs:
|
||||
source:
|
||||
runs-on: alkane-fast
|
||||
env:
|
||||
CARGO_TARGET_DIR: target
|
||||
CARGO_BUILD_JOBS: 2
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
with:
|
||||
fetch-depth: 0
|
||||
- name: Detect README-only change
|
||||
id: surface
|
||||
run: |
|
||||
surface=full
|
||||
if [ "$GITHUB_EVENT_NAME" = pull_request ] &&
|
||||
{ [ "$GITHUB_BASE_REF" = main ] || [ "$GITHUB_BASE_REF" = next ]; } &&
|
||||
base="$(git merge-base HEAD "origin/$GITHUB_BASE_REF" 2>/dev/null)" &&
|
||||
changed="$(git diff --name-only "$base" HEAD)" &&
|
||||
[ "$changed" = README.md ]; then
|
||||
surface=documentation
|
||||
fi
|
||||
echo "surface=$surface" >> "$GITHUB_OUTPUT"
|
||||
- name: Check README-only change
|
||||
if: steps.surface.outputs.surface == 'documentation'
|
||||
run: |
|
||||
base="$(git merge-base HEAD "origin/$GITHUB_BASE_REF")"
|
||||
git diff --check "$base" HEAD
|
||||
if git grep -nIE '^[[:space:]]*-----BEGIN (RSA |EC |OPENSSH )?PRIVATE KEY-----[[:space:]]*$' --; then
|
||||
echo "private key material found in tracked source" >&2
|
||||
exit 1
|
||||
else
|
||||
status=$?
|
||||
[ "$status" -eq 1 ]
|
||||
fi
|
||||
- name: Check source
|
||||
if: steps.surface.outputs.surface != 'documentation'
|
||||
run: |
|
||||
rustup component add rustfmt
|
||||
cargo fmt --check
|
||||
cargo test --locked
|
||||
- name: Clean generated source check
|
||||
if: always()
|
||||
run: python3 ci/cleanup-generated.py
|
||||
+19
-12
@@ -22,12 +22,12 @@ jobs:
|
||||
fetch-depth: 0
|
||||
- name: Install Pages SSH client
|
||||
run: |
|
||||
if ! command -v ssh >/dev/null 2>&1; then
|
||||
apt-get update -qq
|
||||
apt-get install -y -qq --no-install-recommends openssh-client
|
||||
fi
|
||||
apt-get update -qq
|
||||
apt-get install -y -qq --no-install-recommends openssh-client
|
||||
- name: Install Rust quality tools
|
||||
run: rustup component add rustfmt clippy
|
||||
- name: Image safety gate
|
||||
run: sh ci/check-image-safety.sh
|
||||
- name: Formatting
|
||||
run: cargo fmt --check
|
||||
- name: Last-attempt badge checks
|
||||
@@ -38,8 +38,15 @@ jobs:
|
||||
run: python3 ci/test-metrics.py
|
||||
- name: Release evidence gate checks
|
||||
run: python3 ci/test-conformance.py
|
||||
- name: Research and experiment report checks
|
||||
run: |
|
||||
python3 ci/test-evidence-status.py
|
||||
python3 ci/test-experiment-priority.py
|
||||
python3 ci/test-pr-surface.py
|
||||
- name: Release publication checks
|
||||
run: python3 ci/test-release.py
|
||||
- name: Release version checks
|
||||
run: python3 ci/test-version.py
|
||||
- name: CI cleanup containment checks
|
||||
run: python3 ci/test-cleanup-generated.py
|
||||
- name: Quality
|
||||
@@ -56,18 +63,12 @@ jobs:
|
||||
run: |
|
||||
set -o pipefail
|
||||
cargo test --release --locked -- --ignored --nocapture --test-threads=1 | tee bench-current.txt
|
||||
- name: Restore coverage tool
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
path: /root/.cargo/bin/cargo-llvm-cov
|
||||
key: cargo-llvm-cov-0.8.7-rust-1.97.1-${{ runner.os }}
|
||||
- name: Coverage tool
|
||||
run: |
|
||||
rustup component add llvm-tools-preview
|
||||
if [ "$(cargo llvm-cov --version 2>/dev/null || true)" != 'cargo-llvm-cov 0.8.7' ]; then
|
||||
cargo install --locked --force cargo-llvm-cov --version 0.8.7
|
||||
if ! command -v cargo-llvm-cov >/dev/null 2>&1; then
|
||||
cargo install --locked cargo-llvm-cov --version 0.8.7
|
||||
fi
|
||||
[ "$(cargo llvm-cov --version)" = 'cargo-llvm-cov 0.8.7' ]
|
||||
- name: Unit test coverage
|
||||
run: |
|
||||
mkdir -p coverage
|
||||
@@ -107,6 +108,12 @@ jobs:
|
||||
with:
|
||||
name: alkane-os-benchmark-site-preview
|
||||
path: bench-site/index.html
|
||||
- name: Separate research from release evidence
|
||||
run: python3 ci/evidence_status.py --output evidence-status-current.json
|
||||
- uses: https://github.com/ChristopherHX/gitea-upload-artifact@81f940d004763f986ba3582c007fd842dd5cb0d7
|
||||
with:
|
||||
name: alkane-os-evidence-status
|
||||
path: evidence-status-current.json
|
||||
- name: Pairing and simulator conformance
|
||||
run: python3 ci/check-conformance.py
|
||||
- name: Select release version
|
||||
|
||||
@@ -4,22 +4,21 @@ on:
|
||||
push:
|
||||
branches: [next]
|
||||
|
||||
concurrency:
|
||||
group: alkane-os-next
|
||||
cancel-in-progress: false
|
||||
|
||||
jobs:
|
||||
build:
|
||||
runs-on: alkane-fast
|
||||
runs-on: alkane-verify
|
||||
container:
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:9d2a992bbcb91014af3c85d2e1ec8c5990701cecf83fd06c8d46f9ef13dbd948
|
||||
env:
|
||||
CARGO_TARGET_DIR: target
|
||||
CARGO_BUILD_JOBS: 2
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
with:
|
||||
fetch-depth: 0
|
||||
- name: Image safety gate
|
||||
run: sh ci/check-image-safety.sh
|
||||
- name: Build release candidate
|
||||
run: cargo build --release --locked
|
||||
run: cargo build --release --offline --locked
|
||||
- name: Select candidate version
|
||||
id: version
|
||||
run: python3 ci/version.py next >> "$GITHUB_OUTPUT"
|
||||
|
||||
@@ -0,0 +1,57 @@
|
||||
name: source-pr
|
||||
|
||||
on:
|
||||
pull_request:
|
||||
branches: [next, main]
|
||||
workflow_dispatch:
|
||||
|
||||
concurrency:
|
||||
group: alkane-os-source-pr-${{ github.ref }}
|
||||
cancel-in-progress: true
|
||||
|
||||
jobs:
|
||||
source:
|
||||
runs-on: alkane-fast
|
||||
container:
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:9d2a992bbcb91014af3c85d2e1ec8c5990701cecf83fd06c8d46f9ef13dbd948
|
||||
env:
|
||||
CARGO_TARGET_DIR: target
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
with:
|
||||
fetch-depth: 0
|
||||
- name: Detect changed surface
|
||||
id: surface
|
||||
run: python3 ci/pr_surface.py >> "$GITHUB_OUTPUT"
|
||||
- name: Check patch whitespace
|
||||
run: |
|
||||
if [ "${GITHUB_EVENT_NAME:-}" = pull_request ]; then
|
||||
base="$(git merge-base HEAD "origin/$GITHUB_BASE_REF")"
|
||||
git diff --check "$base" HEAD
|
||||
else
|
||||
git diff --check HEAD^ HEAD
|
||||
fi
|
||||
- name: Check CI and evidence tools
|
||||
if: steps.surface.outputs.surface != 'documentation'
|
||||
run: |
|
||||
python3 -m compileall -q ci
|
||||
for test in ci/test-*.py; do python3 "$test"; done
|
||||
python3 ci/evidence_status.py
|
||||
python3 ci/experiment_priority.py
|
||||
- name: Install source formatter
|
||||
if: steps.surface.outputs.surface == 'rust'
|
||||
run: rustup component add rustfmt
|
||||
- name: Check source formatting
|
||||
if: steps.surface.outputs.surface == 'rust'
|
||||
run: cargo fmt --check
|
||||
- name: Check changed Rust source
|
||||
if: steps.surface.outputs.surface == 'rust'
|
||||
run: |
|
||||
if [ "${GITHUB_BASE_REF:-}" = main ]; then
|
||||
cargo build --release --offline --locked
|
||||
else
|
||||
cargo check --offline --locked
|
||||
fi
|
||||
- name: Clean generated build
|
||||
if: always()
|
||||
run: python3 ci/cleanup-generated.py
|
||||
Generated
+444
-1
@@ -2,11 +2,246 @@
|
||||
# It is not intended for manual editing.
|
||||
version = 4
|
||||
|
||||
[[package]]
|
||||
name = "aho-corasick"
|
||||
version = "1.1.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba"
|
||||
dependencies = [
|
||||
"memchr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "alkane-os"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"flare-ui",
|
||||
"maud",
|
||||
"serde_json",
|
||||
"wschema",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "anes"
|
||||
version = "0.1.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
|
||||
|
||||
[[package]]
|
||||
name = "anstyle"
|
||||
version = "1.0.14"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
|
||||
|
||||
[[package]]
|
||||
name = "autocfg"
|
||||
version = "1.5.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
|
||||
|
||||
[[package]]
|
||||
name = "block-buffer"
|
||||
version = "0.10.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
|
||||
dependencies = [
|
||||
"generic-array",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cast"
|
||||
version = "0.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
|
||||
|
||||
[[package]]
|
||||
name = "cfg-if"
|
||||
version = "1.0.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600"
|
||||
|
||||
[[package]]
|
||||
name = "ciborium"
|
||||
version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
|
||||
dependencies = [
|
||||
"ciborium-io",
|
||||
"ciborium-ll",
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ciborium-io"
|
||||
version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
|
||||
|
||||
[[package]]
|
||||
name = "ciborium-ll"
|
||||
version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
|
||||
dependencies = [
|
||||
"ciborium-io",
|
||||
"half",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clap"
|
||||
version = "4.6.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "aa8876b300ab35ba921adea3dfd70157a46249b33f95c9084ae5709785478946"
|
||||
dependencies = [
|
||||
"clap_builder",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clap_builder"
|
||||
version = "4.6.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ec0797fb7aeb1406c84efac526901f7ec3ead2124f946b494e72879d4b54704d"
|
||||
dependencies = [
|
||||
"anstyle",
|
||||
"clap_lex",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clap_lex"
|
||||
version = "1.1.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1c133bc6a41be0d194c306b5506d15e6feeea7b1d6604bd3f8310dfb2ca96486"
|
||||
|
||||
[[package]]
|
||||
name = "cpufeatures"
|
||||
version = "0.2.17"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
|
||||
dependencies = [
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "criterion"
|
||||
version = "0.5.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
|
||||
dependencies = [
|
||||
"anes",
|
||||
"cast",
|
||||
"ciborium",
|
||||
"clap",
|
||||
"criterion-plot",
|
||||
"is-terminal",
|
||||
"itertools",
|
||||
"num-traits",
|
||||
"once_cell",
|
||||
"oorandom",
|
||||
"regex",
|
||||
"serde",
|
||||
"serde_derive",
|
||||
"serde_json",
|
||||
"tinytemplate",
|
||||
"walkdir",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "criterion-plot"
|
||||
version = "0.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
|
||||
dependencies = [
|
||||
"cast",
|
||||
"itertools",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crunchy"
|
||||
version = "0.2.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
|
||||
|
||||
[[package]]
|
||||
name = "crypto-common"
|
||||
version = "0.1.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
|
||||
dependencies = [
|
||||
"generic-array",
|
||||
"typenum",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "digest"
|
||||
version = "0.10.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
|
||||
dependencies = [
|
||||
"block-buffer",
|
||||
"crypto-common",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "either"
|
||||
version = "1.19.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0e9c71c2167ca323c882b99918929403426e2373ea17242ff5653e0d5e1058be"
|
||||
|
||||
[[package]]
|
||||
name = "flare-ui"
|
||||
version = "0.0.1"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"maud",
|
||||
"serde_json",
|
||||
"wschema",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "generic-array"
|
||||
version = "0.14.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
|
||||
dependencies = [
|
||||
"typenum",
|
||||
"version_check",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "half"
|
||||
version = "2.7.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"crunchy",
|
||||
"zerocopy",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "hermit-abi"
|
||||
version = "0.5.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e17592d60ebacc7d5e169f4663c5f84f9161cc90328abcfe8456f41e4dfcb284"
|
||||
|
||||
[[package]]
|
||||
name = "is-terminal"
|
||||
version = "0.4.17"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46"
|
||||
dependencies = [
|
||||
"hermit-abi",
|
||||
"libc",
|
||||
"windows-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itertools"
|
||||
version = "0.10.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
|
||||
dependencies = [
|
||||
"either",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -15,12 +250,61 @@ version = "1.0.18"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
|
||||
|
||||
[[package]]
|
||||
name = "libc"
|
||||
version = "0.2.191"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "65cd87c9a6d60536580b316ad985726104730a5151c99845f2490428ef91240a"
|
||||
|
||||
[[package]]
|
||||
name = "maud"
|
||||
version = "0.27.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8156733e27020ea5c684db5beac5d1d611e1272ab17901a49466294b84fc217e"
|
||||
dependencies = [
|
||||
"itoa",
|
||||
"maud_macros",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "maud_macros"
|
||||
version = "0.27.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7261b00f3952f617899bc012e3dbd56e4f0110a038175929fa5d18e5a19913ca"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"proc-macro2-diagnostics",
|
||||
"quote",
|
||||
"syn 2.0.119",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "memchr"
|
||||
version = "2.8.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
|
||||
|
||||
[[package]]
|
||||
name = "num-traits"
|
||||
version = "0.2.19"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
|
||||
dependencies = [
|
||||
"autocfg",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "once_cell"
|
||||
version = "1.21.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
|
||||
|
||||
[[package]]
|
||||
name = "oorandom"
|
||||
version = "11.1.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro2"
|
||||
version = "1.0.107"
|
||||
@@ -30,6 +314,18 @@ dependencies = [
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro2-diagnostics"
|
||||
version = "0.10.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.119",
|
||||
"version_check",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "quote"
|
||||
version = "1.0.47"
|
||||
@@ -39,6 +335,44 @@ dependencies = [
|
||||
"proc-macro2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "regex"
|
||||
version = "1.13.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d"
|
||||
dependencies = [
|
||||
"aho-corasick",
|
||||
"memchr",
|
||||
"regex-automata",
|
||||
"regex-syntax",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "regex-automata"
|
||||
version = "0.4.18"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2"
|
||||
dependencies = [
|
||||
"aho-corasick",
|
||||
"memchr",
|
||||
"regex-syntax",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "regex-syntax"
|
||||
version = "0.8.11"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
|
||||
|
||||
[[package]]
|
||||
name = "same-file"
|
||||
version = "1.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
|
||||
dependencies = [
|
||||
"winapi-util",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde"
|
||||
version = "1.0.229"
|
||||
@@ -46,6 +380,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
|
||||
dependencies = [
|
||||
"serde_core",
|
||||
"serde_derive",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -65,7 +400,7 @@ checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
"syn 3.0.9",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -81,6 +416,28 @@ dependencies = [
|
||||
"zmij",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "sha2"
|
||||
version = "0.10.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"cpufeatures",
|
||||
"digest",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "syn"
|
||||
version = "2.0.119"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "syn"
|
||||
version = "3.0.9"
|
||||
@@ -92,12 +449,98 @@ dependencies = [
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tinytemplate"
|
||||
version = "1.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
|
||||
dependencies = [
|
||||
"serde",
|
||||
"serde_json",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "typenum"
|
||||
version = "1.20.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
|
||||
|
||||
[[package]]
|
||||
name = "unicode-ident"
|
||||
version = "1.0.27"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"
|
||||
|
||||
[[package]]
|
||||
name = "version_check"
|
||||
version = "0.9.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
|
||||
|
||||
[[package]]
|
||||
name = "walkdir"
|
||||
version = "2.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
|
||||
dependencies = [
|
||||
"same-file",
|
||||
"winapi-util",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "winapi-util"
|
||||
version = "0.1.11"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
|
||||
dependencies = [
|
||||
"windows-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows-link"
|
||||
version = "0.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
|
||||
|
||||
[[package]]
|
||||
name = "windows-sys"
|
||||
version = "0.61.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
|
||||
dependencies = [
|
||||
"windows-link",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wschema"
|
||||
version = "0.0.1"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"sha2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zerocopy"
|
||||
version = "0.8.63"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e5fe1f8f1b06191a00962174c61aa5005e0bb391a6d80d07e24d115c01a92ed8"
|
||||
dependencies = [
|
||||
"zerocopy-derive",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zerocopy-derive"
|
||||
version = "0.8.63"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "863ad3ac83293fb4d740aedbfdc9240dd8d1a50c1099acd76ce80ce7c7230c7f"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.119",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zmij"
|
||||
version = "1.0.23"
|
||||
|
||||
+12
@@ -10,6 +10,18 @@ name = "alkane_os"
|
||||
|
||||
[dependencies]
|
||||
serde_json = { version = "=1.0.154", features = ["arbitrary_precision"] }
|
||||
flare-ui = { path = "third-party/flare-ui/crates/flare-ui" }
|
||||
wschema = { path = "third-party/flare-ui/crates/wschema" }
|
||||
maud = "0.27"
|
||||
|
||||
[workspace]
|
||||
members = ["third-party/flare-ui/crates/flare-ui", "third-party/flare-ui/crates/wschema"]
|
||||
|
||||
[workspace.package]
|
||||
version = "0.0.1"
|
||||
edition = "2021"
|
||||
rust-version = "1.85"
|
||||
license = "MIT"
|
||||
|
||||
[profile.release]
|
||||
lto = true
|
||||
|
||||
@@ -21,6 +21,9 @@ Stratum V1. Tests have replayed 33 captured BM1366 shares and one BM1362
|
||||
share to a loopback pool with matching ACCEPT responses. Production board
|
||||
control is still under development.
|
||||
|
||||
The BM1370 module encodes a captured S21 Pro job and parses captured nonce
|
||||
frames. Work-ID mapping, chain control, and pool acceptance remain open.
|
||||
|
||||
The HAL client requests PSU shutdown on sensor faults and reserves work IDs
|
||||
until a confirmed reset or shutdown. A production backend still needs a
|
||||
power lease, watchdog, and validated temperature limits. SHA-256d and
|
||||
|
||||
@@ -5,6 +5,17 @@ currently fails because the simulator and bench evidence producer is not yet
|
||||
implemented. A green Rust build, host HAL replay probe, or rootfs archive does
|
||||
not fill any cell.
|
||||
|
||||
`research-evidence.json` records scoped historical observations with source
|
||||
hashes. `evidence_status.py` reports those separately from declarations in
|
||||
`conformance.json`. Neither research claims nor manifest declarations count
|
||||
as verified release cells. The current-run checker below is the only release
|
||||
validator. `experiment-queue.json` ranks the next protocol and controller
|
||||
experiments by the number of affected cells; blocked work stays visible.
|
||||
The status report names catalog, decoded protocol, stock simulator boot,
|
||||
captured-nonce pool acceptance, physical lifecycle, and complete-cell levels.
|
||||
It leaves current-run verified counts unset; the conformance checker certifies
|
||||
the full cells separately.
|
||||
|
||||
Each CI run must put a JSON report at
|
||||
`ci/evidence/<GITHUB_RUN_ID>/<board>/<chip>.json`. The report binds its
|
||||
`run_id`, `source_commit`, `os_binary_sha256`, `board`, and `chip` to the
|
||||
|
||||
@@ -0,0 +1,92 @@
|
||||
#!/bin/sh
|
||||
# Refuse to publish an OS image whose payload would not fit, or would not boot,
|
||||
# on the board it claims to target.
|
||||
#
|
||||
# The SDK's planner refuses a bad payload before it is ever written; this is the
|
||||
# other half of the same rule, applied to the artefacts the OS repo produces. A
|
||||
# wrongly-formatted image is not a firmware bug a board survives: the vendor SPL
|
||||
# only parses a legacy uImage, stock U-Boot only parses a legacy uImage, and a
|
||||
# raw zImage in the wrong slot boots nothing.
|
||||
#
|
||||
# Checks, per payload file found:
|
||||
# * magic matches the format its name claims
|
||||
# * size fits the target partition
|
||||
# A file that is present but unreadable, or that claims a format it does not
|
||||
# have, fails the gate. When no payload artefacts exist yet the gate says so and
|
||||
# passes, so it can be wired into CI before the first image is built.
|
||||
set -eu
|
||||
|
||||
fail=0
|
||||
note() { printf ' %s\n' "$*"; }
|
||||
bad() { printf ' FAIL %s\n' "$*"; fail=1; }
|
||||
|
||||
# name-glob|format|max-bytes
|
||||
RULES='
|
||||
kernel-mtd8.zImage|zimage|20971520
|
||||
zImage|zimage|20971520
|
||||
Image|zimage|16777216
|
||||
dtb-mtd6.dtb|fdt|131072
|
||||
am335x-alkane.dtb|fdt|131072
|
||||
meson-axg-alkane.dtb|fdt|131072
|
||||
ramdisk-mtd7.uimg|uimage|5242880
|
||||
uramdisk.image.gz|uimage|8388608
|
||||
uboot-mtd4.img|uimage|1835008
|
||||
'
|
||||
|
||||
check_file() {
|
||||
file=$1
|
||||
name=$(basename "$file")
|
||||
size=$(wc -c < "$file")
|
||||
rule=$(printf '%s\n' "$RULES" | awk -F'|' -v n="$name" '$1 == n { print; exit }')
|
||||
if [ -z "$rule" ]; then
|
||||
return 0
|
||||
fi
|
||||
format=$(printf '%s' "$rule" | cut -d'|' -f2)
|
||||
limit=$(printf '%s' "$rule" | cut -d'|' -f3)
|
||||
if [ "$size" -gt "$limit" ]; then
|
||||
bad "$name is $size bytes, larger than its $limit-byte partition"
|
||||
return 0
|
||||
fi
|
||||
magic=$(od -An -tx1 -N4 "$file" | tr -d ' \n')
|
||||
case "$format" in
|
||||
fdt)
|
||||
[ "$magic" = "d00dfeed" ] || bad "$name does not start with the FDT magic (got $magic)"
|
||||
;;
|
||||
uimage)
|
||||
[ "$magic" = "27051956" ] || bad "$name is not a legacy uImage (got $magic)"
|
||||
;;
|
||||
zimage)
|
||||
# ARM zImage: 0x016f2818 at offset 0x24, stored little-endian on disk.
|
||||
z=$(od -An -tx1 -j36 -N4 "$file" | tr -d ' \n')
|
||||
[ "$z" = "18286f01" ] || bad "$name is not a raw ARM zImage (got $z at 0x24)"
|
||||
;;
|
||||
esac
|
||||
note "$name: $format, $size bytes"
|
||||
}
|
||||
|
||||
echo "image-safety: scanning for payload artefacts"
|
||||
|
||||
found=0
|
||||
for dir in "${1:-.}" dist build/out target/payload; do
|
||||
[ -d "$dir" ] || continue
|
||||
for file in $(find "$dir" -maxdepth 3 -type f \
|
||||
\( -name 'kernel-mtd8.zImage' -o -name 'zImage' -o -name 'Image' \
|
||||
-o -name 'dtb-mtd6.dtb' -o -name 'am335x-alkane.dtb' \
|
||||
-o -name 'meson-axg-alkane.dtb' -o -name 'ramdisk-mtd7.uimg' \
|
||||
-o -name 'uramdisk.image.gz' -o -name 'uboot-mtd4.img' \) 2>/dev/null); do
|
||||
found=$((found + 1))
|
||||
check_file "$file"
|
||||
done
|
||||
done
|
||||
|
||||
if [ "$found" -eq 0 ]; then
|
||||
note "no payload artefacts present in this checkout"
|
||||
else
|
||||
note "$found payload file(s) checked"
|
||||
fi
|
||||
|
||||
if [ "$fail" -ne 0 ]; then
|
||||
echo "image-safety: FAILED - do not publish this image" >&2
|
||||
exit 1
|
||||
fi
|
||||
echo "image-safety: OK"
|
||||
@@ -0,0 +1,37 @@
|
||||
#!/bin/sh
|
||||
# Report what the schema-driven UI costs in a firmware binary.
|
||||
#
|
||||
# Two binaries are built for the same target with the same profile: one renders
|
||||
# a page through flare-ui and wschema, the other renders the same shape with only
|
||||
# maud and serde_json. The difference is the marginal cost of the dependency, and
|
||||
# it is the number a release decision should be made on.
|
||||
#
|
||||
# Measured on armv7-unknown-linux-gnueabihf, release, stripped:
|
||||
# ui-baseline 323 KiB
|
||||
# ui-spike 771 KiB (marginal: ~448 KiB)
|
||||
set -eu
|
||||
ROOT=${1:-$(cd "$(dirname "$0")/.." && pwd)}
|
||||
TARGET=${ALKANE_SIZE_TARGET:-armv7-unknown-linux-gnueabihf}
|
||||
OUT=${CARGO_TARGET_DIR:-/tmp/alkane-os-target}
|
||||
STRIP=${ALKANE_STRIP:-arm-linux-gnueabihf-strip}
|
||||
|
||||
cd "$ROOT"
|
||||
# The workspace mount drops the executable bit on build scripts, so build into
|
||||
export CARGO_TARGET_DIR="$OUT"
|
||||
CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABIHF_LINKER=${ALKANE_ARM_LINKER:-arm-linux-gnueabihf-gcc} \
|
||||
cargo build --release --offline --target "$TARGET" --bins >/dev/null
|
||||
|
||||
sizes=""
|
||||
for bin in ui-baseline ui-spike; do
|
||||
src="$OUT/$TARGET/release/$bin"
|
||||
[ -f "$src" ] || { echo "ui-size: $bin was not built" >&2; exit 1; }
|
||||
cp "$src" "/tmp/$bin.size"
|
||||
"$STRIP" "/tmp/$bin.size" 2>/dev/null || true
|
||||
bytes=$(wc -c < "/tmp/$bin.size")
|
||||
sizes="$sizes $bin=$bytes"
|
||||
printf ' %-12s %4d KiB\n' "$bin" $((bytes / 1024))
|
||||
done
|
||||
|
||||
base=$(printf '%s' "$sizes" | sed 's/.*ui-baseline=\([0-9]*\).*/\1/')
|
||||
spike=$(printf '%s' "$sizes" | sed 's/.*ui-spike=\([0-9]*\).*/\1/')
|
||||
printf ' marginal %4d KiB\n' $(((spike - base) / 1024))
|
||||
@@ -10,7 +10,8 @@ import sys
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
DIRECTORIES = ("target", "coverage", "dist", "bench-site")
|
||||
FILES = ("tests-current.txt", "bench-current.txt", "quality-current.json")
|
||||
FILES = ("tests-current.txt", "bench-current.txt", "quality-current.json",
|
||||
"evidence-status-current.json")
|
||||
|
||||
|
||||
def cleanup() -> None:
|
||||
|
||||
@@ -0,0 +1,84 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Summarize research separately from current-run release conformance."""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
from pathlib import Path
|
||||
import re
|
||||
|
||||
|
||||
LEVELS = {"catalogued", "protocol_decoded"}
|
||||
DIGEST = re.compile(r"[0-9a-f]{64}\Z")
|
||||
|
||||
|
||||
def summarize(matrix: dict, research: dict) -> dict:
|
||||
if matrix.get("schema") != 1 or research.get("schema") != 1:
|
||||
raise ValueError("unsupported evidence schema")
|
||||
boards = matrix["boards"]
|
||||
chips = matrix["chips"]
|
||||
vendors = matrix["vendors"]
|
||||
expected = {(board, chip) for board in boards for chip in chips
|
||||
if vendors[board] == vendors[chip]}
|
||||
rows = matrix["targets"]
|
||||
actual = [(row["board"], row["chip"]) for row in rows]
|
||||
if set(actual) != expected or len(actual) != len(expected) or len(actual) != 64:
|
||||
raise ValueError("release target matrix is incomplete or duplicated")
|
||||
levels = {"catalogued": set(), "protocol_decoded": set()}
|
||||
for claim in research["claims"]:
|
||||
cell = claim["board"], claim["chip"]
|
||||
level = claim["level"]
|
||||
if cell not in expected or level not in LEVELS:
|
||||
raise ValueError("research claim is outside target matrix or level")
|
||||
if not isinstance(claim.get("scope"), str) or not claim["scope"].strip():
|
||||
raise ValueError("research claim lacks scope")
|
||||
if not isinstance(claim.get("source"), str) or not claim["source"].strip():
|
||||
raise ValueError("research claim lacks provenance")
|
||||
if not isinstance(claim.get("sha256"), str) or not DIGEST.fullmatch(claim["sha256"]):
|
||||
raise ValueError("research claim lacks a source digest")
|
||||
levels[level].add(cell)
|
||||
declared = {
|
||||
"stock_result": sum(row.get("stock_result") in {"mines", "rejects"} for row in rows),
|
||||
"alkane_share_capture": sum(bool(row.get("alkane_share_accept_capture")) for row in rows),
|
||||
"bench_validation": sum(bool(row.get("bench_validation")) for row in rows),
|
||||
}
|
||||
evidence_levels = {
|
||||
"catalogued": {"research_claims": len(levels["catalogued"])},
|
||||
"protocol_decoded": {"research_claims": len(levels["protocol_decoded"])},
|
||||
"stock_simulator_boot": {"manifest_claims_unverified": declared["stock_result"],
|
||||
"current_run_verified": None},
|
||||
"captured_nonce_pool_accept": {
|
||||
"manifest_claims_unverified": declared["alkane_share_capture"],
|
||||
"current_run_verified": None},
|
||||
"physical_install_update_uninstall_recovery": {
|
||||
"manifest_claims_unverified": declared["bench_validation"],
|
||||
"current_run_verified": None},
|
||||
"full_release_cell": {"current_run_verified": None},
|
||||
}
|
||||
return {
|
||||
"schema": 1,
|
||||
"target_cells": len(expected),
|
||||
"research_only": {key: len(value) for key, value in levels.items()},
|
||||
"evidence_levels": evidence_levels,
|
||||
"release_manifest_declarations_unverified": declared,
|
||||
"verified_release_cells": None,
|
||||
"note": "Only check-conformance.py may verify current-run artifacts; research claims never satisfy a release cell",
|
||||
}
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("--matrix", type=Path, default=Path("ci/conformance.json"))
|
||||
parser.add_argument("--research", type=Path, default=Path("ci/research-evidence.json"))
|
||||
parser.add_argument("--output", type=Path)
|
||||
args = parser.parse_args()
|
||||
report = summarize(json.loads(args.matrix.read_text()), json.loads(args.research.read_text()))
|
||||
output = json.dumps(report, indent=2, sort_keys=True) + "\n"
|
||||
if args.output:
|
||||
args.output.write_text(output)
|
||||
else:
|
||||
print(output, end="")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,65 @@
|
||||
{
|
||||
"schema": 1,
|
||||
"experiments": [
|
||||
{
|
||||
"id": "am335x-original-nand-boot",
|
||||
"kind": "controller",
|
||||
"board": "am335x-bb",
|
||||
"chip": null,
|
||||
"psu": null,
|
||||
"state": "ready_local",
|
||||
"next_evidence": "Boot hash-pinned stock NAND through the original ROM and SPL path; record the first failing register",
|
||||
"blocker": null
|
||||
},
|
||||
{
|
||||
"id": "bm1368-command-and-nonce",
|
||||
"kind": "chip",
|
||||
"board": null,
|
||||
"chip": "BM1368",
|
||||
"psu": null,
|
||||
"state": "needs_machine",
|
||||
"next_evidence": "Capture real BM1368 enumeration, job, and nonce frames on a recovered test unit",
|
||||
"blocker": "No verified BM1368 silicon candidate in the current inventory"
|
||||
},
|
||||
{
|
||||
"id": "zynq-bm1366-fpga-window",
|
||||
"kind": "transport",
|
||||
"board": "zynq-7010",
|
||||
"chip": "BM1366",
|
||||
"psu": "APW121215d/e",
|
||||
"state": "needs_identity",
|
||||
"next_evidence": "Read a bounded FPGA register/FIFO trace on a verified rooted test unit",
|
||||
"blocker": "Historical mule 10.1.2.137 now reports BTM_S21PRO; do not infer BM1366 from its address"
|
||||
},
|
||||
{
|
||||
"id": "a113d-bm1370-apw17-voltage",
|
||||
"kind": "psu",
|
||||
"board": "a113d",
|
||||
"chip": "BM1370",
|
||||
"psu": "APW171215a/c",
|
||||
"state": "needs_identity",
|
||||
"next_evidence": "Decode captured GPIO bit-bang command and read-only voltage response against an independent meter",
|
||||
"blocker": "Historical 10.4.0.192 unit is not currently reachable for confirmation"
|
||||
},
|
||||
{
|
||||
"id": "h6-kf1950-power-and-asic",
|
||||
"kind": "chip_psu",
|
||||
"board": "allwinner-h6",
|
||||
"chip": "KF1950",
|
||||
"psu": "unknown",
|
||||
"state": "needs_machine",
|
||||
"next_evidence": "Observe actual ASIC and PSU bus frames on a matched miner before modeling either device",
|
||||
"blocker": "Current H6 bench board is bare and its recovery RX path is unproven"
|
||||
},
|
||||
{
|
||||
"id": "s19-88-chain-enumeration",
|
||||
"kind": "topology_psu",
|
||||
"board": "a113d",
|
||||
"chip": "BM1362",
|
||||
"psu": "APW121417b",
|
||||
"state": "needs_identity",
|
||||
"next_evidence": "Capture the 88-chip address walk and read-only PSU identity on a rooted matched test unit",
|
||||
"blocker": "10.7.1.190 reports BTM_S19_88, but its SSH key and physical recovery are unverified"
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Rank representative experiments without changing the 64-cell release gate."""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
STATES = {"ready_local", "needs_identity", "needs_machine"}
|
||||
|
||||
|
||||
def rank(matrix: dict, queue: dict) -> list[dict]:
|
||||
if queue.get("schema") != 1 or matrix.get("schema") != 1:
|
||||
raise ValueError("unsupported experiment schema")
|
||||
targets = {(row["board"], row["chip"]) for row in matrix["targets"]}
|
||||
if len(targets) != 64 or len(matrix["targets"]) != 64:
|
||||
raise ValueError("expected 64 unique release targets")
|
||||
seen = set()
|
||||
result = []
|
||||
for experiment in queue["experiments"]:
|
||||
ident = experiment["id"]
|
||||
if ident in seen:
|
||||
raise ValueError("duplicate experiment id")
|
||||
seen.add(ident)
|
||||
state = experiment["state"]
|
||||
if state not in STATES:
|
||||
raise ValueError("unknown experiment state")
|
||||
board, chip = experiment["board"], experiment["chip"]
|
||||
if board is None and chip is None:
|
||||
raise ValueError("experiment has no target selector")
|
||||
affected = sorted((b, c) for b, c in targets
|
||||
if (board is None or board == b) and (chip is None or chip == c))
|
||||
if not affected:
|
||||
raise ValueError("experiment selects no same-vendor target")
|
||||
if not experiment.get("next_evidence"):
|
||||
raise ValueError("experiment lacks a measurable next result")
|
||||
if state != "ready_local" and not experiment.get("blocker"):
|
||||
raise ValueError("blocked experiment lacks a blocker")
|
||||
result.append({"id": ident, "kind": experiment["kind"], "state": state,
|
||||
"affected_release_cells": len(affected), "board": board,
|
||||
"chip": chip, "psu": experiment["psu"],
|
||||
"next_evidence": experiment["next_evidence"],
|
||||
"blocker": experiment["blocker"]})
|
||||
return sorted(result, key=lambda row: (row["state"] != "ready_local",
|
||||
-row["affected_release_cells"], row["id"]))
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("--matrix", type=Path, default=Path("ci/conformance.json"))
|
||||
parser.add_argument("--queue", type=Path, default=Path("ci/experiment-queue.json"))
|
||||
args = parser.parse_args()
|
||||
for item in rank(json.loads(args.matrix.read_text()), json.loads(args.queue.read_text())):
|
||||
print(f"{item['id']}: {item['state']}, {item['affected_release_cells']} cells")
|
||||
print(f" next: {item['next_evidence']}")
|
||||
if item["blocker"]:
|
||||
print(f" blocked: {item['blocker']}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -55,8 +55,8 @@ def publish(api: str, repo: str, branch: str, data: bytes, token: str) -> None:
|
||||
|
||||
|
||||
def main() -> None:
|
||||
if os.environ["GITHUB_EVENT_NAME"] not in ("workflow_run", "workflow_dispatch"):
|
||||
raise RuntimeError("badge publisher must follow CI completion or manual dispatch")
|
||||
if os.environ["GITHUB_EVENT_NAME"] not in ("schedule", "workflow_dispatch"):
|
||||
raise RuntimeError("badge publisher must run on a timer or manual dispatch")
|
||||
if os.environ["GITHUB_REF"] != "refs/heads/main":
|
||||
raise RuntimeError("badge publisher must use the main branch")
|
||||
repo = os.environ["GITHUB_REPOSITORY"]
|
||||
|
||||
@@ -0,0 +1,68 @@
|
||||
#!/bin/sh
|
||||
# Build an .afw firmware package for one control board and architecture.
|
||||
#
|
||||
# Modelled on the Warden `.wfw` bundle (scada/flare-edge/docs/firmware-format.md):
|
||||
# one file, a strict POSIX ustar tar, a JSON manifest first, then the payload,
|
||||
# with the payload's size and sha256 in the manifest so the device can verify
|
||||
# before it touches flash.
|
||||
#
|
||||
# Differences from .wfw, both deliberate:
|
||||
#
|
||||
# * the payload is COMPRESSED (`payload.tar.gz`) because these images ship to
|
||||
# boards over metered links, and a firmware bundle is mostly redundant;
|
||||
# * the manifest carries `board` and `arch`, and both go in the file name, so a
|
||||
# bundle can never be mistaken for another board family. Flashing the wrong
|
||||
# family is how boards are lost.
|
||||
#
|
||||
# Signature: `.wfw` carries an Ed25519 detached signature. We have no release
|
||||
# key yet, so `.afw` currently ships `members=2` and says so in the manifest
|
||||
# (`signature: "unsigned"`). Do not claim integrity beyond the sha256 until a
|
||||
# key exists.
|
||||
#
|
||||
# usage: make-afw.sh BOARD ARCH VERSION INPUT_DIR [OUTPUT_DIR]
|
||||
# e.g. make-afw.sh am335x-bb armv7 0.1.0 /tmp/release
|
||||
set -eu
|
||||
|
||||
BOARD=${1:?board family, e.g. am335x-bb}
|
||||
ARCH=${2:?architecture, e.g. armv7 or aarch64}
|
||||
VERSION=${3:?version, e.g. 0.1.0}
|
||||
INPUT=${4:?directory holding the release files}
|
||||
OUTPUT=${5:-dist}
|
||||
|
||||
mkdir -p "$OUTPUT"
|
||||
WORK=$(mktemp -d)
|
||||
trap 'rm -rf "$WORK"' EXIT
|
||||
|
||||
# The payload is a tar of the release tree, gzipped at maximum.
|
||||
tar --format=ustar --owner=0 --group=0 --numeric-owner \
|
||||
--create --file "$WORK/payload.tar" -C "$INPUT" .
|
||||
gzip -9 -n -c "$WORK/payload.tar" > "$WORK/payload.tar.gz"
|
||||
|
||||
PAYLOAD_SIZE=$(wc -c < "$WORK/payload.tar.gz")
|
||||
PAYLOAD_SHA=$(sha256sum "$WORK/payload.tar.gz" | cut -d' ' -f1)
|
||||
BUILD_DATE=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
|
||||
|
||||
cat > "$WORK/manifest.json" <<MANIFEST
|
||||
{
|
||||
"schema": 1,
|
||||
"format": "afw",
|
||||
"board": "$BOARD",
|
||||
"arch": "$ARCH",
|
||||
"version": "$VERSION",
|
||||
"build_date": "$BUILD_DATE",
|
||||
"compression": "gzip",
|
||||
"signature": "unsigned",
|
||||
"payload": {
|
||||
"file": "payload.tar.gz",
|
||||
"size": $PAYLOAD_SIZE,
|
||||
"sha256": "$PAYLOAD_SHA"
|
||||
}
|
||||
}
|
||||
MANIFEST
|
||||
|
||||
NAME="alkane-os-$VERSION-$BOARD-$ARCH.afw"
|
||||
(cd "$WORK" && tar --format=ustar --owner=0 --group=0 --numeric-owner \
|
||||
--create --file "$OUTPUT/$NAME" manifest.json payload.tar.gz)
|
||||
printf '%s\n' "$OUTPUT/$NAME"
|
||||
printf 'board %s\narch %s\npayload %s bytes\nsha256 %s\n' \
|
||||
"$BOARD" "$ARCH" "$PAYLOAD_SIZE" "$PAYLOAD_SHA"
|
||||
@@ -0,0 +1,47 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Select a safe fast PR check from the exact merge-base diff."""
|
||||
|
||||
import os
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
|
||||
|
||||
def classify(paths: list[str]) -> str:
|
||||
if not paths:
|
||||
return "rust"
|
||||
docs = {"README.md", "LICENSE", "AGENTS.md", "ci/CONFORMANCE.md"}
|
||||
def is_doc(path: str) -> bool:
|
||||
return path in docs or path.startswith("docs/") and path.endswith(".md")
|
||||
def is_tool(path: str) -> bool:
|
||||
return (path.startswith("ci/") and Path(path).suffix in {".py", ".json"}
|
||||
or path.startswith(".gitea/workflows/") and path.endswith(".yml"))
|
||||
if all(is_doc(path) for path in paths):
|
||||
return "documentation"
|
||||
if all(is_doc(path) or is_tool(path) for path in paths):
|
||||
return "tooling"
|
||||
return "rust"
|
||||
|
||||
|
||||
def changed_paths() -> list[str]:
|
||||
if os.environ.get("GITHUB_EVENT_NAME") != "pull_request":
|
||||
return []
|
||||
base = os.environ.get("GITHUB_BASE_REF")
|
||||
if base not in {"next", "main"}:
|
||||
return []
|
||||
try:
|
||||
merge_base = subprocess.check_output(
|
||||
["git", "merge-base", "HEAD", f"origin/{base}"], cwd=ROOT).strip()
|
||||
diff = subprocess.check_output(
|
||||
["git", "diff", "--name-only", "-z", merge_base, "HEAD"], cwd=ROOT)
|
||||
return [path.decode() for path in diff.split(b"\0") if path]
|
||||
except (OSError, UnicodeError, subprocess.CalledProcessError):
|
||||
return []
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
with open(os.environ["GITHUB_OUTPUT"], "a") as output:
|
||||
output.write(f"surface={classify(changed_paths())}\n")
|
||||
@@ -21,12 +21,8 @@ PAGES_HOST_KEY = "[gitea.bluefla.re]:2222 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIO
|
||||
|
||||
def run(*args: str, env: dict[str, str] | None = None,
|
||||
cwd: Path | None = None) -> subprocess.CompletedProcess[str]:
|
||||
result = subprocess.run(args, env=env, cwd=cwd, text=True,
|
||||
capture_output=True, check=False)
|
||||
if result.returncode:
|
||||
detail = result.stderr.strip()[:2000]
|
||||
raise RuntimeError(f"{args[0]} {args[1]} exited {result.returncode}: {detail}")
|
||||
return result
|
||||
return subprocess.run(args, env=env, cwd=cwd, text=True,
|
||||
capture_output=True, check=True)
|
||||
|
||||
|
||||
def current_main_sha() -> str:
|
||||
|
||||
@@ -0,0 +1,21 @@
|
||||
{
|
||||
"schema": 1,
|
||||
"claims": [
|
||||
{
|
||||
"board": "a113d",
|
||||
"chip": "BM1366",
|
||||
"level": "protocol_decoded",
|
||||
"source": "miner-firmware/firmware-analysis/prong-b/aml-112/fullcov/capC1.strace",
|
||||
"sha256": "05303e93f6d00433a6db5a9ee973b6cdb0351f3efa35d293dd172ede7da89d54",
|
||||
"scope": "Historical BM1366 UART enumeration and nonce frames on an A113D S19k Pro"
|
||||
},
|
||||
{
|
||||
"board": "zynq-7010",
|
||||
"chip": "BM1366",
|
||||
"level": "catalogued",
|
||||
"source": "miner-firmware/firmware-analysis/prong-b/xil-137/fullcov/capC1.strace",
|
||||
"sha256": "3daa3f7381580ef87f3b5925d5a03fdb4d2e7cd93a82b943ef2578da3d545607",
|
||||
"scope": "Historical sensor and board observations; FPGA chip data path was not captured"
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Research observations cannot promote a target into release conformance."""
|
||||
|
||||
import copy
|
||||
import importlib.util
|
||||
import json
|
||||
from pathlib import Path
|
||||
import unittest
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parent
|
||||
spec = importlib.util.spec_from_file_location("evidence_status", ROOT / "evidence_status.py")
|
||||
status = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(status)
|
||||
MATRIX = json.loads((ROOT / "conformance.json").read_text())
|
||||
RESEARCH = json.loads((ROOT / "research-evidence.json").read_text())
|
||||
|
||||
|
||||
class EvidenceStatusTest(unittest.TestCase):
|
||||
def test_historical_protocol_does_not_satisfy_release(self):
|
||||
report = status.summarize(MATRIX, RESEARCH)
|
||||
self.assertEqual(report["target_cells"], 64)
|
||||
self.assertEqual(report["research_only"], {"catalogued": 1, "protocol_decoded": 1})
|
||||
self.assertIsNone(report["verified_release_cells"])
|
||||
self.assertEqual(sum(report["release_manifest_declarations_unverified"].values()), 0)
|
||||
for level in ("stock_simulator_boot", "captured_nonce_pool_accept",
|
||||
"physical_install_update_uninstall_recovery", "full_release_cell"):
|
||||
self.assertIsNone(report["evidence_levels"][level]["current_run_verified"])
|
||||
|
||||
def test_rejects_missing_cell_and_unsupported_claim(self):
|
||||
matrix = copy.deepcopy(MATRIX)
|
||||
matrix["targets"].pop()
|
||||
with self.assertRaisesRegex(ValueError, "incomplete"):
|
||||
status.summarize(matrix, RESEARCH)
|
||||
research = copy.deepcopy(RESEARCH)
|
||||
research["claims"][0]["level"] = "pool_accept"
|
||||
with self.assertRaisesRegex(ValueError, "outside target matrix or level"):
|
||||
status.summarize(MATRIX, research)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,41 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Representative experiments preserve the full release target set."""
|
||||
|
||||
import copy
|
||||
import importlib.util
|
||||
import json
|
||||
from pathlib import Path
|
||||
import unittest
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parent
|
||||
spec = importlib.util.spec_from_file_location("experiment_priority", ROOT / "experiment_priority.py")
|
||||
priority = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(priority)
|
||||
MATRIX = json.loads((ROOT / "conformance.json").read_text())
|
||||
QUEUE = json.loads((ROOT / "experiment-queue.json").read_text())
|
||||
|
||||
|
||||
class ExperimentPriorityTest(unittest.TestCase):
|
||||
def test_local_boot_model_ranks_first_without_reducing_gate(self):
|
||||
ordered = priority.rank(MATRIX, QUEUE)
|
||||
self.assertEqual(ordered[0]["id"], "am335x-original-nand-boot")
|
||||
self.assertEqual(ordered[0]["affected_release_cells"], 13)
|
||||
self.assertEqual(len(MATRIX["targets"]), 64)
|
||||
self.assertEqual(next(row for row in ordered if row["id"] == "bm1368-command-and-nonce")
|
||||
["affected_release_cells"], 4)
|
||||
|
||||
def test_no_selector_or_unexplained_blocker(self):
|
||||
queue = copy.deepcopy(QUEUE)
|
||||
queue["experiments"][0]["board"] = None
|
||||
with self.assertRaisesRegex(ValueError, "no target selector"):
|
||||
priority.rank(MATRIX, queue)
|
||||
queue = copy.deepcopy(QUEUE)
|
||||
queue["experiments"][1]["blocker"] = None
|
||||
with self.assertRaisesRegex(ValueError, "lacks a blocker"):
|
||||
priority.rank(MATRIX, queue)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -36,7 +36,7 @@ assert b">fail</text>" in svg
|
||||
assert b"#d1242f" in svg
|
||||
assert b">pass</text>" in module.badge("next", "success", 108)
|
||||
environment = {
|
||||
"GITHUB_EVENT_NAME": "workflow_run",
|
||||
"GITHUB_EVENT_NAME": "schedule",
|
||||
"GITHUB_REF": "refs/heads/main",
|
||||
"GITHUB_REPOSITORY": "owner/repo",
|
||||
"GITHUB_API_URL": "https://example.invalid/api/v1",
|
||||
@@ -49,19 +49,13 @@ with patch.dict(os.environ, environment), \
|
||||
module.main()
|
||||
assert latest.call_count == 2
|
||||
assert [call.args[2] for call in published.call_args_list] == ["main", "next"]
|
||||
with patch.dict(os.environ, {**environment, "GITHUB_EVENT_NAME": "workflow_dispatch"}), \
|
||||
patch.object(module, "latest_completed", side_effect=[(201, "success"),
|
||||
(202, "failure")]), \
|
||||
patch.object(module, "publish") as published:
|
||||
module.main()
|
||||
assert published.call_count == 2
|
||||
with patch.dict(os.environ, {**environment, "GITHUB_EVENT_NAME": "schedule"}):
|
||||
with patch.dict(os.environ, {**environment, "GITHUB_EVENT_NAME": "workflow_run"}):
|
||||
try:
|
||||
module.main()
|
||||
except RuntimeError as error:
|
||||
assert "CI completion or manual dispatch" in str(error)
|
||||
assert "timer or manual dispatch" in str(error)
|
||||
else:
|
||||
raise AssertionError("scheduled event entered badge publisher")
|
||||
raise AssertionError("workflow_run event entered badge publisher")
|
||||
for invalid in ("", "/main.svg", "../main.svg", "badges//main.svg"):
|
||||
try:
|
||||
publish_file("https://example.invalid/api/v1", "owner/repo", invalid,
|
||||
|
||||
@@ -0,0 +1,28 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Unknown PR paths must retain compiled source checks."""
|
||||
|
||||
import importlib.util
|
||||
from pathlib import Path
|
||||
import unittest
|
||||
|
||||
|
||||
spec = importlib.util.spec_from_file_location("pr_surface", Path(__file__).with_name("pr_surface.py"))
|
||||
surface = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(surface)
|
||||
|
||||
|
||||
class PrSurfaceTest(unittest.TestCase):
|
||||
def test_documentation_and_tooling(self):
|
||||
self.assertEqual(surface.classify(["README.md", "docs/boards.md"]), "documentation")
|
||||
self.assertEqual(surface.classify(["ci/evidence_status.py", "ci/CONFORMANCE.md"]), "tooling")
|
||||
|
||||
def test_unknown_and_rust_paths_fail_open_to_build(self):
|
||||
for paths in ([], ["src/main.rs"], ["Cargo.toml"], ["unknown/file"],
|
||||
["ci/evidence_status.py", "src/main.rs"]):
|
||||
with self.subTest(paths=paths):
|
||||
self.assertEqual(surface.classify(paths), "rust")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,59 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Check candidate numbering and covered-commit reruns with real Git tags."""
|
||||
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import tempfile
|
||||
|
||||
|
||||
VERSION = Path(__file__).with_name("version.py")
|
||||
|
||||
|
||||
def git(root: Path, *args: str) -> str:
|
||||
result = subprocess.run(
|
||||
["git", *args], cwd=root, text=True, check=True, capture_output=True
|
||||
)
|
||||
return result.stdout.strip()
|
||||
|
||||
|
||||
def selected(root: Path, branch: str) -> dict[str, str]:
|
||||
result = subprocess.run(
|
||||
["python3", str(VERSION), branch], cwd=root,
|
||||
text=True, check=True, capture_output=True
|
||||
)
|
||||
return dict(line.split("=", 1) for line in result.stdout.splitlines())
|
||||
|
||||
|
||||
def main() -> None:
|
||||
with tempfile.TemporaryDirectory(prefix="alkane-os-version-") as path:
|
||||
root = Path(path)
|
||||
(root / "ci").mkdir()
|
||||
(root / "ci/version-x.txt").write_text("0\n")
|
||||
git(root, "init", "-q")
|
||||
git(root, "config", "user.name", "Alkane CI")
|
||||
git(root, "config", "user.email", "ci@example.invalid")
|
||||
git(root, "add", ".")
|
||||
git(root, "commit", "-qm", "First source")
|
||||
first = git(root, "rev-parse", "HEAD")
|
||||
assert selected(root, "next") == {
|
||||
"release": "true", "tag": "v0.1.0-rc.1", "version": "0.1.0-rc.1"
|
||||
}
|
||||
git(root, "tag", "v0.1.0-rc.1")
|
||||
assert selected(root, "next") == {"release": "false"}
|
||||
|
||||
(root / "README.md").write_text("A later merge.\n")
|
||||
git(root, "add", ".")
|
||||
git(root, "commit", "-qm", "Later source")
|
||||
assert selected(root, "next") == {
|
||||
"release": "true", "tag": "v0.1.0-rc.2", "version": "0.1.0-rc.2"
|
||||
}
|
||||
git(root, "tag", "v0.1.0-rc.2")
|
||||
assert selected(root, "next") == {"release": "false"}
|
||||
git(root, "checkout", "-q", first)
|
||||
assert selected(root, "next") == {"release": "false"}
|
||||
print("PASS: exact and superseded candidate reruns do not publish")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -27,6 +27,13 @@ def main():
|
||||
parser.add_argument("branch", choices=("main", "next"))
|
||||
args = parser.parse_args()
|
||||
major = int(pathlib.Path("ci/version-x.txt").read_text().strip())
|
||||
# A rerun of a commit already covered by a published tag must not issue
|
||||
# a newer candidate number for older source.
|
||||
tagged_descendants = set(git("tag", "--contains", "HEAD", "-l", "v*").splitlines())
|
||||
known_tags = {tag for _, tag in versions("main") + versions("next")}
|
||||
if tagged_descendants & known_tags:
|
||||
print("release=false")
|
||||
return
|
||||
finals = versions("main")
|
||||
previous = finals[-1] if finals else None
|
||||
if previous and previous[0][0] > major:
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
{
|
||||
"schema": 1,
|
||||
"profiles": [
|
||||
{
|
||||
"name": "s19jpro-bm1362-pic",
|
||||
"chip": "bm1362",
|
||||
"sensor": "pic",
|
||||
"chains": 3,
|
||||
"envelope": {"v_min_mv": 1100, "v_max_mv": 1500, "f_min_mhz": 300, "f_max_mhz": 700}
|
||||
},
|
||||
{
|
||||
"name": "s19kpro-bm1366-nopic",
|
||||
"chip": "bm1366",
|
||||
"sensor": "nopic",
|
||||
"chains": 3,
|
||||
"envelope": {"v_min_mv": 1100, "v_max_mv": 1500, "f_min_mhz": 300, "f_max_mhz": 700}
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,618 @@
|
||||
{
|
||||
"format": 1,
|
||||
"id": "alkane.bb",
|
||||
"kind": "base",
|
||||
"menus": [
|
||||
{
|
||||
"id": "dashboard",
|
||||
"slug": "dashboard",
|
||||
"title": "Dashboard",
|
||||
"icon": "dashboard",
|
||||
"band": 0,
|
||||
"order": 10
|
||||
},
|
||||
{
|
||||
"id": "dashboard/overview",
|
||||
"slug": "overview",
|
||||
"title": "Overview",
|
||||
"order": 10,
|
||||
"page": "dashboard.overview"
|
||||
},
|
||||
{
|
||||
"id": "dashboard/alerts",
|
||||
"slug": "alerts",
|
||||
"title": "Alerts",
|
||||
"order": 20,
|
||||
"page": "dashboard.alerts"
|
||||
},
|
||||
{
|
||||
"id": "mining",
|
||||
"slug": "mining",
|
||||
"title": "Mining",
|
||||
"icon": "pickaxe",
|
||||
"band": 1,
|
||||
"order": 10
|
||||
},
|
||||
{
|
||||
"id": "mining/overview",
|
||||
"slug": "overview",
|
||||
"title": "Overview",
|
||||
"order": 10,
|
||||
"page": "mining.overview"
|
||||
},
|
||||
{
|
||||
"id": "mining/hashboards",
|
||||
"slug": "hashboards",
|
||||
"title": "Hashboards",
|
||||
"order": 20,
|
||||
"page": "mining.hashboards"
|
||||
},
|
||||
{
|
||||
"id": "mining/power",
|
||||
"slug": "power",
|
||||
"title": "Power Supply",
|
||||
"order": 30,
|
||||
"page": "mining.power"
|
||||
},
|
||||
{
|
||||
"id": "mining/fans",
|
||||
"slug": "fans",
|
||||
"title": "Fans",
|
||||
"order": 40,
|
||||
"page": "mining.fans"
|
||||
},
|
||||
{
|
||||
"id": "settings",
|
||||
"slug": "settings",
|
||||
"title": "Settings",
|
||||
"icon": "gear",
|
||||
"band": 2,
|
||||
"order": 10
|
||||
},
|
||||
{
|
||||
"id": "settings/system",
|
||||
"slug": "system",
|
||||
"title": "System",
|
||||
"order": 10,
|
||||
"page": "settings.system"
|
||||
},
|
||||
{
|
||||
"id": "settings/tuning",
|
||||
"slug": "tuning",
|
||||
"title": "Tuning",
|
||||
"order": 20,
|
||||
"page": "settings.tuning"
|
||||
},
|
||||
{
|
||||
"id": "settings/pools",
|
||||
"slug": "pools",
|
||||
"title": "Pools",
|
||||
"order": 30,
|
||||
"page": "settings.pools"
|
||||
},
|
||||
{
|
||||
"id": "settings/network",
|
||||
"slug": "network",
|
||||
"title": "Network",
|
||||
"order": 40,
|
||||
"page": "settings.network"
|
||||
},
|
||||
{
|
||||
"id": "settings/security",
|
||||
"slug": "security",
|
||||
"title": "Security",
|
||||
"order": 50,
|
||||
"page": "settings.security"
|
||||
},
|
||||
{
|
||||
"id": "settings/logs",
|
||||
"slug": "logs",
|
||||
"title": "Logs",
|
||||
"order": 60,
|
||||
"page": "settings.logs"
|
||||
},
|
||||
{
|
||||
"id": "settings/files",
|
||||
"slug": "files",
|
||||
"title": "Files",
|
||||
"order": 70,
|
||||
"page": "settings.files"
|
||||
},
|
||||
{
|
||||
"id": "settings/terminal",
|
||||
"slug": "terminal",
|
||||
"title": "Terminal",
|
||||
"order": 80,
|
||||
"page": "settings.terminal"
|
||||
}
|
||||
],
|
||||
"pages": [],
|
||||
"settings": [
|
||||
{
|
||||
"path": "tuning.mode",
|
||||
"label": "Tuning target",
|
||||
"help": "What the controller holds: a power draw, a hashrate, an ambient margin, or a fan ceiling.",
|
||||
"kind": {
|
||||
"t": "enum",
|
||||
"values": [
|
||||
{
|
||||
"v": "power",
|
||||
"label": "Power"
|
||||
},
|
||||
{
|
||||
"v": "hashrate",
|
||||
"label": "Hashrate"
|
||||
},
|
||||
{
|
||||
"v": "ambient",
|
||||
"label": "Ambient"
|
||||
},
|
||||
{
|
||||
"v": "max-fan",
|
||||
"label": "Max Fan"
|
||||
}
|
||||
]
|
||||
},
|
||||
"default": {
|
||||
"value": "power"
|
||||
},
|
||||
"owner": "synced",
|
||||
"guarded": false,
|
||||
"section": "tuning",
|
||||
"order": 10,
|
||||
"apply": {
|
||||
"class": "none"
|
||||
},
|
||||
"display": {
|
||||
"t": "dropdown"
|
||||
}
|
||||
},
|
||||
{
|
||||
"path": "tuning.power_w",
|
||||
"label": "Power target",
|
||||
"help": "DC power to hold when the target is power.",
|
||||
"kind": {
|
||||
"t": "int",
|
||||
"lo": 200,
|
||||
"hi": 4000,
|
||||
"units": "W"
|
||||
},
|
||||
"default": {
|
||||
"value": 1200
|
||||
},
|
||||
"owner": "synced",
|
||||
"guarded": false,
|
||||
"section": "tuning",
|
||||
"order": 20,
|
||||
"apply": {
|
||||
"class": "none"
|
||||
},
|
||||
"display": {
|
||||
"t": "stepper"
|
||||
}
|
||||
},
|
||||
{
|
||||
"path": "tuning.hashrate_ths",
|
||||
"label": "Hashrate target",
|
||||
"help": "Hashrate to maximise up to, when the target is hashrate.",
|
||||
"kind": {
|
||||
"t": "int",
|
||||
"lo": 1,
|
||||
"hi": 200,
|
||||
"units": "TH/s"
|
||||
},
|
||||
"default": {
|
||||
"value": 60
|
||||
},
|
||||
"owner": "synced",
|
||||
"guarded": false,
|
||||
"section": "tuning",
|
||||
"order": 30,
|
||||
"apply": {
|
||||
"class": "none"
|
||||
},
|
||||
"display": {
|
||||
"t": "stepper"
|
||||
}
|
||||
},
|
||||
{
|
||||
"path": "tuning.ambient_margin_c",
|
||||
"label": "Ambient margin",
|
||||
"help": "Hold the hottest sensor this far above measured ambient.",
|
||||
"kind": {
|
||||
"t": "int",
|
||||
"lo": 0,
|
||||
"hi": 40,
|
||||
"units": "C"
|
||||
},
|
||||
"default": {
|
||||
"value": 20
|
||||
},
|
||||
"owner": "synced",
|
||||
"guarded": false,
|
||||
"section": "tuning",
|
||||
"order": 40,
|
||||
"apply": {
|
||||
"class": "none"
|
||||
},
|
||||
"display": {
|
||||
"t": "stepper"
|
||||
}
|
||||
},
|
||||
{
|
||||
"path": "tuning.max_fan_pwm",
|
||||
"label": "Fan ceiling",
|
||||
"help": "Fan duty cap, percent, when the target is max-fan.",
|
||||
"kind": {
|
||||
"t": "int",
|
||||
"lo": 0,
|
||||
"hi": 100,
|
||||
"units": "%"
|
||||
},
|
||||
"default": {
|
||||
"value": 80
|
||||
},
|
||||
"owner": "synced",
|
||||
"guarded": false,
|
||||
"section": "tuning",
|
||||
"order": 50,
|
||||
"apply": {
|
||||
"class": "none"
|
||||
},
|
||||
"display": {
|
||||
"t": "stepper"
|
||||
}
|
||||
},
|
||||
{
|
||||
"path": "tuning.ceiling_mc",
|
||||
"label": "Frequency ceiling",
|
||||
"help": "Upper bound on the operating frequency, MHz.",
|
||||
"kind": {
|
||||
"t": "int",
|
||||
"lo": 100,
|
||||
"hi": 1000,
|
||||
"units": "MHz"
|
||||
},
|
||||
"default": {
|
||||
"value": 700
|
||||
},
|
||||
"owner": "synced",
|
||||
"guarded": false,
|
||||
"section": "tuning",
|
||||
"order": 60,
|
||||
"apply": {
|
||||
"class": "none"
|
||||
},
|
||||
"display": {
|
||||
"t": "stepper"
|
||||
}
|
||||
},
|
||||
{
|
||||
"path": "tuning.pid.kp_milli",
|
||||
"label": "Proportional gain",
|
||||
"help": "PID proportional term, thousandths of a unit.",
|
||||
"kind": {
|
||||
"t": "int",
|
||||
"lo": 0,
|
||||
"hi": 10000
|
||||
},
|
||||
"default": {
|
||||
"value": 500
|
||||
},
|
||||
"owner": "synced",
|
||||
"guarded": false,
|
||||
"section": "tuning",
|
||||
"order": 100,
|
||||
"apply": {
|
||||
"class": "none"
|
||||
},
|
||||
"display": {
|
||||
"t": "stepper"
|
||||
}
|
||||
},
|
||||
{
|
||||
"path": "tuning.pid.ki_milli",
|
||||
"label": "Integral gain",
|
||||
"help": "PID integral term, milli-units.",
|
||||
"kind": {
|
||||
"t": "int",
|
||||
"lo": 0,
|
||||
"hi": 10000
|
||||
},
|
||||
"default": {
|
||||
"value": 100
|
||||
},
|
||||
"owner": "synced",
|
||||
"guarded": false,
|
||||
"section": "tuning",
|
||||
"order": 110,
|
||||
"apply": {
|
||||
"class": "none"
|
||||
},
|
||||
"display": {
|
||||
"t": "stepper"
|
||||
}
|
||||
},
|
||||
{
|
||||
"path": "tuning.pid.kd_milli",
|
||||
"label": "Derivative gain",
|
||||
"help": "PID derivative term, milli-units.",
|
||||
"kind": {
|
||||
"t": "int",
|
||||
"lo": 0,
|
||||
"hi": 10000
|
||||
},
|
||||
"default": {
|
||||
"value": 0
|
||||
},
|
||||
"owner": "synced",
|
||||
"guarded": false,
|
||||
"section": "tuning",
|
||||
"order": 120,
|
||||
"apply": {
|
||||
"class": "none"
|
||||
},
|
||||
"display": {
|
||||
"t": "stepper"
|
||||
}
|
||||
},
|
||||
{
|
||||
"path": "tuning.pid.out_min_milli",
|
||||
"label": "Output floor",
|
||||
"help": "Lowest control output the loop may emit, milli-units.",
|
||||
"kind": {
|
||||
"t": "int",
|
||||
"lo": 0,
|
||||
"hi": 1000000
|
||||
},
|
||||
"default": {
|
||||
"value": 0
|
||||
},
|
||||
"owner": "synced",
|
||||
"guarded": false,
|
||||
"section": "tuning",
|
||||
"order": 130,
|
||||
"apply": {
|
||||
"class": "none"
|
||||
},
|
||||
"display": {
|
||||
"t": "stepper"
|
||||
}
|
||||
},
|
||||
{
|
||||
"path": "tuning.pid.out_max_milli",
|
||||
"label": "Output ceiling",
|
||||
"help": "Highest control output the loop may emit, milli-units.",
|
||||
"kind": {
|
||||
"t": "int",
|
||||
"lo": 0,
|
||||
"hi": 5000000
|
||||
},
|
||||
"default": {
|
||||
"value": 1000000
|
||||
},
|
||||
"owner": "synced",
|
||||
"guarded": false,
|
||||
"section": "tuning",
|
||||
"order": 140,
|
||||
"apply": {
|
||||
"class": "none"
|
||||
},
|
||||
"display": {
|
||||
"t": "stepper"
|
||||
}
|
||||
},
|
||||
{
|
||||
"path": "tuning.pid.max_step_milli",
|
||||
"label": "Maximum step",
|
||||
"help": "Largest output change per second, milli-units.",
|
||||
"kind": {
|
||||
"t": "int",
|
||||
"lo": 0,
|
||||
"hi": 500000
|
||||
},
|
||||
"default": {
|
||||
"value": 50000
|
||||
},
|
||||
"owner": "synced",
|
||||
"guarded": false,
|
||||
"section": "tuning",
|
||||
"order": 150,
|
||||
"apply": {
|
||||
"class": "none"
|
||||
},
|
||||
"display": {
|
||||
"t": "stepper"
|
||||
}
|
||||
},
|
||||
{
|
||||
"path": "tuning.pid.deadband_milli",
|
||||
"label": "Deadband",
|
||||
"help": "Errors inside this band are ignored, milli-units.",
|
||||
"kind": {
|
||||
"t": "int",
|
||||
"lo": 0,
|
||||
"hi": 50000
|
||||
},
|
||||
"default": {
|
||||
"value": 1000
|
||||
},
|
||||
"owner": "synced",
|
||||
"guarded": false,
|
||||
"section": "tuning",
|
||||
"order": 160,
|
||||
"apply": {
|
||||
"class": "none"
|
||||
},
|
||||
"display": {
|
||||
"t": "stepper"
|
||||
}
|
||||
},
|
||||
{
|
||||
"path": "fans.zone_count",
|
||||
"label": "Fan zones",
|
||||
"help": "Number of independently driven fan zones.",
|
||||
"kind": {
|
||||
"t": "int",
|
||||
"lo": 1,
|
||||
"hi": 8
|
||||
},
|
||||
"default": {
|
||||
"value": 4
|
||||
},
|
||||
"owner": "synced",
|
||||
"guarded": false,
|
||||
"section": "fans",
|
||||
"order": 10,
|
||||
"apply": {
|
||||
"class": "none"
|
||||
},
|
||||
"display": {
|
||||
"t": "stepper"
|
||||
}
|
||||
},
|
||||
{
|
||||
"path": "fans.pwm_min",
|
||||
"label": "Minimum duty",
|
||||
"help": "Duty floor applied to every zone, percent.",
|
||||
"kind": {
|
||||
"t": "int",
|
||||
"lo": 0,
|
||||
"hi": 100,
|
||||
"units": "%"
|
||||
},
|
||||
"default": {
|
||||
"value": 20
|
||||
},
|
||||
"owner": "synced",
|
||||
"guarded": false,
|
||||
"section": "fans",
|
||||
"order": 20,
|
||||
"apply": {
|
||||
"class": "none"
|
||||
},
|
||||
"display": {
|
||||
"t": "stepper"
|
||||
}
|
||||
},
|
||||
{
|
||||
"path": "fans.sweep_steps",
|
||||
"label": "Sweep steps",
|
||||
"help": "Steps per zone when mapping fans to sensors.",
|
||||
"kind": {
|
||||
"t": "int",
|
||||
"lo": 1,
|
||||
"hi": 32
|
||||
},
|
||||
"default": {
|
||||
"value": 8
|
||||
},
|
||||
"owner": "synced",
|
||||
"guarded": false,
|
||||
"section": "fans",
|
||||
"order": 30,
|
||||
"apply": {
|
||||
"class": "none"
|
||||
},
|
||||
"display": {
|
||||
"t": "stepper"
|
||||
}
|
||||
},
|
||||
{
|
||||
"path": "detect.chain_ports",
|
||||
"label": "Chain ports",
|
||||
"help": "Chain UART ports to probe, comma separated.",
|
||||
"kind": {
|
||||
"t": "str"
|
||||
},
|
||||
"default": {
|
||||
"value": "1,2,3"
|
||||
},
|
||||
"owner": "synced",
|
||||
"guarded": false,
|
||||
"section": "detect",
|
||||
"order": 10,
|
||||
"apply": {
|
||||
"class": "none"
|
||||
},
|
||||
"display": {
|
||||
"t": "list"
|
||||
}
|
||||
},
|
||||
{
|
||||
"path": "detect.probe_budget",
|
||||
"label": "Probe budget",
|
||||
"help": "Attempts per chain before detection gives up.",
|
||||
"kind": {
|
||||
"t": "int",
|
||||
"lo": 1,
|
||||
"hi": 20
|
||||
},
|
||||
"default": {
|
||||
"value": 3
|
||||
},
|
||||
"owner": "synced",
|
||||
"guarded": false,
|
||||
"section": "detect",
|
||||
"order": 20,
|
||||
"apply": {
|
||||
"class": "none"
|
||||
},
|
||||
"display": {
|
||||
"t": "stepper"
|
||||
}
|
||||
},
|
||||
{
|
||||
"path": "profiles.db",
|
||||
"label": "Profile database",
|
||||
"help": "Path to the board's tuning profile database.",
|
||||
"kind": {
|
||||
"t": "str"
|
||||
},
|
||||
"default": {
|
||||
"value": "/etc/alkane/profiles.json"
|
||||
},
|
||||
"owner": "synced",
|
||||
"guarded": false,
|
||||
"section": "system",
|
||||
"order": 10,
|
||||
"apply": {
|
||||
"class": "none"
|
||||
},
|
||||
"display": {
|
||||
"t": "text"
|
||||
}
|
||||
},
|
||||
{
|
||||
"path": "system.name",
|
||||
"label": "Board name",
|
||||
"help": "Name shown in the dashboard header.",
|
||||
"kind": {
|
||||
"t": "str"
|
||||
},
|
||||
"default": {
|
||||
"value": "alkane"
|
||||
},
|
||||
"owner": "synced",
|
||||
"guarded": false,
|
||||
"section": "system",
|
||||
"order": 20,
|
||||
"apply": {
|
||||
"class": "none"
|
||||
},
|
||||
"display": {
|
||||
"t": "text"
|
||||
}
|
||||
}
|
||||
],
|
||||
"groups": [],
|
||||
"actions": [],
|
||||
"rules": [],
|
||||
"maps": [],
|
||||
"legacy_keys": [],
|
||||
"requires": {
|
||||
"display_api": 1,
|
||||
"checks_api": 1
|
||||
},
|
||||
"vocab": []
|
||||
}
|
||||
+589
@@ -0,0 +1,589 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Process wiring: start the API and UI servers and publish the hardware snapshot.
|
||||
//!
|
||||
//! The binary and the tests use the same function, so the wiring that CI exercises is the wiring
|
||||
//! that runs on a board. Servers are bound before they are spawned, which lets a caller discover
|
||||
//! ephemeral ports instead of guessing them.
|
||||
|
||||
use crate::detect::{
|
||||
run_detection, DetectionBackend, DetectionFailure, DetectionRequest, FanZone, ProbeBudget,
|
||||
SensorTopology,
|
||||
};
|
||||
use crate::fanmap::{FanMap, MapThresholds, SweepConfig};
|
||||
use crate::fanmap_store::ensure_map;
|
||||
use crate::fault::FaultPolicy;
|
||||
use crate::hal_wire::{HalClient, HalError};
|
||||
use crate::management::{bind_local, serve, HardwareSnapshot, MiningStatus};
|
||||
use crate::profiles::{ProfileDb, ProfileError};
|
||||
use crate::runtime::MinerRuntime;
|
||||
use crate::tuning::{PidConfig, TuningTarget};
|
||||
use crate::web;
|
||||
use std::fmt;
|
||||
use std::io;
|
||||
use std::net::{SocketAddr, TcpListener, TcpStream};
|
||||
use std::path::Path;
|
||||
use std::sync::Arc;
|
||||
use std::thread::JoinHandle;
|
||||
use std::time::Duration;
|
||||
|
||||
/// Bound servers and their worker threads.
|
||||
pub struct Servers {
|
||||
pub api: Option<SocketAddr>,
|
||||
pub web: Option<SocketAddr>,
|
||||
handles: Vec<JoinHandle<()>>,
|
||||
}
|
||||
|
||||
impl Servers {
|
||||
/// Addresses actually bound, which matters when port 0 was requested.
|
||||
pub fn addresses(&self) -> (Option<SocketAddr>, Option<SocketAddr>) {
|
||||
(self.api, self.web)
|
||||
}
|
||||
|
||||
/// Wait for the workers. Only useful in tests; the binary runs until it is killed.
|
||||
pub fn join(self) {
|
||||
for handle in self.handles {
|
||||
let _ = handle.join();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Bind and start the cgminer-style API and the web UI, each when an address is given.
|
||||
pub fn start(
|
||||
status: Arc<MiningStatus>,
|
||||
api: Option<SocketAddr>,
|
||||
web_bind: Option<SocketAddr>,
|
||||
) -> io::Result<Servers> {
|
||||
let api_listener = match api {
|
||||
Some(address) => Some(bind_local(address)?),
|
||||
None => None,
|
||||
};
|
||||
let api_address = api_listener
|
||||
.as_ref()
|
||||
.map(|listener| listener.local_addr())
|
||||
.transpose()?;
|
||||
let web_listener = match web_bind {
|
||||
Some(address) => Some(TcpListener::bind(address)?),
|
||||
None => None,
|
||||
};
|
||||
let web_address = web_listener
|
||||
.as_ref()
|
||||
.map(|listener| listener.local_addr())
|
||||
.transpose()?;
|
||||
|
||||
let mut handles = Vec::new();
|
||||
if let Some(listener) = api_listener {
|
||||
let snapshot = Arc::clone(&status);
|
||||
handles.push(std::thread::spawn(move || {
|
||||
if let Err(error) = serve(listener, snapshot) {
|
||||
eprintln!("management API stopped: {error}");
|
||||
}
|
||||
}));
|
||||
}
|
||||
if let Some(listener) = web_listener {
|
||||
let snapshot = Arc::clone(&status);
|
||||
handles.push(std::thread::spawn(move || {
|
||||
if let Err(error) = web::serve_listener(listener, snapshot) {
|
||||
eprintln!("web UI stopped: {error}");
|
||||
}
|
||||
}));
|
||||
}
|
||||
Ok(Servers {
|
||||
api: api_address,
|
||||
web: web_address,
|
||||
handles,
|
||||
})
|
||||
}
|
||||
|
||||
/// Build the API snapshot from the live runtime.
|
||||
pub fn snapshot(runtime: &MinerRuntime, target: &str) -> HardwareSnapshot {
|
||||
let plan = runtime.plan();
|
||||
HardwareSnapshot {
|
||||
plan: plan.clone(),
|
||||
active_chains: runtime.active_chains(),
|
||||
stopped: runtime.stop_reason().map(|reason| match reason {
|
||||
crate::fault::StopReason::Temperature => "temperature",
|
||||
crate::fault::StopReason::NoChainsLeft => "no chains left",
|
||||
}),
|
||||
frequency_mhz: runtime.operating_point().frequency_mhz,
|
||||
target: target.to_owned(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Everything a boot needs besides the backend.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct BootConfig {
|
||||
pub profile_db_json: String,
|
||||
pub chain_ports: Vec<u8>,
|
||||
pub sensor: SensorTopology,
|
||||
pub budget: ProbeBudget,
|
||||
pub fan_zones: Vec<FanZone>,
|
||||
pub target: TuningTarget,
|
||||
pub pid: PidConfig,
|
||||
pub ceiling_mc: i32,
|
||||
pub fault_policy: FaultPolicy,
|
||||
}
|
||||
|
||||
/// Why boot did not reach a running runtime.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub enum BootError<E> {
|
||||
Profile(ProfileError),
|
||||
Detection(DetectionFailure<E>),
|
||||
/// The board backend could not be reached or refused an operation.
|
||||
Backend(E),
|
||||
}
|
||||
|
||||
impl<E: fmt::Debug> fmt::Display for BootError<E> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
Self::Profile(error) => write!(f, "profile database rejected: {error:?}"),
|
||||
Self::Detection(error) => write!(f, "hardware detection refused: {error:?}"),
|
||||
Self::Backend(error) => write!(f, "hardware backend failed: {error:?}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<E: fmt::Debug> std::error::Error for BootError<E> {}
|
||||
|
||||
/// Operator target in the form the API and UI report.
|
||||
pub fn target_label(target: &TuningTarget) -> String {
|
||||
match *target {
|
||||
TuningTarget::PowerW(watts) => format!("power:{watts:.0}"),
|
||||
TuningTarget::HashrateThs(rate) => format!("hashrate:{rate:.0}"),
|
||||
TuningTarget::AmbientC { margin_mc } => format!("ambient:{margin_mc}"),
|
||||
TuningTarget::MaxFan { max_pwm } => format!("fan:{max_pwm}"),
|
||||
}
|
||||
}
|
||||
|
||||
/// Detect, decide, and publish: the sequence a family image runs at start-up.
|
||||
pub fn boot<B: DetectionBackend>(
|
||||
backend: &mut B,
|
||||
config: &BootConfig,
|
||||
status: &MiningStatus,
|
||||
) -> Result<MinerRuntime, BootError<B::Error>> {
|
||||
let db = ProfileDb::from_json(&config.profile_db_json).map_err(BootError::Profile)?;
|
||||
let request = DetectionRequest {
|
||||
chain_ports: &config.chain_ports,
|
||||
budget: config.budget,
|
||||
sensor: config.sensor,
|
||||
fan_zones: config.fan_zones.clone(),
|
||||
};
|
||||
let plan = run_detection(backend, &db, &request).map_err(BootError::Detection)?;
|
||||
let runtime = MinerRuntime::new(
|
||||
plan,
|
||||
config.fault_policy,
|
||||
config.target,
|
||||
config.pid,
|
||||
config.ceiling_mc,
|
||||
);
|
||||
status.set_hardware(snapshot(&runtime, &target_label(&config.target)));
|
||||
Ok(runtime)
|
||||
}
|
||||
|
||||
/// A boot over the real local HAL contract, including the one-time fan sweep.
|
||||
pub struct HalBoot<'a> {
|
||||
pub config: &'a BootConfig,
|
||||
pub sweep: SweepConfig,
|
||||
pub thresholds: MapThresholds,
|
||||
pub map_path: &'a Path,
|
||||
}
|
||||
|
||||
/// Connect the board backend, detect, map the fans once, and publish.
|
||||
///
|
||||
/// This is the path an image takes on real hardware; the fakes in the tests speak the same HAL
|
||||
/// protocol, so the wiring is exercised rather than assumed.
|
||||
pub fn boot_from_hal(
|
||||
socket: &Path,
|
||||
settings: &HalBoot<'_>,
|
||||
status: &MiningStatus,
|
||||
) -> Result<(MinerRuntime, FanMap), BootError<HalError>> {
|
||||
let mut client = HalClient::connect(socket).map_err(BootError::Backend)?;
|
||||
let zone_count = settings.sweep.zones;
|
||||
let map = if zone_count == 0 {
|
||||
FanMap::default()
|
||||
} else {
|
||||
ensure_map(
|
||||
&mut client,
|
||||
&settings.sweep,
|
||||
settings.thresholds,
|
||||
settings.map_path,
|
||||
|millis| std::thread::sleep(std::time::Duration::from_millis(u64::from(millis))),
|
||||
)
|
||||
.map_err(|error| match error {
|
||||
crate::fanmap_store::StoreError::Sweep(crate::fanmap::SweepError::Backend(error)) => {
|
||||
BootError::Backend(error)
|
||||
}
|
||||
crate::fanmap_store::StoreError::Sweep(_) => {
|
||||
BootError::Backend(HalError::Protocol("fan sweep configuration rejected"))
|
||||
}
|
||||
crate::fanmap_store::StoreError::Io(message) => {
|
||||
BootError::Backend(HalError::Protocol(message))
|
||||
}
|
||||
})?
|
||||
};
|
||||
let config = BootConfig {
|
||||
fan_zones: map.assignments.clone(),
|
||||
..settings.config.clone()
|
||||
};
|
||||
let runtime = boot(&mut client, &config, status)?;
|
||||
Ok((runtime, map))
|
||||
}
|
||||
|
||||
/// Read one HTTP response body from a bound server, for health checks and tests.
|
||||
pub fn http_get(address: SocketAddr, path: &str) -> io::Result<String> {
|
||||
use std::io::{Read, Write};
|
||||
let mut stream = TcpStream::connect_timeout(&address, Duration::from_secs(2))?;
|
||||
stream.set_read_timeout(Some(Duration::from_secs(2)))?;
|
||||
stream.write_all(format!("GET {path} HTTP/1.1\r\nHost: miner\r\n\r\n").as_bytes())?;
|
||||
let mut reply = String::new();
|
||||
stream.read_to_string(&mut reply)?;
|
||||
Ok(reply)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::detect::{
|
||||
ChainReport, ChipModel, EepromState, Envelope, FanZone, HardwarePlan, OperatingPoint,
|
||||
};
|
||||
use crate::detect::{ProbeOutcome, PsuCapability};
|
||||
use crate::fanmap::{MapThresholds, SweepConfig};
|
||||
use crate::fault::FaultPolicy;
|
||||
use crate::tuning::{PidConfig, TuningTarget};
|
||||
use std::io::{Read, Write};
|
||||
|
||||
fn runtime() -> MinerRuntime {
|
||||
MinerRuntime::new(
|
||||
HardwarePlan {
|
||||
profile: "s19jpro-bm1362-pic".into(),
|
||||
chip: ChipModel::Bm1362,
|
||||
chains: vec![ChainReport {
|
||||
index: 0,
|
||||
chip: ChipModel::Bm1362,
|
||||
chips_found: 126,
|
||||
eeprom: EepromState::Absent,
|
||||
response_per_mille: Some(950),
|
||||
}],
|
||||
envelope: Envelope {
|
||||
v_min_mv: 1100,
|
||||
v_max_mv: 1500,
|
||||
f_min_mhz: 300,
|
||||
f_max_mhz: 700,
|
||||
},
|
||||
operating_point: OperatingPoint {
|
||||
voltage_mv: 1200,
|
||||
frequency_mhz: 300,
|
||||
confirmed: false,
|
||||
},
|
||||
psu: "APW12".into(),
|
||||
fan_zones: vec![FanZone {
|
||||
fan: 0,
|
||||
zones: vec![0],
|
||||
}],
|
||||
},
|
||||
FaultPolicy::default(),
|
||||
TuningTarget::PowerW(2_400.0),
|
||||
PidConfig::default(),
|
||||
95_000,
|
||||
)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn both_servers_serve_the_published_snapshot() {
|
||||
let status = Arc::new(MiningStatus::new());
|
||||
status.set_hardware(snapshot(&runtime(), "power:2400"));
|
||||
let servers = start(
|
||||
Arc::clone(&status),
|
||||
Some("127.0.0.1:0".parse().unwrap()),
|
||||
Some("127.0.0.1:0".parse().unwrap()),
|
||||
)
|
||||
.expect("start");
|
||||
let (api, web) = servers.addresses();
|
||||
let api = api.expect("api address");
|
||||
let web = web.expect("web address");
|
||||
|
||||
let page = http_get(web, "/api/hardware").expect("web");
|
||||
assert!(page.contains("s19jpro-bm1362-pic"));
|
||||
assert!(page.contains("power:2400"));
|
||||
|
||||
let mut client =
|
||||
TcpStream::connect_timeout(&api, Duration::from_secs(2)).expect("api connect");
|
||||
client
|
||||
.set_read_timeout(Some(Duration::from_secs(3)))
|
||||
.expect("timeout");
|
||||
client.write_all(b"summary").expect("api write");
|
||||
let mut summary = String::new();
|
||||
client.read_to_string(&mut summary).expect("api read");
|
||||
assert!(summary.contains("SUMMARY"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn servers_are_optional() {
|
||||
let status = Arc::new(MiningStatus::new());
|
||||
let servers = start(status, None, None).expect("start");
|
||||
assert_eq!(servers.addresses(), (None, None));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_snapshot_reports_runtime_state_not_boot_defaults() {
|
||||
let mut runtime = runtime();
|
||||
runtime.tick(&crate::runtime::Tick {
|
||||
power_w: Some(1_000.0),
|
||||
hashrate_ths: None,
|
||||
hottest_mc: Some(60_000),
|
||||
ambient_mc: None,
|
||||
dt_s: 1.0,
|
||||
});
|
||||
let snapshot = snapshot(&runtime, "power:2400");
|
||||
assert_eq!(snapshot.target, "power:2400");
|
||||
assert_eq!(snapshot.active_chains, vec![0]);
|
||||
assert!(snapshot.frequency_mhz > 300);
|
||||
assert!(snapshot.stopped.is_none());
|
||||
}
|
||||
|
||||
struct BootBackend {
|
||||
outcome: ProbeOutcome,
|
||||
psu: Option<PsuCapability>,
|
||||
}
|
||||
|
||||
impl DetectionBackend for BootBackend {
|
||||
type Error = ();
|
||||
|
||||
fn probe(&mut self, _chain: u8, _attempt: u8) -> Result<ProbeOutcome, ()> {
|
||||
Ok(self.outcome)
|
||||
}
|
||||
|
||||
fn eeprom(&mut self, _chain: u8) -> Result<EepromState, ()> {
|
||||
Ok(EepromState::Absent)
|
||||
}
|
||||
|
||||
fn identify_psu(&mut self) -> Result<Option<PsuCapability>, ()> {
|
||||
Ok(self.psu.clone())
|
||||
}
|
||||
}
|
||||
|
||||
const DB: &str = r#"{"schema":1,"profiles":[{"name":"s19jpro-bm1362-pic",
|
||||
"chip":"bm1362","sensor":"pic","chains":3,
|
||||
"envelope":{"v_min_mv":1100,"v_max_mv":1500,"f_min_mhz":300,"f_max_mhz":700}}]}"#;
|
||||
|
||||
fn boot_config() -> BootConfig {
|
||||
BootConfig {
|
||||
profile_db_json: DB.into(),
|
||||
chain_ports: vec![0, 1, 2],
|
||||
sensor: SensorTopology::Pic,
|
||||
budget: ProbeBudget::default(),
|
||||
fan_zones: Vec::new(),
|
||||
target: TuningTarget::PowerW(2_400.0),
|
||||
pid: PidConfig::default(),
|
||||
ceiling_mc: 95_000,
|
||||
fault_policy: FaultPolicy::default(),
|
||||
}
|
||||
}
|
||||
|
||||
fn psu() -> PsuCapability {
|
||||
PsuCapability {
|
||||
name: "APW12".into(),
|
||||
envelope: Envelope {
|
||||
v_min_mv: 1200,
|
||||
v_max_mv: 1600,
|
||||
f_min_mhz: 0,
|
||||
f_max_mhz: 1_000,
|
||||
},
|
||||
max_dc_watts: 3_600,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn boot_detects_and_publishes() {
|
||||
let mut backend = BootBackend {
|
||||
outcome: ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
psu: Some(psu()),
|
||||
};
|
||||
let status = MiningStatus::new();
|
||||
let runtime = boot(&mut backend, &boot_config(), &status).expect("boot");
|
||||
assert_eq!(runtime.active_chains(), vec![0, 1, 2]);
|
||||
let document = status.hardware_document();
|
||||
assert_eq!(document["available"], true);
|
||||
assert_eq!(document["target"], "power:2400");
|
||||
assert_eq!(document["psu"], "APW12");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn boot_refuses_an_unknown_chip() {
|
||||
let mut backend = BootBackend {
|
||||
outcome: ProbeOutcome::Silent,
|
||||
psu: Some(psu()),
|
||||
};
|
||||
let status = MiningStatus::new();
|
||||
assert!(matches!(
|
||||
boot(&mut backend, &boot_config(), &status),
|
||||
Err(BootError::Detection(DetectionFailure::Refused(_)))
|
||||
));
|
||||
assert_eq!(status.hardware_document()["available"], false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn boot_refuses_a_bad_profile_database() {
|
||||
let mut backend = BootBackend {
|
||||
outcome: ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
psu: Some(psu()),
|
||||
};
|
||||
let mut config = boot_config();
|
||||
config.profile_db_json = "{\"schema\": 9}".into();
|
||||
assert!(matches!(
|
||||
boot(&mut backend, &config, &MiningStatus::new()),
|
||||
Err(BootError::Profile(_))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn boot_refuses_a_missing_psu() {
|
||||
let mut backend = BootBackend {
|
||||
outcome: ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
psu: None,
|
||||
};
|
||||
assert!(matches!(
|
||||
boot(&mut backend, &boot_config(), &MiningStatus::new()),
|
||||
Err(BootError::Detection(DetectionFailure::Refused(_)))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn target_labels_are_stable() {
|
||||
assert_eq!(target_label(&TuningTarget::PowerW(3_000.0)), "power:3000");
|
||||
assert_eq!(
|
||||
target_label(&TuningTarget::HashrateThs(200.0)),
|
||||
"hashrate:200"
|
||||
);
|
||||
assert_eq!(
|
||||
target_label(&TuningTarget::AmbientC { margin_mc: 20_000 }),
|
||||
"ambient:20000"
|
||||
);
|
||||
assert_eq!(
|
||||
target_label(&TuningTarget::MaxFan { max_pwm: 100 }),
|
||||
"fan:100"
|
||||
);
|
||||
}
|
||||
|
||||
fn hal_server(socket: std::path::PathBuf) -> std::thread::JoinHandle<()> {
|
||||
use std::io::{Read, Write};
|
||||
use std::os::unix::net::UnixListener;
|
||||
let listener = UnixListener::bind(&socket).expect("bind hal");
|
||||
std::thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().expect("accept");
|
||||
loop {
|
||||
let mut header = [0_u8; 16];
|
||||
if stream.read_exact(&mut header).is_err() {
|
||||
return;
|
||||
}
|
||||
let opcode = header[5];
|
||||
let sequence = header[8..12].to_vec();
|
||||
let length =
|
||||
u32::from_le_bytes([header[12], header[13], header[14], header[15]]) as usize;
|
||||
let mut payload = vec![0_u8; length];
|
||||
if length > 0 && stream.read_exact(&mut payload).is_err() {
|
||||
return;
|
||||
}
|
||||
let body: Vec<u8> = match opcode {
|
||||
// CAPABILITIES: chain probe, EEPROM, PSU identity.
|
||||
7 => {
|
||||
let mut body = vec![0_u8];
|
||||
body.extend_from_slice(&7_u32.to_le_bytes());
|
||||
body
|
||||
}
|
||||
// PROBE_CHAIN: identified, bm1362, 126 chips.
|
||||
8 => vec![0, 0, 1, 126, 0],
|
||||
// READ_EEPROM: absent.
|
||||
9 => vec![0, 1],
|
||||
// IDENTIFY_PSU: APW12 with its envelope.
|
||||
10 => {
|
||||
let name = b"APW12";
|
||||
let mut body = vec![0_u8, name.len() as u8];
|
||||
body.extend_from_slice(name);
|
||||
for word in [1200_u16, 1600, 0, 1000, 3600] {
|
||||
body.extend_from_slice(&word.to_le_bytes());
|
||||
}
|
||||
body
|
||||
}
|
||||
_ => vec![1],
|
||||
};
|
||||
let mut out = [0_u8; 16];
|
||||
out[..4].copy_from_slice(b"ALKH");
|
||||
out[4] = 1;
|
||||
out[5] = opcode;
|
||||
out[6..8].copy_from_slice(&1_u16.to_le_bytes());
|
||||
out[8..12].copy_from_slice(&sequence);
|
||||
out[12..16].copy_from_slice(&(body.len() as u32).to_le_bytes());
|
||||
if stream.write_all(&out).is_err() || stream.write_all(&body).is_err() {
|
||||
return;
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn boot_over_the_hal_socket_detects_and_publishes() {
|
||||
let base = std::env::temp_dir().join(format!("alkane-hal-{}", std::process::id()));
|
||||
let socket = base.with_extension("sock");
|
||||
let map_path = base.with_extension("map.json");
|
||||
let _ = std::fs::remove_file(&socket);
|
||||
let server = hal_server(socket.clone());
|
||||
let status = MiningStatus::new();
|
||||
let config = boot_config();
|
||||
let settings = HalBoot {
|
||||
config: &config,
|
||||
sweep: SweepConfig {
|
||||
fans: 0,
|
||||
zones: 0,
|
||||
low_pwm: 40,
|
||||
high_pwm: 100,
|
||||
repeats: 1,
|
||||
settle_ms: 0,
|
||||
},
|
||||
thresholds: MapThresholds::default(),
|
||||
map_path: &map_path,
|
||||
};
|
||||
let (runtime, map) = boot_from_hal(&socket, &settings, &status).expect("boot over hal");
|
||||
assert_eq!(runtime.active_chains(), vec![0, 1, 2]);
|
||||
assert!(map.assignments.is_empty());
|
||||
let document = status.hardware_document();
|
||||
assert_eq!(document["available"], true);
|
||||
assert_eq!(document["psu"], "APW12");
|
||||
assert_eq!(document["chip"], "bm1362");
|
||||
let _ = std::fs::remove_file(&socket);
|
||||
let _ = server.join();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn boot_over_a_missing_socket_is_a_backend_error() {
|
||||
let socket =
|
||||
std::env::temp_dir().join(format!("alkane-missing-{}.sock", std::process::id()));
|
||||
let status = MiningStatus::new();
|
||||
let config = boot_config();
|
||||
let settings = HalBoot {
|
||||
config: &config,
|
||||
sweep: SweepConfig {
|
||||
fans: 0,
|
||||
zones: 0,
|
||||
low_pwm: 40,
|
||||
high_pwm: 100,
|
||||
repeats: 1,
|
||||
settle_ms: 0,
|
||||
},
|
||||
thresholds: MapThresholds::default(),
|
||||
map_path: &socket,
|
||||
};
|
||||
assert!(matches!(
|
||||
boot_from_hal(&socket, &settings, &status),
|
||||
Err(BootError::Backend(_))
|
||||
));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Control for the size measurement: the same page shape rendered without
|
||||
//! flare-ui, so `check-ui-size.sh` reports the marginal cost of the dependency
|
||||
//! rather than the cost of a Rust binary at all.
|
||||
|
||||
fn main() {
|
||||
let sections = [("dashboard", "Dashboard"), ("mining", "Mining"), ("settings", "Settings")];
|
||||
let body = maud::html! {
|
||||
section class="bf-card" {
|
||||
h1 class="bf-text-title" { "Alkane OS" }
|
||||
p class="bf-text-body" { "Schema-driven page." }
|
||||
}
|
||||
};
|
||||
let mut html = String::from("<!doctype html><html><body>");
|
||||
for (slug, title) in sections {
|
||||
html.push_str(&format!("<a href=\"/{slug}\">{title}</a>"));
|
||||
}
|
||||
html.push_str(&body.into_string());
|
||||
html.push_str("</body></html>");
|
||||
println!("{} {}", html.len(), serde_json::json!({"sections": sections.len()}));
|
||||
}
|
||||
@@ -0,0 +1,68 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Spike: render the on-box UI from a schema document through flare-ui.
|
||||
//!
|
||||
//! This is the incorporation test, not the final UI. It answers three questions
|
||||
//! with evidence rather than argument:
|
||||
//!
|
||||
//! 1. does a hand-authored Alkane schema drive the unified sidebar through
|
||||
//! `flare_ui::nav` + `flare_ui::shell`?
|
||||
//! 2. does the page render with the shared design tokens?
|
||||
//! 3. what does it cost in a firmware binary?
|
||||
//!
|
||||
//! Run it, then compare `--size` against the current hand-rolled renderer.
|
||||
|
||||
use flare_ui::assets::PageAssets;
|
||||
use flare_ui::nav::{self, AllowAll, AppSet, CapSet};
|
||||
use flare_ui::shell::{self, Active};
|
||||
use flare_ui::url::Routes;
|
||||
use wschema::model::{Document, Surface};
|
||||
|
||||
/// The schema is the single source of the UI: sections, tabs and their order.
|
||||
const RECIPE_SCHEMA: &str = include_str!("../../schema/alkane-bb.json");
|
||||
|
||||
fn main() {
|
||||
let schema = match Document::from_json(RECIPE_SCHEMA) {
|
||||
Ok(schema) => schema,
|
||||
Err(error) => {
|
||||
eprintln!("schema did not parse: {error}");
|
||||
std::process::exit(1);
|
||||
}
|
||||
};
|
||||
|
||||
// Capabilities the board actually reports decide what is visible. On a real
|
||||
// board these come from the HAL; here they are the bb set.
|
||||
let caps = CapSet::new(["hashboard-bm1395", "psu-apm", "pid-fan", "cgminer-api"]);
|
||||
let routes = Routes::console();
|
||||
let apps = AppSet::default();
|
||||
let ctx = nav::NavContext {
|
||||
surface: Surface::Web,
|
||||
principal: &AllowAll,
|
||||
caps: &caps,
|
||||
apps: &apps,
|
||||
routes: &routes,
|
||||
};
|
||||
|
||||
let visible = nav::visible(&schema.menus, &ctx);
|
||||
let first = visible.first_tab().map(|(section, tab)| Active { section, tab });
|
||||
let active = first.unwrap_or(Active { section: "", tab: "" });
|
||||
|
||||
let body = maud::html! {
|
||||
section class="bf-card" {
|
||||
h1 class="bf-text-title" { "Alkane OS" }
|
||||
p class="bf-text-body" { "Schema-driven page. Sections and tabs above come from dashboard.json." }
|
||||
}
|
||||
};
|
||||
let assets = PageAssets::default();
|
||||
let page = shell::page("Alkane OS", &assets, &visible, active, body);
|
||||
let html = page.into_string();
|
||||
|
||||
if std::env::args().any(|arg| arg == "--size") {
|
||||
println!("html_bytes {}", html.len());
|
||||
println!("sections {}", visible.sections.len());
|
||||
for section in &visible.sections {
|
||||
println!("section {} ({}) tabs={}", section.slug, section.title, section.tabs.len());
|
||||
}
|
||||
} else {
|
||||
println!("{html}");
|
||||
}
|
||||
}
|
||||
+203
@@ -0,0 +1,203 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! BM1370 wire frames observed on an S21 Pro. This module does not control power.
|
||||
|
||||
use crate::bm13xx::{crc16, crc5};
|
||||
|
||||
pub use crate::bm1362::Job;
|
||||
|
||||
pub const JOB_BYTES: usize = 88;
|
||||
pub const REPORT_BYTES: usize = 11;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct NonceReport {
|
||||
pub nonce: u32,
|
||||
pub byte6: u8,
|
||||
pub byte7: u8,
|
||||
pub byte8: u8,
|
||||
pub byte9: u8,
|
||||
/// Raw trailer: bit 7 marks a nonce response; bits 4:0 carry CRC5.
|
||||
/// No chip identity is inferred from this byte.
|
||||
pub trailer: u8,
|
||||
}
|
||||
|
||||
impl NonceReport {
|
||||
/// Work ID observed in the Braiins S21 Pro capture. Chip and version
|
||||
/// attribution remain unknown, and this has no accepted-share proof.
|
||||
pub fn observed_work_id(&self) -> u8 {
|
||||
(self.byte7 & 0xf0) >> 1
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum ReportError {
|
||||
Length,
|
||||
Preamble,
|
||||
RegisterResponse,
|
||||
Checksum,
|
||||
}
|
||||
|
||||
/// Encode only the job shape observed in the S21 Pro capture. `Job` fields
|
||||
/// are in wire order; this does not validate a pool header or start a chain.
|
||||
pub fn encode_job(job: &Job) -> Option<[u8; JOB_BYTES]> {
|
||||
if job.work_id & 7 != 0 || job.num_midstates != 1 || job.start_nonce != 0 {
|
||||
return None;
|
||||
}
|
||||
let mut frame = crate::bm1362::encode_job(job);
|
||||
frame[3] = 0x36;
|
||||
let checksum = crc16(&frame[2..86]);
|
||||
frame[86..88].copy_from_slice(&checksum.to_be_bytes());
|
||||
Some(frame)
|
||||
}
|
||||
|
||||
/// Keep the five trailing bytes raw. The work-ID expression is correlated with
|
||||
/// same-UART jobs in one capture; chip and version mapping remain unverified.
|
||||
/// The marker bit distinguishes nonce reports from register replies.
|
||||
pub fn decode_nonce_report(frame: &[u8]) -> Result<NonceReport, ReportError> {
|
||||
if frame.len() != REPORT_BYTES {
|
||||
return Err(ReportError::Length);
|
||||
}
|
||||
if frame[..2] != [0xaa, 0x55] {
|
||||
return Err(ReportError::Preamble);
|
||||
}
|
||||
if frame[10] & 0x80 == 0 {
|
||||
return Err(ReportError::RegisterResponse);
|
||||
}
|
||||
if crc5(&frame[2..]) != 0 {
|
||||
return Err(ReportError::Checksum);
|
||||
}
|
||||
Ok(NonceReport {
|
||||
nonce: u32::from_le_bytes(frame[2..6].try_into().expect("four-byte nonce")),
|
||||
byte6: frame[6],
|
||||
byte7: frame[7],
|
||||
byte8: frame[8],
|
||||
byte9: frame[9],
|
||||
trailer: frame[10],
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
// firmware-analysis/prong-b/s21-192/c2-steady.strace, SHA-256
|
||||
// c0aac1222e05e95bdcbd1de5a8ee244a581256e8f28e3dadf5300df6110229c7.
|
||||
const CAPTURED_JOB: &str = concat!(
|
||||
"55aa21366001000000008f060217834f276af0f09aafc588165b7fbfc56f8f09a55d3d0de5",
|
||||
"798bd87460278af180c4696fc200000000000000008af701003acc10cdebe5bc3c90f095e5",
|
||||
"03c6b7de69ca8b5d00000020e769"
|
||||
);
|
||||
|
||||
fn captured_bytes<const N: usize>(hex: &str) -> [u8; N] {
|
||||
assert_eq!(hex.len(), N * 2);
|
||||
let mut bytes = [0; N];
|
||||
for (index, pair) in hex.as_bytes().chunks_exact(2).enumerate() {
|
||||
bytes[index] = u8::from_str_radix(std::str::from_utf8(pair).unwrap(), 16).unwrap();
|
||||
}
|
||||
bytes
|
||||
}
|
||||
|
||||
fn with_valid_crc(mut frame: [u8; REPORT_BYTES]) -> [u8; REPORT_BYTES] {
|
||||
for checksum in 0..32 {
|
||||
frame[10] = (frame[10] & 0xe0) | checksum;
|
||||
if crc5(&frame[2..]) == 0 {
|
||||
return frame;
|
||||
}
|
||||
}
|
||||
panic!("no valid CRC5 trailer");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn live_job_matches_all_88_bytes() {
|
||||
let captured = captured_bytes::<JOB_BYTES>(CAPTURED_JOB);
|
||||
let mut merkle_root = [0; 32];
|
||||
merkle_root.copy_from_slice(&captured[18..50]);
|
||||
let mut previous_hash = [0; 32];
|
||||
previous_hash.copy_from_slice(&captured[50..82]);
|
||||
let job = Job {
|
||||
work_id: captured[4],
|
||||
num_midstates: captured[5],
|
||||
start_nonce: u32::from_le_bytes(captured[6..10].try_into().unwrap()),
|
||||
nbits: u32::from_le_bytes(captured[10..14].try_into().unwrap()),
|
||||
ntime: u32::from_le_bytes(captured[14..18].try_into().unwrap()),
|
||||
merkle_root,
|
||||
previous_hash,
|
||||
version: u32::from_le_bytes(captured[82..86].try_into().unwrap()),
|
||||
};
|
||||
assert_eq!(encode_job(&job), Some(captured));
|
||||
let mut invalid = job;
|
||||
invalid.work_id |= 1;
|
||||
assert_eq!(encode_job(&invalid), None);
|
||||
invalid = job;
|
||||
invalid.num_midstates = 2;
|
||||
assert_eq!(encode_job(&invalid), None);
|
||||
invalid = job;
|
||||
invalid.start_nonce = 1;
|
||||
assert_eq!(encode_job(&invalid), None);
|
||||
assert_eq!(
|
||||
crc16(&captured[2..86]),
|
||||
u16::from_be_bytes([captured[86], captured[87]])
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn live_nonce_reports_preserve_raw_tags() {
|
||||
for hex in [
|
||||
"aa555804a92a041e133e86",
|
||||
"aa55771def23001c16fc82",
|
||||
"aa5574480ae6021417b492",
|
||||
] {
|
||||
let frame = captured_bytes::<REPORT_BYTES>(hex);
|
||||
let report = decode_nonce_report(&frame).unwrap();
|
||||
assert_eq!(
|
||||
report.nonce,
|
||||
u32::from_le_bytes(frame[2..6].try_into().unwrap())
|
||||
);
|
||||
assert_eq!(report.byte6, frame[6]);
|
||||
assert_eq!(report.byte7, frame[7]);
|
||||
assert_eq!(report.byte8, frame[8]);
|
||||
assert_eq!(report.byte9, frame[9]);
|
||||
assert_eq!(report.trailer, frame[10]);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn observed_work_id_matches_same_uart_job() {
|
||||
// c2-steady.strace lines 1287 and 1352: job byte 4 is 0x10.
|
||||
let frame = captured_bytes::<REPORT_BYTES>("aa554a3488c70022013291");
|
||||
let report = decode_nonce_report(&frame).unwrap();
|
||||
assert_eq!(report.observed_work_id(), 0x10);
|
||||
assert_eq!(report.byte7, 0x22);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_report_fails_closed() {
|
||||
let mut frame = captured_bytes::<REPORT_BYTES>("aa555804a92a041e133e86");
|
||||
assert_eq!(decode_nonce_report(&frame[..10]), Err(ReportError::Length));
|
||||
frame[0] = 0;
|
||||
assert_eq!(decode_nonce_report(&frame), Err(ReportError::Preamble));
|
||||
frame[0] = 0xaa;
|
||||
frame[10] &= 0x60;
|
||||
frame = with_valid_crc(frame);
|
||||
assert_eq!(crc5(&frame[2..]), 0);
|
||||
assert_eq!(
|
||||
decode_nonce_report(&frame),
|
||||
Err(ReportError::RegisterResponse)
|
||||
);
|
||||
frame[10] |= 0x80;
|
||||
frame = with_valid_crc(frame);
|
||||
frame[4] ^= 1;
|
||||
assert_eq!(decode_nonce_report(&frame), Err(ReportError::Checksum));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn trailer_low_bits_are_checksum_not_chip_identity() {
|
||||
let original = captured_bytes::<REPORT_BYTES>("aa555804a92a041e133e86");
|
||||
let mut changed_nonce = original;
|
||||
changed_nonce[2] ^= 1;
|
||||
changed_nonce = with_valid_crc(changed_nonce);
|
||||
assert_eq!(crc5(&changed_nonce[2..]), 0);
|
||||
assert_ne!(changed_nonce[10] & 0x1f, original[10] & 0x1f);
|
||||
assert_eq!(changed_nonce[10] & 0xe0, original[10] & 0xe0);
|
||||
assert!(decode_nonce_report(&changed_nonce).is_ok());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,364 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Schema-driven dashboard for the on-box UI.
|
||||
//!
|
||||
//! The sidebar, the tab strip and every settings control come from
|
||||
//! `schema/alkane-bb.json` through `flare-ui` and `wschema`; this module is the
|
||||
//! host boundary the crates expect: it owns the stored rows, applies a
|
||||
//! submitted form only after `wschema` validates it, and keeps the JSON API as
|
||||
//! the interface of record.
|
||||
//!
|
||||
//! Everything here is pure except `load` and `save`, which touch one file.
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use maud::Markup;
|
||||
use serde_json::{Map, Value};
|
||||
|
||||
use flare_ui::assets::PageAssets;
|
||||
use flare_ui::nav::{self, AllowAll, AppSet, CapSet, NavContext, VisibleNav};
|
||||
use flare_ui::url::Routes;
|
||||
use flare_ui::render::{self, View};
|
||||
use flare_ui::shell::{self, Active};
|
||||
use flare_ui::tokens;
|
||||
use wschema::effective::{self, Effective};
|
||||
use wschema::model::{Document, Surface};
|
||||
use wschema::validate::{Op, Rows};
|
||||
|
||||
/// The schema document is the single source of the UI.
|
||||
pub const SCHEMA: &str = include_str!("../schema/alkane-bb.json");
|
||||
|
||||
/// Capabilities this board reports, which decide what the sidebar shows.
|
||||
pub fn board_caps() -> CapSet {
|
||||
CapSet::new(["hashboard", "psu", "fan-map", "cgminer-api"])
|
||||
}
|
||||
|
||||
/// The dashboard: an effective schema plus the stored rows.
|
||||
pub struct Dashboard {
|
||||
effective: Result<Effective, String>,
|
||||
rows: Rows,
|
||||
path: PathBuf,
|
||||
}
|
||||
|
||||
impl Dashboard {
|
||||
/// Load the schema and the stored settings, defaulting absent rows to the
|
||||
/// schema's own defaults.
|
||||
pub fn load(path: impl AsRef<Path>) -> Dashboard {
|
||||
let path = path.as_ref().to_path_buf();
|
||||
let effective = Document::from_json(SCHEMA)
|
||||
.map_err(|error| error.to_string())
|
||||
.and_then(|doc| {
|
||||
effective::merge(&doc, &[]).map_err(|errors| {
|
||||
errors
|
||||
.iter()
|
||||
.map(|error| error.msg.clone())
|
||||
.collect::<Vec<_>>()
|
||||
.join("; ")
|
||||
})
|
||||
});
|
||||
let mut rows = Rows::new();
|
||||
if let Ok(text) = fs::read_to_string(&path) {
|
||||
if let Ok(Value::Object(map)) = serde_json::from_str::<Value>(&text) {
|
||||
for (key, value) in map {
|
||||
rows.insert(key, value);
|
||||
}
|
||||
}
|
||||
}
|
||||
Dashboard {
|
||||
effective,
|
||||
rows,
|
||||
path,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn schema(&self) -> Result<&Effective, String> {
|
||||
self.effective.as_ref().map_err(|error| error.clone())
|
||||
}
|
||||
|
||||
pub fn rows(&self) -> &Rows {
|
||||
&self.rows
|
||||
}
|
||||
|
||||
/// The visible navigation for this board and viewer.
|
||||
pub fn nav(&self) -> Result<VisibleNav, String> {
|
||||
let effective = self.effective.as_ref().map_err(|error| error.clone())?;
|
||||
let caps = board_caps();
|
||||
let apps = AppSet::default();
|
||||
let routes = Routes::console();
|
||||
let ctx = NavContext {
|
||||
surface: Surface::Web,
|
||||
principal: &AllowAll,
|
||||
caps: &caps,
|
||||
apps: &apps,
|
||||
routes: &routes,
|
||||
};
|
||||
Ok(nav::visible(&effective.doc.menus, &ctx))
|
||||
}
|
||||
|
||||
/// Stylesheets the shell needs, served from the crate's embedded assets.
|
||||
pub fn assets() -> PageAssets {
|
||||
PageAssets {
|
||||
styles: vec![
|
||||
"/assets/tokens.css".to_string(),
|
||||
"/assets/components.css".to_string(),
|
||||
"/assets/theme.css".to_string(),
|
||||
],
|
||||
scripts: Vec::new(),
|
||||
streams: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/// The three stylesheets, for the host to serve.
|
||||
pub fn stylesheets() -> [(&'static str, &'static str); 3] {
|
||||
[
|
||||
("tokens.css", tokens::TOKENS_CSS),
|
||||
("components.css", tokens::COMPONENTS_CSS),
|
||||
("theme.css", tokens::THEME_CSS),
|
||||
]
|
||||
}
|
||||
|
||||
/// Render one page: the shell around the settings card of the tab.
|
||||
///
|
||||
/// `section` is the navigation section (`settings`), `tab` the tab slug
|
||||
/// (`tuning`), and the settings card shows the group named by the tab.
|
||||
///
|
||||
/// `errors` carries per-path messages from a rejected submission, so the
|
||||
/// same render can show what went wrong.
|
||||
pub fn page(&self, section: &str, tab: &str, errors: &BTreeMap<String, String>) -> Markup {
|
||||
let effective = match self.effective.as_ref() {
|
||||
Ok(effective) => effective,
|
||||
Err(error) => {
|
||||
return maud::html! {
|
||||
main class="bf-main" {
|
||||
p class="bf-field-error bf-text-body" role="alert" { "Schema did not load: " (error) }
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
let nav = self.nav().unwrap_or_default();
|
||||
let view = View {
|
||||
eff: effective,
|
||||
rows: &self.rows,
|
||||
errors,
|
||||
surface: Surface::Web,
|
||||
can_write: true,
|
||||
};
|
||||
let title = effective
|
||||
.doc
|
||||
.menus
|
||||
.iter()
|
||||
.find(|menu| menu.slug == tab && menu.id.starts_with(&format!("{section}/")))
|
||||
.map(|menu| menu.title.clone())
|
||||
.unwrap_or_else(|| section.to_string());
|
||||
let card = render::card(&title, tab, &view);
|
||||
let body = maud::html! {
|
||||
section class="bf-card" {
|
||||
h1 class="bf-text-title" { (title) }
|
||||
(card)
|
||||
}
|
||||
};
|
||||
shell::page("Alkane OS", &Self::assets(), &nav, Active { section, tab }, body)
|
||||
}
|
||||
|
||||
/// Apply a submitted form body (`application/x-www-form-urlencoded`).
|
||||
///
|
||||
/// Returns the per-path failures when the schema rejects the batch, and
|
||||
/// persists nothing in that case. Unknown keys are ignored: they are not in
|
||||
/// the schema, so they cannot be written.
|
||||
pub fn submit(&mut self, body: &str) -> Result<(), BTreeMap<String, String>> {
|
||||
let effective = match self.effective.as_ref() {
|
||||
Ok(effective) => effective,
|
||||
Err(error) => {
|
||||
let mut failures = BTreeMap::new();
|
||||
failures.insert(String::new(), error.clone());
|
||||
return Err(failures);
|
||||
}
|
||||
};
|
||||
let ops = self.parse_ops(effective, body);
|
||||
let failures = render::validate_form(effective, &ops, &self.rows, wschema::validate::Origin::Web, None);
|
||||
if !failures.is_empty() {
|
||||
return Err(failures);
|
||||
}
|
||||
for op in &ops {
|
||||
if let Op::Set { path, value } = op {
|
||||
self.rows.insert(path.clone(), value.clone());
|
||||
}
|
||||
}
|
||||
let map: Map<String, Value> = self
|
||||
.rows
|
||||
.iter()
|
||||
.map(|(key, value)| (key.clone(), value.clone()))
|
||||
.collect();
|
||||
let text = serde_json::to_string_pretty(&Value::Object(map)).unwrap_or_else(|_| "{}".into());
|
||||
if let Some(parent) = self.path.parent() {
|
||||
let _ = fs::create_dir_all(parent);
|
||||
}
|
||||
// Persist only after validation passed; a failed write leaves the rows
|
||||
// changed in memory but never on disk, which the API reports.
|
||||
let _ = fs::write(&self.path, text);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Turn a form body into schema ops, coercing each value to its declared kind.
|
||||
fn parse_ops(&self, effective: &Effective, body: &str) -> Vec<Op> {
|
||||
let mut ops = Vec::new();
|
||||
for pair in body.split('&') {
|
||||
if pair.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let (raw_key, raw_value) = pair.split_once('=').unwrap_or((pair, ""));
|
||||
let key = percent_decode(raw_key);
|
||||
let raw = percent_decode(raw_value);
|
||||
let setting = match effective.setting(&key) {
|
||||
Some(setting) => setting,
|
||||
None => continue,
|
||||
};
|
||||
let value = coerce(setting.kind.token(), &raw);
|
||||
ops.push(Op::Set {
|
||||
path: setting.path.clone(),
|
||||
value,
|
||||
});
|
||||
}
|
||||
ops
|
||||
}
|
||||
}
|
||||
|
||||
fn percent_decode(text: &str) -> String {
|
||||
let bytes = text.as_bytes();
|
||||
let mut out = Vec::with_capacity(bytes.len());
|
||||
let mut index = 0;
|
||||
while index < bytes.len() {
|
||||
match bytes[index] {
|
||||
b'+' => {
|
||||
out.push(b' ');
|
||||
index += 1;
|
||||
}
|
||||
b'%' if index + 2 < bytes.len() => {
|
||||
let high = (bytes[index + 1] as char).to_digit(16);
|
||||
let low = (bytes[index + 2] as char).to_digit(16);
|
||||
match (high, low) {
|
||||
(Some(high), Some(low)) => {
|
||||
out.push((high * 16 + low) as u8);
|
||||
index += 3;
|
||||
}
|
||||
_ => {
|
||||
out.push(bytes[index]);
|
||||
index += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
byte => {
|
||||
out.push(byte);
|
||||
index += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
String::from_utf8_lossy(&out).into_owned()
|
||||
}
|
||||
|
||||
fn coerce(kind: &str, raw: &str) -> Value {
|
||||
match kind {
|
||||
"int" | "int_set" => raw
|
||||
.trim()
|
||||
.parse::<i64>()
|
||||
.map(Value::from)
|
||||
.unwrap_or_else(|_| Value::String(raw.to_string())),
|
||||
"bool" => Value::Bool(matches!(raw, "true" | "on" | "1")),
|
||||
_ => Value::String(raw.to_string()),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn temp_path(name: &str) -> PathBuf {
|
||||
let mut path = std::env::temp_dir();
|
||||
path.push(format!("alkane-dashboard-{name}-{}.json", std::process::id()));
|
||||
let _ = fs::remove_file(&path);
|
||||
path
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_schema_loads_and_yields_the_three_sections() {
|
||||
let dash = Dashboard::load(temp_path("load"));
|
||||
let effective = dash.schema().expect("schema loads");
|
||||
assert_eq!(effective.doc.menus.len(), 17);
|
||||
let nav = dash.nav().expect("nav builds");
|
||||
assert_eq!(nav.sections.len(), 3);
|
||||
assert_eq!(nav.sections[1].slug, "mining");
|
||||
assert_eq!(nav.sections[1].tabs.len(), 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_scaffolded_setting_is_in_the_schema() {
|
||||
let dash = Dashboard::load(temp_path("settings"));
|
||||
let effective = dash.schema().expect("schema loads");
|
||||
for path in [
|
||||
"tuning.mode",
|
||||
"tuning.power_w",
|
||||
"tuning.ceiling_mc",
|
||||
"tuning.pid.kp_milli",
|
||||
"tuning.pid.deadband_milli",
|
||||
"fans.zone_count",
|
||||
"fans.pwm_min",
|
||||
"detect.chain_ports",
|
||||
"detect.probe_budget",
|
||||
"profiles.db",
|
||||
"system.name",
|
||||
] {
|
||||
assert!(effective.setting(path).is_some(), "{path} is missing from the schema");
|
||||
}
|
||||
assert_eq!(effective.doc.settings.len(), 20);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_page_renders_its_settings_with_inputs() {
|
||||
let dash = Dashboard::load(temp_path("page"));
|
||||
let html = dash.page("settings", "tuning", &BTreeMap::new()).into_string();
|
||||
assert!(html.contains("bf-sidebar"), "the unified sidebar is missing");
|
||||
assert!(html.contains("bf-tabs"), "the tab strip is missing");
|
||||
assert!(html.contains("Tuning target"), "a settings label is missing");
|
||||
assert!(html.contains("tuning.power_w"), "the field path is missing");
|
||||
assert!(html.contains("name=\"tuning.mode\""), "the mode field is missing");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_valid_submission_is_persisted_and_reloaded() {
|
||||
let path = temp_path("submit");
|
||||
let mut dash = Dashboard::load(&path);
|
||||
dash.submit("tuning.power_w=1500&system.name=s19jpro").expect("valid form");
|
||||
assert_eq!(dash.rows().get("tuning.power_w"), Some(&serde_json::json!(1500)));
|
||||
let stored = fs::read_to_string(&path).expect("settings file written");
|
||||
assert!(stored.contains("\"tuning.power_w\": 1500"), "{stored}");
|
||||
let reloaded = Dashboard::load(&path);
|
||||
assert_eq!(reloaded.rows().get("system.name"), Some(&serde_json::json!("s19jpro")));
|
||||
let _ = fs::remove_file(&path);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_out_of_range_value_is_rejected_and_nothing_is_written() {
|
||||
let path = temp_path("reject");
|
||||
let mut dash = Dashboard::load(&path);
|
||||
let failures = dash.submit("tuning.power_w=99999").expect_err("must be rejected");
|
||||
assert!(failures.keys().any(|key| key.contains("tuning.power_w")), "{failures:?}");
|
||||
assert!(!path.exists(), "a rejected submission must not be persisted");
|
||||
assert_eq!(dash.rows().get("tuning.power_w"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unknown_form_keys_are_ignored() {
|
||||
let path = temp_path("unknown");
|
||||
let mut dash = Dashboard::load(&path);
|
||||
dash.submit("not.a.setting=1&tuning.ceiling_mc=650").expect("known key applies");
|
||||
assert_eq!(dash.rows().get("not.a.setting"), None);
|
||||
assert_eq!(dash.rows().get("tuning.ceiling_mc"), Some(&serde_json::json!(650)));
|
||||
let _ = fs::remove_file(&path);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn form_values_are_percent_decoded() {
|
||||
assert_eq!(percent_decode("a+b%2Fc"), "a b/c");
|
||||
}
|
||||
}
|
||||
+761
@@ -0,0 +1,761 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Hardware detection model.
|
||||
//!
|
||||
//! The detection core decides what is physically attached to a control board and whether that
|
||||
//! combination is safe to run. It never talks to a chain directly; backends report what they
|
||||
//! probed, and this module turns that into a `HardwarePlan` the miner can execute.
|
||||
//!
|
||||
//! Identification deliberately does not require a hashboard EEPROM. The EEPROM, when present and
|
||||
//! valid, confirms a board revision; a chain probe alone is enough to select a chip profile.
|
||||
|
||||
/// Chip families the detection core can name. `Unknown` is a real answer, not a placeholder.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum ChipModel {
|
||||
Bm1362,
|
||||
Bm1366,
|
||||
Bm1368,
|
||||
Bm1370,
|
||||
Bm1398,
|
||||
Unknown,
|
||||
}
|
||||
|
||||
impl ChipModel {
|
||||
/// Stable wire/API name for this chip family.
|
||||
pub fn name(self) -> &'static str {
|
||||
match self {
|
||||
Self::Bm1362 => "bm1362",
|
||||
Self::Bm1366 => "bm1366",
|
||||
Self::Bm1368 => "bm1368",
|
||||
Self::Bm1370 => "bm1370",
|
||||
Self::Bm1398 => "bm1398",
|
||||
Self::Unknown => "unknown",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// How a chain reports temperature. PIC boards proxy telemetry through the power MCU.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum SensorTopology {
|
||||
Pic,
|
||||
NoPic,
|
||||
Unknown,
|
||||
}
|
||||
|
||||
/// State of a hashboard EEPROM. Absence is normal and must never block detection.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub enum EepromState {
|
||||
Present { model: String },
|
||||
Absent,
|
||||
Invalid,
|
||||
}
|
||||
|
||||
/// What a backend observed on one physical chain.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct ChainReport {
|
||||
pub index: u8,
|
||||
pub chip: ChipModel,
|
||||
pub chips_found: u16,
|
||||
pub eeprom: EepromState,
|
||||
/// Nonce responses per mille of dispatched work, when the backend could measure it.
|
||||
pub response_per_mille: Option<u16>,
|
||||
}
|
||||
|
||||
impl ChainReport {
|
||||
pub fn is_identified(&self) -> bool {
|
||||
self.chip != ChipModel::Unknown && self.chips_found > 0
|
||||
}
|
||||
}
|
||||
|
||||
/// Safe operating envelope for one hashboard/chip profile, from the profile database.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct Envelope {
|
||||
pub v_min_mv: u16,
|
||||
pub v_max_mv: u16,
|
||||
pub f_min_mhz: u16,
|
||||
pub f_max_mhz: u16,
|
||||
}
|
||||
|
||||
impl Envelope {
|
||||
/// Voltage that pairs with a frequency across this envelope.
|
||||
///
|
||||
/// Voltage follows frequency linearly between the profile's floor and ceiling and is clamped
|
||||
/// outside it. Boards do not run at a fixed voltage across their frequency range, so reporting
|
||||
/// one voltage while the frequency moves would describe a machine that does not exist.
|
||||
pub fn voltage_for(self, frequency_mhz: u16) -> u16 {
|
||||
if frequency_mhz <= self.f_min_mhz {
|
||||
return self.v_min_mv;
|
||||
}
|
||||
if frequency_mhz >= self.f_max_mhz {
|
||||
return self.v_max_mv;
|
||||
}
|
||||
let span_f = u32::from(self.f_max_mhz - self.f_min_mhz);
|
||||
let span_v = u32::from(self.v_max_mv - self.v_min_mv);
|
||||
let offset = u32::from(frequency_mhz - self.f_min_mhz);
|
||||
let voltage = u32::from(self.v_min_mv) + (span_v * offset) / span_f;
|
||||
voltage.min(u32::from(u16::MAX)) as u16
|
||||
}
|
||||
|
||||
pub fn intersect(self, other: Envelope) -> Option<Envelope> {
|
||||
let v_min_mv = self.v_min_mv.max(other.v_min_mv);
|
||||
let v_max_mv = self.v_max_mv.min(other.v_max_mv);
|
||||
let f_min_mhz = self.f_min_mhz.max(other.f_min_mhz);
|
||||
let f_max_mhz = self.f_max_mhz.min(other.f_max_mhz);
|
||||
if v_min_mv > v_max_mv || f_min_mhz > f_max_mhz {
|
||||
return None;
|
||||
}
|
||||
Some(Envelope {
|
||||
v_min_mv,
|
||||
v_max_mv,
|
||||
f_min_mhz,
|
||||
f_max_mhz,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// A hashboard profile from the database.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct BoardProfile {
|
||||
pub name: String,
|
||||
pub chip: ChipModel,
|
||||
pub sensor: SensorTopology,
|
||||
pub chains: u8,
|
||||
pub envelope: Envelope,
|
||||
}
|
||||
|
||||
/// What the PSU reports about itself and what it can deliver.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct PsuCapability {
|
||||
pub name: String,
|
||||
pub envelope: Envelope,
|
||||
pub max_dc_watts: u16,
|
||||
}
|
||||
|
||||
/// Which fans cool which thermal zones, learned by active probing.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct FanZone {
|
||||
pub fan: u8,
|
||||
pub zones: Vec<u8>,
|
||||
}
|
||||
|
||||
/// Why detection refused a combination.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum DetectionError {
|
||||
NoChains,
|
||||
UnknownChip,
|
||||
ChipProfileMismatch,
|
||||
PsuUnidentified,
|
||||
EnvelopeEmpty,
|
||||
}
|
||||
|
||||
/// Operating point chosen for the machine.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct OperatingPoint {
|
||||
pub voltage_mv: u16,
|
||||
pub frequency_mhz: u16,
|
||||
/// True when the profile was confirmed by an EEPROM or a full chain identification.
|
||||
pub confirmed: bool,
|
||||
}
|
||||
|
||||
/// The result of detection: everything the miner needs and nothing it has to guess.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct HardwarePlan {
|
||||
pub profile: String,
|
||||
pub chip: ChipModel,
|
||||
pub chains: Vec<ChainReport>,
|
||||
pub envelope: Envelope,
|
||||
pub operating_point: OperatingPoint,
|
||||
pub psu: String,
|
||||
pub fan_zones: Vec<FanZone>,
|
||||
}
|
||||
|
||||
impl HardwarePlan {
|
||||
/// Chains that identified but reported no nonces, or fewer than expected chips.
|
||||
pub fn degraded_chains(&self, expected: u16) -> Vec<u8> {
|
||||
self.chains
|
||||
.iter()
|
||||
.filter(|chain| {
|
||||
chain.chips_found < expected
|
||||
|| chain.response_per_mille.is_some_and(|ratio| ratio == 0)
|
||||
})
|
||||
.map(|chain| chain.index)
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
|
||||
/// Turn observations into a plan, or refuse.
|
||||
///
|
||||
/// Refusal is a feature: an unverified or out-of-envelope combination must not mine silently.
|
||||
pub fn plan(
|
||||
chains: &[ChainReport],
|
||||
profile: &BoardProfile,
|
||||
psu: Option<&PsuCapability>,
|
||||
fan_zones: Vec<FanZone>,
|
||||
) -> Result<HardwarePlan, DetectionError> {
|
||||
if chains.is_empty() {
|
||||
return Err(DetectionError::NoChains);
|
||||
}
|
||||
if chains.iter().all(|chain| chain.chip == ChipModel::Unknown) {
|
||||
return Err(DetectionError::UnknownChip);
|
||||
}
|
||||
if chains
|
||||
.iter()
|
||||
.filter(|chain| chain.is_identified())
|
||||
.any(|chain| chain.chip != profile.chip)
|
||||
{
|
||||
return Err(DetectionError::ChipProfileMismatch);
|
||||
}
|
||||
let psu = psu.ok_or(DetectionError::PsuUnidentified)?;
|
||||
let envelope = profile
|
||||
.envelope
|
||||
.intersect(psu.envelope)
|
||||
.ok_or(DetectionError::EnvelopeEmpty)?;
|
||||
let confirmed = chains
|
||||
.iter()
|
||||
.any(|chain| matches!(chain.eeprom, EepromState::Present { .. }))
|
||||
&& chains.iter().all(ChainReport::is_identified);
|
||||
let operating_point = if confirmed {
|
||||
OperatingPoint {
|
||||
voltage_mv: envelope.v_max_mv.min(profile.envelope.v_max_mv),
|
||||
frequency_mhz: envelope.f_max_mhz.min(profile.envelope.f_max_mhz),
|
||||
confirmed: true,
|
||||
}
|
||||
} else {
|
||||
// Unverified hardware runs at the conservative floor of the usable envelope.
|
||||
OperatingPoint {
|
||||
voltage_mv: envelope.v_min_mv,
|
||||
frequency_mhz: envelope.f_min_mhz,
|
||||
confirmed: false,
|
||||
}
|
||||
};
|
||||
Ok(HardwarePlan {
|
||||
profile: profile.name.clone(),
|
||||
chip: profile.chip,
|
||||
chains: chains.to_vec(),
|
||||
envelope,
|
||||
operating_point,
|
||||
psu: psu.name.clone(),
|
||||
fan_zones,
|
||||
})
|
||||
}
|
||||
|
||||
/// Outcome of one chip-identification attempt on a chain.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum ProbeOutcome {
|
||||
/// Chips answered: the model and how many responded.
|
||||
Identified { chip: ChipModel, chips: u16 },
|
||||
/// The port is electrically silent (no signal at all).
|
||||
Silent,
|
||||
/// Bytes arrived but did not frame as a chip response: wrong baud, noise, or a dead TX.
|
||||
Garbled,
|
||||
}
|
||||
|
||||
/// Backend contract for identification.
|
||||
///
|
||||
/// Framing, baud switching and electrical detail stay in the SDK image for that family; the OS
|
||||
/// only decides how many attempts to spend and what the results mean.
|
||||
pub trait DetectionBackend {
|
||||
type Error;
|
||||
|
||||
/// Attempt one identification on `chain`. `attempt` lets the backend cycle its candidate
|
||||
/// interface/baud set deterministically. A transport failure is an error, never `Silent`.
|
||||
fn probe(&mut self, chain: u8, attempt: u8) -> Result<ProbeOutcome, Self::Error>;
|
||||
/// Read the hashboard EEPROM, or report that it is absent or unreadable.
|
||||
fn eeprom(&mut self, chain: u8) -> Result<EepromState, Self::Error>;
|
||||
/// Identify the PSU, if this backend can. `None` means "cannot tell", which refuses later.
|
||||
fn identify_psu(&mut self) -> Result<Option<PsuCapability>, Self::Error>;
|
||||
}
|
||||
|
||||
/// How many identification attempts to spend per chain before declaring it unidentified.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct ProbeBudget {
|
||||
pub attempts: u8,
|
||||
}
|
||||
|
||||
impl Default for ProbeBudget {
|
||||
fn default() -> Self {
|
||||
Self { attempts: 4 }
|
||||
}
|
||||
}
|
||||
|
||||
/// Probe one chain until it identifies or the budget is spent.
|
||||
///
|
||||
/// A chain that never identifies is reported as `ChipModel::Unknown` with zero chips rather than
|
||||
/// being dropped, so the plan can refuse explicitly and the API can show why.
|
||||
pub fn probe_chain<B: DetectionBackend>(
|
||||
backend: &mut B,
|
||||
chain: u8,
|
||||
budget: ProbeBudget,
|
||||
) -> Result<ChainReport, B::Error> {
|
||||
let mut outcome = ProbeOutcome::Silent;
|
||||
for attempt in 0..budget.attempts.max(1) {
|
||||
outcome = backend.probe(chain, attempt)?;
|
||||
if matches!(outcome, ProbeOutcome::Identified { .. }) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
let (chip, chips_found) = match outcome {
|
||||
ProbeOutcome::Identified { chip, chips } => (chip, chips),
|
||||
_ => (ChipModel::Unknown, 0),
|
||||
};
|
||||
Ok(ChainReport {
|
||||
index: chain,
|
||||
chip,
|
||||
chips_found,
|
||||
eeprom: backend.eeprom(chain)?,
|
||||
response_per_mille: None,
|
||||
})
|
||||
}
|
||||
|
||||
/// Probe every declared chain port.
|
||||
pub fn detect_chains<B: DetectionBackend>(
|
||||
backend: &mut B,
|
||||
chains: &[u8],
|
||||
budget: ProbeBudget,
|
||||
) -> Result<Vec<ChainReport>, B::Error> {
|
||||
let mut reports = Vec::with_capacity(chains.len());
|
||||
for &chain in chains {
|
||||
reports.push(probe_chain(backend, chain, budget)?);
|
||||
}
|
||||
Ok(reports)
|
||||
}
|
||||
|
||||
/// Everything the caller knows before probing: which ports exist, how hard to try, and how the
|
||||
/// hashboards report temperature.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct DetectionRequest<'a> {
|
||||
pub chain_ports: &'a [u8],
|
||||
pub budget: ProbeBudget,
|
||||
pub sensor: SensorTopology,
|
||||
pub fan_zones: Vec<FanZone>,
|
||||
}
|
||||
|
||||
/// Why a detection run did not produce a plan.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub enum DetectionFailure<E> {
|
||||
Backend(E),
|
||||
Refused(DetectionError),
|
||||
NoProfile,
|
||||
}
|
||||
|
||||
/// Detect, select a profile, and decide whether the machine may run.
|
||||
///
|
||||
/// The profile is selected by chip, sensor wiring and the number of physical chain ports, so a
|
||||
/// machine with a dead chain still matches its profile and runs degraded instead of being
|
||||
/// reclassified as a different model.
|
||||
pub fn run_detection<B: DetectionBackend>(
|
||||
backend: &mut B,
|
||||
db: &crate::profiles::ProfileDb,
|
||||
request: &DetectionRequest<'_>,
|
||||
) -> Result<HardwarePlan, DetectionFailure<B::Error>> {
|
||||
let reports = detect_chains(backend, request.chain_ports, request.budget)
|
||||
.map_err(DetectionFailure::Backend)?;
|
||||
let chip = reports
|
||||
.iter()
|
||||
.find(|report| report.is_identified())
|
||||
.map(|report| report.chip)
|
||||
.ok_or(DetectionFailure::Refused(DetectionError::UnknownChip))?;
|
||||
let chains = u8::try_from(request.chain_ports.len()).unwrap_or(u8::MAX);
|
||||
let profile = db
|
||||
.find(chip, chains, request.sensor)
|
||||
.ok_or(DetectionFailure::NoProfile)?;
|
||||
let psu = backend.identify_psu().map_err(DetectionFailure::Backend)?;
|
||||
plan(&reports, profile, psu.as_ref(), request.fan_zones.clone())
|
||||
.map_err(DetectionFailure::Refused)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn profile() -> BoardProfile {
|
||||
BoardProfile {
|
||||
name: "s19jpro-bm1362".into(),
|
||||
chip: ChipModel::Bm1362,
|
||||
sensor: SensorTopology::Pic,
|
||||
chains: 3,
|
||||
envelope: Envelope {
|
||||
v_min_mv: 1100,
|
||||
v_max_mv: 1500,
|
||||
f_min_mhz: 300,
|
||||
f_max_mhz: 700,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn psu() -> PsuCapability {
|
||||
PsuCapability {
|
||||
name: "APW12".into(),
|
||||
envelope: Envelope {
|
||||
v_min_mv: 1200,
|
||||
v_max_mv: 1600,
|
||||
f_min_mhz: 0,
|
||||
f_max_mhz: 1000,
|
||||
},
|
||||
max_dc_watts: 3600,
|
||||
}
|
||||
}
|
||||
|
||||
fn chain(index: u8, eeprom: EepromState) -> ChainReport {
|
||||
ChainReport {
|
||||
index,
|
||||
chip: ChipModel::Bm1362,
|
||||
chips_found: 126,
|
||||
eeprom,
|
||||
response_per_mille: Some(980),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn confirmed_plan_uses_verified_ceiling() {
|
||||
let chains = [chain(
|
||||
0,
|
||||
EepromState::Present {
|
||||
model: "BHB42601".into(),
|
||||
},
|
||||
)];
|
||||
let plan = plan(&chains, &profile(), Some(&psu()), Vec::new()).expect("plan");
|
||||
assert!(plan.operating_point.confirmed);
|
||||
assert_eq!(plan.operating_point.voltage_mv, 1500);
|
||||
assert_eq!(plan.operating_point.frequency_mhz, 700);
|
||||
assert_eq!(plan.envelope.v_min_mv, 1200);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn absent_eeprom_still_yields_a_conservative_plan() {
|
||||
let chains = [chain(0, EepromState::Absent)];
|
||||
let plan = plan(&chains, &profile(), Some(&psu()), Vec::new()).expect("plan");
|
||||
assert!(!plan.operating_point.confirmed);
|
||||
assert_eq!(plan.operating_point.voltage_mv, plan.envelope.v_min_mv);
|
||||
assert_eq!(plan.operating_point.frequency_mhz, plan.envelope.f_min_mhz);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unknown_chip_refuses() {
|
||||
let mut chains = [chain(0, EepromState::Absent)];
|
||||
chains[0].chip = ChipModel::Unknown;
|
||||
assert_eq!(
|
||||
plan(&chains, &profile(), Some(&psu()), Vec::new()),
|
||||
Err(DetectionError::UnknownChip)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wrong_chip_refuses() {
|
||||
let mut chains = [chain(0, EepromState::Absent)];
|
||||
chains[0].chip = ChipModel::Bm1366;
|
||||
assert_eq!(
|
||||
plan(&chains, &profile(), Some(&psu()), Vec::new()),
|
||||
Err(DetectionError::ChipProfileMismatch)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn missing_psu_refuses() {
|
||||
let chains = [chain(0, EepromState::Absent)];
|
||||
assert_eq!(
|
||||
plan(&chains, &profile(), None, Vec::new()),
|
||||
Err(DetectionError::PsuUnidentified)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn incompatible_psu_refuses() {
|
||||
let chains = [chain(0, EepromState::Absent)];
|
||||
let weak = PsuCapability {
|
||||
name: "APW3".into(),
|
||||
envelope: Envelope {
|
||||
v_min_mv: 700,
|
||||
v_max_mv: 1090,
|
||||
f_min_mhz: 0,
|
||||
f_max_mhz: 1000,
|
||||
},
|
||||
max_dc_watts: 1600,
|
||||
};
|
||||
assert_eq!(
|
||||
plan(&chains, &profile(), Some(&weak), Vec::new()),
|
||||
Err(DetectionError::EnvelopeEmpty)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn empty_chain_set_refuses() {
|
||||
assert_eq!(
|
||||
plan(&[], &profile(), Some(&psu()), Vec::new()),
|
||||
Err(DetectionError::NoChains)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn degraded_chains_are_reported_not_fatal() {
|
||||
let mut silent = chain(1, EepromState::Absent);
|
||||
silent.response_per_mille = Some(0);
|
||||
let chains = [chain(0, EepromState::Absent), silent];
|
||||
let plan = plan(&chains, &profile(), Some(&psu()), Vec::new()).expect("plan");
|
||||
assert_eq!(plan.degraded_chains(126), vec![1]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fan_zones_are_carried_into_the_plan() {
|
||||
let chains = [chain(0, EepromState::Absent)];
|
||||
let zones = vec![FanZone {
|
||||
fan: 0,
|
||||
zones: vec![0, 1],
|
||||
}];
|
||||
let plan = plan(&chains, &profile(), Some(&psu()), zones.clone()).expect("plan");
|
||||
assert_eq!(plan.fan_zones, zones);
|
||||
}
|
||||
|
||||
struct ScriptedProbe {
|
||||
plan: std::collections::VecDeque<ProbeOutcome>,
|
||||
eeprom: EepromState,
|
||||
calls: usize,
|
||||
fail_at: u8,
|
||||
psu: Option<PsuCapability>,
|
||||
}
|
||||
|
||||
impl ScriptedProbe {
|
||||
fn new(plan: &[ProbeOutcome], eeprom: EepromState) -> Self {
|
||||
Self {
|
||||
plan: plan.iter().copied().collect(),
|
||||
eeprom,
|
||||
calls: 0,
|
||||
fail_at: u8::MAX,
|
||||
psu: Some(psu()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl DetectionBackend for ScriptedProbe {
|
||||
type Error = ();
|
||||
|
||||
fn probe(&mut self, _chain: u8, attempt: u8) -> Result<ProbeOutcome, ()> {
|
||||
self.calls += 1;
|
||||
if attempt == self.fail_at {
|
||||
return Err(());
|
||||
}
|
||||
Ok(self.plan.pop_front().unwrap_or(ProbeOutcome::Silent))
|
||||
}
|
||||
|
||||
fn eeprom(&mut self, _chain: u8) -> Result<EepromState, ()> {
|
||||
Ok(self.eeprom.clone())
|
||||
}
|
||||
|
||||
fn identify_psu(&mut self) -> Result<Option<PsuCapability>, ()> {
|
||||
Ok(self.psu.clone())
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn probe_retries_until_the_chain_identifies() {
|
||||
let mut backend = ScriptedProbe::new(
|
||||
&[
|
||||
ProbeOutcome::Silent,
|
||||
ProbeOutcome::Garbled,
|
||||
ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
],
|
||||
EepromState::Absent,
|
||||
);
|
||||
let report = probe_chain(&mut backend, 0, ProbeBudget { attempts: 4 }).expect("probe");
|
||||
assert_eq!(backend.calls, 3);
|
||||
assert_eq!(report.chip, ChipModel::Bm1362);
|
||||
assert_eq!(report.chips_found, 126);
|
||||
assert!(report.is_identified());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn probe_exhaustion_is_reported_not_hidden() {
|
||||
let mut backend = ScriptedProbe::new(&[ProbeOutcome::Silent; 4], EepromState::Absent);
|
||||
let report = probe_chain(&mut backend, 1, ProbeBudget { attempts: 4 }).expect("probe");
|
||||
assert_eq!(backend.calls, 4);
|
||||
assert_eq!(report.chip, ChipModel::Unknown);
|
||||
assert_eq!(report.chips_found, 0);
|
||||
assert!(!report.is_identified());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn probe_keeps_the_eeprom_state_even_when_unidentified() {
|
||||
let mut backend = ScriptedProbe::new(
|
||||
&[ProbeOutcome::Garbled; 2],
|
||||
EepromState::Present {
|
||||
model: "BHB42601".into(),
|
||||
},
|
||||
);
|
||||
let report = probe_chain(&mut backend, 2, ProbeBudget { attempts: 2 }).expect("probe");
|
||||
assert_eq!(report.chip, ChipModel::Unknown);
|
||||
assert_eq!(
|
||||
report.eeprom,
|
||||
EepromState::Present {
|
||||
model: "BHB42601".into()
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn detection_covers_every_declared_chain_port() {
|
||||
let mut backend = ScriptedProbe::new(
|
||||
&[
|
||||
ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
],
|
||||
EepromState::Absent,
|
||||
);
|
||||
let reports =
|
||||
detect_chains(&mut backend, &[0, 1, 2], ProbeBudget::default()).expect("detect");
|
||||
assert_eq!(reports.len(), 3);
|
||||
assert_eq!(
|
||||
reports.iter().map(|r| r.index).collect::<Vec<_>>(),
|
||||
vec![0, 1, 2]
|
||||
);
|
||||
assert!(reports.iter().all(ChainReport::is_identified));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn transport_failure_is_not_reported_as_a_silent_port() {
|
||||
let mut backend = ScriptedProbe::new(&[ProbeOutcome::Silent; 4], EepromState::Absent);
|
||||
backend.fail_at = 1;
|
||||
assert_eq!(
|
||||
probe_chain(&mut backend, 0, ProbeBudget::default()),
|
||||
Err(())
|
||||
);
|
||||
assert_eq!(backend.calls, 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unidentified_chain_makes_the_plan_refuse() {
|
||||
let mut backend = ScriptedProbe::new(&[ProbeOutcome::Silent; 4], EepromState::Absent);
|
||||
let reports = detect_chains(&mut backend, &[0], ProbeBudget::default()).expect("detect");
|
||||
assert_eq!(
|
||||
plan(&reports, &profile(), Some(&psu()), Vec::new()),
|
||||
Err(DetectionError::UnknownChip)
|
||||
);
|
||||
}
|
||||
|
||||
fn db() -> crate::profiles::ProfileDb {
|
||||
crate::profiles::ProfileDb::new(vec![profile()]).expect("db")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn run_detection_emits_a_plan_end_to_end() {
|
||||
let mut backend = ScriptedProbe::new(
|
||||
&[
|
||||
ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
],
|
||||
EepromState::Absent,
|
||||
);
|
||||
let request = DetectionRequest {
|
||||
chain_ports: &[0, 1, 2],
|
||||
budget: ProbeBudget::default(),
|
||||
sensor: SensorTopology::Pic,
|
||||
fan_zones: vec![FanZone {
|
||||
fan: 0,
|
||||
zones: vec![0],
|
||||
}],
|
||||
};
|
||||
let plan = run_detection(&mut backend, &db(), &request).expect("plan");
|
||||
assert_eq!(plan.chains.len(), 3);
|
||||
assert_eq!(plan.psu, "APW12");
|
||||
assert!(!plan.operating_point.confirmed);
|
||||
assert_eq!(plan.operating_point.voltage_mv, 1200);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn run_detection_refuses_when_no_profile_matches() {
|
||||
let mut backend = ScriptedProbe::new(
|
||||
&[ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
}],
|
||||
EepromState::Absent,
|
||||
);
|
||||
let request = DetectionRequest {
|
||||
chain_ports: &[0],
|
||||
budget: ProbeBudget::default(),
|
||||
sensor: SensorTopology::Pic,
|
||||
fan_zones: Vec::new(),
|
||||
};
|
||||
assert_eq!(
|
||||
run_detection(&mut backend, &db(), &request),
|
||||
Err(DetectionFailure::NoProfile)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn run_detection_runs_degraded_with_a_dead_chain() {
|
||||
let mut backend = ScriptedProbe::new(
|
||||
&[
|
||||
ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
ProbeOutcome::Identified {
|
||||
chip: ChipModel::Bm1362,
|
||||
chips: 126,
|
||||
},
|
||||
ProbeOutcome::Silent,
|
||||
ProbeOutcome::Silent,
|
||||
ProbeOutcome::Silent,
|
||||
ProbeOutcome::Silent,
|
||||
],
|
||||
EepromState::Absent,
|
||||
);
|
||||
let request = DetectionRequest {
|
||||
chain_ports: &[0, 1, 2],
|
||||
budget: ProbeBudget::default(),
|
||||
sensor: SensorTopology::Pic,
|
||||
fan_zones: Vec::new(),
|
||||
};
|
||||
let plan = run_detection(&mut backend, &db(), &request).expect("plan");
|
||||
assert_eq!(plan.degraded_chains(126), vec![2]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn voltage_follows_frequency_and_clamps_outside_the_envelope() {
|
||||
let envelope = Envelope {
|
||||
v_min_mv: 1100,
|
||||
v_max_mv: 1500,
|
||||
f_min_mhz: 300,
|
||||
f_max_mhz: 700,
|
||||
};
|
||||
assert_eq!(envelope.voltage_for(200), 1100);
|
||||
assert_eq!(envelope.voltage_for(300), 1100);
|
||||
assert_eq!(envelope.voltage_for(500), 1300);
|
||||
assert_eq!(envelope.voltage_for(700), 1500);
|
||||
assert_eq!(envelope.voltage_for(900), 1500);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_single_frequency_envelope_reports_its_floor() {
|
||||
let envelope = Envelope {
|
||||
v_min_mv: 1200,
|
||||
v_max_mv: 1400,
|
||||
f_min_mhz: 500,
|
||||
f_max_mhz: 500,
|
||||
};
|
||||
assert_eq!(envelope.voltage_for(500), 1200);
|
||||
assert_eq!(envelope.voltage_for(600), 1400);
|
||||
}
|
||||
}
|
||||
+469
@@ -0,0 +1,469 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Active fan-to-thermal-zone mapping.
|
||||
//!
|
||||
//! Antminer chassis wire fans to zones in a way that is not reported by the hardware: a fan may
|
||||
//! cool one hashboard heavily and another barely, and the front/back, top/bottom labels are
|
||||
//! physical. The mapping is learned by stepping one fan at a time and watching which zone's
|
||||
//! temperature responds, which is why this module takes measurements rather than configuration.
|
||||
|
||||
use crate::detect::FanZone;
|
||||
|
||||
/// One sensor reading taken while a fan was held at a given duty.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct ZoneReading {
|
||||
pub zone: u8,
|
||||
pub temp_mc: i32,
|
||||
}
|
||||
|
||||
/// One measurement step: a fan duty and the temperatures observed during it.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct ProbeSample {
|
||||
pub fan: u8,
|
||||
pub pwm: u8,
|
||||
pub readings: Vec<ZoneReading>,
|
||||
}
|
||||
|
||||
/// Thresholds that decide when a response is real.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct MapThresholds {
|
||||
/// Minimum cooling (millidegrees) between the low and high duty to count as a response.
|
||||
pub min_drop_mc: i32,
|
||||
/// Minimum margin over the next-best fan, in parts per thousand of the best response.
|
||||
pub min_margin_per_mille: u16,
|
||||
}
|
||||
|
||||
impl Default for MapThresholds {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
min_drop_mc: 500,
|
||||
min_margin_per_mille: 250,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The learned mapping.
|
||||
#[derive(Clone, Debug, Default, Eq, PartialEq)]
|
||||
pub struct FanMap {
|
||||
pub assignments: Vec<FanZone>,
|
||||
/// Zones whose response was ambiguous and were therefore left unassigned.
|
||||
pub unresolved: Vec<u8>,
|
||||
/// Per assigned zone, the margin over the runner-up in parts per thousand.
|
||||
pub confidence_per_mille: Vec<u16>,
|
||||
}
|
||||
|
||||
impl FanMap {
|
||||
/// Zones a fan was confidently assigned to.
|
||||
pub fn zones_for(&self, fan: u8) -> Vec<u8> {
|
||||
self.assignments
|
||||
.iter()
|
||||
.find(|assignment| assignment.fan == fan)
|
||||
.map(|assignment| assignment.zones.clone())
|
||||
.unwrap_or_default()
|
||||
}
|
||||
}
|
||||
|
||||
/// Response per (fan, zone): positive means the zone cooled when that fan sped up.
|
||||
fn responses(samples: &[ProbeSample], zones: &[u8]) -> Vec<(u8, Vec<(u8, i32)>)> {
|
||||
let mut fans: Vec<u8> = samples.iter().map(|sample| sample.fan).collect();
|
||||
fans.sort_unstable();
|
||||
fans.dedup();
|
||||
let mut out = Vec::new();
|
||||
for fan in fans {
|
||||
let fan_samples: Vec<&ProbeSample> =
|
||||
samples.iter().filter(|sample| sample.fan == fan).collect();
|
||||
let min_pwm = fan_samples.iter().map(|sample| sample.pwm).min();
|
||||
let max_pwm = fan_samples.iter().map(|sample| sample.pwm).max();
|
||||
let (Some(low), Some(high)) = (min_pwm, max_pwm) else {
|
||||
continue;
|
||||
};
|
||||
if low == high {
|
||||
continue;
|
||||
}
|
||||
let mut per_zone = Vec::with_capacity(zones.len());
|
||||
for &zone in zones {
|
||||
let mean_at = |pwm: u8| -> Option<i32> {
|
||||
let values: Vec<i32> = fan_samples
|
||||
.iter()
|
||||
.filter(|sample| sample.pwm == pwm)
|
||||
.flat_map(|sample| {
|
||||
sample
|
||||
.readings
|
||||
.iter()
|
||||
.filter(|reading| reading.zone == zone)
|
||||
.map(|reading| reading.temp_mc)
|
||||
})
|
||||
.collect();
|
||||
if values.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let sum: i64 = values.iter().map(|value| *value as i64).sum();
|
||||
Some((sum / values.len() as i64) as i32)
|
||||
};
|
||||
// Duty goes up, temperature should come down: response = warm-run minus fast-run.
|
||||
if let (Some(slow_temp), Some(fast_temp)) = (mean_at(low), mean_at(high)) {
|
||||
per_zone.push((zone, slow_temp - fast_temp));
|
||||
}
|
||||
}
|
||||
out.push((fan, per_zone));
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Learn which fans cool which zones from a stepped measurement run.
|
||||
///
|
||||
/// Every zone goes to the fan with the strongest cooling response, provided that response clears
|
||||
/// `min_drop_mc` and beats the runner-up by `min_margin_per_mille`. Anything weaker stays
|
||||
/// unresolved instead of being guessed, so a noisy run cannot invent a fan map.
|
||||
pub fn map_fans(samples: &[ProbeSample], zones: &[u8], thresholds: MapThresholds) -> FanMap {
|
||||
let responses = responses(samples, zones);
|
||||
let mut map = FanMap::default();
|
||||
for &zone in zones {
|
||||
let mut ranked: Vec<(i32, u8)> = responses
|
||||
.iter()
|
||||
.filter_map(|(fan, per_zone)| {
|
||||
per_zone
|
||||
.iter()
|
||||
.find(|(candidate, _)| *candidate == zone)
|
||||
.map(|(_, drop)| (*drop, *fan))
|
||||
})
|
||||
.collect();
|
||||
ranked.sort_unstable_by_key(|entry| std::cmp::Reverse(entry.0));
|
||||
let Some(&(best_drop, best_fan)) = ranked.first() else {
|
||||
map.unresolved.push(zone);
|
||||
continue;
|
||||
};
|
||||
let runner_up = ranked.get(1).map(|(drop, _)| *drop).unwrap_or(0);
|
||||
let margin = best_drop - runner_up.max(0);
|
||||
let margin_per_mille = if best_drop > 0 {
|
||||
((margin as i64 * 1000) / best_drop as i64) as u16
|
||||
} else {
|
||||
0
|
||||
};
|
||||
if best_drop < thresholds.min_drop_mc || margin_per_mille < thresholds.min_margin_per_mille
|
||||
{
|
||||
map.unresolved.push(zone);
|
||||
continue;
|
||||
}
|
||||
match map
|
||||
.assignments
|
||||
.iter_mut()
|
||||
.find(|assignment| assignment.fan == best_fan)
|
||||
{
|
||||
Some(assignment) => assignment.zones.push(zone),
|
||||
None => map.assignments.push(FanZone {
|
||||
fan: best_fan,
|
||||
zones: vec![zone],
|
||||
}),
|
||||
}
|
||||
map.confidence_per_mille.push(margin_per_mille);
|
||||
}
|
||||
map
|
||||
}
|
||||
|
||||
/// Safe limits for a fan-mapping sweep.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct SweepConfig {
|
||||
pub fans: u8,
|
||||
pub zones: u8,
|
||||
/// Lowest duty used during probing. Never zero: the boards must keep airflow.
|
||||
pub low_pwm: u8,
|
||||
pub high_pwm: u8,
|
||||
/// Readings taken per (fan, duty) step; the mapper averages them.
|
||||
pub repeats: u8,
|
||||
/// Time to wait after a duty change before reading temperatures.
|
||||
pub settle_ms: u32,
|
||||
}
|
||||
|
||||
impl Default for SweepConfig {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
fans: 4,
|
||||
zones: 3,
|
||||
low_pwm: 40,
|
||||
high_pwm: 100,
|
||||
repeats: 2,
|
||||
settle_ms: 20_000,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Minimum duty a sweep may use. Airflow is never removed to make a measurement.
|
||||
pub const MIN_PROBE_PWM: u8 = 20;
|
||||
|
||||
/// Why a sweep did not run.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub enum SweepError<E> {
|
||||
Backend(E),
|
||||
InvalidConfig(&'static str),
|
||||
}
|
||||
|
||||
/// The two backend actions a sweep needs.
|
||||
pub trait FanProbe {
|
||||
type Error;
|
||||
|
||||
fn set_fan(&mut self, fan: u8, pwm: u8) -> Result<(), Self::Error>;
|
||||
fn read_zone(&mut self, zone: u8) -> Result<i32, Self::Error>;
|
||||
}
|
||||
|
||||
/// Step every fan between the low and high duty and record what the zones do.
|
||||
///
|
||||
/// One fan is moved at a time while the others hold their previous duty, so the response belongs
|
||||
/// to that fan. The run ends with every fan back at `high_pwm`: leaving a fan low after probing
|
||||
/// would be a thermal hazard for whatever runs next.
|
||||
pub fn sweep<B: FanProbe, S: FnMut(u32)>(
|
||||
backend: &mut B,
|
||||
config: &SweepConfig,
|
||||
mut settle: S,
|
||||
) -> Result<Vec<ProbeSample>, SweepError<B::Error>> {
|
||||
if config.fans == 0 {
|
||||
return Err(SweepError::InvalidConfig("no fans to sweep"));
|
||||
}
|
||||
if config.zones == 0 {
|
||||
return Err(SweepError::InvalidConfig("no zones to read"));
|
||||
}
|
||||
if config.low_pwm < MIN_PROBE_PWM {
|
||||
return Err(SweepError::InvalidConfig(
|
||||
"probe duty below the safe minimum",
|
||||
));
|
||||
}
|
||||
if config.high_pwm > 100 {
|
||||
return Err(SweepError::InvalidConfig("probe duty above 100 percent"));
|
||||
}
|
||||
if config.low_pwm >= config.high_pwm {
|
||||
return Err(SweepError::InvalidConfig("probe duty range is empty"));
|
||||
}
|
||||
if config.repeats == 0 {
|
||||
return Err(SweepError::InvalidConfig("no readings requested"));
|
||||
}
|
||||
|
||||
let mut samples = Vec::new();
|
||||
for fan in 0..config.fans {
|
||||
for pwm in [config.low_pwm, config.high_pwm] {
|
||||
backend.set_fan(fan, pwm).map_err(SweepError::Backend)?;
|
||||
settle(config.settle_ms);
|
||||
for _ in 0..config.repeats {
|
||||
let mut readings = Vec::with_capacity(config.zones as usize);
|
||||
for zone in 0..config.zones {
|
||||
readings.push(ZoneReading {
|
||||
zone,
|
||||
temp_mc: backend.read_zone(zone).map_err(SweepError::Backend)?,
|
||||
});
|
||||
}
|
||||
samples.push(ProbeSample { fan, pwm, readings });
|
||||
}
|
||||
}
|
||||
}
|
||||
for fan in 0..config.fans {
|
||||
backend
|
||||
.set_fan(fan, config.high_pwm)
|
||||
.map_err(SweepError::Backend)?;
|
||||
}
|
||||
Ok(samples)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn sample(fan: u8, pwm: u8, zone_temps: &[(u8, i32)]) -> ProbeSample {
|
||||
ProbeSample {
|
||||
fan,
|
||||
pwm,
|
||||
readings: zone_temps
|
||||
.iter()
|
||||
.map(|(zone, temp)| ZoneReading {
|
||||
zone: *zone,
|
||||
temp_mc: *temp,
|
||||
})
|
||||
.collect(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn each_zone_is_assigned_to_the_fan_that_cools_it() {
|
||||
let samples = vec![
|
||||
sample(0, 30, &[(0, 70_000), (1, 60_000)]),
|
||||
sample(0, 100, &[(0, 50_000), (1, 59_000)]),
|
||||
sample(1, 30, &[(0, 69_000), (1, 60_000)]),
|
||||
sample(1, 100, &[(0, 68_000), (1, 40_000)]),
|
||||
];
|
||||
let map = map_fans(&samples, &[0, 1], MapThresholds::default());
|
||||
assert_eq!(map.zones_for(0), vec![0]);
|
||||
assert_eq!(map.zones_for(1), vec![1]);
|
||||
assert!(map.unresolved.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ambiguity_leaves_a_zone_unresolved() {
|
||||
let samples = vec![
|
||||
sample(0, 30, &[(0, 70_000)]),
|
||||
sample(0, 100, &[(0, 60_000)]),
|
||||
sample(1, 30, &[(0, 70_500)]),
|
||||
sample(1, 100, &[(0, 60_500)]),
|
||||
];
|
||||
let map = map_fans(&samples, &[0], MapThresholds::default());
|
||||
assert!(map.assignments.is_empty());
|
||||
assert_eq!(map.unresolved, vec![0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_fan_that_does_not_change_temperature_is_not_assigned() {
|
||||
let samples = vec![
|
||||
sample(0, 30, &[(0, 60_000)]),
|
||||
sample(0, 100, &[(0, 59_900)]),
|
||||
];
|
||||
let map = map_fans(&samples, &[0], MapThresholds::default());
|
||||
assert!(map.assignments.is_empty());
|
||||
assert_eq!(map.unresolved, vec![0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_fan_without_duty_range_is_skipped() {
|
||||
let samples = vec![sample(0, 50, &[(0, 60_000)]), sample(0, 50, &[(0, 60_000)])];
|
||||
let map = map_fans(&samples, &[0], MapThresholds::default());
|
||||
assert!(map.assignments.is_empty());
|
||||
assert_eq!(map.unresolved, vec![0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn one_fan_can_own_several_zones() {
|
||||
let samples = vec![
|
||||
sample(0, 30, &[(0, 70_000), (1, 71_000), (2, 55_000)]),
|
||||
sample(0, 100, &[(0, 55_000), (1, 56_000), (2, 54_000)]),
|
||||
sample(1, 30, &[(0, 70_000), (1, 71_000), (2, 54_000)]),
|
||||
sample(1, 100, &[(0, 69_000), (1, 70_000), (2, 50_000)]),
|
||||
];
|
||||
let map = map_fans(&samples, &[0, 1, 2], MapThresholds::default());
|
||||
assert_eq!(map.zones_for(0), vec![0, 1]);
|
||||
assert_eq!(map.zones_for(1), vec![2]);
|
||||
}
|
||||
|
||||
struct ThermalMock {
|
||||
duty: Vec<u8>,
|
||||
owners: Vec<(u8, u8)>,
|
||||
fail: bool,
|
||||
}
|
||||
|
||||
impl ThermalMock {
|
||||
fn new(owners: &[(u8, u8)]) -> Self {
|
||||
let fans = owners.iter().map(|(fan, _)| *fan).max().unwrap_or(0) + 1;
|
||||
Self {
|
||||
duty: vec![100; fans as usize],
|
||||
owners: owners.to_vec(),
|
||||
fail: false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl FanProbe for ThermalMock {
|
||||
type Error = &'static str;
|
||||
|
||||
fn set_fan(&mut self, fan: u8, pwm: u8) -> Result<(), Self::Error> {
|
||||
if self.fail {
|
||||
return Err("fan bus down");
|
||||
}
|
||||
self.duty[fan as usize] = pwm;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn read_zone(&mut self, zone: u8) -> Result<i32, Self::Error> {
|
||||
if self.fail {
|
||||
return Err("sensor bus down");
|
||||
}
|
||||
let owner = self
|
||||
.owners
|
||||
.iter()
|
||||
.find(|(_, candidate)| *candidate == zone)
|
||||
.map(|(fan, _)| *fan)
|
||||
.expect("zone has an owner");
|
||||
let cooled = self.duty[owner as usize] >= 100;
|
||||
Ok(if cooled { 50_000 } else { 70_000 })
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sweep_then_map_resolves_each_zone() {
|
||||
let mut backend = ThermalMock::new(&[(0, 0), (1, 1)]);
|
||||
let config = SweepConfig {
|
||||
fans: 2,
|
||||
zones: 2,
|
||||
low_pwm: 40,
|
||||
high_pwm: 100,
|
||||
repeats: 2,
|
||||
settle_ms: 0,
|
||||
};
|
||||
let samples = sweep(&mut backend, &config, |_| {}).expect("sweep");
|
||||
assert_eq!(samples.len(), 2 * 2 * 2);
|
||||
let map = map_fans(&samples, &[0, 1], MapThresholds::default());
|
||||
assert_eq!(map.zones_for(0), vec![0]);
|
||||
assert_eq!(map.zones_for(1), vec![1]);
|
||||
assert!(map.unresolved.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sweep_restores_every_fan_to_high_duty() {
|
||||
let mut backend = ThermalMock::new(&[(0, 0), (1, 1)]);
|
||||
let config = SweepConfig {
|
||||
fans: 2,
|
||||
zones: 2,
|
||||
low_pwm: 40,
|
||||
high_pwm: 100,
|
||||
repeats: 1,
|
||||
settle_ms: 0,
|
||||
};
|
||||
sweep(&mut backend, &config, |_| {}).expect("sweep");
|
||||
assert_eq!(backend.duty, vec![100, 100]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sweep_refuses_an_unsafe_duty() {
|
||||
let mut backend = ThermalMock::new(&[(0, 0)]);
|
||||
let config = SweepConfig {
|
||||
fans: 1,
|
||||
zones: 1,
|
||||
low_pwm: 10,
|
||||
high_pwm: 100,
|
||||
repeats: 1,
|
||||
settle_ms: 0,
|
||||
};
|
||||
assert_eq!(
|
||||
sweep(&mut backend, &config, |_| {}),
|
||||
Err(SweepError::InvalidConfig(
|
||||
"probe duty below the safe minimum"
|
||||
))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sweep_refuses_an_empty_range_and_zero_reads() {
|
||||
let mut backend = ThermalMock::new(&[(0, 0)]);
|
||||
let flat = SweepConfig {
|
||||
fans: 1,
|
||||
zones: 1,
|
||||
low_pwm: 60,
|
||||
high_pwm: 60,
|
||||
repeats: 1,
|
||||
settle_ms: 0,
|
||||
};
|
||||
assert!(matches!(
|
||||
sweep(&mut backend, &flat, |_| {}),
|
||||
Err(SweepError::InvalidConfig(_))
|
||||
));
|
||||
let no_reads = SweepConfig { repeats: 0, ..flat };
|
||||
assert!(matches!(
|
||||
sweep(&mut backend, &no_reads, |_| {}),
|
||||
Err(SweepError::InvalidConfig(_))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sweep_propagates_backend_failures() {
|
||||
let mut backend = ThermalMock::new(&[(0, 0)]);
|
||||
backend.fail = true;
|
||||
let config = SweepConfig::default();
|
||||
assert_eq!(
|
||||
sweep(&mut backend, &config, |_| {}),
|
||||
Err(SweepError::Backend("fan bus down"))
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,318 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Persisting the learned fan map.
|
||||
//!
|
||||
//! Mapping fans means heating and cooling the machine deliberately, so it is done once, stored, and
|
||||
//! reused until the fan or sensor set changes. A stored map that does not match the current set is
|
||||
//! ignored rather than trusted: silently applying a map learned on four fans to a machine with two
|
||||
//! would mis-control thermals.
|
||||
|
||||
use crate::detect::FanZone;
|
||||
use crate::fanmap::{map_fans, sweep, FanMap, FanProbe, MapThresholds, SweepConfig, SweepError};
|
||||
use serde_json::{json, Value};
|
||||
use std::fs;
|
||||
use std::io;
|
||||
use std::path::Path;
|
||||
|
||||
/// A stored map together with the hardware it was learned on.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct StoredMap {
|
||||
pub fans: u8,
|
||||
pub zones: u8,
|
||||
pub assignments: Vec<FanZone>,
|
||||
pub unresolved: Vec<u8>,
|
||||
}
|
||||
|
||||
impl StoredMap {
|
||||
pub fn from_map(map: &FanMap, fans: u8, zones: u8) -> Self {
|
||||
Self {
|
||||
fans,
|
||||
zones,
|
||||
assignments: map.assignments.clone(),
|
||||
unresolved: map.unresolved.clone(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn to_map(&self) -> FanMap {
|
||||
FanMap {
|
||||
assignments: self.assignments.clone(),
|
||||
unresolved: self.unresolved.clone(),
|
||||
confidence_per_mille: vec![0; self.assignments.len()],
|
||||
}
|
||||
}
|
||||
|
||||
/// True when this map was learned on the same fan and zone counts.
|
||||
pub fn matches(&self, fans: u8, zones: u8) -> bool {
|
||||
self.fans == fans && self.zones == zones
|
||||
}
|
||||
|
||||
pub fn to_json(&self) -> String {
|
||||
json!({
|
||||
"schema": 1,
|
||||
"fans": self.fans,
|
||||
"zones": self.zones,
|
||||
"assignments": self.assignments.iter().map(|zone| json!({
|
||||
"fan": zone.fan,
|
||||
"zones": zone.zones,
|
||||
})).collect::<Vec<_>>(),
|
||||
"unresolved": self.unresolved,
|
||||
})
|
||||
.to_string()
|
||||
}
|
||||
|
||||
pub fn from_json(text: &str) -> Option<Self> {
|
||||
let root: Value = serde_json::from_str(text).ok()?;
|
||||
if root.get("schema")?.as_u64()? != 1 {
|
||||
return None;
|
||||
}
|
||||
let fans = u8::try_from(root.get("fans")?.as_u64()?).ok()?;
|
||||
let zones = u8::try_from(root.get("zones")?.as_u64()?).ok()?;
|
||||
let assignments = root
|
||||
.get("assignments")?
|
||||
.as_array()?
|
||||
.iter()
|
||||
.map(|entry| {
|
||||
Some(FanZone {
|
||||
fan: u8::try_from(entry.get("fan")?.as_u64()?).ok()?,
|
||||
zones: entry
|
||||
.get("zones")?
|
||||
.as_array()?
|
||||
.iter()
|
||||
.map(|zone| u8::try_from(zone.as_u64()?).ok())
|
||||
.collect::<Option<Vec<u8>>>()?,
|
||||
})
|
||||
})
|
||||
.collect::<Option<Vec<FanZone>>>()?;
|
||||
let unresolved = root
|
||||
.get("unresolved")?
|
||||
.as_array()?
|
||||
.iter()
|
||||
.map(|zone| u8::try_from(zone.as_u64()?).ok())
|
||||
.collect::<Option<Vec<u8>>>()?;
|
||||
Some(Self {
|
||||
fans,
|
||||
zones,
|
||||
assignments,
|
||||
unresolved,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Why mapping did not produce a stored map.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub enum StoreError<E> {
|
||||
Sweep(SweepError<E>),
|
||||
Io(&'static str),
|
||||
}
|
||||
|
||||
/// Read a stored map, if one exists and parses.
|
||||
pub fn load(path: &Path) -> Option<StoredMap> {
|
||||
let text = fs::read_to_string(path).ok()?;
|
||||
StoredMap::from_json(&text)
|
||||
}
|
||||
|
||||
/// Write a map, creating the parent directory when needed.
|
||||
pub fn save(path: &Path, stored: &StoredMap) -> io::Result<()> {
|
||||
if let Some(parent) = path.parent() {
|
||||
if !parent.as_os_str().is_empty() {
|
||||
fs::create_dir_all(parent)?;
|
||||
}
|
||||
}
|
||||
fs::write(path, stored.to_json())
|
||||
}
|
||||
|
||||
/// Return the stored map when it matches this machine, otherwise sweep, map, and store the result.
|
||||
pub fn ensure_map<B: FanProbe, S: FnMut(u32)>(
|
||||
backend: &mut B,
|
||||
config: &SweepConfig,
|
||||
thresholds: MapThresholds,
|
||||
path: &Path,
|
||||
settle: S,
|
||||
) -> Result<FanMap, StoreError<B::Error>> {
|
||||
if let Some(stored) = load(path) {
|
||||
if stored.matches(config.fans, config.zones) {
|
||||
return Ok(stored.to_map());
|
||||
}
|
||||
}
|
||||
let zones: Vec<u8> = (0..config.zones).collect();
|
||||
let samples = sweep(backend, config, settle).map_err(StoreError::Sweep)?;
|
||||
let map = map_fans(&samples, &zones, thresholds);
|
||||
let stored = StoredMap::from_map(&map, config.fans, config.zones);
|
||||
save(path, &stored).map_err(|_| StoreError::Io("cannot write the fan map"))?;
|
||||
Ok(map)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::fanmap::{ProbeSample, ZoneReading};
|
||||
|
||||
struct CountingBackend {
|
||||
duty: Vec<u8>,
|
||||
owners: Vec<(u8, u8)>,
|
||||
calls: usize,
|
||||
}
|
||||
|
||||
impl FanProbe for CountingBackend {
|
||||
type Error = ();
|
||||
|
||||
fn set_fan(&mut self, fan: u8, pwm: u8) -> Result<(), ()> {
|
||||
self.calls += 1;
|
||||
self.duty[fan as usize] = pwm;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn read_zone(&mut self, zone: u8) -> Result<i32, ()> {
|
||||
// Zones without an explicit owner follow fan 0, which keeps the mock usable when a
|
||||
// test asks for more zones than the fixture declares.
|
||||
let owner = self
|
||||
.owners
|
||||
.iter()
|
||||
.find(|(_, candidate)| *candidate == zone)
|
||||
.map(|(fan, _)| *fan)
|
||||
.unwrap_or(0);
|
||||
Ok(if self.duty[owner as usize] >= 100 {
|
||||
50_000
|
||||
} else {
|
||||
70_000
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn backend() -> CountingBackend {
|
||||
CountingBackend {
|
||||
duty: vec![100, 100],
|
||||
owners: vec![(0, 0), (1, 1)],
|
||||
calls: 0,
|
||||
}
|
||||
}
|
||||
|
||||
fn config(zones: u8) -> SweepConfig {
|
||||
SweepConfig {
|
||||
fans: 2,
|
||||
zones,
|
||||
low_pwm: 40,
|
||||
high_pwm: 100,
|
||||
repeats: 1,
|
||||
settle_ms: 0,
|
||||
}
|
||||
}
|
||||
|
||||
fn path(name: &str) -> std::path::PathBuf {
|
||||
let mut dir = std::env::temp_dir();
|
||||
dir.push(format!("alkane-fanmap-{}-{name}.json", std::process::id()));
|
||||
dir
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_stored_map_round_trips() {
|
||||
let map = FanMap {
|
||||
assignments: vec![FanZone {
|
||||
fan: 0,
|
||||
zones: vec![0, 1],
|
||||
}],
|
||||
unresolved: vec![2],
|
||||
confidence_per_mille: vec![900],
|
||||
};
|
||||
let stored = StoredMap::from_map(&map, 4, 3);
|
||||
let text = stored.to_json();
|
||||
assert_eq!(StoredMap::from_json(&text).expect("parse"), stored);
|
||||
let back = stored.to_map();
|
||||
assert_eq!(back.assignments, map.assignments);
|
||||
assert_eq!(back.unresolved, map.unresolved);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn corrupt_or_foreign_json_is_ignored() {
|
||||
assert!(StoredMap::from_json("not json").is_none());
|
||||
assert!(StoredMap::from_json(r#"{"schema":2}"#).is_none());
|
||||
assert!(StoredMap::from_json(r#"{"schema":1,"fans":2}"#).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_matching_map_is_reused_without_sweeping() {
|
||||
let file = path("reuse");
|
||||
let first = ensure_map(
|
||||
&mut backend(),
|
||||
&config(2),
|
||||
MapThresholds::default(),
|
||||
&file,
|
||||
|_| {},
|
||||
)
|
||||
.expect("first");
|
||||
assert_eq!(first.zones_for(0), vec![0]);
|
||||
let mut reuse = backend();
|
||||
let second = ensure_map(
|
||||
&mut reuse,
|
||||
&config(2),
|
||||
MapThresholds::default(),
|
||||
&file,
|
||||
|_| {},
|
||||
)
|
||||
.expect("second");
|
||||
assert_eq!(second.zones_for(0), vec![0]);
|
||||
assert_eq!(reuse.calls, 0, "a stored map must not cause another sweep");
|
||||
let _ = std::fs::remove_file(&file);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_changed_sensor_set_forces_a_new_sweep() {
|
||||
let file = path("changed");
|
||||
ensure_map(
|
||||
&mut backend(),
|
||||
&config(2),
|
||||
MapThresholds::default(),
|
||||
&file,
|
||||
|_| {},
|
||||
)
|
||||
.expect("first");
|
||||
let mut fresh = backend();
|
||||
let map = ensure_map(
|
||||
&mut fresh,
|
||||
&config(2),
|
||||
MapThresholds::default(),
|
||||
&file,
|
||||
|_| {},
|
||||
)
|
||||
.expect("second");
|
||||
assert_eq!(map.zones_for(1), vec![1]);
|
||||
// The stored file describes two zones; asking for three must not reuse it.
|
||||
let mut three = CountingBackend {
|
||||
duty: vec![100, 100],
|
||||
owners: vec![(0, 0), (1, 1)],
|
||||
calls: 0,
|
||||
};
|
||||
let _ = ensure_map(
|
||||
&mut three,
|
||||
&config(3),
|
||||
MapThresholds::default(),
|
||||
&file,
|
||||
|_| {},
|
||||
);
|
||||
assert!(three.calls > 0);
|
||||
let _ = std::fs::remove_file(&file);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn samples_from_a_sweep_still_map_correctly() {
|
||||
let samples = vec![
|
||||
ProbeSample {
|
||||
fan: 0,
|
||||
pwm: 40,
|
||||
readings: vec![ZoneReading {
|
||||
zone: 0,
|
||||
temp_mc: 70_000,
|
||||
}],
|
||||
},
|
||||
ProbeSample {
|
||||
fan: 0,
|
||||
pwm: 100,
|
||||
readings: vec![ZoneReading {
|
||||
zone: 0,
|
||||
temp_mc: 50_000,
|
||||
}],
|
||||
},
|
||||
];
|
||||
let map = map_fans(&samples, &[0], MapThresholds::default());
|
||||
assert_eq!(map.zones_for(0), vec![0]);
|
||||
}
|
||||
}
|
||||
+332
@@ -0,0 +1,332 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Fault-tolerance supervisor.
|
||||
//!
|
||||
//! The goal is to keep hashing with as many dead chips or chains as possible. Faults therefore
|
||||
//! escalate in steps (retry, disable chip, disable chain) and only irreversible conditions stop the
|
||||
//! machine. This module owns that ladder; it does not talk to hardware and it does not choose
|
||||
//! thermal limits, which come from the profile envelope.
|
||||
|
||||
/// A single health observation from the mining loop.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum FaultEvent {
|
||||
/// A chain accepted work and reported nonces for it.
|
||||
NoncesReported { chain: u8, per_mille: u16 },
|
||||
/// A chain returned an error for a frame, reset or work dispatch.
|
||||
ChainError { chain: u8 },
|
||||
/// A chain produced nothing for a full observation window.
|
||||
ChainSilent { chain: u8 },
|
||||
/// One chip on a chain failed its identification or stopped responding.
|
||||
ChipFault { chain: u8, chip: u16 },
|
||||
/// A temperature reading left the profile envelope.
|
||||
TemperatureFault { zone: u8 },
|
||||
}
|
||||
|
||||
/// What the caller should do next.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum FaultAction {
|
||||
/// Keep hashing; nothing changed.
|
||||
None,
|
||||
/// Retry the chain before treating the fault as permanent.
|
||||
Retry { chain: u8 },
|
||||
/// Keep the machine running without this chain.
|
||||
DisableChain { chain: u8 },
|
||||
/// Keep the machine running without this chip.
|
||||
DisableChip { chain: u8, chip: u16 },
|
||||
/// Stop hashing entirely; the reason is carried for the API.
|
||||
Stop { reason: StopReason },
|
||||
}
|
||||
|
||||
/// Why the machine stopped.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum StopReason {
|
||||
Temperature,
|
||||
NoChainsLeft,
|
||||
}
|
||||
|
||||
/// Thresholds for escalation.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct FaultPolicy {
|
||||
/// Consecutive errors tolerated before the chain is disabled (retries included).
|
||||
pub retries: u8,
|
||||
/// Nonce-response ratio below which a chain is considered stalled.
|
||||
pub min_response_per_mille: u16,
|
||||
/// Consecutive weak windows before a stalled chain is disabled.
|
||||
pub weak_windows: u8,
|
||||
}
|
||||
|
||||
impl Default for FaultPolicy {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
retries: 2,
|
||||
min_response_per_mille: 100,
|
||||
weak_windows: 3,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
|
||||
struct ChainHealth {
|
||||
chain: u8,
|
||||
errors: u8,
|
||||
weak: u8,
|
||||
disabled: bool,
|
||||
}
|
||||
|
||||
/// Escalation state for one machine.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct FaultSupervisor {
|
||||
policy: FaultPolicy,
|
||||
chains: Vec<ChainHealth>,
|
||||
stopped: Option<StopReason>,
|
||||
}
|
||||
|
||||
impl FaultSupervisor {
|
||||
pub fn new(chains: &[u8], policy: FaultPolicy) -> Self {
|
||||
Self {
|
||||
policy,
|
||||
chains: chains
|
||||
.iter()
|
||||
.map(|&chain| ChainHealth {
|
||||
chain,
|
||||
..ChainHealth::default()
|
||||
})
|
||||
.collect(),
|
||||
stopped: None,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn is_stopped(&self) -> bool {
|
||||
self.stopped.is_some()
|
||||
}
|
||||
|
||||
pub fn stop_reason(&self) -> Option<StopReason> {
|
||||
self.stopped
|
||||
}
|
||||
|
||||
/// Chains the miner may still dispatch work to.
|
||||
pub fn active_chains(&self) -> Vec<u8> {
|
||||
self.chains
|
||||
.iter()
|
||||
.filter(|health| !health.disabled)
|
||||
.map(|health| health.chain)
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Apply one observation and return the escalation step it implies.
|
||||
pub fn observe(&mut self, event: FaultEvent) -> FaultAction {
|
||||
if self.stopped.is_some() {
|
||||
return FaultAction::None;
|
||||
}
|
||||
match event {
|
||||
FaultEvent::NoncesReported { chain, per_mille } => {
|
||||
let min_response = self.policy.min_response_per_mille;
|
||||
let weak_windows = self.policy.weak_windows;
|
||||
let Some(health) = self.health_mut(chain) else {
|
||||
return FaultAction::None;
|
||||
};
|
||||
health.errors = 0;
|
||||
if per_mille >= min_response {
|
||||
health.weak = 0;
|
||||
return FaultAction::None;
|
||||
}
|
||||
health.weak = health.weak.saturating_add(1);
|
||||
if health.weak >= weak_windows {
|
||||
health.disabled = true;
|
||||
self.maybe_stop(chain)
|
||||
} else {
|
||||
FaultAction::None
|
||||
}
|
||||
}
|
||||
FaultEvent::ChainError { chain } | FaultEvent::ChainSilent { chain } => {
|
||||
let policy = self.policy;
|
||||
let Some(health) = self.health_mut(chain) else {
|
||||
return FaultAction::None;
|
||||
};
|
||||
if health.disabled {
|
||||
return FaultAction::None;
|
||||
}
|
||||
health.errors = health.errors.saturating_add(1);
|
||||
if health.errors > policy.retries {
|
||||
health.disabled = true;
|
||||
self.maybe_stop(chain)
|
||||
} else {
|
||||
FaultAction::Retry { chain }
|
||||
}
|
||||
}
|
||||
FaultEvent::ChipFault { chain, chip } => FaultAction::DisableChip { chain, chip },
|
||||
FaultEvent::TemperatureFault { .. } => {
|
||||
self.stopped = Some(StopReason::Temperature);
|
||||
FaultAction::Stop {
|
||||
reason: StopReason::Temperature,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn health_mut(&mut self, chain: u8) -> Option<&mut ChainHealth> {
|
||||
self.chains.iter_mut().find(|health| health.chain == chain)
|
||||
}
|
||||
|
||||
fn maybe_stop(&mut self, chain: u8) -> FaultAction {
|
||||
if self.chains.iter().all(|health| health.disabled) {
|
||||
self.stopped = Some(StopReason::NoChainsLeft);
|
||||
return FaultAction::Stop {
|
||||
reason: StopReason::NoChainsLeft,
|
||||
};
|
||||
}
|
||||
FaultAction::DisableChain { chain }
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn supervisor() -> FaultSupervisor {
|
||||
FaultSupervisor::new(&[0, 1, 2], FaultPolicy::default())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn transient_errors_retry_then_disable_the_chain() {
|
||||
let mut faults = supervisor();
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::ChainError { chain: 1 }),
|
||||
FaultAction::Retry { chain: 1 }
|
||||
);
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::ChainError { chain: 1 }),
|
||||
FaultAction::Retry { chain: 1 }
|
||||
);
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::ChainSilent { chain: 1 }),
|
||||
FaultAction::DisableChain { chain: 1 }
|
||||
);
|
||||
assert_eq!(faults.active_chains(), vec![0, 2]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn healthy_nonces_reset_the_error_count() {
|
||||
let mut faults = supervisor();
|
||||
faults.observe(FaultEvent::ChainError { chain: 0 });
|
||||
faults.observe(FaultEvent::ChainError { chain: 0 });
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::NoncesReported {
|
||||
chain: 0,
|
||||
per_mille: 900
|
||||
}),
|
||||
FaultAction::None
|
||||
);
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::ChainError { chain: 0 }),
|
||||
FaultAction::Retry { chain: 0 }
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_stalled_chain_is_disabled_after_repeated_weak_windows() {
|
||||
let mut faults = supervisor();
|
||||
for _ in 0..2 {
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::NoncesReported {
|
||||
chain: 2,
|
||||
per_mille: 10
|
||||
}),
|
||||
FaultAction::None
|
||||
);
|
||||
}
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::NoncesReported {
|
||||
chain: 2,
|
||||
per_mille: 10
|
||||
}),
|
||||
FaultAction::DisableChain { chain: 2 }
|
||||
);
|
||||
assert_eq!(faults.active_chains(), vec![0, 1]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn one_good_window_clears_weak_history() {
|
||||
let mut faults = supervisor();
|
||||
faults.observe(FaultEvent::NoncesReported {
|
||||
chain: 0,
|
||||
per_mille: 10,
|
||||
});
|
||||
faults.observe(FaultEvent::NoncesReported {
|
||||
chain: 0,
|
||||
per_mille: 10,
|
||||
});
|
||||
faults.observe(FaultEvent::NoncesReported {
|
||||
chain: 0,
|
||||
per_mille: 900,
|
||||
});
|
||||
faults.observe(FaultEvent::NoncesReported {
|
||||
chain: 0,
|
||||
per_mille: 10,
|
||||
});
|
||||
faults.observe(FaultEvent::NoncesReported {
|
||||
chain: 0,
|
||||
per_mille: 10,
|
||||
});
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::NoncesReported {
|
||||
chain: 0,
|
||||
per_mille: 10
|
||||
}),
|
||||
FaultAction::DisableChain { chain: 0 }
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_chip_fault_disables_only_that_chip() {
|
||||
let mut faults = supervisor();
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::ChipFault { chain: 1, chip: 42 }),
|
||||
FaultAction::DisableChip { chain: 1, chip: 42 }
|
||||
);
|
||||
assert_eq!(faults.active_chains(), vec![0, 1, 2]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn temperature_fault_stops_the_machine() {
|
||||
let mut faults = supervisor();
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::TemperatureFault { zone: 2 }),
|
||||
FaultAction::Stop {
|
||||
reason: StopReason::Temperature
|
||||
}
|
||||
);
|
||||
assert!(faults.is_stopped());
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::ChainError { chain: 0 }),
|
||||
FaultAction::None
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn losing_every_chain_stops_instead_of_hanging() {
|
||||
let mut faults = FaultSupervisor::new(
|
||||
&[0],
|
||||
FaultPolicy {
|
||||
retries: 0,
|
||||
..FaultPolicy::default()
|
||||
},
|
||||
);
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::ChainError { chain: 0 }),
|
||||
FaultAction::Stop {
|
||||
reason: StopReason::NoChainsLeft
|
||||
}
|
||||
);
|
||||
assert_eq!(faults.active_chains(), Vec::<u8>::new());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unknown_chains_are_ignored() {
|
||||
let mut faults = supervisor();
|
||||
assert_eq!(
|
||||
faults.observe(FaultEvent::ChainError { chain: 9 }),
|
||||
FaultAction::None
|
||||
);
|
||||
assert_eq!(faults.active_chains(), vec![0, 1, 2]);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,218 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! HAL conformance checks.
|
||||
//!
|
||||
//! A family backend is only useful if it answers the contract the OS expects. This module walks the
|
||||
//! contract in order and reports each check separately, so a backend author sees exactly which
|
||||
//! opcode is missing or wrong instead of a single opaque failure.
|
||||
//!
|
||||
//! Every check uses a fresh connection: a backend that desynchronises one exchange must not make
|
||||
//! the following checks meaningless.
|
||||
|
||||
use crate::hal_wire::{HalClient, CAP_CHAIN_PROBE, CAP_FREQUENCY, CAP_POWER, CAP_PSU_IDENTITY};
|
||||
use crate::HardwareBackend;
|
||||
use std::path::Path;
|
||||
|
||||
/// One check and its outcome.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct Check {
|
||||
pub name: &'static str,
|
||||
pub passed: bool,
|
||||
pub detail: String,
|
||||
}
|
||||
|
||||
impl Check {
|
||||
fn pass(name: &'static str, detail: impl Into<String>) -> Self {
|
||||
Self {
|
||||
name,
|
||||
passed: true,
|
||||
detail: detail.into(),
|
||||
}
|
||||
}
|
||||
|
||||
fn fail(name: &'static str, detail: impl Into<String>) -> Self {
|
||||
Self {
|
||||
name,
|
||||
passed: false,
|
||||
detail: detail.into(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Run the contract checks against a backend socket.
|
||||
pub fn run(socket: &Path) -> Vec<Check> {
|
||||
vec![
|
||||
check_capabilities(socket),
|
||||
check_probe(socket),
|
||||
check_eeprom(socket),
|
||||
check_psu(socket),
|
||||
check_frequency_and_temperature(socket),
|
||||
check_power(socket),
|
||||
check_fan(socket),
|
||||
]
|
||||
}
|
||||
|
||||
fn connect(socket: &Path) -> Result<HalClient, String> {
|
||||
HalClient::connect(socket).map_err(|error| format!("{error:?}"))
|
||||
}
|
||||
|
||||
fn check_capabilities(socket: &Path) -> Check {
|
||||
const NAME: &str = "capabilities";
|
||||
match connect(socket)
|
||||
.and_then(|mut client| client.capabilities().map_err(|error| format!("{error:?}")))
|
||||
{
|
||||
Ok(mask) if mask & CAP_CHAIN_PROBE == 0 => {
|
||||
Check::fail(NAME, format!("mask {mask:#x} lacks chain probing"))
|
||||
}
|
||||
Ok(mask) => Check::pass(NAME, format!("mask {mask:#x}")),
|
||||
Err(error) => Check::fail(NAME, error),
|
||||
}
|
||||
}
|
||||
|
||||
fn check_probe(socket: &Path) -> Check {
|
||||
const NAME: &str = "probe chain 0";
|
||||
match connect(socket) {
|
||||
Ok(mut client) => match client.probe_chain(0, 0) {
|
||||
Ok(outcome) => Check::pass(NAME, format!("{outcome:?}")),
|
||||
Err(error) => Check::fail(NAME, format!("{error:?}")),
|
||||
},
|
||||
Err(error) => Check::fail(NAME, error),
|
||||
}
|
||||
}
|
||||
|
||||
fn check_eeprom(socket: &Path) -> Check {
|
||||
const NAME: &str = "read EEPROM chain 0";
|
||||
match connect(socket) {
|
||||
Ok(mut client) => match client.read_eeprom(0) {
|
||||
Ok(state) => Check::pass(NAME, format!("{state:?}")),
|
||||
Err(error) => Check::fail(NAME, format!("{error:?}")),
|
||||
},
|
||||
Err(error) => Check::fail(NAME, error),
|
||||
}
|
||||
}
|
||||
|
||||
fn check_psu(socket: &Path) -> Check {
|
||||
const NAME: &str = "identify PSU";
|
||||
match connect(socket) {
|
||||
Ok(mut client) => match client.capabilities() {
|
||||
Ok(mask) if mask & CAP_PSU_IDENTITY == 0 => {
|
||||
Check::fail(NAME, "backend does not advertise PSU identity")
|
||||
}
|
||||
Ok(_) => match client.identify_psu() {
|
||||
Ok(psu) if psu.envelope.v_min_mv <= psu.envelope.v_max_mv => {
|
||||
Check::pass(NAME, format!("{} {} mV", psu.name, psu.envelope.v_max_mv))
|
||||
}
|
||||
Ok(psu) => Check::fail(NAME, format!("inverted envelope from {}", psu.name)),
|
||||
Err(error) => Check::fail(NAME, format!("{error:?}")),
|
||||
},
|
||||
Err(error) => Check::fail(NAME, format!("{error:?}")),
|
||||
},
|
||||
Err(error) => Check::fail(NAME, error),
|
||||
}
|
||||
}
|
||||
|
||||
fn check_frequency_and_temperature(socket: &Path) -> Check {
|
||||
const NAME: &str = "frequency and temperature";
|
||||
match connect(socket) {
|
||||
Ok(mut client) => {
|
||||
let caps = match client.capabilities() {
|
||||
Ok(mask) => mask,
|
||||
Err(error) => return Check::fail(NAME, format!("{error:?}")),
|
||||
};
|
||||
if caps & CAP_FREQUENCY == 0 {
|
||||
return Check::fail(NAME, "backend does not advertise frequency control");
|
||||
}
|
||||
if let Err(error) = client.set_chain_frequency(0, 500) {
|
||||
return Check::fail(NAME, format!("set frequency: {error:?}"));
|
||||
}
|
||||
match client.read_temperature_mc(0) {
|
||||
Ok(value) if (-40_000..=150_000).contains(&value) => {
|
||||
Check::pass(NAME, format!("500 MHz, {} mC", value))
|
||||
}
|
||||
Ok(value) => Check::fail(NAME, format!("implausible temperature {value} mC")),
|
||||
Err(error) => Check::fail(NAME, format!("read temperature: {error:?}")),
|
||||
}
|
||||
}
|
||||
Err(error) => Check::fail(NAME, error),
|
||||
}
|
||||
}
|
||||
|
||||
fn check_power(socket: &Path) -> Check {
|
||||
const NAME: &str = "read power";
|
||||
match connect(socket) {
|
||||
Ok(mut client) => match client.capabilities() {
|
||||
Ok(mask) if mask & CAP_POWER == 0 => {
|
||||
Check::fail(NAME, "backend does not advertise power telemetry")
|
||||
}
|
||||
Ok(_) => {
|
||||
// Ask for a known operating point first: a backend that always reports 0 W would
|
||||
// otherwise pass a range check while being useless to a power-target loop.
|
||||
if let Err(error) = client.set_chain_frequency(0, 500) {
|
||||
return Check::fail(NAME, format!("set frequency: {error:?}"));
|
||||
}
|
||||
std::thread::sleep(std::time::Duration::from_millis(50));
|
||||
match client.read_power_w() {
|
||||
Ok(0) => Check::fail(NAME, "reports 0 W at 500 MHz"),
|
||||
Ok(watts) if watts <= 10_000 => {
|
||||
Check::pass(NAME, format!("{watts} W at 500 MHz"))
|
||||
}
|
||||
Ok(watts) => Check::fail(NAME, format!("implausible power {watts} W")),
|
||||
Err(error) => Check::fail(NAME, format!("{error:?}")),
|
||||
}
|
||||
}
|
||||
Err(error) => Check::fail(NAME, format!("{error:?}")),
|
||||
},
|
||||
Err(error) => Check::fail(NAME, error),
|
||||
}
|
||||
}
|
||||
|
||||
fn check_fan(socket: &Path) -> Check {
|
||||
const NAME: &str = "fan target";
|
||||
match connect(socket) {
|
||||
Ok(mut client) => match client.set_fan_target(0, 100) {
|
||||
Ok(()) => Check::pass(NAME, "100 percent accepted"),
|
||||
Err(error) => Check::fail(NAME, format!("{error:?}")),
|
||||
},
|
||||
Err(error) => Check::fail(NAME, error),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::hal_sim::{serve, SimConfig};
|
||||
|
||||
fn socket(name: &str) -> std::path::PathBuf {
|
||||
std::env::temp_dir().join(format!("alkane-conf-{}-{name}.sock", std::process::id()))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_reference_server_passes_every_check() {
|
||||
let path = socket("ok");
|
||||
let server_path = path.clone();
|
||||
let server = std::thread::spawn(move || {
|
||||
let _ = serve(&server_path, SimConfig::default());
|
||||
});
|
||||
// The reference server binds inside serve(); wait for the socket to exist.
|
||||
for _ in 0..100 {
|
||||
if path.exists() {
|
||||
break;
|
||||
}
|
||||
std::thread::sleep(std::time::Duration::from_millis(10));
|
||||
}
|
||||
let checks = run(&path);
|
||||
let failed: Vec<&Check> = checks.iter().filter(|check| !check.passed).collect();
|
||||
assert!(failed.is_empty(), "reference server failed: {failed:?}");
|
||||
assert_eq!(checks.len(), 7);
|
||||
let _ = std::fs::remove_file(&path);
|
||||
// The server thread is left to exit when the socket disappears.
|
||||
drop(server);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_unreachable_socket_fails_every_check() {
|
||||
let path = socket("missing");
|
||||
let checks = run(&path);
|
||||
assert_eq!(checks.len(), 7);
|
||||
assert!(checks.iter().all(|check| !check.passed));
|
||||
}
|
||||
}
|
||||
+255
@@ -0,0 +1,255 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Reference HAL server.
|
||||
//!
|
||||
//! Speaks the same ALKH contract a family backend serves on a real board, but answers from a fixed
|
||||
//! description of a machine. Two uses: it lets the whole OS path run on any development machine, and
|
||||
//! it shows a backend author exactly what each opcode must return.
|
||||
|
||||
use std::io::{self, Read, Write};
|
||||
use std::os::unix::net::{UnixListener, UnixStream};
|
||||
use std::path::Path;
|
||||
|
||||
const MAGIC: [u8; 4] = *b"ALKH";
|
||||
const VERSION: u8 = 1;
|
||||
const RESPONSE: u16 = 1;
|
||||
const HEADER_LEN: usize = 16;
|
||||
|
||||
const SEND_FRAME: u8 = 1;
|
||||
const RECEIVE_FRAME: u8 = 2;
|
||||
const SET_CHAIN_RESET: u8 = 3;
|
||||
const SET_FAN_TARGET: u8 = 4;
|
||||
const READ_TEMPERATURE: u8 = 5;
|
||||
const SET_PSU_ENABLED: u8 = 6;
|
||||
const CAPABILITIES: u8 = 7;
|
||||
const PROBE_CHAIN: u8 = 8;
|
||||
const READ_EEPROM: u8 = 9;
|
||||
const IDENTIFY_PSU: u8 = 10;
|
||||
const SET_CHAIN_FREQUENCY: u8 = 11;
|
||||
const READ_POWER: u8 = 12;
|
||||
|
||||
const CAP_ALL: u32 = (1 << 5) - 1;
|
||||
|
||||
/// What the simulated machine looks like.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct SimConfig {
|
||||
/// Chains that identify. Chains beyond this answer silent.
|
||||
pub chains: u8,
|
||||
/// Chips reported per chain.
|
||||
pub chips: u16,
|
||||
/// Chip identifier on the wire (1 = bm1362).
|
||||
pub chip: u8,
|
||||
/// Report a working EEPROM instead of an absent one.
|
||||
pub eeprom: bool,
|
||||
/// PSU name and envelope, or `None` to fail identification.
|
||||
pub psu: Option<(String, u16, u16, u16, u16, u16)>,
|
||||
/// Fans on the simulated chassis; zones are distributed over them.
|
||||
pub fans: u8,
|
||||
}
|
||||
|
||||
impl Default for SimConfig {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
chains: 3,
|
||||
chips: 126,
|
||||
chip: 1,
|
||||
eeprom: false,
|
||||
psu: Some(("APW12".into(), 1200, 1600, 0, 1000, 3600)),
|
||||
fans: 2,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct State {
|
||||
config: SimConfig,
|
||||
frequency_mhz: u16,
|
||||
/// Duty per fan, so a zone can respond to the fan that actually cools it.
|
||||
fan_pwm: [u8; 4],
|
||||
}
|
||||
|
||||
impl State {
|
||||
/// Which fan cools a zone. Zones are distributed over the fans round-robin.
|
||||
fn owner(&self, zone: u8) -> usize {
|
||||
let fans = usize::from(self.config.fans.max(1));
|
||||
usize::from(zone) % fans
|
||||
}
|
||||
}
|
||||
|
||||
/// Serve one socket path until the program exits.
|
||||
pub fn serve(path: &Path, config: SimConfig) -> io::Result<()> {
|
||||
let _ = std::fs::remove_file(path);
|
||||
let listener = UnixListener::bind(path)?;
|
||||
for stream in listener.incoming() {
|
||||
let Ok(stream) = stream else { continue };
|
||||
let mut state = State {
|
||||
config: config.clone(),
|
||||
frequency_mhz: 0,
|
||||
fan_pwm: [100; 4],
|
||||
};
|
||||
let _ = serve_connection(stream, &mut state);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn serve_connection(mut stream: UnixStream, state: &mut State) -> io::Result<()> {
|
||||
loop {
|
||||
let mut header = [0_u8; HEADER_LEN];
|
||||
if stream.read_exact(&mut header).is_err() {
|
||||
return Ok(());
|
||||
}
|
||||
if header[..4] != MAGIC {
|
||||
return Err(io::Error::new(io::ErrorKind::InvalidData, "bad HAL magic"));
|
||||
}
|
||||
let opcode = header[5];
|
||||
let sequence = header[8..12].to_vec();
|
||||
let length = u32::from_le_bytes([header[12], header[13], header[14], header[15]]) as usize;
|
||||
let mut payload = vec![0_u8; length];
|
||||
if length > 0 && stream.read_exact(&mut payload).is_err() {
|
||||
return Ok(());
|
||||
}
|
||||
let body = respond(opcode, &payload, state);
|
||||
let mut out = [0_u8; HEADER_LEN];
|
||||
out[..4].copy_from_slice(&MAGIC);
|
||||
out[4] = VERSION;
|
||||
out[5] = opcode;
|
||||
out[6..8].copy_from_slice(&RESPONSE.to_le_bytes());
|
||||
out[8..12].copy_from_slice(&sequence);
|
||||
out[12..16].copy_from_slice(&(body.len() as u32).to_le_bytes());
|
||||
stream.write_all(&out)?;
|
||||
stream.write_all(&body)?;
|
||||
stream.flush()?;
|
||||
}
|
||||
}
|
||||
|
||||
fn respond(opcode: u8, payload: &[u8], state: &mut State) -> Vec<u8> {
|
||||
match opcode {
|
||||
CAPABILITIES => {
|
||||
let mut body = vec![0_u8];
|
||||
body.extend_from_slice(&CAP_ALL.to_le_bytes());
|
||||
body
|
||||
}
|
||||
PROBE_CHAIN => {
|
||||
let chain = payload.first().copied().unwrap_or(0);
|
||||
if chain >= state.config.chains {
|
||||
return vec![0, 1, 0, 0, 0]; // silent
|
||||
}
|
||||
let chips = state.config.chips.to_le_bytes();
|
||||
vec![0, 0, state.config.chip, chips[0], chips[1]]
|
||||
}
|
||||
READ_EEPROM => {
|
||||
if state.config.eeprom {
|
||||
let mut body = vec![0_u8, 0];
|
||||
body.extend_from_slice(b"BHB42601");
|
||||
body
|
||||
} else {
|
||||
vec![0, 1]
|
||||
}
|
||||
}
|
||||
IDENTIFY_PSU => match &state.config.psu {
|
||||
Some((name, v_min, v_max, f_min, f_max, watts)) => {
|
||||
let mut body = vec![0_u8, name.len() as u8];
|
||||
body.extend_from_slice(name.as_bytes());
|
||||
for word in [*v_min, *v_max, *f_min, *f_max, *watts] {
|
||||
body.extend_from_slice(&word.to_le_bytes());
|
||||
}
|
||||
body
|
||||
}
|
||||
None => vec![1],
|
||||
},
|
||||
SET_CHAIN_FREQUENCY => {
|
||||
if let Some(mhz) = payload.get(1..3) {
|
||||
state.frequency_mhz = u16::from_le_bytes([mhz[0], mhz[1]]);
|
||||
}
|
||||
vec![0]
|
||||
}
|
||||
SET_FAN_TARGET => {
|
||||
let fan = usize::from(payload.first().copied().unwrap_or(0)).min(3);
|
||||
state.fan_pwm[fan] = payload.get(1).copied().unwrap_or(0);
|
||||
vec![0]
|
||||
}
|
||||
READ_TEMPERATURE => {
|
||||
// Temperature rises with frequency so the tuner has something to regulate, and falls
|
||||
// when the fan that owns the zone is fast so the fan sweep can learn the mapping.
|
||||
let zone = payload.first().copied().unwrap_or(0);
|
||||
let rise = i32::from(state.frequency_mhz) * 20;
|
||||
let airflow = if state.fan_pwm[state.owner(zone)] >= 100 {
|
||||
0
|
||||
} else {
|
||||
20_000
|
||||
};
|
||||
let mut body = vec![0_u8];
|
||||
body.extend_from_slice(&(45_000 + rise + airflow).to_le_bytes());
|
||||
body
|
||||
}
|
||||
READ_POWER => {
|
||||
// Four watts per MHz, so a power target has something to regulate.
|
||||
let watts = u16::try_from(u32::from(state.frequency_mhz) * 4).unwrap_or(u16::MAX);
|
||||
let mut body = vec![0_u8];
|
||||
body.extend_from_slice(&watts.to_le_bytes());
|
||||
body
|
||||
}
|
||||
SET_CHAIN_RESET | SET_PSU_ENABLED => vec![0],
|
||||
SEND_FRAME => vec![0],
|
||||
RECEIVE_FRAME => {
|
||||
// No nonce traffic in the reference backend.
|
||||
let count: u16 = 0;
|
||||
let mut body = vec![0_u8];
|
||||
body.extend_from_slice(&count.to_le_bytes());
|
||||
body
|
||||
}
|
||||
_ => vec![1],
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::fanmap::FanProbe;
|
||||
use crate::hal_wire::HalClient;
|
||||
use crate::HardwareBackend;
|
||||
|
||||
#[test]
|
||||
fn a_client_can_detect_against_the_reference_server() {
|
||||
let path = std::env::temp_dir().join(format!("alkane-sim-hal-{}.sock", std::process::id()));
|
||||
// Bind before spawning so the client cannot race the socket into existence.
|
||||
let listener = UnixListener::bind(&path).expect("bind");
|
||||
let server = std::thread::spawn(move || {
|
||||
let (stream, _) = listener.accept().expect("accept");
|
||||
let mut state = State {
|
||||
config: SimConfig::default(),
|
||||
frequency_mhz: 0,
|
||||
fan_pwm: [100; 4],
|
||||
};
|
||||
let _ = serve_connection(stream, &mut state);
|
||||
});
|
||||
let mut client = HalClient::connect(&path).expect("connect");
|
||||
assert_eq!(client.capabilities().expect("caps"), CAP_ALL);
|
||||
match client.probe_chain(0, 0).expect("probe") {
|
||||
crate::detect::ProbeOutcome::Identified { chip, chips } => {
|
||||
assert_eq!(chip, crate::detect::ChipModel::Bm1362);
|
||||
assert_eq!(chips, 126);
|
||||
}
|
||||
other => panic!("unexpected probe: {other:?}"),
|
||||
}
|
||||
assert_eq!(
|
||||
client.read_eeprom(0).expect("eeprom"),
|
||||
crate::detect::EepromState::Absent
|
||||
);
|
||||
let psu = client.identify_psu().expect("psu");
|
||||
assert_eq!(psu.name, "APW12");
|
||||
client.set_chain_frequency(0, 512).expect("freq");
|
||||
assert_eq!(client.read_power_w().expect("power"), 512 * 4);
|
||||
// Zone 1 is owned by fan 1: slowing fan 1 must heat zone 1 and not zone 0.
|
||||
let baseline_0 = client.read_temperature_mc(0).expect("temp");
|
||||
let baseline_1 = client.read_temperature_mc(1).expect("temp");
|
||||
client.set_fan(1, 40).expect("fan");
|
||||
assert_eq!(client.read_temperature_mc(0).expect("temp"), baseline_0);
|
||||
assert!(client.read_temperature_mc(1).expect("temp") > baseline_1);
|
||||
assert_eq!(
|
||||
client.read_temperature_mc(0).expect("temp"),
|
||||
45_000 + 512 * 20
|
||||
);
|
||||
drop(client);
|
||||
let _ = std::fs::remove_file(&path);
|
||||
server.join().expect("server");
|
||||
}
|
||||
}
|
||||
+286
@@ -1,6 +1,9 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Versioned local wire contract between Alkane OS and an SDK hardware backend.
|
||||
|
||||
use crate::detect::{
|
||||
ChipModel, DetectionBackend, EepromState, Envelope, ProbeOutcome, PsuCapability,
|
||||
};
|
||||
use crate::HardwareBackend;
|
||||
use std::fmt;
|
||||
use std::io::{self, Read, Write};
|
||||
@@ -24,6 +27,27 @@ const SET_CHAIN_RESET: u8 = 3;
|
||||
const SET_FAN_TARGET: u8 = 4;
|
||||
const READ_TEMPERATURE: u8 = 5;
|
||||
const SET_PSU_ENABLED: u8 = 6;
|
||||
const CAPABILITIES: u8 = 7;
|
||||
const PROBE_CHAIN: u8 = 8;
|
||||
const READ_EEPROM: u8 = 9;
|
||||
const IDENTIFY_PSU: u8 = 10;
|
||||
const SET_CHAIN_FREQUENCY: u8 = 11;
|
||||
const READ_POWER: u8 = 12;
|
||||
|
||||
/// Backend feature bits reported by `CAPABILITIES`.
|
||||
pub const CAP_CHAIN_PROBE: u32 = 1 << 0;
|
||||
pub const CAP_EEPROM: u32 = 1 << 1;
|
||||
pub const CAP_PSU_IDENTITY: u32 = 1 << 2;
|
||||
pub const CAP_FREQUENCY: u32 = 1 << 3;
|
||||
pub const CAP_POWER: u32 = 1 << 4;
|
||||
|
||||
const PROBE_IDENTIFIED: u8 = 0;
|
||||
const PROBE_SILENT: u8 = 1;
|
||||
const PROBE_GARBLED: u8 = 2;
|
||||
|
||||
const EEPROM_PRESENT: u8 = 0;
|
||||
const EEPROM_ABSENT: u8 = 1;
|
||||
const EEPROM_INVALID: u8 = 2;
|
||||
|
||||
#[cfg(not(target_os = "linux"))]
|
||||
compile_error!("Alkane HAL sockets require Linux");
|
||||
@@ -337,6 +361,156 @@ fn connect_until(path: &Path, deadline: Instant) -> io::Result<UnixStream> {
|
||||
Ok(stream)
|
||||
}
|
||||
|
||||
impl HalClient {
|
||||
/// Feature mask advertised by the backend. Old backends reject the opcode, which surfaces as
|
||||
/// a protocol error rather than a silent zero.
|
||||
pub fn capabilities(&mut self) -> Result<u32, HalError> {
|
||||
let body = self.exchange(CAPABILITIES, &[])?;
|
||||
let bytes: [u8; 4] = body
|
||||
.try_into()
|
||||
.map_err(|_| HalError::Protocol("invalid capability response"))?;
|
||||
Ok(u32::from_le_bytes(bytes))
|
||||
}
|
||||
|
||||
fn require(&mut self, capability: u32) -> Result<(), HalError> {
|
||||
if self.capabilities()? & capability == 0 {
|
||||
return Err(HalError::Protocol("backend lacks a detection capability"));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn probe_chain(&mut self, chain: u8, attempt: u8) -> Result<ProbeOutcome, HalError> {
|
||||
self.require(CAP_CHAIN_PROBE)?;
|
||||
let body = self.exchange(PROBE_CHAIN, &[chain, attempt])?;
|
||||
if body.len() != 4 {
|
||||
self.poison();
|
||||
return Err(HalError::Protocol("invalid probe response"));
|
||||
}
|
||||
let chips = u16::from_le_bytes([body[2], body[3]]);
|
||||
match body[0] {
|
||||
PROBE_IDENTIFIED => match chip_from_wire(body[1]) {
|
||||
Some(chip) => Ok(ProbeOutcome::Identified { chip, chips }),
|
||||
None => {
|
||||
self.poison();
|
||||
Err(HalError::Protocol("unknown chip identifier"))
|
||||
}
|
||||
},
|
||||
PROBE_SILENT => Ok(ProbeOutcome::Silent),
|
||||
PROBE_GARBLED => Ok(ProbeOutcome::Garbled),
|
||||
_ => {
|
||||
self.poison();
|
||||
Err(HalError::Protocol("invalid probe outcome"))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn read_eeprom(&mut self, chain: u8) -> Result<EepromState, HalError> {
|
||||
self.require(CAP_EEPROM)?;
|
||||
let body = self.exchange(READ_EEPROM, &[chain])?;
|
||||
match body.first().copied() {
|
||||
Some(EEPROM_ABSENT) if body.len() == 1 => Ok(EepromState::Absent),
|
||||
Some(EEPROM_INVALID) if body.len() == 1 => Ok(EepromState::Invalid),
|
||||
Some(EEPROM_PRESENT) if body.len() > 1 => {
|
||||
let model = std::str::from_utf8(&body[1..])
|
||||
.map_err(|_| HalError::Protocol("invalid EEPROM model text"))?;
|
||||
Ok(EepromState::Present {
|
||||
model: model.to_owned(),
|
||||
})
|
||||
}
|
||||
_ => {
|
||||
self.poison();
|
||||
Err(HalError::Protocol("invalid EEPROM response"))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Apply a chain frequency in MHz. The backend owns the PLL write; the OS owns the decision.
|
||||
pub fn set_chain_frequency(&mut self, chain: u8, mhz: u16) -> Result<(), HalError> {
|
||||
self.require(CAP_FREQUENCY)?;
|
||||
let mut payload = [0_u8; 3];
|
||||
payload[0] = chain;
|
||||
payload[1..].copy_from_slice(&mhz.to_le_bytes());
|
||||
self.empty_reply(SET_CHAIN_FREQUENCY, &payload)
|
||||
}
|
||||
|
||||
/// Measured DC input power in watts, when the board can read its PSU.
|
||||
pub fn read_power_w(&mut self) -> Result<u16, HalError> {
|
||||
self.require(CAP_POWER)?;
|
||||
let body = self.exchange(READ_POWER, &[])?;
|
||||
if body.len() != 2 {
|
||||
self.poison();
|
||||
return Err(HalError::Protocol("invalid power response"));
|
||||
}
|
||||
Ok(u16::from_le_bytes([body[0], body[1]]))
|
||||
}
|
||||
|
||||
pub fn identify_psu(&mut self) -> Result<PsuCapability, HalError> {
|
||||
self.require(CAP_PSU_IDENTITY)?;
|
||||
let body = self.exchange(IDENTIFY_PSU, &[])?;
|
||||
let name_len = *body
|
||||
.first()
|
||||
.ok_or(HalError::Protocol("empty PSU response"))? as usize;
|
||||
if body.len() != name_len + 1 + 10 {
|
||||
self.poison();
|
||||
return Err(HalError::Protocol("invalid PSU response"));
|
||||
}
|
||||
let name = std::str::from_utf8(&body[1..1 + name_len])
|
||||
.map_err(|_| HalError::Protocol("invalid PSU name"))?
|
||||
.to_owned();
|
||||
let at = 1 + name_len;
|
||||
let word = |offset: usize| u16::from_le_bytes([body[at + offset], body[at + offset + 1]]);
|
||||
Ok(PsuCapability {
|
||||
name,
|
||||
envelope: Envelope {
|
||||
v_min_mv: word(0),
|
||||
v_max_mv: word(2),
|
||||
f_min_mhz: word(4),
|
||||
f_max_mhz: word(6),
|
||||
},
|
||||
max_dc_watts: word(8),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl DetectionBackend for HalClient {
|
||||
type Error = HalError;
|
||||
|
||||
fn probe(&mut self, chain: u8, attempt: u8) -> Result<ProbeOutcome, Self::Error> {
|
||||
self.probe_chain(chain, attempt)
|
||||
}
|
||||
|
||||
fn eeprom(&mut self, chain: u8) -> Result<EepromState, Self::Error> {
|
||||
self.read_eeprom(chain)
|
||||
}
|
||||
|
||||
fn identify_psu(&mut self) -> Result<Option<PsuCapability>, Self::Error> {
|
||||
self.identify_psu().map(Some)
|
||||
}
|
||||
}
|
||||
|
||||
impl crate::fanmap::FanProbe for HalClient {
|
||||
type Error = HalError;
|
||||
|
||||
fn set_fan(&mut self, fan: u8, pwm: u8) -> Result<(), Self::Error> {
|
||||
self.set_fan_target(fan, pwm)
|
||||
}
|
||||
|
||||
fn read_zone(&mut self, zone: u8) -> Result<i32, Self::Error> {
|
||||
self.read_temperature_mc(zone)
|
||||
}
|
||||
}
|
||||
|
||||
fn chip_from_wire(value: u8) -> Option<ChipModel> {
|
||||
match value {
|
||||
1 => Some(ChipModel::Bm1362),
|
||||
2 => Some(ChipModel::Bm1366),
|
||||
3 => Some(ChipModel::Bm1368),
|
||||
4 => Some(ChipModel::Bm1370),
|
||||
5 => Some(ChipModel::Bm1398),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
impl HardwareBackend for HalClient {
|
||||
type Error = HalError;
|
||||
|
||||
@@ -403,3 +577,115 @@ impl HardwareBackend for HalClient {
|
||||
result
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::fanmap::FanProbe;
|
||||
use std::os::unix::net::UnixStream;
|
||||
|
||||
fn mock_backend(mut server: UnixStream) {
|
||||
loop {
|
||||
let mut header = [0_u8; 16];
|
||||
if server.read_exact(&mut header).is_err() {
|
||||
return;
|
||||
}
|
||||
let opcode = header[5];
|
||||
let sequence = [header[8], header[9], header[10], header[11]];
|
||||
let length = u32::from_le_bytes(header[12..16].try_into().unwrap()) as usize;
|
||||
let mut payload = vec![0_u8; length];
|
||||
if length > 0 && server.read_exact(&mut payload).is_err() {
|
||||
return;
|
||||
}
|
||||
let body: Vec<u8> = match opcode {
|
||||
CAPABILITIES => {
|
||||
let mut body = vec![0_u8];
|
||||
body.extend_from_slice(
|
||||
&(CAP_CHAIN_PROBE
|
||||
| CAP_EEPROM
|
||||
| CAP_PSU_IDENTITY
|
||||
| CAP_FREQUENCY
|
||||
| CAP_POWER)
|
||||
.to_le_bytes(),
|
||||
);
|
||||
body
|
||||
}
|
||||
PROBE_CHAIN => vec![0, PROBE_IDENTIFIED, 1, 126, 0],
|
||||
READ_EEPROM => {
|
||||
let mut body = vec![0, EEPROM_PRESENT];
|
||||
body.extend_from_slice(b"BHB42601");
|
||||
body
|
||||
}
|
||||
IDENTIFY_PSU => {
|
||||
let name = b"APW12";
|
||||
let mut body = vec![0_u8];
|
||||
body.push(name.len() as u8);
|
||||
body.extend_from_slice(name);
|
||||
for word in [1200_u16, 1600, 0, 1000, 3600] {
|
||||
body.extend_from_slice(&word.to_le_bytes());
|
||||
}
|
||||
body
|
||||
}
|
||||
SET_FAN_TARGET | SET_CHAIN_FREQUENCY => vec![0],
|
||||
READ_POWER => {
|
||||
let mut body = vec![0_u8];
|
||||
body.extend_from_slice(&0_u16.to_le_bytes());
|
||||
body
|
||||
}
|
||||
READ_TEMPERATURE => {
|
||||
let mut body = vec![0_u8];
|
||||
body.extend_from_slice(&42_000_i32.to_le_bytes());
|
||||
body
|
||||
}
|
||||
_ => vec![1],
|
||||
};
|
||||
let mut out = [0_u8; 16];
|
||||
out[..4].copy_from_slice(&MAGIC);
|
||||
out[4] = VERSION;
|
||||
out[5] = opcode;
|
||||
out[6..8].copy_from_slice(&RESPONSE.to_le_bytes());
|
||||
out[8..12].copy_from_slice(&sequence);
|
||||
out[12..16].copy_from_slice(&(body.len() as u32).to_le_bytes());
|
||||
if server.write_all(&out).is_err() || server.write_all(&body).is_err() {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn detection_verbs_round_trip_over_the_wire() {
|
||||
let (client_stream, server_stream) = UnixStream::pair().expect("socket pair");
|
||||
let server = std::thread::spawn(move || mock_backend(server_stream));
|
||||
let mut client = HalClient::from_stream(client_stream).expect("client");
|
||||
|
||||
assert_eq!(
|
||||
client.capabilities().expect("capabilities"),
|
||||
CAP_CHAIN_PROBE | CAP_EEPROM | CAP_PSU_IDENTITY | CAP_FREQUENCY | CAP_POWER
|
||||
);
|
||||
match client.probe_chain(0, 0).expect("probe") {
|
||||
ProbeOutcome::Identified { chip, chips } => {
|
||||
assert_eq!(chip, ChipModel::Bm1362);
|
||||
assert_eq!(chips, 126);
|
||||
}
|
||||
other => panic!("unexpected probe outcome: {other:?}"),
|
||||
}
|
||||
assert_eq!(
|
||||
client.read_eeprom(0).expect("eeprom"),
|
||||
EepromState::Present {
|
||||
model: "BHB42601".into()
|
||||
}
|
||||
);
|
||||
let psu = client.identify_psu().expect("psu");
|
||||
assert_eq!(psu.name, "APW12");
|
||||
assert_eq!(psu.envelope.v_min_mv, 1200);
|
||||
assert_eq!(psu.envelope.v_max_mv, 1600);
|
||||
assert_eq!(psu.max_dc_watts, 3600);
|
||||
|
||||
client.set_chain_frequency(2, 512).expect("set frequency");
|
||||
client.set_fan(1, 60).expect("set fan");
|
||||
assert_eq!(client.read_zone(2).expect("read zone"), 42_000);
|
||||
|
||||
drop(client);
|
||||
server.join().expect("server thread");
|
||||
}
|
||||
}
|
||||
|
||||
+18
@@ -3,21 +3,39 @@
|
||||
//! An entry in the target matrix is a development obligation, not a claim that
|
||||
//! the pairing already mines. Hardware backends are supplied by SDK images.
|
||||
|
||||
pub mod app;
|
||||
pub mod bm1362;
|
||||
pub mod bm1366;
|
||||
pub mod bm1370;
|
||||
pub mod bm13xx;
|
||||
pub mod detect;
|
||||
pub mod dashboard;
|
||||
pub mod difficulty;
|
||||
pub mod fanmap;
|
||||
pub mod fanmap_store;
|
||||
pub mod fault;
|
||||
pub mod hal_conformance;
|
||||
pub mod hal_sim;
|
||||
pub mod hal_wire;
|
||||
pub mod management;
|
||||
pub mod miner;
|
||||
pub mod pow;
|
||||
pub mod profiles;
|
||||
pub mod runtime;
|
||||
pub mod scrypt_pow;
|
||||
pub mod split;
|
||||
pub mod stratum_client;
|
||||
pub mod stratum_link;
|
||||
pub mod stratum_session;
|
||||
pub mod stratum_submit;
|
||||
pub mod stratum_v1;
|
||||
pub mod stratum_v2;
|
||||
pub mod stratum_v2_session;
|
||||
pub mod stratum_wire;
|
||||
pub mod stratum_work;
|
||||
pub mod tuning;
|
||||
pub mod ui;
|
||||
pub mod web;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum Vendor {
|
||||
|
||||
+352
-10
@@ -1,9 +1,17 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
use alkane_os::app;
|
||||
use alkane_os::detect::{
|
||||
ChipModel as DetectedChip, DetectionBackend, EepromState, Envelope, ProbeBudget, ProbeOutcome,
|
||||
PsuCapability, SensorTopology,
|
||||
};
|
||||
use alkane_os::hal_wire::HalClient;
|
||||
use alkane_os::management::{bind_local, serve, MiningStatus};
|
||||
use alkane_os::management::MiningStatus;
|
||||
use alkane_os::miner::{Bm1366Miner, ChipModel};
|
||||
use alkane_os::runtime::{Tick, TickOutcome};
|
||||
use alkane_os::stratum_client::{PoolConnection, PoolEvent};
|
||||
use alkane_os::target_matrix;
|
||||
use alkane_os::tuning::{PidConfig, TuningTarget};
|
||||
use alkane_os::HardwareBackend;
|
||||
use std::error::Error;
|
||||
use std::io;
|
||||
use std::net::SocketAddr;
|
||||
@@ -26,14 +34,18 @@ fn sim_mine(mut args: impl Iterator<Item = String>) -> Result<(), Box<dyn Error>
|
||||
let password = std::env::var("ALKANE_POOL_PASSWORD")
|
||||
.map_err(|_| "set ALKANE_POOL_PASSWORD in the environment")?;
|
||||
let status = Arc::new(MiningStatus::new());
|
||||
if let Ok(bind) = std::env::var("ALKANE_API_LISTEN") {
|
||||
let listener = bind_local(bind.parse()?)?;
|
||||
let snapshot = Arc::clone(&status);
|
||||
std::thread::spawn(move || {
|
||||
if let Err(error) = serve(listener, snapshot) {
|
||||
eprintln!("management API stopped: {error}");
|
||||
}
|
||||
});
|
||||
let api = std::env::var("ALKANE_API_LISTEN")
|
||||
.ok()
|
||||
.map(|bind| bind.parse())
|
||||
.transpose()?;
|
||||
let web = web_listen()?;
|
||||
let servers = app::start(Arc::clone(&status), api, web)?;
|
||||
let (api_address, web_address) = servers.addresses();
|
||||
if let Some(address) = api_address {
|
||||
println!("management API on {address}");
|
||||
}
|
||||
if let Some(address) = web_address {
|
||||
println!("web UI on http://{address}/");
|
||||
}
|
||||
|
||||
// Connect to the pool before enabling power. The SDK HAL server owns the
|
||||
@@ -80,6 +92,249 @@ fn sim_mine(mut args: impl Iterator<Item = String>) -> Result<(), Box<dyn Error>
|
||||
}
|
||||
}
|
||||
|
||||
/// A backend that answers without hardware, so the boot path can be exercised on any machine.
|
||||
struct SelfCheckBackend;
|
||||
|
||||
impl DetectionBackend for SelfCheckBackend {
|
||||
type Error = ();
|
||||
|
||||
fn probe(&mut self, _chain: u8, _attempt: u8) -> Result<ProbeOutcome, ()> {
|
||||
Ok(ProbeOutcome::Identified {
|
||||
chip: DetectedChip::Bm1362,
|
||||
chips: 126,
|
||||
})
|
||||
}
|
||||
|
||||
fn eeprom(&mut self, _chain: u8) -> Result<EepromState, ()> {
|
||||
Ok(EepromState::Absent)
|
||||
}
|
||||
|
||||
fn identify_psu(&mut self) -> Result<Option<PsuCapability>, ()> {
|
||||
Ok(Some(PsuCapability {
|
||||
name: "APW12".into(),
|
||||
envelope: Envelope {
|
||||
v_min_mv: 1200,
|
||||
v_max_mv: 1600,
|
||||
f_min_mhz: 0,
|
||||
f_max_mhz: 1000,
|
||||
},
|
||||
max_dc_watts: 3600,
|
||||
}))
|
||||
}
|
||||
}
|
||||
|
||||
/// Run detection, the runtime loop and the API document against the self-check backend.
|
||||
///
|
||||
/// This is the smoke test an image can run on a bench machine before any hashboard is attached:
|
||||
/// it proves the profile database parses, detection produces a plan, the tuner moves within the
|
||||
/// envelope and the published document is well formed.
|
||||
fn self_check() -> Result<(), Box<dyn Error>> {
|
||||
let status = MiningStatus::new();
|
||||
let config = app::BootConfig {
|
||||
profile_db_json: include_str!("../profiles.example.json").to_owned(),
|
||||
chain_ports: vec![0, 1, 2],
|
||||
sensor: SensorTopology::Pic,
|
||||
budget: ProbeBudget::default(),
|
||||
fan_zones: Vec::new(),
|
||||
target: TuningTarget::PowerW(2_400.0),
|
||||
pid: PidConfig::default(),
|
||||
ceiling_mc: 95_000,
|
||||
fault_policy: Default::default(),
|
||||
};
|
||||
let mut backend = SelfCheckBackend;
|
||||
let mut runtime = app::boot(&mut backend, &config, &status)?;
|
||||
let start = runtime.operating_point().frequency_mhz;
|
||||
for _ in 0..20 {
|
||||
let power = 4.0 * f32::from(runtime.operating_point().frequency_mhz);
|
||||
runtime.tick(&Tick {
|
||||
power_w: Some(power),
|
||||
hashrate_ths: None,
|
||||
hottest_mc: Some(70_000),
|
||||
ambient_mc: None,
|
||||
dt_s: 1.0,
|
||||
});
|
||||
}
|
||||
let end = runtime.operating_point().frequency_mhz;
|
||||
if end <= start {
|
||||
return Err("self-check: frequency did not move toward the target".into());
|
||||
}
|
||||
if runtime.active_chains().len() != 3 {
|
||||
return Err("self-check: detection did not expose three chains".into());
|
||||
}
|
||||
status.set_hardware(app::snapshot(&runtime, &app::target_label(&config.target)));
|
||||
let document = status.hardware_document();
|
||||
if document["available"] != true {
|
||||
return Err("self-check: hardware document is not available".into());
|
||||
}
|
||||
println!("{}", serde_json::to_string_pretty(&document)?);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn parse_target(text: &str) -> Result<TuningTarget, Box<dyn Error>> {
|
||||
let (kind, value) = text
|
||||
.split_once(':')
|
||||
.ok_or("target must look like power:2400")?;
|
||||
let value: f32 = value.parse()?;
|
||||
Ok(match kind {
|
||||
"power" => TuningTarget::PowerW(value),
|
||||
"hashrate" => TuningTarget::HashrateThs(value),
|
||||
"ambient" => TuningTarget::AmbientC {
|
||||
margin_mc: value as i32,
|
||||
},
|
||||
"fan" => TuningTarget::MaxFan {
|
||||
max_pwm: value as u8,
|
||||
},
|
||||
_ => return Err("target must be power, hashrate, ambient or fan".into()),
|
||||
})
|
||||
}
|
||||
|
||||
/// Boot a real board through the HAL socket, then run a bounded tuning loop.
|
||||
fn boot_hal(mut args: impl Iterator<Item = String>) -> Result<(), Box<dyn Error>> {
|
||||
let socket = args.next().ok_or("missing HAL socket")?;
|
||||
let profiles = args.next().ok_or("missing profile database path")?;
|
||||
let target = parse_target(&args.next().ok_or("missing target")?)?;
|
||||
let sensor = match args.next().as_deref() {
|
||||
Some("nopic") => SensorTopology::NoPic,
|
||||
Some("pic") | None => SensorTopology::Pic,
|
||||
Some(_) => return Err("sensor must be pic or nopic".into()),
|
||||
};
|
||||
let ticks: usize = args
|
||||
.next()
|
||||
.map(|value| value.parse())
|
||||
.transpose()?
|
||||
.unwrap_or(30);
|
||||
let profile_db_json = std::fs::read_to_string(&profiles)?;
|
||||
let status = Arc::new(MiningStatus::new());
|
||||
let api = std::env::var("ALKANE_API_LISTEN")
|
||||
.ok()
|
||||
.map(|bind| bind.parse())
|
||||
.transpose()?;
|
||||
let web = web_listen()?;
|
||||
let servers = app::start(Arc::clone(&status), api, web)?;
|
||||
|
||||
let config = app::BootConfig {
|
||||
profile_db_json,
|
||||
chain_ports: vec![0, 1, 2],
|
||||
sensor,
|
||||
budget: ProbeBudget::default(),
|
||||
fan_zones: Vec::new(),
|
||||
target,
|
||||
pid: PidConfig::default(),
|
||||
ceiling_mc: 95_000,
|
||||
fault_policy: Default::default(),
|
||||
};
|
||||
let map_path = std::path::PathBuf::from(
|
||||
std::env::var("ALKANE_FANMAP").unwrap_or_else(|_| "/var/lib/alkane/fanmap.json".into()),
|
||||
);
|
||||
// Fan mapping is opt-in: it perturbs the machine and takes minutes, so a plain boot skips it.
|
||||
let fans: u8 = std::env::var("ALKANE_FAN_FANS")
|
||||
.ok()
|
||||
.and_then(|v| v.parse().ok())
|
||||
.unwrap_or(0);
|
||||
let zones: u8 = std::env::var("ALKANE_FAN_ZONES")
|
||||
.ok()
|
||||
.and_then(|v| v.parse().ok())
|
||||
.unwrap_or(0);
|
||||
let settings = app::HalBoot {
|
||||
config: &config,
|
||||
sweep: alkane_os::fanmap::SweepConfig {
|
||||
fans,
|
||||
zones,
|
||||
low_pwm: 40,
|
||||
high_pwm: 100,
|
||||
repeats: 1,
|
||||
settle_ms: std::env::var("ALKANE_FAN_SETTLE_MS")
|
||||
.ok()
|
||||
.and_then(|v| v.parse().ok())
|
||||
.unwrap_or(20_000),
|
||||
},
|
||||
thresholds: Default::default(),
|
||||
map_path: &map_path,
|
||||
};
|
||||
let (mut runtime, _map) =
|
||||
app::boot_from_hal(std::path::Path::new(&socket), &settings, &status)?;
|
||||
println!(
|
||||
"detected {} with {} active chains",
|
||||
runtime.plan().profile,
|
||||
runtime.active_chains().len()
|
||||
);
|
||||
|
||||
let mut client = HalClient::connect(std::path::Path::new(&socket))?;
|
||||
let label = app::target_label(&config.target);
|
||||
for _ in 0..ticks {
|
||||
let hottest = client.read_temperature_mc(0).ok();
|
||||
let power_w = client.read_power_w().ok().map(f32::from);
|
||||
let outcome = runtime.tick(&Tick {
|
||||
power_w,
|
||||
hashrate_ths: None,
|
||||
hottest_mc: hottest,
|
||||
ambient_mc: None,
|
||||
dt_s: 1.0,
|
||||
});
|
||||
if let TickOutcome::Run(command) = outcome {
|
||||
for chain in runtime.active_chains() {
|
||||
client.set_chain_frequency(chain, command.frequency_mhz)?;
|
||||
}
|
||||
if let Some(pwm) = command.fan_pwm {
|
||||
client.set_fan_target(0, pwm)?;
|
||||
}
|
||||
}
|
||||
// Publish every period: a client watching the API must see the live operating point,
|
||||
// not the boot-time snapshot.
|
||||
status.set_hardware(app::snapshot(&runtime, &label));
|
||||
if let Some(reason) = runtime.stop_reason() {
|
||||
println!("stopped: {reason:?}");
|
||||
break;
|
||||
}
|
||||
std::thread::sleep(Duration::from_millis(50));
|
||||
}
|
||||
status.set_hardware(app::snapshot(&runtime, &app::target_label(&config.target)));
|
||||
println!(
|
||||
"{}",
|
||||
serde_json::to_string_pretty(&status.hardware_document())?
|
||||
);
|
||||
let _ = servers;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Where the UI listens. The miner serves it on port 80 of its own address;
|
||||
/// if that is not permitted (a non-root development run), fall back to 8080
|
||||
/// rather than refusing to start.
|
||||
fn web_listen() -> Result<Option<std::net::SocketAddr>, Box<dyn std::error::Error>> {
|
||||
if let Ok(bind) = std::env::var("ALKANE_WEB_LISTEN") {
|
||||
return Ok(Some(bind.parse()?));
|
||||
}
|
||||
let port = if std::net::TcpListener::bind("0.0.0.0:80").is_ok() {
|
||||
80
|
||||
} else {
|
||||
8080
|
||||
};
|
||||
Ok(Some(std::net::SocketAddr::from(([0, 0, 0, 0], port))))
|
||||
}
|
||||
|
||||
/// Serve the UI and the API without a mining backend. A board whose HAL
|
||||
/// backend is not written yet still has to be reachable and observable; every
|
||||
/// page says "not identified" rather than claiming hardware it cannot see.
|
||||
fn serve_only() -> Result<(), Box<dyn std::error::Error>> {
|
||||
let status = Arc::new(MiningStatus::new());
|
||||
let api = std::env::var("ALKANE_API_LISTEN")
|
||||
.ok()
|
||||
.map(|bind| bind.parse())
|
||||
.transpose()?;
|
||||
let api = api.or(Some("0.0.0.0:4028".parse()?));
|
||||
let servers = app::start(Arc::clone(&status), api, web_listen()?)?;
|
||||
let (api_address, web_address) = servers.addresses();
|
||||
if let Some(address) = api_address {
|
||||
println!("management API on {address}");
|
||||
}
|
||||
if let Some(address) = web_address {
|
||||
println!("web UI on http://{address}");
|
||||
}
|
||||
loop {
|
||||
std::thread::sleep(Duration::from_secs(3600));
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let mut args = std::env::args().skip(1);
|
||||
match args.next().as_deref() {
|
||||
@@ -93,6 +348,90 @@ fn main() {
|
||||
}
|
||||
}
|
||||
Some("--version") => println!("alkane-os {}", env!("CARGO_PKG_VERSION")),
|
||||
Some("--serve") => {
|
||||
if let Err(error) = serve_only() {
|
||||
eprintln!("serve failed: {error}");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
Some("--boot") => {
|
||||
if let Err(error) = boot_hal(args) {
|
||||
eprintln!("boot failed: {error}");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
Some("--sim-hal") => {
|
||||
let socket = match args.next() {
|
||||
Some(path) => path,
|
||||
None => {
|
||||
eprintln!("usage: alkane-os --sim-hal SOCKET");
|
||||
std::process::exit(2);
|
||||
}
|
||||
};
|
||||
if let Err(error) = alkane_os::hal_sim::serve(
|
||||
std::path::Path::new(&socket),
|
||||
alkane_os::hal_sim::SimConfig::default(),
|
||||
) {
|
||||
eprintln!("reference HAL stopped: {error}");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
Some("--check-profiles") => {
|
||||
let path = match args.next() {
|
||||
Some(path) => path,
|
||||
None => {
|
||||
eprintln!("usage: alkane-os --check-profiles PATH");
|
||||
std::process::exit(2);
|
||||
}
|
||||
};
|
||||
let text = match std::fs::read_to_string(&path) {
|
||||
Ok(text) => text,
|
||||
Err(error) => {
|
||||
eprintln!("cannot read {path}: {error}");
|
||||
std::process::exit(1);
|
||||
}
|
||||
};
|
||||
match alkane_os::profiles::ProfileDb::from_json(&text) {
|
||||
Ok(db) => {
|
||||
println!("{} profiles, schema 1, validated", db.len());
|
||||
}
|
||||
Err(error) => {
|
||||
eprintln!("profile database rejected: {error:?}");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
Some("--check-hal") => {
|
||||
let socket = match args.next() {
|
||||
Some(path) => path,
|
||||
None => {
|
||||
eprintln!("usage: alkane-os --check-hal SOCKET");
|
||||
std::process::exit(2);
|
||||
}
|
||||
};
|
||||
let checks = alkane_os::hal_conformance::run(std::path::Path::new(&socket));
|
||||
let mut failed = 0;
|
||||
for check in &checks {
|
||||
println!(
|
||||
"{:<28} {:<4} {}",
|
||||
check.name,
|
||||
if check.passed { "PASS" } else { "FAIL" },
|
||||
check.detail
|
||||
);
|
||||
if !check.passed {
|
||||
failed += 1;
|
||||
}
|
||||
}
|
||||
if failed > 0 {
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
Some("--self-check") => {
|
||||
if let Err(error) = self_check() {
|
||||
eprintln!("self-check failed: {error}");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
Some("--mine-simulator") => {
|
||||
if let Err(error) = sim_mine(args) {
|
||||
eprintln!("simulator mining failed: {error}");
|
||||
@@ -100,7 +439,10 @@ fn main() {
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
eprintln!("usage: alkane-os --list-targets | --version | --mine-simulator HAL_SOCKET POOL_ADDRESS WORKER BM1362|BM1366 [MAX_ACCEPTS]");
|
||||
eprintln!("usage: alkane-os --list-targets | --version | --self-check | --boot HAL_SOCKET PROFILES.json TARGET [PIC|NOPIC] [TICKS] | --sim-hal SOCKET | --check-hal SOCKET | --check-profiles PATH | --mine-simulator HAL_SOCKET POOL_ADDRESS WORKER BM1362|BM1366 [MAX_ACCEPTS]");
|
||||
eprintln!(
|
||||
"env: ALKANE_API_LISTEN=ADDR ALKANE_WEB_LISTEN=ADDR ALKANE_POOL_PASSWORD=..."
|
||||
);
|
||||
std::process::exit(2);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,23 +1,39 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Bounded, read-only cgminer-style status for a local management client.
|
||||
|
||||
use crate::detect::{EepromState, HardwarePlan};
|
||||
use serde_json::{json, Value};
|
||||
use std::io::{self, Read, Write};
|
||||
use std::net::{SocketAddr, TcpListener, TcpStream};
|
||||
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
|
||||
use std::sync::Arc;
|
||||
use std::sync::Mutex;
|
||||
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
|
||||
|
||||
const MAX_REQUEST_BYTES: usize = 2048;
|
||||
const CLIENT_TIMEOUT: Duration = Duration::from_millis(500);
|
||||
const REQUEST_DEADLINE: Duration = Duration::from_secs(2);
|
||||
|
||||
/// Everything the extended API exposes beyond share counters.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct HardwareSnapshot {
|
||||
pub plan: HardwarePlan,
|
||||
/// Chains the supervisor still allows work on.
|
||||
pub active_chains: Vec<u8>,
|
||||
/// `None` while hashing; otherwise why the machine stopped.
|
||||
pub stopped: Option<&'static str>,
|
||||
pub frequency_mhz: u16,
|
||||
/// Operator target in the form `power:3000`, `hashrate:200`, `ambient:20000`, `fan:100`.
|
||||
pub target: String,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct MiningStatus {
|
||||
started: Instant,
|
||||
running: AtomicBool,
|
||||
accepted: AtomicU64,
|
||||
rejected: AtomicU64,
|
||||
hardware: Mutex<Option<HardwareSnapshot>>,
|
||||
}
|
||||
|
||||
impl Default for MiningStatus {
|
||||
@@ -33,9 +49,31 @@ impl MiningStatus {
|
||||
running: AtomicBool::new(false),
|
||||
accepted: AtomicU64::new(0),
|
||||
rejected: AtomicU64::new(0),
|
||||
hardware: Mutex::new(None),
|
||||
}
|
||||
}
|
||||
|
||||
/// Publish the current hardware view for the API.
|
||||
pub fn set_hardware(&self, snapshot: HardwareSnapshot) {
|
||||
if let Ok(mut slot) = self.hardware.lock() {
|
||||
*slot = Some(snapshot);
|
||||
}
|
||||
}
|
||||
|
||||
/// The `hardware` document, for the on-box UI and local clients.
|
||||
pub fn hardware_document(&self) -> Value {
|
||||
hardware_json(self.hardware())
|
||||
}
|
||||
|
||||
/// The `summary` document, for the on-box UI and local clients.
|
||||
pub fn summary_document(&self) -> Value {
|
||||
self.response("summary")
|
||||
}
|
||||
|
||||
fn hardware(&self) -> Option<HardwareSnapshot> {
|
||||
self.hardware.lock().ok().and_then(|slot| slot.clone())
|
||||
}
|
||||
|
||||
pub fn set_running(&self, running: bool) {
|
||||
self.running.store(running, Ordering::Relaxed);
|
||||
}
|
||||
@@ -72,6 +110,16 @@ impl MiningStatus {
|
||||
"API": "1.0"
|
||||
}]}),
|
||||
),
|
||||
"hardware" => (
|
||||
"S",
|
||||
"Hardware",
|
||||
json!({"HARDWARE": [hardware_json(self.hardware())]}),
|
||||
),
|
||||
"stats" => (
|
||||
"S",
|
||||
"Stats",
|
||||
json!({"STATS": [stats_json(self.hardware())]}),
|
||||
),
|
||||
_ => ("E", "Unknown command", json!({})),
|
||||
};
|
||||
let mut response = json!({"STATUS": [{
|
||||
@@ -89,6 +137,69 @@ impl MiningStatus {
|
||||
}
|
||||
}
|
||||
|
||||
fn eeprom_json(state: &EepromState) -> Value {
|
||||
match state {
|
||||
EepromState::Present { model } => json!({"state": "present", "model": model}),
|
||||
EepromState::Absent => json!({"state": "absent"}),
|
||||
EepromState::Invalid => json!({"state": "invalid"}),
|
||||
}
|
||||
}
|
||||
|
||||
fn hardware_json(snapshot: Option<HardwareSnapshot>) -> Value {
|
||||
let Some(snapshot) = snapshot else {
|
||||
return json!({"available": false});
|
||||
};
|
||||
let plan = &snapshot.plan;
|
||||
json!({
|
||||
"available": true,
|
||||
"profile": plan.profile,
|
||||
"chip": plan.chip.name(),
|
||||
"psu": plan.psu,
|
||||
"envelope": {
|
||||
"v_min_mv": plan.envelope.v_min_mv,
|
||||
"v_max_mv": plan.envelope.v_max_mv,
|
||||
"f_min_mhz": plan.envelope.f_min_mhz,
|
||||
"f_max_mhz": plan.envelope.f_max_mhz,
|
||||
},
|
||||
"operating_point": {
|
||||
"voltage_mv": plan.envelope.voltage_for(snapshot.frequency_mhz),
|
||||
"frequency_mhz": snapshot.frequency_mhz,
|
||||
"confirmed": plan.operating_point.confirmed,
|
||||
},
|
||||
"chains": plan.chains.iter().map(|chain| json!({
|
||||
"index": chain.index,
|
||||
"chip": chain.chip.name(),
|
||||
"chips_found": chain.chips_found,
|
||||
"eeprom": eeprom_json(&chain.eeprom),
|
||||
"response_per_mille": chain.response_per_mille,
|
||||
})).collect::<Vec<_>>(),
|
||||
"fan_zones": plan.fan_zones.iter().map(|zone| json!({
|
||||
"fan": zone.fan,
|
||||
"zones": zone.zones,
|
||||
})).collect::<Vec<_>>(),
|
||||
"active_chains": snapshot.active_chains,
|
||||
"stopped": snapshot.stopped,
|
||||
"target": snapshot.target,
|
||||
"frequency_mhz": snapshot.frequency_mhz,
|
||||
})
|
||||
}
|
||||
|
||||
fn stats_json(snapshot: Option<HardwareSnapshot>) -> Value {
|
||||
let Some(snapshot) = snapshot else {
|
||||
return json!({"available": false});
|
||||
};
|
||||
json!({
|
||||
"Profile": snapshot.plan.profile,
|
||||
"Chip": snapshot.plan.chip.name(),
|
||||
"PSU": snapshot.plan.psu,
|
||||
"FrequencyMHz": snapshot.frequency_mhz,
|
||||
"VoltageMV": snapshot.plan.envelope.voltage_for(snapshot.frequency_mhz),
|
||||
"Target": snapshot.target,
|
||||
"ActiveChains": snapshot.active_chains.len(),
|
||||
"Stopped": snapshot.stopped,
|
||||
})
|
||||
}
|
||||
|
||||
fn request_command(bytes: &[u8]) -> Option<&str> {
|
||||
let request = std::str::from_utf8(bytes).ok()?.trim();
|
||||
if request.starts_with('{') {
|
||||
@@ -97,12 +208,16 @@ fn request_command(bytes: &[u8]) -> Option<&str> {
|
||||
match command {
|
||||
"summary" => Some("summary"),
|
||||
"version" => Some("version"),
|
||||
"hardware" => Some("hardware"),
|
||||
"stats" => Some("stats"),
|
||||
_ => Some("unknown"),
|
||||
}
|
||||
} else {
|
||||
match request {
|
||||
"summary" => Some("summary"),
|
||||
"version" => Some("version"),
|
||||
"hardware" => Some("hardware"),
|
||||
"stats" => Some("stats"),
|
||||
_ => Some("unknown"),
|
||||
}
|
||||
}
|
||||
@@ -246,4 +361,85 @@ mod tests {
|
||||
assert!(parsed.get("SUMMARY").is_some());
|
||||
worker.join().unwrap();
|
||||
}
|
||||
|
||||
fn snapshot() -> HardwareSnapshot {
|
||||
HardwareSnapshot {
|
||||
plan: HardwarePlan {
|
||||
profile: "s19jpro-bm1362-pic".into(),
|
||||
chip: crate::detect::ChipModel::Bm1362,
|
||||
chains: vec![crate::detect::ChainReport {
|
||||
index: 0,
|
||||
chip: crate::detect::ChipModel::Bm1362,
|
||||
chips_found: 126,
|
||||
eeprom: EepromState::Absent,
|
||||
response_per_mille: Some(950),
|
||||
}],
|
||||
envelope: crate::detect::Envelope {
|
||||
v_min_mv: 1100,
|
||||
v_max_mv: 1500,
|
||||
f_min_mhz: 300,
|
||||
f_max_mhz: 700,
|
||||
},
|
||||
operating_point: crate::detect::OperatingPoint {
|
||||
voltage_mv: 1200,
|
||||
frequency_mhz: 500,
|
||||
confirmed: false,
|
||||
},
|
||||
psu: "APW12".into(),
|
||||
fan_zones: vec![crate::detect::FanZone {
|
||||
fan: 0,
|
||||
zones: vec![0, 1],
|
||||
}],
|
||||
},
|
||||
active_chains: vec![0],
|
||||
stopped: None,
|
||||
frequency_mhz: 512,
|
||||
target: "power:3000".into(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hardware_is_unavailable_until_published() {
|
||||
let status = MiningStatus::new();
|
||||
let reply = status.response("hardware");
|
||||
assert_eq!(reply["HARDWARE"][0]["available"], false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hardware_command_exposes_detection_and_fault_state() {
|
||||
let status = MiningStatus::new();
|
||||
status.set_hardware(snapshot());
|
||||
let reply = status.response("hardware");
|
||||
let hardware = &reply["HARDWARE"][0];
|
||||
assert_eq!(hardware["available"], true);
|
||||
assert_eq!(hardware["profile"], "s19jpro-bm1362-pic");
|
||||
assert_eq!(hardware["chip"], "bm1362");
|
||||
assert_eq!(hardware["psu"], "APW12");
|
||||
assert_eq!(hardware["chains"][0]["chips_found"], 126);
|
||||
assert_eq!(hardware["chains"][0]["eeprom"]["state"], "absent");
|
||||
assert_eq!(hardware["operating_point"]["confirmed"], false);
|
||||
assert_eq!(hardware["active_chains"][0], 0);
|
||||
assert_eq!(hardware["target"], "power:3000");
|
||||
assert_eq!(hardware["fan_zones"][0]["zones"][1], 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stats_command_keeps_cgminer_shape() {
|
||||
let status = MiningStatus::new();
|
||||
status.set_hardware(snapshot());
|
||||
let reply = status.response("stats");
|
||||
let stats = &reply["STATS"][0];
|
||||
assert_eq!(stats["Profile"], "s19jpro-bm1362-pic");
|
||||
assert_eq!(stats["FrequencyMHz"], 512);
|
||||
assert_eq!(stats["VoltageMV"], 1312);
|
||||
assert_eq!(stats["ActiveChains"], 1);
|
||||
assert!(stats["Stopped"].is_null());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unknown_commands_still_refuse() {
|
||||
let status = MiningStatus::new();
|
||||
let reply = status.response("reboot");
|
||||
assert_eq!(reply["STATUS"][0]["STATUS"], "E");
|
||||
}
|
||||
}
|
||||
|
||||
+236
@@ -0,0 +1,236 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Board profile database.
|
||||
//!
|
||||
//! Profiles carry the safe voltage/frequency envelope a chip/board combination may run inside.
|
||||
//! Detection may only use what this database provides: if a combination is absent, the answer is
|
||||
//! "refuse", never "assume a number". Entries are data, so they can be filled from captures
|
||||
//! without touching code.
|
||||
|
||||
use crate::detect::{BoardProfile, ChipModel, Envelope, SensorTopology};
|
||||
use serde_json::Value;
|
||||
|
||||
/// Why a profile database was rejected.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub enum ProfileError {
|
||||
InvalidJson,
|
||||
UnsupportedSchema,
|
||||
MissingProfiles,
|
||||
UnknownChip(String),
|
||||
UnknownSensor(String),
|
||||
InvalidEnvelope(String),
|
||||
DuplicateName(String),
|
||||
}
|
||||
|
||||
/// A validated set of profiles.
|
||||
#[derive(Clone, Debug, Default, Eq, PartialEq)]
|
||||
pub struct ProfileDb {
|
||||
profiles: Vec<BoardProfile>,
|
||||
}
|
||||
|
||||
impl ProfileDb {
|
||||
/// Validate and keep a set of profiles.
|
||||
pub fn new(profiles: Vec<BoardProfile>) -> Result<Self, ProfileError> {
|
||||
for (index, profile) in profiles.iter().enumerate() {
|
||||
if profiles[..index]
|
||||
.iter()
|
||||
.any(|other| other.name == profile.name)
|
||||
{
|
||||
return Err(ProfileError::DuplicateName(profile.name.clone()));
|
||||
}
|
||||
if profile.chains == 0 {
|
||||
return Err(ProfileError::InvalidEnvelope(profile.name.clone()));
|
||||
}
|
||||
let envelope = profile.envelope;
|
||||
if envelope.v_min_mv == 0
|
||||
|| envelope.v_min_mv > envelope.v_max_mv
|
||||
|| envelope.f_min_mhz > envelope.f_max_mhz
|
||||
{
|
||||
return Err(ProfileError::InvalidEnvelope(profile.name.clone()));
|
||||
}
|
||||
}
|
||||
Ok(Self { profiles })
|
||||
}
|
||||
|
||||
/// Parse the schema-1 profile document.
|
||||
pub fn from_json(text: &str) -> Result<Self, ProfileError> {
|
||||
let root: Value = serde_json::from_str(text).map_err(|_| ProfileError::InvalidJson)?;
|
||||
match root.get("schema").and_then(Value::as_u64) {
|
||||
Some(1) => {}
|
||||
Some(_) => return Err(ProfileError::UnsupportedSchema),
|
||||
None => return Err(ProfileError::UnsupportedSchema),
|
||||
}
|
||||
let entries = root
|
||||
.get("profiles")
|
||||
.and_then(Value::as_array)
|
||||
.ok_or(ProfileError::MissingProfiles)?;
|
||||
let mut profiles = Vec::with_capacity(entries.len());
|
||||
for entry in entries {
|
||||
profiles.push(profile_from_value(entry)?);
|
||||
}
|
||||
if profiles.is_empty() {
|
||||
return Err(ProfileError::MissingProfiles);
|
||||
}
|
||||
Self::new(profiles)
|
||||
}
|
||||
|
||||
/// Exact lookup: a profile only applies to the chip, chain count and sensor wiring it declares.
|
||||
pub fn find(
|
||||
&self,
|
||||
chip: ChipModel,
|
||||
chains: u8,
|
||||
sensor: SensorTopology,
|
||||
) -> Option<&BoardProfile> {
|
||||
self.profiles.iter().find(|profile| {
|
||||
profile.chip == chip && profile.chains == chains && profile.sensor == sensor
|
||||
})
|
||||
}
|
||||
|
||||
pub fn len(&self) -> usize {
|
||||
self.profiles.len()
|
||||
}
|
||||
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.profiles.is_empty()
|
||||
}
|
||||
}
|
||||
|
||||
fn profile_from_value(entry: &Value) -> Result<BoardProfile, ProfileError> {
|
||||
let name = entry
|
||||
.get("name")
|
||||
.and_then(Value::as_str)
|
||||
.ok_or(ProfileError::InvalidJson)?
|
||||
.to_owned();
|
||||
let chip_text = entry
|
||||
.get("chip")
|
||||
.and_then(Value::as_str)
|
||||
.ok_or(ProfileError::UnknownChip(name.clone()))?;
|
||||
let chip = match chip_text {
|
||||
"bm1362" => ChipModel::Bm1362,
|
||||
"bm1366" => ChipModel::Bm1366,
|
||||
"bm1368" => ChipModel::Bm1368,
|
||||
"bm1370" => ChipModel::Bm1370,
|
||||
"bm1398" => ChipModel::Bm1398,
|
||||
other => return Err(ProfileError::UnknownChip(other.to_owned())),
|
||||
};
|
||||
let sensor_text = entry
|
||||
.get("sensor")
|
||||
.and_then(Value::as_str)
|
||||
.ok_or(ProfileError::UnknownSensor(name.clone()))?;
|
||||
let sensor = match sensor_text {
|
||||
"pic" => SensorTopology::Pic,
|
||||
"nopic" => SensorTopology::NoPic,
|
||||
"unknown" => SensorTopology::Unknown,
|
||||
other => return Err(ProfileError::UnknownSensor(other.to_owned())),
|
||||
};
|
||||
let chains = entry
|
||||
.get("chains")
|
||||
.and_then(Value::as_u64)
|
||||
.and_then(|value| u8::try_from(value).ok())
|
||||
.ok_or(ProfileError::InvalidEnvelope(name.clone()))?;
|
||||
let envelope = entry
|
||||
.get("envelope")
|
||||
.and_then(Value::as_object)
|
||||
.ok_or(ProfileError::InvalidEnvelope(name.clone()))?;
|
||||
let field = |key: &str| -> Result<u16, ProfileError> {
|
||||
envelope
|
||||
.get(key)
|
||||
.and_then(Value::as_u64)
|
||||
.and_then(|value| u16::try_from(value).ok())
|
||||
.ok_or(ProfileError::InvalidEnvelope(name.clone()))
|
||||
};
|
||||
let envelope = Envelope {
|
||||
v_min_mv: field("v_min_mv")?,
|
||||
v_max_mv: field("v_max_mv")?,
|
||||
f_min_mhz: field("f_min_mhz")?,
|
||||
f_max_mhz: field("f_max_mhz")?,
|
||||
};
|
||||
Ok(BoardProfile {
|
||||
name,
|
||||
chip,
|
||||
sensor,
|
||||
chains,
|
||||
envelope,
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
const VALID: &str = r#"{
|
||||
"schema": 1,
|
||||
"profiles": [
|
||||
{
|
||||
"name": "s19jpro-bm1362-pic",
|
||||
"chip": "bm1362",
|
||||
"sensor": "pic",
|
||||
"chains": 3,
|
||||
"envelope": {"v_min_mv": 1100, "v_max_mv": 1500, "f_min_mhz": 300, "f_max_mhz": 700}
|
||||
}
|
||||
]
|
||||
}"#;
|
||||
|
||||
#[test]
|
||||
fn valid_document_loads_and_resolves() {
|
||||
let db = ProfileDb::from_json(VALID).expect("db");
|
||||
assert_eq!(db.len(), 1);
|
||||
let profile = db
|
||||
.find(ChipModel::Bm1362, 3, SensorTopology::Pic)
|
||||
.expect("profile");
|
||||
assert_eq!(profile.name, "s19jpro-bm1362-pic");
|
||||
assert_eq!(profile.envelope.v_max_mv, 1500);
|
||||
assert!(db.find(ChipModel::Bm1362, 2, SensorTopology::Pic).is_none());
|
||||
assert!(db
|
||||
.find(ChipModel::Bm1362, 3, SensorTopology::NoPic)
|
||||
.is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unknown_chip_is_rejected() {
|
||||
let text = VALID.replace("bm1362", "bm9999");
|
||||
assert_eq!(
|
||||
ProfileDb::from_json(&text),
|
||||
Err(ProfileError::UnknownChip("bm9999".into()))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn inverted_envelope_is_rejected() {
|
||||
let text = VALID.replace(
|
||||
"\"v_min_mv\": 1100, \"v_max_mv\": 1500",
|
||||
"\"v_min_mv\": 1500, \"v_max_mv\": 1100",
|
||||
);
|
||||
assert!(matches!(
|
||||
ProfileDb::from_json(&text),
|
||||
Err(ProfileError::InvalidEnvelope(_))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wrong_schema_is_rejected() {
|
||||
let text = VALID.replace("\"schema\": 1", "\"schema\": 2");
|
||||
assert_eq!(
|
||||
ProfileDb::from_json(&text),
|
||||
Err(ProfileError::UnsupportedSchema)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn missing_profiles_are_rejected() {
|
||||
assert_eq!(
|
||||
ProfileDb::from_json("{\"schema\": 1}"),
|
||||
Err(ProfileError::MissingProfiles)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn duplicate_names_are_rejected() {
|
||||
let one = VALID.split("\"profiles\": [").nth(1).unwrap();
|
||||
let entry = one.trim().trim_end_matches("]\n }").trim();
|
||||
let duplicated = format!("{{\"schema\": 1, \"profiles\": [{entry}, {entry}]}}");
|
||||
assert!(matches!(
|
||||
ProfileDb::from_json(&duplicated),
|
||||
Err(ProfileError::DuplicateName(_))
|
||||
));
|
||||
}
|
||||
}
|
||||
+287
@@ -0,0 +1,287 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Mining runtime: one state machine over the detection plan, the fault ladder and the tuner.
|
||||
//!
|
||||
//! Each tick takes a measurement, lets the tuner move the operating point, and lets the fault
|
||||
//! supervisor veto the machine. The pieces are tested in isolation elsewhere; this module is the
|
||||
//! place where their order is decided, and the order matters: a stopped machine must not be tuned,
|
||||
//! and a disabled chain must not be dispatched to.
|
||||
|
||||
use crate::detect::{HardwarePlan, OperatingPoint};
|
||||
use crate::fault::{FaultAction, FaultEvent, FaultPolicy, FaultSupervisor, StopReason};
|
||||
use crate::tuning::{Command, Observation, PidConfig, TuningError, TuningLoop, TuningTarget};
|
||||
|
||||
/// One control period's measurements.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub struct Tick {
|
||||
pub power_w: Option<f32>,
|
||||
pub hashrate_ths: Option<f32>,
|
||||
pub hottest_mc: Option<i32>,
|
||||
pub ambient_mc: Option<i32>,
|
||||
pub dt_s: f32,
|
||||
}
|
||||
|
||||
/// What the runtime decided for this period.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum TickOutcome {
|
||||
/// Apply this command to the hardware.
|
||||
Run(Command),
|
||||
/// Measurement missing; hold the previous operating point.
|
||||
Hold(Command),
|
||||
/// The machine is stopped and must not hash.
|
||||
Stopped(StopReason),
|
||||
}
|
||||
|
||||
/// Runtime state for one machine.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct MinerRuntime {
|
||||
plan: HardwarePlan,
|
||||
faults: FaultSupervisor,
|
||||
tuning: TuningLoop,
|
||||
last_command: Command,
|
||||
}
|
||||
|
||||
impl MinerRuntime {
|
||||
pub fn new(
|
||||
plan: HardwarePlan,
|
||||
policy: FaultPolicy,
|
||||
target: TuningTarget,
|
||||
pid: PidConfig,
|
||||
ceiling_mc: i32,
|
||||
) -> Self {
|
||||
let chains: Vec<u8> = plan.chains.iter().map(|chain| chain.index).collect();
|
||||
let last_command = Command {
|
||||
frequency_mhz: plan.operating_point.frequency_mhz,
|
||||
fan_pwm: None,
|
||||
};
|
||||
Self {
|
||||
faults: FaultSupervisor::new(&chains, policy),
|
||||
tuning: TuningLoop::new(target, plan.envelope, pid, ceiling_mc),
|
||||
plan,
|
||||
last_command,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn plan(&self) -> &HardwarePlan {
|
||||
&self.plan
|
||||
}
|
||||
|
||||
pub fn operating_point(&self) -> OperatingPoint {
|
||||
OperatingPoint {
|
||||
voltage_mv: self
|
||||
.plan
|
||||
.envelope
|
||||
.voltage_for(self.last_command.frequency_mhz),
|
||||
frequency_mhz: self.last_command.frequency_mhz,
|
||||
confirmed: self.plan.operating_point.confirmed,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn active_chains(&self) -> Vec<u8> {
|
||||
self.faults.active_chains()
|
||||
}
|
||||
|
||||
pub fn stop_reason(&self) -> Option<StopReason> {
|
||||
self.faults.stop_reason()
|
||||
}
|
||||
|
||||
/// Feed one health observation; returns what the supervisor decided.
|
||||
pub fn on_event(&mut self, event: FaultEvent) -> FaultAction {
|
||||
self.faults.observe(event)
|
||||
}
|
||||
|
||||
/// Advance one control period.
|
||||
pub fn tick(&mut self, tick: &Tick) -> TickOutcome {
|
||||
if let Some(reason) = self.faults.stop_reason() {
|
||||
return TickOutcome::Stopped(reason);
|
||||
}
|
||||
let observation = Observation {
|
||||
power_w: tick.power_w,
|
||||
hashrate_ths: tick.hashrate_ths,
|
||||
hottest_mc: tick.hottest_mc,
|
||||
ambient_mc: tick.ambient_mc,
|
||||
};
|
||||
match self.tuning.step(observation, tick.dt_s) {
|
||||
Ok(command) => {
|
||||
self.last_command = command;
|
||||
TickOutcome::Run(command)
|
||||
}
|
||||
Err(TuningError::NoMeasurement) => TickOutcome::Hold(self.last_command),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::detect::{ChainReport, ChipModel, EepromState, Envelope, FanZone};
|
||||
|
||||
fn plan() -> HardwarePlan {
|
||||
HardwarePlan {
|
||||
profile: "s19jpro-bm1362-pic".into(),
|
||||
chip: ChipModel::Bm1362,
|
||||
chains: (0..3)
|
||||
.map(|index| ChainReport {
|
||||
index,
|
||||
chip: ChipModel::Bm1362,
|
||||
chips_found: 126,
|
||||
eeprom: EepromState::Absent,
|
||||
response_per_mille: Some(950),
|
||||
})
|
||||
.collect(),
|
||||
envelope: Envelope {
|
||||
v_min_mv: 1100,
|
||||
v_max_mv: 1500,
|
||||
f_min_mhz: 300,
|
||||
f_max_mhz: 700,
|
||||
},
|
||||
operating_point: OperatingPoint {
|
||||
voltage_mv: 1200,
|
||||
frequency_mhz: 300,
|
||||
confirmed: false,
|
||||
},
|
||||
psu: "APW12".into(),
|
||||
fan_zones: vec![FanZone {
|
||||
fan: 0,
|
||||
zones: vec![0],
|
||||
}],
|
||||
}
|
||||
}
|
||||
|
||||
fn runtime() -> MinerRuntime {
|
||||
MinerRuntime::new(
|
||||
plan(),
|
||||
FaultPolicy::default(),
|
||||
TuningTarget::PowerW(2_400.0),
|
||||
PidConfig {
|
||||
kp: 0.2,
|
||||
ki: 0.05,
|
||||
kd: 0.0,
|
||||
out_min: 0.0,
|
||||
out_max: 0.0,
|
||||
max_step_per_s: 50.0,
|
||||
deadband: 0.0,
|
||||
},
|
||||
95_000,
|
||||
)
|
||||
}
|
||||
|
||||
fn tick(power: f32) -> Tick {
|
||||
Tick {
|
||||
power_w: Some(power),
|
||||
hashrate_ths: None,
|
||||
hottest_mc: Some(70_000),
|
||||
ambient_mc: None,
|
||||
dt_s: 1.0,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_fresh_runtime_exposes_every_chain() {
|
||||
assert_eq!(runtime().active_chains(), vec![0, 1, 2]);
|
||||
assert_eq!(runtime().stop_reason(), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ticks_move_frequency_inside_the_envelope() {
|
||||
let mut runtime = runtime();
|
||||
let mut frequency = 300;
|
||||
for _ in 0..60 {
|
||||
let power = 4.0 * f32::from(frequency);
|
||||
if let TickOutcome::Run(command) = runtime.tick(&tick(power)) {
|
||||
frequency = command.frequency_mhz;
|
||||
assert!((300..=700).contains(&frequency));
|
||||
}
|
||||
}
|
||||
assert!(frequency > 300, "frequency never moved: {frequency}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_missing_measurement_holds_the_last_command() {
|
||||
let mut runtime = runtime();
|
||||
let empty = Tick {
|
||||
power_w: None,
|
||||
hashrate_ths: None,
|
||||
hottest_mc: None,
|
||||
ambient_mc: None,
|
||||
dt_s: 1.0,
|
||||
};
|
||||
match runtime.tick(&empty) {
|
||||
TickOutcome::Hold(command) => assert_eq!(command.frequency_mhz, 300),
|
||||
other => panic!("unexpected outcome: {other:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_dead_chain_is_removed_from_dispatch_without_stopping_the_machine() {
|
||||
let mut runtime = runtime();
|
||||
assert_eq!(
|
||||
runtime.on_event(FaultEvent::ChainError { chain: 1 }),
|
||||
FaultAction::Retry { chain: 1 }
|
||||
);
|
||||
assert_eq!(
|
||||
runtime.on_event(FaultEvent::ChainError { chain: 1 }),
|
||||
FaultAction::Retry { chain: 1 }
|
||||
);
|
||||
assert_eq!(
|
||||
runtime.on_event(FaultEvent::ChainError { chain: 1 }),
|
||||
FaultAction::DisableChain { chain: 1 }
|
||||
);
|
||||
assert_eq!(runtime.active_chains(), vec![0, 2]);
|
||||
assert!(matches!(runtime.tick(&tick(2_000.0)), TickOutcome::Run(_)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_temperature_fault_stops_the_machine_for_good() {
|
||||
let mut runtime = runtime();
|
||||
assert_eq!(
|
||||
runtime.on_event(FaultEvent::TemperatureFault { zone: 1 }),
|
||||
FaultAction::Stop {
|
||||
reason: StopReason::Temperature
|
||||
}
|
||||
);
|
||||
assert_eq!(
|
||||
runtime.tick(&tick(2_400.0)),
|
||||
TickOutcome::Stopped(StopReason::Temperature)
|
||||
);
|
||||
assert_eq!(
|
||||
runtime.tick(&tick(2_400.0)),
|
||||
TickOutcome::Stopped(StopReason::Temperature)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn losing_every_chain_stops_the_machine() {
|
||||
let mut runtime = MinerRuntime::new(
|
||||
plan(),
|
||||
FaultPolicy {
|
||||
retries: 0,
|
||||
..FaultPolicy::default()
|
||||
},
|
||||
TuningTarget::PowerW(2_400.0),
|
||||
PidConfig::default(),
|
||||
95_000,
|
||||
);
|
||||
for chain in 0..3 {
|
||||
runtime.on_event(FaultEvent::ChainError { chain });
|
||||
}
|
||||
assert_eq!(runtime.stop_reason(), Some(StopReason::NoChainsLeft));
|
||||
assert!(runtime.active_chains().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_operating_point_reflects_the_last_command() {
|
||||
let mut runtime = runtime();
|
||||
for _ in 0..10 {
|
||||
runtime.tick(&tick(1_500.0));
|
||||
}
|
||||
let point = runtime.operating_point();
|
||||
assert!(point.frequency_mhz > 300);
|
||||
assert!(!point.confirmed);
|
||||
// Voltage follows the frequency across the envelope instead of staying at the boot value.
|
||||
assert_eq!(
|
||||
point.voltage_mv,
|
||||
runtime.plan().envelope.voltage_for(point.frequency_mhz)
|
||||
);
|
||||
assert!(point.voltage_mv > 1100);
|
||||
}
|
||||
}
|
||||
+172
@@ -0,0 +1,172 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Hashrate splitting across pools.
|
||||
//!
|
||||
//! Splitting is per work slot: each dispatched job comes from exactly one pool, and the router
|
||||
//! hands out slots in proportion to the configured weights. Smooth weighted round-robin is used
|
||||
//! because it keeps the mix correct at every prefix, not just over a long run, which matters when
|
||||
//! a miner only has a handful of chains.
|
||||
|
||||
/// Why a split configuration was rejected.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum SplitError {
|
||||
Empty,
|
||||
NoWeight,
|
||||
InvalidNumber,
|
||||
TooManyPools,
|
||||
}
|
||||
|
||||
/// Per-pool weights, `50,50` style.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct SplitWeights {
|
||||
weights: Vec<u32>,
|
||||
}
|
||||
|
||||
impl SplitWeights {
|
||||
/// Parse a comma-separated weight list such as `"60,40"`.
|
||||
pub fn parse(text: &str) -> Result<Self, SplitError> {
|
||||
let mut weights = Vec::new();
|
||||
for part in text.split(',') {
|
||||
let trimmed = part.trim();
|
||||
if trimmed.is_empty() {
|
||||
return Err(SplitError::InvalidNumber);
|
||||
}
|
||||
let weight: u32 = trimmed.parse().map_err(|_| SplitError::InvalidNumber)?;
|
||||
weights.push(weight);
|
||||
}
|
||||
Self::new(weights)
|
||||
}
|
||||
|
||||
pub fn new(weights: Vec<u32>) -> Result<Self, SplitError> {
|
||||
if weights.is_empty() {
|
||||
return Err(SplitError::Empty);
|
||||
}
|
||||
if weights.len() > 16 {
|
||||
return Err(SplitError::TooManyPools);
|
||||
}
|
||||
if weights.iter().all(|weight| *weight == 0) {
|
||||
return Err(SplitError::NoWeight);
|
||||
}
|
||||
Ok(Self { weights })
|
||||
}
|
||||
|
||||
pub fn pools(&self) -> usize {
|
||||
self.weights.len()
|
||||
}
|
||||
|
||||
pub fn weight(&self, pool: usize) -> u32 {
|
||||
self.weights.get(pool).copied().unwrap_or(0)
|
||||
}
|
||||
|
||||
/// Split `slots` work slots across the pools and return how many each receives.
|
||||
pub fn allocate(&self, slots: usize) -> Vec<usize> {
|
||||
let mut router = WorkRouter::new(self.clone());
|
||||
let mut counts = vec![0_usize; self.pools()];
|
||||
for _ in 0..slots {
|
||||
counts[router.next_pool()] += 1;
|
||||
}
|
||||
counts
|
||||
}
|
||||
}
|
||||
|
||||
/// Smooth weighted round-robin state.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct WorkRouter {
|
||||
weights: SplitWeights,
|
||||
current: Vec<i64>,
|
||||
total: i64,
|
||||
}
|
||||
|
||||
impl WorkRouter {
|
||||
pub fn new(weights: SplitWeights) -> Self {
|
||||
let current = vec![0_i64; weights.pools()];
|
||||
let total: i64 = weights
|
||||
.weights
|
||||
.iter()
|
||||
.map(|weight| i64::from(*weight))
|
||||
.sum();
|
||||
Self {
|
||||
weights,
|
||||
current,
|
||||
total,
|
||||
}
|
||||
}
|
||||
|
||||
/// Which pool supplies the next work slot.
|
||||
///
|
||||
/// A pool with weight 0 never receives a slot. The winner's running score is reduced by the
|
||||
/// total weight, which is what keeps the distribution proportional at every prefix.
|
||||
pub fn next_pool(&mut self) -> usize {
|
||||
let mut winner = 0;
|
||||
for pool in 0..self.weights.pools() {
|
||||
self.current[pool] += i64::from(self.weights.weight(pool));
|
||||
if self.current[pool] > self.current[winner] {
|
||||
winner = pool;
|
||||
}
|
||||
}
|
||||
self.current[winner] -= self.total;
|
||||
winner
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn equal_weights_split_evenly() {
|
||||
let weights = SplitWeights::parse("50,50").expect("weights");
|
||||
assert_eq!(weights.allocate(10), vec![5, 5]);
|
||||
assert_eq!(weights.allocate(4), vec![2, 2]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unequal_weights_split_proportionally() {
|
||||
let weights = SplitWeights::parse("1,2").expect("weights");
|
||||
assert_eq!(weights.allocate(9), vec![3, 6]);
|
||||
assert_eq!(weights.allocate(3), vec![1, 2]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rounding_is_exact_at_every_prefix() {
|
||||
let weights = SplitWeights::parse("1,1,1").expect("weights");
|
||||
assert_eq!(weights.allocate(10), vec![4, 3, 3]);
|
||||
assert_eq!(weights.allocate(3), vec![1, 1, 1]);
|
||||
assert_eq!(weights.allocate(1), vec![1, 0, 0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zero_weight_pools_never_receive_work() {
|
||||
let weights = SplitWeights::parse("100,0,100").expect("weights");
|
||||
assert_eq!(weights.allocate(6), vec![3, 0, 3]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_single_pool_takes_everything() {
|
||||
let weights = SplitWeights::parse("100").expect("weights");
|
||||
assert_eq!(weights.allocate(5), vec![5]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn malformed_configurations_are_rejected() {
|
||||
assert_eq!(SplitWeights::parse(""), Err(SplitError::InvalidNumber));
|
||||
assert_eq!(
|
||||
SplitWeights::parse("50,abc"),
|
||||
Err(SplitError::InvalidNumber)
|
||||
);
|
||||
assert_eq!(SplitWeights::parse("0,0"), Err(SplitError::NoWeight));
|
||||
assert_eq!(SplitWeights::new(Vec::new()), Err(SplitError::Empty));
|
||||
let many = vec![1_u32; 17];
|
||||
assert_eq!(SplitWeights::new(many), Err(SplitError::TooManyPools));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_router_is_deterministic_for_the_same_input() {
|
||||
let weights = SplitWeights::parse("60,40").expect("weights");
|
||||
let first = weights.allocate(50);
|
||||
let second = weights.allocate(50);
|
||||
assert_eq!(first, second);
|
||||
assert_eq!(first.iter().sum::<usize>(), 50);
|
||||
assert_eq!(first[0], 30);
|
||||
assert_eq!(first[1], 20);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,385 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Stratum V2 transport and version selection.
|
||||
//!
|
||||
//! `TcpLink` turns a TCP stream into the framed messages the session expects: it buffers partial
|
||||
//! reads and hands out one frame at a time, so a frame split across packets is not a protocol
|
||||
//! error. The selection policy decides when a miner may fall back to Stratum V1.
|
||||
|
||||
use crate::stratum_v2::{Frame, V2Error};
|
||||
use crate::stratum_v2_session::V2Link;
|
||||
use std::io::{self, Read, Write};
|
||||
use std::net::{SocketAddr, TcpStream};
|
||||
use std::time::Duration;
|
||||
|
||||
const READ_CHUNK: usize = 4096;
|
||||
|
||||
/// A framed connection over TCP.
|
||||
pub struct TcpLink {
|
||||
stream: TcpStream,
|
||||
buffer: Vec<u8>,
|
||||
}
|
||||
|
||||
impl TcpLink {
|
||||
pub fn connect(address: SocketAddr, timeout: Duration) -> io::Result<Self> {
|
||||
let stream = TcpStream::connect_timeout(&address, timeout)?;
|
||||
stream.set_read_timeout(Some(timeout))?;
|
||||
stream.set_write_timeout(Some(timeout))?;
|
||||
stream.set_nodelay(true)?;
|
||||
Ok(Self {
|
||||
stream,
|
||||
buffer: Vec::new(),
|
||||
})
|
||||
}
|
||||
|
||||
pub fn from_stream(stream: TcpStream) -> io::Result<Self> {
|
||||
stream.set_nodelay(true)?;
|
||||
Ok(Self {
|
||||
stream,
|
||||
buffer: Vec::new(),
|
||||
})
|
||||
}
|
||||
|
||||
/// Bytes received but not yet consumed, for diagnostics.
|
||||
pub fn buffered(&self) -> usize {
|
||||
self.buffer.len()
|
||||
}
|
||||
}
|
||||
|
||||
impl V2Link for TcpLink {
|
||||
type Error = io::Error;
|
||||
|
||||
fn send(&mut self, frame: &Frame) -> io::Result<()> {
|
||||
let mut wire = Vec::with_capacity(frame.payload.len() + 6);
|
||||
frame.encode(&mut wire);
|
||||
self.stream.write_all(&wire)?;
|
||||
self.stream.flush()
|
||||
}
|
||||
|
||||
fn recv(&mut self) -> io::Result<Frame> {
|
||||
loop {
|
||||
if !self.buffer.is_empty() {
|
||||
match Frame::decode(&self.buffer) {
|
||||
Ok((frame, consumed)) => {
|
||||
self.buffer.drain(..consumed);
|
||||
return Ok(frame);
|
||||
}
|
||||
Err(V2Error::Truncated) => {}
|
||||
Err(error) => {
|
||||
self.buffer.clear();
|
||||
return Err(io::Error::new(io::ErrorKind::InvalidData, error));
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut chunk = [0_u8; READ_CHUNK];
|
||||
let count = self.stream.read(&mut chunk)?;
|
||||
if count == 0 {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::UnexpectedEof,
|
||||
"stratum v2 stream closed",
|
||||
));
|
||||
}
|
||||
self.buffer.extend_from_slice(&chunk[..count]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Which protocol the miner speaks.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum StratumVersion {
|
||||
V1,
|
||||
V2,
|
||||
}
|
||||
|
||||
/// Why an attempt failed.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum FailureKind {
|
||||
/// The server refused the connection or the setup message.
|
||||
Refused,
|
||||
/// No mutually supported version.
|
||||
Unsupported,
|
||||
/// The connection could not be established or dropped.
|
||||
Transport,
|
||||
/// The server did not answer in time.
|
||||
Timeout,
|
||||
}
|
||||
|
||||
/// Operator preference.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct Preference {
|
||||
pub primary: StratumVersion,
|
||||
pub allow_v1_fallback: bool,
|
||||
}
|
||||
|
||||
impl Default for Preference {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
primary: StratumVersion::V2,
|
||||
allow_v1_fallback: true,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The protocol to try next, or `None` when there is nothing left.
|
||||
///
|
||||
/// V1 is attempted only when the operator allowed it and the failure is not a transport-level
|
||||
/// problem: a dead route or a dropped stream will fail identically on V1, so falling back would
|
||||
/// only delay the operator-visible error.
|
||||
pub fn fallback(
|
||||
preference: Preference,
|
||||
failed: StratumVersion,
|
||||
kind: FailureKind,
|
||||
) -> Option<StratumVersion> {
|
||||
match (preference.primary, failed) {
|
||||
(StratumVersion::V2, StratumVersion::V2)
|
||||
if preference.allow_v1_fallback && kind != FailureKind::Transport =>
|
||||
{
|
||||
Some(StratumVersion::V1)
|
||||
}
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::net::TcpListener;
|
||||
|
||||
#[test]
|
||||
fn a_frame_arrives_intact_over_tcp() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").expect("bind");
|
||||
let address = listener.local_addr().expect("addr");
|
||||
let server = std::thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().expect("accept");
|
||||
let mut wire = Vec::new();
|
||||
Frame::new(0x00, vec![1, 2, 3, 4]).encode(&mut wire);
|
||||
stream.write_all(&wire).expect("write");
|
||||
});
|
||||
let mut link = TcpLink::connect(address, Duration::from_secs(2)).expect("connect");
|
||||
let frame = link.recv().expect("recv");
|
||||
assert_eq!(frame.msg_type, 0x00);
|
||||
assert_eq!(frame.payload, vec![1, 2, 3, 4]);
|
||||
server.join().expect("join");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_frame_split_across_reads_is_reassembled() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").expect("bind");
|
||||
let address = listener.local_addr().expect("addr");
|
||||
let server = std::thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().expect("accept");
|
||||
let mut wire = Vec::new();
|
||||
Frame::new(0x10, vec![9; 40]).encode(&mut wire);
|
||||
stream.write_all(&wire[..5]).expect("first");
|
||||
std::thread::sleep(Duration::from_millis(20));
|
||||
stream.write_all(&wire[5..]).expect("rest");
|
||||
});
|
||||
let mut link = TcpLink::connect(address, Duration::from_secs(2)).expect("connect");
|
||||
let frame = link.recv().expect("recv");
|
||||
assert_eq!(frame.msg_type, 0x10);
|
||||
assert_eq!(frame.payload.len(), 40);
|
||||
server.join().expect("join");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn two_frames_in_one_read_are_returned_one_at_a_time() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").expect("bind");
|
||||
let address = listener.local_addr().expect("addr");
|
||||
let server = std::thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().expect("accept");
|
||||
let mut wire = Vec::new();
|
||||
Frame::new(0x01, vec![1]).encode(&mut wire);
|
||||
Frame::new(0x02, vec![2]).encode(&mut wire);
|
||||
stream.write_all(&wire).expect("write");
|
||||
});
|
||||
let mut link = TcpLink::connect(address, Duration::from_secs(2)).expect("connect");
|
||||
assert_eq!(link.recv().expect("first").msg_type, 0x01);
|
||||
assert_eq!(link.recv().expect("second").msg_type, 0x02);
|
||||
server.join().expect("join");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_closed_stream_is_an_error_not_an_empty_frame() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").expect("bind");
|
||||
let address = listener.local_addr().expect("addr");
|
||||
let server = std::thread::spawn(move || {
|
||||
let (_stream, _) = listener.accept().expect("accept");
|
||||
});
|
||||
let mut link = TcpLink::connect(address, Duration::from_secs(2)).expect("connect");
|
||||
let error = link.recv().expect_err("closed stream");
|
||||
assert_eq!(error.kind(), io::ErrorKind::UnexpectedEof);
|
||||
server.join().expect("join");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn v1_fallback_requires_permission_and_a_non_transport_failure() {
|
||||
let allowed = Preference {
|
||||
primary: StratumVersion::V2,
|
||||
allow_v1_fallback: true,
|
||||
};
|
||||
assert_eq!(
|
||||
fallback(allowed, StratumVersion::V2, FailureKind::Refused),
|
||||
Some(StratumVersion::V1)
|
||||
);
|
||||
assert_eq!(
|
||||
fallback(allowed, StratumVersion::V2, FailureKind::Unsupported),
|
||||
Some(StratumVersion::V1)
|
||||
);
|
||||
assert_eq!(
|
||||
fallback(allowed, StratumVersion::V2, FailureKind::Timeout),
|
||||
Some(StratumVersion::V1)
|
||||
);
|
||||
assert_eq!(
|
||||
fallback(allowed, StratumVersion::V2, FailureKind::Transport),
|
||||
None
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn v1_fallback_can_be_disabled_and_v1_failures_do_not_loop() {
|
||||
let denied = Preference {
|
||||
primary: StratumVersion::V2,
|
||||
allow_v1_fallback: false,
|
||||
};
|
||||
assert_eq!(
|
||||
fallback(denied, StratumVersion::V2, FailureKind::Refused),
|
||||
None
|
||||
);
|
||||
let allowed = Preference::default();
|
||||
assert_eq!(
|
||||
fallback(allowed, StratumVersion::V1, FailureKind::Refused),
|
||||
None
|
||||
);
|
||||
}
|
||||
|
||||
fn mock_pool() -> std::net::SocketAddr {
|
||||
use crate::stratum_v2::{
|
||||
NewMiningJob, OpenStandardMiningChannelSuccess, SetNewPrevHash, SetupConnectionSuccess,
|
||||
OPEN_STANDARD_MINING_CHANNEL, OPEN_STANDARD_MINING_CHANNEL_SUCCESS, SETUP_CONNECTION,
|
||||
SETUP_CONNECTION_SUCCESS, SET_NEW_PREV_HASH, SUBMIT_SHARES_SUCCESS,
|
||||
};
|
||||
let listener = TcpListener::bind("127.0.0.1:0").expect("bind");
|
||||
let address = listener.local_addr().expect("addr");
|
||||
// Publish the address through a channel so the test can connect after binding.
|
||||
let (tx, rx) = std::sync::mpsc::channel();
|
||||
tx.send(address).expect("send address");
|
||||
std::thread::spawn(move || {
|
||||
let (stream, _) = listener.accept().expect("accept");
|
||||
let mut link = TcpLink::from_stream(stream).expect("link");
|
||||
let setup = link.recv().expect("setup");
|
||||
assert_eq!(setup.msg_type, SETUP_CONNECTION);
|
||||
link.send(&Frame::new(
|
||||
SETUP_CONNECTION_SUCCESS,
|
||||
SetupConnectionSuccess {
|
||||
used_version: 2,
|
||||
flags: 0,
|
||||
}
|
||||
.encode(),
|
||||
))
|
||||
.expect("setup success");
|
||||
let open = link.recv().expect("open");
|
||||
assert_eq!(open.msg_type, OPEN_STANDARD_MINING_CHANNEL);
|
||||
link.send(&Frame::new(
|
||||
OPEN_STANDARD_MINING_CHANNEL_SUCCESS,
|
||||
OpenStandardMiningChannelSuccess {
|
||||
request_id: 1,
|
||||
channel_id: 7,
|
||||
target: [0x7f; 32],
|
||||
extranonce_prefix: vec![9, 9],
|
||||
group_channel_id: 0,
|
||||
}
|
||||
.encode(),
|
||||
))
|
||||
.expect("channel success");
|
||||
link.send(&Frame::new(
|
||||
SET_NEW_PREV_HASH,
|
||||
SetNewPrevHash {
|
||||
channel_id: 7,
|
||||
job_id: 41,
|
||||
prev_hash: [0x11; 32],
|
||||
ntime_start: 1_700_000_000,
|
||||
nbits: 0x1707_0000,
|
||||
}
|
||||
.encode(),
|
||||
))
|
||||
.expect("prev hash");
|
||||
link.send(&Frame::new(
|
||||
NEW_MINING_JOB_TYPE,
|
||||
NewMiningJob {
|
||||
channel_id: 7,
|
||||
job_id: 42,
|
||||
ntime_start: Some(1_700_000_100),
|
||||
version: 0x2000_0000,
|
||||
merkle_root: [0x22; 32],
|
||||
}
|
||||
.encode(),
|
||||
))
|
||||
.expect("job");
|
||||
let share = link.recv().expect("share");
|
||||
assert_eq!(share.msg_type, SUBMIT_SHARES_STANDARD_TYPE);
|
||||
let mut body = Vec::new();
|
||||
body.extend_from_slice(&7_u32.to_le_bytes());
|
||||
body.extend_from_slice(&1_u32.to_le_bytes());
|
||||
body.extend_from_slice(&1_u32.to_le_bytes());
|
||||
body.extend_from_slice(&0_u64.to_le_bytes());
|
||||
link.send(&Frame::new(SUBMIT_SHARES_SUCCESS, body))
|
||||
.expect("share success");
|
||||
});
|
||||
rx.recv().expect("address")
|
||||
}
|
||||
|
||||
const NEW_MINING_JOB_TYPE: u8 = 0x15;
|
||||
const SUBMIT_SHARES_STANDARD_TYPE: u8 = 0x1a;
|
||||
|
||||
#[test]
|
||||
fn a_session_runs_against_a_socket_pool() {
|
||||
use crate::stratum_v2_session::{handshake, V2Config, V2Event, V2Session};
|
||||
let address = mock_pool();
|
||||
let mut link = TcpLink::connect(address, Duration::from_secs(3)).expect("connect");
|
||||
let config = V2Config {
|
||||
host: "pool.test".into(),
|
||||
port: 3333,
|
||||
flags: 0,
|
||||
user_identity: "worker".into(),
|
||||
nominal_hash_rate: 1.0e14,
|
||||
max_target: [0xff; 32],
|
||||
vendor: "alkane".into(),
|
||||
hardware: "bench".into(),
|
||||
firmware: "alkane-os".into(),
|
||||
device_id: "b1".into(),
|
||||
};
|
||||
let channel = handshake(&mut link, &config).expect("handshake");
|
||||
assert_eq!(channel.channel_id, 7);
|
||||
assert_eq!(channel.extranonce_prefix, vec![9, 9]);
|
||||
|
||||
let mut session = V2Session::new(channel);
|
||||
let prev = session
|
||||
.on_frame(&link.recv().expect("prev"))
|
||||
.expect("prev event");
|
||||
assert!(matches!(prev, V2Event::PrevHash { job_id: 41, .. }));
|
||||
let job = session
|
||||
.on_frame(&link.recv().expect("job"))
|
||||
.expect("job event");
|
||||
match job {
|
||||
V2Event::Job(parsed) => {
|
||||
assert_eq!(parsed.job_id, 42);
|
||||
assert_eq!(parsed.prev_hash, Some([0x11; 32]));
|
||||
assert_eq!(parsed.ntime_start, Some(1_700_000_100));
|
||||
}
|
||||
other => panic!("unexpected event: {other:?}"),
|
||||
}
|
||||
let sequence = session
|
||||
.submit(&mut link, 42, 0xdead_beef, 1_700_000_100, 0x2000_0000)
|
||||
.expect("submit");
|
||||
assert_eq!(sequence, 1);
|
||||
let ack = session
|
||||
.on_frame(&link.recv().expect("ack"))
|
||||
.expect("ack event");
|
||||
assert_eq!(
|
||||
ack,
|
||||
V2Event::ShareAccepted {
|
||||
last_sequence: 1,
|
||||
accepted: 1
|
||||
}
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,631 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Stratum V2 mining-protocol codec.
|
||||
//!
|
||||
//! Covers the client half of the mining sub-protocol: connection setup, opening a standard
|
||||
//! channel, and the job/share messages that follow. Layouts follow the published specification
|
||||
//! (framing in 03-Protocol-Overview 3.2, message types in 08-Message-Types, payloads in
|
||||
//! 05-Mining-Protocol 5.3).
|
||||
//!
|
||||
//! Everything is little-endian. `U256` is carried as the raw 32 bytes of the little-endian
|
||||
//! integer, which for a SHA-256 digest is the digest's own byte order.
|
||||
|
||||
use std::fmt;
|
||||
|
||||
pub const EXTENSION_TYPE_CORE: u16 = 0;
|
||||
|
||||
pub const SETUP_CONNECTION: u8 = 0x00;
|
||||
pub const SETUP_CONNECTION_SUCCESS: u8 = 0x01;
|
||||
pub const SETUP_CONNECTION_ERROR: u8 = 0x02;
|
||||
pub const OPEN_STANDARD_MINING_CHANNEL: u8 = 0x10;
|
||||
pub const OPEN_STANDARD_MINING_CHANNEL_SUCCESS: u8 = 0x11;
|
||||
pub const OPEN_MINING_CHANNEL_ERROR: u8 = 0x12;
|
||||
pub const NEW_MINING_JOB: u8 = 0x15;
|
||||
pub const SUBMIT_SHARES_STANDARD: u8 = 0x1a;
|
||||
pub const SUBMIT_SHARES_SUCCESS: u8 = 0x1c;
|
||||
pub const SUBMIT_SHARES_ERROR: u8 = 0x1d;
|
||||
pub const SET_NEW_PREV_HASH: u8 = 0x20;
|
||||
pub const SET_TARGET: u8 = 0x21;
|
||||
|
||||
const HEADER_LEN: usize = 6;
|
||||
const MAX_FRAME: usize = 1 << 20;
|
||||
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub enum V2Error {
|
||||
Truncated,
|
||||
Length,
|
||||
String,
|
||||
NonFiniteRate,
|
||||
UnknownMessage(u8),
|
||||
}
|
||||
|
||||
impl fmt::Display for V2Error {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
Self::Truncated => f.write_str("stratum v2 message is truncated"),
|
||||
Self::Length => f.write_str("stratum v2 length field is invalid"),
|
||||
Self::String => f.write_str("stratum v2 string field is invalid"),
|
||||
Self::NonFiniteRate => {
|
||||
f.write_str("stratum v2 hashrate is not a finite positive number")
|
||||
}
|
||||
Self::UnknownMessage(kind) => {
|
||||
write!(f, "unsupported stratum v2 message type {kind:#x}")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::error::Error for V2Error {}
|
||||
|
||||
/// One framed message: 6-byte header plus payload.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct Frame {
|
||||
pub extension_type: u16,
|
||||
pub msg_type: u8,
|
||||
pub payload: Vec<u8>,
|
||||
}
|
||||
|
||||
impl Frame {
|
||||
pub fn new(msg_type: u8, payload: Vec<u8>) -> Self {
|
||||
Self {
|
||||
extension_type: EXTENSION_TYPE_CORE,
|
||||
msg_type,
|
||||
payload,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn encode(&self, out: &mut Vec<u8>) {
|
||||
out.extend_from_slice(&self.extension_type.to_le_bytes());
|
||||
out.push(self.msg_type);
|
||||
let length = self.payload.len() as u32;
|
||||
out.extend_from_slice(&length.to_le_bytes()[..3]);
|
||||
out.extend_from_slice(&self.payload);
|
||||
}
|
||||
|
||||
/// Decode one frame from `buf`, returning it and how many bytes it consumed.
|
||||
pub fn decode(buf: &[u8]) -> Result<(Self, usize), V2Error> {
|
||||
if buf.len() < HEADER_LEN {
|
||||
return Err(V2Error::Truncated);
|
||||
}
|
||||
let extension_type = u16::from_le_bytes([buf[0], buf[1]]);
|
||||
let msg_type = buf[2];
|
||||
let length = u32::from_le_bytes([buf[3], buf[4], buf[5], 0]) as usize;
|
||||
if length > MAX_FRAME {
|
||||
return Err(V2Error::Length);
|
||||
}
|
||||
let end = HEADER_LEN + length;
|
||||
if buf.len() < end {
|
||||
return Err(V2Error::Truncated);
|
||||
}
|
||||
Ok((
|
||||
Self {
|
||||
extension_type,
|
||||
msg_type,
|
||||
payload: buf[HEADER_LEN..end].to_vec(),
|
||||
},
|
||||
end,
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
/// `SetupConnection` for the mining sub-protocol.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct SetupConnection {
|
||||
pub protocol: u8,
|
||||
pub min_version: u16,
|
||||
pub max_version: u16,
|
||||
pub flags: u32,
|
||||
pub endpoint_host: String,
|
||||
pub endpoint_port: u16,
|
||||
pub vendor: String,
|
||||
pub hardware_version: String,
|
||||
pub firmware: String,
|
||||
pub device_id: String,
|
||||
}
|
||||
|
||||
impl SetupConnection {
|
||||
pub fn encode(&self) -> Vec<u8> {
|
||||
let mut out = Vec::new();
|
||||
out.push(self.protocol);
|
||||
put_u16(&mut out, self.min_version);
|
||||
put_u16(&mut out, self.max_version);
|
||||
put_u32(&mut out, self.flags);
|
||||
put_str(&mut out, &self.endpoint_host);
|
||||
put_u16(&mut out, self.endpoint_port);
|
||||
put_str(&mut out, &self.vendor);
|
||||
put_str(&mut out, &self.hardware_version);
|
||||
put_str(&mut out, &self.firmware);
|
||||
put_str(&mut out, &self.device_id);
|
||||
out
|
||||
}
|
||||
|
||||
pub fn decode(payload: &[u8]) -> Result<Self, V2Error> {
|
||||
let mut reader = Reader::new(payload);
|
||||
Ok(Self {
|
||||
protocol: reader.u8()?,
|
||||
min_version: reader.u16()?,
|
||||
max_version: reader.u16()?,
|
||||
flags: reader.u32()?,
|
||||
endpoint_host: reader.string()?,
|
||||
endpoint_port: reader.u16()?,
|
||||
vendor: reader.string()?,
|
||||
hardware_version: reader.string()?,
|
||||
firmware: reader.string()?,
|
||||
device_id: reader.string()?,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// `SetupConnection.Success`.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct SetupConnectionSuccess {
|
||||
pub used_version: u16,
|
||||
pub flags: u32,
|
||||
}
|
||||
|
||||
impl SetupConnectionSuccess {
|
||||
pub fn encode(&self) -> Vec<u8> {
|
||||
let mut out = Vec::new();
|
||||
put_u16(&mut out, self.used_version);
|
||||
put_u32(&mut out, self.flags);
|
||||
out
|
||||
}
|
||||
|
||||
pub fn decode(payload: &[u8]) -> Result<Self, V2Error> {
|
||||
let mut reader = Reader::new(payload);
|
||||
Ok(Self {
|
||||
used_version: reader.u16()?,
|
||||
flags: reader.u32()?,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// `OpenStandardMiningChannel`.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct OpenStandardMiningChannel {
|
||||
pub request_id: u32,
|
||||
pub user_identity: String,
|
||||
pub nominal_hash_rate: f32,
|
||||
pub max_target: [u8; 32],
|
||||
}
|
||||
|
||||
impl OpenStandardMiningChannel {
|
||||
pub fn encode(&self) -> Vec<u8> {
|
||||
let mut out = Vec::new();
|
||||
put_u32(&mut out, self.request_id);
|
||||
put_str(&mut out, &self.user_identity);
|
||||
out.extend_from_slice(&self.nominal_hash_rate.to_le_bytes());
|
||||
out.extend_from_slice(&self.max_target);
|
||||
out
|
||||
}
|
||||
|
||||
pub fn decode(payload: &[u8]) -> Result<Self, V2Error> {
|
||||
let mut reader = Reader::new(payload);
|
||||
let request_id = reader.u32()?;
|
||||
let user_identity = reader.string()?;
|
||||
let nominal_hash_rate = reader.f32()?;
|
||||
if !nominal_hash_rate.is_finite() || nominal_hash_rate < 0.0 {
|
||||
return Err(V2Error::NonFiniteRate);
|
||||
}
|
||||
Ok(Self {
|
||||
request_id,
|
||||
user_identity,
|
||||
nominal_hash_rate,
|
||||
max_target: reader.u256()?,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// `OpenStandardMiningChannel.Success`.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct OpenStandardMiningChannelSuccess {
|
||||
pub request_id: u32,
|
||||
pub channel_id: u32,
|
||||
pub target: [u8; 32],
|
||||
pub extranonce_prefix: Vec<u8>,
|
||||
pub group_channel_id: u32,
|
||||
}
|
||||
|
||||
impl OpenStandardMiningChannelSuccess {
|
||||
pub fn encode(&self) -> Vec<u8> {
|
||||
let mut out = Vec::new();
|
||||
put_u32(&mut out, self.request_id);
|
||||
put_u32(&mut out, self.channel_id);
|
||||
out.extend_from_slice(&self.target);
|
||||
put_bytes(&mut out, &self.extranonce_prefix);
|
||||
put_u32(&mut out, self.group_channel_id);
|
||||
out
|
||||
}
|
||||
|
||||
pub fn decode(payload: &[u8]) -> Result<Self, V2Error> {
|
||||
let mut reader = Reader::new(payload);
|
||||
Ok(Self {
|
||||
request_id: reader.u32()?,
|
||||
channel_id: reader.u32()?,
|
||||
target: reader.u256()?,
|
||||
extranonce_prefix: reader.bytes(32)?,
|
||||
group_channel_id: reader.u32()?,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// `NewMiningJob` on a standard channel.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct NewMiningJob {
|
||||
pub channel_id: u32,
|
||||
pub job_id: u32,
|
||||
/// `None` means a future job, activated by the matching `SetNewPrevHash`.
|
||||
pub ntime_start: Option<u32>,
|
||||
pub version: u32,
|
||||
pub merkle_root: [u8; 32],
|
||||
}
|
||||
|
||||
impl NewMiningJob {
|
||||
pub fn encode(&self) -> Vec<u8> {
|
||||
let mut out = Vec::new();
|
||||
put_u32(&mut out, self.channel_id);
|
||||
put_u32(&mut out, self.job_id);
|
||||
match self.ntime_start {
|
||||
Some(ntime) => {
|
||||
out.push(1);
|
||||
put_u32(&mut out, ntime);
|
||||
}
|
||||
None => out.push(0),
|
||||
}
|
||||
put_u32(&mut out, self.version);
|
||||
out.extend_from_slice(&self.merkle_root);
|
||||
out
|
||||
}
|
||||
|
||||
pub fn decode(payload: &[u8]) -> Result<Self, V2Error> {
|
||||
let mut reader = Reader::new(payload);
|
||||
let channel_id = reader.u32()?;
|
||||
let job_id = reader.u32()?;
|
||||
let ntime_start = reader.option_u32()?;
|
||||
Ok(Self {
|
||||
channel_id,
|
||||
job_id,
|
||||
ntime_start,
|
||||
version: reader.u32()?,
|
||||
merkle_root: reader.u256()?,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// `SetNewPrevHash`.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct SetNewPrevHash {
|
||||
pub channel_id: u32,
|
||||
pub job_id: u32,
|
||||
pub prev_hash: [u8; 32],
|
||||
pub ntime_start: u32,
|
||||
pub nbits: u32,
|
||||
}
|
||||
|
||||
impl SetNewPrevHash {
|
||||
pub fn encode(&self) -> Vec<u8> {
|
||||
let mut out = Vec::new();
|
||||
put_u32(&mut out, self.channel_id);
|
||||
put_u32(&mut out, self.job_id);
|
||||
out.extend_from_slice(&self.prev_hash);
|
||||
put_u32(&mut out, self.ntime_start);
|
||||
put_u32(&mut out, self.nbits);
|
||||
out
|
||||
}
|
||||
|
||||
pub fn decode(payload: &[u8]) -> Result<Self, V2Error> {
|
||||
let mut reader = Reader::new(payload);
|
||||
Ok(Self {
|
||||
channel_id: reader.u32()?,
|
||||
job_id: reader.u32()?,
|
||||
prev_hash: reader.u256()?,
|
||||
ntime_start: reader.u32()?,
|
||||
nbits: reader.u32()?,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// `SubmitSharesStandard`.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct SubmitSharesStandard {
|
||||
pub channel_id: u32,
|
||||
pub sequence_number: u32,
|
||||
pub job_id: u32,
|
||||
pub nonce: u32,
|
||||
pub ntime: u32,
|
||||
pub version: u32,
|
||||
}
|
||||
|
||||
impl SubmitSharesStandard {
|
||||
pub fn encode(&self) -> Vec<u8> {
|
||||
let mut out = Vec::new();
|
||||
put_u32(&mut out, self.channel_id);
|
||||
put_u32(&mut out, self.sequence_number);
|
||||
put_u32(&mut out, self.job_id);
|
||||
put_u32(&mut out, self.nonce);
|
||||
put_u32(&mut out, self.ntime);
|
||||
put_u32(&mut out, self.version);
|
||||
out
|
||||
}
|
||||
|
||||
pub fn decode(payload: &[u8]) -> Result<Self, V2Error> {
|
||||
let mut reader = Reader::new(payload);
|
||||
Ok(Self {
|
||||
channel_id: reader.u32()?,
|
||||
sequence_number: reader.u32()?,
|
||||
job_id: reader.u32()?,
|
||||
nonce: reader.u32()?,
|
||||
ntime: reader.u32()?,
|
||||
version: reader.u32()?,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn put_u16(out: &mut Vec<u8>, value: u16) {
|
||||
out.extend_from_slice(&value.to_le_bytes());
|
||||
}
|
||||
|
||||
fn put_u32(out: &mut Vec<u8>, value: u32) {
|
||||
out.extend_from_slice(&value.to_le_bytes());
|
||||
}
|
||||
|
||||
fn put_str(out: &mut Vec<u8>, text: &str) {
|
||||
let bytes = text.as_bytes();
|
||||
let length = bytes.len().min(255);
|
||||
out.push(length as u8);
|
||||
out.extend_from_slice(&bytes[..length]);
|
||||
}
|
||||
|
||||
fn put_bytes(out: &mut Vec<u8>, bytes: &[u8]) {
|
||||
let length = bytes.len().min(255);
|
||||
out.push(length as u8);
|
||||
out.extend_from_slice(&bytes[..length]);
|
||||
}
|
||||
|
||||
struct Reader<'a> {
|
||||
buf: &'a [u8],
|
||||
at: usize,
|
||||
}
|
||||
|
||||
impl<'a> Reader<'a> {
|
||||
fn new(buf: &'a [u8]) -> Self {
|
||||
Self { buf, at: 0 }
|
||||
}
|
||||
|
||||
fn take(&mut self, count: usize) -> Result<&'a [u8], V2Error> {
|
||||
let end = self.at.checked_add(count).ok_or(V2Error::Length)?;
|
||||
if end > self.buf.len() {
|
||||
return Err(V2Error::Truncated);
|
||||
}
|
||||
let slice = &self.buf[self.at..end];
|
||||
self.at = end;
|
||||
Ok(slice)
|
||||
}
|
||||
|
||||
fn u8(&mut self) -> Result<u8, V2Error> {
|
||||
Ok(self.take(1)?[0])
|
||||
}
|
||||
|
||||
fn u16(&mut self) -> Result<u16, V2Error> {
|
||||
let bytes = self.take(2)?;
|
||||
Ok(u16::from_le_bytes([bytes[0], bytes[1]]))
|
||||
}
|
||||
|
||||
fn u32(&mut self) -> Result<u32, V2Error> {
|
||||
let bytes = self.take(4)?;
|
||||
Ok(u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]))
|
||||
}
|
||||
|
||||
fn f32(&mut self) -> Result<f32, V2Error> {
|
||||
Ok(f32::from_bits(self.u32()?))
|
||||
}
|
||||
|
||||
fn u256(&mut self) -> Result<[u8; 32], V2Error> {
|
||||
let bytes = self.take(32)?;
|
||||
let mut out = [0_u8; 32];
|
||||
out.copy_from_slice(bytes);
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
fn string(&mut self) -> Result<String, V2Error> {
|
||||
let length = self.u8()? as usize;
|
||||
let bytes = self.take(length)?;
|
||||
String::from_utf8(bytes.to_vec()).map_err(|_| V2Error::String)
|
||||
}
|
||||
|
||||
fn bytes(&mut self, max: usize) -> Result<Vec<u8>, V2Error> {
|
||||
let length = self.u8()? as usize;
|
||||
if length > max {
|
||||
return Err(V2Error::Length);
|
||||
}
|
||||
Ok(self.take(length)?.to_vec())
|
||||
}
|
||||
|
||||
fn option_u32(&mut self) -> Result<Option<u32>, V2Error> {
|
||||
match self.u8()? {
|
||||
0 => Ok(None),
|
||||
1 => Ok(Some(self.u32()?)),
|
||||
_ => Err(V2Error::Length),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn hash(byte: u8) -> [u8; 32] {
|
||||
[byte; 32]
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn frame_header_matches_the_specification() {
|
||||
let mut wire = Vec::new();
|
||||
Frame::new(SETUP_CONNECTION, vec![1, 2, 3]).encode(&mut wire);
|
||||
assert_eq!(&wire[..3], &[0x00, 0x00, 0x00]);
|
||||
assert_eq!(&wire[3..6], &[0x03, 0x00, 0x00]);
|
||||
let (frame, consumed) = Frame::decode(&wire).expect("frame");
|
||||
assert_eq!(consumed, wire.len());
|
||||
assert_eq!(frame.msg_type, SETUP_CONNECTION);
|
||||
assert_eq!(frame.payload, vec![1, 2, 3]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_truncated_frame_is_rejected() {
|
||||
assert_eq!(Frame::decode(&[0, 0, 0x00]), Err(V2Error::Truncated));
|
||||
let mut wire = Vec::new();
|
||||
Frame::new(SETUP_CONNECTION, vec![9; 10]).encode(&mut wire);
|
||||
assert_eq!(Frame::decode(&wire[..8]), Err(V2Error::Truncated));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn setup_connection_round_trips() {
|
||||
let message = SetupConnection {
|
||||
protocol: 0,
|
||||
min_version: 2,
|
||||
max_version: 2,
|
||||
flags: 0b1011,
|
||||
endpoint_host: "pool.example".into(),
|
||||
endpoint_port: 3333,
|
||||
vendor: "alkane".into(),
|
||||
hardware_version: "s19jpro-bm1362".into(),
|
||||
firmware: "alkane-os/0.1.0".into(),
|
||||
device_id: "bench-169".into(),
|
||||
};
|
||||
let wire = message.encode();
|
||||
assert_eq!(SetupConnection::decode(&wire).expect("decode"), message);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn setup_connection_success_round_trips() {
|
||||
let message = SetupConnectionSuccess {
|
||||
used_version: 2,
|
||||
flags: 0,
|
||||
};
|
||||
assert_eq!(
|
||||
SetupConnectionSuccess::decode(&message.encode()).expect("decode"),
|
||||
message
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn open_standard_channel_round_trips() {
|
||||
let message = OpenStandardMiningChannel {
|
||||
request_id: 7,
|
||||
user_identity: "bc1q.example".into(),
|
||||
nominal_hash_rate: 95_000_000_000_000.0,
|
||||
max_target: hash(0xff),
|
||||
};
|
||||
assert_eq!(
|
||||
OpenStandardMiningChannel::decode(&message.encode()).expect("decode"),
|
||||
message
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_non_finite_hashrate_is_a_protocol_error() {
|
||||
let message = OpenStandardMiningChannel {
|
||||
request_id: 1,
|
||||
user_identity: "x".into(),
|
||||
nominal_hash_rate: f32::NAN,
|
||||
max_target: hash(0),
|
||||
};
|
||||
assert_eq!(
|
||||
OpenStandardMiningChannel::decode(&message.encode()),
|
||||
Err(V2Error::NonFiniteRate)
|
||||
);
|
||||
let negative = OpenStandardMiningChannel {
|
||||
nominal_hash_rate: -1.0,
|
||||
..message
|
||||
};
|
||||
assert_eq!(
|
||||
OpenStandardMiningChannel::decode(&negative.encode()),
|
||||
Err(V2Error::NonFiniteRate)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn channel_success_carries_the_extranonce_prefix() {
|
||||
let message = OpenStandardMiningChannelSuccess {
|
||||
request_id: 7,
|
||||
channel_id: 11,
|
||||
target: hash(0x7f),
|
||||
extranonce_prefix: vec![0xde, 0xad, 0xbe, 0xef],
|
||||
group_channel_id: 0,
|
||||
};
|
||||
assert_eq!(
|
||||
OpenStandardMiningChannelSuccess::decode(&message.encode()).expect("decode"),
|
||||
message
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn new_job_round_trips_both_ntime_forms() {
|
||||
let active = NewMiningJob {
|
||||
channel_id: 1,
|
||||
job_id: 2,
|
||||
ntime_start: Some(1_700_000_000),
|
||||
version: 0x2000_0000,
|
||||
merkle_root: hash(0x11),
|
||||
};
|
||||
assert_eq!(
|
||||
NewMiningJob::decode(&active.encode()).expect("decode"),
|
||||
active
|
||||
);
|
||||
let future = NewMiningJob {
|
||||
ntime_start: None,
|
||||
..active
|
||||
};
|
||||
assert_eq!(
|
||||
NewMiningJob::decode(&future.encode()).expect("decode"),
|
||||
future
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_new_prev_hash_round_trips() {
|
||||
let message = SetNewPrevHash {
|
||||
channel_id: 1,
|
||||
job_id: 2,
|
||||
prev_hash: hash(0x22),
|
||||
ntime_start: 1_700_000_100,
|
||||
nbits: 0x1707_0000,
|
||||
};
|
||||
assert_eq!(
|
||||
SetNewPrevHash::decode(&message.encode()).expect("decode"),
|
||||
message
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn submit_shares_round_trips() {
|
||||
let message = SubmitSharesStandard {
|
||||
channel_id: 3,
|
||||
sequence_number: 99,
|
||||
job_id: 4,
|
||||
nonce: 0xdead_beef,
|
||||
ntime: 1_700_000_200,
|
||||
version: 0x2000_0000,
|
||||
};
|
||||
assert_eq!(
|
||||
SubmitSharesStandard::decode(&message.encode()).expect("decode"),
|
||||
message
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_short_payload_is_rejected_rather_than_padded() {
|
||||
let wire = SubmitSharesStandard {
|
||||
channel_id: 3,
|
||||
sequence_number: 99,
|
||||
job_id: 4,
|
||||
nonce: 0,
|
||||
ntime: 0,
|
||||
version: 0,
|
||||
}
|
||||
.encode();
|
||||
assert_eq!(
|
||||
SubmitSharesStandard::decode(&wire[..8]),
|
||||
Err(V2Error::Truncated)
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,553 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Stratum V2 session: handshake, channel, jobs and share submission.
|
||||
//!
|
||||
//! The codec in `stratum_v2` owns bytes; this module owns order. It drives the client half of a
|
||||
//! mining connection and refuses to invent state: a job received before any `SetNewPrevHash` is
|
||||
//! reported with no previous hash rather than with a zero one, and a rejected setup surfaces the
|
||||
//! server's code.
|
||||
|
||||
use crate::stratum_v2::{
|
||||
Frame, NewMiningJob, OpenStandardMiningChannel, SetNewPrevHash, SetupConnection,
|
||||
SetupConnectionSuccess, SubmitSharesStandard, NEW_MINING_JOB, OPEN_MINING_CHANNEL_ERROR,
|
||||
OPEN_STANDARD_MINING_CHANNEL, OPEN_STANDARD_MINING_CHANNEL_SUCCESS, SETUP_CONNECTION,
|
||||
SETUP_CONNECTION_ERROR, SETUP_CONNECTION_SUCCESS, SET_NEW_PREV_HASH, SET_TARGET,
|
||||
SUBMIT_SHARES_ERROR, SUBMIT_SHARES_STANDARD, SUBMIT_SHARES_SUCCESS,
|
||||
};
|
||||
|
||||
/// A connection that carries whole frames.
|
||||
pub trait V2Link {
|
||||
type Error;
|
||||
|
||||
fn send(&mut self, frame: &Frame) -> Result<(), Self::Error>;
|
||||
fn recv(&mut self) -> Result<Frame, Self::Error>;
|
||||
}
|
||||
|
||||
/// What the client declares when it connects.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct V2Config {
|
||||
pub host: String,
|
||||
pub port: u16,
|
||||
pub flags: u32,
|
||||
pub user_identity: String,
|
||||
pub nominal_hash_rate: f32,
|
||||
pub max_target: [u8; 32],
|
||||
pub vendor: String,
|
||||
pub hardware: String,
|
||||
pub firmware: String,
|
||||
pub device_id: String,
|
||||
}
|
||||
|
||||
/// An opened standard channel.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct V2Channel {
|
||||
pub channel_id: u32,
|
||||
pub target: [u8; 32],
|
||||
pub extranonce_prefix: Vec<u8>,
|
||||
pub group_channel_id: u32,
|
||||
}
|
||||
|
||||
/// A job the miner may work on.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct V2Job {
|
||||
pub job_id: u32,
|
||||
pub version: u32,
|
||||
pub merkle_root: [u8; 32],
|
||||
pub ntime_start: Option<u32>,
|
||||
pub prev_hash: Option<[u8; 32]>,
|
||||
pub nbits: Option<u32>,
|
||||
}
|
||||
|
||||
/// Something the server told us.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum V2Event {
|
||||
Job(V2Job),
|
||||
PrevHash {
|
||||
job_id: u32,
|
||||
prev_hash: [u8; 32],
|
||||
ntime_start: u32,
|
||||
nbits: u32,
|
||||
},
|
||||
Target {
|
||||
channel_id: u32,
|
||||
target: [u8; 32],
|
||||
},
|
||||
ShareAccepted {
|
||||
last_sequence: u32,
|
||||
accepted: u32,
|
||||
},
|
||||
ShareRejected {
|
||||
last_sequence: u32,
|
||||
},
|
||||
Ignored,
|
||||
}
|
||||
|
||||
/// A protocol-level failure, without a link error inside it.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub enum SessionError {
|
||||
Protocol(&'static str),
|
||||
Rejected(String),
|
||||
}
|
||||
|
||||
/// A failure that may have come from the transport.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub enum ConnectError<E> {
|
||||
Link(E),
|
||||
Session(SessionError),
|
||||
}
|
||||
|
||||
/// Run the client handshake and return the opened channel.
|
||||
pub fn handshake<L: V2Link>(
|
||||
link: &mut L,
|
||||
config: &V2Config,
|
||||
) -> Result<V2Channel, ConnectError<L::Error>> {
|
||||
let setup = SetupConnection {
|
||||
protocol: 0,
|
||||
min_version: 2,
|
||||
max_version: 2,
|
||||
flags: config.flags,
|
||||
endpoint_host: config.host.clone(),
|
||||
endpoint_port: config.port,
|
||||
vendor: config.vendor.clone(),
|
||||
hardware_version: config.hardware.clone(),
|
||||
firmware: config.firmware.clone(),
|
||||
device_id: config.device_id.clone(),
|
||||
};
|
||||
link.send(&Frame::new(SETUP_CONNECTION, setup.encode()))
|
||||
.map_err(ConnectError::Link)?;
|
||||
let reply = link.recv().map_err(ConnectError::Link)?;
|
||||
match reply.msg_type {
|
||||
SETUP_CONNECTION_SUCCESS => {
|
||||
let _ = SetupConnectionSuccess::decode(&reply.payload)
|
||||
.map_err(|_| ConnectError::Session(SessionError::Protocol("bad setup success")))?;
|
||||
}
|
||||
SETUP_CONNECTION_ERROR => {
|
||||
return Err(ConnectError::Session(SessionError::Rejected(
|
||||
setup_error_text(&reply.payload),
|
||||
)))
|
||||
}
|
||||
_ => {
|
||||
return Err(ConnectError::Session(SessionError::Protocol(
|
||||
"unexpected message before setup success",
|
||||
)))
|
||||
}
|
||||
}
|
||||
|
||||
let open = OpenStandardMiningChannel {
|
||||
request_id: 1,
|
||||
user_identity: config.user_identity.clone(),
|
||||
nominal_hash_rate: config.nominal_hash_rate,
|
||||
max_target: config.max_target,
|
||||
};
|
||||
link.send(&Frame::new(OPEN_STANDARD_MINING_CHANNEL, open.encode()))
|
||||
.map_err(ConnectError::Link)?;
|
||||
let reply = link.recv().map_err(ConnectError::Link)?;
|
||||
match reply.msg_type {
|
||||
OPEN_STANDARD_MINING_CHANNEL_SUCCESS => {
|
||||
let success =
|
||||
crate::stratum_v2::OpenStandardMiningChannelSuccess::decode(&reply.payload)
|
||||
.map_err(|_| {
|
||||
ConnectError::Session(SessionError::Protocol("bad channel success"))
|
||||
})?;
|
||||
if success.request_id != 1 {
|
||||
return Err(ConnectError::Session(SessionError::Protocol(
|
||||
"channel response does not match the request",
|
||||
)));
|
||||
}
|
||||
Ok(V2Channel {
|
||||
channel_id: success.channel_id,
|
||||
target: success.target,
|
||||
extranonce_prefix: success.extranonce_prefix,
|
||||
group_channel_id: success.group_channel_id,
|
||||
})
|
||||
}
|
||||
OPEN_MINING_CHANNEL_ERROR => Err(ConnectError::Session(SessionError::Rejected(
|
||||
setup_error_text(&reply.payload),
|
||||
))),
|
||||
_ => Err(ConnectError::Session(SessionError::Protocol(
|
||||
"unexpected message while opening a channel",
|
||||
))),
|
||||
}
|
||||
}
|
||||
|
||||
fn setup_error_text(payload: &[u8]) -> String {
|
||||
// Error messages are a U32 flag mask followed by a STR0_255 code.
|
||||
if payload.len() < 5 {
|
||||
return String::from("unspecified");
|
||||
}
|
||||
let length = payload[4] as usize;
|
||||
payload
|
||||
.get(5..5 + length)
|
||||
.and_then(|bytes| std::str::from_utf8(bytes).ok())
|
||||
.unwrap_or("unspecified")
|
||||
.to_owned()
|
||||
}
|
||||
|
||||
/// Session state after the handshake.
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub struct V2Session {
|
||||
channel: V2Channel,
|
||||
prev_hash: Option<[u8; 32]>,
|
||||
nbits: Option<u32>,
|
||||
sequence: u32,
|
||||
}
|
||||
|
||||
impl V2Session {
|
||||
pub fn new(channel: V2Channel) -> Self {
|
||||
Self {
|
||||
channel,
|
||||
prev_hash: None,
|
||||
nbits: None,
|
||||
sequence: 0,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn channel(&self) -> &V2Channel {
|
||||
&self.channel
|
||||
}
|
||||
|
||||
/// Interpret one server frame.
|
||||
pub fn on_frame(&mut self, frame: &Frame) -> Result<V2Event, SessionError> {
|
||||
match frame.msg_type {
|
||||
NEW_MINING_JOB => {
|
||||
let job = NewMiningJob::decode(&frame.payload)
|
||||
.map_err(|_| SessionError::Protocol("bad NewMiningJob"))?;
|
||||
Ok(V2Event::Job(V2Job {
|
||||
job_id: job.job_id,
|
||||
version: job.version,
|
||||
merkle_root: job.merkle_root,
|
||||
ntime_start: job.ntime_start,
|
||||
prev_hash: self.prev_hash,
|
||||
nbits: self.nbits,
|
||||
}))
|
||||
}
|
||||
SET_NEW_PREV_HASH => {
|
||||
let message = SetNewPrevHash::decode(&frame.payload)
|
||||
.map_err(|_| SessionError::Protocol("bad SetNewPrevHash"))?;
|
||||
self.prev_hash = Some(message.prev_hash);
|
||||
self.nbits = Some(message.nbits);
|
||||
Ok(V2Event::PrevHash {
|
||||
job_id: message.job_id,
|
||||
prev_hash: message.prev_hash,
|
||||
ntime_start: message.ntime_start,
|
||||
nbits: message.nbits,
|
||||
})
|
||||
}
|
||||
SET_TARGET => {
|
||||
if frame.payload.len() != 4 + 32 {
|
||||
return Err(SessionError::Protocol("bad SetTarget"));
|
||||
}
|
||||
let channel_id = u32::from_le_bytes([
|
||||
frame.payload[0],
|
||||
frame.payload[1],
|
||||
frame.payload[2],
|
||||
frame.payload[3],
|
||||
]);
|
||||
let mut target = [0_u8; 32];
|
||||
target.copy_from_slice(&frame.payload[4..36]);
|
||||
Ok(V2Event::Target { channel_id, target })
|
||||
}
|
||||
SUBMIT_SHARES_SUCCESS => {
|
||||
if frame.payload.len() < 20 {
|
||||
return Err(SessionError::Protocol("bad SubmitShares.Success"));
|
||||
}
|
||||
let last_sequence = u32::from_le_bytes([
|
||||
frame.payload[4],
|
||||
frame.payload[5],
|
||||
frame.payload[6],
|
||||
frame.payload[7],
|
||||
]);
|
||||
let accepted = u32::from_le_bytes([
|
||||
frame.payload[8],
|
||||
frame.payload[9],
|
||||
frame.payload[10],
|
||||
frame.payload[11],
|
||||
]);
|
||||
Ok(V2Event::ShareAccepted {
|
||||
last_sequence,
|
||||
accepted,
|
||||
})
|
||||
}
|
||||
SUBMIT_SHARES_ERROR => {
|
||||
let last_sequence = if frame.payload.len() >= 8 {
|
||||
u32::from_le_bytes([
|
||||
frame.payload[0],
|
||||
frame.payload[1],
|
||||
frame.payload[2],
|
||||
frame.payload[3],
|
||||
])
|
||||
} else {
|
||||
0
|
||||
};
|
||||
Ok(V2Event::ShareRejected { last_sequence })
|
||||
}
|
||||
_ => Ok(V2Event::Ignored),
|
||||
}
|
||||
}
|
||||
|
||||
/// Submit one standard share; returns the sequence number used.
|
||||
pub fn submit<L: V2Link>(
|
||||
&mut self,
|
||||
link: &mut L,
|
||||
job_id: u32,
|
||||
nonce: u32,
|
||||
ntime: u32,
|
||||
version: u32,
|
||||
) -> Result<u32, ConnectError<L::Error>> {
|
||||
self.sequence = self.sequence.wrapping_add(1);
|
||||
let share = SubmitSharesStandard {
|
||||
channel_id: self.channel.channel_id,
|
||||
sequence_number: self.sequence,
|
||||
job_id,
|
||||
nonce,
|
||||
ntime,
|
||||
version,
|
||||
};
|
||||
link.send(&Frame::new(SUBMIT_SHARES_STANDARD, share.encode()))
|
||||
.map_err(ConnectError::Link)?;
|
||||
Ok(self.sequence)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::collections::VecDeque;
|
||||
|
||||
struct Scripted {
|
||||
incoming: VecDeque<Frame>,
|
||||
sent: Vec<Frame>,
|
||||
}
|
||||
|
||||
impl Scripted {
|
||||
fn new(incoming: Vec<Frame>) -> Self {
|
||||
Self {
|
||||
incoming: incoming.into(),
|
||||
sent: Vec::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl V2Link for Scripted {
|
||||
type Error = ();
|
||||
|
||||
fn send(&mut self, frame: &Frame) -> Result<(), ()> {
|
||||
self.sent.push(frame.clone());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn recv(&mut self) -> Result<Frame, ()> {
|
||||
self.incoming.pop_front().ok_or(())
|
||||
}
|
||||
}
|
||||
|
||||
fn config() -> V2Config {
|
||||
V2Config {
|
||||
host: "pool.example".into(),
|
||||
port: 3333,
|
||||
flags: 0,
|
||||
user_identity: "worker".into(),
|
||||
nominal_hash_rate: 1.0e14,
|
||||
max_target: [0xff; 32],
|
||||
vendor: "alkane".into(),
|
||||
hardware: "bench".into(),
|
||||
firmware: "alkane-os".into(),
|
||||
device_id: "bench-1".into(),
|
||||
}
|
||||
}
|
||||
|
||||
fn setup_success() -> Frame {
|
||||
Frame::new(
|
||||
SETUP_CONNECTION_SUCCESS,
|
||||
SetupConnectionSuccess {
|
||||
used_version: 2,
|
||||
flags: 0,
|
||||
}
|
||||
.encode(),
|
||||
)
|
||||
}
|
||||
|
||||
fn channel_success() -> Frame {
|
||||
Frame::new(
|
||||
OPEN_STANDARD_MINING_CHANNEL_SUCCESS,
|
||||
crate::stratum_v2::OpenStandardMiningChannelSuccess {
|
||||
request_id: 1,
|
||||
channel_id: 9,
|
||||
target: [0x7f; 32],
|
||||
extranonce_prefix: vec![1, 2],
|
||||
group_channel_id: 0,
|
||||
}
|
||||
.encode(),
|
||||
)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn handshake_sends_setup_then_open_and_returns_the_channel() {
|
||||
let mut link = Scripted::new(vec![setup_success(), channel_success()]);
|
||||
let channel = handshake(&mut link, &config()).expect("handshake");
|
||||
assert_eq!(channel.channel_id, 9);
|
||||
assert_eq!(channel.extranonce_prefix, vec![1, 2]);
|
||||
assert_eq!(link.sent.len(), 2);
|
||||
assert_eq!(link.sent[0].msg_type, SETUP_CONNECTION);
|
||||
assert_eq!(link.sent[1].msg_type, OPEN_STANDARD_MINING_CHANNEL);
|
||||
let open = OpenStandardMiningChannel::decode(&link.sent[1].payload).expect("open");
|
||||
assert_eq!(open.user_identity, "worker");
|
||||
assert_eq!(open.request_id, 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_setup_error_surfaces_the_server_code() {
|
||||
let mut payload = 0_u32.to_le_bytes().to_vec();
|
||||
payload.push(3);
|
||||
payload.extend_from_slice(b"bad");
|
||||
let mut link = Scripted::new(vec![Frame::new(SETUP_CONNECTION_ERROR, payload)]);
|
||||
assert_eq!(
|
||||
handshake(&mut link, &config()),
|
||||
Err(ConnectError::Session(SessionError::Rejected("bad".into())))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_unexpected_message_during_setup_is_a_protocol_error() {
|
||||
let mut link = Scripted::new(vec![Frame::new(NEW_MINING_JOB, vec![0; 44])]);
|
||||
assert_eq!(
|
||||
handshake(&mut link, &config()),
|
||||
Err(ConnectError::Session(SessionError::Protocol(
|
||||
"unexpected message before setup success"
|
||||
)))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_job_before_any_prev_hash_has_no_prev_hash() {
|
||||
let mut session = V2Session::new(V2Channel {
|
||||
channel_id: 9,
|
||||
target: [0xff; 32],
|
||||
extranonce_prefix: Vec::new(),
|
||||
group_channel_id: 0,
|
||||
});
|
||||
let job = NewMiningJob {
|
||||
channel_id: 9,
|
||||
job_id: 1,
|
||||
ntime_start: Some(1_700_000_000),
|
||||
version: 0x2000_0000,
|
||||
merkle_root: [0x11; 32],
|
||||
};
|
||||
let event = session
|
||||
.on_frame(&Frame::new(NEW_MINING_JOB, job.encode()))
|
||||
.expect("job");
|
||||
match event {
|
||||
V2Event::Job(parsed) => {
|
||||
assert_eq!(parsed.job_id, 1);
|
||||
assert_eq!(parsed.prev_hash, None);
|
||||
assert_eq!(parsed.nbits, None);
|
||||
}
|
||||
other => panic!("unexpected event: {other:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn prev_hash_is_remembered_for_later_jobs() {
|
||||
let mut session = V2Session::new(V2Channel {
|
||||
channel_id: 9,
|
||||
target: [0xff; 32],
|
||||
extranonce_prefix: Vec::new(),
|
||||
group_channel_id: 0,
|
||||
});
|
||||
let prev = SetNewPrevHash {
|
||||
channel_id: 9,
|
||||
job_id: 1,
|
||||
prev_hash: [0x22; 32],
|
||||
ntime_start: 1_700_000_100,
|
||||
nbits: 0x1707_0000,
|
||||
};
|
||||
session
|
||||
.on_frame(&Frame::new(SET_NEW_PREV_HASH, prev.encode()))
|
||||
.expect("prev hash");
|
||||
let job = NewMiningJob {
|
||||
channel_id: 9,
|
||||
job_id: 2,
|
||||
ntime_start: None,
|
||||
version: 0x2000_0000,
|
||||
merkle_root: [0x33; 32],
|
||||
};
|
||||
match session
|
||||
.on_frame(&Frame::new(NEW_MINING_JOB, job.encode()))
|
||||
.expect("job")
|
||||
{
|
||||
V2Event::Job(parsed) => {
|
||||
assert_eq!(parsed.prev_hash, Some([0x22; 32]));
|
||||
assert_eq!(parsed.nbits, Some(0x1707_0000));
|
||||
assert_eq!(parsed.ntime_start, None);
|
||||
}
|
||||
other => panic!("unexpected event: {other:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn submissions_use_the_channel_and_increasing_sequence_numbers() {
|
||||
let mut session = V2Session::new(V2Channel {
|
||||
channel_id: 9,
|
||||
target: [0xff; 32],
|
||||
extranonce_prefix: Vec::new(),
|
||||
group_channel_id: 0,
|
||||
});
|
||||
let mut link = Scripted::new(Vec::new());
|
||||
assert_eq!(
|
||||
session
|
||||
.submit(&mut link, 1, 0xabcd, 1_700_000_000, 0x2000_0000)
|
||||
.expect("submit"),
|
||||
1
|
||||
);
|
||||
assert_eq!(
|
||||
session
|
||||
.submit(&mut link, 1, 0xabce, 1_700_000_000, 0x2000_0000)
|
||||
.expect("submit"),
|
||||
2
|
||||
);
|
||||
assert_eq!(link.sent.len(), 2);
|
||||
let first = SubmitSharesStandard::decode(&link.sent[0].payload).expect("share");
|
||||
assert_eq!(first.channel_id, 9);
|
||||
assert_eq!(first.sequence_number, 1);
|
||||
assert_eq!(first.nonce, 0xabcd);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn share_success_reports_the_last_sequence() {
|
||||
let mut session = V2Session::new(V2Channel {
|
||||
channel_id: 9,
|
||||
target: [0xff; 32],
|
||||
extranonce_prefix: Vec::new(),
|
||||
group_channel_id: 0,
|
||||
});
|
||||
let mut payload = Vec::new();
|
||||
payload.extend_from_slice(&9_u32.to_le_bytes());
|
||||
payload.extend_from_slice(&7_u32.to_le_bytes());
|
||||
payload.extend_from_slice(&3_u32.to_le_bytes());
|
||||
payload.extend_from_slice(&0_u64.to_le_bytes());
|
||||
assert_eq!(
|
||||
session
|
||||
.on_frame(&Frame::new(SUBMIT_SHARES_SUCCESS, payload))
|
||||
.expect("event"),
|
||||
V2Event::ShareAccepted {
|
||||
last_sequence: 7,
|
||||
accepted: 3
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_unknown_message_is_ignored_not_fatal() {
|
||||
let mut session = V2Session::new(V2Channel {
|
||||
channel_id: 9,
|
||||
target: [0xff; 32],
|
||||
extranonce_prefix: Vec::new(),
|
||||
group_channel_id: 0,
|
||||
});
|
||||
assert_eq!(
|
||||
session
|
||||
.on_frame(&Frame::new(0x7e, vec![0; 4]))
|
||||
.expect("event"),
|
||||
V2Event::Ignored
|
||||
);
|
||||
}
|
||||
}
|
||||
+506
@@ -0,0 +1,506 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Adaptive tuning.
|
||||
//!
|
||||
//! The miner targets a power draw, a hashrate, or an operating point chosen for the ambient
|
||||
//! temperature. Rather than picking a preset, a bounded PID moves the chain frequency inside the
|
||||
//! profile envelope each control period, and a thermal guard can always override it downward.
|
||||
//!
|
||||
//! The controller is deliberately conservative: bounded output, rate limit, deadband, derivative
|
||||
//! on the measurement (no setpoint kick) and conditional integration (no windup while saturated).
|
||||
|
||||
use crate::detect::Envelope;
|
||||
|
||||
/// What the operator asked for.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum TuningTarget {
|
||||
/// Hold this DC power draw; efficiency follows from the power point.
|
||||
PowerW(f32),
|
||||
/// Maximise hashrate up to this value.
|
||||
HashrateThs(f32),
|
||||
/// Hold the hottest sensor this far above the measured ambient: efficiency at that ambient.
|
||||
AmbientC { margin_mc: i32 },
|
||||
/// Pin the fan at this duty and maximise hashrate under it.
|
||||
MaxFan { max_pwm: u8 },
|
||||
}
|
||||
|
||||
/// Controller tuning.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub struct PidConfig {
|
||||
pub kp: f32,
|
||||
pub ki: f32,
|
||||
pub kd: f32,
|
||||
pub out_min: f32,
|
||||
pub out_max: f32,
|
||||
/// Maximum output change per second.
|
||||
pub max_step_per_s: f32,
|
||||
/// Errors inside this band are ignored.
|
||||
pub deadband: f32,
|
||||
}
|
||||
|
||||
impl Default for PidConfig {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
kp: 0.5,
|
||||
ki: 0.1,
|
||||
kd: 0.0,
|
||||
out_min: 0.0,
|
||||
out_max: 1_000.0,
|
||||
max_step_per_s: 50.0,
|
||||
deadband: 1.0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A bounded PID with anti-windup and rate limiting.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Pid {
|
||||
config: PidConfig,
|
||||
integral: f32,
|
||||
last_measurement: Option<f32>,
|
||||
output: f32,
|
||||
}
|
||||
|
||||
impl Pid {
|
||||
pub fn new(config: PidConfig, initial_output: f32) -> Self {
|
||||
Self {
|
||||
config,
|
||||
integral: 0.0,
|
||||
last_measurement: None,
|
||||
output: initial_output.clamp(config.out_min, config.out_max),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn output(&self) -> f32 {
|
||||
self.output
|
||||
}
|
||||
|
||||
/// Force the output (used by ramp modes and the thermal guard).
|
||||
pub fn set_output(&mut self, value: f32) {
|
||||
self.output = value.clamp(self.config.out_min, self.config.out_max);
|
||||
}
|
||||
|
||||
/// Advance one control period and return the new output.
|
||||
pub fn update(&mut self, setpoint: f32, measurement: f32, dt_s: f32) -> f32 {
|
||||
if !dt_s.is_finite() || dt_s <= 0.0 {
|
||||
return self.output;
|
||||
}
|
||||
let error = setpoint - measurement;
|
||||
if error.abs() <= self.config.deadband {
|
||||
self.last_measurement = Some(measurement);
|
||||
return self.output;
|
||||
}
|
||||
let derivative = match self.last_measurement {
|
||||
Some(previous) => -(measurement - previous) / dt_s,
|
||||
None => 0.0,
|
||||
};
|
||||
let candidate = self.config.kp * error + self.integral + self.config.kd * derivative;
|
||||
let saturated = candidate > self.config.out_max || candidate < self.config.out_min;
|
||||
// Conditional integration: never accumulate while the actuator is pinned in the direction
|
||||
// of the error, or the loop unwinds slowly after a saturation episode.
|
||||
let pinning = (candidate > self.config.out_max && error > 0.0)
|
||||
|| (candidate < self.config.out_min && error < 0.0);
|
||||
if !saturated || !pinning {
|
||||
self.integral += self.config.ki * error * dt_s;
|
||||
}
|
||||
let mut desired = self.config.kp * error + self.integral + self.config.kd * derivative;
|
||||
desired = desired.clamp(self.config.out_min, self.config.out_max);
|
||||
let max_step = self.config.max_step_per_s * dt_s;
|
||||
let step = (desired - self.output).clamp(-max_step, max_step);
|
||||
self.output = (self.output + step).clamp(self.config.out_min, self.config.out_max);
|
||||
self.last_measurement = Some(measurement);
|
||||
self.output
|
||||
}
|
||||
}
|
||||
|
||||
/// What the loop needs to know each period.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub struct Observation {
|
||||
pub power_w: Option<f32>,
|
||||
pub hashrate_ths: Option<f32>,
|
||||
/// Hottest sensor in millidegrees, when telemetry is available.
|
||||
pub hottest_mc: Option<i32>,
|
||||
/// Intake/enclosure temperature in millidegrees, for the ambient target.
|
||||
pub ambient_mc: Option<i32>,
|
||||
}
|
||||
|
||||
/// What the loop wants applied this period.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct Command {
|
||||
pub frequency_mhz: u16,
|
||||
/// `Some` only when the target owns the fan (max-fan mode).
|
||||
pub fan_pwm: Option<u8>,
|
||||
}
|
||||
|
||||
/// Why the loop could not produce a command.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum TuningError {
|
||||
/// The measurement the target needs is missing this period.
|
||||
NoMeasurement,
|
||||
}
|
||||
|
||||
/// The tuning loop: one PID over chain frequency, bounded by the profile envelope.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct TuningLoop {
|
||||
pid: Pid,
|
||||
envelope: Envelope,
|
||||
target: TuningTarget,
|
||||
ceiling_mc: i32,
|
||||
}
|
||||
|
||||
impl TuningLoop {
|
||||
/// Start from the conservative floor of the envelope.
|
||||
pub fn new(target: TuningTarget, envelope: Envelope, pid: PidConfig, ceiling_mc: i32) -> Self {
|
||||
let config = PidConfig {
|
||||
out_min: f32::from(envelope.f_min_mhz),
|
||||
out_max: f32::from(envelope.f_max_mhz),
|
||||
..pid
|
||||
};
|
||||
let start = f32::from(envelope.f_min_mhz);
|
||||
Self {
|
||||
pid: Pid::new(config, start),
|
||||
envelope,
|
||||
target,
|
||||
ceiling_mc,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn frequency_mhz(&self) -> u16 {
|
||||
self.pid.output().round() as u16
|
||||
}
|
||||
|
||||
/// Fan duty implied by the target, if the target owns the fan.
|
||||
fn target_fan(&self) -> Option<u8> {
|
||||
match self.target {
|
||||
TuningTarget::MaxFan { max_pwm } => Some(max_pwm),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn command(&self) -> Command {
|
||||
Command {
|
||||
frequency_mhz: self.frequency_mhz(),
|
||||
fan_pwm: self.target_fan(),
|
||||
}
|
||||
}
|
||||
|
||||
/// One control period. Returns the command to apply, inside the envelope.
|
||||
pub fn step(&mut self, observation: Observation, dt_s: f32) -> Result<Command, TuningError> {
|
||||
// Thermal guard: a hot sensor always derates, whatever the target says.
|
||||
if let Some(hottest) = observation.hottest_mc {
|
||||
if hottest >= self.ceiling_mc {
|
||||
let derated = (self.pid.output() - 25.0).max(f32::from(self.envelope.f_min_mhz));
|
||||
self.pid = Pid::new(
|
||||
PidConfig {
|
||||
out_min: f32::from(self.envelope.f_min_mhz),
|
||||
out_max: f32::from(self.envelope.f_max_mhz),
|
||||
..self.pid.config
|
||||
},
|
||||
derated,
|
||||
);
|
||||
return Ok(self.command());
|
||||
}
|
||||
}
|
||||
match self.target {
|
||||
TuningTarget::PowerW(setpoint) => {
|
||||
let measurement = observation.power_w.ok_or(TuningError::NoMeasurement)?;
|
||||
self.pid.update(setpoint, measurement, dt_s);
|
||||
}
|
||||
TuningTarget::HashrateThs(setpoint) => {
|
||||
let measurement = observation.hashrate_ths.ok_or(TuningError::NoMeasurement)?;
|
||||
self.pid.update(setpoint, measurement, dt_s);
|
||||
}
|
||||
TuningTarget::AmbientC { margin_mc } => {
|
||||
let ambient = observation.ambient_mc.ok_or(TuningError::NoMeasurement)?;
|
||||
let hottest = observation.hottest_mc.ok_or(TuningError::NoMeasurement)?;
|
||||
let setpoint = ambient as f32 + margin_mc as f32;
|
||||
self.pid.update(setpoint, hottest as f32, dt_s);
|
||||
}
|
||||
TuningTarget::MaxFan { .. } => {
|
||||
// No setpoint loop here: ramp toward the envelope ceiling and let the thermal
|
||||
// guard be the only thing that stops it.
|
||||
let step = self.pid.config.max_step_per_s * dt_s;
|
||||
let next = (self.pid.output() + step).min(f32::from(self.envelope.f_max_mhz));
|
||||
self.pid.set_output(next);
|
||||
}
|
||||
}
|
||||
Ok(self.command())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn envelope() -> Envelope {
|
||||
Envelope {
|
||||
v_min_mv: 1100,
|
||||
v_max_mv: 1500,
|
||||
f_min_mhz: 300,
|
||||
f_max_mhz: 700,
|
||||
}
|
||||
}
|
||||
|
||||
fn observation(hottest: i32) -> Observation {
|
||||
Observation {
|
||||
power_w: None,
|
||||
hashrate_ths: None,
|
||||
hottest_mc: Some(hottest),
|
||||
ambient_mc: None,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pid_drives_the_plant_to_the_setpoint() {
|
||||
let mut pid = Pid::new(
|
||||
PidConfig {
|
||||
kp: 0.02,
|
||||
ki: 0.01,
|
||||
kd: 0.0,
|
||||
out_min: 0.0,
|
||||
out_max: 700.0,
|
||||
max_step_per_s: 1_000.0,
|
||||
deadband: 0.0,
|
||||
},
|
||||
0.0,
|
||||
);
|
||||
// Plant: 5 W per MHz, so 3 kW needs 600 MHz, inside the controller ceiling.
|
||||
let mut power = 0.0_f32;
|
||||
for _ in 0..400 {
|
||||
let freq = pid.update(3_000.0, power, 1.0);
|
||||
power = 5.0 * freq;
|
||||
}
|
||||
assert!((power - 3_000.0).abs() < 50.0, "power settled at {power}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn output_is_rate_limited() {
|
||||
let mut pid = Pid::new(
|
||||
PidConfig {
|
||||
kp: 1.0,
|
||||
ki: 0.0,
|
||||
kd: 0.0,
|
||||
out_min: 0.0,
|
||||
out_max: 1_000.0,
|
||||
max_step_per_s: 10.0,
|
||||
deadband: 0.0,
|
||||
},
|
||||
0.0,
|
||||
);
|
||||
assert!((pid.update(1_000.0, 0.0, 1.0) - 10.0).abs() < f32::EPSILON);
|
||||
assert!((pid.update(1_000.0, 0.0, 1.0) - 20.0).abs() < f32::EPSILON);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deadband_holds_the_output() {
|
||||
let mut pid = Pid::new(
|
||||
PidConfig {
|
||||
kp: 1.0,
|
||||
ki: 0.1,
|
||||
kd: 0.0,
|
||||
out_min: 0.0,
|
||||
out_max: 1_000.0,
|
||||
max_step_per_s: 100.0,
|
||||
deadband: 5.0,
|
||||
},
|
||||
100.0,
|
||||
);
|
||||
let before = pid.output();
|
||||
assert!((pid.update(102.0, 100.0, 1.0) - before).abs() < f32::EPSILON);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn saturation_does_not_wind_up_the_integral() {
|
||||
let mut pid = Pid::new(
|
||||
PidConfig {
|
||||
kp: 1.0,
|
||||
ki: 1.0,
|
||||
kd: 0.0,
|
||||
out_min: 0.0,
|
||||
out_max: 100.0,
|
||||
max_step_per_s: 1_000.0,
|
||||
deadband: 0.0,
|
||||
},
|
||||
0.0,
|
||||
);
|
||||
for _ in 0..100 {
|
||||
pid.update(1_000.0, 0.0, 1.0);
|
||||
}
|
||||
assert!((pid.output() - 100.0).abs() < 0.01);
|
||||
for _ in 0..5 {
|
||||
pid.update(0.0, 200.0, 1.0);
|
||||
}
|
||||
assert!(
|
||||
pid.output() < 99.0,
|
||||
"output stuck at the rail: {}",
|
||||
pid.output()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn power_target_moves_frequency_inside_the_envelope() {
|
||||
let mut loop_ = TuningLoop::new(
|
||||
TuningTarget::PowerW(2_400.0),
|
||||
envelope(),
|
||||
PidConfig {
|
||||
kp: 0.2,
|
||||
ki: 0.05,
|
||||
kd: 0.0,
|
||||
out_min: 0.0,
|
||||
out_max: 0.0,
|
||||
max_step_per_s: 50.0,
|
||||
deadband: 0.0,
|
||||
},
|
||||
95_000,
|
||||
);
|
||||
let mut freq = loop_.frequency_mhz();
|
||||
for _ in 0..100 {
|
||||
let power = 4.0 * f32::from(freq);
|
||||
let mut obs = observation(70_000);
|
||||
obs.power_w = Some(power);
|
||||
freq = loop_.step(obs, 1.0).expect("step").frequency_mhz;
|
||||
assert!((300..=700).contains(&freq), "out of envelope: {freq}");
|
||||
}
|
||||
let power = 4.0 * f32::from(freq);
|
||||
assert!((power - 2_400.0).abs() < 200.0, "power settled at {power}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn thermal_guard_derates_regardless_of_target() {
|
||||
let mut loop_ = TuningLoop::new(
|
||||
TuningTarget::HashrateThs(200.0),
|
||||
envelope(),
|
||||
PidConfig::default(),
|
||||
90_000,
|
||||
);
|
||||
for _ in 0..50 {
|
||||
let mut obs = observation(60_000);
|
||||
obs.hashrate_ths = Some(10.0);
|
||||
loop_.step(obs, 1.0).expect("step");
|
||||
}
|
||||
let hot = loop_.frequency_mhz();
|
||||
let mut obs = observation(91_000);
|
||||
obs.hashrate_ths = Some(10.0);
|
||||
let derated = loop_.step(obs, 1.0).expect("step").frequency_mhz;
|
||||
assert!(
|
||||
derated < hot,
|
||||
"thermal guard did not derate: {derated} vs {hot}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn missing_measurement_is_an_error() {
|
||||
let mut loop_ = TuningLoop::new(
|
||||
TuningTarget::PowerW(3_000.0),
|
||||
envelope(),
|
||||
PidConfig::default(),
|
||||
95_000,
|
||||
);
|
||||
let mut obs = observation(50_000);
|
||||
obs.hashrate_ths = Some(1.0);
|
||||
assert_eq!(loop_.step(obs, 1.0), Err(TuningError::NoMeasurement));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zero_dt_holds_the_output() {
|
||||
let mut pid = Pid::new(PidConfig::default(), 42.0);
|
||||
assert!((pid.update(100.0, 0.0, 0.0) - 42.0).abs() < f32::EPSILON);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ambient_target_holds_the_hottest_sensor_near_ambient_plus_margin() {
|
||||
let mut loop_ = TuningLoop::new(
|
||||
TuningTarget::AmbientC { margin_mc: 20_000 },
|
||||
envelope(),
|
||||
PidConfig {
|
||||
kp: 0.5,
|
||||
ki: 0.05,
|
||||
kd: 0.0,
|
||||
out_min: 0.0,
|
||||
out_max: 0.0,
|
||||
max_step_per_s: 50.0,
|
||||
deadband: 0.0,
|
||||
},
|
||||
200_000,
|
||||
);
|
||||
// Plant: hottest = ambient + 50 mC per MHz.
|
||||
let ambient = 40_000;
|
||||
let mut freq = loop_.frequency_mhz();
|
||||
for _ in 0..300 {
|
||||
let hottest = ambient + 50 * i32::from(freq);
|
||||
let obs = Observation {
|
||||
power_w: None,
|
||||
hashrate_ths: None,
|
||||
hottest_mc: Some(hottest),
|
||||
ambient_mc: Some(ambient),
|
||||
};
|
||||
freq = loop_.step(obs, 1.0).expect("step").frequency_mhz;
|
||||
}
|
||||
let hottest = ambient + 50 * i32::from(freq);
|
||||
assert!(
|
||||
(hottest - (ambient + 20_000)).abs() < 2_000,
|
||||
"hottest settled at {hottest}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ambient_target_needs_an_ambient_sensor() {
|
||||
let mut loop_ = TuningLoop::new(
|
||||
TuningTarget::AmbientC { margin_mc: 20_000 },
|
||||
envelope(),
|
||||
PidConfig::default(),
|
||||
95_000,
|
||||
);
|
||||
assert_eq!(
|
||||
loop_.step(observation(50_000), 1.0),
|
||||
Err(TuningError::NoMeasurement)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn max_fan_mode_pins_the_fan_and_ramps_frequency() {
|
||||
let ramp = PidConfig {
|
||||
kp: 1.0,
|
||||
ki: 0.0,
|
||||
kd: 0.0,
|
||||
out_min: 0.0,
|
||||
out_max: 0.0,
|
||||
max_step_per_s: 50.0,
|
||||
deadband: 0.0,
|
||||
};
|
||||
let mut loop_ = TuningLoop::new(
|
||||
TuningTarget::MaxFan { max_pwm: 100 },
|
||||
envelope(),
|
||||
ramp,
|
||||
120_000,
|
||||
);
|
||||
let start = loop_.frequency_mhz();
|
||||
let mut last = start;
|
||||
for _ in 0..20 {
|
||||
let command = loop_.step(observation(70_000), 1.0).expect("step");
|
||||
assert_eq!(command.fan_pwm, Some(100));
|
||||
last = command.frequency_mhz;
|
||||
}
|
||||
assert!(last > start, "frequency did not ramp: {last} vs {start}");
|
||||
assert!(
|
||||
last == 700,
|
||||
"ramp did not reach the envelope ceiling: {last}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn max_fan_mode_still_respects_the_temperature_ceiling() {
|
||||
let mut loop_ = TuningLoop::new(
|
||||
TuningTarget::MaxFan { max_pwm: 100 },
|
||||
envelope(),
|
||||
PidConfig::default(),
|
||||
80_000,
|
||||
);
|
||||
for _ in 0..50 {
|
||||
loop_.step(observation(70_000), 1.0).expect("step");
|
||||
}
|
||||
let hot = loop_.frequency_mhz();
|
||||
let command = loop_.step(observation(85_000), 1.0).expect("step");
|
||||
assert!(command.frequency_mhz < hot);
|
||||
assert_eq!(command.fan_pwm, Some(100));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,736 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! On-box web UI: navigation, pages, and the editable dashboard document.
|
||||
//!
|
||||
//! The shape follows the Warden/FLARE console: a fixed sidebar of groups and
|
||||
//! items, hash-routed pages, and dashboards that are a JSON document an operator
|
||||
//! edits in place. The document is stored on the box, has a default template per
|
||||
//! deck, and is capped server-side so a bad save cannot grow without bound.
|
||||
//!
|
||||
//! The JSON API remains the interface of record: every value the pages show is
|
||||
//! also available at an `/api/...` route, and the page never becomes the only
|
||||
//! way to see or change the machine.
|
||||
|
||||
use serde_json::{json, Value};
|
||||
|
||||
/// Blocks a dashboard may hold. Docker rows count too, so a tidy layout cannot
|
||||
/// cost an operator a widget.
|
||||
pub const BLOCK_CAP: usize = 32;
|
||||
/// Characters allowed in a dashboard name.
|
||||
pub const NAME_MAX: usize = 120;
|
||||
|
||||
/// One navigable destination.
|
||||
pub struct Item {
|
||||
pub path: &'static str,
|
||||
pub label: &'static str,
|
||||
}
|
||||
|
||||
/// A sidebar group.
|
||||
pub struct Group {
|
||||
pub label: &'static str,
|
||||
pub items: &'static [Item],
|
||||
}
|
||||
|
||||
const DASHBOARD: [Item; 1] = [Item {
|
||||
path: "/",
|
||||
label: "Dashboard",
|
||||
}];
|
||||
const MINING: [Item; 4] = [
|
||||
Item {
|
||||
path: "/mining",
|
||||
label: "Overview",
|
||||
},
|
||||
Item {
|
||||
path: "/mining/hashboards",
|
||||
label: "Hashboards",
|
||||
},
|
||||
Item {
|
||||
path: "/mining/power",
|
||||
label: "Power Supply",
|
||||
},
|
||||
Item {
|
||||
path: "/mining/fans",
|
||||
label: "Fans",
|
||||
},
|
||||
];
|
||||
const SETTINGS: [Item; 8] = [
|
||||
Item {
|
||||
path: "/settings/system",
|
||||
label: "System",
|
||||
},
|
||||
Item {
|
||||
path: "/settings/drivers",
|
||||
label: "Drivers",
|
||||
},
|
||||
Item {
|
||||
path: "/settings/security",
|
||||
label: "Security",
|
||||
},
|
||||
Item {
|
||||
path: "/settings/services",
|
||||
label: "Services",
|
||||
},
|
||||
Item {
|
||||
path: "/settings/monitor",
|
||||
label: "Monitor",
|
||||
},
|
||||
Item {
|
||||
path: "/settings/logs",
|
||||
label: "Logs",
|
||||
},
|
||||
Item {
|
||||
path: "/settings/files",
|
||||
label: "Files",
|
||||
},
|
||||
Item {
|
||||
path: "/settings/terminal",
|
||||
label: "Terminal",
|
||||
},
|
||||
];
|
||||
|
||||
pub const NAV: [Group; 3] = [
|
||||
Group {
|
||||
label: "Overview",
|
||||
items: &DASHBOARD,
|
||||
},
|
||||
Group {
|
||||
label: "Mining",
|
||||
items: &MINING,
|
||||
},
|
||||
Group {
|
||||
label: "Settings",
|
||||
items: &SETTINGS,
|
||||
},
|
||||
];
|
||||
|
||||
/// The dashboard a deck starts with. Every deck has one, so a fresh box is never
|
||||
/// an empty page.
|
||||
pub fn default_deck(deck: &str) -> Value {
|
||||
match deck {
|
||||
"overview" => json!({
|
||||
"version": 1,
|
||||
"name": "Mining overview",
|
||||
"blocks": [
|
||||
{"id": "status", "kind": "status", "span": 1, "title": "State", "source": "status"},
|
||||
{"id": "accepted", "kind": "metric", "span": 1, "title": "Accepted", "source": "accepted", "unit": "shares"},
|
||||
{"id": "rejected", "kind": "metric", "span": 1, "title": "Rejected", "source": "rejected", "unit": "shares"},
|
||||
{"id": "elapsed", "kind": "metric", "span": 1, "title": "Uptime", "source": "elapsed", "unit": "s"},
|
||||
{"id": "chains", "kind": "metric", "span": 1, "title": "Active chains", "source": "active_chains", "unit": ""},
|
||||
{"id": "frequency", "kind": "metric", "span": 1, "title": "Frequency", "source": "frequency", "unit": "MHz"},
|
||||
{"id": "voltage", "kind": "metric", "span": 1, "title": "Voltage", "source": "voltage", "unit": "mV"},
|
||||
{"id": "target", "kind": "metric", "span": 1, "title": "Target", "source": "target", "unit": ""},
|
||||
{"id": "chains_table", "kind": "table", "span": 4, "title": "Hashboards", "source": "chains"}
|
||||
]
|
||||
}),
|
||||
_ => json!({
|
||||
"version": 1,
|
||||
"name": "Dashboard",
|
||||
"blocks": [
|
||||
{"id": "status", "kind": "status", "span": 2, "title": "Miner", "source": "status"},
|
||||
{"id": "accepted", "kind": "metric", "span": 1, "title": "Accepted", "source": "accepted", "unit": "shares"},
|
||||
{"id": "rejected", "kind": "metric", "span": 1, "title": "Rejected", "source": "rejected", "unit": "shares"},
|
||||
{"id": "hardware", "kind": "kv", "span": 2, "title": "Hardware", "source": "hardware"},
|
||||
{"id": "fans", "kind": "table", "span": 2, "title": "Fan map", "source": "fans"}
|
||||
]
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
/// Validate a dashboard document the client wants to store.
|
||||
///
|
||||
/// Returns the parsed document, or a sentence naming the rule that failed. The
|
||||
/// rules are the same ones the page enforces, so a save that the UI allowed is
|
||||
/// never rejected here for a reason the operator cannot see.
|
||||
pub fn validate_deck(text: &str) -> Result<Value, String> {
|
||||
let doc: Value =
|
||||
serde_json::from_str(text).map_err(|_| "document is not valid JSON".to_string())?;
|
||||
let object = doc.as_object().ok_or("document must be an object")?;
|
||||
let version = object
|
||||
.get("version")
|
||||
.and_then(Value::as_u64)
|
||||
.ok_or("version must be a number")?;
|
||||
if version != 1 {
|
||||
return Err(format!("unsupported version {version}"));
|
||||
}
|
||||
if let Some(name) = object.get("name") {
|
||||
let name = name.as_str().ok_or("name must be a string")?;
|
||||
if name.chars().count() > NAME_MAX {
|
||||
return Err(format!("name is longer than {NAME_MAX} characters"));
|
||||
}
|
||||
}
|
||||
let blocks = object
|
||||
.get("blocks")
|
||||
.and_then(Value::as_array)
|
||||
.ok_or("blocks must be a list")?;
|
||||
if blocks.len() > BLOCK_CAP {
|
||||
return Err(format!("more than {BLOCK_CAP} blocks"));
|
||||
}
|
||||
for block in blocks {
|
||||
let block = block.as_object().ok_or("each block must be an object")?;
|
||||
let id = block
|
||||
.get("id")
|
||||
.and_then(Value::as_str)
|
||||
.ok_or("block id must be a string")?;
|
||||
if id.is_empty() || id.len() > 64 {
|
||||
return Err("block id must be 1..=64 characters".to_string());
|
||||
}
|
||||
let kind = block
|
||||
.get("kind")
|
||||
.and_then(Value::as_str)
|
||||
.ok_or("block kind must be a string")?;
|
||||
if !["metric", "status", "kv", "table", "text"].contains(&kind) {
|
||||
return Err(format!("unknown block kind {kind}"));
|
||||
}
|
||||
let span = block.get("span").and_then(Value::as_u64).unwrap_or(1);
|
||||
if !(1..=4).contains(&span) {
|
||||
return Err("block span must be 1..=4".to_string());
|
||||
}
|
||||
}
|
||||
Ok(doc)
|
||||
}
|
||||
|
||||
/// Render one page inside the shell.
|
||||
///
|
||||
/// The rail follows the FLARE/Warden console: a 232px navy column with a 44px
|
||||
/// head, one native `<details>` per group so the tree opens and closes with no
|
||||
/// script, and the current page marked with `aria-current` rather than a class
|
||||
/// alone. Below 901px it slides off-canvas and comes back as a `:target`
|
||||
/// fragment, which is the one disclosure a locked-down page can still use.
|
||||
pub fn page(active: &str, title: &str, body: &str) -> String {
|
||||
format!(
|
||||
"<!doctype html>\n<html lang=\"en\"><head><meta charset=\"utf-8\">\
|
||||
<meta name=\"viewport\" content=\"width=device-width,initial-scale=1\">\
|
||||
<title>{title} - Alkane</title><style>{CSS}</style></head>\
|
||||
<body class=\"shell\"><aside class=\"rail\" id=\"rail\">{rail_head}{nav}</aside><div class=\"rail-backdrop\" id=\"rail-backdrop\"></div>\
|
||||
<main class=\"content\"><header class=\"appbar\">\
|
||||
<a class=\"appbar__menu\" href=\"#rail\" aria-label=\"Open menu\">Menu</a>\
|
||||
<h1 class=\"page-title\">{title}</h1><span id=\"live\" class=\"pill\">connecting</span></header>\
|
||||
<div class=\"frame\">{body}</div></main>\
|
||||
<script>{JS}</script></body></html>",
|
||||
title = escape(title),
|
||||
rail_head = rail_head(),
|
||||
nav = sidebar(active),
|
||||
)
|
||||
}
|
||||
|
||||
fn rail_head() -> String {
|
||||
"<div class=\"rail__head\"><span class=\"rail__brand\">Alkane</span>\
|
||||
<button class=\"rail__toggle\" type=\"button\" aria-label=\"Collapse sidebar\" title=\"Collapse sidebar\">☰</button>\
|
||||
<a class=\"rail__close\" href=\"#\" aria-label=\"Close menu\" title=\"Close menu\">✕</a></div>"
|
||||
.to_string()
|
||||
}
|
||||
|
||||
/// An 18px stroke icon for a destination, matching the rail's icon column.
|
||||
fn icon(path: &str) -> &'static str {
|
||||
let body = match path {
|
||||
"/" => "<rect x=\"3\" y=\"3\" width=\"7\" height=\"7\" rx=\"1\"/><rect x=\"14\" y=\"3\" width=\"7\" height=\"7\" rx=\"1\"/><rect x=\"3\" y=\"14\" width=\"7\" height=\"7\" rx=\"1\"/><rect x=\"14\" y=\"14\" width=\"7\" height=\"7\" rx=\"1\"/>",
|
||||
"/mining" => "<path d=\"M4 20V10M10 20V4M16 20v-7M22 20H2\"/>",
|
||||
"/mining/hashboards" => "<rect x=\"5\" y=\"5\" width=\"14\" height=\"14\" rx=\"2\"/><path d=\"M9 2v3M15 2v3M9 19v3M15 19v3M2 9h3M2 15h3M19 9h3M19 15h3\"/>",
|
||||
"/mining/power" => "<path d=\"M13 2 4 14h7l-1 8 9-12h-7z\"/>",
|
||||
"/mining/fans" => "<circle cx=\"12\" cy=\"12\" r=\"2\"/><path d=\"M12 10c0-4 1-7 4-7 2 0 3 2 3 4 0 3-3 5-7 5M14 12c4 0 7 1 7 4 0 2-2 3-4 3-3 0-5-3-5-7M12 14c0 4-1 7-4 7-2 0-3-2-3-4 0-3 3-5 7-5M10 12c-4 0-7-1-7-4 0-2 2-3 4-3 3 0 5 3 5 7\"/>",
|
||||
"/settings/system" => "<rect x=\"3\" y=\"4\" width=\"18\" height=\"6\" rx=\"1\"/><rect x=\"3\" y=\"14\" width=\"18\" height=\"6\" rx=\"1\"/><path d=\"M7 7h.01M7 17h.01\"/>",
|
||||
"/settings/drivers" => "<rect x=\"4\" y=\"4\" width=\"16\" height=\"16\" rx=\"2\"/><path d=\"M9 9h6v6H9z\"/>",
|
||||
"/settings/security" => "<rect x=\"4\" y=\"10\" width=\"16\" height=\"10\" rx=\"2\"/><path d=\"M8 10V7a4 4 0 0 1 8 0v3\"/>",
|
||||
"/settings/services" => "<circle cx=\"12\" cy=\"12\" r=\"9\"/><path d=\"M10 8l6 4-6 4z\"/>",
|
||||
"/settings/monitor" => "<path d=\"M2 12h4l3-8 4 16 3-8h6\"/>",
|
||||
"/settings/logs" => "<path d=\"M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z\"/><path d=\"M14 2v6h6M8 13h8M8 17h5\"/>",
|
||||
"/settings/files" => "<path d=\"M3 7a2 2 0 0 1 2-2h5l2 2h7a2 2 0 0 1 2 2v9a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z\"/>",
|
||||
"/settings/terminal" => "<rect x=\"3\" y=\"4\" width=\"18\" height=\"16\" rx=\"2\"/><path d=\"M7 9l3 3-3 3M13 15h4\"/>",
|
||||
_ => "<circle cx=\"12\" cy=\"12\" r=\"9\"/>",
|
||||
};
|
||||
// The strings above are static markup, never user input.
|
||||
let html = format!(
|
||||
"<svg class=\"rail__icon\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" \
|
||||
stroke-width=\"1.7\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\">{body}</svg>"
|
||||
);
|
||||
Box::leak(html.into_boxed_str())
|
||||
}
|
||||
|
||||
fn group_icon_svg(label: &str) -> &'static str {
|
||||
let body = match label {
|
||||
"Mining" => "<rect x=\"5\" y=\"5\" width=\"14\" height=\"14\" rx=\"2\"/><path d=\"M9 2v3M15 2v3M9 19v3M15 19v3M2 9h3M2 15h3M19 9h3M19 15h3\"/>",
|
||||
"Settings" => "<circle cx=\"12\" cy=\"12\" r=\"3\"/><path d=\"M19.4 15a1.7 1.7 0 0 0 .3 1.9l.1.1a2 2 0 1 1-2.8 2.8l-.1-.1a1.7 1.7 0 0 0-1.9-.3 1.7 1.7 0 0 0-1 1.5V21a2 2 0 1 1-4 0v-.1a1.7 1.7 0 0 0-1.1-1.5 1.7 1.7 0 0 0-1.9.3l-.1.1a2 2 0 1 1-2.8-2.8l.1-.1a1.7 1.7 0 0 0 .3-1.9 1.7 1.7 0 0 0-1.5-1H3a2 2 0 1 1 0-4h.1A1.7 1.7 0 0 0 4.6 9a1.7 1.7 0 0 0-.3-1.9l-.1-.1a2 2 0 1 1 2.8-2.8l.1.1a1.7 1.7 0 0 0 1.9.3H9a1.7 1.7 0 0 0 1-1.5V3a2 2 0 1 1 4 0v.1a1.7 1.7 0 0 0 1 1.5 1.7 1.7 0 0 0 1.9-.3l.1-.1a2 2 0 1 1 2.8 2.8l-.1.1a1.7 1.7 0 0 0-.3 1.9V9a1.7 1.7 0 0 0 1.5 1H21a2 2 0 1 1 0 4h-.1a1.7 1.7 0 0 0-1.5 1z\"/>",
|
||||
_ => "",
|
||||
};
|
||||
if body.is_empty() {
|
||||
return "";
|
||||
}
|
||||
let html = format!(
|
||||
"<svg class=\"rail__icon\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" \
|
||||
stroke-width=\"1.7\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\">{body}</svg>"
|
||||
);
|
||||
Box::leak(html.into_boxed_str())
|
||||
}
|
||||
|
||||
fn sidebar(active: &str) -> String {
|
||||
let mut out = String::from("<nav class=\"rail__nav\">");
|
||||
let mut first = true;
|
||||
for group in NAV.iter() {
|
||||
// A one-item group is a plain link, exactly as the FLARE rail renders
|
||||
// Dashboard: a disclosure around a single leaf is a control that only
|
||||
// hides the thing it names.
|
||||
if group.items.len() == 1 {
|
||||
let item = &group.items[0];
|
||||
out.push_str(&rail_link(item, active, "rail__link"));
|
||||
} else {
|
||||
let open = group.items.iter().any(|item| item.path == active);
|
||||
out.push_str(&format!(
|
||||
"<details class=\"tree\"{open}>\
|
||||
<summary class=\"rail__link tree__summary\">{icon}<span class=\"rail__label\">{label}</span><span class=\"rail__chevron\" aria-hidden=\"true\"></span></summary>\
|
||||
<ul class=\"tree__list\">",
|
||||
open = if open { " open" } else { "" },
|
||||
label = escape(group.label),
|
||||
icon = group_icon_svg(group.label),
|
||||
));
|
||||
for item in group.items {
|
||||
out.push_str(&rail_link(item, active, "rail__link tree__leaf"));
|
||||
}
|
||||
out.push_str("</ul></details>");
|
||||
}
|
||||
first = false;
|
||||
}
|
||||
let _ = first;
|
||||
out.push_str("</nav>");
|
||||
out
|
||||
}
|
||||
|
||||
fn rail_link(item: &Item, active: &str, class: &str) -> String {
|
||||
let current = if item.path == active {
|
||||
" aria-current=\"page\""
|
||||
} else {
|
||||
""
|
||||
};
|
||||
format!(
|
||||
"<a class=\"{class}\" href=\"#{path}\"{current}>{icon}<span class=\"rail__label\">{label}</span></a>",
|
||||
class = class,
|
||||
path = item.path,
|
||||
label = escape(item.label),
|
||||
icon = icon(item.path),
|
||||
)
|
||||
}
|
||||
|
||||
/// A dashboard page: the editor chrome plus the document the client loads.
|
||||
pub fn dashboard_page(deck: &str, editable: bool) -> String {
|
||||
let deck = escape(deck);
|
||||
format!(
|
||||
"<div class=\"bar\">\
|
||||
<label>Template <select id=\"deck-name\"></select></label>\
|
||||
<button id=\"save\"{disabled}>Save</button>\
|
||||
<button id=\"reset\"{disabled}>Reset to template</button>\
|
||||
<button id=\"add\"{disabled}>Add block</button>\
|
||||
<span id=\"edit-msg\" class=\"muted\"></span></div>\
|
||||
<div id=\"grid\" class=\"grid\" data-deck=\"{deck}\" data-editable=\"{editable}\"></div>",
|
||||
disabled = if editable { "" } else { " disabled" },
|
||||
editable = if editable { "1" } else { "0" },
|
||||
)
|
||||
}
|
||||
|
||||
/// Escape text for HTML. Every user-visible string goes through this.
|
||||
pub fn escape(text: &str) -> String {
|
||||
let mut out = String::with_capacity(text.len());
|
||||
for ch in text.chars() {
|
||||
match ch {
|
||||
'&' => out.push_str("&"),
|
||||
'<' => out.push_str("<"),
|
||||
'>' => out.push_str(">"),
|
||||
'"' => out.push_str("""),
|
||||
'\'' => out.push_str("'"),
|
||||
other => out.push(other),
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// A definition-list page for key/value data (settings pages).
|
||||
pub fn kv_page(rows: &[(&str, String)]) -> String {
|
||||
let mut out = String::from("<table class=\"kv\"><tbody>");
|
||||
for (key, value) in rows {
|
||||
out.push_str(&format!(
|
||||
"<tr><th>{}</th><td>{}</td></tr>",
|
||||
escape(key),
|
||||
escape(value)
|
||||
));
|
||||
}
|
||||
out.push_str("</tbody></table>");
|
||||
out
|
||||
}
|
||||
|
||||
/// Several titled sections in one page: the settings pages' shape in the
|
||||
/// Warden console, where each group (Identity, Network, ...) is its own block.
|
||||
pub fn sections_page(sections: &[(&str, String)]) -> String {
|
||||
let mut out = String::new();
|
||||
for (title, body) in sections {
|
||||
out.push_str(&format!(
|
||||
"<section class=\"section\"><h2 class=\"section__title\">{}</h2>{}</section>",
|
||||
escape(title),
|
||||
body
|
||||
));
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// A table page with a header row.
|
||||
pub fn table_page(headers: &[&str], rows: &[Vec<String>]) -> String {
|
||||
let mut out = String::from("<table><thead><tr>");
|
||||
for header in headers {
|
||||
out.push_str(&format!("<th>{}</th>", escape(header)));
|
||||
}
|
||||
out.push_str("</tr></thead><tbody>");
|
||||
for row in rows {
|
||||
out.push_str("<tr>");
|
||||
for cell in row {
|
||||
out.push_str(&format!("<td>{}</td>", escape(cell)));
|
||||
}
|
||||
out.push_str("</tr>");
|
||||
}
|
||||
if rows.is_empty() {
|
||||
out.push_str(&format!(
|
||||
"<tr><td colspan=\"{}\" class=\"muted\">nothing to show</td></tr>",
|
||||
headers.len().max(1)
|
||||
));
|
||||
}
|
||||
out.push_str("</tbody></table>");
|
||||
out
|
||||
}
|
||||
|
||||
const CSS: &str = r#"
|
||||
:root{
|
||||
color-scheme:dark;
|
||||
/* FLARE tokens: navy scale, cyan action, the same steps portal.css uses. */
|
||||
--navy-900:#070D1D; --navy-800:#0B1020; --navy-700:#192858; --navy-600:#1E4E90;
|
||||
--cyan-400:#3ABCF8; --cyan-500:#31A2D6; --orange-500:#F26522;
|
||||
--text:#FFFFFF; --text-muted:#BABABA;
|
||||
--border:#192858;
|
||||
--space-1:4px; --space-2:8px; --space-3:12px; --space-4:16px; --space-6:24px;
|
||||
--font-display:'Creato Display','Sora','Segoe UI','Selawik',system-ui,-apple-system,sans-serif;
|
||||
--font-body:'Segoe UI','Selawik',system-ui,-apple-system,sans-serif;
|
||||
--text-xs:12px; --text-sm:14px; --text-base:16px;
|
||||
}
|
||||
*{box-sizing:border-box}
|
||||
body.shell{margin:0;display:flex;min-height:100vh;background:var(--navy-900);color:var(--text);
|
||||
font:var(--text-sm)/1.45 var(--font-body)}
|
||||
a{color:var(--cyan-400);text-decoration:none}
|
||||
:focus-visible{outline:2px solid var(--cyan-400);outline-offset:2px}
|
||||
|
||||
/* --- rail: the Warden console's sidebar ------------------------------- */
|
||||
.rail{flex:none;width:232px;background:var(--navy-700);border-right:1px solid #1E2A4E;
|
||||
display:flex;flex-direction:column;position:sticky;top:0;height:100vh;overflow-y:auto;
|
||||
overscroll-behavior:contain}
|
||||
.rail__head{display:flex;align-items:center;gap:var(--space-2);min-height:44px;
|
||||
padding:0 var(--space-3);border-bottom:1px solid #1E2A4E}
|
||||
.rail__brand{font-family:var(--font-display);font-weight:700;font-size:var(--text-base);
|
||||
letter-spacing:.02em}
|
||||
.rail__nav{padding:var(--space-2) 0;display:flex;flex-direction:column}
|
||||
.rail__link{display:flex;align-items:center;gap:var(--space-3);min-height:36px;
|
||||
padding:var(--space-2) var(--space-4);color:#E6ECF5;font-size:var(--text-sm);font-weight:600;
|
||||
border-left:2px solid transparent;min-width:0}
|
||||
.rail__link:hover{background:rgba(255,255,255,.06)}
|
||||
.rail__link[aria-current='page']{border-left-color:var(--cyan-400);color:var(--cyan-400);
|
||||
background:rgba(255,255,255,.06)}
|
||||
.tree>summary{list-style:none;cursor:pointer}
|
||||
.tree>summary::-webkit-details-marker{display:none}
|
||||
.rail__chevron{margin-left:auto;width:0;height:0;border-left:4px solid transparent;
|
||||
border-right:4px solid transparent;border-top:5px solid #9AA5BB}
|
||||
.tree[open]>summary .rail__chevron{transform:rotate(180deg)}
|
||||
.tree__list{list-style:none;margin:0;padding:0}
|
||||
.tree__leaf{font-weight:400;color:#9AA5BB;min-height:32px;
|
||||
padding-left:calc(var(--space-4) + var(--space-3))}
|
||||
.tree__leaf:hover{color:#E6ECF5}
|
||||
.tree__leaf[aria-current='page']{color:var(--cyan-400);font-weight:600}
|
||||
.rail a:focus-visible,.rail summary:focus-visible{outline-offset:-2px}
|
||||
.rail__icon{width:18px;height:18px;flex:none}
|
||||
.rail__label{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
|
||||
.rail__toggle{margin-left:auto;background:transparent;border:0;color:#9AA5BB;cursor:pointer;
|
||||
padding:4px;font-size:14px;line-height:1}
|
||||
.rail__toggle:hover{color:#E6ECF5}
|
||||
|
||||
/* Collapsed: icons only, and only where the rail is docked. Labels are clipped
|
||||
rather than removed so they keep their accessible name. */
|
||||
@media (min-width:901px){
|
||||
.shell--collapsed .rail{width:41px}
|
||||
.shell--collapsed .rail__label,
|
||||
.shell--collapsed .rail__brand{position:absolute;width:1px;height:1px;overflow:hidden;
|
||||
clip-path:inset(50%);white-space:nowrap}
|
||||
.shell--collapsed .tree__list,
|
||||
.shell--collapsed .rail__chevron{display:none}
|
||||
.shell--collapsed .rail__link{justify-content:center;padding-left:0;padding-right:2px}
|
||||
.shell--collapsed .rail__head{justify-content:center;padding-inline:0}
|
||||
}
|
||||
|
||||
/* --- content column ---------------------------------------------------- */
|
||||
.content{flex:1;min-width:0;display:flex;flex-direction:column}
|
||||
.appbar{display:flex;align-items:center;gap:var(--space-4);min-height:44px;
|
||||
padding:0 var(--space-6);border-bottom:1px solid var(--border);
|
||||
position:sticky;top:0;z-index:40;background:var(--navy-900)}
|
||||
.page-title{font-family:var(--font-display);font-size:22px;font-weight:700;line-height:1.1;
|
||||
margin:0;letter-spacing:-.01em}
|
||||
.appbar__menu{display:none;font-size:var(--text-sm);color:var(--cyan-400)}
|
||||
.pill{border-radius:0;margin-left:auto;font-size:var(--text-xs);padding:3px 9px;
|
||||
background:var(--navy-800);color:var(--text-muted);border:1px solid var(--border)}
|
||||
.pill.ok{color:#7EE787;border-color:#1F4D2C}
|
||||
.pill.bad{color:#FF9B9B;border-color:#552323}
|
||||
.frame{padding:var(--space-6);display:flex;flex-direction:column;gap:var(--space-6)}
|
||||
|
||||
/* --- blocks ------------------------------------------------------------ */
|
||||
.bar{display:flex;gap:var(--space-3);align-items:center;flex-wrap:wrap}
|
||||
h2,.card h2{font-family:var(--font-display);font-size:11px;font-weight:600;line-height:1.15;
|
||||
text-transform:uppercase;letter-spacing:2px;color:var(--text-muted);margin:0 0 var(--space-2)}
|
||||
button{border-radius:0;font:inherit;cursor:pointer;padding:7px 12px;
|
||||
background:var(--navy-700);color:var(--text);border:1px solid #1E2A4E}
|
||||
button:hover:not(:disabled){background:var(--navy-600)}
|
||||
button:disabled{opacity:.4;cursor:default}
|
||||
select,input[type=text]{border-radius:0;font:inherit;color:var(--text);background:var(--navy-900);
|
||||
border:1px solid #1E2A4E;padding:6px 8px}
|
||||
input[type=text]{min-width:320px;padding:8px 10px}
|
||||
.grid{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:var(--space-4)}
|
||||
.card{background:var(--navy-800);border:1px solid var(--border);border-radius:0;
|
||||
padding:var(--space-4);min-height:96px}
|
||||
.card.drag{outline:1px dashed var(--cyan-400);outline-offset:2px}
|
||||
.card .big{font-family:var(--font-display);font-size:28px;font-weight:700;letter-spacing:-.5px}
|
||||
.card .unit{font-size:var(--text-xs);color:var(--text-muted);margin-left:var(--space-1)}
|
||||
.span2{grid-column:span 2}.span3{grid-column:span 3}.span4{grid-column:span 4}
|
||||
table{width:100%;border-collapse:collapse;font-size:var(--text-sm)}
|
||||
th,td{text-align:left;padding:8px 10px;border-bottom:1px solid #14203C}
|
||||
th{font-family:var(--font-display);font-size:11px;font-weight:600;text-transform:uppercase;
|
||||
letter-spacing:2px;color:var(--text-muted)}
|
||||
table.kv th{width:220px;color:var(--text-muted);font-weight:600;text-transform:none;
|
||||
letter-spacing:0;font-family:var(--font-body);font-size:var(--text-sm)}
|
||||
.muted{color:var(--text-muted)}
|
||||
.section{display:flex;flex-direction:column;gap:var(--space-2)}
|
||||
.section__title{font-family:var(--font-display);font-size:11px;font-weight:600;line-height:1.15;
|
||||
text-transform:uppercase;letter-spacing:2px;color:var(--text-muted);margin:0;
|
||||
padding-bottom:var(--space-2);border-bottom:1px solid var(--border)}
|
||||
pre{background:var(--navy-900);border:1px solid var(--border);border-radius:0;
|
||||
padding:var(--space-4);overflow:auto;max-height:60vh;
|
||||
font:12px/1.5 ui-monospace,SFMono-Regular,Menlo,monospace}
|
||||
|
||||
/* Off-canvas below 901px, reopened by the fragment so it works without a
|
||||
script, exactly as portal.css does it. */
|
||||
.rail__close{display:none;margin-left:var(--space-2);background:transparent;border:0;
|
||||
color:#9AA5BB;font-size:16px;line-height:1;padding:6px;cursor:pointer}
|
||||
.rail__close:hover{color:#E6ECF5}
|
||||
.rail-backdrop{display:none}
|
||||
|
||||
@media (max-width:900px){
|
||||
.shell{display:block}
|
||||
/* Full-screen drawer, as the design's mobile menu: page background, its own
|
||||
top bar with the brand and a close, rows split by 1px dividers. */
|
||||
.rail{position:fixed;inset:0;width:100%;max-width:none;transform:translateX(-100%);
|
||||
z-index:60;background:var(--navy-900);border-right:0}
|
||||
.rail:target{transform:none}
|
||||
body.drawer-open .rail{transform:none}
|
||||
body.drawer-open{overflow:hidden}
|
||||
body.drawer-open .rail-backdrop{display:block;position:fixed;inset:0;background:rgba(0,0,0,.6);z-index:55}
|
||||
.rail__head{min-height:56px;padding:0 var(--space-4);border-bottom:1px solid var(--border)}
|
||||
.rail__brand{font-size:18px}
|
||||
.rail__toggle{display:none}
|
||||
.rail__close{display:inline-flex}
|
||||
.rail__link{padding:var(--space-4);border-bottom:1px solid var(--border);border-left:0}
|
||||
.rail__link[aria-current='page']{border-left:0;background:rgba(255,255,255,.06)}
|
||||
.tree__leaf{padding:var(--space-4) var(--space-4) var(--space-4) calc(var(--space-4) * 2);min-height:48px}
|
||||
.appbar__menu{display:inline-flex}
|
||||
.appbar{padding:0 var(--space-4)}
|
||||
.frame{padding:var(--space-4)}
|
||||
.grid{grid-template-columns:1fr}
|
||||
.span2,.span3,.span4{grid-column:span 1}
|
||||
}
|
||||
"#;
|
||||
|
||||
const JS: &str = r#"
|
||||
(function(){
|
||||
"use strict";
|
||||
function $(id){return document.getElementById(id)}
|
||||
function esc(s){return String(s).replace(/[&<>"']/g,function(c){return {'&':'&','<':'<','>':'>','"':'"',"'":'''}[c]})}
|
||||
function route(){var p=location.hash.slice(1)||"/";return p}
|
||||
function go(){location.hash=route()}
|
||||
// Live status pill: the page is a convenience over the JSON API.
|
||||
function poll(){fetch("/api/summary").then(function(r){return r.json()}).then(function(d){
|
||||
var el=$("live"); if(!el)return; var m=(d.miner||d); el.textContent=(m.state||"up"); el.className="pill ok";
|
||||
}).catch(function(){var el=$("live"); if(el){el.textContent="offline"; el.className="pill bad"}})}
|
||||
setInterval(poll,5000); poll();
|
||||
|
||||
// Mobile drawer. The rail is full-screen below 901px; Menu opens it and the
|
||||
// close control, the backdrop or Escape puts it away. Without a script the
|
||||
// :target fragment still opens it, which is why the Menu link is an anchor.
|
||||
(function(){
|
||||
var body=document.body;
|
||||
var menu=document.querySelector(".appbar__menu");
|
||||
var close=document.querySelector(".rail__close");
|
||||
var backdrop=document.getElementById("rail-backdrop");
|
||||
function open(){body.classList.add("drawer-open")}
|
||||
function shut(){body.classList.remove("drawer-open")}
|
||||
if(menu)menu.addEventListener("click",function(e){e.preventDefault();open()});
|
||||
if(close)close.addEventListener("click",function(e){e.preventDefault();shut()});
|
||||
if(backdrop)backdrop.addEventListener("click",shut);
|
||||
document.addEventListener("keydown",function(e){if(e.key==="Escape")shut()});
|
||||
document.querySelectorAll(".rail__link").forEach(function(link){
|
||||
link.addEventListener("click",function(){shut()});
|
||||
});
|
||||
})();
|
||||
|
||||
// Rail collapse. The state is remembered so a reload keeps the operator's
|
||||
// choice; the button is the only control that needs a script.
|
||||
(function(){
|
||||
var key="alkane.rail.collapsed";
|
||||
try{if(localStorage.getItem(key)==="1")document.body.classList.add("shell--collapsed")}catch(e){}
|
||||
var toggle=document.querySelector(".rail__toggle");
|
||||
if(toggle)toggle.addEventListener("click",function(){
|
||||
var on=document.body.classList.toggle("shell--collapsed");
|
||||
try{localStorage.setItem(key,on?"1":"0")}catch(e){}
|
||||
});
|
||||
})();
|
||||
|
||||
var grid=$("grid");
|
||||
if(grid){
|
||||
var deck=grid.dataset.deck, editable=grid.dataset.editable==="1", doc=null, dragId=null;
|
||||
var METRICS={hashrate:["TH/s",1],power_w:["W",1],chains:["",0],chip_temp_c:["C",0],fans:["",0]};
|
||||
function render(){
|
||||
grid.innerHTML="";
|
||||
(doc.blocks||[]).forEach(function(b){
|
||||
var card=document.createElement("div");
|
||||
card.className="card span"+(b.span||1);
|
||||
card.draggable=editable;
|
||||
card.addEventListener("dragstart",function(){dragId=b.id;card.classList.add("drag")});
|
||||
card.addEventListener("dragend",function(){card.classList.remove("drag")});
|
||||
card.addEventListener("dragover",function(e){e.preventDefault()});
|
||||
card.addEventListener("drop",function(e){e.preventDefault(); if(!dragId||dragId===b.id)return;
|
||||
var from=doc.blocks.findIndex(function(x){return x.id===dragId});
|
||||
var to=doc.blocks.findIndex(function(x){return x.id===b.id});
|
||||
if(from<0||to<0)return; var moved=doc.blocks.splice(from,1)[0]; doc.blocks.splice(to,0,moved); render(); msg("unsaved changes")});
|
||||
var h=document.createElement("h2"); h.textContent=b.title||b.id; card.appendChild(h);
|
||||
if(b.kind==="metric"||b.kind==="status"){
|
||||
var big=document.createElement("div"); big.className="big"; big.textContent="--";
|
||||
big.dataset.source=b.source||""; card.appendChild(big);
|
||||
if(b.unit){var u=document.createElement("span"); u.className="unit"; u.textContent=b.unit; card.appendChild(u)}
|
||||
} else if(b.kind==="table"){
|
||||
var t=document.createElement("table");
|
||||
t.dataset[b.source==="fans"?"fans":"table"]=b.source||"";
|
||||
t.innerHTML="<tbody><tr><td class='muted'>loading</td></tr></tbody>";
|
||||
card.appendChild(t);
|
||||
} else {
|
||||
var p=document.createElement("div"); p.className="muted"; p.dataset.kv=b.source||""; p.textContent="loading"; card.appendChild(p);
|
||||
}
|
||||
grid.appendChild(card);
|
||||
});
|
||||
}
|
||||
function msg(text){var el=$("edit-msg"); if(el)el.textContent=text}
|
||||
function fill(){
|
||||
var hw=null, sm=null;
|
||||
function paint(){
|
||||
if(!hw||!sm)return;
|
||||
var s=(sm.SUMMARY||[{}])[0];
|
||||
var src={
|
||||
status:(s.Status||"unknown"),
|
||||
accepted:(s.Accepted||0),
|
||||
rejected:(s.Rejected||0),
|
||||
elapsed:(s.Elapsed||0),
|
||||
active_chains:(hw.active_chains||[]).length,
|
||||
frequency:(hw.frequency_mhz||0),
|
||||
voltage:((hw.operating_point||{}).voltage_mv||0),
|
||||
target:(hw.target||"-")
|
||||
};
|
||||
document.querySelectorAll("[data-source]").forEach(function(el){
|
||||
var v=src[el.dataset.source];
|
||||
if(v===undefined||v===null){el.textContent="not reported"; el.classList.add("muted"); return}
|
||||
el.textContent=String(v);
|
||||
});
|
||||
document.querySelectorAll("[data-table]").forEach(function(t){
|
||||
var rows=(hw.chains||[]).map(function(c){return [c.index,c.chip,c.chips_found,JSON.stringify(c.eeprom),c.response_per_mille]});
|
||||
if(!rows.length){t.innerHTML="<tbody><tr><td class='muted'>no chains reported</td></tr></tbody>";return}
|
||||
t.innerHTML="<thead><tr><th>#</th><th>chip</th><th>chips</th><th>eeprom</th><th>response</th></tr></thead><tbody>"+
|
||||
rows.map(function(r){return "<tr>"+r.map(function(c){return "<td>"+esc(c)+"</td>"}).join("")+"</tr>"}).join("")+"</tbody>";
|
||||
});
|
||||
document.querySelectorAll("[data-kv]").forEach(function(el){
|
||||
var rows=[["profile",hw.profile||"-"],["chip",hw.chip||"-"],["psu",hw.psu||"-"],["target",hw.target||"-"],["stopped",hw.stopped?hw.stopped:"no"]];
|
||||
el.innerHTML=rows.map(function(r){return "<div><span class='muted'>"+esc(r[0])+"</span> "+esc(r[1])+"</div>"}).join("");
|
||||
});
|
||||
document.querySelectorAll("[data-fans]").forEach(function(t){
|
||||
var rows=(hw.fan_zones||[]).map(function(z){return [z.fan,(z.zones||[]).join(", ")]});
|
||||
if(!rows.length){t.innerHTML="<tbody><tr><td class='muted'>not mapped yet</td></tr></tbody>";return}
|
||||
t.innerHTML="<thead><tr><th>fan</th><th>zones</th></tr></thead><tbody>"+
|
||||
rows.map(function(r){return "<tr><td>"+esc(r[0])+"</td><td>"+esc(r[1])+"</td></tr>"}).join("")+"</tbody>";
|
||||
});
|
||||
}
|
||||
fetch("/api/hardware").then(function(r){return r.json()}).then(function(h){hw=h;paint()}).catch(function(){msg("hardware unavailable")});
|
||||
fetch("/api/summary").then(function(r){return r.json()}).then(function(s){sm=s;paint()}).catch(function(){});
|
||||
}
|
||||
fetch("/api/dashboard?deck="+encodeURIComponent(deck)).then(function(r){return r.json()}).then(function(d){doc=d;render();fill()});
|
||||
if(editable){
|
||||
$("save").onclick=function(){fetch("/api/dashboard?deck="+encodeURIComponent(deck),{method:"PUT",headers:{"Content-Type":"application/json"},body:JSON.stringify(doc)}).then(function(r){if(r.ok){msg("saved")}else{r.text().then(msg)}})};
|
||||
$("reset").onclick=function(){fetch("/api/dashboard?deck="+encodeURIComponent(deck)+"&reset=1",{method:"PUT",headers:{"Content-Type":"application/json"},body:"{}"}).then(function(r){return r.json()}).then(function(d){doc=d;render();fill();msg("template restored")})};
|
||||
$("add").onclick=function(){
|
||||
if(doc.blocks.length>=32){msg("32 blocks is the limit");return}
|
||||
var id="block"+(doc.blocks.length+1);
|
||||
doc.blocks.push({id:id,kind:"metric",span:1,title:"New block",source:"power_w",unit:"W"});render();msg("unsaved changes")};
|
||||
}
|
||||
}
|
||||
})();
|
||||
"#;
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn every_sidebar_item_has_a_page() {
|
||||
for group in NAV.iter() {
|
||||
for item in group.items {
|
||||
assert!(item.path.starts_with('/'), "{} has no path", item.label);
|
||||
assert!(!item.label.is_empty());
|
||||
}
|
||||
}
|
||||
assert_eq!(NAV.iter().map(|g| g.items.len()).sum::<usize>(), 13);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn default_decks_are_valid() {
|
||||
for deck in ["dashboard", "overview"] {
|
||||
let doc = default_deck(deck);
|
||||
let text = doc.to_string();
|
||||
assert!(validate_deck(&text).is_ok(), "{deck} default rejected");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_block_cap_is_enforced() {
|
||||
let mut blocks = Vec::new();
|
||||
for i in 0..=BLOCK_CAP {
|
||||
blocks.push(json!({"id": format!("b{i}"), "kind": "metric", "span": 1}));
|
||||
}
|
||||
let doc = json!({"version": 1, "blocks": blocks});
|
||||
assert!(validate_deck(&doc.to_string()).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn malformed_documents_are_rejected_with_a_reason() {
|
||||
assert!(validate_deck("not json").is_err());
|
||||
assert!(validate_deck("{}").is_err());
|
||||
assert!(validate_deck(r#"{"version":2,"blocks":[]}"#).is_err());
|
||||
assert!(
|
||||
validate_deck(r#"{"version":1,"blocks":[{"id":"x","kind":"evil","span":1}]}"#).is_err()
|
||||
);
|
||||
assert!(
|
||||
validate_deck(r#"{"version":1,"blocks":[{"id":"x","kind":"metric","span":9}]}"#)
|
||||
.is_err()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sidebar_marks_the_active_page_and_opens_its_group() {
|
||||
let html = page("/mining/fans", "Fans", "");
|
||||
assert!(html.contains("href=\"#/mining/fans\" aria-current=\"page\""));
|
||||
// Exactly the group holding the current page is open; the other is not.
|
||||
assert_eq!(html.matches("<details class=\"tree\" open>").count(), 1);
|
||||
assert!(html.contains("Power Supply"));
|
||||
assert!(html.contains("href=\"#/settings/terminal\""));
|
||||
// A one-item group is a plain link, not a disclosure around a leaf.
|
||||
assert!(html.contains("class=\"rail__link\" href=\"#/\""));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn user_text_is_escaped() {
|
||||
assert_eq!(escape("<script>"), "<script>");
|
||||
let html = kv_page(&[("note", "<b>x</b>".to_string())]);
|
||||
assert!(!html.contains("<b>x</b>"));
|
||||
assert!(html.contains("<b>"));
|
||||
}
|
||||
}
|
||||
+975
@@ -0,0 +1,975 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! On-box web UI and its API.
|
||||
//!
|
||||
//! The page is a convenience; `/api/...` stays the interface of record, so every
|
||||
//! value the UI shows is also available as JSON and nothing is reachable only
|
||||
//! through the browser.
|
||||
//!
|
||||
//! No framework and no dependency: the request parser is bounded, only the
|
||||
//! methods each route needs are accepted, and every response closes the
|
||||
//! connection. Files and Terminal are gated on a token so a shared network
|
||||
//! cannot silently use them.
|
||||
|
||||
use crate::management::MiningStatus;
|
||||
use crate::ui;
|
||||
use serde_json::{json, Value};
|
||||
use std::fs;
|
||||
use std::io::{self, Read, Write};
|
||||
use std::net::{SocketAddr, TcpListener, TcpStream};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::Command;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
const MAX_HEAD: usize = 8192;
|
||||
const MAX_BODY: usize = 64 * 1024;
|
||||
const CLIENT_TIMEOUT: Duration = Duration::from_millis(2000);
|
||||
const DECK_DIR: &str = "/var/lib/alkane/decks";
|
||||
const TOKEN_FILE: &str = "/var/lib/alkane/ui-token";
|
||||
const LOG_FILE: &str = "/var/log/messages";
|
||||
|
||||
/// Bind and serve until the listener fails.
|
||||
pub fn serve(bind: SocketAddr, status: Arc<MiningStatus>) -> io::Result<()> {
|
||||
let listener = TcpListener::bind(bind)?;
|
||||
serve_listener(listener, status)
|
||||
}
|
||||
|
||||
/// Serve on an already-bound listener.
|
||||
pub fn serve_listener(listener: TcpListener, status: Arc<MiningStatus>) -> io::Result<()> {
|
||||
for stream in listener.incoming() {
|
||||
let Ok(stream) = stream else { continue };
|
||||
let status = Arc::clone(&status);
|
||||
std::thread::spawn(move || {
|
||||
let _ = handle(stream, &status);
|
||||
});
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
struct Request {
|
||||
method: String,
|
||||
path: String,
|
||||
query: String,
|
||||
body: String,
|
||||
}
|
||||
|
||||
impl Request {
|
||||
fn param(&self, key: &str) -> Option<String> {
|
||||
self.query.split('&').find_map(|pair| {
|
||||
let (k, v) = pair.split_once('=')?;
|
||||
if k == key {
|
||||
Some(percent_decode(v))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
fn param_or(&self, key: &str, fallback: &str) -> String {
|
||||
self.param(key).unwrap_or_else(|| fallback.to_string())
|
||||
}
|
||||
}
|
||||
|
||||
fn percent_decode(text: &str) -> String {
|
||||
let bytes = text.as_bytes();
|
||||
let mut out = Vec::with_capacity(bytes.len());
|
||||
let mut i = 0;
|
||||
while i < bytes.len() {
|
||||
match bytes[i] {
|
||||
b'%' if i + 2 < bytes.len() => {
|
||||
let hex = std::str::from_utf8(&bytes[i + 1..i + 3]).unwrap_or("");
|
||||
match u8::from_str_radix(hex, 16) {
|
||||
Ok(byte) => {
|
||||
out.push(byte);
|
||||
i += 3;
|
||||
}
|
||||
Err(_) => {
|
||||
out.push(bytes[i]);
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
b'+' => {
|
||||
out.push(b' ');
|
||||
i += 1;
|
||||
}
|
||||
byte => {
|
||||
out.push(byte);
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
String::from_utf8_lossy(&out).into_owned()
|
||||
}
|
||||
|
||||
/// Handle one HTTP request.
|
||||
pub fn handle(mut stream: TcpStream, status: &MiningStatus) -> io::Result<()> {
|
||||
stream.set_read_timeout(Some(CLIENT_TIMEOUT))?;
|
||||
stream.set_write_timeout(Some(CLIENT_TIMEOUT))?;
|
||||
let mut raw = Vec::new();
|
||||
let mut chunk = [0_u8; 1024];
|
||||
let mut head_end = None;
|
||||
while head_end.is_none() {
|
||||
let count = stream.read(&mut chunk)?;
|
||||
if count == 0 {
|
||||
break;
|
||||
}
|
||||
raw.extend_from_slice(&chunk[..count]);
|
||||
if raw.len() > MAX_HEAD {
|
||||
return respond(&mut stream, 431, "text/plain", b"request head too large");
|
||||
}
|
||||
head_end = raw.windows(4).position(|w| w == b"\r\n\r\n").map(|i| i + 4);
|
||||
}
|
||||
let Some(head_end) = head_end else {
|
||||
return respond(&mut stream, 400, "text/plain", b"bad request");
|
||||
};
|
||||
let head = String::from_utf8_lossy(&raw[..head_end]).into_owned();
|
||||
let mut lines = head.lines();
|
||||
let mut first = lines.next().unwrap_or("").split_whitespace();
|
||||
let method = first.next().unwrap_or("").to_string();
|
||||
let target = first.next().unwrap_or("/").to_string();
|
||||
let (path, query) = match target.split_once('?') {
|
||||
Some((p, q)) => (p.to_string(), q.to_string()),
|
||||
None => (target.clone(), String::new()),
|
||||
};
|
||||
let length = lines
|
||||
.find_map(|line| {
|
||||
let (name, value) = line.split_once(':')?;
|
||||
if name.eq_ignore_ascii_case("content-length") {
|
||||
value.trim().parse::<usize>().ok()
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
.unwrap_or(0);
|
||||
if length > MAX_BODY {
|
||||
return respond(&mut stream, 413, "text/plain", b"body too large");
|
||||
}
|
||||
let mut body = raw[head_end..].to_vec();
|
||||
while body.len() < length {
|
||||
let count = stream.read(&mut chunk)?;
|
||||
if count == 0 {
|
||||
break;
|
||||
}
|
||||
body.extend_from_slice(&chunk[..count]);
|
||||
}
|
||||
let request = Request {
|
||||
method,
|
||||
path,
|
||||
query,
|
||||
body: String::from_utf8_lossy(&body).into_owned(),
|
||||
};
|
||||
route(&mut stream, status, &request)
|
||||
}
|
||||
|
||||
fn route(stream: &mut TcpStream, status: &MiningStatus, request: &Request) -> io::Result<()> {
|
||||
if dashboard_route(stream, request)? {
|
||||
return Ok(());
|
||||
}
|
||||
match (request.method.as_str(), request.path.as_str()) {
|
||||
("GET", "/") => html(stream, "Dashboard", &ui::dashboard_page("dashboard", true)),
|
||||
("GET", "/mining") => html(
|
||||
stream,
|
||||
"Mining overview",
|
||||
&ui::dashboard_page("overview", true),
|
||||
),
|
||||
("GET", "/mining/hashboards") => {
|
||||
let hw = status.hardware_document();
|
||||
let rows: Vec<Vec<String>> = hw["chains"]
|
||||
.as_array()
|
||||
.map(|chains| {
|
||||
chains
|
||||
.iter()
|
||||
.map(|chain| {
|
||||
vec![
|
||||
chain["index"].to_string(),
|
||||
chain["chip"].as_str().unwrap_or("-").to_string(),
|
||||
chain["chips_found"].to_string(),
|
||||
chain["eeprom"].to_string(),
|
||||
chain["response_per_mille"].to_string(),
|
||||
]
|
||||
})
|
||||
.collect()
|
||||
})
|
||||
.unwrap_or_default();
|
||||
html(
|
||||
stream,
|
||||
"Hashboards",
|
||||
&ui::table_page(
|
||||
&["#", "chip", "chips", "eeprom", "response per mille"],
|
||||
&rows,
|
||||
),
|
||||
)
|
||||
}
|
||||
("GET", "/mining/power") => {
|
||||
let hw = status.hardware_document();
|
||||
let point = &hw["operating_point"];
|
||||
html(
|
||||
stream,
|
||||
"Power supply",
|
||||
&ui::kv_page(&[
|
||||
(
|
||||
"supply",
|
||||
hw["psu"].as_str().unwrap_or("not identified").to_string(),
|
||||
),
|
||||
(
|
||||
"voltage range (mV)",
|
||||
format!(
|
||||
"{} - {}",
|
||||
hw["envelope"]["v_min_mv"], hw["envelope"]["v_max_mv"]
|
||||
),
|
||||
),
|
||||
(
|
||||
"frequency range (MHz)",
|
||||
format!(
|
||||
"{} - {}",
|
||||
hw["envelope"]["f_min_mhz"], hw["envelope"]["f_max_mhz"]
|
||||
),
|
||||
),
|
||||
(
|
||||
"running at",
|
||||
format!(
|
||||
"{} mV / {} MHz",
|
||||
point["voltage_mv"], point["frequency_mhz"]
|
||||
),
|
||||
),
|
||||
("target", hw["target"].as_str().unwrap_or("-").to_string()),
|
||||
]),
|
||||
)
|
||||
}
|
||||
("GET", "/mining/fans") => {
|
||||
let hw = status.hardware_document();
|
||||
let rows: Vec<Vec<String>> = hw["fan_zones"]
|
||||
.as_array()
|
||||
.map(|zones| {
|
||||
zones
|
||||
.iter()
|
||||
.map(|zone| vec![zone["fan"].to_string(), zone["zones"].to_string()])
|
||||
.collect()
|
||||
})
|
||||
.unwrap_or_default();
|
||||
html(
|
||||
stream,
|
||||
"Fans",
|
||||
&ui::table_page(&["fan", "zones it cools"], &rows),
|
||||
)
|
||||
}
|
||||
("GET", "/settings/system") => html(
|
||||
stream,
|
||||
"System",
|
||||
&ui::sections_page(&[
|
||||
("Identity", ui::kv_page(&system_rows())),
|
||||
("Network", ui::kv_page(&network_rows())),
|
||||
("Updates", ui::kv_page(&update_rows())),
|
||||
]),
|
||||
),
|
||||
("GET", "/settings/drivers") => html(
|
||||
stream,
|
||||
"Drivers",
|
||||
&ui::sections_page(&[
|
||||
("Chains", ui::kv_page(&driver_rows(status))),
|
||||
("Firmware", ui::kv_page(&update_rows())),
|
||||
]),
|
||||
),
|
||||
("GET", "/settings/security") => html(stream, "Security", &ui::kv_page(&security_rows())),
|
||||
("GET", "/settings/services") => html(
|
||||
stream,
|
||||
"Services",
|
||||
&ui::table_page(&["service", "running"], &service_rows()),
|
||||
),
|
||||
("GET", "/settings/monitor") => {
|
||||
html(stream, "Monitor", &ui::kv_page(&monitor_rows(status)))
|
||||
}
|
||||
("GET", "/settings/logs") => {
|
||||
let lines = request
|
||||
.param_or("lines", "200")
|
||||
.parse::<usize>()
|
||||
.unwrap_or(200)
|
||||
.min(2000);
|
||||
let tail = tail_file(Path::new(LOG_FILE), lines);
|
||||
html(
|
||||
stream,
|
||||
"Logs",
|
||||
&format!(
|
||||
"<p class=\"muted\">{}</p><pre>{}</pre>",
|
||||
ui::escape(LOG_FILE),
|
||||
ui::escape(&tail)
|
||||
),
|
||||
)
|
||||
}
|
||||
("GET", "/settings/files") => {
|
||||
let path = request.param_or("path", "/");
|
||||
html(stream, "Files", &files_page(&path))
|
||||
}
|
||||
("GET", "/settings/terminal") => html(stream, "Terminal", &terminal_page()),
|
||||
("POST", "/api/terminal") => {
|
||||
if !authorised(request) {
|
||||
return respond(stream, 403, "text/plain", b"terminal requires a token");
|
||||
}
|
||||
let command = request.param_or("cmd", "");
|
||||
let output = run_shell(&command);
|
||||
respond(stream, 200, "text/plain; charset=utf-8", output.as_bytes())
|
||||
}
|
||||
("GET", "/api/hardware") => json_response(stream, &status.hardware_document()),
|
||||
("GET", "/api/summary") => json_response(stream, &status.summary_document()),
|
||||
("GET", "/api/dashboard") => {
|
||||
let deck = request.param_or("deck", "dashboard");
|
||||
json_response(stream, &load_deck(&deck))
|
||||
}
|
||||
("PUT", "/api/dashboard") => {
|
||||
let deck = request.param_or("deck", "dashboard");
|
||||
if request.param("reset").is_some() {
|
||||
let doc = ui::default_deck(&deck);
|
||||
let _ = save_deck(&deck, &doc);
|
||||
return json_response(stream, &doc);
|
||||
}
|
||||
match ui::validate_deck(&request.body) {
|
||||
Ok(doc) => match save_deck(&deck, &doc) {
|
||||
Ok(()) => json_response(stream, &doc),
|
||||
Err(error) => respond(stream, 500, "text/plain", error.as_bytes()),
|
||||
},
|
||||
Err(reason) => respond(stream, 400, "text/plain", reason.as_bytes()),
|
||||
}
|
||||
}
|
||||
("GET", "/api/logs") => {
|
||||
let lines = request
|
||||
.param_or("lines", "200")
|
||||
.parse::<usize>()
|
||||
.unwrap_or(200)
|
||||
.min(2000);
|
||||
let tail = tail_file(Path::new(LOG_FILE), lines);
|
||||
json_response(
|
||||
stream,
|
||||
&json!({"file": LOG_FILE, "lines": tail.lines().collect::<Vec<_>>()}),
|
||||
)
|
||||
}
|
||||
("GET", "/api/files") => {
|
||||
let path = request.param_or("path", "/");
|
||||
json_response(stream, &files_document(&path))
|
||||
}
|
||||
("GET", "/api/file") => {
|
||||
let path = request.param_or("path", "");
|
||||
match read_text(Path::new(&path)) {
|
||||
Some(text) => respond(stream, 200, "text/plain; charset=utf-8", text.as_bytes()),
|
||||
None => respond(stream, 404, "text/plain", b"not a readable text file"),
|
||||
}
|
||||
}
|
||||
_ => respond(stream, 404, "text/plain", b"not found"),
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/// Where the dashboard keeps operator settings.
|
||||
fn settings_path() -> std::path::PathBuf {
|
||||
let etc = std::path::Path::new("/etc/alkane/settings.json");
|
||||
if etc.exists() || std::path::Path::new("/etc/alkane").is_dir() {
|
||||
return etc.to_path_buf();
|
||||
}
|
||||
// A read-only root or a test run: keep the file beside the binary.
|
||||
std::env::temp_dir().join("alkane-settings.json")
|
||||
}
|
||||
|
||||
/// Serve the schema-driven UI: assets, pages and the settings form.
|
||||
///
|
||||
/// Returns `None` when the path is not a dashboard path, so the hand-written
|
||||
/// API routes below keep working unchanged.
|
||||
fn dashboard_route(stream: &mut TcpStream, request: &Request) -> io::Result<bool> {
|
||||
let path = request.path.clone();
|
||||
if let Some(name) = path.strip_prefix("/assets/") {
|
||||
for (file, css) in crate::dashboard::Dashboard::stylesheets() {
|
||||
if name == file {
|
||||
return respond(stream, 200, "text/css; charset=utf-8", css.as_bytes()).map(|_| true);
|
||||
}
|
||||
}
|
||||
return Ok(false);
|
||||
}
|
||||
if request.method == "POST" && path == "/settings" {
|
||||
let mut dash = crate::dashboard::Dashboard::load(settings_path());
|
||||
return match dash.submit(&request.body) {
|
||||
Ok(()) => respond(stream, 303, "text/plain", b"see /").map(|_| true),
|
||||
Err(failures) => {
|
||||
let mut text = String::new();
|
||||
for (key, why) in failures {
|
||||
text.push_str(&format!("{key}: {why}\n"));
|
||||
}
|
||||
respond(stream, 422, "text/plain; charset=utf-8", text.as_bytes()).map(|_| true)
|
||||
}
|
||||
};
|
||||
}
|
||||
if request.method != "GET" {
|
||||
return Ok(false);
|
||||
}
|
||||
let mut parts = path.trim_start_matches('/').split('/');
|
||||
let section = match parts.next() {
|
||||
Some(section) if !section.is_empty() => section,
|
||||
_ => return Ok(false),
|
||||
};
|
||||
let dash = crate::dashboard::Dashboard::load(settings_path());
|
||||
let nav = match dash.nav() {
|
||||
Ok(nav) => nav,
|
||||
Err(_) => return Ok(false),
|
||||
};
|
||||
let known = nav.sections.iter().find(|s| s.slug == section);
|
||||
let known = match known {
|
||||
Some(section) => section,
|
||||
None => return Ok(false),
|
||||
};
|
||||
let tab = parts.next().unwrap_or_else(|| {
|
||||
known.tabs.first().map(|tab| tab.slug.as_str()).unwrap_or("")
|
||||
});
|
||||
if !known.tabs.iter().any(|t| t.slug == tab) {
|
||||
return Ok(false);
|
||||
}
|
||||
let html = dash.page(section, tab, &std::collections::BTreeMap::new()).into_string();
|
||||
respond(stream, 200, "text/html; charset=utf-8", html.as_bytes()).map(|_| true)
|
||||
}
|
||||
|
||||
fn html(stream: &mut TcpStream, title: &str, body: &str) -> io::Result<()> {
|
||||
let page = ui::page(path_for(title), title, body);
|
||||
respond(stream, 200, "text/html; charset=utf-8", page.as_bytes())
|
||||
}
|
||||
|
||||
fn path_for(title: &str) -> &'static str {
|
||||
match title {
|
||||
"Dashboard" => "/",
|
||||
"Mining overview" => "/mining",
|
||||
"Hashboards" => "/mining/hashboards",
|
||||
"Power supply" => "/mining/power",
|
||||
"Fans" => "/mining/fans",
|
||||
"System" => "/settings/system",
|
||||
"Drivers" => "/settings/drivers",
|
||||
"Security" => "/settings/security",
|
||||
"Services" => "/settings/services",
|
||||
"Monitor" => "/settings/monitor",
|
||||
"Logs" => "/settings/logs",
|
||||
"Files" => "/settings/files",
|
||||
"Terminal" => "/settings/terminal",
|
||||
_ => "/",
|
||||
}
|
||||
}
|
||||
|
||||
fn json_response(stream: &mut TcpStream, value: &Value) -> io::Result<()> {
|
||||
respond(
|
||||
stream,
|
||||
200,
|
||||
"application/json",
|
||||
value.to_string().as_bytes(),
|
||||
)
|
||||
}
|
||||
|
||||
// --- dashboard storage -------------------------------------------------------
|
||||
|
||||
fn deck_path(deck: &str) -> PathBuf {
|
||||
let safe: String = deck
|
||||
.chars()
|
||||
.filter(|c| c.is_ascii_alphanumeric() || *c == '-' || *c == '_')
|
||||
.collect();
|
||||
Path::new(DECK_DIR).join(format!("{safe}.json"))
|
||||
}
|
||||
|
||||
fn load_deck(deck: &str) -> Value {
|
||||
fs::read_to_string(deck_path(deck))
|
||||
.ok()
|
||||
.and_then(|text| ui::validate_deck(&text).ok())
|
||||
.unwrap_or_else(|| ui::default_deck(deck))
|
||||
}
|
||||
|
||||
fn save_deck(deck: &str, doc: &Value) -> Result<(), String> {
|
||||
let path = deck_path(deck);
|
||||
if let Some(parent) = path.parent() {
|
||||
fs::create_dir_all(parent)
|
||||
.map_err(|e| format!("cannot create {}: {e}", parent.display()))?;
|
||||
}
|
||||
let text = serde_json::to_string_pretty(doc).map_err(|e| e.to_string())?;
|
||||
fs::write(&path, text).map_err(|e| format!("cannot write {}: {e}", path.display()))
|
||||
}
|
||||
|
||||
// --- page data ---------------------------------------------------------------
|
||||
|
||||
fn system_rows() -> Vec<(&'static str, String)> {
|
||||
vec![
|
||||
(
|
||||
"hostname",
|
||||
read_trim("/proc/sys/kernel/hostname").unwrap_or_else(|| "unknown".into()),
|
||||
),
|
||||
(
|
||||
"kernel",
|
||||
read_trim("/proc/sys/kernel/osrelease").unwrap_or_else(|| "unknown".into()),
|
||||
),
|
||||
(
|
||||
"machine",
|
||||
read_trim("/proc/device-tree/model").unwrap_or_else(|| "unknown".into()),
|
||||
),
|
||||
(
|
||||
"uptime",
|
||||
read_trim("/proc/uptime")
|
||||
.and_then(|s| s.split_whitespace().next().map(|v| v.to_string()))
|
||||
.map(|s| format!("{s} s"))
|
||||
.unwrap_or_else(|| "unknown".into()),
|
||||
),
|
||||
(
|
||||
"load",
|
||||
read_trim("/proc/loadavg").unwrap_or_else(|| "unknown".into()),
|
||||
),
|
||||
(
|
||||
"memory",
|
||||
fs::read_to_string("/proc/meminfo")
|
||||
.ok()
|
||||
.and_then(|text| {
|
||||
let total = text
|
||||
.lines()
|
||||
.find(|l| l.starts_with("MemTotal:"))?
|
||||
.split_whitespace()
|
||||
.nth(1)?;
|
||||
let free = text
|
||||
.lines()
|
||||
.find(|l| l.starts_with("MemAvailable:"))?
|
||||
.split_whitespace()
|
||||
.nth(1)?;
|
||||
Some(format!("{free} kB available of {total} kB"))
|
||||
})
|
||||
.unwrap_or_else(|| "unknown".into()),
|
||||
),
|
||||
(
|
||||
"api",
|
||||
"JSON under /api is the interface of record".to_string(),
|
||||
),
|
||||
]
|
||||
}
|
||||
|
||||
fn network_rows() -> Vec<(&'static str, String)> {
|
||||
let mut rows: Vec<(&'static str, String)> = Vec::new();
|
||||
if let Ok(text) = fs::read_to_string("/proc/net/route") {
|
||||
let default: Vec<String> = text
|
||||
.lines()
|
||||
.skip(1)
|
||||
.filter_map(|line| {
|
||||
let mut fields = line.split_whitespace();
|
||||
let iface = fields.next()?.to_string();
|
||||
let dest = fields.next().unwrap_or("");
|
||||
if dest == "00000000" {
|
||||
Some(iface)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
rows.push((
|
||||
"default route",
|
||||
if default.is_empty() {
|
||||
"none".into()
|
||||
} else {
|
||||
default.join(", ")
|
||||
},
|
||||
));
|
||||
}
|
||||
for iface in ["eth0", "wlan0"] {
|
||||
if let Ok(text) = fs::read_to_string("/proc/net/dev") {
|
||||
if let Some(line) = text.lines().find(|l| l.trim_start().starts_with(iface)) {
|
||||
let counters: Vec<&str> = line.split_whitespace().collect();
|
||||
if counters.len() > 9 {
|
||||
rows.push((
|
||||
iface,
|
||||
format!("rx {} bytes, tx {} bytes", counters[1], counters[9]),
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
rows.push((
|
||||
"ssh",
|
||||
if running("dropbear") {
|
||||
"listening".into()
|
||||
} else {
|
||||
"not running".into()
|
||||
},
|
||||
));
|
||||
rows
|
||||
}
|
||||
|
||||
fn update_rows() -> Vec<(&'static str, String)> {
|
||||
vec![
|
||||
(
|
||||
"image",
|
||||
read_trim("/etc/alkane-version").unwrap_or_else(|| "alkane-os".into()),
|
||||
),
|
||||
(
|
||||
"kernel",
|
||||
read_trim("/proc/sys/kernel/osrelease").unwrap_or_else(|| "unknown".into()),
|
||||
),
|
||||
(
|
||||
"binary",
|
||||
read_trim("/etc/alkane-build").unwrap_or_else(|| "unknown".into()),
|
||||
),
|
||||
(
|
||||
"update channel",
|
||||
"manual (no updater installed yet)".to_string(),
|
||||
),
|
||||
]
|
||||
}
|
||||
|
||||
fn driver_rows(status: &MiningStatus) -> Vec<(&'static str, String)> {
|
||||
let hw = status.hardware_document();
|
||||
vec![
|
||||
(
|
||||
"chain driver",
|
||||
hw["chip"].as_str().unwrap_or("not identified").to_string(),
|
||||
),
|
||||
(
|
||||
"board profile",
|
||||
hw["profile"]
|
||||
.as_str()
|
||||
.unwrap_or("not identified")
|
||||
.to_string(),
|
||||
),
|
||||
(
|
||||
"power supply",
|
||||
hw["psu"].as_str().unwrap_or("not identified").to_string(),
|
||||
),
|
||||
(
|
||||
"chains detected",
|
||||
hw["chains"]
|
||||
.as_array()
|
||||
.map(|c| c.len())
|
||||
.unwrap_or(0)
|
||||
.to_string(),
|
||||
),
|
||||
(
|
||||
"chains active",
|
||||
hw["active_chains"]
|
||||
.as_array()
|
||||
.map(|c| c.len())
|
||||
.unwrap_or(0)
|
||||
.to_string(),
|
||||
),
|
||||
(
|
||||
"stopped",
|
||||
if hw["stopped"].is_null() {
|
||||
"no".into()
|
||||
} else {
|
||||
hw["stopped"].to_string()
|
||||
},
|
||||
),
|
||||
]
|
||||
}
|
||||
|
||||
fn security_rows() -> Vec<(&'static str, String)> {
|
||||
let users = fs::read_to_string("/etc/passwd")
|
||||
.map(|text| {
|
||||
text.lines()
|
||||
.filter_map(|line| line.split(':').next())
|
||||
.collect::<Vec<_>>()
|
||||
.join(", ")
|
||||
})
|
||||
.unwrap_or_else(|_| "unreadable".into());
|
||||
let keys = fs::read_to_string("/root/.ssh/authorized_keys")
|
||||
.map(|text| {
|
||||
text.lines()
|
||||
.filter(|l| !l.trim().is_empty())
|
||||
.count()
|
||||
.to_string()
|
||||
})
|
||||
.unwrap_or_else(|_| "0".into());
|
||||
let dropbear = if running("dropbear") {
|
||||
"running"
|
||||
} else {
|
||||
"not running"
|
||||
};
|
||||
vec![
|
||||
("accounts", users),
|
||||
("root ssh keys", keys),
|
||||
("dropbear", dropbear.to_string()),
|
||||
(
|
||||
"web files and terminal",
|
||||
if ui_token().is_some() {
|
||||
"token configured".into()
|
||||
} else {
|
||||
"disabled until a token exists".into()
|
||||
},
|
||||
),
|
||||
]
|
||||
}
|
||||
|
||||
fn service_rows() -> Vec<Vec<String>> {
|
||||
let mut rows = Vec::new();
|
||||
if let Ok(entries) = fs::read_dir("/etc/init.d") {
|
||||
for entry in entries.flatten() {
|
||||
let name = entry.file_name().to_string_lossy().into_owned();
|
||||
if let Some(service) = name.strip_prefix('S') {
|
||||
let label = service
|
||||
.trim_start_matches(|c: char| c.is_ascii_digit())
|
||||
.to_string();
|
||||
rows.push(vec![
|
||||
label.clone(),
|
||||
if running(&label) { "yes" } else { "no" }.to_string(),
|
||||
]);
|
||||
}
|
||||
}
|
||||
}
|
||||
rows.sort();
|
||||
rows
|
||||
}
|
||||
|
||||
fn monitor_rows(status: &MiningStatus) -> Vec<(&'static str, String)> {
|
||||
let hw = status.hardware_document();
|
||||
let point = &hw["operating_point"];
|
||||
vec![
|
||||
(
|
||||
"load",
|
||||
read_trim("/proc/loadavg").unwrap_or_else(|| "-".into()),
|
||||
),
|
||||
("frequency", format!("{} MHz", hw["frequency_mhz"])),
|
||||
("voltage", format!("{} mV", point["voltage_mv"])),
|
||||
("target", hw["target"].as_str().unwrap_or("-").to_string()),
|
||||
(
|
||||
"chains",
|
||||
format!(
|
||||
"{} active",
|
||||
hw["active_chains"].as_array().map(|c| c.len()).unwrap_or(0)
|
||||
),
|
||||
),
|
||||
(
|
||||
"memory",
|
||||
read_trim("/proc/meminfo")
|
||||
.and_then(|t| {
|
||||
t.lines()
|
||||
.find(|l| l.starts_with("MemAvailable:"))
|
||||
.map(|l| l.trim().to_string())
|
||||
})
|
||||
.unwrap_or_else(|| "-".into()),
|
||||
),
|
||||
]
|
||||
}
|
||||
|
||||
fn files_page(path: &str) -> String {
|
||||
let doc = files_document(path);
|
||||
let mut rows = Vec::new();
|
||||
if let Some(entries) = doc["entries"].as_array() {
|
||||
for entry in entries {
|
||||
rows.push(vec![
|
||||
entry["name"].as_str().unwrap_or("-").to_string(),
|
||||
entry["kind"].as_str().unwrap_or("-").to_string(),
|
||||
entry["size"].to_string(),
|
||||
]);
|
||||
}
|
||||
}
|
||||
format!(
|
||||
"<div class=\"bar\"><input type=\"text\" id=\"path\" value=\"{}\"><span class=\"muted\">read-only listing; individual text files are at /api/file?path=</span></div>{}",
|
||||
ui::escape(path),
|
||||
ui::table_page(&["name", "kind", "size"], &rows)
|
||||
)
|
||||
}
|
||||
|
||||
fn terminal_page() -> String {
|
||||
if ui_token().is_none() {
|
||||
return format!(
|
||||
"<p class=\"muted\">Terminal is disabled until a token exists at {}. Create one with \
|
||||
<code>head -c 16 /dev/urandom | od -An -tx1 | tr -d ' \\n' > {}; chmod 600 {}</code>.</p>",
|
||||
TOKEN_FILE, TOKEN_FILE, TOKEN_FILE
|
||||
);
|
||||
}
|
||||
"<div class=\"bar\"><input type=\"text\" id=\"cmd\" placeholder=\"command\"><button id=\"run\">Run</button>\
|
||||
<span class=\"muted\">commands run as root on this miner</span></div><pre id=\"out\">ready</pre>\
|
||||
<script>(function(){var b=document.getElementById('run');if(!b)return;b.onclick=function(){\
|
||||
var c=document.getElementById('cmd').value;fetch('/api/terminal?cmd='+encodeURIComponent(c),{method:'POST'})\
|
||||
.then(function(r){return r.text()}).then(function(t){document.getElementById('out').textContent=t})}})();</script>"
|
||||
.to_string()
|
||||
}
|
||||
|
||||
fn files_document(path: &str) -> Value {
|
||||
let root = Path::new(path);
|
||||
let mut entries = Vec::new();
|
||||
if let Ok(listing) = fs::read_dir(root) {
|
||||
for entry in listing.flatten() {
|
||||
let meta = entry.metadata().ok();
|
||||
entries.push(json!({
|
||||
"name": entry.file_name().to_string_lossy(),
|
||||
"kind": if meta.as_ref().map(|m| m.is_dir()).unwrap_or(false) { "dir" } else { "file" },
|
||||
"size": meta.map(|m| m.len()).unwrap_or(0),
|
||||
}));
|
||||
}
|
||||
}
|
||||
entries.sort_by(|a, b| a["name"].as_str().cmp(&b["name"].as_str()));
|
||||
json!({"path": path, "entries": entries})
|
||||
}
|
||||
|
||||
fn read_text(path: &Path) -> Option<String> {
|
||||
let meta = fs::metadata(path).ok()?;
|
||||
if !meta.is_file() || meta.len() > 256 * 1024 {
|
||||
return None;
|
||||
}
|
||||
String::from_utf8(fs::read(path).ok()?).ok()
|
||||
}
|
||||
|
||||
fn tail_file(path: &Path, lines: usize) -> String {
|
||||
let text = match read_text(path) {
|
||||
Some(text) => text,
|
||||
None => return String::from("no readable log yet"),
|
||||
};
|
||||
let all: Vec<&str> = text.lines().collect();
|
||||
let start = all.len().saturating_sub(lines);
|
||||
all[start..].join("\n")
|
||||
}
|
||||
|
||||
fn read_trim(path: &str) -> Option<String> {
|
||||
fs::read_to_string(path)
|
||||
.ok()
|
||||
.map(|text| text.trim().replace('\0', ""))
|
||||
}
|
||||
|
||||
fn running(name: &str) -> bool {
|
||||
Command::new("pgrep")
|
||||
.arg("-x")
|
||||
.arg(name)
|
||||
.output()
|
||||
.map(|out| out.status.success())
|
||||
.unwrap_or(false)
|
||||
}
|
||||
|
||||
fn run_shell(command: &str) -> String {
|
||||
if command.trim().is_empty() {
|
||||
return "no command".to_string();
|
||||
}
|
||||
match Command::new("/bin/sh").arg("-c").arg(command).output() {
|
||||
Ok(out) => {
|
||||
let mut text = String::from_utf8_lossy(&out.stdout).into_owned();
|
||||
text.push_str(&String::from_utf8_lossy(&out.stderr));
|
||||
if text.len() > 64 * 1024 {
|
||||
text.truncate(64 * 1024);
|
||||
}
|
||||
text
|
||||
}
|
||||
Err(error) => format!("cannot run: {error}"),
|
||||
}
|
||||
}
|
||||
|
||||
// --- access control ----------------------------------------------------------
|
||||
|
||||
fn ui_token() -> Option<String> {
|
||||
if let Ok(token) = std::env::var("ALKANE_UI_TOKEN") {
|
||||
if !token.is_empty() {
|
||||
return Some(token);
|
||||
}
|
||||
}
|
||||
fs::read_to_string(TOKEN_FILE)
|
||||
.ok()
|
||||
.map(|t| t.trim().to_string())
|
||||
.filter(|t| !t.is_empty())
|
||||
}
|
||||
|
||||
fn authorised(request: &Request) -> bool {
|
||||
match (ui_token(), request.param("token")) {
|
||||
(Some(expected), Some(given)) => given == expected,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
fn respond(stream: &mut TcpStream, code: u16, content_type: &str, body: &[u8]) -> io::Result<()> {
|
||||
let reason = match code {
|
||||
200 => "OK",
|
||||
400 => "Bad Request",
|
||||
403 => "Forbidden",
|
||||
404 => "Not Found",
|
||||
413 => "Payload Too Large",
|
||||
431 => "Request Header Fields Too Large",
|
||||
500 => "Internal Server Error",
|
||||
_ => "Error",
|
||||
};
|
||||
let header = format!(
|
||||
"HTTP/1.1 {code} {reason}\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nConnection: close\r\nCache-Control: no-store\r\n\r\n",
|
||||
body.len()
|
||||
);
|
||||
stream.write_all(header.as_bytes())?;
|
||||
stream.write_all(body)?;
|
||||
stream.flush()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn client(request: &str) -> String {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let addr = listener.local_addr().unwrap();
|
||||
let status = Arc::new(MiningStatus::new());
|
||||
let worker = std::thread::spawn(move || {
|
||||
let (stream, _) = listener.accept().unwrap();
|
||||
handle(stream, &status).unwrap();
|
||||
});
|
||||
let mut stream = TcpStream::connect(addr).unwrap();
|
||||
stream.write_all(request.as_bytes()).unwrap();
|
||||
let mut reply = String::new();
|
||||
stream.read_to_string(&mut reply).unwrap();
|
||||
worker.join().unwrap();
|
||||
reply
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_dashboard_serves_a_page_with_the_sidebar() {
|
||||
let reply = client("GET / HTTP/1.1\r\nHost: x\r\n\r\n");
|
||||
assert!(reply.starts_with("HTTP/1.1 200 OK"));
|
||||
assert!(reply.contains("Power Supply"));
|
||||
assert!(reply.contains("Terminal"));
|
||||
assert!(reply.contains("text/html"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_page_answers() {
|
||||
for path in [
|
||||
"/mining",
|
||||
"/mining/hashboards",
|
||||
"/mining/power",
|
||||
"/mining/fans",
|
||||
"/settings/system",
|
||||
"/settings/drivers",
|
||||
"/settings/security",
|
||||
"/settings/services",
|
||||
"/settings/monitor",
|
||||
"/settings/logs",
|
||||
"/settings/files",
|
||||
"/settings/terminal",
|
||||
] {
|
||||
let reply = client(&format!("GET {path} HTTP/1.1\r\nHost: x\r\n\r\n"));
|
||||
assert!(reply.starts_with("HTTP/1.1 200 OK"), "{path}: {reply}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_dashboard_api_serves_the_default_template() {
|
||||
let reply = client("GET /api/dashboard?deck=bogus HTTP/1.1\r\nHost: x\r\n\r\n");
|
||||
let body = reply.split("\r\n\r\n").nth(1).unwrap_or("");
|
||||
let doc: Value = serde_json::from_str(body).unwrap_or_else(|_| json!({}));
|
||||
assert_eq!(doc["version"], 1);
|
||||
assert!(doc["blocks"]
|
||||
.as_array()
|
||||
.map(|b| !b.is_empty())
|
||||
.unwrap_or(false));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_dashboard_api_rejects_a_bad_document() {
|
||||
let body = "not json";
|
||||
let reply = client(&format!(
|
||||
"PUT /api/dashboard?deck=test HTTP/1.1\r\nHost: x\r\nContent-Length: {}\r\n\r\n{body}",
|
||||
body.len()
|
||||
));
|
||||
assert!(reply.starts_with("HTTP/1.1 400"), "{reply}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_terminal_is_forbidden_without_a_token() {
|
||||
std::env::remove_var("ALKANE_UI_TOKEN");
|
||||
let reply =
|
||||
client("POST /api/terminal?cmd=id HTTP/1.1\r\nHost: x\r\nContent-Length: 0\r\n\r\n");
|
||||
assert!(reply.starts_with("HTTP/1.1 403"), "{reply}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_api_still_serves_hardware_and_summary() {
|
||||
for path in ["/api/hardware", "/api/summary"] {
|
||||
let reply = client(&format!("GET {path} HTTP/1.1\r\nHost: x\r\n\r\n"));
|
||||
assert!(reply.starts_with("HTTP/1.1 200 OK"), "{path}");
|
||||
assert!(reply.contains("application/json"));
|
||||
}
|
||||
}
|
||||
}
|
||||
Vendored
+41
@@ -0,0 +1,41 @@
|
||||
# Third-party sources
|
||||
|
||||
Code we consume that is not on crates.io. Both entries are pinned, and both are
|
||||
vendored rather than fetched so an image build works with no network.
|
||||
|
||||
## flare-ui
|
||||
|
||||
`flare-ui/` is a full checkout of the `flare-ui` tag recorded in
|
||||
`flare-ui/flare-ui.lock` (repo, tag, commit). It is used as path dependencies:
|
||||
|
||||
```
|
||||
flare-ui = { path = "third-party/flare-ui/crates/flare-ui" }
|
||||
wschema = { path = "third-party/flare-ui/crates/wschema" }
|
||||
```
|
||||
|
||||
The whole tree is vendored, not just `crates/`, because the crate embeds assets
|
||||
from `dash-editor/` with `include_str!` and will not compile from a partial
|
||||
archive.
|
||||
|
||||
Updating the pin:
|
||||
|
||||
```
|
||||
git archive <new-tag> | tar -x -C third-party/flare-ui # from a flare-ui checkout
|
||||
cargo vendor vendor # refresh registry deps
|
||||
```
|
||||
|
||||
`vendor/` is a cargo directory source (see `.cargo/config.toml`), so every
|
||||
registry dependency flare-ui needs - `maud`, `sha2`, `typenum`, `digest` and the
|
||||
rest - must be re-vendored or the build fails offline.
|
||||
|
||||
## Size
|
||||
|
||||
`ci/check-ui-size.sh` builds two binaries for armv7 with the same profile: one
|
||||
renders through flare-ui, one renders the same shape with `maud` alone. The
|
||||
difference is the marginal cost. Measured 2026-11-03, release, stripped:
|
||||
|
||||
```
|
||||
ui-baseline 323 KiB
|
||||
ui-spike 771 KiB
|
||||
marginal 448 KiB
|
||||
```
|
||||
+121
@@ -0,0 +1,121 @@
|
||||
name: CI
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [main, next]
|
||||
pull_request:
|
||||
workflow_dispatch:
|
||||
|
||||
concurrency:
|
||||
group: ci-${{ gitea.ref }}
|
||||
cancel-in-progress: true
|
||||
|
||||
env:
|
||||
CARGO_TERM_COLOR: always
|
||||
CARGO_INCREMENTAL: "0"
|
||||
|
||||
jobs:
|
||||
check:
|
||||
name: Format, lint and test
|
||||
runs-on: ci-small
|
||||
timeout-minutes: 30
|
||||
steps:
|
||||
- uses: actions/checkout@v7
|
||||
|
||||
# rust-toolchain.toml names one exact version. Install it, then require
|
||||
# the compiler cargo will use to report that same version.
|
||||
- name: Toolchain matches the pin
|
||||
run: |
|
||||
want="$(sed -n 's/^channel *= *"\(.*\)"/\1/p' rust-toolchain.toml)"
|
||||
if command -v rustup >/dev/null 2>&1; then
|
||||
rustup toolchain install "$want" --profile minimal --component clippy --component rustfmt
|
||||
fi
|
||||
got="$(rustc --version | cut -d' ' -f2)"
|
||||
echo "pinned $want, rustc $got"
|
||||
[ "$want" = "$got" ]
|
||||
|
||||
- name: Cache cargo registry
|
||||
uses: actions/cache@v6
|
||||
with:
|
||||
path: |
|
||||
~/.cargo/registry/index
|
||||
~/.cargo/registry/cache
|
||||
~/.cargo/git/db
|
||||
key: ${{ runner.os }}-cargo-${{ hashFiles('Cargo.lock') }}
|
||||
restore-keys: ${{ runner.os }}-cargo-
|
||||
|
||||
- name: Format
|
||||
run: cargo fmt --check
|
||||
|
||||
- name: Clippy
|
||||
run: cargo clippy --workspace --all-targets --locked -- -D warnings
|
||||
|
||||
- name: Test
|
||||
run: cargo test --workspace --locked
|
||||
|
||||
- name: Crate owners
|
||||
run: scripts/check-owners.sh
|
||||
|
||||
- name: Vendor script self-test
|
||||
run: scripts/vendor-selftest.sh
|
||||
|
||||
# The panel crates must keep building for the device target.
|
||||
- name: Build for the panel
|
||||
run: |
|
||||
if command -v rustup >/dev/null 2>&1; then
|
||||
rustup target add armv7-unknown-linux-musleabihf
|
||||
fi
|
||||
cargo build --locked --target armv7-unknown-linux-musleabihf \
|
||||
-p wschema -p warden-sync -p warden-seal -p wapp-core
|
||||
|
||||
# The imported dashboard editor ships plain static files; its tests
|
||||
# are Node's built-in runner, no install step.
|
||||
- name: Dash editor tests
|
||||
run: |
|
||||
cd dash-editor
|
||||
node --test tests/*.test.mjs
|
||||
|
||||
# The automation flowchart model, same runner as the dash editor.
|
||||
- name: Flow builder tests
|
||||
run: |
|
||||
cd flow-builder
|
||||
node --test tests/*.test.mjs
|
||||
|
||||
- name: UI adapter tests
|
||||
run: node --test crates/flare-ui/tests/js/*.test.js
|
||||
|
||||
browser:
|
||||
name: UI browser tests
|
||||
runs-on: ci-small
|
||||
timeout-minutes: 15
|
||||
permissions:
|
||||
contents: read
|
||||
env:
|
||||
PLAYWRIGHT_BROWSERS_PATH: ${{ runner.tool_cache }}/flare-ui-playwright
|
||||
defaults:
|
||||
run:
|
||||
working-directory: crates/flare-ui/tests/browser
|
||||
steps:
|
||||
- uses: actions/checkout@v7
|
||||
- uses: actions/setup-node@v4
|
||||
with:
|
||||
node-version: '24'
|
||||
- name: Restore browser cache
|
||||
id: browsers
|
||||
uses: actions/cache/restore@v6
|
||||
with:
|
||||
path: ${{ env.PLAYWRIGHT_BROWSERS_PATH }}
|
||||
key: ${{ runner.os }}-flare-ui-playwright-${{ hashFiles('crates/flare-ui/tests/browser/package-lock.json') }}
|
||||
- name: Install test dependencies
|
||||
run: npm ci --ignore-scripts
|
||||
- name: Install headless browsers
|
||||
run: npx playwright install --with-deps chromium firefox
|
||||
- name: Check UI behavior
|
||||
run: npm test
|
||||
# Pull requests read the cache; only trusted next pushes replace it.
|
||||
- name: Save browser cache
|
||||
if: github.event_name == 'push' && github.ref == 'refs/heads/next' && steps.browsers.outputs.cache-hit != 'true'
|
||||
uses: actions/cache/save@v6
|
||||
with:
|
||||
path: ${{ env.PLAYWRIGHT_BROWSERS_PATH }}
|
||||
key: ${{ runner.os }}-flare-ui-playwright-${{ hashFiles('crates/flare-ui/tests/browser/package-lock.json') }}
|
||||
@@ -0,0 +1,8 @@
|
||||
/target
|
||||
**/node_modules/
|
||||
*.zip
|
||||
.env
|
||||
|
||||
*.env
|
||||
*.pem
|
||||
*.key
|
||||
+942
@@ -0,0 +1,942 @@
|
||||
# This file is automatically @generated by Cargo.
|
||||
# It is not intended for manual editing.
|
||||
version = 4
|
||||
|
||||
[[package]]
|
||||
name = "adler2"
|
||||
version = "2.0.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
|
||||
|
||||
[[package]]
|
||||
name = "aead"
|
||||
version = "0.5.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
|
||||
dependencies = [
|
||||
"crypto-common",
|
||||
"generic-array",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "aes"
|
||||
version = "0.8.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"cipher",
|
||||
"cpufeatures",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "aes-gcm"
|
||||
version = "0.10.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "831010a0f742e1209b3bcea8fab6a8e149051ba6099432c8cb2cc117dec3ead1"
|
||||
dependencies = [
|
||||
"aead",
|
||||
"aes",
|
||||
"cipher",
|
||||
"ctr",
|
||||
"ghash",
|
||||
"subtle",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "aho-corasick"
|
||||
version = "1.1.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba"
|
||||
dependencies = [
|
||||
"memchr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "anes"
|
||||
version = "0.1.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
|
||||
|
||||
[[package]]
|
||||
name = "anstyle"
|
||||
version = "1.0.14"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
|
||||
|
||||
[[package]]
|
||||
name = "autocfg"
|
||||
version = "1.5.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
|
||||
|
||||
[[package]]
|
||||
name = "base64"
|
||||
version = "0.22.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
|
||||
|
||||
[[package]]
|
||||
name = "block-buffer"
|
||||
version = "0.10.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
|
||||
dependencies = [
|
||||
"generic-array",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cast"
|
||||
version = "0.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
|
||||
|
||||
[[package]]
|
||||
name = "cfg-if"
|
||||
version = "1.0.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600"
|
||||
|
||||
[[package]]
|
||||
name = "chacha20"
|
||||
version = "0.9.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"cipher",
|
||||
"cpufeatures",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "chacha20poly1305"
|
||||
version = "0.10.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "10cd79432192d1c0f4e1a0fef9527696cc039165d729fb41b3f4f4f354c2dc35"
|
||||
dependencies = [
|
||||
"aead",
|
||||
"chacha20",
|
||||
"cipher",
|
||||
"poly1305",
|
||||
"zeroize",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ciborium"
|
||||
version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
|
||||
dependencies = [
|
||||
"ciborium-io",
|
||||
"ciborium-ll",
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ciborium-io"
|
||||
version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
|
||||
|
||||
[[package]]
|
||||
name = "ciborium-ll"
|
||||
version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
|
||||
dependencies = [
|
||||
"ciborium-io",
|
||||
"half",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cipher"
|
||||
version = "0.4.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
|
||||
dependencies = [
|
||||
"crypto-common",
|
||||
"inout",
|
||||
"zeroize",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clap"
|
||||
version = "4.6.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "aa8876b300ab35ba921adea3dfd70157a46249b33f95c9084ae5709785478946"
|
||||
dependencies = [
|
||||
"clap_builder",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clap_builder"
|
||||
version = "4.6.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ec0797fb7aeb1406c84efac526901f7ec3ead2124f946b494e72879d4b54704d"
|
||||
dependencies = [
|
||||
"anstyle",
|
||||
"clap_lex",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clap_lex"
|
||||
version = "1.1.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1c133bc6a41be0d194c306b5506d15e6feeea7b1d6604bd3f8310dfb2ca96486"
|
||||
|
||||
[[package]]
|
||||
name = "cpufeatures"
|
||||
version = "0.2.17"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
|
||||
dependencies = [
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crc32fast"
|
||||
version = "1.5.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "01a7799fd6b852db0e61728dde9a204c423b44d689dbd432522543614b490e78"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "criterion"
|
||||
version = "0.5.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
|
||||
dependencies = [
|
||||
"anes",
|
||||
"cast",
|
||||
"ciborium",
|
||||
"clap",
|
||||
"criterion-plot",
|
||||
"is-terminal",
|
||||
"itertools",
|
||||
"num-traits",
|
||||
"once_cell",
|
||||
"oorandom",
|
||||
"regex",
|
||||
"serde",
|
||||
"serde_derive",
|
||||
"serde_json",
|
||||
"tinytemplate",
|
||||
"walkdir",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "criterion-plot"
|
||||
version = "0.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
|
||||
dependencies = [
|
||||
"cast",
|
||||
"itertools",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crunchy"
|
||||
version = "0.2.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
|
||||
|
||||
[[package]]
|
||||
name = "crypto-common"
|
||||
version = "0.1.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
|
||||
dependencies = [
|
||||
"generic-array",
|
||||
"rand_core 0.6.4",
|
||||
"typenum",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ctr"
|
||||
version = "0.9.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835"
|
||||
dependencies = [
|
||||
"cipher",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "curve25519-dalek"
|
||||
version = "4.1.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"cpufeatures",
|
||||
"curve25519-dalek-derive",
|
||||
"fiat-crypto",
|
||||
"rustc_version",
|
||||
"subtle",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "curve25519-dalek-derive"
|
||||
version = "0.1.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.119",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "digest"
|
||||
version = "0.10.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
|
||||
dependencies = [
|
||||
"block-buffer",
|
||||
"crypto-common",
|
||||
"subtle",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ed25519-compact"
|
||||
version = "2.6.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1454db4f2edb7f0e8fe0c5b375b0c978fc63244cc9f010d160e417eb10139aa8"
|
||||
|
||||
[[package]]
|
||||
name = "either"
|
||||
version = "1.19.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0e9c71c2167ca323c882b99918929403426e2373ea17242ff5653e0d5e1058be"
|
||||
|
||||
[[package]]
|
||||
name = "fiat-crypto"
|
||||
version = "0.2.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d"
|
||||
|
||||
[[package]]
|
||||
name = "flare-plugin-abi"
|
||||
version = "0.0.1"
|
||||
|
||||
[[package]]
|
||||
name = "flare-ui"
|
||||
version = "0.0.1"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"maud",
|
||||
"serde_json",
|
||||
"wschema",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "flate2"
|
||||
version = "1.1.10"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb"
|
||||
dependencies = [
|
||||
"crc32fast",
|
||||
"miniz_oxide",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "generic-array"
|
||||
version = "0.14.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
|
||||
dependencies = [
|
||||
"typenum",
|
||||
"version_check",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "getrandom"
|
||||
version = "0.2.17"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"libc",
|
||||
"wasi",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ghash"
|
||||
version = "0.5.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f0d8a4362ccb29cb0b265253fb0a2728f592895ee6854fd9bc13f2ffda266ff1"
|
||||
dependencies = [
|
||||
"opaque-debug",
|
||||
"polyval",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "half"
|
||||
version = "2.7.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"crunchy",
|
||||
"zerocopy",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "hermit-abi"
|
||||
version = "0.5.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e17592d60ebacc7d5e169f4663c5f84f9161cc90328abcfe8456f41e4dfcb284"
|
||||
|
||||
[[package]]
|
||||
name = "hkdf"
|
||||
version = "0.12.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7"
|
||||
dependencies = [
|
||||
"hmac",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "hmac"
|
||||
version = "0.12.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
|
||||
dependencies = [
|
||||
"digest",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "hpke"
|
||||
version = "0.13.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f65d16b699dd1a1fa2d851c970b0c971b388eeeb40f744252b8de48860980c8f"
|
||||
dependencies = [
|
||||
"aead",
|
||||
"aes-gcm",
|
||||
"chacha20poly1305",
|
||||
"digest",
|
||||
"generic-array",
|
||||
"hkdf",
|
||||
"hmac",
|
||||
"rand_core 0.9.5",
|
||||
"sha2",
|
||||
"subtle",
|
||||
"x25519-dalek",
|
||||
"zeroize",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "inout"
|
||||
version = "0.1.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
|
||||
dependencies = [
|
||||
"generic-array",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "is-terminal"
|
||||
version = "0.4.17"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46"
|
||||
dependencies = [
|
||||
"hermit-abi",
|
||||
"libc",
|
||||
"windows-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itertools"
|
||||
version = "0.10.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
|
||||
dependencies = [
|
||||
"either",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itoa"
|
||||
version = "1.0.18"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
|
||||
|
||||
[[package]]
|
||||
name = "libc"
|
||||
version = "0.2.190"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ce5d3ddc6d3fa000eb1536d85e147bfe31aacaba692ed6a876f95cb7c855be78"
|
||||
|
||||
[[package]]
|
||||
name = "maud"
|
||||
version = "0.27.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8156733e27020ea5c684db5beac5d1d611e1272ab17901a49466294b84fc217e"
|
||||
dependencies = [
|
||||
"itoa",
|
||||
"maud_macros",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "maud_macros"
|
||||
version = "0.27.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7261b00f3952f617899bc012e3dbd56e4f0110a038175929fa5d18e5a19913ca"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"proc-macro2-diagnostics",
|
||||
"quote",
|
||||
"syn 2.0.119",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "memchr"
|
||||
version = "2.8.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
|
||||
|
||||
[[package]]
|
||||
name = "miniz_oxide"
|
||||
version = "0.9.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b63fbc4a50860e98e7b2aa7804ded1db5cbc3aff9193adaff57a6931bf7c4b4c"
|
||||
dependencies = [
|
||||
"adler2",
|
||||
"simd-adler32",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "num-traits"
|
||||
version = "0.2.19"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
|
||||
dependencies = [
|
||||
"autocfg",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "once_cell"
|
||||
version = "1.21.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
|
||||
|
||||
[[package]]
|
||||
name = "oorandom"
|
||||
version = "11.1.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
|
||||
|
||||
[[package]]
|
||||
name = "opaque-debug"
|
||||
version = "0.3.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
|
||||
|
||||
[[package]]
|
||||
name = "poly1305"
|
||||
version = "0.8.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf"
|
||||
dependencies = [
|
||||
"cpufeatures",
|
||||
"opaque-debug",
|
||||
"universal-hash",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "polyval"
|
||||
version = "0.6.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9d1fe60d06143b2430aa532c94cfe9e29783047f06c0d7fd359a9a51b729fa25"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"cpufeatures",
|
||||
"opaque-debug",
|
||||
"universal-hash",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro2"
|
||||
version = "1.0.107"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
|
||||
dependencies = [
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro2-diagnostics"
|
||||
version = "0.10.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.119",
|
||||
"version_check",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "quote"
|
||||
version = "1.0.47"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rand_core"
|
||||
version = "0.6.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
|
||||
dependencies = [
|
||||
"getrandom",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rand_core"
|
||||
version = "0.9.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
|
||||
|
||||
[[package]]
|
||||
name = "regex"
|
||||
version = "1.13.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d"
|
||||
dependencies = [
|
||||
"aho-corasick",
|
||||
"memchr",
|
||||
"regex-automata",
|
||||
"regex-syntax",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "regex-automata"
|
||||
version = "0.4.18"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2"
|
||||
dependencies = [
|
||||
"aho-corasick",
|
||||
"memchr",
|
||||
"regex-syntax",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "regex-syntax"
|
||||
version = "0.8.11"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
|
||||
|
||||
[[package]]
|
||||
name = "rustc_version"
|
||||
version = "0.4.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
|
||||
dependencies = [
|
||||
"semver",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "same-file"
|
||||
version = "1.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
|
||||
dependencies = [
|
||||
"winapi-util",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "semver"
|
||||
version = "1.0.28"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
|
||||
|
||||
[[package]]
|
||||
name = "serde"
|
||||
version = "1.0.229"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
|
||||
dependencies = [
|
||||
"serde_core",
|
||||
"serde_derive",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_core"
|
||||
version = "1.0.229"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
|
||||
dependencies = [
|
||||
"serde_derive",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_derive"
|
||||
version = "1.0.229"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 3.0.9",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_json"
|
||||
version = "1.0.154"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6"
|
||||
dependencies = [
|
||||
"itoa",
|
||||
"memchr",
|
||||
"serde",
|
||||
"serde_core",
|
||||
"zmij",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "sha2"
|
||||
version = "0.10.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"cpufeatures",
|
||||
"digest",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "simd-adler32"
|
||||
version = "0.3.10"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea"
|
||||
|
||||
[[package]]
|
||||
name = "subtle"
|
||||
version = "2.6.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
|
||||
|
||||
[[package]]
|
||||
name = "syn"
|
||||
version = "2.0.119"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "syn"
|
||||
version = "3.0.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d78c8dee4c7bf0e14673097256fed6142ce9d3b85a408189d07482442145823b"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tinytemplate"
|
||||
version = "1.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
|
||||
dependencies = [
|
||||
"serde",
|
||||
"serde_json",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "typenum"
|
||||
version = "1.20.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
|
||||
|
||||
[[package]]
|
||||
name = "unicode-ident"
|
||||
version = "1.0.27"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"
|
||||
|
||||
[[package]]
|
||||
name = "universal-hash"
|
||||
version = "0.5.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"
|
||||
dependencies = [
|
||||
"crypto-common",
|
||||
"subtle",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "version_check"
|
||||
version = "0.9.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
|
||||
|
||||
[[package]]
|
||||
name = "walkdir"
|
||||
version = "2.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
|
||||
dependencies = [
|
||||
"same-file",
|
||||
"winapi-util",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wapp-core"
|
||||
version = "0.0.1"
|
||||
dependencies = [
|
||||
"ed25519-compact",
|
||||
"flate2",
|
||||
"sha2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wapp-pack"
|
||||
version = "0.0.1"
|
||||
dependencies = [
|
||||
"sha2",
|
||||
"wapp-core",
|
||||
"wschema",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "warden-seal"
|
||||
version = "0.0.1"
|
||||
dependencies = [
|
||||
"base64",
|
||||
"hpke",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"sha2",
|
||||
"zeroize",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "warden-sync"
|
||||
version = "0.0.1"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"serde_json",
|
||||
"sha2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wasi"
|
||||
version = "0.11.1+wasi-snapshot-preview1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
|
||||
|
||||
[[package]]
|
||||
name = "winapi-util"
|
||||
version = "0.1.11"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
|
||||
dependencies = [
|
||||
"windows-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows-link"
|
||||
version = "0.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
|
||||
|
||||
[[package]]
|
||||
name = "windows-sys"
|
||||
version = "0.61.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
|
||||
dependencies = [
|
||||
"windows-link",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wschema"
|
||||
version = "0.0.1"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"sha2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wschema-cli"
|
||||
version = "0.0.1"
|
||||
dependencies = [
|
||||
"serde_json",
|
||||
"wschema",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wschema-gen"
|
||||
version = "0.0.1"
|
||||
dependencies = [
|
||||
"regex",
|
||||
"serde_json",
|
||||
"wschema",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "x25519-dalek"
|
||||
version = "2.0.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c7e468321c81fb07fa7f4c636c3972b9100f0346e5b6a9f2bd0603a52f7ed277"
|
||||
dependencies = [
|
||||
"curve25519-dalek",
|
||||
"rand_core 0.6.4",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zerocopy"
|
||||
version = "0.8.62"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "86502bf56ac7c77571a32e2647bb2a15894565e981fb2a48d7bde2d91c965a9d"
|
||||
dependencies = [
|
||||
"zerocopy-derive",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zerocopy-derive"
|
||||
version = "0.8.62"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5457206954b06561e2608c7e19cf58b1926586d999c246eebe4502f7e2039d1a"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.119",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zeroize"
|
||||
version = "1.9.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e13084392c5e4bc371903e2935a5eaeed24905a7511356b883835e18a78f6879"
|
||||
dependencies = [
|
||||
"zeroize_derive",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zeroize_derive"
|
||||
version = "1.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3c50655cbb0fe3fc43170059e702f1ce5e19b84cec58dc87b037a09935c2f328"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.119",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zmij"
|
||||
version = "1.0.23"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
|
||||
Vendored
+9
@@ -0,0 +1,9 @@
|
||||
[workspace]
|
||||
resolver = "2"
|
||||
members = ["crates/*"]
|
||||
|
||||
[workspace.package]
|
||||
version = "0.0.1"
|
||||
edition = "2021"
|
||||
rust-version = "1.85"
|
||||
license = "MIT"
|
||||
Vendored
+21
@@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2026 FLARE contributors
|
||||
|
||||
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.
|
||||
Vendored
+12
@@ -0,0 +1,12 @@
|
||||
# One line per crate: <path> <lane>. Only the owning lane edits a crate;
|
||||
# other lanes ask it through a note. Only lane LD tags (see docs/vendoring.md).
|
||||
# scripts/check-owners.sh keeps this file and crates/ in step.
|
||||
crates/flare-ui LD
|
||||
crates/flare-plugin-abi LD
|
||||
crates/wschema LB
|
||||
crates/wschema-gen LB
|
||||
crates/wschema-cli LB
|
||||
crates/warden-sync LI
|
||||
crates/warden-seal LI
|
||||
crates/wapp-core LM
|
||||
crates/wapp-pack LM
|
||||
Vendored
+70
@@ -0,0 +1,70 @@
|
||||
# flare-ui
|
||||
|
||||
Shared UI and schema crates for FLARE and the Warden console. They provide
|
||||
schema forms, navigation, charts, page assets, editors and package validation.
|
||||
|
||||
- Licence: MIT.
|
||||
- Branches: `main` and `next`, like flare. Work branches from `next`.
|
||||
- Pinning: consumers vendor a tagged commit (`vN.N.N`) and record it in
|
||||
`flare-ui.lock`. They never pin an untagged commit, and CI jobs hold no
|
||||
cross-repo credential.
|
||||
- Layout: worktree per branch, `flare-ui/.bare` plus one folder per branch,
|
||||
kept in step with Gitea by `scripts/sync-worktrees.sh` (outside the repo).
|
||||
- Toolchain: `rust-toolchain.toml` pins one exact version.
|
||||
- Dash editor: `dash-editor/` holds the imported `flare-dash-editor` tree and
|
||||
its history (lane LD owns it). Its tests: `cd dash-editor && node --test tests/*.test.mjs`.
|
||||
- Flow builder: `flow-builder/` holds the automation flowchart (model, form,
|
||||
view). Its tests: `cd flow-builder && node --test tests/*.test.mjs`.
|
||||
- Validation corpus: `corpus/` (lane LB), described in `corpus/README.md`.
|
||||
- Crates and owners: see `OWNERS`. Vendoring and tags: `docs/vendoring.md`.
|
||||
|
||||
## Crates
|
||||
|
||||
| Crate | Role |
|
||||
|---|---|
|
||||
| `flare-ui` | Schema forms, navigation, chart islands, page assets and editor assets |
|
||||
| `wschema` | Schema document model, builder DSL, canonical JSON, hashes, lint L01 to L23 |
|
||||
| `wschema-cli` | `canon`, `hash`, `lint` and corpus `validate` for fragment authors and CI; `verify-lock` and `gen-lock` for consumer locks (`flare-ui.lock`, `gen.lock`) |
|
||||
| `wschema-gen` | Generators: the OpenAPI `components.schemas` of an effective schema and their splice into a template |
|
||||
| `warden-sync` | Sync stamps, HLC, windows, digest and planner (d03), and the wire and value limits both ends share, with golden limit vectors (`tests/vectors/limits-vectors.jsonl`) each end replays |
|
||||
| `warden-seal` | Per-Warden sealing (HPKE Auth): suite, `info` and `aad` builders, padding, kid, shared vectors |
|
||||
| `wapp-core` | App package format, manifests, platform checks and validation |
|
||||
| `wapp-pack` | Package creation, verification, signing, index and release guard CLI |
|
||||
| `flare-plugin-abi` | Reserved plugin ABI placeholder |
|
||||
|
||||
`wschema` depends on `serde`, `serde_json` and `sha2` only, and builds for
|
||||
x86_64 and `armv7-unknown-linux-musleabihf`.
|
||||
|
||||
## Checks
|
||||
|
||||
```
|
||||
cargo fmt --check
|
||||
cargo clippy --workspace --all-targets -- -D warnings
|
||||
cargo test --workspace
|
||||
scripts/check-owners.sh
|
||||
scripts/vendor-selftest.sh
|
||||
```
|
||||
|
||||
The [chart browser checks](crates/flare-ui/tests/browser/README.md) run on
|
||||
Chromium and Firefox over plain HTTP, with CSP and real SSE samples.
|
||||
The [live client](docs/live.md) documents typed chart props, server tier
|
||||
links, accessible latest values and named series events.
|
||||
|
||||
The shared crates also build for the panel:
|
||||
|
||||
```
|
||||
cargo build --locked --target armv7-unknown-linux-musleabihf \
|
||||
-p wschema -p warden-sync -p warden-seal -p wapp-core
|
||||
```
|
||||
|
||||
The OpenAPI emitter's sample output passes an OpenAPI 3.1 validator
|
||||
(`openapi-spec-validator`, not part of CI here; the consumer's CI runs it on
|
||||
the real document):
|
||||
|
||||
```
|
||||
cargo run -q -p wschema-gen --example openapi_sample > sample.yaml
|
||||
openapi-spec-validator sample.yaml
|
||||
```
|
||||
|
||||
Benchmarks for `wschema` (canonical JSON, hash, lint on a 140-setting
|
||||
document): `cargo bench -p wschema --bench canon_hash`.
|
||||
+49
@@ -0,0 +1,49 @@
|
||||
# Validation corpus
|
||||
|
||||
Cases that every implementation of the settings schema must answer the same
|
||||
way: `wschema` (flared and the FLARE server) and anything that ports it. The
|
||||
format is d02 "Corpus"; the reference is the module doc of
|
||||
`crates/wschema/src/corpus.rs`.
|
||||
|
||||
## Files
|
||||
|
||||
| File | What it holds |
|
||||
|---|---|
|
||||
| `generic.jsonl` | One or more cases per validation stage and code: path, key, cap, scope, `write_via`, type, range, enum, length, check, the cross-field rules, permissions, resets |
|
||||
| `flare-ported.jsonl` | The leaf cases of FLARE's `flare-server/src/tests_wardencfg.rs`, each with a `note` naming its test |
|
||||
| `schema/warden-base.json` | The schema both files run against: the Warden base as flare-edge emits it (`data/schema/base.json`, commit f6bc5281) |
|
||||
|
||||
A case's `schema` member names a base id (the base alone) or a fragment id
|
||||
(the base plus that fragment). Both files use `base`.
|
||||
|
||||
## Differences from FLARE
|
||||
|
||||
- An empty `system.hostname` is refused (V_LEN, d02 D25); FLARE stored it.
|
||||
- `network.interfaces.Eth0` is outside the path grammar (V_PATH), so the key
|
||||
check never sees it; `0eth` is the key-check case (V_KEY).
|
||||
- A VPN field written alone carries the other VPN fields in `ctx.rows`, since
|
||||
the `vpn` rules (all or none, allowed IPs once an address is set) now run.
|
||||
|
||||
## Running
|
||||
|
||||
```
|
||||
cargo test -p wschema --test corpus
|
||||
wschema-cli validate --schema corpus/schema/warden-base.json \
|
||||
--corpus corpus/generic.jsonl --corpus corpus/flare-ported.jsonl
|
||||
```
|
||||
|
||||
`validate_corpus` runs every `*.jsonl` here. It also fails when the generic
|
||||
file stops reaching a validation code the base can produce, and when any one
|
||||
flipped expectation goes unreported.
|
||||
|
||||
## Editing
|
||||
|
||||
Edit the JSON lines directly; one case per line, ASCII only. When flare-edge
|
||||
changes a row the cases touch, refresh `schema/warden-base.json` from its
|
||||
emitted `data/schema/base.json` and record the commit above. Each firmware
|
||||
also emits its own corpus from the `valid` and `invalid` vectors of its
|
||||
settings (`wschema::corpus::emit`). A setting that a cross-field rule
|
||||
refuses in the empty context declares a `vector_ctx` (DSL `vector_path`,
|
||||
`vector_row`): the concrete path and the stored rows its vectors run at.
|
||||
Each emitted case carries those rows in `ctx.rows`. Like the vectors, it is
|
||||
never emitted into the schema or hashed.
|
||||
+57
@@ -0,0 +1,57 @@
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.wifi.country", "value": "CA", "expect": {"ok": true}, "note": "flare tests_wardencfg.rs wifi_country_is_two_uppercase_letters_or_unset"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.wifi.country", "value": "ca", "expect": {"code": "V_CHECK"}, "note": "flare tests_wardencfg.rs wifi_country_is_two_uppercase_letters_or_unset"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.wifi.country", "value": "C", "expect": {"code": "V_CHECK"}, "note": "flare tests_wardencfg.rs wifi_country_is_two_uppercase_letters_or_unset"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.wifi.country", "value": "CAN", "expect": {"code": "V_CHECK"}, "note": "flare tests_wardencfg.rs wifi_country_is_two_uppercase_letters_or_unset"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.wifi.country", "value": "00", "expect": {"code": "V_CHECK"}, "note": "flare tests_wardencfg.rs wifi_country_is_two_uppercase_letters_or_unset"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.wifi.country", "value": "C1", "expect": {"code": "V_CHECK"}, "note": "flare tests_wardencfg.rs wifi_country_is_two_uppercase_letters_or_unset"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.wifi.country", "value": " CA", "expect": {"code": "V_CHECK"}, "note": "flare tests_wardencfg.rs wifi_country_is_two_uppercase_letters_or_unset"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.wifi.country", "value": 12, "expect": {"code": "V_TYPE"}, "note": "flare tests_wardencfg.rs wifi_country_is_two_uppercase_letters_or_unset"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.wifi.regdomain", "value": "CA", "expect": {"code": "V_PATH"}, "note": "flare tests_wardencfg.rs wifi_country_is_two_uppercase_letters_or_unset"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "display.brightness", "value": 101, "expect": {"code": "V_RANGE"}, "note": "flare tests_wardencfg.rs out_of_range_values_read_like_the_wardens_own_details"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "display.sleep_minutes", "value": 2, "expect": {"code": "V_ENUM"}, "note": "flare tests_wardencfg.rs out_of_range_values_read_like_the_wardens_own_details"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "display.theme", "value": "sepia", "expect": {"code": "V_ENUM"}, "note": "flare tests_wardencfg.rs out_of_range_values_read_like_the_wardens_own_details"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "rs485.baud", "value": 9601, "expect": {"code": "V_ENUM"}, "note": "flare tests_wardencfg.rs out_of_range_values_read_like_the_wardens_own_details"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "rs485.timeout_ms", "value": 60001, "expect": {"code": "V_RANGE"}, "note": "flare tests_wardencfg.rs out_of_range_values_read_like_the_wardens_own_details"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.vpn.keepalive_seconds", "value": 65536, "expect": {"code": "V_RANGE"}, "note": "flare tests_wardencfg.rs out_of_range_values_read_like_the_wardens_own_details"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.routing.lease", "value": "2h", "expect": {"code": "V_ENUM"}, "note": "flare tests_wardencfg.rs out_of_range_values_read_like_the_wardens_own_details"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.routing.lease", "value": "12h", "expect": {"ok": true}, "note": "flare tests_wardencfg.rs out_of_range_values_read_like_the_wardens_own_details"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "display.sleep_minutes", "value": 0, "expect": {"ok": true}, "note": "flare tests_wardencfg.rs out_of_range_values_read_like_the_wardens_own_details"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "system.timezone", "value": "CET-1CEST,M3.5.0,M10.5.0/3", "expect": {"ok": true}, "note": "flare tests_wardencfg.rs timezone_is_curated_or_empty"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "system.timezone", "value": "Europe/Berlin", "expect": {"code": "V_ENUM"}, "note": "flare tests_wardencfg.rs timezone_is_curated_or_empty"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "system.hostname", "value": "warden-07", "expect": {"ok": true}, "note": "flare tests_wardencfg.rs hostname_is_an_rfc1123_label_or_empty"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "system.hostname", "value": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "expect": {"ok": true}, "note": "flare tests_wardencfg.rs hostname_is_an_rfc1123_label_or_empty"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "system.hostname", "value": "", "expect": {"code": "V_LEN"}, "note": "flare tests_wardencfg.rs hostname_is_an_rfc1123_label_or_empty; d02 D25 refuses an empty hostname where FLARE stored it"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "system.hostname", "value": "-edge", "expect": {"code": "V_CHECK"}, "note": "flare tests_wardencfg.rs hostname_is_an_rfc1123_label_or_empty"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "system.hostname", "value": "edge-", "expect": {"code": "V_CHECK"}, "note": "flare tests_wardencfg.rs hostname_is_an_rfc1123_label_or_empty"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "system.hostname", "value": "no.dots", "expect": {"code": "V_CHECK"}, "note": "flare tests_wardencfg.rs hostname_is_an_rfc1123_label_or_empty"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "system.hostname", "value": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "expect": {"code": "V_CHECK"}, "note": "flare tests_wardencfg.rs hostname_is_an_rfc1123_label_or_empty"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.ap.address", "value": "10.0.0.1/24", "expect": {"ok": true}, "note": "flare tests_wardencfg.rs addresses_and_endpoints_follow_the_yaml_patterns"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.ap.address", "value": "10.0.0.1/31", "expect": {"code": "V_CHECK"}, "note": "flare tests_wardencfg.rs addresses_and_endpoints_follow_the_yaml_patterns"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.ap.address", "value": "", "expect": {"code": "V_LEN"}, "note": "flare tests_wardencfg.rs addresses_and_endpoints_follow_the_yaml_patterns"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.routing.lan_address", "value": "300.1.1.1/24", "expect": {"code": "V_CHECK"}, "note": "flare tests_wardencfg.rs addresses_and_endpoints_follow_the_yaml_patterns"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.vpn.address", "value": "10.99.0.2/33", "expect": {"code": "V_CHECK"}, "note": "flare tests_wardencfg.rs addresses_and_endpoints_follow_the_yaml_patterns"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {"rows": {"network.vpn.peer_endpoint": "hub.example.test:51820", "network.vpn.peer_public_key": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", "network.vpn.allowed_ips": "10.99.0.0/24"}}, "path": "network.vpn.address", "value": "10.99.0.2/32", "expect": {"ok": true}, "note": "flare tests_wardencfg.rs addresses_and_endpoints_follow_the_yaml_patterns; the other VPN fields set so the vpn rules hold"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.vpn.address", "value": "", "expect": {"ok": true}, "note": "flare tests_wardencfg.rs addresses_and_endpoints_follow_the_yaml_patterns"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {"rows": {"network.vpn.address": "10.99.0.2/32", "network.vpn.peer_public_key": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", "network.vpn.allowed_ips": "10.99.0.0/24"}}, "path": "network.vpn.peer_endpoint", "value": "[2001:db8::1]:51820", "expect": {"ok": true}, "note": "flare tests_wardencfg.rs addresses_and_endpoints_follow_the_yaml_patterns; the other VPN fields set so the vpn rules hold"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {"rows": {"network.vpn.address": "10.99.0.2/32", "network.vpn.peer_endpoint": "hub.example.test:51820", "network.vpn.allowed_ips": "10.99.0.0/24"}}, "path": "network.vpn.peer_public_key", "value": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", "expect": {"ok": true}, "note": "flare tests_wardencfg.rs addresses_and_endpoints_follow_the_yaml_patterns; the other VPN fields set so the vpn rules hold"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.vpn.peer_public_key", "value": "", "expect": {"ok": true}, "note": "flare tests_wardencfg.rs addresses_and_endpoints_follow_the_yaml_patterns"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.proxy.pac", "value": "", "expect": {"ok": true}, "note": "flare tests_wardencfg.rs addresses_and_endpoints_follow_the_yaml_patterns"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.proxy.http", "value": "proxy.example.test:3128", "expect": {"ok": true}, "note": "flare tests_wardencfg.rs addresses_and_endpoints_follow_the_yaml_patterns"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.proxy.http", "value": "no-port", "expect": {"code": "V_CHECK"}, "note": "flare tests_wardencfg.rs addresses_and_endpoints_follow_the_yaml_patterns"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.proxy.socks", "value": "spaced host:80", "expect": {"code": "V_CHECK"}, "note": "flare tests_wardencfg.rs addresses_and_endpoints_follow_the_yaml_patterns"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.proxy.pac", "value": "http://wpad.example.test/wpad.dat", "expect": {"ok": true}, "note": "flare tests_wardencfg.rs addresses_and_endpoints_follow_the_yaml_patterns"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.proxy.pac", "value": "ftp://x", "expect": {"code": "V_CHECK"}, "note": "flare tests_wardencfg.rs addresses_and_endpoints_follow_the_yaml_patterns"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.vpn.peer_public_key", "value": "short=", "expect": {"code": "V_CHECK"}, "note": "flare tests_wardencfg.rs addresses_and_endpoints_follow_the_yaml_patterns"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.vpn.allowed_ips", "value": "10.0.0.0/8, 192.168.0.0/16", "expect": {"ok": true}, "note": "flare tests_wardencfg.rs string_byte_caps_are_the_stores_own"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.vpn.allowed_ips", "value": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "expect": {"code": "V_LEN"}, "note": "flare tests_wardencfg.rs string_byte_caps_are_the_stores_own"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "system.ntp.server", "value": "two\nlines", "expect": {"code": "V_CHECK"}, "note": "flare tests_wardencfg.rs string_byte_caps_are_the_stores_own"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.ap.ssid", "value": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "expect": {"ok": true}, "note": "flare tests_wardencfg.rs string_byte_caps_are_the_stores_own"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.ap.ssid", "value": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "expect": {"code": "V_CHECK"}, "note": "flare tests_wardencfg.rs string_byte_caps_are_the_stores_own"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.ap.passphrase", "value": "1234567", "expect": {"code": "V_CHECK"}, "note": "flare tests_wardencfg.rs string_byte_caps_are_the_stores_own"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.ap.passphrase", "value": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "expect": {"code": "V_LEN"}, "note": "flare tests_wardencfg.rs string_byte_caps_are_the_stores_own"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.ap.passphrase", "value": "snowman\u2603pass", "expect": {"code": "V_CHECK"}, "note": "flare tests_wardencfg.rs string_byte_caps_are_the_stores_own"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.interfaces.eth0.zone", "value": "lan", "expect": {"ok": true}, "note": "flare tests_wardencfg.rs interface_names_and_app_ids_follow_their_key_patterns"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.interfaces.Eth0.zone", "value": "lan", "expect": {"code": "V_PATH"}, "note": "flare tests_wardencfg.rs interface_names_and_app_ids_follow_their_key_patterns"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.interfaces.0eth.zone", "value": "lan", "expect": {"code": "V_KEY"}, "note": "flare tests_wardencfg.rs interface_names_and_app_ids_follow_their_key_patterns"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.interfaces.eth-0.zone", "value": "lan", "expect": {"code": "V_KEY"}, "note": "flare tests_wardencfg.rs interface_names_and_app_ids_follow_their_key_patterns"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.interfaces.abcdefghijklmnop.zone", "value": "lan", "expect": {"code": "V_KEY"}, "note": "flare tests_wardencfg.rs interface_names_and_app_ids_follow_their_key_patterns"}
|
||||
+60
@@ -0,0 +1,60 @@
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.wifi.regdomain", "value": "CA", "expect": {"code": "V_PATH"}, "note": "not a setting"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network..wifi", "value": "x", "expect": {"code": "V_PATH"}, "note": "malformed path"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "display.brightness.extra", "value": 1, "expect": {"code": "V_PATH"}, "note": "a leaf has no children"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.wifi.country", "reset": true, "expect": {"ok": true}, "note": "a reset of a synced setting from FLARE"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "$meta.fp_key", "value": "k", "expect": {"ok": true}, "note": "meta path handled before the schema"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "$meta.unknown", "value": "k", "expect": {"code": "V_PATH"}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.interfaces.Eth0.zone", "value": "lan", "expect": {"code": "V_PATH"}, "note": "uppercase is outside the path grammar, so the key check never sees it"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.interfaces.0eth.zone", "value": "lan", "expect": {"code": "V_KEY"}, "note": "ifname key check: starts with a letter"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "relays.8.safe_state", "value": "open", "expect": {"code": "V_KEY"}, "note": "index key above max 7"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "relays.7.safe_state", "value": "open", "expect": {"ok": true}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {"rows": {"network.interfaces.eth0.ipv4.method": "dhcp", "network.interfaces.eth1.ipv4.method": "dhcp", "network.interfaces.eth2.ipv4.method": "dhcp", "network.interfaces.eth3.ipv4.method": "dhcp", "network.interfaces.eth4.ipv4.method": "dhcp", "network.interfaces.eth5.ipv4.method": "dhcp", "network.interfaces.eth6.ipv4.method": "dhcp", "network.interfaces.eth7.ipv4.method": "dhcp", "network.interfaces.eth8.ipv4.method": "dhcp", "network.interfaces.eth9.ipv4.method": "dhcp", "network.interfaces.eth10.ipv4.method": "dhcp", "network.interfaces.eth11.ipv4.method": "dhcp", "network.interfaces.eth12.ipv4.method": "dhcp", "network.interfaces.eth13.ipv4.method": "dhcp", "network.interfaces.eth14.ipv4.method": "dhcp", "network.interfaces.eth15.ipv4.method": "dhcp"}}, "path": "network.interfaces.eth16.ipv4.method", "value": "dhcp", "expect": {"code": "V_CAP"}, "note": "17th entry of a 16-entry map"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {"rows": {"network.interfaces.eth0.ipv4.method": "dhcp", "network.interfaces.eth1.ipv4.method": "dhcp", "network.interfaces.eth2.ipv4.method": "dhcp", "network.interfaces.eth3.ipv4.method": "dhcp", "network.interfaces.eth4.ipv4.method": "dhcp", "network.interfaces.eth5.ipv4.method": "dhcp", "network.interfaces.eth6.ipv4.method": "dhcp", "network.interfaces.eth7.ipv4.method": "dhcp", "network.interfaces.eth8.ipv4.method": "dhcp", "network.interfaces.eth9.ipv4.method": "dhcp", "network.interfaces.eth10.ipv4.method": "dhcp", "network.interfaces.eth11.ipv4.method": "dhcp", "network.interfaces.eth12.ipv4.method": "dhcp", "network.interfaces.eth13.ipv4.method": "dhcp", "network.interfaces.eth14.ipv4.method": "dhcp", "network.interfaces.eth15.ipv4.method": "dhcp"}}, "path": "network.interfaces.eth15.ipv4.method", "value": "dhcp", "expect": {"ok": true}, "note": "an existing entry never counts twice"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {"rows": {"network.interfaces.eth0.ipv4.method": "dhcp", "network.interfaces.eth1.ipv4.method": "dhcp", "network.interfaces.eth2.ipv4.method": "dhcp", "network.interfaces.eth3.ipv4.method": "dhcp", "network.interfaces.eth4.ipv4.method": "dhcp", "network.interfaces.eth5.ipv4.method": "dhcp", "network.interfaces.eth6.ipv4.method": "dhcp", "network.interfaces.eth7.ipv4.method": "dhcp", "network.interfaces.eth8.ipv4.method": "dhcp", "network.interfaces.eth9.ipv4.method": "dhcp", "network.interfaces.eth10.ipv4.method": "dhcp", "network.interfaces.eth11.ipv4.method": "dhcp", "network.interfaces.eth12.ipv4.method": "dhcp", "network.interfaces.eth13.ipv4.method": "dhcp", "network.interfaces.eth14.ipv4.method": "dhcp", "network.interfaces.eth15.ipv4.method": "dhcp"}}, "path": "network.interfaces.eth16.ipv4.method", "reset": true, "expect": {"ok": true}, "note": "a reset never counts against the cap"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "display.debug_overlay", "value": true, "expect": {"code": "V_SCOPE"}, "note": "device_only from FLARE"}
|
||||
{"schema": "base", "origin": "panel", "ctx": {}, "path": "display.debug_overlay", "value": true, "expect": {"ok": true}}
|
||||
{"schema": "base", "origin": "panel", "ctx": {}, "path": "network.ap.local.password", "value": "secret12", "expect": {"code": "V_VIA"}, "note": "write_via: only the action writes it"}
|
||||
{"schema": "base", "origin": "system", "ctx": {}, "path": "network.ap.local.password", "value": "secret12", "expect": {"ok": true}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "display.brightness", "value": "50", "expect": {"code": "V_TYPE"}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "display.brightness", "value": null, "expect": {"code": "V_TYPE"}, "note": "null is not a value; reset is the op for that"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "display.brightness", "value": 50.5, "expect": {"code": "V_TYPE"}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "display.brightness", "value": -1, "expect": {"code": "V_RANGE"}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "display.brightness", "value": 0, "expect": {"ok": true}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "display.theme", "value": "sepia", "expect": {"code": "V_ENUM"}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "display.sleep_minutes", "value": 2, "expect": {"code": "V_ENUM"}, "note": "int_set"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "relays.lease_max_s", "value": 59, "expect": {"code": "V_RANGE"}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "relays.lease_max_s", "value": 86400, "expect": {"ok": true}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.interfaces.eth0.ipv4.dns", "value": ["1.1.1.1", "9.9.9.9"], "expect": {"ok": true}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.interfaces.eth0.ipv4.dns", "value": ["1.1.1.1", "dns.example"], "expect": {"code": "V_CHECK"}, "note": "list item check"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.interfaces.eth0.ipv4.dns", "value": ["1.1.1.1", "1.1.1.1", "1.1.1.1", "1.1.1.1", "1.1.1.1"], "expect": {"code": "V_LEN"}, "note": "max_items 4"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.interfaces.eth0.ipv4.dns", "value": [1], "expect": {"code": "V_TYPE"}, "note": "list items are strings"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.scan_ranges", "value": ["10.0.0.0/8"], "expect": {"ok": true}, "note": "a CIDR counts once toward the expansion cap"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.scan_ranges", "value": ["10.0-255.0-1.1-255"], "expect": {"code": "V_CHECK"}, "note": "scan_expansion_cap: 512 /24 ranges"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.scan_ranges", "value": ["192.168.1.0/24"], "expect": {"ok": true}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.ap.passphrase", "value": "short", "expect": {"code": "V_CHECK"}, "note": "secret kind with a check"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.ap.passphrase", "value": "12345678", "expect": {"ok": true}}
|
||||
{"schema": "base", "origin": "panel", "ctx": {}, "path": "display.debug_overlay", "value": "true", "expect": {"code": "V_TYPE"}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "display.brightness", "reset": true, "expect": {"ok": true}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.wifi.nope", "reset": true, "expect": {"code": "V_PATH"}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.ap.security", "value": "WPA2", "expect": {"code": "V_REQUIRES"}, "note": "PSK needs a passphrase"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {"rows": {"network.ap.passphrase": "12345678"}}, "path": "network.ap.security", "value": "WPA2", "expect": {"ok": true}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.ap.security", "value": "Open", "expect": {"ok": true}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.interfaces.eth0.ipv4.method", "value": "manual", "expect": {"code": "V_REQUIRES"}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {"rows": {"network.interfaces.eth0.ipv4.address": "10.1.0.2/24"}}, "path": "network.interfaces.eth0.ipv4.method", "value": "manual", "expect": {"ok": true}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {"rows": {"network.interfaces.eth0.zone": "wan"}}, "path": "network.interfaces.eth1.zone", "value": "wan", "expect": {"code": "V_EXCLUSIVE"}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {"rows": {"network.interfaces.eth0.zone": "wan"}}, "path": "network.interfaces.eth1.zone", "value": "lan", "expect": {"ok": true}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {"rows": {"network.interfaces.eth0.zone": "wan"}}, "path": "network.interfaces.eth0.zone", "value": "wan", "expect": {"ok": true}, "note": "rewriting the entry that holds the value"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {"rows": {"network.routing.lan_address": "192.168.50.1/24"}}, "path": "network.ap.address", "value": "192.168.50.1/24", "expect": {"code": "V_OVERLAP"}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {"rows": {"network.routing.lan_address": "192.168.50.1/24"}}, "path": "network.ap.address", "value": "10.254.1.1/24", "expect": {"ok": true}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.vpn.peer_endpoint", "value": "hub.example.test:51820", "expect": {"code": "V_ALL_OR_NONE"}, "note": "flare-ui#13: the other two hold their empty default"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {"rows": {"network.vpn.peer_endpoint": "hub.example.test:51820", "network.vpn.peer_public_key": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="}}, "path": "network.vpn.address", "value": "10.99.0.2/32", "expect": {"code": "V_REQUIRES"}, "note": "flare-ui#13: allowed_ips is empty"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {"rows": {"network.vpn.peer_endpoint": "hub.example.test:51820", "network.vpn.peer_public_key": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", "network.vpn.allowed_ips": "10.99.0.0/24"}}, "path": "network.vpn.address", "value": "10.99.0.2/32", "expect": {"ok": true}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.vpn.address", "value": "", "expect": {"ok": true}, "note": "all three empty is the none state"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {"usable_wifi_credentials": false, "rows": {"network.ap.local.enabled": false}}, "path": "network.ap.security", "value": "WPA2-Enterprise", "expect": {"code": "V_RULE"}, "note": "ap_enterprise_credentials"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {"usable_wifi_credentials": false, "rows": {"network.ap.local.enabled": true}}, "path": "network.ap.security", "value": "WPA2-Enterprise", "expect": {"ok": true}}
|
||||
{"schema": "base", "origin": "flare", "ctx": {}, "path": "network.ap.security", "value": "WPA2-Enterprise", "expect": {"ok": true}, "note": "named rules without their context input are skipped"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {"tls_state": "self_signed"}, "path": "network.ap.security", "value": "WPA2-Enterprise", "expect": {"code": "V_RULE"}, "note": "ap_enterprise_cert"}
|
||||
{"schema": "base", "origin": "flare", "ctx": {"tls_state": "public"}, "path": "network.ap.security", "value": "WPA2-Enterprise", "expect": {"ok": true}}
|
||||
{"schema": "base", "origin": "web", "ctx": {"perms": ["site.view"]}, "path": "display.brightness", "value": 50, "expect": {"code": "V_PERM"}}
|
||||
{"schema": "base", "origin": "web", "ctx": {"perms": ["site.manage"]}, "path": "display.brightness", "value": 50, "expect": {"ok": true}}
|
||||
{"schema": "base", "origin": "migration", "ctx": {"perms": []}, "path": "display.brightness", "value": 50, "expect": {"ok": true}, "note": "internal origins skip permissions"}
|
||||
+5725
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,10 @@
|
||||
[package]
|
||||
name = "flare-plugin-abi"
|
||||
version.workspace = true
|
||||
edition.workspace = true
|
||||
rust-version.workspace = true
|
||||
license.workspace = true
|
||||
description = "Plugin ABI shared by FLARE and the Warden console"
|
||||
publish = false
|
||||
|
||||
[dependencies]
|
||||
@@ -0,0 +1,16 @@
|
||||
//! Plugin ABI shared by FLARE and the Warden console.
|
||||
//!
|
||||
//! Placeholder until its owning lane lands the real crate (see OWNERS).
|
||||
|
||||
/// Crate name, used by consumers to check which pin they vendored.
|
||||
pub const NAME: &str = "flare-plugin-abi";
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn name_is_stable() {
|
||||
assert_eq!(NAME, "flare-plugin-abi");
|
||||
}
|
||||
}
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
[package]
|
||||
name = "flare-ui"
|
||||
version.workspace = true
|
||||
edition.workspace = true
|
||||
rust-version.workspace = true
|
||||
license.workspace = true
|
||||
description = "Shared UI crate for FLARE and the Warden console: schema renderer, nav model, dash editor assets, LVGL table generator"
|
||||
publish = false
|
||||
|
||||
[dependencies]
|
||||
wschema = { path = "../wschema" }
|
||||
serde_json = "1"
|
||||
maud = "0.27"
|
||||
|
||||
[dev-dependencies]
|
||||
criterion = { version = "0.5", default-features = false }
|
||||
|
||||
[[bench]]
|
||||
name = "chart"
|
||||
harness = false
|
||||
@@ -0,0 +1,184 @@
|
||||
/* Shared component styles. Every value comes from tokens.css. */
|
||||
.bf-btn {
|
||||
display: inline-block;
|
||||
padding: var(--bf-space-2) var(--bf-space-4);
|
||||
cursor: pointer;
|
||||
}
|
||||
.bf-btn-primary {
|
||||
font-weight: 600;
|
||||
}
|
||||
.bf-badge {
|
||||
display: inline-block;
|
||||
padding: 0 var(--bf-space-2);
|
||||
}
|
||||
.bf-badge-ok {
|
||||
font-weight: 600;
|
||||
}
|
||||
.bf-badge-warn {
|
||||
font-weight: 600;
|
||||
}
|
||||
.bf-badge-err {
|
||||
font-weight: 700;
|
||||
}
|
||||
.bf-card {
|
||||
padding: var(--bf-space-4);
|
||||
}
|
||||
.bf-card-title {
|
||||
margin: 0 0 var(--bf-space-2);
|
||||
}
|
||||
.bf-table {
|
||||
width: 100%;
|
||||
border-collapse: collapse;
|
||||
}
|
||||
.bf-stale {
|
||||
opacity: 0.6;
|
||||
}
|
||||
.bf-shell {
|
||||
display: flex;
|
||||
min-height: 100vh;
|
||||
}
|
||||
.bf-sidebar {
|
||||
padding: var(--bf-space-4);
|
||||
}
|
||||
.bf-nav-section {
|
||||
margin: 0 0 var(--bf-space-4);
|
||||
}
|
||||
.bf-nav-section-title {
|
||||
margin: 0 0 var(--bf-space-2);
|
||||
}
|
||||
.bf-nav-link {
|
||||
display: block;
|
||||
padding: var(--bf-space-1) var(--bf-space-2);
|
||||
text-decoration: none;
|
||||
}
|
||||
.bf-nav-active {
|
||||
font-weight: 700;
|
||||
}
|
||||
.bf-main {
|
||||
flex: 1;
|
||||
padding: var(--bf-space-4);
|
||||
}
|
||||
.bf-tabs {
|
||||
display: flex;
|
||||
gap: var(--bf-space-2);
|
||||
margin: 0 0 var(--bf-space-4);
|
||||
}
|
||||
.bf-field {
|
||||
margin: 0 0 var(--bf-space-4);
|
||||
}
|
||||
.bf-field-label {
|
||||
display: block;
|
||||
margin: 0 0 var(--bf-space-1);
|
||||
}
|
||||
.bf-field-help {
|
||||
margin: var(--bf-space-1) 0 0;
|
||||
}
|
||||
.bf-field-error {
|
||||
margin: var(--bf-space-1) 0 0;
|
||||
font-weight: 600;
|
||||
}
|
||||
.bf-input {
|
||||
width: 100%;
|
||||
padding: var(--bf-space-2);
|
||||
}
|
||||
.bf-segmented {
|
||||
display: flex;
|
||||
gap: var(--bf-space-2);
|
||||
}
|
||||
.bf-segment {
|
||||
padding: var(--bf-space-1) var(--bf-space-2);
|
||||
cursor: pointer;
|
||||
}
|
||||
.bf-switch {
|
||||
display: inline-flex;
|
||||
gap: var(--bf-space-2);
|
||||
cursor: pointer;
|
||||
}
|
||||
.bf-kv {
|
||||
display: flex;
|
||||
justify-content: space-between;
|
||||
gap: var(--bf-space-2);
|
||||
padding: var(--bf-space-1) 0;
|
||||
}
|
||||
.bf-kv-label {
|
||||
display: inline-block;
|
||||
}
|
||||
.bf-kv-value {
|
||||
font-variant-numeric: tabular-nums;
|
||||
}
|
||||
.bf-gauge {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: var(--bf-space-2);
|
||||
}
|
||||
.bf-gauge-bar {
|
||||
flex: 1;
|
||||
}
|
||||
.bf-hero {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
align-items: flex-start;
|
||||
}
|
||||
.bf-hero-value {
|
||||
font-size: 3rem;
|
||||
font-weight: 700;
|
||||
font-variant-numeric: tabular-nums;
|
||||
}
|
||||
.bf-hero-units {
|
||||
display: inline-block;
|
||||
}
|
||||
.bf-log {
|
||||
margin: 0;
|
||||
padding: 0 0 0 var(--bf-space-4);
|
||||
font-family: monospace;
|
||||
}
|
||||
.bf-chart {
|
||||
margin: 0;
|
||||
}
|
||||
.bf-chart-canvas {
|
||||
width: 100%;
|
||||
height: 12rem;
|
||||
}
|
||||
.bf-vh {
|
||||
position: absolute;
|
||||
width: 1px;
|
||||
height: 1px;
|
||||
padding: 0;
|
||||
border: 0;
|
||||
overflow: hidden;
|
||||
clip: rect(0, 0, 0, 0);
|
||||
clip-path: inset(50%);
|
||||
white-space: nowrap;
|
||||
}
|
||||
.bf-note {
|
||||
margin: 0 0 var(--bf-space-2);
|
||||
}
|
||||
.bf-plate {
|
||||
display: grid;
|
||||
grid-template-columns: max-content 1fr;
|
||||
gap: var(--bf-space-1) var(--bf-space-4);
|
||||
margin: 0;
|
||||
}
|
||||
.bf-btn-danger {
|
||||
background: var(--bf-color-danger);
|
||||
color: #fff;
|
||||
}
|
||||
.bf-action {
|
||||
display: inline-block;
|
||||
margin: 0 var(--bf-space-2) var(--bf-space-2) 0;
|
||||
}
|
||||
.bf-action-confirm {
|
||||
margin: 0 0 var(--bf-space-1);
|
||||
}
|
||||
.bf-approvals {
|
||||
list-style: none;
|
||||
margin: 0;
|
||||
padding: 0;
|
||||
}
|
||||
.bf-approval {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
gap: var(--bf-space-2);
|
||||
align-items: center;
|
||||
padding: var(--bf-space-2) 0;
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
/* flare-ui page glue (UI-6): one call wires the live stream, stale marker,
|
||||
* chart island, table sort and the htmx CSRF header. Reads two optional
|
||||
* <meta> tags: bf-stream (SSE URL) and bf-csrf (token). No dependencies. */
|
||||
(function (root, factory) {
|
||||
if (typeof module === "object" && module.exports) module.exports = factory(root);
|
||||
else root.FlareBoot = factory(root);
|
||||
})(typeof self !== "undefined" ? self : this, function (root) {
|
||||
"use strict";
|
||||
|
||||
function meta(doc, name) {
|
||||
var m = doc.querySelector('meta[name="' + name + '"]');
|
||||
return m ? m.getAttribute("content") : null;
|
||||
}
|
||||
|
||||
/* Same-origin check on a stream URL: path-absolute, not protocol-relative. */
|
||||
function safeStream(url) {
|
||||
return typeof url === "string" && url.charAt(0) === "/" && url.charAt(1) !== "/" &&
|
||||
url.indexOf("\\") < 0 && !/[\x00-\x20\x7f]/.test(url);
|
||||
}
|
||||
|
||||
/* htmx:configRequest handler: adds the CSRF header to every htmx request. */
|
||||
function csrfHeader(token) {
|
||||
return function (evt) {
|
||||
if (token && evt && evt.detail && evt.detail.headers) {
|
||||
evt.detail.headers["X-CSRF-Token"] = token;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/* env: { Live, Charts, Islands, doc, loc } injected so tests need no browser. */
|
||||
function boot(env) {
|
||||
var doc = env.doc;
|
||||
var result = { live: null, csrf: false };
|
||||
var token = meta(doc, "bf-csrf");
|
||||
if (token) {
|
||||
doc.body.addEventListener("htmx:configRequest", csrfHeader(token));
|
||||
result.csrf = true;
|
||||
}
|
||||
if (env.Islands) env.Islands.bindTableSort(doc, env.loc);
|
||||
var url = meta(doc, "bf-stream");
|
||||
if (url && safeStream(url) && env.Live) {
|
||||
var live = new env.Live.Live(url);
|
||||
env.Live.bindStaleMarker(live, doc);
|
||||
if (env.Charts) env.Charts.bindCharts(live, doc);
|
||||
live.start();
|
||||
result.live = live;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
function auto() {
|
||||
if (typeof document === "undefined") return;
|
||||
boot({
|
||||
doc: document, loc: location,
|
||||
Live: root.FlareLive, Charts: root.FlareChart, Islands: root.FlareIslands
|
||||
});
|
||||
}
|
||||
if (typeof document !== "undefined") {
|
||||
if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", auto);
|
||||
else auto();
|
||||
}
|
||||
|
||||
return { boot: boot, safeStream: safeStream, csrfHeader: csrfHeader };
|
||||
});
|
||||
@@ -0,0 +1,533 @@
|
||||
(function (root, factory) {
|
||||
if (typeof module === "object" && module.exports) module.exports = factory();
|
||||
else root.FlareChart = factory();
|
||||
})(typeof self !== "undefined" ? self : this, function () {
|
||||
"use strict";
|
||||
|
||||
/* Retained Warden renderer. */
|
||||
function createEngine(env) {
|
||||
env = env || {};
|
||||
var window = env.window;
|
||||
var document = env.document || (window && window.document);
|
||||
if (!window || !document) throw new Error("canvas engine needs a window and document");
|
||||
var state = env.state || { chartTier: "min", prevGenMs: 0 };
|
||||
var reduceMotion = env.reduceMotion || window.matchMedia("(prefers-reduced-motion: reduce)");
|
||||
var now = env.now || function () { return window.performance.now(); };
|
||||
var getComputedStyle = env.getComputedStyle || function (el) { return window.getComputedStyle(el); };
|
||||
var paletteMemo = null; // invalidated by the binding on each new feed
|
||||
function palette(){
|
||||
if (paletteMemo) return paletteMemo;
|
||||
var cs = getComputedStyle(document.documentElement);
|
||||
function c(n){ return (cs.getPropertyValue('--'+n)||'').trim(); }
|
||||
return (paletteMemo = { accent:c('accent')||'#3776BE', flame:c('flame')||'#F26522',
|
||||
ok:c('ok')||'#1E8E4E', border:c('border')||'#D5DAE3',
|
||||
muted:c('text-muted')||'#5A6577', font:c('font-body')||'sans-serif' });
|
||||
}
|
||||
function hexToRgba(hex, a){
|
||||
var m = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i.exec((hex||'').trim());
|
||||
if(!m) return hex;
|
||||
var h = m[1]; if(h.length===3) h = h[0]+h[0]+h[1]+h[1]+h[2]+h[2];
|
||||
return 'rgba('+parseInt(h.slice(0,2),16)+','+parseInt(h.slice(2,4),16)+','+parseInt(h.slice(4,6),16)+','+a+')';
|
||||
}
|
||||
function fitCanvas(cv){
|
||||
var r = cv.getBoundingClientRect();
|
||||
var w = Math.round(r.width), h = Math.round(r.height);
|
||||
if(w<=0 || h<=0) return null;
|
||||
var dpr = Math.min(2.5, window.devicePixelRatio || 1);
|
||||
var bw = Math.round(w*dpr), bh = Math.round(h*dpr);
|
||||
if(cv.width !== bw) cv.width = bw;
|
||||
if(cv.height !== bh) cv.height = bh;
|
||||
var ctx = cv.getContext('2d');
|
||||
ctx.setTransform(dpr,0,0,dpr,0,0);
|
||||
return { ctx:ctx, w:w, h:h, dpr:dpr };
|
||||
}
|
||||
var GRAPH_SUBDIV = 12;
|
||||
function catmull(p0,p1,p2,p3,t){
|
||||
var t2 = t*t, t3 = t2*t;
|
||||
return 0.5*((2*p1) + (-p0+p2)*t + (2*p0-5*p1+4*p2-p3)*t2 + (-p0+3*p1-3*p2+p3)*t3);
|
||||
}
|
||||
function sampleAt(v,n,i){ if(i<0)i=0; if(i>n-1)i=n-1; return v[i]; }
|
||||
|
||||
var SLIDE_SLOTS = 9;
|
||||
var LAG_LOW = 2.5;
|
||||
var LAG_START = 3;
|
||||
var LAG_OVERRUN = 3;
|
||||
var MAX_ADVANCE = 8;
|
||||
var MAX_HISTORY = 72;
|
||||
|
||||
function chartSlide(frame, ts){
|
||||
if (!frame.vel) return frame.slide0;
|
||||
return Math.min(frame.maxSlide, frame.slide0 + frame.vel * Math.max(0, ts - frame.feedAt));
|
||||
}
|
||||
|
||||
function alignAdvance(prior, fresh, expected){
|
||||
var best = -1, bestGap = 1e9;
|
||||
for (var k = 0; k <= MAX_ADVANCE; k++) {
|
||||
var ok = true, judged = 0;
|
||||
for (var i = 0; ok && i < fresh.length; i++) {
|
||||
var a = prior[i], b = fresh[i];
|
||||
if (!a || !b) continue;
|
||||
var n = Math.min(a.length, b.length - k, 30);
|
||||
if (n < 4) continue;
|
||||
judged++;
|
||||
for (var j = 0; j < n; j++) {
|
||||
var x = b[b.length - 1 - k - j], y = a[a.length - 1 - j];
|
||||
if (Math.abs(x - y) > 1e-6 * (1 + Math.abs(y))) { ok = false; break; }
|
||||
}
|
||||
}
|
||||
if (ok && judged) {
|
||||
var gap = Math.abs(k - expected);
|
||||
if (gap < bestGap) { best = k; bestGap = gap; }
|
||||
}
|
||||
}
|
||||
return best;
|
||||
}
|
||||
|
||||
function layerFor(cv, key, w, h, dpr){
|
||||
var l = cv[key] || (cv[key] = document.createElement('canvas'));
|
||||
var bw = Math.max(1, Math.ceil(w * dpr)), bh = Math.max(1, Math.ceil(h * dpr));
|
||||
if (l.width !== bw) l.width = bw;
|
||||
if (l.height !== bh) l.height = bh;
|
||||
var c = l.getContext('2d');
|
||||
c.setTransform(1,0,0,1,0,0); c.clearRect(0,0,bw,bh);
|
||||
c.setTransform(dpr,0,0,dpr,0,0);
|
||||
return { el:l, ctx:c };
|
||||
}
|
||||
|
||||
function paintLines(cv, spec){
|
||||
var generation = state.prevGenMs || 0, t = now();
|
||||
var minute = state.chartTier === 'min';
|
||||
var animated = minute && !reduceMotion.matches;
|
||||
var slots = animated ? SLIDE_SLOTS : 0;
|
||||
|
||||
var advanced = -1, total = 0;
|
||||
if (minute) {
|
||||
var prior = cv.__history, fresh = spec.series.map(function(s){ return (s.data || []).slice(); });
|
||||
if (prior) advanced = alignAdvance(prior.series, fresh, Math.round((generation - prior.gen) / 1000));
|
||||
spec.series = spec.series.map(function(s, i){
|
||||
var data = fresh[i], old = prior && advanced >= 0 && prior.series[i];
|
||||
if (old) {
|
||||
var joined = advanced > 0 ? old.concat(data.slice(-advanced)) : old;
|
||||
if (joined.length >= data.length) data = joined;
|
||||
}
|
||||
return { data:data.slice(-MAX_HISTORY), color:s.color, area:s.area };
|
||||
});
|
||||
total = advanced >= 0 ? prior.total + advanced : 0;
|
||||
cv.__history = { gen:generation, revision:spec.historyRevision, total:total,
|
||||
series:spec.series.map(function(s){ return s.data.slice(); }) };
|
||||
} else cv.__history = null;
|
||||
|
||||
var clk = null;
|
||||
if (animated) {
|
||||
clk = cv.__clock;
|
||||
if (!clk || advanced < 0) clk = { lag:LAG_START, v:1, t:t, arrived:t, T:2 };
|
||||
else {
|
||||
clk.lag = Math.max(-LAG_OVERRUN, clk.lag - clk.v * (t - clk.t) / 1000); clk.t = t;
|
||||
if (advanced > 0) {
|
||||
clk.T = Math.min(6, Math.max(0.8, 0.6 * clk.T + 0.4 * (t - clk.arrived) / 1000));
|
||||
clk.arrived = t;
|
||||
clk.lag = Math.min(slots, clk.lag + advanced);
|
||||
clk.v = Math.min(2.5, Math.max(0.5, (clk.lag - LAG_LOW) / clk.T));
|
||||
} else if ((t - clk.arrived) / 1000 > 0.8 * clk.T) {
|
||||
clk.v = Math.min(2.5, Math.max(0.5, (clk.lag - LAG_LOW) / clk.T));
|
||||
}
|
||||
}
|
||||
cv.__clock = clk;
|
||||
} else cv.__clock = null;
|
||||
|
||||
var f = fitCanvas(cv); if(!f) return;
|
||||
var W=f.w, H=f.h, dpr=f.dpr, pal=palette();
|
||||
var labelled = !!spec.fmtY;
|
||||
var padL = labelled?46:10, padR=12, padT=10, padB=8;
|
||||
var plotW = Math.max(1, W-padL-padR), plotH = Math.max(1, H-padT-padB);
|
||||
var yMin = spec.yMin, yMax = spec.yMax; if(!(yMax>yMin)) yMax = yMin+1;
|
||||
var baseY = padT+plotH;
|
||||
function yPx(v){ if(v<yMin)v=yMin; if(v>yMax)v=yMax; return padT+plotH-(v-yMin)/(yMax-yMin)*plotH; }
|
||||
|
||||
var maxLen=0, hasData=false;
|
||||
spec.series.forEach(function(s){ var n=(s.data&&s.data.length)||0; if(n>maxLen)maxLen=n; if(n>0)hasData=true; });
|
||||
|
||||
var frame = {
|
||||
W:W, H:H, dpr:dpr, padL:padL, padR:padR, padT:padT, plotW:plotW, plotH:plotH, baseY:baseY,
|
||||
yMin:yMin, yMax:yMax, divs:spec.grid||4, labelled:labelled, fmtY:spec.fmtY||null,
|
||||
gridColor:pal.border, labelColor:pal.muted, mutedColor:pal.muted, font:pal.font,
|
||||
empty:!hasData, dx:0, slots:slots, feedAt:t, slide0:0, vel:0, maxSlide:0,
|
||||
newestId:total, series:[],
|
||||
slideAt:function(ts){ return chartSlide(frame, ts); }
|
||||
};
|
||||
|
||||
if(hasData){
|
||||
var N = minute ? 60 : Math.max(2, maxLen), dx = plotW/(N-1);
|
||||
frame.dx = dx;
|
||||
frame.maxSlide = (slots + LAG_OVERRUN)*dx;
|
||||
frame.slide0 = clk ? (slots - clk.lag) * dx : 0;
|
||||
frame.vel = clk ? clk.v * dx / 1000 : 0;
|
||||
function xBase(len,j){ return padL + plotW + slots*dx - (len-1-j)*dx; }
|
||||
spec.series.forEach(function(s){
|
||||
var data=s.data||[], len=data.length;
|
||||
var entry = { color:s.color, area:!!s.area, pts:[], endpoint:null };
|
||||
if(len>=1) entry.endpoint = { x:xBase(len,len-1), y:yPx(data[len-1]) };
|
||||
if(len>=2){
|
||||
for(var j=0;j<len-1;j++){
|
||||
var p0=sampleAt(data,len,j-1), p1=sampleAt(data,len,j),
|
||||
p2=sampleAt(data,len,j+1), p3=sampleAt(data,len,j+2), x0=xBase(len,j);
|
||||
var subdivisions = Math.max(GRAPH_SUBDIV, Math.ceil(dx / 2));
|
||||
for(var k=0;k<subdivisions;k++){
|
||||
var tt=k/subdivisions, v=catmull(p0,p1,p2,p3,tt);
|
||||
if(v<yMin)v=yMin; if(v>yMax)v=yMax; // a spline through noisy data overshoots; keep it in range
|
||||
entry.pts.push({ x:x0 + tt*dx, y:yPx(v) });
|
||||
}
|
||||
}
|
||||
entry.pts.push({ x:xBase(len,len-1), y:yPx(data[len-1]) }); // the newest sample, exactly
|
||||
}
|
||||
frame.series.push(entry);
|
||||
});
|
||||
}
|
||||
|
||||
var base = layerFor(cv, '__base', W, H, dpr);
|
||||
drawBase(base.ctx, frame);
|
||||
frame.base = base.el;
|
||||
if (!frame.empty) {
|
||||
var lw = W + slots*frame.dx + 2, ly = layerFor(cv, '__layer', lw, H, dpr);
|
||||
drawSeries(ly.ctx, frame);
|
||||
frame.layer = ly.el; frame.layerW = ly.el.width / dpr;
|
||||
}
|
||||
cv.__cframe = frame;
|
||||
drawFrame(cv, frame, t);
|
||||
}
|
||||
|
||||
function drawBase(ctx, frame){
|
||||
var padL=frame.padL, padR=frame.padR, padT=frame.padT, plotW=frame.plotW, plotH=frame.plotH, W=frame.W;
|
||||
var yMin=frame.yMin, yMax=frame.yMax, divs=frame.divs;
|
||||
function yPx(v){ return padT+plotH-(v-yMin)/(yMax-yMin)*plotH; }
|
||||
ctx.save();
|
||||
ctx.lineWidth=1; ctx.strokeStyle=frame.gridColor;
|
||||
ctx.font='11px '+frame.font; ctx.textBaseline='middle'; ctx.textAlign='right';
|
||||
for(var g=0; g<=divs; g++){
|
||||
var gv = yMin+(yMax-yMin)*g/divs, gy = Math.round(yPx(gv))+0.5;
|
||||
ctx.globalAlpha=0.4; ctx.beginPath(); ctx.moveTo(padL,gy); ctx.lineTo(W-padR,gy); ctx.stroke();
|
||||
if(frame.labelled){ ctx.globalAlpha=0.9; ctx.fillStyle=frame.labelColor; ctx.fillText(frame.fmtY(gv), padL-6, yPx(gv)); }
|
||||
}
|
||||
ctx.restore();
|
||||
if(frame.empty){
|
||||
ctx.save(); ctx.fillStyle=frame.mutedColor; ctx.font='12px '+frame.font;
|
||||
ctx.textAlign='center'; ctx.textBaseline='middle';
|
||||
ctx.fillText('Collecting trend data...', padL+plotW/2, padT+plotH/2); ctx.restore();
|
||||
}
|
||||
}
|
||||
|
||||
function drawSeries(ctx, frame){
|
||||
var padT=frame.padT, baseY=frame.baseY;
|
||||
frame.series.forEach(function(s){
|
||||
var pts=s.pts, len=pts.length;
|
||||
if(len>1){
|
||||
if(s.area){
|
||||
ctx.save(); ctx.beginPath();
|
||||
for(var j=0;j<len;j++){ if(j===0)ctx.moveTo(pts[j].x,pts[j].y); else ctx.lineTo(pts[j].x,pts[j].y); }
|
||||
ctx.lineTo(pts[len-1].x, baseY); ctx.lineTo(pts[0].x, baseY); ctx.closePath();
|
||||
var grad = ctx.createLinearGradient(0,padT,0,baseY);
|
||||
grad.addColorStop(0, hexToRgba(s.color,0.26)); grad.addColorStop(1, hexToRgba(s.color,0.02));
|
||||
ctx.fillStyle=grad; ctx.fill(); ctx.restore();
|
||||
}
|
||||
ctx.save(); ctx.beginPath();
|
||||
for(var k=0;k<len;k++){ if(k===0)ctx.moveTo(pts[k].x,pts[k].y); else ctx.lineTo(pts[k].x,pts[k].y); }
|
||||
ctx.lineWidth=2; ctx.lineJoin='round'; ctx.lineCap='round'; ctx.strokeStyle=s.color; ctx.stroke(); ctx.restore();
|
||||
}
|
||||
if(s.endpoint){
|
||||
var e=s.endpoint;
|
||||
ctx.save();
|
||||
ctx.globalAlpha=0.2; ctx.beginPath(); ctx.arc(e.x,e.y,6,0,6.2832); ctx.fillStyle=s.color; ctx.fill();
|
||||
ctx.globalAlpha=1; ctx.beginPath(); ctx.arc(e.x,e.y,3.4,0,6.2832); ctx.fillStyle=s.color; ctx.fill();
|
||||
ctx.restore();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function drawFrame(cv, frame, ts){
|
||||
var ctx = cv.getContext('2d'), dpr = frame.dpr;
|
||||
ctx.setTransform(1,0,0,1,0,0); ctx.clearRect(0,0,cv.width,cv.height);
|
||||
ctx.setTransform(dpr,0,0,dpr,0,0);
|
||||
ctx.drawImage(frame.base, 0, 0, frame.W, frame.H);
|
||||
if(frame.empty || !frame.layer) return;
|
||||
ctx.save();
|
||||
ctx.beginPath(); ctx.rect(frame.padL, frame.padT, frame.plotW, frame.plotH); ctx.clip();
|
||||
ctx.drawImage(frame.layer, -chartSlide(frame, ts), 0, frame.layerW, frame.H);
|
||||
ctx.restore();
|
||||
}
|
||||
|
||||
return { paintLines: paintLines, drawFrame: drawFrame, catmull: catmull,
|
||||
chartSlide: chartSlide, alignAdvance: alignAdvance, state: state,
|
||||
invalidatePalette: function () { paletteMemo = null; } };
|
||||
}
|
||||
|
||||
function numeric(samples) {
|
||||
return samples.filter(function (s) {
|
||||
return typeof s.v === "number" && isFinite(s.v) && typeof s.t === "number" && isFinite(s.t);
|
||||
});
|
||||
}
|
||||
|
||||
function bounds(samples) {
|
||||
var pts = numeric(samples);
|
||||
if (!pts.length) return [0, 1];
|
||||
var lo = Infinity, hi = -Infinity;
|
||||
pts.forEach(function (s) { if (s.v < lo) lo = s.v; if (s.v > hi) hi = s.v; });
|
||||
var pad = lo === hi ? Math.max(1, Math.abs(lo) * 0.05) : (hi / 2 - lo / 2) * 0.1;
|
||||
var low = lo - pad, high = hi + pad;
|
||||
return [isFinite(low) ? low : lo, isFinite(high) ? high : hi];
|
||||
}
|
||||
|
||||
/* Keep a stable scale for history; reserve spline headroom and lift subnormals. */
|
||||
function fitSeries(series, scale) {
|
||||
var peak = 0, values = [], floor = Number.MIN_VALUE * Math.pow(2, 52), limit = Number.MAX_VALUE / 32;
|
||||
series.forEach(function (s) { s.data.forEach(function (v) { peak = Math.max(peak, Math.abs(v)); }); });
|
||||
scale = scale || 1;
|
||||
var magnitude = peak / scale;
|
||||
if (!isFinite(magnitude) || magnitude > limit || (peak > 0 && magnitude < floor)) {
|
||||
scale = peak > limit ? limit : peak < floor ? floor : 1;
|
||||
}
|
||||
var fitted = series.map(function (s) {
|
||||
var data = s.data.map(function (v) { var n = v / scale; values.push({ t: 0, v: n }); return n; });
|
||||
return Object.assign({}, s, { data: data });
|
||||
});
|
||||
return { series: fitted, range: bounds(values), scale: scale };
|
||||
}
|
||||
|
||||
function plotPoints(samples, w, h) {
|
||||
var pts = numeric(samples);
|
||||
if (!pts.length || w <= 0 || h <= 0) return [];
|
||||
var fitted = fitSeries([{ data: pts.map(function (s) { return s.v; }) }]);
|
||||
var times = fitSeries([{ data: pts.map(function (s) { return s.t; }) }]).series[0].data;
|
||||
var b = fitted.range, values = fitted.series[0].data;
|
||||
var t0 = times[0], t1 = times[times.length - 1];
|
||||
var span = t1 - t0;
|
||||
return pts.map(function (s, i) {
|
||||
var x = span > 0 ? ((times[i] - t0) / span) * w : (pts.length === 1 ? w / 2 : (i / (pts.length - 1)) * w);
|
||||
var y = h - ((values[i] - b[0]) / (b[1] - b[0])) * h;
|
||||
return [x, y];
|
||||
});
|
||||
}
|
||||
|
||||
function draw(ctx, samples, w, h, style) {
|
||||
style = style || {};
|
||||
ctx.clearRect(0, 0, w, h);
|
||||
var p = plotPoints(samples, w, h);
|
||||
if (!p.length) return 0;
|
||||
ctx.strokeStyle = style.stroke || "currentColor";
|
||||
ctx.lineWidth = style.width || 2;
|
||||
ctx.beginPath();
|
||||
p.forEach(function (q, i) { if (i === 0) ctx.moveTo(q[0], q[1]); else ctx.lineTo(q[0], q[1]); });
|
||||
ctx.stroke();
|
||||
return p.length;
|
||||
}
|
||||
|
||||
function formatValue(v) {
|
||||
if (typeof v === "number") {
|
||||
if (!isFinite(v)) return "--";
|
||||
return String(Number(v.toFixed(3)));
|
||||
}
|
||||
return typeof v === "object" ? "--" : String(v);
|
||||
}
|
||||
|
||||
function withValue(text, value) {
|
||||
var m = /^\s*\S*(\s.*)?$/.exec(String(text));
|
||||
return value + (m && m[1] ? m[1] : "");
|
||||
}
|
||||
|
||||
function applyReadings(live, doc) {
|
||||
var els = doc.querySelectorAll("[data-live][data-key]");
|
||||
for (var i = 0; i < els.length; i++) {
|
||||
var el = els[i];
|
||||
if (el.getAttribute("data-island")) continue;
|
||||
var key = el.getAttribute("data-key");
|
||||
var s = live.samples(key);
|
||||
if (!s.length) continue;
|
||||
var v = s[s.length - 1].v;
|
||||
var txt = formatValue(v);
|
||||
var kv = el.querySelector(".bf-kv-value");
|
||||
if (kv) kv.textContent = withValue(kv.textContent, txt);
|
||||
var hero = el.querySelector(".bf-hero-value");
|
||||
if (hero) hero.textContent = txt;
|
||||
var meter = el.querySelector("meter");
|
||||
if (meter && typeof v === "number" && isFinite(v)) meter.value = v;
|
||||
}
|
||||
}
|
||||
|
||||
var chartBindings = new WeakMap();
|
||||
|
||||
function chartProps(raw) {
|
||||
var p;
|
||||
try { p = JSON.parse(raw); } catch (_) { return null; }
|
||||
function text(s, max) { return typeof s === "string" && s.length > 0 && s.length <= max && !/[\x00-\x1f\x7f]/.test(s); }
|
||||
if (!p || !text(p.id, 128) || !Array.isArray(p.series) || !p.series.length || p.series.length > 64 ||
|
||||
!["min", "hour", "day"].includes(p.tier) || !p.tiers || !p.points || typeof p.points !== "object" || Array.isArray(p.points)) return null;
|
||||
var keys = new Set();
|
||||
for (var s of p.series) {
|
||||
if (!s || !text(s.key, 256) || !text(s.label, 256) || typeof s.unit !== "string" || s.unit.length > 64 ||
|
||||
/[\x00-\x1f\x7f]/.test(s.unit) || typeof s.color !== "string" || !/^#(?:[\da-f]{3}|[\da-f]{6})$/i.test(s.color) || keys.has(s.key)) return null;
|
||||
keys.add(s.key);
|
||||
}
|
||||
for (var tier of ["min", "hour", "day"]) {
|
||||
var t = p.tiers[tier];
|
||||
if (!t || t.n !== 60 || !Number.isInteger(t.step_s) || t.step_s <= 0 || t.step_s > 4294967295) return null;
|
||||
}
|
||||
for (var key of Object.keys(p.points)) {
|
||||
var points = p.points[key];
|
||||
if (!keys.has(key) || !Array.isArray(points) || points.length > 60 || points.some(function (q, i) {
|
||||
return !Array.isArray(q) || q.length !== 2 || !q.every(Number.isFinite) || (i > 0 && points[i - 1][0] >= q[0]);
|
||||
})) return null;
|
||||
}
|
||||
return p;
|
||||
}
|
||||
|
||||
function chartData(props, live) {
|
||||
var all = [], latest = Object.create(null), generation = 0;
|
||||
var series = props.series.map(function (s) {
|
||||
var points = new Map();
|
||||
if (Object.prototype.hasOwnProperty.call(props.points, s.key)) props.points[s.key].forEach(function (p) { points.set(p[0], p[1]); });
|
||||
if (live.chartSamples) numeric(live.chartSamples(props.id, s.key)).forEach(function (p) { points.set(p.t, p.v); });
|
||||
var samples = Array.from(points, function (p) { return { t: p[0], v: p[1] }; })
|
||||
.sort(function (a, b) { return a.t - b.t; }).slice(-props.tiers[props.tier].n);
|
||||
all = all.concat(samples);
|
||||
var last = samples[samples.length - 1];
|
||||
latest[s.key] = (last ? formatValue(last.v) : "--") + " " + s.unit;
|
||||
if (last) generation = Math.max(generation, last.t);
|
||||
return { data: samples.map(function (p) { return p.v; }), color: s.color };
|
||||
});
|
||||
return { series: series, range: bounds(all), latest: latest, generation: generation };
|
||||
}
|
||||
|
||||
function bindCharts(live, doc) {
|
||||
var prior = chartBindings.get(doc);
|
||||
if (prior) prior();
|
||||
var view = doc.defaultView;
|
||||
if (!view) throw new Error("chart binding needs a browser document");
|
||||
var motion = view.matchMedia("(prefers-reduced-motion: reduce)");
|
||||
var entries = new Map(), raf = null, disposed = false;
|
||||
function attached(canvas) { return doc.documentElement.contains(canvas); }
|
||||
function visible(canvas) {
|
||||
var rect = canvas.getBoundingClientRect();
|
||||
return Math.round(rect.width) > 0 && Math.round(rect.height) > 0;
|
||||
}
|
||||
function prune() {
|
||||
entries.forEach(function (_, canvas) { if (!attached(canvas)) entries.delete(canvas); });
|
||||
}
|
||||
function cancel() {
|
||||
if (raf !== null) view.cancelAnimationFrame(raf);
|
||||
raf = null;
|
||||
}
|
||||
function moving() {
|
||||
if (disposed || motion.matches || doc.hidden || live.stale === true || live.closed === true) return false;
|
||||
var result = false, stamp = view.performance.now();
|
||||
entries.forEach(function (entry, canvas) {
|
||||
var frame = entry.frame;
|
||||
if (frame && frame.vel && attached(canvas) && visible(canvas) && frame.slideAt(stamp) < frame.maxSlide) result = true;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
function schedule() {
|
||||
if (!moving()) { cancel(); return; }
|
||||
if (raf === null) raf = view.requestAnimationFrame(tick);
|
||||
}
|
||||
function tick(stamp) {
|
||||
raf = null;
|
||||
prune();
|
||||
if (!disposed && !motion.matches && !doc.hidden && live.stale !== true && live.closed !== true) {
|
||||
entries.forEach(function (entry, canvas) {
|
||||
if (entry.frame && entry.frame.vel && visible(canvas)) entry.engine.drawFrame(canvas, entry.frame, stamp);
|
||||
});
|
||||
}
|
||||
schedule();
|
||||
}
|
||||
function tierFor(figure) {
|
||||
var tier = figure.getAttribute("data-tier") || new URLSearchParams(view.location.search).get("tier");
|
||||
return tier === "hour" || tier === "day" ? tier : "min";
|
||||
}
|
||||
function redraw(initial) {
|
||||
if (disposed) return;
|
||||
prune();
|
||||
var figures = doc.querySelectorAll('[data-island="chart"]');
|
||||
for (var i = 0; i < figures.length; i++) {
|
||||
var figure = figures[i], canvas = figure.querySelector("canvas");
|
||||
if (!canvas || !canvas.getContext || !attached(canvas)) continue;
|
||||
var raw = figure.getAttribute("data-chart"), key = figure.getAttribute("data-key"), tier = tierFor(figure);
|
||||
if (initial === true && !raw) continue;
|
||||
var entry = entries.get(canvas);
|
||||
if (raw && entry && entry.raw === raw && entry.props) tier = entry.props.tier;
|
||||
if (!entry || entry.key !== key || entry.tier !== tier || entry.raw !== raw) {
|
||||
var props = raw ? chartProps(raw) : null;
|
||||
if (raw && !props) { entries.delete(canvas); continue; }
|
||||
if (props) tier = props.tier;
|
||||
delete canvas.__history; delete canvas.__clock; delete canvas.__cframe;
|
||||
var reduced = { matches: false };
|
||||
entry = { key: key, tier: tier, raw: raw, props: props, motion: reduced, engine: createEngine({ window: view, document: doc,
|
||||
reduceMotion: reduced, state: { chartTier: tier, prevGenMs: 0 } }) };
|
||||
entries.set(canvas, entry);
|
||||
}
|
||||
if (!visible(canvas)) { entry.frame = null; continue; }
|
||||
var data;
|
||||
if (entry.props) {
|
||||
data = chartData(entry.props, live);
|
||||
var values = figure.querySelectorAll("[data-chart-value]");
|
||||
for (var j = 0; j < values.length; j++) {
|
||||
var valueKey = values[j].getAttribute("data-chart-value");
|
||||
if (Object.prototype.hasOwnProperty.call(data.latest, valueKey)) values[j].textContent = data.latest[valueKey];
|
||||
}
|
||||
} else {
|
||||
var samples = numeric(live.samples(key)).slice(-60);
|
||||
data = { series: [{ data: samples.map(function (s) { return s.v; }), color: figure.getAttribute("data-color") || "#3776BE" }],
|
||||
range: bounds(samples), generation: samples.length ? samples[samples.length - 1].t : 0 };
|
||||
}
|
||||
entry.engine.state.prevGenMs = data.generation;
|
||||
entry.engine.invalidatePalette();
|
||||
var fitted = fitSeries(data.series, entry.scale);
|
||||
if (entry.scale && entry.scale !== fitted.scale) { delete canvas.__history; delete canvas.__clock; }
|
||||
entry.scale = fitted.scale;
|
||||
// Keep short seeds inside the plot.
|
||||
entry.motion.matches = motion.matches || live.stale === true || fitted.series.some(s => s.data.length > 0 && s.data.length < 4);
|
||||
entry.engine.paintLines(canvas, { series: fitted.series, yMin: fitted.range[0], yMax: fitted.range[1], grid: 4 });
|
||||
entry.frame = canvas.__cframe;
|
||||
}
|
||||
schedule();
|
||||
}
|
||||
function clean(event) {
|
||||
var element = event && event.detail && event.detail.elt;
|
||||
if (element && element.contains) {
|
||||
entries.forEach(function (_, canvas) { if (element.contains(canvas)) entries.delete(canvas); });
|
||||
}
|
||||
schedule();
|
||||
}
|
||||
function visibility() { if (doc.hidden) cancel(); else redraw(); }
|
||||
var unsubscribe = live.onChange(function (what) {
|
||||
if (disposed) return;
|
||||
if (what === "data") { applyReadings(live, doc); redraw(); }
|
||||
else if (what === "stale") schedule();
|
||||
});
|
||||
doc.addEventListener("htmx:afterSwap", redraw);
|
||||
doc.addEventListener("htmx:beforeCleanupElement", clean);
|
||||
doc.addEventListener("htmx:beforeCleanup", clean);
|
||||
doc.addEventListener("visibilitychange", visibility);
|
||||
view.addEventListener("resize", redraw);
|
||||
motion.addEventListener("change", redraw);
|
||||
function stop() {
|
||||
if (disposed) return;
|
||||
disposed = true; cancel(); entries.clear();
|
||||
if (typeof unsubscribe === "function") unsubscribe();
|
||||
doc.removeEventListener("htmx:afterSwap", redraw);
|
||||
doc.removeEventListener("htmx:beforeCleanupElement", clean);
|
||||
doc.removeEventListener("htmx:beforeCleanup", clean);
|
||||
doc.removeEventListener("visibilitychange", visibility);
|
||||
view.removeEventListener("resize", redraw);
|
||||
motion.removeEventListener("change", redraw);
|
||||
if (chartBindings.get(doc) === stop) chartBindings.delete(doc);
|
||||
}
|
||||
chartBindings.set(doc, stop);
|
||||
redraw(true);
|
||||
return stop;
|
||||
}
|
||||
|
||||
return {
|
||||
createEngine: createEngine, bounds: bounds, plotPoints: plotPoints, draw: draw, formatValue: formatValue,
|
||||
withValue: withValue, applyReadings: applyReadings, bindCharts: bindCharts,
|
||||
chartProps: chartProps, chartData: chartData
|
||||
};
|
||||
});
|
||||
@@ -0,0 +1,79 @@
|
||||
/* flare-ui islands (UI-6): table sort kept in the URL and column resize.
|
||||
* Pure helpers are exported for Node tests; the DOM binders are thin. */
|
||||
(function (root, factory) {
|
||||
if (typeof module === "object" && module.exports) module.exports = factory();
|
||||
else root.FlareIslands = factory();
|
||||
})(typeof self !== "undefined" ? self : this, function () {
|
||||
"use strict";
|
||||
|
||||
var MIN_COL = 40;
|
||||
var MAX_COL = 800;
|
||||
|
||||
/* "?sort=name&dir=desc" -> {key, dir}; dir defaults to asc, junk -> null. */
|
||||
function parseSort(search) {
|
||||
var key = null, dir = "asc";
|
||||
new URLSearchParams(search || "").forEach(function (v, k) {
|
||||
if (k === "sort" && /^[A-Za-z0-9_.-]{1,64}$/.test(v)) key = v;
|
||||
if (k === "dir" && (v === "asc" || v === "desc")) dir = v;
|
||||
});
|
||||
return key ? { key: key, dir: dir } : null;
|
||||
}
|
||||
|
||||
/* Query string after clicking column `key`: toggles dir on the same key. */
|
||||
function nextSortQuery(search, key) {
|
||||
var cur = parseSort(search);
|
||||
var dir = cur && cur.key === key && cur.dir === "asc" ? "desc" : "asc";
|
||||
var params = new URLSearchParams(search || "");
|
||||
params.delete("sort"); params.delete("dir");
|
||||
params.append("sort", key); params.append("dir", dir);
|
||||
return "?" + params.toString();
|
||||
}
|
||||
|
||||
/* Numbers compare numerically, everything else as case-folded text. */
|
||||
function compareCells(a, b) {
|
||||
var na = Number(a), nb = Number(b);
|
||||
if (a !== "" && b !== "" && isFinite(na) && isFinite(nb)) return na - nb;
|
||||
var x = String(a).toLowerCase(), y = String(b).toLowerCase();
|
||||
return x < y ? -1 : x > y ? 1 : 0;
|
||||
}
|
||||
|
||||
/* Stable sort of rows (arrays of strings) by column index. */
|
||||
function sortRows(rows, col, dir) {
|
||||
var sign = dir === "desc" ? -1 : 1;
|
||||
return rows
|
||||
.map(function (r, i) { return { r: r, i: i }; })
|
||||
.sort(function (p, q) {
|
||||
return sign * compareCells(p.r[col], q.r[col]) || p.i - q.i;
|
||||
})
|
||||
.map(function (p) { return p.r; });
|
||||
}
|
||||
|
||||
function clampWidth(px) {
|
||||
var n = Math.round(Number(px));
|
||||
if (!isFinite(n)) return MIN_COL;
|
||||
return Math.max(MIN_COL, Math.min(MAX_COL, n));
|
||||
}
|
||||
|
||||
/* Keep column headers semantic; native controls supply keyboard activation. */
|
||||
function bindTableSort(doc, loc) {
|
||||
var ths = doc.querySelectorAll("th[data-sort]");
|
||||
for (var i = 0; i < ths.length; i++) {
|
||||
(function (th) {
|
||||
if (th.querySelector("a[href],button,input,select,textarea,[tabindex],[role=button],[role=link]")) return;
|
||||
var button = doc.createElement("button");
|
||||
button.type = "button";
|
||||
while (th.firstChild) button.appendChild(th.firstChild);
|
||||
th.appendChild(button);
|
||||
button.addEventListener("click", function () {
|
||||
loc.search = nextSortQuery(loc.search, th.getAttribute("data-sort"));
|
||||
});
|
||||
})(ths[i]);
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
parseSort: parseSort, nextSortQuery: nextSortQuery, compareCells: compareCells,
|
||||
sortRows: sortRows, clampWidth: clampWidth, bindTableSort: bindTableSort,
|
||||
MIN_COL: MIN_COL, MAX_COL: MAX_COL
|
||||
};
|
||||
});
|
||||
@@ -0,0 +1,209 @@
|
||||
/* flare-ui live client (UI-6): SSE stream with a bounded ring, reconnect
|
||||
* backoff and a stale marker. No dependencies; works in a browser and in
|
||||
* Node (tests inject EventSource, timers and a clock). */
|
||||
(function (root, factory) {
|
||||
if (typeof module === "object" && module.exports) module.exports = factory();
|
||||
else root.FlareLive = factory();
|
||||
})(typeof self !== "undefined" ? self : this, function () {
|
||||
"use strict";
|
||||
|
||||
var DEFAULTS = {
|
||||
ringCap: 600, // samples kept per series
|
||||
maxSeries: 64, // series tracked per stream; extra keys are dropped
|
||||
staleAfterMs: 15000, // no event for this long marks the stream stale
|
||||
backoffMinMs: 1000,
|
||||
backoffMaxMs: 30000,
|
||||
staleClass: "bf-stale"
|
||||
};
|
||||
|
||||
/* Fixed-capacity ring of {t, v}; oldest sample is overwritten. */
|
||||
function Ring(cap) {
|
||||
this.cap = cap;
|
||||
this.buf = [];
|
||||
this.head = 0;
|
||||
}
|
||||
Ring.prototype.push = function (item) {
|
||||
if (this.buf.length < this.cap) this.buf.push(item);
|
||||
else {
|
||||
this.buf[this.head] = item;
|
||||
this.head = (this.head + 1) % this.cap;
|
||||
}
|
||||
};
|
||||
Ring.prototype.toArray = function () {
|
||||
return this.buf.slice(this.head).concat(this.buf.slice(0, this.head));
|
||||
};
|
||||
Ring.prototype.size = function () { return this.buf.length; };
|
||||
|
||||
/* Reconnect delay for attempt n (0-based): doubles, capped. */
|
||||
function backoff(attempt, min, max) {
|
||||
var d = min * Math.pow(2, attempt);
|
||||
return d > max || !isFinite(d) ? max : d;
|
||||
}
|
||||
|
||||
/* env: { EventSource, setTimeout, clearTimeout, now } (all optional in a browser). */
|
||||
function Live(url, opts, env) {
|
||||
env = env || {};
|
||||
var o = {};
|
||||
var k;
|
||||
for (k in DEFAULTS) o[k] = DEFAULTS[k];
|
||||
for (k in (opts || {})) o[k] = opts[k];
|
||||
this.opts = o;
|
||||
this.url = url;
|
||||
this.ES = env.EventSource || (typeof EventSource !== "undefined" ? EventSource : null);
|
||||
var st = env.setTimeout || setTimeout;
|
||||
var ct = env.clearTimeout || clearTimeout;
|
||||
/* Wrapped so the timers run unbound; browsers reject a foreign `this`. */
|
||||
this.setT = function (fn, ms) { return st(fn, ms); };
|
||||
this.clearT = function (id) { return ct(id); };
|
||||
this.now = env.now || Date.now;
|
||||
this.series = Object.create(null);
|
||||
this.chartSeries = Object.create(null);
|
||||
this.seriesCount = 0;
|
||||
this.dropped = 0;
|
||||
this.attempt = 0;
|
||||
this.lastEventAt = null;
|
||||
this.stale = true;
|
||||
this.es = null;
|
||||
this.timer = null;
|
||||
this.staleTimer = null;
|
||||
this.closed = false;
|
||||
this.listeners = [];
|
||||
}
|
||||
|
||||
Live.prototype.onChange = function (fn) {
|
||||
var self = this, active = true;
|
||||
this.listeners.push(fn);
|
||||
return function () {
|
||||
if (!active) return;
|
||||
active = false;
|
||||
var index = self.listeners.indexOf(fn);
|
||||
if (index >= 0) self.listeners.splice(index, 1);
|
||||
};
|
||||
};
|
||||
Live.prototype._emit = function (what) {
|
||||
var listeners = this.listeners.slice();
|
||||
for (var i = 0; i < listeners.length; i++) listeners[i](what, this);
|
||||
};
|
||||
|
||||
Live.prototype.start = function () {
|
||||
var self = this;
|
||||
if (this.es || this.timer !== null) return;
|
||||
if (!this.ES) throw new Error("EventSource unavailable");
|
||||
this.closed = false;
|
||||
var source = this.es = new this.ES(this.url);
|
||||
function current() { return !self.closed && self.es === source; }
|
||||
source.onopen = function () { if (current()) { self.attempt = 0; self._arm(); } };
|
||||
source.onmessage = function (ev) { if (current()) self.ingest(ev.data); };
|
||||
if (source.addEventListener) source.addEventListener("series", function (ev) {
|
||||
if (current()) self.ingestSeries(ev.data);
|
||||
});
|
||||
source.onerror = function () {
|
||||
if (!current()) return;
|
||||
self._setStale(true);
|
||||
if (self.es) { self.es.close(); self.es = null; }
|
||||
if (self.closed) return;
|
||||
var d = backoff(self.attempt++, self.opts.backoffMinMs, self.opts.backoffMaxMs);
|
||||
self.timer = self.setT(function () { self.timer = null; self.start(); }, d);
|
||||
};
|
||||
this._arm();
|
||||
};
|
||||
|
||||
Live.prototype.close = function () {
|
||||
this.closed = true;
|
||||
if (this.es) { this.es.close(); this.es = null; }
|
||||
if (this.timer !== null) { this.clearT(this.timer); this.timer = null; }
|
||||
if (this.staleTimer !== null) { this.clearT(this.staleTimer); this.staleTimer = null; }
|
||||
};
|
||||
|
||||
/* Restart the stale watchdog. */
|
||||
Live.prototype._arm = function () {
|
||||
var self = this;
|
||||
if (this.staleTimer !== null) this.clearT(this.staleTimer);
|
||||
this.staleTimer = this.setT(function () {
|
||||
self.staleTimer = null;
|
||||
self._setStale(true);
|
||||
}, this.opts.staleAfterMs);
|
||||
};
|
||||
|
||||
Live.prototype._setStale = function (v) {
|
||||
if (this.stale === v) return;
|
||||
this.stale = v;
|
||||
this._emit("stale");
|
||||
};
|
||||
|
||||
/* One SSE data payload: JSON {"k": key, "v": value, "t": ms} or an array of those. */
|
||||
Live.prototype.ingest = function (data) {
|
||||
var msg;
|
||||
try { msg = JSON.parse(data); } catch (e) { this.dropped++; return; }
|
||||
var items = Array.isArray(msg) ? msg : [msg];
|
||||
var t0 = this.now(), accepted = 0;
|
||||
for (var i = 0; i < items.length; i++) {
|
||||
var m = items[i];
|
||||
if (!m || typeof m.k !== "string" || m.v === undefined) { this.dropped++; continue; }
|
||||
if (typeof m.t === "number" && !isFinite(m.t)) { this.dropped++; continue; }
|
||||
var r = this.series[m.k];
|
||||
if (!r) {
|
||||
if (this.seriesCount >= this.opts.maxSeries) { this.dropped++; continue; }
|
||||
r = this.series[m.k] = new Ring(this.opts.ringCap);
|
||||
this.seriesCount++;
|
||||
}
|
||||
r.push({ t: typeof m.t === "number" ? m.t : t0, v: m.v });
|
||||
accepted++;
|
||||
}
|
||||
if (!accepted) return;
|
||||
this.lastEventAt = t0;
|
||||
this._arm();
|
||||
this._setStale(false);
|
||||
this._emit("data");
|
||||
};
|
||||
|
||||
Live.prototype.samples = function (key) {
|
||||
return this.series[key] ? this.series[key].toArray() : [];
|
||||
};
|
||||
|
||||
/* Named chart events are isolated from readings and other chart ids. */
|
||||
Live.prototype.ingestSeries = function (data) {
|
||||
var m;
|
||||
try { m = JSON.parse(data); } catch (e) { this.dropped++; return; }
|
||||
if (!m || typeof m.id !== "string" || !m.id.length || m.id.length > 128 ||
|
||||
typeof m.key !== "string" || !m.key.length || m.key.length > 256 ||
|
||||
!Array.isArray(m.p) || m.p.length !== 2 ||
|
||||
!m.p.every(function (v) { return typeof v === "number" && isFinite(v); })) {
|
||||
this.dropped++; return;
|
||||
}
|
||||
var key = JSON.stringify([m.id, m.key]), ring = this.chartSeries[key];
|
||||
if (!ring) {
|
||||
if (this.seriesCount >= this.opts.maxSeries) { this.dropped++; return; }
|
||||
ring = this.chartSeries[key] = new Ring(this.opts.ringCap);
|
||||
this.seriesCount++;
|
||||
}
|
||||
ring.push({ t: m.p[0], v: m.p[1] });
|
||||
this.lastEventAt = this.now(); this._arm(); this._setStale(false); this._emit("data");
|
||||
};
|
||||
|
||||
Live.prototype.chartSamples = function (id, key) {
|
||||
var ring = this.chartSeries[JSON.stringify([id, key])];
|
||||
return ring ? ring.toArray() : [];
|
||||
};
|
||||
|
||||
/* Toggle the stale class on every element carrying data-live. */
|
||||
function bindStaleMarker(live, doc, cls) {
|
||||
cls = cls || live.opts.staleClass;
|
||||
function mark() {
|
||||
var els = doc.querySelectorAll("[data-live]");
|
||||
for (var i = 0; i < els.length; i++) {
|
||||
if (live.stale) els[i].classList.add(cls);
|
||||
else els[i].classList.remove(cls);
|
||||
}
|
||||
}
|
||||
mark();
|
||||
var unsubscribe = live.onChange(function (what) { if (what === "stale") mark(); });
|
||||
if (doc.addEventListener) doc.addEventListener("htmx:afterSwap", mark);
|
||||
return function () {
|
||||
unsubscribe();
|
||||
if (doc.removeEventListener) doc.removeEventListener("htmx:afterSwap", mark);
|
||||
};
|
||||
}
|
||||
|
||||
return { Live: Live, Ring: Ring, backoff: backoff, bindStaleMarker: bindStaleMarker, DEFAULTS: DEFAULTS };
|
||||
});
|
||||
@@ -0,0 +1,74 @@
|
||||
/* Shared app theme (UI-4): the --app-* semantic layer over tokens.css.
|
||||
* Dark is the default; light follows an explicit data-theme or, when absent,
|
||||
* the system preference. Extracted from the FLARE portal stylesheet so FLARE
|
||||
* and the Warden console read one palette. Embedded as flare_ui::tokens::THEME_CSS.
|
||||
*/
|
||||
|
||||
:root {
|
||||
--app-bg: var(--bf-bg-page); /* #070D1D */
|
||||
--app-surface: var(--bf-bg-surface); /* #0B1020 */
|
||||
--app-surface-alt: var(--bf-bg-surface-alt); /* #192858 */
|
||||
--app-text: var(--bf-text-on-dark);
|
||||
--app-text-muted: var(--bf-text-on-dark-muted);
|
||||
--app-border: var(--bf-border-default);
|
||||
--app-link: var(--bf-color-cyan-400);
|
||||
--app-elevation: var(--bf-shadow-flare-soft); /* the signature flare */
|
||||
--app-input-bg: var(--bf-bg-page);
|
||||
--app-btn2-hover: var(--bf-action-secondary);
|
||||
/* A whisper of the signature cyan under a hovered row - enough to say
|
||||
"live", never enough to fight the text on it. */
|
||||
--app-row-hover: rgba(58, 188, 248, 0.07);
|
||||
/* The brand red is 3.22:1 on the dark surface. Lightened for dark only, so
|
||||
destructive actions clear AA in both themes rather than one. */
|
||||
--app-danger: #FF6B6B;
|
||||
--app-danger-hover-tint: rgba(255, 107, 107, 0.12);
|
||||
/* Same step-down as --app-link: --bf-border-accent is flat cyan-400 in
|
||||
every theme, which is ~2.16:1 on light backgrounds and fails the 3:1
|
||||
WCAG 1.4.11 floor for a focus indicator. */
|
||||
--app-focus-ring: var(--bf-color-cyan-400);
|
||||
color-scheme: dark;
|
||||
}
|
||||
|
||||
:root[data-theme='light'] {
|
||||
--app-bg: var(--bf-bg-page-light); /* #FFFFFF */
|
||||
--app-surface: var(--bf-color-neutral-100); /* #F6F6F6 */
|
||||
--app-surface-alt: var(--bf-color-neutral-100);
|
||||
--app-text: var(--bf-text-on-light);
|
||||
--app-text-muted: var(--bf-text-on-light-muted);
|
||||
--app-border: var(--bf-border-subtle); /* #D9D9D9 hairline */
|
||||
/* One shade darker so link text clears AA on white. */
|
||||
--app-link: var(--bf-color-cyan-600);
|
||||
--app-danger: #C7162B;
|
||||
--app-danger-hover-tint: rgba(199, 22, 43, 0.12);
|
||||
/* The flare mutes on white - never a cyan glow on a light surface. */
|
||||
--app-elevation: var(--bf-shadow-elevation-1);
|
||||
--app-input-bg: var(--bf-bg-page-light);
|
||||
--app-btn2-hover: var(--bf-color-neutral-100);
|
||||
--app-row-hover: rgba(55, 118, 190, 0.06);
|
||||
/* One shade darker, same reasoning as --app-link above. */
|
||||
--app-focus-ring: var(--bf-color-cyan-600);
|
||||
color-scheme: light;
|
||||
}
|
||||
|
||||
/* System preference, used when the user has not chosen explicitly.
|
||||
`data-theme` is absent in that case, so this must not out-specify the
|
||||
explicit selectors above - hence :root:not([data-theme]). */
|
||||
@media (prefers-color-scheme: light) {
|
||||
:root:not([data-theme]) {
|
||||
--app-bg: var(--bf-bg-page-light);
|
||||
--app-surface: var(--bf-color-neutral-100);
|
||||
--app-surface-alt: var(--bf-color-neutral-100);
|
||||
--app-text: var(--bf-text-on-light);
|
||||
--app-text-muted: var(--bf-text-on-light-muted);
|
||||
--app-border: var(--bf-border-subtle);
|
||||
--app-link: var(--bf-color-cyan-600);
|
||||
--app-danger: #C7162B;
|
||||
--app-danger-hover-tint: rgba(199, 22, 43, 0.12);
|
||||
--app-elevation: var(--bf-shadow-elevation-1);
|
||||
--app-input-bg: var(--bf-bg-page-light);
|
||||
--app-btn2-hover: var(--bf-color-neutral-100);
|
||||
--app-row-hover: rgba(55, 118, 190, 0.06);
|
||||
--app-focus-ring: var(--bf-color-cyan-600);
|
||||
color-scheme: light;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,176 @@
|
||||
/* FLARE portal - design tokens as CSS custom properties.
|
||||
* Hand-written; owned by the flare-ui crate (assets/tokens.css) and embedded as flare_ui::tokens::TOKENS_CSS.
|
||||
* Import as the root stylesheet; portal.css builds its components on these.
|
||||
* <link rel="stylesheet" href="tokens.css">
|
||||
* All values are flat (resolved) - semantic tokens reference primitives.
|
||||
*/
|
||||
|
||||
:root {
|
||||
/* --- Color - navy -------------------------------- */
|
||||
--bf-color-navy-50: #F6F6F6;
|
||||
--bf-color-navy-100: #D9D9D9;
|
||||
--bf-color-navy-200: #BABABA;
|
||||
--bf-color-navy-300: #9A9A9A;
|
||||
--bf-color-navy-400: #5D5D5D;
|
||||
--bf-color-navy-500: #295399;
|
||||
--bf-color-navy-600: #1E4E90;
|
||||
--bf-color-navy-700: #192858; /* core brand */
|
||||
--bf-color-navy-800: #0B1020;
|
||||
--bf-color-navy-900: #070D1D;
|
||||
--bf-color-navy-950: #050A16;
|
||||
|
||||
/* --- Color - cyan (signature flare) -------------- */
|
||||
--bf-color-cyan-400: #3ABCF8;
|
||||
--bf-color-cyan-500: #31A2D6;
|
||||
--bf-color-cyan-600: #3776BE;
|
||||
|
||||
/* --- Color - orange (accent) --------------------- */
|
||||
--bf-color-orange-500: #F26522;
|
||||
|
||||
/* --- Color - neutral ----------------------------- */
|
||||
--bf-color-neutral-0: #FFFFFF;
|
||||
--bf-color-neutral-100: #F6F6F6;
|
||||
--bf-color-neutral-200: #D9D9D9;
|
||||
--bf-color-neutral-300: #BABABA;
|
||||
--bf-color-neutral-400: #9A9A9A;
|
||||
--bf-color-neutral-500: #5D5D5D;
|
||||
--bf-color-neutral-600: #484848;
|
||||
--bf-color-neutral-700: #383838;
|
||||
--bf-color-neutral-800: #252525;
|
||||
--bf-color-neutral-900: #000000;
|
||||
|
||||
/* --- Color - feedback ---------------------------- */
|
||||
--bf-color-danger: #FF0202;
|
||||
--bf-color-warning: #F26522;
|
||||
--bf-color-info: #3ABCF8;
|
||||
|
||||
/* --- Semantic aliases (use these in product code) - */
|
||||
--bf-bg-page: var(--bf-color-navy-900);
|
||||
--bf-bg-page-light: var(--bf-color-neutral-0);
|
||||
--bf-bg-surface: var(--bf-color-navy-800);
|
||||
--bf-bg-surface-alt: var(--bf-color-navy-700);
|
||||
--bf-bg-surface-light: var(--bf-color-neutral-100);
|
||||
|
||||
--bf-text-on-dark: var(--bf-color-neutral-0);
|
||||
--bf-text-on-dark-muted: var(--bf-color-neutral-300);
|
||||
--bf-text-on-light: var(--bf-color-neutral-800);
|
||||
--bf-text-on-light-muted: var(--bf-color-neutral-500);
|
||||
--bf-text-link: var(--bf-color-cyan-400);
|
||||
--bf-text-brand: var(--bf-color-navy-700);
|
||||
|
||||
--bf-border-default: var(--bf-color-navy-700);
|
||||
--bf-border-subtle: var(--bf-color-neutral-200);
|
||||
--bf-border-accent: var(--bf-color-cyan-400);
|
||||
--bf-border-on-dark: var(--bf-color-neutral-0);
|
||||
|
||||
--bf-action-primary: var(--bf-color-cyan-400);
|
||||
--bf-action-primary-hover: var(--bf-color-cyan-500);
|
||||
--bf-action-primary-text: var(--bf-color-navy-900);
|
||||
--bf-action-secondary: var(--bf-color-navy-700);
|
||||
--bf-action-secondary-hover: var(--bf-color-navy-600);
|
||||
--bf-action-secondary-text: var(--bf-color-neutral-0);
|
||||
--bf-action-accent: var(--bf-color-orange-500);
|
||||
|
||||
/* --- Typography ----------------------------------
|
||||
* Free-substitute stack: Sora (Google Fonts) for display, Selawik (Microsoft's
|
||||
* open-source Segoe UI clone, SIL OFL 1.1, self-hosted from /fonts) for body.
|
||||
* Native brand fonts (Creato Display, Segoe UI) remain first in the stack so
|
||||
* licensed deployments don't require any token change. See fonts.md.
|
||||
*/
|
||||
--bf-font-display: 'Creato Display', 'Sora', 'Segoe UI', 'Selawik', system-ui, -apple-system, BlinkMacSystemFont, 'Helvetica Neue', Arial, sans-serif;
|
||||
--bf-font-body: 'Segoe UI', 'Selawik', system-ui, -apple-system, BlinkMacSystemFont, 'Helvetica Neue', Arial, sans-serif;
|
||||
|
||||
--bf-font-weight-regular: 400;
|
||||
--bf-font-weight-semibold: 600;
|
||||
--bf-font-weight-bold: 700;
|
||||
|
||||
--bf-text-xs: 12px;
|
||||
--bf-text-sm: 14px;
|
||||
--bf-text-base: 16px;
|
||||
--bf-text-md: 18px;
|
||||
--bf-text-lg: 20px;
|
||||
--bf-text-xl: 24px;
|
||||
--bf-text-2xl: 28px;
|
||||
--bf-text-3xl: 40px;
|
||||
--bf-text-4xl: 56px;
|
||||
|
||||
--bf-leading-tight: 1.0;
|
||||
--bf-leading-snug: 1.15;
|
||||
--bf-leading-normal: 1.25;
|
||||
--bf-leading-relaxed: 1.4;
|
||||
--bf-leading-loose: 1.6;
|
||||
--bf-leading-display: 1.1;
|
||||
|
||||
--bf-tracking-normal: 0;
|
||||
--bf-tracking-wide: 0.03em;
|
||||
--bf-tracking-wider: 0.3em;
|
||||
|
||||
/* --- Spacing (4-px base, 10-px friendly) --------- */
|
||||
--bf-space-0: 0;
|
||||
--bf-space-1: 4px;
|
||||
--bf-space-2: 8px;
|
||||
--bf-space-2_5:10px;
|
||||
--bf-space-3: 12px;
|
||||
--bf-space-4: 16px;
|
||||
--bf-space-5: 20px;
|
||||
--bf-space-6: 24px;
|
||||
--bf-space-8: 32px;
|
||||
--bf-space-9: 36px;
|
||||
--bf-space-10: 40px;
|
||||
--bf-space-13: 53px;
|
||||
--bf-space-16: 64px;
|
||||
--bf-space-20: 80px;
|
||||
--bf-space-24: 96px;
|
||||
|
||||
/* --- Layout -------------------------------------- */
|
||||
--bf-container-max: 1280px;
|
||||
--bf-gutter: 24px;
|
||||
--bf-gutter-mobile: 16px;
|
||||
--bf-section-y: 80px;
|
||||
--bf-section-y-mobile: 53px;
|
||||
|
||||
/* --- Radius ----------------------------------------
|
||||
* Square corners, everywhere (philosophy adopted 2026-07-14).
|
||||
* All steps resolve to 0 and are retained only so existing code
|
||||
* that references them renders square. Omit border-radius in new code.
|
||||
*/
|
||||
--bf-radius-none: 0;
|
||||
--bf-radius-xs: 0;
|
||||
--bf-radius-sm: 0;
|
||||
--bf-radius-md: 0;
|
||||
--bf-radius-lg: 0;
|
||||
--bf-radius-xl: 0;
|
||||
--bf-radius-2xl: 0;
|
||||
--bf-radius-3xl: 0;
|
||||
--bf-radius-pill: 0;
|
||||
|
||||
/* --- Shadows (signature flare glow) -------------- */
|
||||
--bf-shadow-flare-soft: 0 0 79px 0 rgba(58, 188, 248, 0.05);
|
||||
--bf-shadow-flare-medium: 0 0 29px 0 rgba(58, 188, 248, 0.50);
|
||||
--bf-shadow-flare-hover: 0 1px 22px 0 rgba(58, 188, 248, 0.40);
|
||||
--bf-shadow-flare-ring: 0 0 10.3px 1px #31A2D6, 0 0 10.9px 1px #31A2D6;
|
||||
--bf-shadow-elevation-1: 0 0 79px 0 rgba(0, 0, 0, 0.10);
|
||||
--bf-shadow-drift: 22px 0 92px 0 rgba(58, 188, 248, 0.10);
|
||||
|
||||
/* --- Breakpoints (also exposed for JS readers) ---- */
|
||||
--bf-bp-sm: 640px;
|
||||
--bf-bp-md: 768px;
|
||||
--bf-bp-lg: 1024px;
|
||||
--bf-bp-xl: 1280px;
|
||||
--bf-bp-2xl: 1536px;
|
||||
}
|
||||
|
||||
/* --- Reusable text styles ------------------------------------------------ */
|
||||
.bf-text-display-1 { font: var(--bf-font-weight-bold) var(--bf-text-4xl)/var(--bf-leading-display) var(--bf-font-display); letter-spacing: var(--bf-tracking-normal); }
|
||||
.bf-text-display-2 { font: var(--bf-font-weight-bold) var(--bf-text-3xl)/var(--bf-leading-display) var(--bf-font-display); letter-spacing: var(--bf-tracking-normal); }
|
||||
.bf-text-h2 { font: var(--bf-font-weight-semibold) var(--bf-text-2xl)/var(--bf-leading-relaxed) var(--bf-font-body); }
|
||||
.bf-text-h3 { font: var(--bf-font-weight-bold) var(--bf-text-xl)/var(--bf-leading-snug) var(--bf-font-body); }
|
||||
.bf-text-h4 { font: var(--bf-font-weight-bold) var(--bf-text-lg)/var(--bf-leading-normal) var(--bf-font-body); }
|
||||
.bf-text-lead { font: var(--bf-font-weight-regular) var(--bf-text-md)/var(--bf-leading-loose) var(--bf-font-body); letter-spacing: var(--bf-tracking-wide); }
|
||||
.bf-text-body { font: var(--bf-font-weight-regular) var(--bf-text-base)/var(--bf-leading-normal) var(--bf-font-body); }
|
||||
.bf-text-body-loose{ font: var(--bf-font-weight-regular) var(--bf-text-base)/var(--bf-leading-loose) var(--bf-font-body); letter-spacing: var(--bf-tracking-wide); }
|
||||
.bf-text-body-sm { font: var(--bf-font-weight-regular) var(--bf-text-sm)/var(--bf-leading-normal) var(--bf-font-body); }
|
||||
.bf-text-label { font: var(--bf-font-weight-semibold) var(--bf-text-sm)/var(--bf-leading-normal) var(--bf-font-body); }
|
||||
.bf-text-button { font: var(--bf-font-weight-semibold) var(--bf-text-base)/var(--bf-leading-normal) var(--bf-font-body); }
|
||||
.bf-text-caption { font: var(--bf-font-weight-regular) var(--bf-text-xs)/var(--bf-leading-relaxed) var(--bf-font-body); }
|
||||
.bf-text-eyebrow { font: var(--bf-font-weight-bold) var(--bf-text-xs)/var(--bf-leading-tight) var(--bf-font-body); letter-spacing: var(--bf-tracking-wider); text-transform: uppercase; }
|
||||
@@ -0,0 +1,59 @@
|
||||
/* Warden console compatibility layer (UI-4): maps the legacy app.css custom
|
||||
* properties onto the shared theme and token names so the console can drop its
|
||||
* own palette. Load after tokens.css and theme.css. Names with no shared
|
||||
* equivalent (brand chips, layout widths) keep fixed values.
|
||||
*/
|
||||
|
||||
:root {
|
||||
--radius: var(--bf-radius-none);
|
||||
--sp-1: var(--bf-space-1);
|
||||
--sp-2: var(--bf-space-2);
|
||||
--sp-3: var(--bf-space-3);
|
||||
--sp-4: var(--bf-space-4);
|
||||
--sp-6: var(--bf-space-6);
|
||||
--sp-8: var(--bf-space-8);
|
||||
--hair: 1px;
|
||||
--font-display: var(--bf-font-display);
|
||||
--font-body: var(--bf-font-body);
|
||||
|
||||
--bg: var(--app-bg);
|
||||
--surface: var(--app-surface);
|
||||
--surface-alt: var(--app-surface-alt);
|
||||
--border: var(--app-border);
|
||||
--text: var(--app-text);
|
||||
--text-muted: var(--app-text-muted);
|
||||
--accent: var(--app-link);
|
||||
--accent-ink: var(--bf-action-primary-text);
|
||||
--accent-soft: var(--app-row-hover);
|
||||
--crit: var(--app-danger);
|
||||
--focus: var(--app-focus-ring);
|
||||
|
||||
--flame: var(--bf-color-orange-500);
|
||||
--scrim: rgba(0, 0, 0, 0.55);
|
||||
--chip-dark: var(--bf-color-navy-800);
|
||||
--rail-w: 76px;
|
||||
--rail-narrow: 60px;
|
||||
--sidebar-w: 340px;
|
||||
}
|
||||
|
||||
/* Status colors have no shared token yet; values match the console palette. */
|
||||
:root,
|
||||
:root[data-theme='dark'] {
|
||||
--ok: #35C26A; --warn: #F2B441;
|
||||
--dot-ok: #35C26A; --dot-warn: #F2B441; --dot-crit: #F0555A;
|
||||
--dot-new: #3ABCF8; --dot-off: #5A6577;
|
||||
}
|
||||
|
||||
:root[data-theme='light'] {
|
||||
--ok: #1E8E4E; --warn: #9A6700;
|
||||
--dot-ok: #22B25A; --dot-warn: #E0A100; --dot-crit: #E5484D;
|
||||
--dot-new: #3776BE; --dot-off: #9AA3B2;
|
||||
}
|
||||
|
||||
@media (prefers-color-scheme: light) {
|
||||
:root:not([data-theme]) {
|
||||
--ok: #1E8E4E; --warn: #9A6700;
|
||||
--dot-ok: #22B25A; --dot-warn: #E0A100; --dot-crit: #E5484D;
|
||||
--dot-new: #3776BE; --dot-off: #9AA3B2;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
use std::collections::BTreeMap;
|
||||
use std::hint::black_box;
|
||||
|
||||
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
|
||||
use flare_ui::chart::{Chart, Series, Tier, TierSpec};
|
||||
|
||||
fn fixture(count: usize) -> Chart {
|
||||
Chart {
|
||||
id: "traffic".into(),
|
||||
label: "Network traffic".into(),
|
||||
series: (0..count)
|
||||
.map(|i| Series {
|
||||
key: format!("interface{i}"),
|
||||
label: format!("Interface {i}"),
|
||||
unit: "B/s".into(),
|
||||
color: "#3776BE".into(),
|
||||
})
|
||||
.collect(),
|
||||
tiers: [
|
||||
TierSpec { n: 60, step_s: 60 },
|
||||
TierSpec {
|
||||
n: 60,
|
||||
step_s: 3600,
|
||||
},
|
||||
TierSpec {
|
||||
n: 60,
|
||||
step_s: 86400,
|
||||
},
|
||||
],
|
||||
tier: Tier::Min,
|
||||
points: (0..count)
|
||||
.map(|i| {
|
||||
(
|
||||
format!("interface{i}"),
|
||||
(0..60)
|
||||
.map(|j| (j as f64 * 1000.0, (i + j) as f64))
|
||||
.collect(),
|
||||
)
|
||||
})
|
||||
.collect::<BTreeMap<_, _>>(),
|
||||
}
|
||||
}
|
||||
|
||||
fn charts(c: &mut Criterion) {
|
||||
let mut group = c.benchmark_group("chart_contract");
|
||||
for count in [2, 64] {
|
||||
let chart = fixture(count);
|
||||
group.bench_with_input(BenchmarkId::new("props", count), &chart, |b, chart| {
|
||||
b.iter(|| black_box(chart).props().unwrap())
|
||||
});
|
||||
group.bench_with_input(BenchmarkId::new("render", count), &chart, |b, chart| {
|
||||
b.iter(|| black_box(chart).render("/network/traffic").unwrap())
|
||||
});
|
||||
}
|
||||
group.finish();
|
||||
}
|
||||
|
||||
criterion_group!(benches, charts);
|
||||
criterion_main!(benches);
|
||||
@@ -0,0 +1,97 @@
|
||||
//! Action and approval block renderers (LD-06): buttons that post through htmx.
|
||||
//!
|
||||
//! Every action is a `<form method="post">` so it works without script; the
|
||||
//! `hx-post` attributes only upgrade it in place. Targets must be same-origin
|
||||
//! absolute paths (`/...`, not `//`), and each form carries the CSRF token the
|
||||
//! caller supplies. Text is escaped by maud and classes are allowlisted.
|
||||
|
||||
use maud::{html, Markup};
|
||||
|
||||
/// True when `path` is a same-origin absolute path safe to post to.
|
||||
pub fn safe_target(path: &str) -> bool {
|
||||
path.starts_with('/')
|
||||
&& !path.starts_with("//")
|
||||
&& !path.contains('\\')
|
||||
&& !path.chars().any(|c| c.is_control() || c.is_whitespace())
|
||||
}
|
||||
|
||||
/// Visual weight of an action button.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Tone {
|
||||
Normal,
|
||||
Primary,
|
||||
Danger,
|
||||
}
|
||||
|
||||
impl Tone {
|
||||
fn class(self) -> &'static str {
|
||||
match self {
|
||||
Tone::Normal => "bf-btn bf-text-button",
|
||||
Tone::Primary => "bf-btn bf-btn-primary bf-text-button",
|
||||
Tone::Danger => "bf-btn bf-btn-danger bf-text-button",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// One action button. Returns `None` for an unsafe target so a bad schema
|
||||
/// entry renders nothing instead of a post to another origin.
|
||||
pub fn action_button(
|
||||
target: &str,
|
||||
label: &str,
|
||||
tone: Tone,
|
||||
csrf: &str,
|
||||
confirm: Option<&str>,
|
||||
) -> Option<Markup> {
|
||||
if !safe_target(target) {
|
||||
return None;
|
||||
}
|
||||
Some(html! {
|
||||
form class="bf-action" method="post" action=(target) hx-post=(target) hx-swap="outerHTML" {
|
||||
input type="hidden" name="csrf" value=(csrf);
|
||||
@if let Some(c) = confirm {
|
||||
p class="bf-action-confirm bf-text-body" { (c) }
|
||||
}
|
||||
button type="submit" class=(tone.class()) { (label) }
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// A pending approval awaiting a decision.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Approval {
|
||||
pub id: String,
|
||||
pub summary: String,
|
||||
pub requested_by: String,
|
||||
}
|
||||
|
||||
/// Approval list: each row has approve and deny buttons posting to
|
||||
/// `<base>/<id>/approve` and `<base>/<id>/deny`. Ids outside `[A-Za-z0-9_-]`
|
||||
/// are skipped so they cannot alter the path. The empty list shows a note.
|
||||
pub fn approvals(base: &str, items: &[Approval], csrf: &str) -> Markup {
|
||||
let usable: Vec<&Approval> = items
|
||||
.iter()
|
||||
.filter(|a| {
|
||||
!a.id.is_empty()
|
||||
&& a.id
|
||||
.chars()
|
||||
.all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-')
|
||||
})
|
||||
.collect();
|
||||
html! {
|
||||
@if usable.is_empty() || !safe_target(base) {
|
||||
p class="bf-note bf-text-body" { "No approvals pending." }
|
||||
} @else {
|
||||
ul class="bf-approvals" {
|
||||
@for a in usable {
|
||||
li class="bf-approval" {
|
||||
span class="bf-text-body" { (a.summary) }
|
||||
span class="bf-text-label" { "Requested by " (a.requested_by) }
|
||||
@let b = base.trim_end_matches('/');
|
||||
(action_button(&format!("{b}/{}/approve", a.id), "Approve", Tone::Primary, csrf, None).unwrap_or_default())
|
||||
(action_button(&format!("{b}/{}/deny", a.id), "Deny", Tone::Danger, csrf, Some("Deny this request?")).unwrap_or_default())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
+180
@@ -0,0 +1,180 @@
|
||||
//! Page assets and the plain-HTTP lint (UI-6, d04).
|
||||
//!
|
||||
//! A page declares the scripts and stylesheets it needs as [`PageAssets`];
|
||||
//! [`PageAssets::head`] renders the tags and [`lint`] checks the declaration
|
||||
//! against the delivery context. Consoles are often served over plain HTTP on
|
||||
//! a site LAN, so secure-context-only browser APIs and an over-large SSE
|
||||
//! budget are lint errors there.
|
||||
|
||||
use maud::{html, Markup};
|
||||
|
||||
use crate::live::LIVE_JS;
|
||||
|
||||
/// Islands script (table sort in the URL, column resize).
|
||||
pub const ISLANDS_JS: &str = include_str!("../assets/js/islands.js");
|
||||
|
||||
/// Page glue: stream, stale marker, charts, table sort, htmx CSRF header.
|
||||
pub const BOOT_JS: &str = include_str!("../assets/js/boot.js");
|
||||
|
||||
/// Chart island and reading glue (draws series, writes pushed values).
|
||||
pub const CHART_JS: &str = include_str!("../assets/js/chart.js");
|
||||
|
||||
/// Browsers cap plain HTTP/1.1 connections per origin at 6. One is kept free
|
||||
/// for page loads and API calls, so at most 5 SSE streams per page.
|
||||
pub const PLAIN_HTTP_SSE_BUDGET: usize = 5;
|
||||
|
||||
/// Browser APIs that exist only in a secure context (HTTPS or localhost).
|
||||
pub const SECURE_ONLY_APIS: &[&str] = &[
|
||||
"crypto.subtle",
|
||||
"navigator.clipboard",
|
||||
"navigator.serviceWorker",
|
||||
"navigator.mediaDevices",
|
||||
"navigator.geolocation",
|
||||
];
|
||||
|
||||
/// What one page loads.
|
||||
#[derive(Debug, Clone, Default, PartialEq, Eq)]
|
||||
pub struct PageAssets {
|
||||
/// Stylesheet URLs, in order.
|
||||
pub styles: Vec<String>,
|
||||
/// Script URLs, in order. All are emitted `defer`.
|
||||
pub scripts: Vec<String>,
|
||||
/// SSE stream URLs the page opens.
|
||||
pub streams: Vec<String>,
|
||||
}
|
||||
|
||||
impl PageAssets {
|
||||
/// Head tags: stylesheets, then deferred scripts.
|
||||
pub fn head(&self) -> Markup {
|
||||
html! {
|
||||
@for s in &self.styles { link rel="stylesheet" href=(s); }
|
||||
@for s in &self.scripts { script src=(s) defer {} }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// How the page is delivered.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum Delivery {
|
||||
PlainHttp,
|
||||
Secure,
|
||||
}
|
||||
|
||||
/// One lint finding.
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub enum Finding {
|
||||
/// More SSE streams than [`PLAIN_HTTP_SSE_BUDGET`] on plain HTTP.
|
||||
SseBudget { streams: usize, budget: usize },
|
||||
/// A script source uses a secure-context-only API.
|
||||
SecureOnlyApi { script: String, api: &'static str },
|
||||
}
|
||||
|
||||
/// Lints a page. `script_source` returns the text of a script URL (the caller
|
||||
/// reads its own static files); unknown scripts return `None` and are skipped.
|
||||
pub fn lint(
|
||||
assets: &PageAssets,
|
||||
delivery: Delivery,
|
||||
script_source: &dyn Fn(&str) -> Option<String>,
|
||||
) -> Vec<Finding> {
|
||||
let mut out = Vec::new();
|
||||
if delivery == Delivery::Secure {
|
||||
return out;
|
||||
}
|
||||
if assets.streams.len() > PLAIN_HTTP_SSE_BUDGET {
|
||||
out.push(Finding::SseBudget {
|
||||
streams: assets.streams.len(),
|
||||
budget: PLAIN_HTTP_SSE_BUDGET,
|
||||
});
|
||||
}
|
||||
for s in &assets.scripts {
|
||||
let Some(src) = script_source(s) else {
|
||||
continue;
|
||||
};
|
||||
for api in SECURE_ONLY_APIS {
|
||||
if src.contains(api) {
|
||||
out.push(Finding::SecureOnlyApi {
|
||||
script: s.clone(),
|
||||
api,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The crate's own scripts never use a secure-context-only API.
|
||||
pub fn builtin_script(name: &str) -> Option<&'static str> {
|
||||
match name {
|
||||
"live.js" => Some(LIVE_JS),
|
||||
"islands.js" => Some(ISLANDS_JS),
|
||||
"chart.js" => Some(CHART_JS),
|
||||
"boot.js" => Some(BOOT_JS),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn pa(scripts: &[&str], streams: usize) -> PageAssets {
|
||||
PageAssets {
|
||||
styles: vec!["/a/tokens.css".into()],
|
||||
scripts: scripts.iter().map(|s| s.to_string()).collect(),
|
||||
streams: (0..streams).map(|i| format!("/s/{i}")).collect(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn head_renders_styles_then_deferred_scripts() {
|
||||
let h = pa(&["live.js"], 0).head().into_string();
|
||||
assert_eq!(
|
||||
h,
|
||||
r#"<link rel="stylesheet" href="/a/tokens.css"><script src="live.js" defer></script>"#
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn builtin_scripts_pass_plain_http_lint() {
|
||||
let a = pa(&["live.js", "islands.js", "chart.js", "boot.js"], 5);
|
||||
let f = lint(&a, Delivery::PlainHttp, &|s| {
|
||||
builtin_script(s).map(String::from)
|
||||
});
|
||||
assert!(f.is_empty(), "{f:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chart_script_is_ascii_and_exports() {
|
||||
assert!(BOOT_JS.is_ascii());
|
||||
assert!(BOOT_JS.contains("FlareBoot"));
|
||||
assert!(CHART_JS.is_ascii());
|
||||
assert!(CHART_JS.contains("FlareChart"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sse_budget_is_enforced_on_plain_http_only() {
|
||||
let a = pa(&[], 6);
|
||||
assert_eq!(
|
||||
lint(&a, Delivery::PlainHttp, &|_| None),
|
||||
vec![Finding::SseBudget {
|
||||
streams: 6,
|
||||
budget: 5
|
||||
}]
|
||||
);
|
||||
assert!(lint(&a, Delivery::Secure, &|_| None).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn secure_only_api_is_flagged_on_plain_http() {
|
||||
let a = pa(&["x.js"], 0);
|
||||
let src = |_: &str| Some("navigator.clipboard.writeText(1)".to_string());
|
||||
assert_eq!(
|
||||
lint(&a, Delivery::PlainHttp, &src),
|
||||
vec![Finding::SecureOnlyApi {
|
||||
script: "x.js".into(),
|
||||
api: "navigator.clipboard"
|
||||
}]
|
||||
);
|
||||
assert!(lint(&a, Delivery::Secure, &src).is_empty());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
//! `nav-json <schema.json>`: prints `nav.json` for an effective (or base)
|
||||
//! schema document. Exit 2 on a usage or parse error.
|
||||
|
||||
use std::process::ExitCode;
|
||||
|
||||
fn main() -> ExitCode {
|
||||
let mut args = std::env::args().skip(1);
|
||||
let (Some(path), None) = (args.next(), args.next()) else {
|
||||
eprintln!("usage: nav-json <schema.json>");
|
||||
return ExitCode::from(2);
|
||||
};
|
||||
let text = match std::fs::read_to_string(&path) {
|
||||
Ok(t) => t,
|
||||
Err(e) => {
|
||||
eprintln!("nav-json: {path}: {e}");
|
||||
return ExitCode::from(2);
|
||||
}
|
||||
};
|
||||
let doc = match wschema::model::Document::from_json(&text) {
|
||||
Ok(d) => d,
|
||||
Err(e) => {
|
||||
eprintln!("nav-json: {path}: {e}");
|
||||
return ExitCode::from(2);
|
||||
}
|
||||
};
|
||||
match serde_json::to_string_pretty(&flare_ui::nav::nav_json(&doc.menus)) {
|
||||
Ok(s) => {
|
||||
println!("{s}");
|
||||
ExitCode::SUCCESS
|
||||
}
|
||||
Err(e) => {
|
||||
eprintln!("nav-json: {e}");
|
||||
ExitCode::from(2)
|
||||
}
|
||||
}
|
||||
}
|
||||
+183
@@ -0,0 +1,183 @@
|
||||
//! Chart island props, server navigation and accessible latest values (D63).
|
||||
|
||||
use std::collections::{BTreeMap, BTreeSet};
|
||||
|
||||
use maud::{html, Markup};
|
||||
use serde_json::{json, Value};
|
||||
|
||||
/// The retained renderer displays 60 samples at each tier.
|
||||
pub const SAMPLES: usize = 60;
|
||||
pub const MAX_SERIES: usize = 64;
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Tier {
|
||||
Min,
|
||||
Hour,
|
||||
Day,
|
||||
}
|
||||
|
||||
impl Tier {
|
||||
pub const ALL: [Self; 3] = [Self::Min, Self::Hour, Self::Day];
|
||||
|
||||
pub fn as_str(self) -> &'static str {
|
||||
match self {
|
||||
Self::Min => "min",
|
||||
Self::Hour => "hour",
|
||||
Self::Day => "day",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct TierSpec {
|
||||
pub n: usize,
|
||||
pub step_s: u32,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Series {
|
||||
pub key: String,
|
||||
pub label: String,
|
||||
pub unit: String,
|
||||
/// Three or six hexadecimal RGB digits, prefixed with `#`.
|
||||
pub color: String,
|
||||
}
|
||||
|
||||
/// Timestamps are milliseconds since the Unix epoch, as in live readings.
|
||||
pub type Point = (f64, f64);
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Chart {
|
||||
pub id: String,
|
||||
pub label: String,
|
||||
pub series: Vec<Series>,
|
||||
/// Min, hour and day metadata, in [`Tier::ALL`] order.
|
||||
pub tiers: [TierSpec; 3],
|
||||
pub tier: Tier,
|
||||
/// Selected-tier samples, oldest first. Empty or missing series are valid.
|
||||
pub points: BTreeMap<String, Vec<Point>>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Error {
|
||||
Identity,
|
||||
Series,
|
||||
Tiers,
|
||||
Points,
|
||||
Path,
|
||||
}
|
||||
|
||||
impl std::fmt::Display for Error {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.write_str(match self {
|
||||
Self::Identity => "invalid chart identity",
|
||||
Self::Series => "invalid chart series",
|
||||
Self::Tiers => "invalid chart tiers",
|
||||
Self::Points => "invalid chart samples",
|
||||
Self::Path => "invalid chart page path",
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl std::error::Error for Error {}
|
||||
|
||||
fn text(s: &str, max: usize) -> bool {
|
||||
!s.is_empty() && s.len() <= max && !s.chars().any(char::is_control)
|
||||
}
|
||||
|
||||
impl Chart {
|
||||
pub fn validate(&self) -> Result<(), Error> {
|
||||
if !text(&self.id, 128) || !text(&self.label, 256) {
|
||||
return Err(Error::Identity);
|
||||
}
|
||||
if self.series.is_empty() || self.series.len() > MAX_SERIES {
|
||||
return Err(Error::Series);
|
||||
}
|
||||
let mut keys = BTreeSet::new();
|
||||
for s in &self.series {
|
||||
let hex = s.color.strip_prefix('#').unwrap_or("");
|
||||
if !text(&s.key, 256)
|
||||
|| !text(&s.label, 256)
|
||||
|| s.unit.len() > 64
|
||||
|| s.unit.chars().any(char::is_control)
|
||||
|| !matches!(hex.len(), 3 | 6)
|
||||
|| !hex.bytes().all(|b| b.is_ascii_hexdigit())
|
||||
|| !keys.insert(s.key.as_str())
|
||||
{
|
||||
return Err(Error::Series);
|
||||
}
|
||||
}
|
||||
if self.tiers.iter().any(|t| t.n != SAMPLES || t.step_s == 0) {
|
||||
return Err(Error::Tiers);
|
||||
}
|
||||
for (key, points) in &self.points {
|
||||
if !keys.contains(key.as_str())
|
||||
|| points.len() > SAMPLES
|
||||
|| points.iter().any(|(t, v)| !t.is_finite() || !v.is_finite())
|
||||
|| points.windows(2).any(|p| p[0].0 >= p[1].0)
|
||||
{
|
||||
return Err(Error::Points);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn props(&self) -> Result<Value, Error> {
|
||||
self.validate()?;
|
||||
let tiers: BTreeMap<_, _> = Tier::ALL
|
||||
.iter()
|
||||
.zip(&self.tiers)
|
||||
.map(|(tier, spec)| (tier.as_str(), json!({ "n": spec.n, "step_s": spec.step_s })))
|
||||
.collect();
|
||||
Ok(json!({
|
||||
"id": self.id,
|
||||
"series": self.series.iter().map(|s| json!({
|
||||
"key": s.key, "label": s.label, "unit": s.unit, "color": s.color
|
||||
})).collect::<Vec<_>>(),
|
||||
"tiers": tiers, "tier": self.tier.as_str(), "points": self.points,
|
||||
}))
|
||||
}
|
||||
|
||||
/// `path` is the canonical page path without a query or fragment.
|
||||
/// Tier changes remain normal links when JavaScript is unavailable.
|
||||
pub fn render(&self, path: &str) -> Result<Markup, Error> {
|
||||
if !path.starts_with('/')
|
||||
|| path.starts_with("//")
|
||||
|| path
|
||||
.chars()
|
||||
.any(|c| c.is_control() || matches!(c, '\\' | '?' | '#'))
|
||||
{
|
||||
return Err(Error::Path);
|
||||
}
|
||||
let props = self.props()?.to_string();
|
||||
Ok(html! {
|
||||
figure id=(self.id) class="bf-chart" data-live data-island="chart" data-chart=(props) {
|
||||
figcaption class="bf-text-label" { (self.label) }
|
||||
nav aria-label="Chart tier" {
|
||||
@for tier in Tier::ALL {
|
||||
a href=(crate::url::with_query(path, [("tier", tier.as_str())], &[]))
|
||||
aria-current=[(tier == self.tier).then_some("page")] { (tier.as_str()) }
|
||||
}
|
||||
}
|
||||
canvas class="bf-chart-canvas" role="img" aria-label=(self.label) {}
|
||||
table class="bf-vh" {
|
||||
caption { (self.label) " latest values" }
|
||||
thead { tr { th scope="col" { "Series" } th scope="col" { "Value" } } }
|
||||
tbody {
|
||||
@for series in &self.series {
|
||||
tr {
|
||||
th scope="row" { (series.label) }
|
||||
td data-chart-value=(series.key) {
|
||||
@if let Some((_, value)) = self.points.get(&series.key).and_then(|p| p.last()) {
|
||||
(value)
|
||||
} @else { "--" }
|
||||
" " (series.unit)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,119 @@
|
||||
//! Shared HTML components (UI-4), rendered with maud.
|
||||
//!
|
||||
//! Every class a component emits is in the stylesheet allowlist
|
||||
//! ([`crate::tokens::class_allowed`]); a test renders each component and
|
||||
//! checks that. Text is escaped by maud.
|
||||
|
||||
use maud::{html, Markup};
|
||||
|
||||
/// Severity of a [`badge`].
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum Level {
|
||||
Ok,
|
||||
Warn,
|
||||
Err,
|
||||
}
|
||||
|
||||
impl Level {
|
||||
fn class(self) -> &'static str {
|
||||
match self {
|
||||
Level::Ok => "bf-badge bf-badge-ok",
|
||||
Level::Warn => "bf-badge bf-badge-warn",
|
||||
Level::Err => "bf-badge bf-badge-err",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A status badge.
|
||||
pub fn badge(level: Level, text: &str) -> Markup {
|
||||
html! { span class=(level.class()) { (text) } }
|
||||
}
|
||||
|
||||
/// A link styled as a button.
|
||||
pub fn button_link(href: &str, label: &str, primary: bool) -> Markup {
|
||||
let class = if primary {
|
||||
"bf-btn bf-btn-primary bf-text-button"
|
||||
} else {
|
||||
"bf-btn bf-text-button"
|
||||
};
|
||||
html! { a class=(class) href=(href) { (label) } }
|
||||
}
|
||||
|
||||
/// A titled card around caller-supplied content.
|
||||
pub fn card(title: &str, body: Markup) -> Markup {
|
||||
html! {
|
||||
section class="bf-card" {
|
||||
h3 class="bf-card-title bf-text-h3" { (title) }
|
||||
(body)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A plain table. `stale` dims it (the SSE client sets this on disconnect).
|
||||
pub fn table(headers: &[&str], rows: &[Vec<String>], stale: bool) -> Markup {
|
||||
let class = if stale {
|
||||
"bf-table bf-stale"
|
||||
} else {
|
||||
"bf-table"
|
||||
};
|
||||
html! {
|
||||
table class=(class) {
|
||||
thead { tr { @for h in headers { th class="bf-text-label" { (h) } } } }
|
||||
tbody { @for r in rows { tr { @for c in r { td class="bf-text-body-sm" { (c) } } } } }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::tokens::class_allowed;
|
||||
|
||||
fn classes(html: &str) -> Vec<String> {
|
||||
let mut out = Vec::new();
|
||||
let mut rest = html;
|
||||
while let Some(i) = rest.find("class=\"") {
|
||||
rest = &rest[i + 7..];
|
||||
let end = rest.find('"').unwrap();
|
||||
out.extend(rest[..end].split_whitespace().map(String::from));
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_emitted_class_is_allowed() {
|
||||
let rows = vec![vec!["a".to_string(), "b".to_string()]];
|
||||
let outs = [
|
||||
badge(Level::Ok, "up"),
|
||||
badge(Level::Warn, "w"),
|
||||
badge(Level::Err, "e"),
|
||||
button_link("/x", "Go", true),
|
||||
button_link("/x", "Go", false),
|
||||
card("T", html! { p { "x" } }),
|
||||
table(&["A", "B"], &rows, false),
|
||||
table(&["A", "B"], &rows, true),
|
||||
];
|
||||
for o in outs {
|
||||
let s = o.into_string();
|
||||
let cs = classes(&s);
|
||||
assert!(!cs.is_empty(), "{s}");
|
||||
for c in cs {
|
||||
assert!(class_allowed(&c), "class {c} not allowed in {s}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn text_is_escaped() {
|
||||
let s = badge(Level::Err, "<script>").into_string();
|
||||
assert!(s.contains("<script>") && !s.contains("<script>"));
|
||||
let s = button_link("/x?a=1&b=2", "a\"b", false).into_string();
|
||||
assert!(s.contains("&") && s.contains("""));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stale_table_is_marked() {
|
||||
let s = table(&["A"], &[], true).into_string();
|
||||
assert!(s.contains("bf-stale"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
//! The display-type list as a versioned file.
|
||||
//!
|
||||
//! `wschema::display::REGISTRY` is the source of truth. This module renders it
|
||||
//! to `docs/display-types.json`, the file generators in other repos read (the
|
||||
//! panel table generator and the golden HTML cases). A test keeps the
|
||||
//! committed file equal to the registry, so a new display type cannot ship
|
||||
//! without the file moving with it.
|
||||
|
||||
use serde_json::{json, Value};
|
||||
use wschema::display::{level, Bind, BLOCK_KINDS, REGISTRY};
|
||||
|
||||
/// Snake-case token of a bind kind, as the file spells it.
|
||||
pub fn bind_token(b: Bind) -> &'static str {
|
||||
match b {
|
||||
Bind::Str => "str",
|
||||
Bind::Enum => "enum",
|
||||
Bind::Int => "int",
|
||||
Bind::IntSet => "int_set",
|
||||
Bind::Bool => "bool",
|
||||
Bind::Secret => "secret",
|
||||
Bind::List => "list",
|
||||
Bind::Map => "map",
|
||||
Bind::MapEntry => "map_entry",
|
||||
Bind::Reading => "reading",
|
||||
Bind::Action => "action",
|
||||
Bind::Block => "block",
|
||||
}
|
||||
}
|
||||
|
||||
/// `{"display_api", "types": [{"id", "binds", "since"}], "block_kinds"}`,
|
||||
/// in registry order. Rows are only ever added.
|
||||
pub fn display_types_json() -> Value {
|
||||
let types: Vec<Value> = REGISTRY
|
||||
.iter()
|
||||
.map(|d| {
|
||||
json!({
|
||||
"id": d.id,
|
||||
"binds": d.binds.iter().map(|b| bind_token(*b)).collect::<Vec<_>>(),
|
||||
"since": d.since,
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
json!({
|
||||
"display_api": level(),
|
||||
"types": types,
|
||||
"block_kinds": BLOCK_KINDS,
|
||||
})
|
||||
}
|
||||
+50
@@ -0,0 +1,50 @@
|
||||
//! Shared UI crate for FLARE and the Warden console.
|
||||
//!
|
||||
//! - [`display_types`]: the versioned display-type list (`docs/display-types.json`).
|
||||
//! - [`nav`]: evaluates the schema's menu nodes for one viewer and emits
|
||||
//! `nav.json` (d04 section 4.1).
|
||||
//! - [`url`]: URL builders for the console and FLARE route tables, and the
|
||||
//! closed query-parameter set (d04 sections 4.2, 4.3).
|
||||
//! - [`components`]: maud components that emit only allowlisted classes.
|
||||
//! - [`actions`]: action buttons and approval lists (htmx upgrade over plain forms).
|
||||
//! - [`assets`]: page asset declarations, head tags and the plain-HTTP lint.
|
||||
//! - [`live`]: the SSE client script (ring, caps, reconnect, stale marker).
|
||||
//! - [`readings`]: live reading and block renderers.
|
||||
//! - [`chart`]: typed chart props, tier links and latest-value fallback.
|
||||
//! - [`render`]: renders schema settings by display type and validates forms.
|
||||
//! - [`shell`]: page shell (sidebar, tab strip, main area).
|
||||
//! - [`tokens`]: design tokens stylesheet and the CSS class allowlist.
|
||||
//! - [`resolve`]: maps a request path to a route, with canonical redirects
|
||||
//! and the `#/` bookmark rule (d04 sections 4.2, 4.3).
|
||||
//!
|
||||
//! Every function is pure: no I/O, no environment.
|
||||
|
||||
#![forbid(unsafe_code)]
|
||||
|
||||
pub mod actions;
|
||||
pub mod assets;
|
||||
pub mod chart;
|
||||
pub mod components;
|
||||
pub mod display_types;
|
||||
pub mod live;
|
||||
pub mod nav;
|
||||
pub mod readings;
|
||||
pub mod render;
|
||||
pub mod resolve;
|
||||
pub mod shell;
|
||||
pub mod studio;
|
||||
pub mod tokens;
|
||||
pub mod url;
|
||||
|
||||
/// Crate name, used by consumers to check which pin they vendored.
|
||||
pub const NAME: &str = "flare-ui";
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn name_is_stable() {
|
||||
assert_eq!(NAME, "flare-ui");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
//! Live-data client script (UI-6).
|
||||
//!
|
||||
//! [`LIVE_JS`] is the SSE client served as a static asset: bounded ring per
|
||||
//! series, capped series count, reconnect with capped exponential backoff,
|
||||
//! and a stale marker (`bf-stale` on every `[data-live]` element).
|
||||
|
||||
/// The client script, byte for byte.
|
||||
pub const LIVE_JS: &str = include_str!("../assets/js/live.js");
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn script_is_ascii_and_exports_live() {
|
||||
assert!(LIVE_JS.is_ascii());
|
||||
assert!(LIVE_JS.contains("FlareLive"));
|
||||
assert!(LIVE_JS.contains("bf-stale"));
|
||||
}
|
||||
}
|
||||
+248
@@ -0,0 +1,248 @@
|
||||
//! Navigation model: one evaluation of the schema menus per viewer.
|
||||
//!
|
||||
//! The menu nodes come from the effective schema (`wschema::model::Menu`).
|
||||
//! [`visible`] keeps what the current surface, capabilities, installed apps
|
||||
//! and principal allow, orders it, and attaches the canonical href of every
|
||||
//! tab. [`nav_json`] emits the unfiltered nav listing that flow tooling and
|
||||
//! the browser route table read.
|
||||
|
||||
use std::collections::{BTreeMap, BTreeSet};
|
||||
|
||||
use serde_json::{json, Value};
|
||||
use wschema::model::{Menu, MenuRequires, Surface};
|
||||
|
||||
use crate::url::Routes;
|
||||
|
||||
/// Band used when a section does not set one (core).
|
||||
pub const DEFAULT_BAND: i64 = 1;
|
||||
|
||||
/// What the viewer may see. The page-level grant is the permission check of
|
||||
/// d04 7.3; the nav only asks whether a page shows the viewer anything.
|
||||
pub trait Principal {
|
||||
/// True when the viewer may see at least one block of `page`.
|
||||
fn may_view_page(&self, page: &str) -> bool;
|
||||
}
|
||||
|
||||
/// A principal that may view every page (Warden console tests, panel).
|
||||
pub struct AllowAll;
|
||||
|
||||
impl Principal for AllowAll {
|
||||
fn may_view_page(&self, _page: &str) -> bool {
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
/// A set of names (platform capabilities or installed app ids).
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq)]
|
||||
pub struct NameSet(BTreeSet<String>);
|
||||
|
||||
impl NameSet {
|
||||
pub fn new<I, S>(names: I) -> Self
|
||||
where
|
||||
I: IntoIterator<Item = S>,
|
||||
S: Into<String>,
|
||||
{
|
||||
NameSet(names.into_iter().map(Into::into).collect())
|
||||
}
|
||||
|
||||
pub fn contains(&self, name: &str) -> bool {
|
||||
self.0.contains(name)
|
||||
}
|
||||
}
|
||||
|
||||
/// Platform capabilities (`rs485-bus`, `relay-io`, ...).
|
||||
pub type CapSet = NameSet;
|
||||
/// Installed and enabled apps from the app manager.
|
||||
pub type AppSet = NameSet;
|
||||
|
||||
/// Everything `visible` needs about the viewer and the device.
|
||||
pub struct NavContext<'a> {
|
||||
pub surface: Surface,
|
||||
pub principal: &'a dyn Principal,
|
||||
pub caps: &'a CapSet,
|
||||
pub apps: &'a AppSet,
|
||||
/// Builds the tab hrefs; carries the route prefix of the surface.
|
||||
pub routes: &'a Routes,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct VisibleTab {
|
||||
pub slug: String,
|
||||
pub title: String,
|
||||
pub page: String,
|
||||
pub href: String,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct VisibleSection {
|
||||
pub slug: String,
|
||||
pub title: String,
|
||||
pub icon: String,
|
||||
pub tabs: Vec<VisibleTab>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq)]
|
||||
pub struct VisibleNav {
|
||||
pub sections: Vec<VisibleSection>,
|
||||
}
|
||||
|
||||
impl VisibleNav {
|
||||
/// The section with this slug.
|
||||
pub fn section(&self, slug: &str) -> Option<&VisibleSection> {
|
||||
self.sections.iter().find(|s| s.slug == slug)
|
||||
}
|
||||
|
||||
/// `(section, tab)` slugs of the first visible tab of the first visible
|
||||
/// section: the target of `GET /`.
|
||||
pub fn first_tab(&self) -> Option<(&str, &str)> {
|
||||
let s = self.sections.first()?;
|
||||
let t = s.tabs.first()?;
|
||||
Some((&s.slug, &t.slug))
|
||||
}
|
||||
}
|
||||
|
||||
/// Sort key shared by sections and tabs: band, order, case-folded title, id.
|
||||
fn sort_key(m: &Menu) -> (i64, i64, String, String) {
|
||||
(
|
||||
m.band.unwrap_or(DEFAULT_BAND),
|
||||
m.order.unwrap_or(0),
|
||||
m.title.to_ascii_lowercase(),
|
||||
m.id.clone(),
|
||||
)
|
||||
}
|
||||
|
||||
fn requires_hold(req: &Option<MenuRequires>, cx: &NavContext) -> bool {
|
||||
let Some(r) = req else { return true };
|
||||
r.capabilities.iter().all(|c| cx.caps.contains(c))
|
||||
&& (r.any.is_empty() || r.any.iter().any(|a| cx.apps.contains(a)))
|
||||
}
|
||||
|
||||
/// Surfaces a node appears on. A tab without its own list inherits the
|
||||
/// section's; a section without one appears everywhere.
|
||||
fn effective_surfaces(tab: Option<&Menu>, section: &Menu) -> BTreeSet<Surface> {
|
||||
let list = tab
|
||||
.and_then(|t| t.surfaces.as_ref())
|
||||
.or(section.surfaces.as_ref());
|
||||
match list {
|
||||
Some(v) => v.iter().copied().collect(),
|
||||
None => [Surface::Panel, Surface::Web, Surface::Flare]
|
||||
.into_iter()
|
||||
.collect(),
|
||||
}
|
||||
}
|
||||
|
||||
fn split_id(id: &str) -> (&str, Option<&str>) {
|
||||
match id.split_once('/') {
|
||||
Some((s, t)) => (s, Some(t)),
|
||||
None => (id, None),
|
||||
}
|
||||
}
|
||||
|
||||
/// Groups menu nodes into `(section, tabs)`; a tab whose section node is
|
||||
/// missing is dropped (lint reports it).
|
||||
fn group(menus: &[Menu]) -> Vec<(&Menu, Vec<&Menu>)> {
|
||||
let mut tabs: BTreeMap<&str, Vec<&Menu>> = BTreeMap::new();
|
||||
for m in menus {
|
||||
if let (sec, Some(_)) = split_id(&m.id) {
|
||||
tabs.entry(sec).or_default().push(m);
|
||||
}
|
||||
}
|
||||
menus
|
||||
.iter()
|
||||
.filter(|m| split_id(&m.id).1.is_none())
|
||||
.map(|s| (s, tabs.remove(s.id.as_str()).unwrap_or_default()))
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Evaluates the menus for one viewer. Pure.
|
||||
///
|
||||
/// A section stays when the surface is in its `surfaces`, its `requires`
|
||||
/// hold and at least one tab is visible. A tab stays when the surface is in
|
||||
/// its effective `surfaces`, its own and its section's `requires` hold, it
|
||||
/// names a page and the principal may see that page.
|
||||
pub fn visible(menus: &[Menu], cx: &NavContext) -> VisibleNav {
|
||||
let mut grouped = group(menus);
|
||||
grouped.sort_by_key(|(s, _)| sort_key(s));
|
||||
let mut sections = Vec::new();
|
||||
for (sec, mut tabs) in grouped {
|
||||
if !effective_surfaces(None, sec).contains(&cx.surface) || !requires_hold(&sec.requires, cx)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
tabs.sort_by_key(|t| sort_key(t));
|
||||
let tabs: Vec<VisibleTab> = tabs
|
||||
.into_iter()
|
||||
.filter(|t| effective_surfaces(Some(t), sec).contains(&cx.surface))
|
||||
.filter(|t| requires_hold(&t.requires, cx))
|
||||
.filter_map(|t| {
|
||||
let page = t.page.as_ref()?;
|
||||
cx.principal.may_view_page(page).then(|| VisibleTab {
|
||||
slug: t.slug.clone(),
|
||||
title: t.title.clone(),
|
||||
page: page.clone(),
|
||||
href: cx.routes.page(&sec.slug, &t.slug),
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
if tabs.is_empty() {
|
||||
continue;
|
||||
}
|
||||
sections.push(VisibleSection {
|
||||
slug: sec.slug.clone(),
|
||||
title: sec.title.clone(),
|
||||
icon: sec.icon.clone().unwrap_or_default(),
|
||||
tabs,
|
||||
});
|
||||
}
|
||||
VisibleNav { sections }
|
||||
}
|
||||
|
||||
fn surface_names(set: &BTreeSet<Surface>) -> Vec<&'static str> {
|
||||
set.iter()
|
||||
.map(|s| match s {
|
||||
Surface::Panel => "panel",
|
||||
Surface::Web => "web",
|
||||
Surface::Flare => "flare",
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The `nav.json` document: every section and tab of the schema in rail
|
||||
/// order, unfiltered by viewer, with the surfaces each appears on.
|
||||
///
|
||||
/// Shape: `{"sections": [{"slug", "title", "icon", "band", "order",
|
||||
/// "surfaces", "tabs": [{"slug", "title", "page", "surfaces"}]}]}`.
|
||||
/// Flow tooling reads only `slug` and `title`; the browser route table also
|
||||
/// reads `page` and `surfaces`. A tab without a page is listed with
|
||||
/// `"page": null`.
|
||||
pub fn nav_json(menus: &[Menu]) -> Value {
|
||||
let mut grouped = group(menus);
|
||||
grouped.sort_by_key(|(s, _)| sort_key(s));
|
||||
let sections: Vec<Value> = grouped
|
||||
.into_iter()
|
||||
.map(|(sec, mut tabs)| {
|
||||
tabs.sort_by_key(|t| sort_key(t));
|
||||
let tabs: Vec<Value> = tabs
|
||||
.into_iter()
|
||||
.map(|t| {
|
||||
json!({
|
||||
"slug": t.slug,
|
||||
"title": t.title,
|
||||
"page": t.page,
|
||||
"surfaces": surface_names(&effective_surfaces(Some(t), sec)),
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
json!({
|
||||
"slug": sec.slug,
|
||||
"title": sec.title,
|
||||
"icon": sec.icon,
|
||||
"band": sec.band.unwrap_or(DEFAULT_BAND),
|
||||
"order": sec.order.unwrap_or(0),
|
||||
"surfaces": surface_names(&effective_surfaces(None, sec)),
|
||||
"tabs": tabs,
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
json!({ "sections": sections })
|
||||
}
|
||||
@@ -0,0 +1,143 @@
|
||||
//! Reading and block renderers (LD-06): live values from data to HTML.
|
||||
//!
|
||||
//! Readings carry `data-live` so the stale marker in `live.js` can grey them
|
||||
//! when the stream drops, and `data-key` so a push can find the element.
|
||||
//! Text is escaped by maud and every class is in the stylesheet allowlist.
|
||||
|
||||
use maud::{html, Markup};
|
||||
|
||||
/// Severity of a status reading.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Level {
|
||||
Ok,
|
||||
Warn,
|
||||
Err,
|
||||
}
|
||||
|
||||
impl Level {
|
||||
fn class(self) -> &'static str {
|
||||
match self {
|
||||
Level::Ok => "bf-badge bf-badge-ok",
|
||||
Level::Warn => "bf-badge bf-badge-warn",
|
||||
Level::Err => "bf-badge bf-badge-err",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// One live reading. `value` is `None` before the first sample.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Reading {
|
||||
pub key: String,
|
||||
pub label: String,
|
||||
pub value: Option<f64>,
|
||||
pub units: String,
|
||||
/// Decimal places shown.
|
||||
pub digits: usize,
|
||||
}
|
||||
|
||||
impl Reading {
|
||||
fn text(&self) -> String {
|
||||
match self.value {
|
||||
Some(v) if v.is_finite() => format!("{:.*}", self.digits, v),
|
||||
_ => "--".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Label and value row.
|
||||
pub fn kv(r: &Reading) -> Markup {
|
||||
html! {
|
||||
div class="bf-kv" data-live data-key=(r.key) {
|
||||
span class="bf-kv-label bf-text-label" { (r.label) }
|
||||
span class="bf-kv-value bf-text-body" { (r.text()) " " (r.units) }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Status badge with a text label (never colour alone).
|
||||
pub fn status(r: &Reading, level: Level, text: &str) -> Markup {
|
||||
html! {
|
||||
div class="bf-kv" data-live data-key=(r.key) {
|
||||
span class="bf-kv-label bf-text-label" { (r.label) }
|
||||
span class=(level.class()) { (text) }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Fraction of `v` within `lo..hi`, clamped to 0..=1 (0 when the span is empty).
|
||||
pub fn fraction(v: f64, lo: f64, hi: f64) -> f64 {
|
||||
if !v.is_finite() || hi <= lo {
|
||||
return 0.0;
|
||||
}
|
||||
((v - lo) / (hi - lo)).clamp(0.0, 1.0)
|
||||
}
|
||||
|
||||
/// Gauge or meter: a native `meter` element with the value as text beside it.
|
||||
pub fn gauge(r: &Reading, lo: f64, hi: f64) -> Markup {
|
||||
let pct = r.value.map(|v| fraction(v, lo, hi) * 100.0).unwrap_or(0.0);
|
||||
html! {
|
||||
div class="bf-gauge" data-live data-key=(r.key) {
|
||||
span class="bf-kv-label bf-text-label" { (r.label) }
|
||||
meter class="bf-gauge-bar" min=(lo) max=(hi) value=(r.value.unwrap_or(lo))
|
||||
aria-label=(r.label) { (format!("{pct:.0}%")) }
|
||||
span class="bf-kv-value bf-text-body" { (r.text()) " " (r.units) }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Large single value.
|
||||
pub fn hero(r: &Reading) -> Markup {
|
||||
html! {
|
||||
div class="bf-hero" data-live data-key=(r.key) {
|
||||
span class="bf-hero-value" { (r.text()) }
|
||||
span class="bf-hero-units bf-text-body" { (r.units) }
|
||||
span class="bf-kv-label bf-text-label" { (r.label) }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Table of rows; every cell is escaped text.
|
||||
pub fn table(head: &[&str], rows: &[Vec<String>]) -> Markup {
|
||||
html! {
|
||||
table class="bf-table" {
|
||||
thead { tr { @for h in head { th { (h) } } } }
|
||||
tbody { @for row in rows { tr { @for c in row { td { (c) } } } } }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Log lines, newest last.
|
||||
pub fn log(lines: &[String]) -> Markup {
|
||||
html! {
|
||||
ol class="bf-log" data-live {
|
||||
@for l in lines { li class="bf-text-body-sm" { (l) } }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Chart host: the canvas island draws into it from `data-key`.
|
||||
pub fn chart(key: &str, label: &str) -> Markup {
|
||||
html! {
|
||||
figure class="bf-chart" data-live data-island="chart" data-key=(key) {
|
||||
canvas class="bf-chart-canvas" role="img" aria-label=(label) {}
|
||||
figcaption class="bf-text-label" { (label) }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Plain note block.
|
||||
pub fn note(text: &str) -> Markup {
|
||||
html! { p class="bf-note bf-text-body" { (text) } }
|
||||
}
|
||||
|
||||
/// Nameplate: label and value pairs.
|
||||
pub fn plate(items: &[(String, String)]) -> Markup {
|
||||
html! {
|
||||
dl class="bf-plate" {
|
||||
@for (k, v) in items {
|
||||
dt class="bf-text-label" { (k) }
|
||||
dd class="bf-text-body" { (v) }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
+231
@@ -0,0 +1,231 @@
|
||||
//! Schema renderer (LD-06): settings from the wschema model to HTML.
|
||||
//!
|
||||
//! [`field`] renders one setting by its display type; [`card`] renders every
|
||||
//! setting of one section in `order`. [`validate_form`] runs a submitted
|
||||
//! batch through `wschema::validate_batch`, so the page shows the same
|
||||
//! failures the daemon would return. Secrets are write-only: no stored value
|
||||
//! is ever placed in the output. Text is escaped by maud, and every class is
|
||||
//! in the stylesheet allowlist.
|
||||
|
||||
use maud::{html, Markup};
|
||||
use serde_json::Value;
|
||||
use std::collections::BTreeMap;
|
||||
use wschema::model::{Kind, Setting, Surface};
|
||||
use wschema::{validate_batch, Ctx, Effective, Op, Origin, Rows};
|
||||
|
||||
/// What the page knows when it renders.
|
||||
pub struct View<'a> {
|
||||
pub eff: &'a Effective,
|
||||
/// Stored rows: concrete path to wire value.
|
||||
pub rows: &'a Rows,
|
||||
/// Failure message per path, from [`validate_form`].
|
||||
pub errors: &'a BTreeMap<String, String>,
|
||||
pub surface: Surface,
|
||||
/// False renders every control disabled.
|
||||
pub can_write: bool,
|
||||
}
|
||||
|
||||
/// One selectable value: wire value and label.
|
||||
struct Choice {
|
||||
v: String,
|
||||
label: String,
|
||||
}
|
||||
|
||||
fn choices(kind: &Kind, eff: &Effective) -> Vec<Choice> {
|
||||
match kind {
|
||||
Kind::Enum { values, vocab } => {
|
||||
let mut out: Vec<Choice> = values
|
||||
.iter()
|
||||
.map(|e| Choice {
|
||||
v: e.v.clone(),
|
||||
label: e.label.clone(),
|
||||
})
|
||||
.collect();
|
||||
if let Some(v) = vocab.as_deref().and_then(|id| eff.vocab(id)) {
|
||||
out.extend(v.values.iter().map(|e| Choice {
|
||||
v: e.v.clone(),
|
||||
label: e.label.clone(),
|
||||
}));
|
||||
}
|
||||
out
|
||||
}
|
||||
Kind::IntSet { values } => values
|
||||
.iter()
|
||||
.map(|e| Choice {
|
||||
v: e.v.to_string(),
|
||||
label: e.label.clone().unwrap_or_else(|| e.v.to_string()),
|
||||
})
|
||||
.collect(),
|
||||
_ => Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/// The value to show: stored row, else a static default.
|
||||
fn current<'a>(s: &'a Setting, rows: &'a Rows, path: &str) -> Option<&'a Value> {
|
||||
rows.get(path).or(s.default.value.as_ref())
|
||||
}
|
||||
|
||||
fn text_of(v: Option<&Value>) -> String {
|
||||
match v {
|
||||
Some(Value::String(x)) => x.clone(),
|
||||
Some(Value::Null) | None => String::new(),
|
||||
Some(other) => other.to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
fn list_text(v: Option<&Value>) -> String {
|
||||
match v {
|
||||
Some(Value::Array(a)) => a
|
||||
.iter()
|
||||
.map(|x| text_of(Some(x)))
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n"),
|
||||
_ => String::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn control(
|
||||
s: &Setting,
|
||||
path: &str,
|
||||
v: Option<&Value>,
|
||||
eff: &Effective,
|
||||
off: bool,
|
||||
description: Option<&str>,
|
||||
invalid: bool,
|
||||
) -> Markup {
|
||||
let cur = text_of(v);
|
||||
let ch = choices(&s.kind, eff);
|
||||
let (lo, hi, step) = match &s.kind {
|
||||
Kind::Int { lo, hi, step, .. } => (*lo, *hi, step.unwrap_or(1)),
|
||||
_ => (0, 0, 1),
|
||||
};
|
||||
match s.display.t.as_str() {
|
||||
"text" => html! {
|
||||
input class="bf-input" type="text" name=(path) value=(cur) disabled[off]
|
||||
aria-description=[description] aria-invalid=[invalid.then_some("true")];
|
||||
},
|
||||
"secret" => html! {
|
||||
input class="bf-input" type="password" name=(path) value=""
|
||||
placeholder="unchanged" autocomplete="new-password" disabled[off]
|
||||
aria-description=[description] aria-invalid=[invalid.then_some("true")];
|
||||
},
|
||||
"dropdown" => html! {
|
||||
select class="bf-input" name=(path) disabled[off]
|
||||
aria-description=[description] aria-invalid=[invalid.then_some("true")] {
|
||||
@for c in &ch { option value=(c.v) selected[c.v == cur] { (c.label) } }
|
||||
}
|
||||
},
|
||||
"segmented" | "swatch" => html! {
|
||||
div class="bf-segmented" role="radiogroup" aria-label=(s.label)
|
||||
aria-description=[description] aria-invalid=[invalid.then_some("true")] {
|
||||
@for c in &ch {
|
||||
label class="bf-segment" {
|
||||
input type="radio" name=(path) value=(c.v) checked[c.v == cur] disabled[off];
|
||||
span { (c.label) }
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"switch" => {
|
||||
let on = matches!(v, Some(Value::Bool(true)));
|
||||
html! {
|
||||
span class="bf-switch" {
|
||||
input type="checkbox" name=(path) value="true" checked[on] disabled[off]
|
||||
aria-description=[description] aria-invalid=[invalid.then_some("true")];
|
||||
span aria-hidden="true" { (if on { "On" } else { "Off" }) }
|
||||
}
|
||||
}
|
||||
}
|
||||
"slider" => html! {
|
||||
input class="bf-input" type="range" name=(path) value=(cur)
|
||||
min=(lo) max=(hi) step=(step) disabled[off]
|
||||
aria-description=[description] aria-invalid=[invalid.then_some("true")];
|
||||
},
|
||||
"stepper" | "number" => html! {
|
||||
input class="bf-input" type="number" name=(path) value=(cur)
|
||||
min=(lo) max=(hi) step=(step) disabled[off]
|
||||
aria-description=[description] aria-invalid=[invalid.then_some("true")];
|
||||
},
|
||||
"list" => html! {
|
||||
textarea class="bf-input" name=(path) rows="4" disabled[off]
|
||||
aria-description=[description] aria-invalid=[invalid.then_some("true")] { (list_text(v)) }
|
||||
},
|
||||
other => html! {
|
||||
p class="bf-field-help bf-text-body-sm" { "Unsupported display: " (other) }
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
/// Render one setting at the concrete `path` (equal to `s.path` unless the
|
||||
/// setting belongs to a map).
|
||||
pub fn field(s: &Setting, path: &str, view: &View<'_>) -> Markup {
|
||||
let v = current(s, view.rows, path);
|
||||
let off = !view.can_write || s.hidden == Some(true);
|
||||
let err = view.errors.get(path);
|
||||
let error_description = err.map(|error| match (s.help.is_empty(), error.is_empty()) {
|
||||
(true, _) => error.clone(),
|
||||
(_, true) => s.help.clone(),
|
||||
_ => format!("{} {error}", s.help),
|
||||
});
|
||||
let description = error_description.as_deref().unwrap_or(&s.help);
|
||||
let description = (!description.is_empty()).then_some(description);
|
||||
html! {
|
||||
div class="bf-field" data-path=(path) {
|
||||
@if matches!(s.display.t.as_str(), "text" | "secret" | "dropdown" | "switch" | "slider" | "stepper" | "number" | "list") {
|
||||
// Implicit labels also work when another form repeats the field.
|
||||
label {
|
||||
span class="bf-field-label bf-text-label" { (s.label) }
|
||||
(control(s, path, v, view.eff, off, description, err.is_some()))
|
||||
}
|
||||
} @else {
|
||||
span class="bf-field-label bf-text-label" { (s.label) }
|
||||
(control(s, path, v, view.eff, off, description, err.is_some()))
|
||||
}
|
||||
@if !s.help.is_empty() { p class="bf-field-help bf-text-body-sm" { (s.help) } }
|
||||
@if let Some(e) = err { p class="bf-field-error bf-text-body-sm" role="alert" { (e) } }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn on_surface(s: &Setting, surface: Surface) -> bool {
|
||||
s.surfaces.as_ref().is_none_or(|l| l.contains(&surface))
|
||||
}
|
||||
|
||||
/// Render every visible setting of `section`, ordered by `order` then path.
|
||||
pub fn card(title: &str, section: &str, view: &View<'_>) -> Markup {
|
||||
let mut list: Vec<&Setting> = view
|
||||
.eff
|
||||
.doc
|
||||
.settings
|
||||
.iter()
|
||||
.filter(|s| s.section == section && s.hidden != Some(true) && !s.path.contains('*'))
|
||||
.filter(|s| on_surface(s, view.surface))
|
||||
.collect();
|
||||
list.sort_by(|a, b| a.order.cmp(&b.order).then_with(|| a.path.cmp(&b.path)));
|
||||
crate::components::card(
|
||||
title,
|
||||
html! { @for s in list { (field(s, &s.path, view)) } },
|
||||
)
|
||||
}
|
||||
|
||||
/// Validate a submitted batch. Returns the failure message per path; an empty
|
||||
/// map means the batch is acceptable.
|
||||
pub fn validate_form(
|
||||
eff: &Effective,
|
||||
ops: &[Op],
|
||||
rows: &Rows,
|
||||
origin: Origin,
|
||||
perms: Option<&[String]>,
|
||||
) -> BTreeMap<String, String> {
|
||||
let ctx = Ctx {
|
||||
origin,
|
||||
perms,
|
||||
rows,
|
||||
usable_wifi_credentials: None,
|
||||
tls_state: None,
|
||||
};
|
||||
validate_batch(eff, ops, &ctx)
|
||||
.into_iter()
|
||||
.map(|f| (f.path, f.msg))
|
||||
.collect()
|
||||
}
|
||||
+331
@@ -0,0 +1,331 @@
|
||||
//! Request path resolution: path in, route or redirect out.
|
||||
//!
|
||||
//! The resolver knows the nav grammar only (d04 4.2, 4.3). Infrastructure
|
||||
//! routes (reserved words), and FLARE pages outside `/sites`, belong to
|
||||
//! their own handlers; the resolver reports them so the caller can dispatch.
|
||||
|
||||
use wschema::lint::RESERVED_ROUTE_WORDS;
|
||||
|
||||
use crate::nav::VisibleNav;
|
||||
use crate::url::Routes;
|
||||
|
||||
/// Which device a page belongs to.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub enum Scope {
|
||||
/// Warden console at the root.
|
||||
Console,
|
||||
/// A Warden under a FLARE site.
|
||||
Warden { site: u64, warden: String },
|
||||
/// The hub's backend device.
|
||||
Backend { site: u64 },
|
||||
}
|
||||
|
||||
impl Scope {
|
||||
pub fn routes(&self) -> Routes {
|
||||
match self {
|
||||
Scope::Console => Routes::console(),
|
||||
Scope::Warden { site, warden } => Routes::flare_warden(*site, warden),
|
||||
Scope::Backend { site } => Routes::flare_backend(*site),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// What follows `/{section}/{tab}`.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub enum Tail {
|
||||
Page,
|
||||
Action(String),
|
||||
ActionStatus(String),
|
||||
ActionConfirm(String),
|
||||
Entries(String),
|
||||
Events,
|
||||
Edit,
|
||||
ItemEdit(String),
|
||||
}
|
||||
|
||||
/// A resolved nav route.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct Target {
|
||||
pub scope: Scope,
|
||||
pub section: String,
|
||||
pub tab: String,
|
||||
pub tail: Tail,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub enum Resolved {
|
||||
/// Serve this route.
|
||||
Route(Target),
|
||||
/// 302 (first visible tab can change) or 308 (canonical form).
|
||||
Redirect {
|
||||
status: u16,
|
||||
location: String,
|
||||
},
|
||||
/// A site-level page FLARE owns: `Site`, `SiteSettings` or the d05 words.
|
||||
Site {
|
||||
site: u64,
|
||||
page: SitePage,
|
||||
},
|
||||
/// First segment is a reserved word: another handler owns it.
|
||||
Infrastructure(String),
|
||||
/// Not under `/sites`: a global FLARE page, routed by FLARE itself.
|
||||
Outside,
|
||||
NotFound,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub enum SitePage {
|
||||
Home,
|
||||
Settings,
|
||||
/// `wifi`: owned by d05; listed so the word stays reserved.
|
||||
Wifi,
|
||||
}
|
||||
|
||||
/// Supplies the visible nav of a scope and canonical warden segments.
|
||||
pub trait NavSource {
|
||||
/// Visible nav for the scope; `None` when the scope does not exist.
|
||||
fn nav(&self, scope: &Scope) -> Option<VisibleNav>;
|
||||
/// Canonical `{warden}` segment for the one given (hostname or UUID),
|
||||
/// `None` when unknown.
|
||||
fn canonical_warden(&self, site: u64, segment: &str) -> Option<String>;
|
||||
}
|
||||
|
||||
/// A fixed nav for the console (single device).
|
||||
pub struct ConsoleNav(pub VisibleNav);
|
||||
|
||||
impl NavSource for ConsoleNav {
|
||||
fn nav(&self, scope: &Scope) -> Option<VisibleNav> {
|
||||
matches!(scope, Scope::Console).then(|| self.0.clone())
|
||||
}
|
||||
|
||||
fn canonical_warden(&self, _site: u64, _segment: &str) -> Option<String> {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// True when `word` may not be a section slug.
|
||||
pub fn is_reserved(word: &str) -> bool {
|
||||
RESERVED_ROUTE_WORDS.contains(&word)
|
||||
}
|
||||
|
||||
/// The `#/` bookmark rule: `#/{section}[/{tab}]` becomes the path, anything
|
||||
/// else is left alone. Mirrors the five-line rule of `shell.js`.
|
||||
pub fn hash_redirect(hash: &str) -> Option<String> {
|
||||
let rest = hash.strip_prefix("#/")?;
|
||||
let ok = |seg: &str| {
|
||||
!seg.is_empty()
|
||||
&& seg
|
||||
.bytes()
|
||||
.all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b == b'-')
|
||||
};
|
||||
let mut parts = rest.split('/');
|
||||
let first = parts.next()?;
|
||||
let second = parts.next();
|
||||
if parts.next().is_some() || !ok(first) || second.is_some_and(|s| !ok(s)) {
|
||||
return None;
|
||||
}
|
||||
Some(format!("/{rest}"))
|
||||
}
|
||||
|
||||
fn redirect(status: u16, location: String) -> Resolved {
|
||||
Resolved::Redirect { status, location }
|
||||
}
|
||||
|
||||
/// Splits a path into non-empty segments; the flag says whether the path was
|
||||
/// not already in canonical shape (trailing or doubled slash).
|
||||
fn segments(path: &str) -> (Vec<&str>, bool) {
|
||||
let segs: Vec<&str> = path.split('/').filter(|s| !s.is_empty()).collect();
|
||||
let canonical = path == "/" || path == format!("/{}", segs.join("/"));
|
||||
(segs, !canonical)
|
||||
}
|
||||
|
||||
/// Resolves `path` (no query string) for the surface the source serves.
|
||||
/// `flare` selects the FLARE grammar (`/sites/...`); false is the console.
|
||||
pub fn resolve(path: &str, flare: bool, src: &dyn NavSource) -> Resolved {
|
||||
if !path.starts_with('/') {
|
||||
return Resolved::NotFound;
|
||||
}
|
||||
let (segs, uncanonical) = segments(path);
|
||||
if flare {
|
||||
resolve_flare(&segs, uncanonical, src)
|
||||
} else {
|
||||
resolve_nav(&Scope::Console, &segs, uncanonical, src)
|
||||
}
|
||||
}
|
||||
|
||||
fn join(prefix: &str, segs: &[String]) -> String {
|
||||
let tail = segs.join("/");
|
||||
if tail.is_empty() {
|
||||
if prefix.is_empty() {
|
||||
"/".to_string()
|
||||
} else {
|
||||
prefix.to_string()
|
||||
}
|
||||
} else {
|
||||
format!("{prefix}/{tail}")
|
||||
}
|
||||
}
|
||||
|
||||
fn resolve_flare(segs: &[&str], uncanonical: bool, src: &dyn NavSource) -> Resolved {
|
||||
if segs.first() != Some(&"sites") {
|
||||
return Resolved::Outside;
|
||||
}
|
||||
let Some(site) = segs.get(1).and_then(|s| parse_site(s)) else {
|
||||
return Resolved::NotFound;
|
||||
};
|
||||
let canon_site = format!("/sites/{site}");
|
||||
// A non-canonical site number ("007") redirects too.
|
||||
let site_changed = segs[1] != site.to_string();
|
||||
let redirect_to = |rest: &[String]| redirect(308, join(&canon_site, rest));
|
||||
match segs.get(2).copied() {
|
||||
None => {
|
||||
if uncanonical || site_changed {
|
||||
redirect_to(&[])
|
||||
} else {
|
||||
Resolved::Site {
|
||||
site,
|
||||
page: SitePage::Home,
|
||||
}
|
||||
}
|
||||
}
|
||||
Some("settings") if segs.len() == 3 => {
|
||||
if uncanonical || site_changed {
|
||||
redirect_to(&["settings".to_string()])
|
||||
} else {
|
||||
Resolved::Site {
|
||||
site,
|
||||
page: SitePage::Settings,
|
||||
}
|
||||
}
|
||||
}
|
||||
Some("wifi") if segs.len() == 3 => Resolved::Site {
|
||||
site,
|
||||
page: SitePage::Wifi,
|
||||
},
|
||||
Some("backend") => {
|
||||
let scope = Scope::Backend { site };
|
||||
let prefix = format!("{canon_site}/backend");
|
||||
resolve_nav_under(
|
||||
&scope,
|
||||
&prefix,
|
||||
&segs[3..],
|
||||
uncanonical || site_changed,
|
||||
src,
|
||||
)
|
||||
}
|
||||
Some("wardens") => {
|
||||
let Some(raw) = segs.get(3) else {
|
||||
return Resolved::NotFound;
|
||||
};
|
||||
let Some(canon) = src.canonical_warden(site, raw) else {
|
||||
return Resolved::NotFound;
|
||||
};
|
||||
let warden_changed = canon != *raw;
|
||||
let scope = Scope::Warden {
|
||||
site,
|
||||
warden: canon.clone(),
|
||||
};
|
||||
let prefix = scope.routes().prefix().to_string();
|
||||
resolve_nav_under(
|
||||
&scope,
|
||||
&prefix,
|
||||
&segs[4..],
|
||||
uncanonical || site_changed || warden_changed,
|
||||
src,
|
||||
)
|
||||
}
|
||||
// /sites/{site}/{section}: dropped, a Warden page is never here.
|
||||
Some(_) => Resolved::NotFound,
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_site(s: &str) -> Option<u64> {
|
||||
(!s.is_empty() && s.bytes().all(|b| b.is_ascii_digit()))
|
||||
.then(|| s.parse().ok())
|
||||
.flatten()
|
||||
}
|
||||
|
||||
fn resolve_nav(scope: &Scope, segs: &[&str], uncanonical: bool, src: &dyn NavSource) -> Resolved {
|
||||
if let Some(first) = segs.first() {
|
||||
let lower = first.to_ascii_lowercase();
|
||||
if is_reserved(&lower) {
|
||||
return Resolved::Infrastructure(lower);
|
||||
}
|
||||
}
|
||||
resolve_nav_under(scope, "", segs, uncanonical, src)
|
||||
}
|
||||
|
||||
/// Resolves the segments after the scope prefix. `changed` carries any
|
||||
/// canonicalisation already needed above this point.
|
||||
fn resolve_nav_under(
|
||||
scope: &Scope,
|
||||
prefix: &str,
|
||||
segs: &[&str],
|
||||
changed: bool,
|
||||
src: &dyn NavSource,
|
||||
) -> Resolved {
|
||||
let Some(nav) = src.nav(scope) else {
|
||||
return Resolved::NotFound;
|
||||
};
|
||||
if segs.is_empty() {
|
||||
// Scope home: first visible tab.
|
||||
return match nav.first_tab() {
|
||||
Some((s, t)) => redirect(302, scope.routes().page(s, t)),
|
||||
None => Resolved::NotFound,
|
||||
};
|
||||
}
|
||||
// Section and tab slugs are lower case; fold them, the rest keeps case.
|
||||
let mut canon: Vec<String> = Vec::with_capacity(segs.len());
|
||||
let mut fold = changed;
|
||||
for (i, s) in segs.iter().enumerate() {
|
||||
if i < 2 && *s != s.to_ascii_lowercase() {
|
||||
fold = true;
|
||||
canon.push(s.to_ascii_lowercase());
|
||||
} else {
|
||||
canon.push(s.to_string());
|
||||
}
|
||||
}
|
||||
let section_slug = &canon[0];
|
||||
let Some(section) = nav.section(section_slug) else {
|
||||
return Resolved::NotFound;
|
||||
};
|
||||
let Some(tab_slug) = canon.get(1) else {
|
||||
// /{section}: 302 to the first visible tab; a canonicalisation
|
||||
// redirect would only add a hop.
|
||||
return match section.tabs.first() {
|
||||
Some(t) => redirect(302, scope.routes().page(§ion.slug, &t.slug)),
|
||||
None => Resolved::NotFound,
|
||||
};
|
||||
};
|
||||
if !section.tabs.iter().any(|t| &t.slug == tab_slug) {
|
||||
return Resolved::NotFound;
|
||||
}
|
||||
let tail = match parse_tail(&canon[2..]) {
|
||||
Some(t) => t,
|
||||
None => return Resolved::NotFound,
|
||||
};
|
||||
if fold {
|
||||
return redirect(308, join(prefix, &canon));
|
||||
}
|
||||
Resolved::Route(Target {
|
||||
scope: scope.clone(),
|
||||
section: section_slug.clone(),
|
||||
tab: tab_slug.clone(),
|
||||
tail,
|
||||
})
|
||||
}
|
||||
|
||||
fn parse_tail(rest: &[String]) -> Option<Tail> {
|
||||
let r: Vec<&str> = rest.iter().map(String::as_str).collect();
|
||||
Some(match r.as_slice() {
|
||||
[] => Tail::Page,
|
||||
["events"] => Tail::Events,
|
||||
["edit"] => Tail::Edit,
|
||||
["actions", name] => Tail::Action((*name).to_string()),
|
||||
["actions", name, "status"] => Tail::ActionStatus((*name).to_string()),
|
||||
["actions", name, "confirm"] => Tail::ActionConfirm((*name).to_string()),
|
||||
["entries", map] => Tail::Entries((*map).to_string()),
|
||||
[id, "edit"] => Tail::ItemEdit((*id).to_string()),
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
+219
@@ -0,0 +1,219 @@
|
||||
//! Page shell (UI-4): sidebar of visible sections, tab strip, main area.
|
||||
//!
|
||||
//! The shell renders a [`VisibleNav`] already filtered for the viewer; it does
|
||||
//! no permission logic of its own. Active section and tab are marked with
|
||||
//! `aria-current="page"` and the `bf-nav-active` class.
|
||||
|
||||
use maud::{html, Markup, DOCTYPE};
|
||||
|
||||
use crate::assets::PageAssets;
|
||||
use crate::nav::VisibleNav;
|
||||
|
||||
/// The section and tab being shown, by slug.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub struct Active<'a> {
|
||||
pub section: &'a str,
|
||||
pub tab: &'a str,
|
||||
}
|
||||
|
||||
fn link_class(active: bool) -> &'static str {
|
||||
if active {
|
||||
"bf-nav-link bf-text-body bf-nav-active"
|
||||
} else {
|
||||
"bf-nav-link bf-text-body"
|
||||
}
|
||||
}
|
||||
|
||||
/// The sidebar: one block per visible section, linking its first tab.
|
||||
pub fn sidebar(nav: &VisibleNav, active: Active) -> Markup {
|
||||
html! {
|
||||
nav class="bf-sidebar" aria-label="Sections" {
|
||||
@for s in &nav.sections {
|
||||
@let here = s.slug == active.section;
|
||||
@if let Some(first) = s.tabs.first() {
|
||||
div class="bf-nav-section" {
|
||||
a class=(link_class(here)) href=(first.href)
|
||||
aria-current=[here.then_some("page")] { (s.title) }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The tab strip of the active section; empty markup when it has one tab or
|
||||
/// the section is not visible.
|
||||
pub fn tab_strip(nav: &VisibleNav, active: Active) -> Markup {
|
||||
let Some(sec) = nav.section(active.section) else {
|
||||
return html! {};
|
||||
};
|
||||
if sec.tabs.len() < 2 {
|
||||
return html! {};
|
||||
}
|
||||
html! {
|
||||
div class="bf-tabs" role="navigation" aria-label="Tabs" {
|
||||
@for t in &sec.tabs {
|
||||
@let here = t.slug == active.tab;
|
||||
a class=(link_class(here)) href=(t.href)
|
||||
aria-current=[here.then_some("page")] { (t.title) }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A full HTML document around `body`.
|
||||
pub fn page(
|
||||
title: &str,
|
||||
assets: &PageAssets,
|
||||
nav: &VisibleNav,
|
||||
active: Active,
|
||||
body: Markup,
|
||||
) -> Markup {
|
||||
html! {
|
||||
(DOCTYPE)
|
||||
html lang="en" {
|
||||
head {
|
||||
meta charset="utf-8";
|
||||
meta name="viewport" content="width=device-width, initial-scale=1";
|
||||
title { (title) }
|
||||
(assets.head())
|
||||
}
|
||||
body {
|
||||
div class="bf-shell" {
|
||||
(sidebar(nav, active))
|
||||
main class="bf-main" {
|
||||
(tab_strip(nav, active))
|
||||
(body)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::nav::{VisibleSection, VisibleTab};
|
||||
use crate::tokens::class_allowed;
|
||||
|
||||
fn tab(slug: &str) -> VisibleTab {
|
||||
VisibleTab {
|
||||
slug: slug.into(),
|
||||
title: slug.to_uppercase(),
|
||||
page: "p".into(),
|
||||
href: format!("/s/{slug}"),
|
||||
}
|
||||
}
|
||||
|
||||
fn nav() -> VisibleNav {
|
||||
VisibleNav {
|
||||
sections: vec![
|
||||
VisibleSection {
|
||||
slug: "a".into(),
|
||||
title: "Alpha <x>".into(),
|
||||
icon: "i".into(),
|
||||
tabs: vec![tab("t1"), tab("t2")],
|
||||
},
|
||||
VisibleSection {
|
||||
slug: "b".into(),
|
||||
title: "Beta".into(),
|
||||
icon: "i".into(),
|
||||
tabs: vec![tab("t3")],
|
||||
},
|
||||
VisibleSection {
|
||||
slug: "empty".into(),
|
||||
title: "Empty".into(),
|
||||
icon: "i".into(),
|
||||
tabs: vec![],
|
||||
},
|
||||
],
|
||||
}
|
||||
}
|
||||
|
||||
fn classes(html: &str) -> Vec<String> {
|
||||
let mut out = Vec::new();
|
||||
let mut rest = html;
|
||||
while let Some(i) = rest.find("class=\"") {
|
||||
rest = &rest[i + 7..];
|
||||
let end = rest.find('"').unwrap();
|
||||
out.extend(rest[..end].split_whitespace().map(String::from));
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn marks_active_and_escapes() {
|
||||
let s = sidebar(
|
||||
&nav(),
|
||||
Active {
|
||||
section: "a",
|
||||
tab: "t1",
|
||||
},
|
||||
)
|
||||
.into_string();
|
||||
assert!(s.contains("aria-current=\"page\""));
|
||||
assert_eq!(s.matches("aria-current").count(), 1);
|
||||
assert!(s.contains("Alpha <x>"));
|
||||
assert!(!s.contains("Empty"), "sections without tabs are skipped");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tab_strip_only_for_multi_tab_sections() {
|
||||
let a = Active {
|
||||
section: "a",
|
||||
tab: "t2",
|
||||
};
|
||||
let s = tab_strip(&nav(), a).into_string();
|
||||
assert!(s.contains("href=\"/s/t1\"") && s.contains("href=\"/s/t2\""));
|
||||
assert_eq!(s.matches("aria-current").count(), 1);
|
||||
assert_eq!(
|
||||
tab_strip(
|
||||
&nav(),
|
||||
Active {
|
||||
section: "b",
|
||||
tab: "t3"
|
||||
}
|
||||
)
|
||||
.into_string(),
|
||||
""
|
||||
);
|
||||
assert_eq!(
|
||||
tab_strip(
|
||||
&nav(),
|
||||
Active {
|
||||
section: "zz",
|
||||
tab: "t"
|
||||
}
|
||||
)
|
||||
.into_string(),
|
||||
""
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn page_is_complete_and_classes_allowed() {
|
||||
let assets = PageAssets {
|
||||
styles: vec!["/s.css".into()],
|
||||
scripts: vec!["/live.js".into()],
|
||||
streams: vec![],
|
||||
};
|
||||
let s = page(
|
||||
"T",
|
||||
&assets,
|
||||
&nav(),
|
||||
Active {
|
||||
section: "a",
|
||||
tab: "t1",
|
||||
},
|
||||
html! { p { "hi" } },
|
||||
)
|
||||
.into_string();
|
||||
assert!(s.starts_with("<!DOCTYPE html>"));
|
||||
assert!(s.contains("<title>T</title>") && s.contains("href=\"/s.css\""));
|
||||
assert!(s.contains("<p>hi</p>"));
|
||||
for c in classes(&s) {
|
||||
assert!(class_allowed(&c), "class {c} not allowed");
|
||||
}
|
||||
}
|
||||
}
|
||||
+113
@@ -0,0 +1,113 @@
|
||||
//! Dash studio assets (LD-07, flare-ui side).
|
||||
//!
|
||||
//! The dashboard editor lives under `dash-editor/editor/`. This module embeds
|
||||
//! its files so a consumer serves them from one table instead of vendoring a
|
||||
//! copy: [`asset`] maps a request name to a content type and body, and
|
||||
//! [`STUDIO_FRAGMENT`] is the page body the studio script mounts into.
|
||||
|
||||
/// The studio page fragment (no `<html>` wrapper; the shell supplies it).
|
||||
pub const STUDIO_FRAGMENT: &str = include_str!("../../../dash-editor/editor/dashboard_studio.html");
|
||||
|
||||
/// One embedded studio file.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub struct StudioAsset {
|
||||
/// File name under the studio mount, with no directory part.
|
||||
pub name: &'static str,
|
||||
/// Media type to serve it with.
|
||||
pub content_type: &'static str,
|
||||
/// File body, byte for byte.
|
||||
pub body: &'static str,
|
||||
}
|
||||
|
||||
macro_rules! js {
|
||||
($n:literal) => {
|
||||
StudioAsset {
|
||||
name: $n,
|
||||
content_type: "text/javascript; charset=utf-8",
|
||||
body: include_str!(concat!("../../../dash-editor/editor/", $n)),
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/// Every studio file served to the browser, in load order.
|
||||
pub const ASSETS: &[StudioAsset] = &[
|
||||
js!("dashboard-json.js"),
|
||||
js!("dashboard-doc.js"),
|
||||
js!("dashboard-file.js"),
|
||||
js!("dashboard-sources.js"),
|
||||
js!("dashboard-raw.js"),
|
||||
js!("dashboard-list.js"),
|
||||
js!("dashboard-drag.js"),
|
||||
js!("dashboard-editor.js"),
|
||||
js!("dashboard-inspector.js"),
|
||||
StudioAsset {
|
||||
name: "studio.css",
|
||||
content_type: "text/css; charset=utf-8",
|
||||
body: include_str!("../../../dash-editor/editor/studio.css"),
|
||||
},
|
||||
];
|
||||
|
||||
/// Look up a studio file by request name. Names with a path separator or a
|
||||
/// dot-dot never match.
|
||||
pub fn asset(name: &str) -> Option<&'static StudioAsset> {
|
||||
if name.contains('/') || name.contains('\\') || name.contains("..") {
|
||||
return None;
|
||||
}
|
||||
ASSETS.iter().find(|a| a.name == name)
|
||||
}
|
||||
|
||||
/// Script names in load order, for [`crate::assets::PageAssets::scripts`].
|
||||
pub fn script_names() -> impl Iterator<Item = &'static str> {
|
||||
ASSETS
|
||||
.iter()
|
||||
.filter(|a| a.name.ends_with(".js"))
|
||||
.map(|a| a.name)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::path::Path;
|
||||
|
||||
#[test]
|
||||
fn every_editor_file_is_embedded() {
|
||||
let dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../dash-editor/editor");
|
||||
for e in std::fs::read_dir(dir).unwrap() {
|
||||
let name = e.unwrap().file_name().into_string().unwrap();
|
||||
if name == "dashboard_studio.html" {
|
||||
continue;
|
||||
}
|
||||
assert!(asset(&name).is_some(), "{name} not embedded");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bodies_are_ascii_and_nonempty() {
|
||||
for a in ASSETS {
|
||||
assert!(a.body.is_ascii() && !a.body.is_empty(), "{}", a.name);
|
||||
}
|
||||
assert!(STUDIO_FRAGMENT.is_ascii());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lookup_rejects_traversal() {
|
||||
assert!(asset("studio.css").is_some());
|
||||
assert!(asset("../studio.css").is_none());
|
||||
assert!(asset("a/studio.css").is_none());
|
||||
assert!(asset("missing.js").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn content_types_match_extension() {
|
||||
for a in ASSETS {
|
||||
let js = a.name.ends_with(".js");
|
||||
assert_eq!(
|
||||
a.content_type.starts_with("text/javascript"),
|
||||
js,
|
||||
"{}",
|
||||
a.name
|
||||
);
|
||||
}
|
||||
assert_eq!(script_names().count(), ASSETS.len() - 1);
|
||||
}
|
||||
}
|
||||
+199
@@ -0,0 +1,199 @@
|
||||
//! Design tokens and the CSS class allowlist (UI-4).
|
||||
//!
|
||||
//! `assets/tokens.css` is the single source of design tokens for FLARE and
|
||||
//! the Warden console. [`TOKENS_CSS`] embeds it; [`token_names`] and
|
||||
//! [`class_names`] list what it defines; [`class_allowed`] is the allowlist
|
||||
//! the renderer checks every emitted `class` against.
|
||||
|
||||
/// The token stylesheet, byte for byte.
|
||||
pub const TOKENS_CSS: &str = include_str!("../assets/tokens.css");
|
||||
|
||||
/// The component stylesheet, byte for byte. Uses only tokens from [`TOKENS_CSS`].
|
||||
pub const COMPONENTS_CSS: &str = include_str!("../assets/components.css");
|
||||
|
||||
/// The shared app theme (`--app-*` aliases, dark default, light variants), byte for byte.
|
||||
pub const THEME_CSS: &str = include_str!("../assets/theme.css");
|
||||
|
||||
/// Maps the legacy Warden console property names onto the shared theme.
|
||||
pub const WARDEN_COMPAT_CSS: &str = include_str!("../assets/warden-compat.css");
|
||||
|
||||
/// Prefix every token and shared class carries.
|
||||
pub const PREFIX: &str = "bf-";
|
||||
|
||||
/// Custom property names defined in `:root` (for example `--bf-space-4`), sorted.
|
||||
pub fn token_names() -> Vec<String> {
|
||||
let mut out: Vec<String> = Vec::new();
|
||||
for line in TOKENS_CSS.lines() {
|
||||
let t = line.trim_start();
|
||||
if let Some(rest) = t.strip_prefix("--") {
|
||||
if let Some((name, _)) = rest.split_once(':') {
|
||||
out.push(format!("--{}", name.trim()));
|
||||
}
|
||||
}
|
||||
}
|
||||
out.sort();
|
||||
out.dedup();
|
||||
out
|
||||
}
|
||||
|
||||
/// Class names defined by the stylesheet (without the dot), sorted.
|
||||
pub fn class_names() -> Vec<String> {
|
||||
let mut out: Vec<String> = Vec::new();
|
||||
for line in TOKENS_CSS.lines().chain(COMPONENTS_CSS.lines()) {
|
||||
let Some(rest) = line.strip_prefix('.') else {
|
||||
continue;
|
||||
};
|
||||
let end = rest
|
||||
.find(|c: char| !(c.is_ascii_alphanumeric() || c == '-' || c == '_'))
|
||||
.unwrap_or(rest.len());
|
||||
if end > 0 {
|
||||
out.push(rest[..end].to_string());
|
||||
}
|
||||
}
|
||||
out.sort();
|
||||
out.dedup();
|
||||
out
|
||||
}
|
||||
|
||||
/// True when `class` may appear in rendered output: a single token with only
|
||||
/// `[a-z0-9_-]` that the stylesheet defines.
|
||||
pub fn class_allowed(class: &str) -> bool {
|
||||
class_names().iter().any(|c| c == class)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn tokens_are_ascii_and_prefixed() {
|
||||
assert!(TOKENS_CSS.is_ascii());
|
||||
let names = token_names();
|
||||
assert!(names.len() > 100);
|
||||
assert!(names.iter().all(|n| n.starts_with("--bf-")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_var_reference_resolves() {
|
||||
let names = token_names();
|
||||
let all = format!("{TOKENS_CSS}\n{COMPONENTS_CSS}");
|
||||
let mut rest = all.as_str();
|
||||
while let Some(i) = rest.find("var(") {
|
||||
rest = &rest[i + 4..];
|
||||
let end = rest.find(')').unwrap();
|
||||
let name = rest[..end].trim();
|
||||
assert!(names.iter().any(|n| n == name), "unresolved {name}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn allowlist_matches_stylesheet() {
|
||||
assert!(class_allowed("bf-text-body"));
|
||||
assert!(!class_allowed("bf-text-bodyx"));
|
||||
assert!(!class_allowed("evil"));
|
||||
assert!(!class_allowed(""));
|
||||
assert!(class_names().iter().all(|c| c.starts_with(PREFIX)));
|
||||
}
|
||||
|
||||
fn defined(css: &str) -> Vec<String> {
|
||||
css.lines()
|
||||
.flat_map(|l| l.split(';'))
|
||||
.filter_map(|d| {
|
||||
let d = d.trim_start().trim_start_matches('{').trim_start();
|
||||
let rest = d.strip_prefix("--")?;
|
||||
let (name, _) = rest.split_once(':')?;
|
||||
Some(format!("--{}", name.trim()))
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn used(css: &str) -> Vec<String> {
|
||||
let mut out = Vec::new();
|
||||
let mut rest = css;
|
||||
while let Some(i) = rest.find("var(") {
|
||||
rest = &rest[i + 4..];
|
||||
let end = rest.find(')').unwrap();
|
||||
out.push(rest[..end].trim().to_string());
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn theme_references_resolve() {
|
||||
let mut known = defined(TOKENS_CSS);
|
||||
known.extend(defined(THEME_CSS));
|
||||
known.extend(defined(WARDEN_COMPAT_CSS));
|
||||
for css in [THEME_CSS, WARDEN_COMPAT_CSS] {
|
||||
assert!(css.is_ascii());
|
||||
for name in used(css) {
|
||||
assert!(known.contains(&name), "unresolved {name}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn theme_variants_define_the_same_names() {
|
||||
// Dark root block, light data-theme block and the system-preference block.
|
||||
let sets: Vec<Vec<String>> = THEME_CSS
|
||||
.split('}')
|
||||
.map(|b| {
|
||||
let mut d: Vec<String> = defined(b)
|
||||
.into_iter()
|
||||
.filter(|n| n.starts_with("--app-"))
|
||||
.collect();
|
||||
d.sort();
|
||||
d.dedup();
|
||||
d
|
||||
})
|
||||
.filter(|d| !d.is_empty())
|
||||
.collect();
|
||||
assert_eq!(sets.len(), 3, "dark, light, system light");
|
||||
assert_eq!(sets[0], sets[1]);
|
||||
assert_eq!(sets[0], sets[2]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn warden_names_are_all_mapped() {
|
||||
// Custom properties the console stylesheet reads (checked against app.css).
|
||||
let legacy = [
|
||||
"--radius",
|
||||
"--sp-1",
|
||||
"--sp-2",
|
||||
"--sp-3",
|
||||
"--sp-4",
|
||||
"--sp-6",
|
||||
"--sp-8",
|
||||
"--hair",
|
||||
"--font-display",
|
||||
"--font-body",
|
||||
"--bg",
|
||||
"--surface",
|
||||
"--surface-alt",
|
||||
"--border",
|
||||
"--text",
|
||||
"--text-muted",
|
||||
"--accent",
|
||||
"--accent-ink",
|
||||
"--accent-soft",
|
||||
"--flame",
|
||||
"--ok",
|
||||
"--warn",
|
||||
"--crit",
|
||||
"--dot-ok",
|
||||
"--dot-warn",
|
||||
"--dot-crit",
|
||||
"--dot-new",
|
||||
"--dot-off",
|
||||
"--focus",
|
||||
"--scrim",
|
||||
"--chip-dark",
|
||||
"--rail-w",
|
||||
"--rail-narrow",
|
||||
"--sidebar-w",
|
||||
];
|
||||
let got = defined(WARDEN_COMPAT_CSS);
|
||||
for n in legacy {
|
||||
assert!(got.iter().any(|g| g == n), "unmapped {n}");
|
||||
}
|
||||
}
|
||||
}
|
||||
+153
@@ -0,0 +1,153 @@
|
||||
//! URL builders. Every URL derives from the nav model (d04 4.1): one canonical
|
||||
//! form per page, `/{section}/{tab}`, under a prefix that is empty on the
|
||||
//! Warden console and a device path in FLARE.
|
||||
|
||||
/// Query parameters every page shares (names.md 18).
|
||||
pub const QUERY_KEYS: &[&str] = &[
|
||||
"sort", "dir", "page", "per", "q", "tier", "src", "range", "app",
|
||||
];
|
||||
/// Stream resume position on `.../events`.
|
||||
pub const KEY_SEQ: &str = "seq";
|
||||
/// `mode=poll`, the one-batch fallback of `.../events`.
|
||||
pub const KEY_MODE: &str = "mode";
|
||||
/// Terminal ticket on `/term`.
|
||||
pub const KEY_TICKET: &str = "t";
|
||||
|
||||
/// Percent-encodes one path segment or query component (RFC 3986 unreserved
|
||||
/// characters pass through).
|
||||
pub fn encode(s: &str) -> String {
|
||||
let mut out = String::with_capacity(s.len());
|
||||
for b in s.bytes() {
|
||||
if b.is_ascii_alphanumeric() || matches!(b, b'-' | b'.' | b'_' | b'~') {
|
||||
out.push(b as char);
|
||||
} else {
|
||||
out.push_str(&format!("%{b:02X}"));
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Route prefix of one surface scope.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct Routes {
|
||||
prefix: String,
|
||||
}
|
||||
|
||||
impl Routes {
|
||||
/// The Warden console: routes at the root.
|
||||
pub fn console() -> Self {
|
||||
Routes {
|
||||
prefix: String::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/// A Warden under a FLARE site: `/sites/{site}/wardens/{warden}`.
|
||||
pub fn flare_warden(site: u64, warden: &str) -> Self {
|
||||
Routes {
|
||||
prefix: format!("/sites/{site}/wardens/{}", encode(warden)),
|
||||
}
|
||||
}
|
||||
|
||||
/// The hub's backend device: `/sites/{site}/backend`.
|
||||
pub fn flare_backend(site: u64) -> Self {
|
||||
Routes {
|
||||
prefix: format!("/sites/{site}/backend"),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn prefix(&self) -> &str {
|
||||
&self.prefix
|
||||
}
|
||||
|
||||
/// Home of the scope: the root or the Warden path (redirects to the first
|
||||
/// visible tab).
|
||||
pub fn home(&self) -> String {
|
||||
if self.prefix.is_empty() {
|
||||
"/".to_string()
|
||||
} else {
|
||||
self.prefix.clone()
|
||||
}
|
||||
}
|
||||
|
||||
pub fn section(&self, section: &str) -> String {
|
||||
format!("{}/{}", self.prefix, encode(section))
|
||||
}
|
||||
|
||||
/// The canonical page URL.
|
||||
pub fn page(&self, section: &str, tab: &str) -> String {
|
||||
format!("{}/{}", self.section(section), encode(tab))
|
||||
}
|
||||
|
||||
pub fn action(&self, section: &str, tab: &str, name: &str) -> String {
|
||||
format!("{}/actions/{}", self.page(section, tab), encode(name))
|
||||
}
|
||||
|
||||
pub fn action_status(&self, section: &str, tab: &str, name: &str) -> String {
|
||||
format!("{}/status", self.action(section, tab, name))
|
||||
}
|
||||
|
||||
pub fn action_confirm(&self, section: &str, tab: &str, name: &str) -> String {
|
||||
format!("{}/confirm", self.action(section, tab, name))
|
||||
}
|
||||
|
||||
pub fn entries(&self, section: &str, tab: &str, map: &str) -> String {
|
||||
format!("{}/entries/{}", self.page(section, tab), encode(map))
|
||||
}
|
||||
|
||||
pub fn events(&self, section: &str, tab: &str) -> String {
|
||||
format!("{}/events", self.page(section, tab))
|
||||
}
|
||||
|
||||
/// The page's own island editor.
|
||||
pub fn edit(&self, section: &str, tab: &str) -> String {
|
||||
format!("{}/edit", self.page(section, tab))
|
||||
}
|
||||
|
||||
/// An item editor such as the later flow builder.
|
||||
pub fn item_edit(&self, section: &str, tab: &str, id: &str) -> String {
|
||||
format!("{}/{}/edit", self.page(section, tab), encode(id))
|
||||
}
|
||||
}
|
||||
|
||||
/// FLARE site home.
|
||||
pub fn flare_site(site: u64) -> String {
|
||||
format!("/sites/{site}")
|
||||
}
|
||||
|
||||
/// FLARE site settings (FLARE-owned).
|
||||
pub fn flare_site_settings(site: u64) -> String {
|
||||
format!("/sites/{site}/settings")
|
||||
}
|
||||
|
||||
/// Appends a query string built from `pairs` to `path`. Only the closed
|
||||
/// parameter set of [`QUERY_KEYS`] and the `extra` keys the route allows pass;
|
||||
/// unknown keys are dropped, as are values outside their domain (`dir` other
|
||||
/// than asc or desc, `tier` other than min, hour or day, `per` outside
|
||||
/// 10 to 200, `mode` other than poll). Order follows `pairs`.
|
||||
pub fn with_query<'a, I>(path: &str, pairs: I, extra: &[&str]) -> String
|
||||
where
|
||||
I: IntoIterator<Item = (&'a str, &'a str)>,
|
||||
{
|
||||
let kept: Vec<String> = pairs
|
||||
.into_iter()
|
||||
.filter(|(k, _)| QUERY_KEYS.contains(k) || extra.contains(k))
|
||||
.filter(|(k, v)| value_ok(k, v))
|
||||
.map(|(k, v)| format!("{}={}", encode(k), encode(v)))
|
||||
.collect();
|
||||
if kept.is_empty() {
|
||||
path.to_string()
|
||||
} else {
|
||||
format!("{path}?{}", kept.join("&"))
|
||||
}
|
||||
}
|
||||
|
||||
fn value_ok(key: &str, value: &str) -> bool {
|
||||
match key {
|
||||
"dir" => matches!(value, "asc" | "desc"),
|
||||
"tier" => matches!(value, "min" | "hour" | "day"),
|
||||
"per" => value.parse::<u32>().is_ok_and(|n| (10..=200).contains(&n)),
|
||||
"page" | KEY_SEQ => value.parse::<u64>().is_ok(),
|
||||
KEY_MODE => value == "poll",
|
||||
_ => true,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,112 @@
|
||||
//! Action and approval tests: target safety, escaping, allowlist, goldens.
|
||||
//! Refresh goldens with `UPDATE_GOLDEN=1 cargo test -p flare-ui --test actions`.
|
||||
|
||||
use flare_ui::actions::*;
|
||||
use flare_ui::tokens::class_allowed;
|
||||
|
||||
fn ap(id: &str) -> Approval {
|
||||
Approval {
|
||||
id: id.into(),
|
||||
summary: "Open <valve> 3".into(),
|
||||
requested_by: "ann".into(),
|
||||
}
|
||||
}
|
||||
|
||||
fn cases() -> Vec<(&'static str, String)> {
|
||||
vec![
|
||||
(
|
||||
"button",
|
||||
action_button("/a/b", "Run", Tone::Primary, "tok", None)
|
||||
.unwrap()
|
||||
.into_string(),
|
||||
),
|
||||
(
|
||||
"button_confirm",
|
||||
action_button("/a/b", "Stop", Tone::Danger, "tok", Some("Sure?"))
|
||||
.unwrap()
|
||||
.into_string(),
|
||||
),
|
||||
(
|
||||
"approvals",
|
||||
approvals("/approvals", &[ap("a1")], "tok").into_string(),
|
||||
),
|
||||
(
|
||||
"approvals_empty",
|
||||
approvals("/approvals", &[], "tok").into_string(),
|
||||
),
|
||||
]
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn golden_per_block() {
|
||||
for (name, got) in cases() {
|
||||
let p = format!(
|
||||
"{}/tests/golden/actions/{name}.html",
|
||||
env!("CARGO_MANIFEST_DIR")
|
||||
);
|
||||
if std::env::var("UPDATE_GOLDEN").is_ok() {
|
||||
std::fs::create_dir_all(std::path::Path::new(&p).parent().unwrap()).unwrap();
|
||||
std::fs::write(&p, format!("{got}\n")).unwrap();
|
||||
continue;
|
||||
}
|
||||
let want = std::fs::read_to_string(&p).unwrap_or_else(|_| panic!("missing golden {p}"));
|
||||
assert_eq!(want.trim_end(), got, "golden {name} differs");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unsafe_targets_render_nothing() {
|
||||
for t in [
|
||||
"//evil.example/x",
|
||||
"https://evil.example",
|
||||
"x",
|
||||
"",
|
||||
"/a b",
|
||||
"/a\\b",
|
||||
"/a\nb",
|
||||
] {
|
||||
assert!(
|
||||
action_button(t, "Go", Tone::Normal, "t", None).is_none(),
|
||||
"{t:?}"
|
||||
);
|
||||
assert!(!safe_target(t), "{t:?}");
|
||||
}
|
||||
assert!(safe_target("/ok/path?x=1"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bad_ids_and_base_are_dropped() {
|
||||
let s = approvals("/approvals", &[ap("../x"), ap(""), ap("a/b")], "t").into_string();
|
||||
assert!(s.contains("No approvals pending"), "{s}");
|
||||
let s = approvals("//evil", &[ap("ok")], "t").into_string();
|
||||
assert!(
|
||||
s.contains("No approvals pending") && !s.contains("evil"),
|
||||
"{s}"
|
||||
);
|
||||
let s = approvals("/approvals/", &[ap("ok")], "t").into_string();
|
||||
assert!(s.contains("action=\"/approvals/ok/approve\""), "{s}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn text_is_escaped_and_csrf_present() {
|
||||
let s = approvals("/approvals", &[ap("a1")], "t\"k").into_string();
|
||||
assert!(s.contains("<valve>") && !s.contains("<valve>"));
|
||||
assert!(s.contains("name=\"csrf\"") && s.contains("t"k"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_class_is_allowed() {
|
||||
let mut n = 0;
|
||||
for (name, html) in cases() {
|
||||
let mut rest = html.as_str();
|
||||
while let Some(i) = rest.find("class=\"") {
|
||||
rest = &rest[i + 7..];
|
||||
let end = rest.find('"').unwrap();
|
||||
for cl in rest[..end].split_whitespace() {
|
||||
assert!(class_allowed(cl), "{name}: class {cl} not allowed");
|
||||
n += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
assert!(n > 5);
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
mod common;
|
||||
|
||||
use std::process::Command;
|
||||
use wschema::model::{DocKind, Document};
|
||||
|
||||
#[test]
|
||||
fn nav_json_binary_prints_the_document() {
|
||||
let mut doc = Document::new(DocKind::Base, "t");
|
||||
doc.menus = common::menus();
|
||||
let dir = std::env::temp_dir().join(format!("nav-json-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let file = dir.join("schema.json");
|
||||
std::fs::write(&file, doc.to_value().to_string()).unwrap();
|
||||
|
||||
let out = Command::new(env!("CARGO_BIN_EXE_nav-json"))
|
||||
.arg(&file)
|
||||
.output()
|
||||
.unwrap();
|
||||
assert!(
|
||||
out.status.success(),
|
||||
"{}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
let v: serde_json::Value = serde_json::from_slice(&out.stdout).unwrap();
|
||||
assert_eq!(v, flare_ui::nav::nav_json(&common::menus()));
|
||||
|
||||
let bad = Command::new(env!("CARGO_BIN_EXE_nav-json"))
|
||||
.output()
|
||||
.unwrap();
|
||||
assert_eq!(bad.status.code(), Some(2));
|
||||
let missing = Command::new(env!("CARGO_BIN_EXE_nav-json"))
|
||||
.arg(dir.join("none"))
|
||||
.output()
|
||||
.unwrap();
|
||||
assert_eq!(missing.status.code(), Some(2));
|
||||
std::fs::remove_dir_all(dir).ok();
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
//! Runs the Node unit tests for `assets/js/boot.js`. Skipped (with a note)
|
||||
//! when `node` is not installed.
|
||||
|
||||
use std::process::Command;
|
||||
|
||||
#[test]
|
||||
fn boot_js_unit_tests() {
|
||||
let dir = env!("CARGO_MANIFEST_DIR");
|
||||
let out = match Command::new("node")
|
||||
.args(["--test", "tests/js/boot.test.js"])
|
||||
.current_dir(dir)
|
||||
.output()
|
||||
{
|
||||
Ok(o) => o,
|
||||
Err(e) => {
|
||||
eprintln!("skipping boot.js tests: node unavailable ({e})");
|
||||
return;
|
||||
}
|
||||
};
|
||||
assert!(
|
||||
out.status.success(),
|
||||
"node tests failed:\n{}\n{}",
|
||||
String::from_utf8_lossy(&out.stdout),
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,94 @@
|
||||
# Chart benchmarks
|
||||
|
||||
Use the pinned Playwright installation described in README.md. Run these
|
||||
workloads on an isolated test worker with headless Chromium and Firefox.
|
||||
|
||||
```sh
|
||||
node benchmark.cjs --verify
|
||||
node benchmark.cjs --runs=3 --samples=20 --warmup=5
|
||||
node visually-hidden.cjs
|
||||
```
|
||||
|
||||
`--verify` checks the workloads without reporting timing estimates. It
|
||||
uses one browser launch per engine, two warmup batches and three measured
|
||||
batches per case. Profiling defaults to three independent browser launches,
|
||||
five warmup batches and 20 measured batches. `--browser=chromium` or
|
||||
`--browser=firefox` limits either mode to one engine.
|
||||
|
||||
## Workloads
|
||||
|
||||
Each case runs with normal and reduced motion, 60 seeded points per series,
|
||||
the real live/chart scripts, all shared stylesheets and a plain-HTTP SSE
|
||||
server. The stream retains its existing 64-series and 600-point limits.
|
||||
|
||||
| Case | Charts and series | Ring points | Update batch |
|
||||
|---|---|---:|---:|
|
||||
| two-seeded | One chart, two series | 60 | 1 |
|
||||
| two-full-ring | One chart, two series | 600 | 1 |
|
||||
| series-cap | One chart, 64 series | 600 | 1 |
|
||||
| four-charts | Four charts, 16 series each | 600 | 1 |
|
||||
| burst | Four charts, 16 series each | 600 | 16 |
|
||||
| unrelated | One chart, two series; events target another id | 600 | 1 |
|
||||
| extremes | One chart, two series; opposite finite maxima | 600 | 1 |
|
||||
| subnormal | One chart, two series; smallest positive values | 600 | 1 |
|
||||
|
||||
Setup fills real Live rings through ingestSeries before mounting charts.
|
||||
This avoids charging thousands of setup redraws to a steady-state sample.
|
||||
Every timed update arrives through EventSource as a named `series` event
|
||||
and runs the actual chart binding. Charts occupy two equal columns in a
|
||||
1280px viewport, using the normal canvas height from components.css.
|
||||
|
||||
## Measurements
|
||||
|
||||
Output consists of JSON records prefixed with BENCH_PROVENANCE and
|
||||
BENCH_RESULT. Provenance includes the revision, asset hashes and sizes,
|
||||
benchmark hash, Node version, CPU model and browser version. Dirty source
|
||||
is identified by its hashes; a revision alone does not identify it.
|
||||
|
||||
| Field | Measurement |
|
||||
|---|---|
|
||||
| coldMountMs | First bindCharts call on a fresh page after ring setup |
|
||||
| handlerMs | ingestSeries duration, including synchronous chart/readings updates |
|
||||
| deliveryBatchMs | Browser request through the local server to completion of the SSE batch |
|
||||
| parsePropsMs | Parsing all chart props on the page |
|
||||
| chartDataMs | Merging all chart props with their live rings |
|
||||
|
||||
Warmup batches are excluded. Hot-path distributions report count, p50,
|
||||
p95 and maximum milliseconds per independent run. Two animation frames
|
||||
consume the drawn output after each batch; that wait is outside delivery
|
||||
timing. Timings include normal browser allocation and garbage collection.
|
||||
No CPU-frequency or scheduler isolation is claimed. Treat ungated runs
|
||||
as relative diagnostics, not device or CI performance acceptance.
|
||||
|
||||
Every run also checks that SSE updates reached the real ring and latest
|
||||
value table, frame geometry is finite, point counts are bounded, and stream
|
||||
caps remain unchanged. Animation does not rebuild geometry between updates.
|
||||
The existing 24 KiB chart asset cap stays unchanged. There is no new timing
|
||||
budget or automatic baseline update.
|
||||
|
||||
## Hidden table regression
|
||||
|
||||
`visually-hidden.cjs` colors only the caption red and counts painted red
|
||||
pixels in real screenshots. A visible-caption control proves the detector
|
||||
works. The hidden table and row header must remain accessible in both
|
||||
browsers with JavaScript enabled and disabled.
|
||||
|
||||
`--css=/absolute/path/components.css` tests a candidate stylesheet without
|
||||
editing assets. Its exact hash is recorded. Set FLARE_UI_SCREENSHOTS to
|
||||
an output directory to retain screenshots. The PNG reader comes from the
|
||||
pinned Playwright package; no additional dependency is required.
|
||||
|
||||
## Workspace coverage
|
||||
|
||||
The Rust workspace has three benchmark targets:
|
||||
|
||||
```sh
|
||||
cargo bench --locked -p flare-ui --bench chart
|
||||
cargo bench --locked -p wschema --bench canon_hash
|
||||
cargo bench --locked -p warden-sync --bench sync
|
||||
```
|
||||
|
||||
They cover chart props/render, schema parse/canonicalization/hash/lint/
|
||||
tables/corpus, and sync digest/planning/HLC. They do not measure package
|
||||
validation, sealing, OpenAPI generation or editor operations. Keep those
|
||||
coverage gaps explicit when reporting whole-workspace performance.
|
||||
@@ -0,0 +1,21 @@
|
||||
# UI browser checks
|
||||
|
||||
Run from this directory:
|
||||
|
||||
```sh
|
||||
npm ci --ignore-scripts
|
||||
npx playwright install --with-deps chromium firefox
|
||||
npm test
|
||||
```
|
||||
|
||||
The fixtures serve real assets and SSE samples. Their local HTTP proxy gives
|
||||
pages an insecure origin without DNS or hosts-file changes. Both browsers run:
|
||||
|
||||
- Chart geometry, cached animation, reduced motion, cleanup and CSP checks.
|
||||
- Island binding, settings control names and visually hidden caption checks.
|
||||
- Theme, flow parameter form and swapped live-state checks.
|
||||
- Chart benchmark correctness workloads; timing profiles are separate.
|
||||
|
||||
`node chart.cjs --baseline=<commit>` replaces the chart and live assets with
|
||||
that commit's files. The boot asset stays current so the earlier renderer can
|
||||
be tested separately from bootstrap failures.
|
||||
@@ -0,0 +1,250 @@
|
||||
"use strict";
|
||||
const assert = require("node:assert/strict");
|
||||
const crypto = require("node:crypto");
|
||||
const { execFileSync } = require("node:child_process");
|
||||
const fs = require("node:fs");
|
||||
const http = require("node:http");
|
||||
const os = require("node:os");
|
||||
const path = require("node:path");
|
||||
const { chromium, firefox } = require("playwright");
|
||||
|
||||
const verify = process.argv.includes("--verify");
|
||||
function option(name, fallback, min, max) {
|
||||
const arg = process.argv.find(value => value.startsWith("--" + name + "="));
|
||||
const value = arg ? Number(arg.slice(name.length + 3)) : fallback;
|
||||
assert(Number.isInteger(value) && value >= min && value <= max, "invalid " + name);
|
||||
return value;
|
||||
}
|
||||
const samples = option("samples", verify ? 3 : 20, 2, 1000);
|
||||
const warmup = option("warmup", verify ? 2 : 5, 1, 100);
|
||||
const runs = option("runs", verify ? 1 : 3, 1, 10);
|
||||
const browserArg = process.argv.find(arg => arg.startsWith("--browser="))?.slice(10) || "both";
|
||||
assert(["chromium", "firefox", "both"].includes(browserArg), "invalid browser");
|
||||
const types = [chromium, firefox].filter(type => browserArg === "both" || type.name() === browserArg);
|
||||
const assets = path.resolve(__dirname, "../../assets");
|
||||
const root = path.resolve(__dirname, "../../../..");
|
||||
const origin = "http://flare-ui.test";
|
||||
const sha256 = data => crypto.createHash("sha256").update(data).digest("hex");
|
||||
const assetNames = ["js/live.js", "js/chart.js", "components.css", "tokens.css", "theme.css", "warden-compat.css"];
|
||||
const sources = new Map(assetNames.map(name => ["/" + name, fs.readFileSync(path.join(assets, name))]));
|
||||
assert(sources.get("/js/chart.js").length <= 24576, "the existing chart asset cap must hold");
|
||||
const cases = [
|
||||
{ name: "two-seeded", charts: 1, series: 2, history: 60, burst: 1, range: "normal" },
|
||||
{ name: "two-full-ring", charts: 1, series: 2, history: 600, burst: 1, range: "normal" },
|
||||
{ name: "series-cap", charts: 1, series: 64, history: 600, burst: 1, range: "normal" },
|
||||
{ name: "four-charts", charts: 4, series: 16, history: 600, burst: 1, range: "normal" },
|
||||
{ name: "burst", charts: 4, series: 16, history: 600, burst: 16, range: "normal" },
|
||||
{ name: "unrelated", charts: 1, series: 2, history: 600, burst: 1, range: "normal", unrelated: true },
|
||||
{ name: "extremes", charts: 1, series: 2, history: 600, burst: 1, range: "extreme" },
|
||||
{ name: "subnormal", charts: 1, series: 2, history: 600, burst: 1, range: "subnormal" }
|
||||
];
|
||||
|
||||
function value(index, series, range) {
|
||||
if (range === "extreme") return index % 2 ? Number.MAX_VALUE : -Number.MAX_VALUE;
|
||||
if (range === "subnormal") return Number.MIN_VALUE * (index % 2 + 1);
|
||||
return (index * 13 + series * 7) % 97 + Math.sin(index / 8);
|
||||
}
|
||||
function propsFor(config, chart) {
|
||||
const series = Array.from({ length: config.series }, (_, s) => ({ key: "s" + s,
|
||||
label: "Series " + s, unit: "kW", color: ["#3776BE", "#F26522", "#1E8E4E", "#7046B8"][s % 4] }));
|
||||
return { id: "chart" + chart, series, tier: "min",
|
||||
tiers: { min: { n: 60, step_s: 60 }, hour: { n: 60, step_s: 3600 }, day: { n: 60, step_s: 86400 } },
|
||||
points: Object.fromEntries(series.map((s, n) => [s.key, Array.from({ length: 60 }, (_, i) => [1700000000000 + i * 60000, value(i, n, config.range)])])) };
|
||||
}
|
||||
function attribute(text) {
|
||||
return text.replaceAll("&", "&").replaceAll('"', """).replaceAll("<", "<").replaceAll(">", ">");
|
||||
}
|
||||
function figure(config, index) {
|
||||
const props = propsFor(config, index);
|
||||
return '<figure class="bf-chart" data-live data-island="chart" data-chart="' + attribute(JSON.stringify(props)) + '">' +
|
||||
'<figcaption>Chart ' + index + '</figcaption><canvas class="bf-chart-canvas" role="img" aria-label="Chart ' + index + '"></canvas>' +
|
||||
'<table class="bf-vh"><caption>Chart ' + index + ' latest values</caption><tbody>' +
|
||||
props.series.map(s => '<tr><th scope="row">' + s.label + '</th><td data-chart-value="' + s.key + '">-- kW</td></tr>').join("") + '</tbody></table></figure>';
|
||||
}
|
||||
|
||||
// This runs in the browser after the unchanged live and chart assets load.
|
||||
function driver(config, readingValue) {
|
||||
const live = new FlareLive.Live("/events?case=" + config.name);
|
||||
const figures = [...document.querySelectorAll("figure")];
|
||||
const raw = figures.map(figure => figure.getAttribute("data-chart"));
|
||||
const props = raw.map(FlareChart.chartProps);
|
||||
if (props.some(p => !p)) throw new Error("invalid benchmark props");
|
||||
// Fill actual bounded rings before binding, avoiding 38400 unmeasured redraws.
|
||||
for (const p of props) for (let s = 0; s < p.series.length; s++) {
|
||||
for (let i = 0; i < config.history; i++) live.ingestSeries(JSON.stringify({ id: p.id, key: "s" + s,
|
||||
p: [1700000000000 + i * 60000, readingValue(i, s, config.range)] }));
|
||||
}
|
||||
const bench = window.benchmark = { ready: false, durations: [], last: null, waiter: null, live };
|
||||
const ingest = live.ingestSeries.bind(live);
|
||||
live.ingestSeries = data => {
|
||||
const start = performance.now();
|
||||
ingest(data);
|
||||
bench.durations.push(performance.now() - start);
|
||||
bench.last = JSON.parse(data);
|
||||
if (bench.waiter && bench.durations.length >= bench.waiter.target) {
|
||||
const resolve = bench.waiter.resolve;
|
||||
bench.waiter = null;
|
||||
resolve();
|
||||
}
|
||||
};
|
||||
const mount = performance.now();
|
||||
const stop = FlareChart.bindCharts(live, document);
|
||||
bench.mountMs = performance.now() - mount;
|
||||
live.start();
|
||||
live.es.addEventListener("open", () => { bench.ready = true; });
|
||||
bench.sample = async count => {
|
||||
const offset = bench.durations.length;
|
||||
let timer;
|
||||
const done = new Promise((resolve, reject) => {
|
||||
bench.waiter = { target: offset + count, resolve };
|
||||
timer = setTimeout(() => reject(new Error("SSE batch timed out")), 30000);
|
||||
});
|
||||
const start = performance.now();
|
||||
try {
|
||||
const response = fetch("/emit?case=" + config.name + "&count=" + count).then(response => {
|
||||
if (!response.ok) throw new Error("emit failed: " + response.status);
|
||||
});
|
||||
await Promise.all([done, response]);
|
||||
const deliveryMs = performance.now() - start;
|
||||
const frames = figures.map(figure => figure.querySelector("canvas").__cframe);
|
||||
// Two frames consume the painted result; this wait is outside delivery timing.
|
||||
await new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)));
|
||||
if (figures.some((figure, i) => figure.querySelector("canvas").__cframe !== frames[i])) {
|
||||
throw new Error("animation rebuilt geometry between events");
|
||||
}
|
||||
return { deliveryMs, handlerMs: bench.durations.slice(offset) };
|
||||
} finally { clearTimeout(timer); bench.waiter = null; }
|
||||
};
|
||||
bench.inspect = () => {
|
||||
const last = bench.last;
|
||||
const ring = live.chartSamples(last.id, last.key);
|
||||
if (ring.at(-1).t !== last.p[0] || ring.at(-1).v !== last.p[1]) throw new Error("SSE output was not consumed");
|
||||
if (!config.unrelated) {
|
||||
const index = Number(last.id.slice(5));
|
||||
const cell = figures[index].querySelector('[data-chart-value="' + last.key + '"]');
|
||||
if (cell.textContent !== FlareChart.formatValue(last.p[1]) + " kW") throw new Error("latest table value drifted");
|
||||
}
|
||||
const frames = figures.map(figure => figure.querySelector("canvas").__cframe);
|
||||
for (const frame of frames) {
|
||||
if (!frame || !Number.isFinite(frame.yMax - frame.yMin) || frame.yMax <= frame.yMin) throw new Error("invalid frame range");
|
||||
if (frame.series.length !== config.series) throw new Error("series lost");
|
||||
const limit = 71 * Math.max(12, Math.ceil(frame.dx / 2)) + 1;
|
||||
for (const s of frame.series) {
|
||||
if (s.pts.length > limit || s.pts.some(p => !Number.isFinite(p.x) || !Number.isFinite(p.y))) throw new Error("unbounded or nonfinite geometry");
|
||||
}
|
||||
}
|
||||
if (live.seriesCount > 64 || ring.length > 600 || live.dropped) throw new Error("stream capacity changed");
|
||||
return { events: bench.durations.length, series: live.seriesCount, lastRing: ring.length,
|
||||
frames: frames.length, points: frames.reduce((total, f) => total + f.series.reduce((n, s) => n + s.pts.length, 0), 0) };
|
||||
};
|
||||
bench.micro = count => {
|
||||
const parse = [], merge = [];
|
||||
let checksum = 0;
|
||||
for (let i = 0; i < count; i++) {
|
||||
let start = performance.now();
|
||||
for (const text of raw) checksum += FlareChart.chartProps(text).series.length;
|
||||
parse.push(performance.now() - start);
|
||||
start = performance.now();
|
||||
for (const p of props) checksum += FlareChart.chartData(p, live).series.reduce((n, s) => n + s.data.length, 0);
|
||||
merge.push(performance.now() - start);
|
||||
}
|
||||
return { parse, merge, checksum };
|
||||
};
|
||||
bench.stop = () => { stop(); live.close(); };
|
||||
}
|
||||
|
||||
const clients = new Map();
|
||||
const server = http.createServer((request, response) => {
|
||||
const url = new URL(request.url, origin);
|
||||
const config = cases.find(item => item.name === url.searchParams.get("case"));
|
||||
if (url.origin !== origin) { response.writeHead(404); response.end(); return; }
|
||||
if (sources.has(url.pathname)) {
|
||||
response.writeHead(200, { "content-type": url.pathname.endsWith(".css") ? "text/css" : "text/javascript" });
|
||||
response.end(sources.get(url.pathname));
|
||||
} else if (url.pathname === "/bench.css") {
|
||||
response.writeHead(200, { "content-type": "text/css" });
|
||||
response.end("main {display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:8px} .bf-chart {min-width:0}");
|
||||
} else if (url.pathname === "/driver.js" && config) {
|
||||
response.writeHead(200, { "content-type": "text/javascript" });
|
||||
response.end("(" + driver.toString() + ")(" + JSON.stringify(config) + "," + value.toString() + ");");
|
||||
} else if (url.pathname === "/events" && config) {
|
||||
response.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-store" });
|
||||
response.write(": ready\n\n");
|
||||
const client = { response, sequence: config.history };
|
||||
clients.set(config.name, client);
|
||||
response.on("close", () => { if (clients.get(config.name) === client) clients.delete(config.name); });
|
||||
} else if (url.pathname === "/emit" && config && clients.has(config.name)) {
|
||||
const count = Number(url.searchParams.get("count"));
|
||||
if (!Number.isInteger(count) || count < 1 || count > 64) { response.writeHead(400); response.end(); return; }
|
||||
const client = clients.get(config.name);
|
||||
let packet = "";
|
||||
for (let i = 0; i < count; i++) {
|
||||
const seq = client.sequence++, series = seq % (config.charts * config.series);
|
||||
const point = { id: config.unrelated ? "unmounted" : "chart" + Math.floor(series / config.series),
|
||||
key: config.unrelated ? "outside" : "s" + series % config.series,
|
||||
p: [1700000000000 + seq * 60000, value(seq, series % config.series, config.range)] };
|
||||
packet += "event: series\ndata: " + JSON.stringify(point) + "\n\n";
|
||||
}
|
||||
client.response.write(packet);
|
||||
response.writeHead(200); response.end("ok");
|
||||
} else if (url.pathname === "/" && config) {
|
||||
response.writeHead(200, { "content-type": "text/html",
|
||||
"content-security-policy": "default-src 'none'; script-src 'self'; style-src 'self'; connect-src 'self'; base-uri 'none'; object-src 'none'" });
|
||||
response.end('<!doctype html><html lang="en"><head><meta name="viewport" content="width=device-width, initial-scale=1">' +
|
||||
assetNames.filter(name => name.endsWith(".css")).map(name => '<link rel="stylesheet" href="/' + name + '">').join("") +
|
||||
'<link rel="stylesheet" href="/bench.css"><script src="/js/live.js" defer></script><script src="/js/chart.js" defer></script>' +
|
||||
'<script src="/driver.js?case=' + config.name + '" defer></script></head><body><main>' +
|
||||
Array.from({ length: config.charts }, (_, i) => figure(config, i)).join("") + '</main></body></html>');
|
||||
} else if (url.pathname === "/favicon.ico") { response.writeHead(204); response.end(); }
|
||||
else { response.writeHead(404); response.end(); }
|
||||
});
|
||||
server.on("connect", (_, socket) => socket.end("HTTP/1.1 403 Forbidden\r\n\r\n"));
|
||||
|
||||
function distribution(values) {
|
||||
assert(values.length && values.every(Number.isFinite), "measurements must be finite");
|
||||
const sorted = [...values].sort((a, b) => a - b);
|
||||
const at = p => Number(sorted[Math.ceil(p * sorted.length) - 1].toFixed(3));
|
||||
return { n: sorted.length, p50: at(.5), p95: at(.95), max: at(1) };
|
||||
}
|
||||
|
||||
(async () => {
|
||||
console.log("BENCH_PROVENANCE", JSON.stringify({ mode: verify ? "verification" : "ungated-profile", samples, warmup, runs,
|
||||
revision: execFileSync("git", ["rev-parse", "HEAD"], { cwd: root, encoding: "utf8" }).trim(),
|
||||
node: process.version, platform: os.platform(), arch: os.arch(), cpu: os.cpus()[0]?.model,
|
||||
source: Object.fromEntries([...sources].map(([name, body]) => [name, { bytes: body.length, sha256: sha256(body) }])),
|
||||
benchmarkSha256: sha256(fs.readFileSync(__filename)) }));
|
||||
await new Promise(resolve => server.listen(0, "127.0.0.1", resolve));
|
||||
try {
|
||||
for (const type of types) for (let run = 0; run < runs; run++) {
|
||||
const browser = await type.launch({ headless: true,
|
||||
proxy: { server: "http://127.0.0.1:" + server.address().port } });
|
||||
try {
|
||||
for (const config of cases) for (const reduced of [false, true]) {
|
||||
const page = await browser.newPage({ viewport: { width: 1280, height: 900 }, reducedMotion: reduced ? "reduce" : "no-preference" });
|
||||
const errors = [];
|
||||
page.on("pageerror", error => errors.push(error.message));
|
||||
try {
|
||||
await page.goto(origin + "/?case=" + config.name);
|
||||
await page.waitForFunction(() => window.benchmark?.ready, null, { timeout: 30000 });
|
||||
const coldMountMs = await page.evaluate(() => benchmark.mountMs);
|
||||
for (let i = 0; i < warmup; i++) await page.evaluate(count => benchmark.sample(count), config.burst);
|
||||
const measurements = [];
|
||||
for (let i = 0; i < samples; i++) measurements.push(await page.evaluate(count => benchmark.sample(count), config.burst));
|
||||
const state = await page.evaluate(() => benchmark.inspect());
|
||||
const micro = await page.evaluate(count => benchmark.micro(count), samples + warmup);
|
||||
assert.equal(state.events, (samples + warmup) * config.burst);
|
||||
assert(micro.checksum > 0);
|
||||
assert.deepEqual(errors, []);
|
||||
const result = { browser: type.name(), version: browser.version(), run, case: config.name, reduced, state };
|
||||
if (!verify) Object.assign(result, { coldMountMs, handlerMs: distribution(measurements.flatMap(m => m.handlerMs)),
|
||||
deliveryBatchMs: distribution(measurements.map(m => m.deliveryMs)),
|
||||
parsePropsMs: distribution(micro.parse.slice(warmup)), chartDataMs: distribution(micro.merge.slice(warmup)) });
|
||||
console.log("BENCH_RESULT", JSON.stringify(result));
|
||||
await page.evaluate(() => benchmark.stop());
|
||||
} finally { await page.close(); }
|
||||
}
|
||||
} finally { await browser.close(); }
|
||||
}
|
||||
} finally { server.closeAllConnections(); await new Promise(resolve => server.close(resolve)); }
|
||||
console.log("PASS chart benchmark workloads");
|
||||
})().catch(error => { console.error(error); process.exitCode = 1; });
|
||||
@@ -0,0 +1,297 @@
|
||||
"use strict";
|
||||
const assert = require("node:assert/strict");
|
||||
const { execFileSync } = require("node:child_process");
|
||||
const fs = require("node:fs");
|
||||
const http = require("node:http");
|
||||
const path = require("node:path");
|
||||
const { chromium, firefox } = require("playwright");
|
||||
|
||||
const origin = "http://flare-ui.test";
|
||||
const assets = path.resolve(__dirname, "../../assets/js");
|
||||
const baseline = process.argv.find(arg => arg.startsWith("--baseline="))?.split("=")[1];
|
||||
if (baseline && !/^[0-9a-f]{40}$/.test(baseline)) throw new Error("baseline must be a full commit id");
|
||||
const sources = new Map(["live.js", "islands.js", "chart.js", "boot.js"].map(name => {
|
||||
const source = baseline && (name === "chart.js" || name === "live.js")
|
||||
? execFileSync("git", ["show", baseline + ":crates/flare-ui/assets/js/" + name])
|
||||
: fs.readFileSync(path.join(assets, name));
|
||||
return ["/" + name, source];
|
||||
}));
|
||||
const css = fs.readFileSync(path.resolve(assets, "../components.css"));
|
||||
const timeout = Math.min(30000, Math.max(1000, Number(process.env.FLARE_UI_BROWSER_TIMEOUT_MS) || 10000));
|
||||
const seriesClients = new Set();
|
||||
|
||||
// The fixture is also the browser's HTTP proxy. The test origin stays outside
|
||||
// localhost's secure-context exception without a DNS or hosts-file change.
|
||||
const server = http.createServer((request, response) => {
|
||||
const url = new URL(request.url, origin);
|
||||
if (url.origin !== origin) { response.writeHead(404); response.end(); return; }
|
||||
if (url.pathname === "/series") {
|
||||
response.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-store" });
|
||||
response.write(": ready\n\n");
|
||||
seriesClients.add(response);
|
||||
response.on("close", () => seriesClients.delete(response));
|
||||
} else if (url.pathname === "/emit") {
|
||||
const payload = url.searchParams.has("invalid") ? '{"id":"traffic","key":"rx","p":[1e400,999]}' :
|
||||
JSON.stringify({ id: url.searchParams.get("id") || "traffic", key: url.searchParams.get("key") || "rx", p: [3000, 4] });
|
||||
const boundaries = { flat: [1e20, 1e20], maximum: [Number.MAX_VALUE, Number.MAX_VALUE],
|
||||
opposite: [-Number.MAX_VALUE, Number.MAX_VALUE], subnormal: [Number.MIN_VALUE, Number.MIN_VALUE * 2] };
|
||||
const boundary = url.searchParams.get("boundary");
|
||||
const values = Object.hasOwn(boundaries, boundary) ? boundaries[boundary] : null;
|
||||
const packets = values ? values.map((v, i) => JSON.stringify({ id: "traffic", key: "rx", p: [(i + 1) * 1000, v] })) : [payload];
|
||||
for (const client of seriesClients) for (const packet of packets) client.write("event: series\ndata: " + packet + "\n\n");
|
||||
response.writeHead(200); response.end("ok");
|
||||
} else if (url.pathname === "/network/traffic") {
|
||||
const tier = ["min", "hour", "day"].includes(url.searchParams.get("tier")) ? url.searchParams.get("tier") : "hour";
|
||||
let figure = fs.readFileSync(path.join(__dirname, "../golden/chart-" + tier + ".html"), "utf8");
|
||||
const count = Number(url.searchParams.get("seed"));
|
||||
if ([1, 2, 3].includes(count)) {
|
||||
const attribute = /data-chart="([^"]*)"/.exec(figure)[1];
|
||||
const props = JSON.parse(attribute.replaceAll(""", '"').replaceAll("&", "&"));
|
||||
props.points = { rx: Array.from({ length: count }, (_, i) => [(i + 1) * 1000, i + 1]) };
|
||||
figure = figure.replace(attribute, JSON.stringify(props).replaceAll("&", "&").replaceAll('"', """))
|
||||
.replace('data-chart-value="rx">2 B/s', 'data-chart-value="rx">' + count + ' B/s');
|
||||
}
|
||||
const control = Number(url.searchParams.get("bad"));
|
||||
const stream = [9, 10, 13].includes(control) ? "/&#" + control + ";/outside.example/stream" : "/series";
|
||||
response.writeHead(200, { "content-type": "text/html",
|
||||
"content-security-policy": "default-src 'none'; script-src 'self'; connect-src 'self'; style-src 'self'; img-src 'self'; base-uri 'none'; object-src 'none'" });
|
||||
response.end('<!doctype html><html><head><meta name="bf-stream" content="' + stream + '">' +
|
||||
'<link rel="stylesheet" href="/components.css">' + [...sources.keys()].map(name => '<script src="' + name + '" defer></script>').join("") +
|
||||
'</head><body>' + figure + figure.replaceAll("traffic", "other") + '</body></html>');
|
||||
} else if (url.pathname === "/events") {
|
||||
const points = Array.from({ length: 60 }, (_, i) => ({ k: "pressure", t: i * 1000, v: 25 + 10 * Math.sin(i / 5) }));
|
||||
points[59].v = 42.5;
|
||||
let data = JSON.stringify(points);
|
||||
if (url.searchParams.has("invalid")) data = data.slice(0, -1) + ',{"k":"pressure","v":999,"t":1e400}]';
|
||||
response.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-store" });
|
||||
response.write("data: " + data + "\n\n");
|
||||
} else if (url.pathname === "/") {
|
||||
const defer = url.searchParams.get("mode") === "defer" ? " defer" : "";
|
||||
const stream = url.searchParams.has("invalid") ? "/events?invalid=1" : "/events";
|
||||
response.writeHead(200, {
|
||||
"content-type": "text/html",
|
||||
"content-security-policy": "default-src 'none'; script-src 'self'; connect-src 'self'; style-src 'self'; img-src 'self'; base-uri 'none'; object-src 'none'"
|
||||
});
|
||||
response.end('<!doctype html><html><head><meta name="bf-stream" content="' + stream + '">' +
|
||||
[...sources.keys()].map(name => '<script src="' + name + '"' + defer + '></script>').join("") +
|
||||
'</head><body><div data-live data-key="pressure"><span class="bf-kv-value">1 psi</span></div>' +
|
||||
'<figure data-live data-island="chart" data-key="pressure"><canvas width="240" height="120" aria-label="Pressure"></canvas></figure></body></html>');
|
||||
} else if (url.pathname === "/components.css") {
|
||||
response.writeHead(200, { "content-type": "text/css" }); response.end(css);
|
||||
} else if (sources.has(url.pathname)) {
|
||||
response.writeHead(200, { "content-type": "text/javascript" }); response.end(sources.get(url.pathname));
|
||||
} else if (url.pathname === "/favicon.ico") {
|
||||
response.writeHead(204); response.end();
|
||||
} else { response.writeHead(404); response.end(); }
|
||||
});
|
||||
server.on("connect", (_, socket) => socket.end("HTTP/1.1 403 Forbidden\r\n\r\n"));
|
||||
|
||||
async function check(browser, mode, reduced, tier, invalid) {
|
||||
const page = await browser.newPage({ reducedMotion: reduced ? "reduce" : "no-preference" });
|
||||
const errors = [];
|
||||
page.on("pageerror", error => errors.push(error.message));
|
||||
await page.addInitScript(() => {
|
||||
const trace = window.chartTrace = { blits: 0, lines: 0, requests: 0, csp: [] };
|
||||
const prototype = CanvasRenderingContext2D.prototype;
|
||||
for (const [method, key] of [["drawImage", "blits"], ["lineTo", "lines"]]) {
|
||||
const original = prototype[method];
|
||||
prototype[method] = function (...args) { trace[key]++; return original.apply(this, args); };
|
||||
}
|
||||
const request = window.requestAnimationFrame.bind(window);
|
||||
window.requestAnimationFrame = callback => { trace.requests++; return request(callback); };
|
||||
document.addEventListener("securitypolicyviolation", event => trace.csp.push(event.violatedDirective));
|
||||
});
|
||||
try {
|
||||
await page.goto(origin + "/?mode=" + mode + "&tier=" + tier + (invalid ? "&invalid=1" : ""));
|
||||
await page.waitForFunction(() => document.querySelector(".bf-kv-value").textContent === "42.5 psi", null, { timeout });
|
||||
await page.waitForFunction(() => !!document.querySelector("canvas").__cframe, null, { timeout });
|
||||
assert.equal(await page.evaluate(() => isSecureContext), false);
|
||||
const frame = await page.evaluate(() => {
|
||||
const canvas = document.querySelector("canvas"), frame = canvas.__cframe;
|
||||
return { points: frame.series[0].pts.length, vel: frame.vel, top: frame.yMax,
|
||||
pixels: canvas.getContext("2d").getImageData(0, 0, canvas.width, canvas.height).data.some(value => value !== 0),
|
||||
trace: { ...chartTrace } };
|
||||
});
|
||||
assert(frame.points > 60, "the live binding must use spline geometry");
|
||||
assert(frame.top < 100, "invalid timestamps must not enter the chart");
|
||||
assert(frame.pixels, "the chart must paint real pixels");
|
||||
if (!reduced && tier === "min") {
|
||||
await page.waitForFunction(count => chartTrace.blits > count, frame.trace.blits, { timeout });
|
||||
} else await page.waitForTimeout(120);
|
||||
const later = await page.evaluate(() => ({ ...chartTrace }));
|
||||
assert.equal(later.lines, frame.trace.lines, "animation must not rebuild geometry");
|
||||
if (reduced || tier !== "min") {
|
||||
assert.equal(frame.vel, 0);
|
||||
assert.equal(later.requests, 0, "static charts must not start an animation loop");
|
||||
} else {
|
||||
assert(frame.vel > 0);
|
||||
assert(later.blits > frame.trace.blits);
|
||||
await page.emulateMedia({ reducedMotion: "reduce" });
|
||||
await page.waitForFunction(() => document.querySelector("canvas").__cframe.vel === 0, null, { timeout });
|
||||
}
|
||||
await page.evaluate(() => {
|
||||
const figure = document.querySelector("figure");
|
||||
document.dispatchEvent(new CustomEvent("htmx:beforeCleanupElement", { detail: { elt: figure } }));
|
||||
figure.remove();
|
||||
});
|
||||
const afterCleanup = await page.evaluate(() => chartTrace.requests);
|
||||
await page.waitForTimeout(80);
|
||||
assert.equal(await page.evaluate(() => chartTrace.requests), afterCleanup);
|
||||
assert.deepEqual(await page.evaluate(() => chartTrace.csp), []);
|
||||
assert.deepEqual(errors, []);
|
||||
} catch (error) {
|
||||
error.message += " " + JSON.stringify({ mode, reduced, tier, invalid, errors,
|
||||
state: await page.evaluate(() => ({ reading: document.querySelector(".bf-kv-value")?.textContent,
|
||||
frame: !!document.querySelector("canvas")?.__cframe, csp: window.chartTrace?.csp })).catch(() => null) });
|
||||
throw error;
|
||||
} finally { await page.close(); }
|
||||
}
|
||||
|
||||
async function contract(browser) {
|
||||
const nojs = await browser.newPage({ javaScriptEnabled: false });
|
||||
try {
|
||||
await nojs.goto(origin + "/network/traffic?tier=hour");
|
||||
assert.equal(await nojs.locator('#traffic [data-chart-value="rx"]').textContent(), "2 B/s");
|
||||
assert.equal(await nojs.locator('#traffic [data-chart-value="constructor"]').textContent(), "-- B/s");
|
||||
assert.equal(await nojs.locator('#traffic a[aria-current="page"]').getAttribute("href"), "/network/traffic?tier=hour");
|
||||
await nojs.locator('#traffic a[href$="tier=day"]').click();
|
||||
assert.equal(new URL(nojs.url()).searchParams.get("tier"), "day");
|
||||
assert.equal(await nojs.locator('#traffic a[aria-current="page"]').textContent(), "day");
|
||||
} finally { await nojs.close(); }
|
||||
for (const reduced of [false, true]) {
|
||||
const page = await browser.newPage({ reducedMotion: reduced ? "reduce" : "no-preference" });
|
||||
const errors = [], csp = [];
|
||||
page.on("pageerror", error => errors.push(error.message));
|
||||
await page.addInitScript(() => {
|
||||
window.violations = [];
|
||||
document.addEventListener("securitypolicyviolation", event => violations.push(event.violatedDirective));
|
||||
});
|
||||
try {
|
||||
const ready = page.waitForResponse(response => response.url() === origin + "/series");
|
||||
await page.goto(origin + "/network/traffic?tier=min");
|
||||
await ready;
|
||||
await page.waitForFunction(() => !!document.querySelector("#traffic canvas").__cframe, null, { timeout });
|
||||
const initial = await page.locator("#traffic canvas").evaluate(cv => ({
|
||||
count: cv.__cframe.series.length, pts: cv.__cframe.series[0].pts.length,
|
||||
colors: cv.__cframe.series.map(s => s.color), vel: cv.__cframe.vel
|
||||
}));
|
||||
assert.equal(initial.count, 2); assert(initial.pts > 2);
|
||||
assert.deepEqual(initial.colors, ["#3776BE", "#F26522"]);
|
||||
assert.equal(initial.vel, 0, "short seeded histories are visible before the feed");
|
||||
await page.evaluate(() => fetch("/emit"));
|
||||
await page.waitForFunction(() => document.querySelector('#traffic [data-chart-value="rx"]').textContent === "4 B/s", null, { timeout });
|
||||
assert.equal(await page.locator('#other [data-chart-value="rx"]').textContent(), "2 B/s");
|
||||
await page.evaluate(() => fetch("/emit?id=traffic&key=constructor"));
|
||||
await page.waitForFunction(() => document.querySelector('#traffic [data-chart-value="constructor"]').textContent === "4 B/s", null, { timeout });
|
||||
await page.evaluate(() => fetch("/emit?invalid=1"));
|
||||
await page.waitForTimeout(60);
|
||||
assert.equal(await page.locator('#traffic [data-chart-value="rx"]').textContent(), "4 B/s");
|
||||
await page.emulateMedia({ reducedMotion: "reduce" });
|
||||
await page.waitForFunction(() => document.querySelector("#traffic canvas").__cframe.vel === 0, null, { timeout });
|
||||
csp.push(...await page.evaluate(() => violations));
|
||||
assert.deepEqual(csp, []); assert.deepEqual(errors, []);
|
||||
} finally { await page.close(); }
|
||||
}
|
||||
}
|
||||
|
||||
async function boundaries(browser) {
|
||||
for (const name of ["flat", "maximum", "opposite", "subnormal"]) {
|
||||
const page = await browser.newPage({ reducedMotion: "reduce" }), errors = [];
|
||||
page.on("pageerror", error => errors.push(error.message));
|
||||
try {
|
||||
const ready = page.waitForResponse(response => response.url() === origin + "/series");
|
||||
await page.goto(origin + "/network/traffic?tier=min"); await ready;
|
||||
await page.evaluate(name => fetch("/emit?boundary=" + name), name);
|
||||
const expected = name === "flat" ? "100000000000000000000 B/s" :
|
||||
name === "subnormal" ? "0 B/s" : "1.7976931348623157e+308 B/s";
|
||||
await page.waitForFunction(expected => document.querySelector('#traffic [data-chart-value="rx"]').textContent === expected, expected, { timeout });
|
||||
const frame = await page.locator("#traffic canvas").evaluate(cv => {
|
||||
const f = cv.__cframe;
|
||||
return { span: f.yMax - f.yMin,
|
||||
finite: f.series.every(s => s.pts.every(p => Number.isFinite(p.x) && Number.isFinite(p.y)) &&
|
||||
(!s.endpoint || (Number.isFinite(s.endpoint.x) && Number.isFinite(s.endpoint.y)))),
|
||||
pixels: cv.getContext("2d").getImageData(0, 0, cv.width, cv.height).data.some(v => v !== 0) };
|
||||
});
|
||||
assert(Number.isFinite(frame.span) && frame.span > 0); assert(frame.finite); assert(frame.pixels);
|
||||
for (const color of [{ toString: 0 }, ["#abc"]]) {
|
||||
assert.equal(await page.evaluate(color => {
|
||||
const figure = document.querySelector("#traffic"), p = JSON.parse(figure.getAttribute("data-chart"));
|
||||
p.series[0].color = color; figure.setAttribute("data-chart", JSON.stringify(p));
|
||||
document.dispatchEvent(new CustomEvent("htmx:afterSwap"));
|
||||
return FlareChart.chartProps(figure.getAttribute("data-chart"));
|
||||
}, color), null);
|
||||
}
|
||||
await page.evaluate(() => fetch("/emit?id=other"));
|
||||
await page.waitForFunction(() => document.querySelector('#other [data-chart-value="rx"]').textContent === "4 B/s", null, { timeout });
|
||||
assert.deepEqual(errors, []);
|
||||
console.log("PASS chart numeric boundary", browser.browserType().name(), name);
|
||||
} finally { await page.close(); }
|
||||
}
|
||||
}
|
||||
|
||||
async function firstPaint(browser) {
|
||||
for (const count of [1, 2, 3]) {
|
||||
const page = await browser.newPage({ reducedMotion: "no-preference" });
|
||||
try {
|
||||
await page.goto(origin + "/network/traffic?tier=min&seed=" + count);
|
||||
await page.waitForFunction(() => !!document.querySelector("#traffic canvas").__cframe, null, { timeout });
|
||||
const observed = await page.locator("#traffic canvas").evaluate(cv => {
|
||||
const pixels = cv.getContext("2d").getImageData(0, 0, cv.width, cv.height).data;
|
||||
let blue = 0;
|
||||
for (let i = 0; i < pixels.length; i += 4) {
|
||||
if (pixels[i] < 100 && pixels[i + 1] > 70 && pixels[i + 1] < 180 && pixels[i + 2] > 150 && pixels[i + 3]) blue++;
|
||||
}
|
||||
return { blue, velocity: cv.__cframe.vel };
|
||||
});
|
||||
assert(observed.blue > 0, "seeded series must paint its own pixels");
|
||||
assert.equal(observed.velocity, 0);
|
||||
assert(await page.locator("#traffic").evaluate(el => el.classList.contains("bf-stale")));
|
||||
await page.evaluate(() => fetch("/emit"));
|
||||
await page.waitForFunction(() => !document.querySelector("#traffic").classList.contains("bf-stale"), null, { timeout });
|
||||
console.log("PASS seeded first paint", browser.browserType().name(), count, observed.blue);
|
||||
} finally { await page.close(); }
|
||||
}
|
||||
for (const code of [9, 10, 13]) {
|
||||
const page = await browser.newPage();
|
||||
try {
|
||||
await page.addInitScript(() => {
|
||||
const Original = window.EventSource;
|
||||
window.streamAttempts = [];
|
||||
window.EventSource = class extends Original {
|
||||
constructor(url, options) { window.streamAttempts.push(String(url)); super(url, options); }
|
||||
};
|
||||
});
|
||||
await page.goto(origin + "/network/traffic?bad=" + code);
|
||||
assert.deepEqual(await page.evaluate(() => window.streamAttempts), []);
|
||||
console.log("PASS stream origin refusal", browser.browserType().name(), code);
|
||||
} finally { await page.close(); }
|
||||
}
|
||||
}
|
||||
|
||||
(async () => {
|
||||
await new Promise(resolve => server.listen(0, "127.0.0.1", resolve));
|
||||
try {
|
||||
for (const type of [chromium, firefox]) {
|
||||
const browser = await type.launch({ headless: true,
|
||||
proxy: { server: "http://127.0.0.1:" + server.address().port } });
|
||||
try {
|
||||
for (const [mode, reduced, tier, invalid] of [
|
||||
["loading", false, "min", false], ["defer", false, "min", true],
|
||||
["defer", true, "min", false], ["defer", false, "hour", false]
|
||||
]) {
|
||||
await check(browser, mode, reduced, tier, invalid);
|
||||
console.log("PASS chart browser", type.name(), mode, reduced ? "reduced" : tier, invalid ? "invalid timestamp" : "valid data");
|
||||
}
|
||||
if (!baseline) {
|
||||
await contract(browser);
|
||||
console.log("PASS chart contract", type.name(), "SSR/no-JS/tier navigation/seeded/multi-series/named SSE/id isolation/reduced motion");
|
||||
await boundaries(browser);
|
||||
await firstPaint(browser);
|
||||
}
|
||||
} finally { await browser.close(); }
|
||||
}
|
||||
} finally {
|
||||
server.closeAllConnections();
|
||||
await new Promise(resolve => server.close(resolve));
|
||||
}
|
||||
})().catch(error => { console.error(error); process.exitCode = 1; });
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user